1 /* 2 * ALSA Driver for Ego Systems Inc. (ESI) Miditerminal 4140 3 * Copyright (c) 2006 by Matthias König <mk@phasorlab.de> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 18 * 19 */ 20 21 #include <sound/driver.h> 22 #include <linux/init.h> 23 #include <linux/platform_device.h> 24 #include <linux/parport.h> 25 #include <linux/spinlock.h> 26 #include <linux/delay.h> 27 #include <sound/core.h> 28 #include <sound/initval.h> 29 #include <sound/rawmidi.h> 30 #include <sound/control.h> 31 32 #define CARD_NAME "Miditerminal 4140" 33 #define DRIVER_NAME "MTS64" 34 #define PLATFORM_DRIVER "snd_mts64" 35 36 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; 37 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; 38 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; 39 40 static struct platform_device *platform_devices[SNDRV_CARDS]; 41 static int device_count; 42 43 module_param_array(index, int, NULL, S_IRUGO); 44 MODULE_PARM_DESC(index, "Index value for " CARD_NAME " soundcard."); 45 module_param_array(id, charp, NULL, S_IRUGO); 46 MODULE_PARM_DESC(id, "ID string for " CARD_NAME " soundcard."); 47 module_param_array(enable, bool, NULL, S_IRUGO); 48 MODULE_PARM_DESC(enable, "Enable " CARD_NAME " soundcard."); 49 50 MODULE_AUTHOR("Matthias Koenig <mk@phasorlab.de>"); 51 MODULE_DESCRIPTION("ESI Miditerminal 4140"); 52 MODULE_LICENSE("GPL"); 53 MODULE_SUPPORTED_DEVICE("{{ESI,Miditerminal 4140}}"); 54 55 /********************************************************************* 56 * Chip specific 57 *********************************************************************/ 58 #define MTS64_NUM_INPUT_PORTS 5 59 #define MTS64_NUM_OUTPUT_PORTS 4 60 #define MTS64_SMPTE_SUBSTREAM 4 61 62 struct mts64 { 63 spinlock_t lock; 64 struct snd_card *card; 65 struct snd_rawmidi *rmidi; 66 struct pardevice *pardev; 67 int pardev_claimed; 68 69 int open_count; 70 int current_midi_output_port; 71 int current_midi_input_port; 72 u8 mode[MTS64_NUM_INPUT_PORTS]; 73 struct snd_rawmidi_substream *midi_input_substream[MTS64_NUM_INPUT_PORTS]; 74 int smpte_switch; 75 u8 time[4]; /* [0]=hh, [1]=mm, [2]=ss, [3]=ff */ 76 u8 fps; 77 }; 78 79 static int snd_mts64_free(struct mts64 *mts) 80 { 81 kfree(mts); 82 return 0; 83 } 84 85 static int __devinit snd_mts64_create(struct snd_card *card, 86 struct pardevice *pardev, 87 struct mts64 **rchip) 88 { 89 struct mts64 *mts; 90 91 *rchip = NULL; 92 93 mts = kzalloc(sizeof(struct mts64), GFP_KERNEL); 94 if (mts == NULL) 95 return -ENOMEM; 96 97 /* Init chip specific data */ 98 spin_lock_init(&mts->lock); 99 mts->card = card; 100 mts->pardev = pardev; 101 mts->current_midi_output_port = -1; 102 mts->current_midi_input_port = -1; 103 104 *rchip = mts; 105 106 return 0; 107 } 108 109 /********************************************************************* 110 * HW register related constants 111 *********************************************************************/ 112 113 /* Status Bits */ 114 #define MTS64_STAT_BSY 0x80 115 #define MTS64_STAT_BIT_SET 0x20 /* readout process, bit is set */ 116 #define MTS64_STAT_PORT 0x10 /* read byte is a port number */ 117 118 /* Control Bits */ 119 #define MTS64_CTL_READOUT 0x08 /* enable readout */ 120 #define MTS64_CTL_WRITE_CMD 0x06 121 #define MTS64_CTL_WRITE_DATA 0x02 122 #define MTS64_CTL_STROBE 0x01 123 124 /* Command */ 125 #define MTS64_CMD_RESET 0xfe 126 #define MTS64_CMD_PROBE 0x8f /* Used in probing procedure */ 127 #define MTS64_CMD_SMPTE_SET_TIME 0xe8 128 #define MTS64_CMD_SMPTE_SET_FPS 0xee 129 #define MTS64_CMD_SMPTE_STOP 0xef 130 #define MTS64_CMD_SMPTE_FPS_24 0xe3 131 #define MTS64_CMD_SMPTE_FPS_25 0xe2 132 #define MTS64_CMD_SMPTE_FPS_2997 0xe4 133 #define MTS64_CMD_SMPTE_FPS_30D 0xe1 134 #define MTS64_CMD_SMPTE_FPS_30 0xe0 135 #define MTS64_CMD_COM_OPEN 0xf8 /* setting the communication mode */ 136 #define MTS64_CMD_COM_CLOSE1 0xff /* clearing communication mode */ 137 #define MTS64_CMD_COM_CLOSE2 0xf5 138 139 /********************************************************************* 140 * Hardware specific functions 141 *********************************************************************/ 142 static void mts64_enable_readout(struct parport *p); 143 static void mts64_disable_readout(struct parport *p); 144 static int mts64_device_ready(struct parport *p); 145 static int mts64_device_init(struct parport *p); 146 static int mts64_device_open(struct mts64 *mts); 147 static int mts64_device_close(struct mts64 *mts); 148 static u8 mts64_map_midi_input(u8 c); 149 static int mts64_probe(struct parport *p); 150 static u16 mts64_read(struct parport *p); 151 static u8 mts64_read_char(struct parport *p); 152 static void mts64_smpte_start(struct parport *p, 153 u8 hours, u8 minutes, 154 u8 seconds, u8 frames, 155 u8 idx); 156 static void mts64_smpte_stop(struct parport *p); 157 static void mts64_write_command(struct parport *p, u8 c); 158 static void mts64_write_data(struct parport *p, u8 c); 159 static void mts64_write_midi(struct mts64 *mts, u8 c, int midiport); 160 161 162 /* Enables the readout procedure 163 * 164 * Before we can read a midi byte from the device, we have to set 165 * bit 3 of control port. 166 */ 167 static void mts64_enable_readout(struct parport *p) 168 { 169 u8 c; 170 171 c = parport_read_control(p); 172 c |= MTS64_CTL_READOUT; 173 parport_write_control(p, c); 174 } 175 176 /* Disables readout 177 * 178 * Readout is disabled by clearing bit 3 of control 179 */ 180 static void mts64_disable_readout(struct parport *p) 181 { 182 u8 c; 183 184 c = parport_read_control(p); 185 c &= ~MTS64_CTL_READOUT; 186 parport_write_control(p, c); 187 } 188 189 /* waits for device ready 190 * 191 * Checks if BUSY (Bit 7 of status) is clear 192 * 1 device ready 193 * 0 failure 194 */ 195 static int mts64_device_ready(struct parport *p) 196 { 197 int i; 198 u8 c; 199 200 for (i = 0; i < 0xffff; ++i) { 201 c = parport_read_status(p); 202 c &= MTS64_STAT_BSY; 203 if (c != 0) 204 return 1; 205 } 206 207 return 0; 208 } 209 210 /* Init device (LED blinking startup magic) 211 * 212 * Returns: 213 * 0 init ok 214 * -EIO failure 215 */ 216 static int __devinit mts64_device_init(struct parport *p) 217 { 218 int i; 219 220 mts64_write_command(p, MTS64_CMD_RESET); 221 222 for (i = 0; i < 64; ++i) { 223 msleep(100); 224 225 if (mts64_probe(p) == 0) { 226 /* success */ 227 mts64_disable_readout(p); 228 return 0; 229 } 230 } 231 mts64_disable_readout(p); 232 233 return -EIO; 234 } 235 236 /* 237 * Opens the device (set communication mode) 238 */ 239 static int mts64_device_open(struct mts64 *mts) 240 { 241 int i; 242 struct parport *p = mts->pardev->port; 243 244 for (i = 0; i < 5; ++i) 245 mts64_write_command(p, MTS64_CMD_COM_OPEN); 246 247 return 0; 248 } 249 250 /* 251 * Close device (clear communication mode) 252 */ 253 static int mts64_device_close(struct mts64 *mts) 254 { 255 int i; 256 struct parport *p = mts->pardev->port; 257 258 for (i = 0; i < 5; ++i) { 259 mts64_write_command(p, MTS64_CMD_COM_CLOSE1); 260 mts64_write_command(p, MTS64_CMD_COM_CLOSE2); 261 } 262 263 return 0; 264 } 265 266 /* map hardware port to substream number 267 * 268 * When reading a byte from the device, the device tells us 269 * on what port the byte is. This HW port has to be mapped to 270 * the midiport (substream number). 271 * substream 0-3 are Midiports 1-4 272 * substream 4 is SMPTE Timecode 273 * The mapping is done by the table: 274 * HW | 0 | 1 | 2 | 3 | 4 275 * SW | 0 | 1 | 4 | 2 | 3 276 */ 277 static u8 mts64_map_midi_input(u8 c) 278 { 279 static u8 map[] = { 0, 1, 4, 2, 3 }; 280 281 return map[c]; 282 } 283 284 285 /* Probe parport for device 286 * 287 * Do we have a Miditerminal 4140 on parport? 288 * Returns: 289 * 0 device found 290 * -ENODEV no device 291 */ 292 static int __devinit mts64_probe(struct parport *p) 293 { 294 u8 c; 295 296 mts64_smpte_stop(p); 297 mts64_write_command(p, MTS64_CMD_PROBE); 298 299 msleep(50); 300 301 c = mts64_read(p); 302 303 c &= 0x00ff; 304 if (c != MTS64_CMD_PROBE) 305 return -ENODEV; 306 else 307 return 0; 308 309 } 310 311 /* Read byte incl. status from device 312 * 313 * Returns: 314 * data in lower 8 bits and status in upper 8 bits 315 */ 316 static u16 mts64_read(struct parport *p) 317 { 318 u8 data, status; 319 320 mts64_device_ready(p); 321 mts64_enable_readout(p); 322 status = parport_read_status(p); 323 data = mts64_read_char(p); 324 mts64_disable_readout(p); 325 326 return (status << 8) | data; 327 } 328 329 /* Read a byte from device 330 * 331 * Note, that readout mode has to be enabled. 332 * readout procedure is as follows: 333 * - Write number of the Bit to read to DATA 334 * - Read STATUS 335 * - Bit 5 of STATUS indicates if Bit is set 336 * 337 * Returns: 338 * Byte read from device 339 */ 340 static u8 mts64_read_char(struct parport *p) 341 { 342 u8 c = 0; 343 u8 status; 344 u8 i; 345 346 for (i = 0; i < 8; ++i) { 347 parport_write_data(p, i); 348 c >>= 1; 349 status = parport_read_status(p); 350 if (status & MTS64_STAT_BIT_SET) 351 c |= 0x80; 352 } 353 354 return c; 355 } 356 357 /* Starts SMPTE Timecode generation 358 * 359 * The device creates SMPTE Timecode by hardware. 360 * 0 24 fps 361 * 1 25 fps 362 * 2 29.97 fps 363 * 3 30 fps (Drop-frame) 364 * 4 30 fps 365 */ 366 static void mts64_smpte_start(struct parport *p, 367 u8 hours, u8 minutes, 368 u8 seconds, u8 frames, 369 u8 idx) 370 { 371 static u8 fps[5] = { MTS64_CMD_SMPTE_FPS_24, 372 MTS64_CMD_SMPTE_FPS_25, 373 MTS64_CMD_SMPTE_FPS_2997, 374 MTS64_CMD_SMPTE_FPS_30D, 375 MTS64_CMD_SMPTE_FPS_30 }; 376 377 mts64_write_command(p, MTS64_CMD_SMPTE_SET_TIME); 378 mts64_write_command(p, frames); 379 mts64_write_command(p, seconds); 380 mts64_write_command(p, minutes); 381 mts64_write_command(p, hours); 382 383 mts64_write_command(p, MTS64_CMD_SMPTE_SET_FPS); 384 mts64_write_command(p, fps[idx]); 385 } 386 387 /* Stops SMPTE Timecode generation 388 */ 389 static void mts64_smpte_stop(struct parport *p) 390 { 391 mts64_write_command(p, MTS64_CMD_SMPTE_STOP); 392 } 393 394 /* Write a command byte to device 395 */ 396 static void mts64_write_command(struct parport *p, u8 c) 397 { 398 mts64_device_ready(p); 399 400 parport_write_data(p, c); 401 402 parport_write_control(p, MTS64_CTL_WRITE_CMD); 403 parport_write_control(p, MTS64_CTL_WRITE_CMD | MTS64_CTL_STROBE); 404 parport_write_control(p, MTS64_CTL_WRITE_CMD); 405 } 406 407 /* Write a data byte to device 408 */ 409 static void mts64_write_data(struct parport *p, u8 c) 410 { 411 mts64_device_ready(p); 412 413 parport_write_data(p, c); 414 415 parport_write_control(p, MTS64_CTL_WRITE_DATA); 416 parport_write_control(p, MTS64_CTL_WRITE_DATA | MTS64_CTL_STROBE); 417 parport_write_control(p, MTS64_CTL_WRITE_DATA); 418 } 419 420 /* Write a MIDI byte to midiport 421 * 422 * midiport ranges from 0-3 and maps to Ports 1-4 423 * assumptions: communication mode is on 424 */ 425 static void mts64_write_midi(struct mts64 *mts, u8 c, 426 int midiport) 427 { 428 struct parport *p = mts->pardev->port; 429 430 /* check current midiport */ 431 if (mts->current_midi_output_port != midiport) 432 mts64_write_command(p, midiport); 433 434 /* write midi byte */ 435 mts64_write_data(p, c); 436 } 437 438 /********************************************************************* 439 * Control elements 440 *********************************************************************/ 441 442 /* SMPTE Switch */ 443 static int snd_mts64_ctl_smpte_switch_info(struct snd_kcontrol *kctl, 444 struct snd_ctl_elem_info *uinfo) 445 { 446 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 447 uinfo->count = 1; 448 uinfo->value.integer.min = 0; 449 uinfo->value.integer.max = 1; 450 return 0; 451 } 452 453 static int snd_mts64_ctl_smpte_switch_get(struct snd_kcontrol* kctl, 454 struct snd_ctl_elem_value *uctl) 455 { 456 struct mts64 *mts = snd_kcontrol_chip(kctl); 457 458 spin_lock_irq(&mts->lock); 459 uctl->value.integer.value[0] = mts->smpte_switch; 460 spin_unlock_irq(&mts->lock); 461 462 return 0; 463 } 464 465 /* smpte_switch is not accessed from IRQ handler, so we just need 466 to protect the HW access */ 467 static int snd_mts64_ctl_smpte_switch_put(struct snd_kcontrol* kctl, 468 struct snd_ctl_elem_value *uctl) 469 { 470 struct mts64 *mts = snd_kcontrol_chip(kctl); 471 int changed = 0; 472 473 spin_lock_irq(&mts->lock); 474 if (mts->smpte_switch == uctl->value.integer.value[0]) 475 goto __out; 476 477 changed = 1; 478 mts->smpte_switch = uctl->value.integer.value[0]; 479 if (mts->smpte_switch) { 480 mts64_smpte_start(mts->pardev->port, 481 mts->time[0], mts->time[1], 482 mts->time[2], mts->time[3], 483 mts->fps); 484 } else { 485 mts64_smpte_stop(mts->pardev->port); 486 } 487 __out: 488 spin_unlock_irq(&mts->lock); 489 return changed; 490 } 491 492 static struct snd_kcontrol_new mts64_ctl_smpte_switch __devinitdata = { 493 .iface = SNDRV_CTL_ELEM_IFACE_RAWMIDI, 494 .name = "SMPTE Playback Switch", 495 .index = 0, 496 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 497 .private_value = 0, 498 .info = snd_mts64_ctl_smpte_switch_info, 499 .get = snd_mts64_ctl_smpte_switch_get, 500 .put = snd_mts64_ctl_smpte_switch_put 501 }; 502 503 /* Time */ 504 static int snd_mts64_ctl_smpte_time_h_info(struct snd_kcontrol *kctl, 505 struct snd_ctl_elem_info *uinfo) 506 { 507 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 508 uinfo->count = 1; 509 uinfo->value.integer.min = 0; 510 uinfo->value.integer.max = 23; 511 return 0; 512 } 513 514 static int snd_mts64_ctl_smpte_time_f_info(struct snd_kcontrol *kctl, 515 struct snd_ctl_elem_info *uinfo) 516 { 517 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 518 uinfo->count = 1; 519 uinfo->value.integer.min = 0; 520 uinfo->value.integer.max = 99; 521 return 0; 522 } 523 524 static int snd_mts64_ctl_smpte_time_info(struct snd_kcontrol *kctl, 525 struct snd_ctl_elem_info *uinfo) 526 { 527 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 528 uinfo->count = 1; 529 uinfo->value.integer.min = 0; 530 uinfo->value.integer.max = 59; 531 return 0; 532 } 533 534 static int snd_mts64_ctl_smpte_time_get(struct snd_kcontrol *kctl, 535 struct snd_ctl_elem_value *uctl) 536 { 537 struct mts64 *mts = snd_kcontrol_chip(kctl); 538 int idx = kctl->private_value; 539 540 spin_lock_irq(&mts->lock); 541 uctl->value.integer.value[0] = mts->time[idx]; 542 spin_unlock_irq(&mts->lock); 543 544 return 0; 545 } 546 547 static int snd_mts64_ctl_smpte_time_put(struct snd_kcontrol *kctl, 548 struct snd_ctl_elem_value *uctl) 549 { 550 struct mts64 *mts = snd_kcontrol_chip(kctl); 551 int idx = kctl->private_value; 552 int changed = 0; 553 554 spin_lock_irq(&mts->lock); 555 if (mts->time[idx] != uctl->value.integer.value[0]) { 556 changed = 1; 557 mts->time[idx] = uctl->value.integer.value[0]; 558 } 559 spin_unlock_irq(&mts->lock); 560 561 return changed; 562 } 563 564 static struct snd_kcontrol_new mts64_ctl_smpte_time_hours __devinitdata = { 565 .iface = SNDRV_CTL_ELEM_IFACE_RAWMIDI, 566 .name = "SMPTE Time Hours", 567 .index = 0, 568 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 569 .private_value = 0, 570 .info = snd_mts64_ctl_smpte_time_h_info, 571 .get = snd_mts64_ctl_smpte_time_get, 572 .put = snd_mts64_ctl_smpte_time_put 573 }; 574 575 static struct snd_kcontrol_new mts64_ctl_smpte_time_minutes __devinitdata = { 576 .iface = SNDRV_CTL_ELEM_IFACE_RAWMIDI, 577 .name = "SMPTE Time Minutes", 578 .index = 0, 579 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 580 .private_value = 1, 581 .info = snd_mts64_ctl_smpte_time_info, 582 .get = snd_mts64_ctl_smpte_time_get, 583 .put = snd_mts64_ctl_smpte_time_put 584 }; 585 586 static struct snd_kcontrol_new mts64_ctl_smpte_time_seconds __devinitdata = { 587 .iface = SNDRV_CTL_ELEM_IFACE_RAWMIDI, 588 .name = "SMPTE Time Seconds", 589 .index = 0, 590 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 591 .private_value = 2, 592 .info = snd_mts64_ctl_smpte_time_info, 593 .get = snd_mts64_ctl_smpte_time_get, 594 .put = snd_mts64_ctl_smpte_time_put 595 }; 596 597 static struct snd_kcontrol_new mts64_ctl_smpte_time_frames __devinitdata = { 598 .iface = SNDRV_CTL_ELEM_IFACE_RAWMIDI, 599 .name = "SMPTE Time Frames", 600 .index = 0, 601 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 602 .private_value = 3, 603 .info = snd_mts64_ctl_smpte_time_f_info, 604 .get = snd_mts64_ctl_smpte_time_get, 605 .put = snd_mts64_ctl_smpte_time_put 606 }; 607 608 /* FPS */ 609 static int snd_mts64_ctl_smpte_fps_info(struct snd_kcontrol *kctl, 610 struct snd_ctl_elem_info *uinfo) 611 { 612 static char *texts[5] = { "24", 613 "25", 614 "29.97", 615 "30D", 616 "30" }; 617 618 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 619 uinfo->count = 1; 620 uinfo->value.enumerated.items = 5; 621 if (uinfo->value.enumerated.item > 4) 622 uinfo->value.enumerated.item = 4; 623 strcpy(uinfo->value.enumerated.name, 624 texts[uinfo->value.enumerated.item]); 625 626 return 0; 627 } 628 629 static int snd_mts64_ctl_smpte_fps_get(struct snd_kcontrol *kctl, 630 struct snd_ctl_elem_value *uctl) 631 { 632 struct mts64 *mts = snd_kcontrol_chip(kctl); 633 634 spin_lock_irq(&mts->lock); 635 uctl->value.enumerated.item[0] = mts->fps; 636 spin_unlock_irq(&mts->lock); 637 638 return 0; 639 } 640 641 static int snd_mts64_ctl_smpte_fps_put(struct snd_kcontrol *kctl, 642 struct snd_ctl_elem_value *uctl) 643 { 644 struct mts64 *mts = snd_kcontrol_chip(kctl); 645 int changed = 0; 646 647 spin_lock_irq(&mts->lock); 648 if (mts->fps != uctl->value.enumerated.item[0]) { 649 changed = 1; 650 mts->fps = uctl->value.enumerated.item[0]; 651 } 652 spin_unlock_irq(&mts->lock); 653 654 return changed; 655 } 656 657 static struct snd_kcontrol_new mts64_ctl_smpte_fps __devinitdata = { 658 .iface = SNDRV_CTL_ELEM_IFACE_RAWMIDI, 659 .name = "SMPTE Fps", 660 .index = 0, 661 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 662 .private_value = 0, 663 .info = snd_mts64_ctl_smpte_fps_info, 664 .get = snd_mts64_ctl_smpte_fps_get, 665 .put = snd_mts64_ctl_smpte_fps_put 666 }; 667 668 669 static int __devinit snd_mts64_ctl_create(struct snd_card *card, 670 struct mts64 *mts) 671 { 672 int err, i; 673 static struct snd_kcontrol_new *control[] = { 674 &mts64_ctl_smpte_switch, 675 &mts64_ctl_smpte_time_hours, 676 &mts64_ctl_smpte_time_minutes, 677 &mts64_ctl_smpte_time_seconds, 678 &mts64_ctl_smpte_time_frames, 679 &mts64_ctl_smpte_fps, 680 0 }; 681 682 for (i = 0; control[i]; ++i) { 683 err = snd_ctl_add(card, snd_ctl_new1(control[i], mts)); 684 if (err < 0) { 685 snd_printd("Cannot create control: %s\n", 686 control[i]->name); 687 return err; 688 } 689 } 690 691 return 0; 692 } 693 694 /********************************************************************* 695 * Rawmidi 696 *********************************************************************/ 697 #define MTS64_MODE_INPUT_TRIGGERED 0x01 698 699 static int snd_mts64_rawmidi_open(struct snd_rawmidi_substream *substream) 700 { 701 struct mts64 *mts = substream->rmidi->private_data; 702 703 if (mts->open_count == 0) { 704 /* We don't need a spinlock here, because this is just called 705 if the device has not been opened before. 706 So there aren't any IRQs from the device */ 707 mts64_device_open(mts); 708 709 msleep(50); 710 } 711 ++(mts->open_count); 712 713 return 0; 714 } 715 716 static int snd_mts64_rawmidi_close(struct snd_rawmidi_substream *substream) 717 { 718 struct mts64 *mts = substream->rmidi->private_data; 719 unsigned long flags; 720 721 --(mts->open_count); 722 if (mts->open_count == 0) { 723 /* We need the spinlock_irqsave here because we can still 724 have IRQs at this point */ 725 spin_lock_irqsave(&mts->lock, flags); 726 mts64_device_close(mts); 727 spin_unlock_irqrestore(&mts->lock, flags); 728 729 msleep(500); 730 731 } else if (mts->open_count < 0) 732 mts->open_count = 0; 733 734 return 0; 735 } 736 737 static void snd_mts64_rawmidi_output_trigger(struct snd_rawmidi_substream *substream, 738 int up) 739 { 740 struct mts64 *mts = substream->rmidi->private_data; 741 u8 data; 742 unsigned long flags; 743 744 spin_lock_irqsave(&mts->lock, flags); 745 while (snd_rawmidi_transmit_peek(substream, &data, 1) == 1) { 746 mts64_write_midi(mts, data, substream->number+1); 747 snd_rawmidi_transmit_ack(substream, 1); 748 } 749 spin_unlock_irqrestore(&mts->lock, flags); 750 } 751 752 static void snd_mts64_rawmidi_input_trigger(struct snd_rawmidi_substream *substream, 753 int up) 754 { 755 struct mts64 *mts = substream->rmidi->private_data; 756 unsigned long flags; 757 758 spin_lock_irqsave(&mts->lock, flags); 759 if (up) 760 mts->mode[substream->number] |= MTS64_MODE_INPUT_TRIGGERED; 761 else 762 mts->mode[substream->number] &= ~MTS64_MODE_INPUT_TRIGGERED; 763 764 spin_unlock_irqrestore(&mts->lock, flags); 765 } 766 767 static struct snd_rawmidi_ops snd_mts64_rawmidi_output_ops = { 768 .open = snd_mts64_rawmidi_open, 769 .close = snd_mts64_rawmidi_close, 770 .trigger = snd_mts64_rawmidi_output_trigger 771 }; 772 773 static struct snd_rawmidi_ops snd_mts64_rawmidi_input_ops = { 774 .open = snd_mts64_rawmidi_open, 775 .close = snd_mts64_rawmidi_close, 776 .trigger = snd_mts64_rawmidi_input_trigger 777 }; 778 779 /* Create and initialize the rawmidi component */ 780 static int __devinit snd_mts64_rawmidi_create(struct snd_card *card) 781 { 782 struct mts64 *mts = card->private_data; 783 struct snd_rawmidi *rmidi; 784 struct snd_rawmidi_substream *substream; 785 struct list_head *list; 786 int err; 787 788 err = snd_rawmidi_new(card, CARD_NAME, 0, 789 MTS64_NUM_OUTPUT_PORTS, 790 MTS64_NUM_INPUT_PORTS, 791 &rmidi); 792 if (err < 0) 793 return err; 794 795 rmidi->private_data = mts; 796 strcpy(rmidi->name, CARD_NAME); 797 rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT | 798 SNDRV_RAWMIDI_INFO_INPUT | 799 SNDRV_RAWMIDI_INFO_DUPLEX; 800 801 mts->rmidi = rmidi; 802 803 /* register rawmidi ops */ 804 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, 805 &snd_mts64_rawmidi_output_ops); 806 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, 807 &snd_mts64_rawmidi_input_ops); 808 809 /* name substreams */ 810 /* output */ 811 list_for_each(list, 812 &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams) { 813 substream = list_entry(list, struct snd_rawmidi_substream, list); 814 sprintf(substream->name, 815 "Miditerminal %d", substream->number+1); 816 } 817 /* input */ 818 list_for_each(list, 819 &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams) { 820 substream = list_entry(list, struct snd_rawmidi_substream, list); 821 mts->midi_input_substream[substream->number] = substream; 822 switch(substream->number) { 823 case MTS64_SMPTE_SUBSTREAM: 824 strcpy(substream->name, "Miditerminal SMPTE"); 825 break; 826 default: 827 sprintf(substream->name, 828 "Miditerminal %d", substream->number+1); 829 } 830 } 831 832 /* controls */ 833 err = snd_mts64_ctl_create(card, mts); 834 835 return err; 836 } 837 838 /********************************************************************* 839 * parport stuff 840 *********************************************************************/ 841 static void snd_mts64_interrupt(int irq, void *private, struct pt_regs *r) 842 { 843 struct mts64 *mts = ((struct snd_card*)private)->private_data; 844 u16 ret; 845 u8 status, data; 846 struct snd_rawmidi_substream *substream; 847 848 spin_lock(&mts->lock); 849 ret = mts64_read(mts->pardev->port); 850 data = ret & 0x00ff; 851 status = ret >> 8; 852 853 if (status & MTS64_STAT_PORT) { 854 mts->current_midi_input_port = mts64_map_midi_input(data); 855 } else { 856 if (mts->current_midi_input_port == -1) 857 goto __out; 858 substream = mts->midi_input_substream[mts->current_midi_input_port]; 859 if (mts->mode[substream->number] & MTS64_MODE_INPUT_TRIGGERED) 860 snd_rawmidi_receive(substream, &data, 1); 861 } 862 __out: 863 spin_unlock(&mts->lock); 864 } 865 866 static int __devinit snd_mts64_probe_port(struct parport *p) 867 { 868 struct pardevice *pardev; 869 int res; 870 871 pardev = parport_register_device(p, DRIVER_NAME, 872 NULL, NULL, NULL, 873 0, NULL); 874 if (!pardev) 875 return -EIO; 876 877 if (parport_claim(pardev)) { 878 parport_unregister_device(pardev); 879 return -EIO; 880 } 881 882 res = mts64_probe(p); 883 884 parport_release(pardev); 885 parport_unregister_device(pardev); 886 887 return res; 888 } 889 890 static void __devinit snd_mts64_attach(struct parport *p) 891 { 892 struct platform_device *device; 893 894 device = platform_device_alloc(PLATFORM_DRIVER, device_count); 895 if (!device) 896 return; 897 898 /* Temporary assignment to forward the parport */ 899 platform_set_drvdata(device, p); 900 901 if (platform_device_register(device) < 0) { 902 platform_device_put(device); 903 return; 904 } 905 906 /* Since we dont get the return value of probe 907 * We need to check if device probing succeeded or not */ 908 if (!platform_get_drvdata(device)) { 909 platform_device_unregister(device); 910 return; 911 } 912 913 /* register device in global table */ 914 platform_devices[device_count] = device; 915 device_count++; 916 } 917 918 static void snd_mts64_detach(struct parport *p) 919 { 920 /* nothing to do here */ 921 } 922 923 static struct parport_driver mts64_parport_driver = { 924 .name = "mts64", 925 .attach = snd_mts64_attach, 926 .detach = snd_mts64_detach 927 }; 928 929 /********************************************************************* 930 * platform stuff 931 *********************************************************************/ 932 static void snd_mts64_card_private_free(struct snd_card *card) 933 { 934 struct mts64 *mts = card->private_data; 935 struct pardevice *pardev = mts->pardev; 936 937 if (pardev) { 938 if (mts->pardev_claimed) 939 parport_release(pardev); 940 parport_unregister_device(pardev); 941 } 942 943 snd_mts64_free(mts); 944 } 945 946 static int __devinit snd_mts64_probe(struct platform_device *pdev) 947 { 948 struct pardevice *pardev; 949 struct parport *p; 950 int dev = pdev->id; 951 struct snd_card *card = NULL; 952 struct mts64 *mts = NULL; 953 int err; 954 955 p = platform_get_drvdata(pdev); 956 platform_set_drvdata(pdev, NULL); 957 958 if (dev >= SNDRV_CARDS) 959 return -ENODEV; 960 if (!enable[dev]) 961 return -ENOENT; 962 if ((err = snd_mts64_probe_port(p)) < 0) 963 return err; 964 965 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); 966 if (card == NULL) { 967 snd_printd("Cannot create card\n"); 968 return -ENOMEM; 969 } 970 strcpy(card->driver, DRIVER_NAME); 971 strcpy(card->shortname, "ESI " CARD_NAME); 972 sprintf(card->longname, "%s at 0x%lx, irq %i", 973 card->shortname, p->base, p->irq); 974 975 pardev = parport_register_device(p, /* port */ 976 DRIVER_NAME, /* name */ 977 NULL, /* preempt */ 978 NULL, /* wakeup */ 979 snd_mts64_interrupt, /* ISR */ 980 PARPORT_DEV_EXCL, /* flags */ 981 (void *)card); /* private */ 982 if (pardev == NULL) { 983 snd_printd("Cannot register pardevice\n"); 984 err = -EIO; 985 goto __err; 986 } 987 988 if ((err = snd_mts64_create(card, pardev, &mts)) < 0) { 989 snd_printd("Cannot create main component\n"); 990 parport_unregister_device(pardev); 991 goto __err; 992 } 993 card->private_data = mts; 994 card->private_free = snd_mts64_card_private_free; 995 996 if ((err = snd_mts64_rawmidi_create(card)) < 0) { 997 snd_printd("Creating Rawmidi component failed\n"); 998 goto __err; 999 } 1000 1001 /* claim parport */ 1002 if (parport_claim(pardev)) { 1003 snd_printd("Cannot claim parport 0x%lx\n", pardev->port->base); 1004 err = -EIO; 1005 goto __err; 1006 } 1007 mts->pardev_claimed = 1; 1008 1009 /* init device */ 1010 if ((err = mts64_device_init(p)) < 0) 1011 goto __err; 1012 1013 platform_set_drvdata(pdev, card); 1014 1015 /* At this point card will be usable */ 1016 if ((err = snd_card_register(card)) < 0) { 1017 snd_printd("Cannot register card\n"); 1018 goto __err; 1019 } 1020 1021 snd_printk("ESI Miditerminal 4140 on 0x%lx\n", p->base); 1022 return 0; 1023 1024 __err: 1025 snd_card_free(card); 1026 return err; 1027 } 1028 1029 static int snd_mts64_remove(struct platform_device *pdev) 1030 { 1031 struct snd_card *card = platform_get_drvdata(pdev); 1032 1033 if (card) 1034 snd_card_free(card); 1035 1036 return 0; 1037 } 1038 1039 1040 static struct platform_driver snd_mts64_driver = { 1041 .probe = snd_mts64_probe, 1042 .remove = snd_mts64_remove, 1043 .driver = { 1044 .name = PLATFORM_DRIVER 1045 } 1046 }; 1047 1048 /********************************************************************* 1049 * module init stuff 1050 *********************************************************************/ 1051 static void snd_mts64_unregister_all(void) 1052 { 1053 int i; 1054 1055 for (i = 0; i < SNDRV_CARDS; ++i) { 1056 if (platform_devices[i]) { 1057 platform_device_unregister(platform_devices[i]); 1058 platform_devices[i] = NULL; 1059 } 1060 } 1061 platform_driver_unregister(&snd_mts64_driver); 1062 parport_unregister_driver(&mts64_parport_driver); 1063 } 1064 1065 static int __init snd_mts64_module_init(void) 1066 { 1067 int err; 1068 1069 if ((err = platform_driver_register(&snd_mts64_driver)) < 0) 1070 return err; 1071 1072 if (parport_register_driver(&mts64_parport_driver) != 0) { 1073 platform_driver_unregister(&snd_mts64_driver); 1074 return -EIO; 1075 } 1076 1077 if (device_count == 0) { 1078 snd_mts64_unregister_all(); 1079 return -ENODEV; 1080 } 1081 1082 return 0; 1083 } 1084 1085 static void __exit snd_mts64_module_exit(void) 1086 { 1087 snd_mts64_unregister_all(); 1088 } 1089 1090 module_init(snd_mts64_module_init); 1091 module_exit(snd_mts64_module_exit); 1092