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 <linux/slab.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 #define snd_mts64_ctl_smpte_switch_info snd_ctl_boolean_mono_info 444 445 static int snd_mts64_ctl_smpte_switch_get(struct snd_kcontrol* kctl, 446 struct snd_ctl_elem_value *uctl) 447 { 448 struct mts64 *mts = snd_kcontrol_chip(kctl); 449 450 spin_lock_irq(&mts->lock); 451 uctl->value.integer.value[0] = mts->smpte_switch; 452 spin_unlock_irq(&mts->lock); 453 454 return 0; 455 } 456 457 /* smpte_switch is not accessed from IRQ handler, so we just need 458 to protect the HW access */ 459 static int snd_mts64_ctl_smpte_switch_put(struct snd_kcontrol* kctl, 460 struct snd_ctl_elem_value *uctl) 461 { 462 struct mts64 *mts = snd_kcontrol_chip(kctl); 463 int changed = 0; 464 int val = !!uctl->value.integer.value[0]; 465 466 spin_lock_irq(&mts->lock); 467 if (mts->smpte_switch == val) 468 goto __out; 469 470 changed = 1; 471 mts->smpte_switch = val; 472 if (mts->smpte_switch) { 473 mts64_smpte_start(mts->pardev->port, 474 mts->time[0], mts->time[1], 475 mts->time[2], mts->time[3], 476 mts->fps); 477 } else { 478 mts64_smpte_stop(mts->pardev->port); 479 } 480 __out: 481 spin_unlock_irq(&mts->lock); 482 return changed; 483 } 484 485 static struct snd_kcontrol_new mts64_ctl_smpte_switch __devinitdata = { 486 .iface = SNDRV_CTL_ELEM_IFACE_RAWMIDI, 487 .name = "SMPTE Playback Switch", 488 .index = 0, 489 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 490 .private_value = 0, 491 .info = snd_mts64_ctl_smpte_switch_info, 492 .get = snd_mts64_ctl_smpte_switch_get, 493 .put = snd_mts64_ctl_smpte_switch_put 494 }; 495 496 /* Time */ 497 static int snd_mts64_ctl_smpte_time_h_info(struct snd_kcontrol *kctl, 498 struct snd_ctl_elem_info *uinfo) 499 { 500 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 501 uinfo->count = 1; 502 uinfo->value.integer.min = 0; 503 uinfo->value.integer.max = 23; 504 return 0; 505 } 506 507 static int snd_mts64_ctl_smpte_time_f_info(struct snd_kcontrol *kctl, 508 struct snd_ctl_elem_info *uinfo) 509 { 510 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 511 uinfo->count = 1; 512 uinfo->value.integer.min = 0; 513 uinfo->value.integer.max = 99; 514 return 0; 515 } 516 517 static int snd_mts64_ctl_smpte_time_info(struct snd_kcontrol *kctl, 518 struct snd_ctl_elem_info *uinfo) 519 { 520 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 521 uinfo->count = 1; 522 uinfo->value.integer.min = 0; 523 uinfo->value.integer.max = 59; 524 return 0; 525 } 526 527 static int snd_mts64_ctl_smpte_time_get(struct snd_kcontrol *kctl, 528 struct snd_ctl_elem_value *uctl) 529 { 530 struct mts64 *mts = snd_kcontrol_chip(kctl); 531 int idx = kctl->private_value; 532 533 spin_lock_irq(&mts->lock); 534 uctl->value.integer.value[0] = mts->time[idx]; 535 spin_unlock_irq(&mts->lock); 536 537 return 0; 538 } 539 540 static int snd_mts64_ctl_smpte_time_put(struct snd_kcontrol *kctl, 541 struct snd_ctl_elem_value *uctl) 542 { 543 struct mts64 *mts = snd_kcontrol_chip(kctl); 544 int idx = kctl->private_value; 545 unsigned int time = uctl->value.integer.value[0] % 60; 546 int changed = 0; 547 548 spin_lock_irq(&mts->lock); 549 if (mts->time[idx] != time) { 550 changed = 1; 551 mts->time[idx] = time; 552 } 553 spin_unlock_irq(&mts->lock); 554 555 return changed; 556 } 557 558 static struct snd_kcontrol_new mts64_ctl_smpte_time_hours __devinitdata = { 559 .iface = SNDRV_CTL_ELEM_IFACE_RAWMIDI, 560 .name = "SMPTE Time Hours", 561 .index = 0, 562 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 563 .private_value = 0, 564 .info = snd_mts64_ctl_smpte_time_h_info, 565 .get = snd_mts64_ctl_smpte_time_get, 566 .put = snd_mts64_ctl_smpte_time_put 567 }; 568 569 static struct snd_kcontrol_new mts64_ctl_smpte_time_minutes __devinitdata = { 570 .iface = SNDRV_CTL_ELEM_IFACE_RAWMIDI, 571 .name = "SMPTE Time Minutes", 572 .index = 0, 573 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 574 .private_value = 1, 575 .info = snd_mts64_ctl_smpte_time_info, 576 .get = snd_mts64_ctl_smpte_time_get, 577 .put = snd_mts64_ctl_smpte_time_put 578 }; 579 580 static struct snd_kcontrol_new mts64_ctl_smpte_time_seconds __devinitdata = { 581 .iface = SNDRV_CTL_ELEM_IFACE_RAWMIDI, 582 .name = "SMPTE Time Seconds", 583 .index = 0, 584 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 585 .private_value = 2, 586 .info = snd_mts64_ctl_smpte_time_info, 587 .get = snd_mts64_ctl_smpte_time_get, 588 .put = snd_mts64_ctl_smpte_time_put 589 }; 590 591 static struct snd_kcontrol_new mts64_ctl_smpte_time_frames __devinitdata = { 592 .iface = SNDRV_CTL_ELEM_IFACE_RAWMIDI, 593 .name = "SMPTE Time Frames", 594 .index = 0, 595 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 596 .private_value = 3, 597 .info = snd_mts64_ctl_smpte_time_f_info, 598 .get = snd_mts64_ctl_smpte_time_get, 599 .put = snd_mts64_ctl_smpte_time_put 600 }; 601 602 /* FPS */ 603 static int snd_mts64_ctl_smpte_fps_info(struct snd_kcontrol *kctl, 604 struct snd_ctl_elem_info *uinfo) 605 { 606 static char *texts[5] = { "24", 607 "25", 608 "29.97", 609 "30D", 610 "30" }; 611 612 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 613 uinfo->count = 1; 614 uinfo->value.enumerated.items = 5; 615 if (uinfo->value.enumerated.item > 4) 616 uinfo->value.enumerated.item = 4; 617 strcpy(uinfo->value.enumerated.name, 618 texts[uinfo->value.enumerated.item]); 619 620 return 0; 621 } 622 623 static int snd_mts64_ctl_smpte_fps_get(struct snd_kcontrol *kctl, 624 struct snd_ctl_elem_value *uctl) 625 { 626 struct mts64 *mts = snd_kcontrol_chip(kctl); 627 628 spin_lock_irq(&mts->lock); 629 uctl->value.enumerated.item[0] = mts->fps; 630 spin_unlock_irq(&mts->lock); 631 632 return 0; 633 } 634 635 static int snd_mts64_ctl_smpte_fps_put(struct snd_kcontrol *kctl, 636 struct snd_ctl_elem_value *uctl) 637 { 638 struct mts64 *mts = snd_kcontrol_chip(kctl); 639 int changed = 0; 640 641 if (uctl->value.enumerated.item[0] >= 5) 642 return -EINVAL; 643 spin_lock_irq(&mts->lock); 644 if (mts->fps != uctl->value.enumerated.item[0]) { 645 changed = 1; 646 mts->fps = uctl->value.enumerated.item[0]; 647 } 648 spin_unlock_irq(&mts->lock); 649 650 return changed; 651 } 652 653 static struct snd_kcontrol_new mts64_ctl_smpte_fps __devinitdata = { 654 .iface = SNDRV_CTL_ELEM_IFACE_RAWMIDI, 655 .name = "SMPTE Fps", 656 .index = 0, 657 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 658 .private_value = 0, 659 .info = snd_mts64_ctl_smpte_fps_info, 660 .get = snd_mts64_ctl_smpte_fps_get, 661 .put = snd_mts64_ctl_smpte_fps_put 662 }; 663 664 665 static int __devinit snd_mts64_ctl_create(struct snd_card *card, 666 struct mts64 *mts) 667 { 668 int err, i; 669 static struct snd_kcontrol_new *control[] __devinitdata = { 670 &mts64_ctl_smpte_switch, 671 &mts64_ctl_smpte_time_hours, 672 &mts64_ctl_smpte_time_minutes, 673 &mts64_ctl_smpte_time_seconds, 674 &mts64_ctl_smpte_time_frames, 675 &mts64_ctl_smpte_fps, 676 NULL }; 677 678 for (i = 0; control[i]; ++i) { 679 err = snd_ctl_add(card, snd_ctl_new1(control[i], mts)); 680 if (err < 0) { 681 snd_printd("Cannot create control: %s\n", 682 control[i]->name); 683 return err; 684 } 685 } 686 687 return 0; 688 } 689 690 /********************************************************************* 691 * Rawmidi 692 *********************************************************************/ 693 #define MTS64_MODE_INPUT_TRIGGERED 0x01 694 695 static int snd_mts64_rawmidi_open(struct snd_rawmidi_substream *substream) 696 { 697 struct mts64 *mts = substream->rmidi->private_data; 698 699 if (mts->open_count == 0) { 700 /* We don't need a spinlock here, because this is just called 701 if the device has not been opened before. 702 So there aren't any IRQs from the device */ 703 mts64_device_open(mts); 704 705 msleep(50); 706 } 707 ++(mts->open_count); 708 709 return 0; 710 } 711 712 static int snd_mts64_rawmidi_close(struct snd_rawmidi_substream *substream) 713 { 714 struct mts64 *mts = substream->rmidi->private_data; 715 unsigned long flags; 716 717 --(mts->open_count); 718 if (mts->open_count == 0) { 719 /* We need the spinlock_irqsave here because we can still 720 have IRQs at this point */ 721 spin_lock_irqsave(&mts->lock, flags); 722 mts64_device_close(mts); 723 spin_unlock_irqrestore(&mts->lock, flags); 724 725 msleep(500); 726 727 } else if (mts->open_count < 0) 728 mts->open_count = 0; 729 730 return 0; 731 } 732 733 static void snd_mts64_rawmidi_output_trigger(struct snd_rawmidi_substream *substream, 734 int up) 735 { 736 struct mts64 *mts = substream->rmidi->private_data; 737 u8 data; 738 unsigned long flags; 739 740 spin_lock_irqsave(&mts->lock, flags); 741 while (snd_rawmidi_transmit_peek(substream, &data, 1) == 1) { 742 mts64_write_midi(mts, data, substream->number+1); 743 snd_rawmidi_transmit_ack(substream, 1); 744 } 745 spin_unlock_irqrestore(&mts->lock, flags); 746 } 747 748 static void snd_mts64_rawmidi_input_trigger(struct snd_rawmidi_substream *substream, 749 int up) 750 { 751 struct mts64 *mts = substream->rmidi->private_data; 752 unsigned long flags; 753 754 spin_lock_irqsave(&mts->lock, flags); 755 if (up) 756 mts->mode[substream->number] |= MTS64_MODE_INPUT_TRIGGERED; 757 else 758 mts->mode[substream->number] &= ~MTS64_MODE_INPUT_TRIGGERED; 759 760 spin_unlock_irqrestore(&mts->lock, flags); 761 } 762 763 static struct snd_rawmidi_ops snd_mts64_rawmidi_output_ops = { 764 .open = snd_mts64_rawmidi_open, 765 .close = snd_mts64_rawmidi_close, 766 .trigger = snd_mts64_rawmidi_output_trigger 767 }; 768 769 static struct snd_rawmidi_ops snd_mts64_rawmidi_input_ops = { 770 .open = snd_mts64_rawmidi_open, 771 .close = snd_mts64_rawmidi_close, 772 .trigger = snd_mts64_rawmidi_input_trigger 773 }; 774 775 /* Create and initialize the rawmidi component */ 776 static int __devinit snd_mts64_rawmidi_create(struct snd_card *card) 777 { 778 struct mts64 *mts = card->private_data; 779 struct snd_rawmidi *rmidi; 780 struct snd_rawmidi_substream *substream; 781 struct list_head *list; 782 int err; 783 784 err = snd_rawmidi_new(card, CARD_NAME, 0, 785 MTS64_NUM_OUTPUT_PORTS, 786 MTS64_NUM_INPUT_PORTS, 787 &rmidi); 788 if (err < 0) 789 return err; 790 791 rmidi->private_data = mts; 792 strcpy(rmidi->name, CARD_NAME); 793 rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT | 794 SNDRV_RAWMIDI_INFO_INPUT | 795 SNDRV_RAWMIDI_INFO_DUPLEX; 796 797 mts->rmidi = rmidi; 798 799 /* register rawmidi ops */ 800 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, 801 &snd_mts64_rawmidi_output_ops); 802 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, 803 &snd_mts64_rawmidi_input_ops); 804 805 /* name substreams */ 806 /* output */ 807 list_for_each(list, 808 &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams) { 809 substream = list_entry(list, struct snd_rawmidi_substream, list); 810 sprintf(substream->name, 811 "Miditerminal %d", substream->number+1); 812 } 813 /* input */ 814 list_for_each(list, 815 &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams) { 816 substream = list_entry(list, struct snd_rawmidi_substream, list); 817 mts->midi_input_substream[substream->number] = substream; 818 switch(substream->number) { 819 case MTS64_SMPTE_SUBSTREAM: 820 strcpy(substream->name, "Miditerminal SMPTE"); 821 break; 822 default: 823 sprintf(substream->name, 824 "Miditerminal %d", substream->number+1); 825 } 826 } 827 828 /* controls */ 829 err = snd_mts64_ctl_create(card, mts); 830 831 return err; 832 } 833 834 /********************************************************************* 835 * parport stuff 836 *********************************************************************/ 837 static void snd_mts64_interrupt(void *private) 838 { 839 struct mts64 *mts = ((struct snd_card*)private)->private_data; 840 u16 ret; 841 u8 status, data; 842 struct snd_rawmidi_substream *substream; 843 844 spin_lock(&mts->lock); 845 ret = mts64_read(mts->pardev->port); 846 data = ret & 0x00ff; 847 status = ret >> 8; 848 849 if (status & MTS64_STAT_PORT) { 850 mts->current_midi_input_port = mts64_map_midi_input(data); 851 } else { 852 if (mts->current_midi_input_port == -1) 853 goto __out; 854 substream = mts->midi_input_substream[mts->current_midi_input_port]; 855 if (mts->mode[substream->number] & MTS64_MODE_INPUT_TRIGGERED) 856 snd_rawmidi_receive(substream, &data, 1); 857 } 858 __out: 859 spin_unlock(&mts->lock); 860 } 861 862 static int __devinit snd_mts64_probe_port(struct parport *p) 863 { 864 struct pardevice *pardev; 865 int res; 866 867 pardev = parport_register_device(p, DRIVER_NAME, 868 NULL, NULL, NULL, 869 0, NULL); 870 if (!pardev) 871 return -EIO; 872 873 if (parport_claim(pardev)) { 874 parport_unregister_device(pardev); 875 return -EIO; 876 } 877 878 res = mts64_probe(p); 879 880 parport_release(pardev); 881 parport_unregister_device(pardev); 882 883 return res; 884 } 885 886 static void __devinit snd_mts64_attach(struct parport *p) 887 { 888 struct platform_device *device; 889 890 device = platform_device_alloc(PLATFORM_DRIVER, device_count); 891 if (!device) 892 return; 893 894 /* Temporary assignment to forward the parport */ 895 platform_set_drvdata(device, p); 896 897 if (platform_device_add(device) < 0) { 898 platform_device_put(device); 899 return; 900 } 901 902 /* Since we dont get the return value of probe 903 * We need to check if device probing succeeded or not */ 904 if (!platform_get_drvdata(device)) { 905 platform_device_unregister(device); 906 return; 907 } 908 909 /* register device in global table */ 910 platform_devices[device_count] = device; 911 device_count++; 912 } 913 914 static void snd_mts64_detach(struct parport *p) 915 { 916 /* nothing to do here */ 917 } 918 919 static struct parport_driver mts64_parport_driver = { 920 .name = "mts64", 921 .attach = snd_mts64_attach, 922 .detach = snd_mts64_detach 923 }; 924 925 /********************************************************************* 926 * platform stuff 927 *********************************************************************/ 928 static void snd_mts64_card_private_free(struct snd_card *card) 929 { 930 struct mts64 *mts = card->private_data; 931 struct pardevice *pardev = mts->pardev; 932 933 if (pardev) { 934 if (mts->pardev_claimed) 935 parport_release(pardev); 936 parport_unregister_device(pardev); 937 } 938 939 snd_mts64_free(mts); 940 } 941 942 static int __devinit snd_mts64_probe(struct platform_device *pdev) 943 { 944 struct pardevice *pardev; 945 struct parport *p; 946 int dev = pdev->id; 947 struct snd_card *card = NULL; 948 struct mts64 *mts = NULL; 949 int err; 950 951 p = platform_get_drvdata(pdev); 952 platform_set_drvdata(pdev, NULL); 953 954 if (dev >= SNDRV_CARDS) 955 return -ENODEV; 956 if (!enable[dev]) 957 return -ENOENT; 958 if ((err = snd_mts64_probe_port(p)) < 0) 959 return err; 960 961 err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card); 962 if (err < 0) { 963 snd_printd("Cannot create card\n"); 964 return err; 965 } 966 strcpy(card->driver, DRIVER_NAME); 967 strcpy(card->shortname, "ESI " CARD_NAME); 968 sprintf(card->longname, "%s at 0x%lx, irq %i", 969 card->shortname, p->base, p->irq); 970 971 pardev = parport_register_device(p, /* port */ 972 DRIVER_NAME, /* name */ 973 NULL, /* preempt */ 974 NULL, /* wakeup */ 975 snd_mts64_interrupt, /* ISR */ 976 PARPORT_DEV_EXCL, /* flags */ 977 (void *)card); /* private */ 978 if (pardev == NULL) { 979 snd_printd("Cannot register pardevice\n"); 980 err = -EIO; 981 goto __err; 982 } 983 984 if ((err = snd_mts64_create(card, pardev, &mts)) < 0) { 985 snd_printd("Cannot create main component\n"); 986 parport_unregister_device(pardev); 987 goto __err; 988 } 989 card->private_data = mts; 990 card->private_free = snd_mts64_card_private_free; 991 992 if ((err = snd_mts64_rawmidi_create(card)) < 0) { 993 snd_printd("Creating Rawmidi component failed\n"); 994 goto __err; 995 } 996 997 /* claim parport */ 998 if (parport_claim(pardev)) { 999 snd_printd("Cannot claim parport 0x%lx\n", pardev->port->base); 1000 err = -EIO; 1001 goto __err; 1002 } 1003 mts->pardev_claimed = 1; 1004 1005 /* init device */ 1006 if ((err = mts64_device_init(p)) < 0) 1007 goto __err; 1008 1009 platform_set_drvdata(pdev, card); 1010 1011 snd_card_set_dev(card, &pdev->dev); 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 __devexit 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 = __devexit_p(snd_mts64_remove), 1041 .driver = { 1042 .name = PLATFORM_DRIVER 1043 } 1044 }; 1045 1046 /********************************************************************* 1047 * module init stuff 1048 *********************************************************************/ 1049 static void snd_mts64_unregister_all(void) 1050 { 1051 int i; 1052 1053 for (i = 0; i < SNDRV_CARDS; ++i) { 1054 if (platform_devices[i]) { 1055 platform_device_unregister(platform_devices[i]); 1056 platform_devices[i] = NULL; 1057 } 1058 } 1059 platform_driver_unregister(&snd_mts64_driver); 1060 parport_unregister_driver(&mts64_parport_driver); 1061 } 1062 1063 static int __init snd_mts64_module_init(void) 1064 { 1065 int err; 1066 1067 if ((err = platform_driver_register(&snd_mts64_driver)) < 0) 1068 return err; 1069 1070 if (parport_register_driver(&mts64_parport_driver) != 0) { 1071 platform_driver_unregister(&snd_mts64_driver); 1072 return -EIO; 1073 } 1074 1075 if (device_count == 0) { 1076 snd_mts64_unregister_all(); 1077 return -ENODEV; 1078 } 1079 1080 return 0; 1081 } 1082 1083 static void __exit snd_mts64_module_exit(void) 1084 { 1085 snd_mts64_unregister_all(); 1086 } 1087 1088 module_init(snd_mts64_module_init); 1089 module_exit(snd_mts64_module_exit); 1090