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