linux/sound/drivers/mts64.c
<<
>>
Prefs
   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
  37static int index[SNDRV_CARDS]  = SNDRV_DEFAULT_IDX;
  38static char *id[SNDRV_CARDS]   = SNDRV_DEFAULT_STR;
  39static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
  40
  41static struct platform_device *platform_devices[SNDRV_CARDS]; 
  42static int device_count;
  43
  44module_param_array(index, int, NULL, S_IRUGO);
  45MODULE_PARM_DESC(index, "Index value for " CARD_NAME " soundcard.");
  46module_param_array(id, charp, NULL, S_IRUGO);
  47MODULE_PARM_DESC(id, "ID string for " CARD_NAME " soundcard.");
  48module_param_array(enable, bool, NULL, S_IRUGO);
  49MODULE_PARM_DESC(enable, "Enable " CARD_NAME " soundcard.");
  50
  51MODULE_AUTHOR("Matthias Koenig <mk@phasorlab.de>");
  52MODULE_DESCRIPTION("ESI Miditerminal 4140");
  53MODULE_LICENSE("GPL");
  54MODULE_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
  63struct 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
  80static int snd_mts64_free(struct mts64 *mts)
  81{
  82        kfree(mts);
  83        return 0;
  84}
  85
  86static int __devinit 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 *********************************************************************/
 143static void mts64_enable_readout(struct parport *p);
 144static void mts64_disable_readout(struct parport *p);
 145static int mts64_device_ready(struct parport *p);
 146static int mts64_device_init(struct parport *p);
 147static int mts64_device_open(struct mts64 *mts);
 148static int mts64_device_close(struct mts64 *mts);
 149static u8 mts64_map_midi_input(u8 c);
 150static int mts64_probe(struct parport *p);
 151static u16 mts64_read(struct parport *p);
 152static u8 mts64_read_char(struct parport *p);
 153static void mts64_smpte_start(struct parport *p,
 154                              u8 hours, u8 minutes,
 155                              u8 seconds, u8 frames,
 156                              u8 idx);
 157static void mts64_smpte_stop(struct parport *p);
 158static void mts64_write_command(struct parport *p, u8 c);
 159static void mts64_write_data(struct parport *p, u8 c);
 160static 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 */
 168static 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 */
 181static 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 */
 196static 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 */
 217static int __devinit 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 */
 240static 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 */
 254static 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 */
 278static 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 */
 293static int __devinit 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 */
 317static 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 */
 341static 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 */
 367static 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 */
 390static 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 */
 397static 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 */
 410static 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 */
 426static 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
 446static 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 */
 460static 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
 486static struct snd_kcontrol_new mts64_ctl_smpte_switch __devinitdata = {
 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 */
 498static 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
 508static 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
 518static 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
 528static 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
 541static 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
 559static struct snd_kcontrol_new mts64_ctl_smpte_time_hours __devinitdata = {
 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
 570static struct snd_kcontrol_new mts64_ctl_smpte_time_minutes __devinitdata = {
 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
 581static struct snd_kcontrol_new mts64_ctl_smpte_time_seconds __devinitdata = {
 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
 592static struct snd_kcontrol_new mts64_ctl_smpte_time_frames __devinitdata = {
 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 */
 604static 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
 624static 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
 636static 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
 654static struct snd_kcontrol_new mts64_ctl_smpte_fps __devinitdata = {
 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
 666static int __devinit snd_mts64_ctl_create(struct snd_card *card, 
 667                                          struct mts64 *mts) 
 668{
 669        int err, i;
 670        static struct snd_kcontrol_new *control[] __devinitdata = {
 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
 696static 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
 713static 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
 734static 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
 749static 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
 764static 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
 770static 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 */
 777static int __devinit 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 *********************************************************************/
 838static 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
 863static int __devinit 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
 887static void __devinit 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
 915static void snd_mts64_detach(struct parport *p)
 916{
 917        /* nothing to do here */
 918}
 919
 920static 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 *********************************************************************/
 929static 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
 943static int __devinit 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_create(index[dev], id[dev], THIS_MODULE, 0, &card);
 963        if (err < 0) {
 964                snd_printd("Cannot create card\n");
 965                return err;
 966        }
 967        strcpy(card->driver, DRIVER_NAME);
 968        strcpy(card->shortname, "ESI " CARD_NAME);
 969        sprintf(card->longname,  "%s at 0x%lx, irq %i", 
 970                card->shortname, p->base, p->irq);
 971
 972        pardev = parport_register_device(p,                   /* port */
 973                                         DRIVER_NAME,         /* name */
 974                                         NULL,                /* preempt */
 975                                         NULL,                /* wakeup */
 976                                         snd_mts64_interrupt, /* ISR */
 977                                         PARPORT_DEV_EXCL,    /* flags */
 978                                         (void *)card);       /* private */
 979        if (pardev == NULL) {
 980                snd_printd("Cannot register pardevice\n");
 981                err = -EIO;
 982                goto __err;
 983        }
 984
 985        if ((err = snd_mts64_create(card, pardev, &mts)) < 0) {
 986                snd_printd("Cannot create main component\n");
 987                parport_unregister_device(pardev);
 988                goto __err;
 989        }
 990        card->private_data = mts;
 991        card->private_free = snd_mts64_card_private_free;
 992        
 993        if ((err = snd_mts64_rawmidi_create(card)) < 0) {
 994                snd_printd("Creating Rawmidi component failed\n");
 995                goto __err;
 996        }
 997
 998        /* claim parport */
 999        if (parport_claim(pardev)) {
1000                snd_printd("Cannot claim parport 0x%lx\n", pardev->port->base);
1001                err = -EIO;
1002                goto __err;
1003        }
1004        mts->pardev_claimed = 1;
1005
1006        /* init device */
1007        if ((err = mts64_device_init(p)) < 0)
1008                goto __err;
1009
1010        platform_set_drvdata(pdev, card);
1011
1012        snd_card_set_dev(card, &pdev->dev);
1013
1014        /* At this point card will be usable */
1015        if ((err = snd_card_register(card)) < 0) {
1016                snd_printd("Cannot register card\n");
1017                goto __err;
1018        }
1019
1020        snd_printk(KERN_INFO "ESI Miditerminal 4140 on 0x%lx\n", p->base);
1021        return 0;
1022
1023__err:
1024        snd_card_free(card);
1025        return err;
1026}
1027
1028static int __devexit snd_mts64_remove(struct platform_device *pdev)
1029{
1030        struct snd_card *card = platform_get_drvdata(pdev);
1031
1032        if (card)
1033                snd_card_free(card);
1034
1035        return 0;
1036}
1037
1038
1039static struct platform_driver snd_mts64_driver = {
1040        .probe  = snd_mts64_probe,
1041        .remove = __devexit_p(snd_mts64_remove),
1042        .driver = {
1043                .name = PLATFORM_DRIVER,
1044                .owner  = THIS_MODULE,
1045        }
1046};
1047
1048/*********************************************************************
1049 * module init stuff
1050 *********************************************************************/
1051static void snd_mts64_unregister_all(void)
1052{
1053        int i;
1054
1055        for (i = 0; i < SNDRV_CARDS; ++i) {
1056                if (platform_devices[i]) {
1057                        platform_device_unregister(platform_devices[i]);
1058                        platform_devices[i] = NULL;
1059                }
1060        }               
1061        platform_driver_unregister(&snd_mts64_driver);
1062        parport_unregister_driver(&mts64_parport_driver);
1063}
1064
1065static int __init snd_mts64_module_init(void)
1066{
1067        int err;
1068
1069        if ((err = platform_driver_register(&snd_mts64_driver)) < 0)
1070                return err;
1071
1072        if (parport_register_driver(&mts64_parport_driver) != 0) {
1073                platform_driver_unregister(&snd_mts64_driver);
1074                return -EIO;
1075        }
1076
1077        if (device_count == 0) {
1078                snd_mts64_unregister_all();
1079                return -ENODEV;
1080        }
1081
1082        return 0;
1083}
1084
1085static void __exit snd_mts64_module_exit(void)
1086{
1087        snd_mts64_unregister_all();
1088}
1089
1090module_init(snd_mts64_module_init);
1091module_exit(snd_mts64_module_exit);
1092
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.