1/*
  2 * sound/oss/sb_midi.c
  3 *
  4 * The low level driver for the Sound Blaster DS chips.
  5 *
  6 *
  7 * Copyright (C) by Hannu Savolainen 1993-1997
  8 *
  9 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
 10 * Version 2 (June 1991). See the "COPYING" file distributed with this software
 11 * for more info.
 12 */
 13
 14#include <linux/spinlock.h>
 15#include <linux/slab.h>
 16
 17#include "sound_config.h"
 18
 19#include "sb.h"
 20#undef SB_TEST_IRQ
 21
 22/*
 23 * The DSP channel can be used either for input or output. Variable
 24 * 'sb_irq_mode' will be set when the program calls read or write first time
 25 * after open. Current version doesn't support mode changes without closing
 26 * and reopening the device. Support for this feature may be implemented in a
 27 * future version of this driver.
 28 */
 29
 30
 31static int sb_midi_open(int dev, int mode,
 32	     void            (*input) (int dev, unsigned char data),
 33	     void            (*output) (int dev)
 34)
 35{
 36	sb_devc *devc = midi_devs[dev]->devc;
 37	unsigned long flags;
 38
 39	if (devc == NULL)
 40		return -ENXIO;
 41
 42	spin_lock_irqsave(&devc->lock, flags);
 43	if (devc->opened)
 44	{
 45		spin_unlock_irqrestore(&devc->lock, flags);
 46		return -EBUSY;
 47	}
 48	devc->opened = 1;
 49	spin_unlock_irqrestore(&devc->lock, flags);
 50
 51	devc->irq_mode = IMODE_MIDI;
 52	devc->midi_broken = 0;
 53
 54	sb_dsp_reset(devc);
 55
 56	if (!sb_dsp_command(devc, 0x35))	/* Start MIDI UART mode */
 57	{
 58		  devc->opened = 0;
 59		  return -EIO;
 60	}
 61	devc->intr_active = 1;
 62
 63	if (mode & OPEN_READ)
 64	{
 65		devc->input_opened = 1;
 66		devc->midi_input_intr = input;
 67	}
 68	return 0;
 69}
 70
 71static void sb_midi_close(int dev)
 72{
 73	sb_devc *devc = midi_devs[dev]->devc;
 74	unsigned long flags;
 75
 76	if (devc == NULL)
 77		return;
 78
 79	spin_lock_irqsave(&devc->lock, flags);
 80	sb_dsp_reset(devc);
 81	devc->intr_active = 0;
 82	devc->input_opened = 0;
 83	devc->opened = 0;
 84	spin_unlock_irqrestore(&devc->lock, flags);
 85}
 86
 87static int sb_midi_out(int dev, unsigned char midi_byte)
 88{
 89	sb_devc *devc = midi_devs[dev]->devc;
 90
 91	if (devc == NULL)
 92		return 1;
 93
 94	if (devc->midi_broken)
 95		return 1;
 96
 97	if (!sb_dsp_command(devc, midi_byte))
 98	{
 99		devc->midi_broken = 1;
100		return 1;
101	}
102	return 1;
103}
104
105static int sb_midi_start_read(int dev)
106{
107	return 0;
108}
109
110static int sb_midi_end_read(int dev)
111{
112	sb_devc *devc = midi_devs[dev]->devc;
113
114	if (devc == NULL)
115		return -ENXIO;
116
117	sb_dsp_reset(devc);
118	devc->intr_active = 0;
119	return 0;
120}
121
122static int sb_midi_ioctl(int dev, unsigned cmd, void __user *arg)
123{
124        return -EINVAL;
125}
126
127void sb_midi_interrupt(sb_devc * devc)
128{
129	unsigned long   flags;
130	unsigned char   data;
131
132	if (devc == NULL)
133		return;
134
135	spin_lock_irqsave(&devc->lock, flags);
136
137	data = inb(DSP_READ);
138	if (devc->input_opened)
139		devc->midi_input_intr(devc->my_mididev, data);
140
141	spin_unlock_irqrestore(&devc->lock, flags);
142}
143
144#define MIDI_SYNTH_NAME	"Sound Blaster Midi"
145#define MIDI_SYNTH_CAPS	0
146#include "midi_synth.h"
147
148static struct midi_operations sb_midi_operations =
149{
150	.owner		= THIS_MODULE,
151	.info		= {"Sound Blaster", 0, 0, SNDCARD_SB},
152	.converter	= &std_midi_synth,
153	.in_info	= {0},
154	.open		= sb_midi_open,
155	.close		= sb_midi_close,
156	.ioctl		= sb_midi_ioctl,
157	.outputc	= sb_midi_out,
158	.start_read	= sb_midi_start_read,
159	.end_read	= sb_midi_end_read,
160};
161
162void sb_dsp_midi_init(sb_devc * devc, struct module *owner)
163{
164	int dev;
165
166	if (devc->model < 2)	/* No MIDI support for SB 1.x */
167		return;
168
169	dev = sound_alloc_mididev();
170
171	if (dev == -1)
172	{
173		printk(KERN_ERR "sb_midi: too many MIDI devices detected\n");
174		return;
175	}
176	std_midi_synth.midi_dev = devc->my_mididev = dev;
177	midi_devs[dev] = kmalloc(sizeof(struct midi_operations), GFP_KERNEL);
178	if (midi_devs[dev] == NULL)
179	{
180		printk(KERN_WARNING "Sound Blaster:  failed to allocate MIDI memory.\n");
181		sound_unload_mididev(dev);
182		  return;
183	}
184	memcpy((char *) midi_devs[dev], (char *) &sb_midi_operations,
185	       sizeof(struct midi_operations));
186
187	if (owner)
188			midi_devs[dev]->owner = owner;
189	
190	midi_devs[dev]->devc = devc;
191
192
193	midi_devs[dev]->converter = kmalloc(sizeof(struct synth_operations), GFP_KERNEL);
194	if (midi_devs[dev]->converter == NULL)
195	{
196		  printk(KERN_WARNING "Sound Blaster:  failed to allocate MIDI memory.\n");
197		  kfree(midi_devs[dev]);
198		  sound_unload_mididev(dev);
199		  return;
200	}
201	memcpy((char *) midi_devs[dev]->converter, (char *) &std_midi_synth,
202	       sizeof(struct synth_operations));
203
204	midi_devs[dev]->converter->id = "SBMIDI";
205	sequencer_init();
206}