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