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