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