mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-06 04:56:41 +07:00
f0418d46d6
Let's make things line up a little bit better. Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com> Signed-off-by: Takashi Iwai <tiwai@suse.de>
207 lines
4.2 KiB
C
207 lines
4.2 KiB
C
/*
|
|
* sound/oss/sb_midi.c
|
|
*
|
|
* The low level driver for the Sound Blaster DS chips.
|
|
*
|
|
*
|
|
* Copyright (C) by Hannu Savolainen 1993-1997
|
|
*
|
|
* OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
|
|
* Version 2 (June 1991). See the "COPYING" file distributed with this software
|
|
* for more info.
|
|
*/
|
|
|
|
#include <linux/spinlock.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include "sound_config.h"
|
|
|
|
#include "sb.h"
|
|
#undef SB_TEST_IRQ
|
|
|
|
/*
|
|
* The DSP channel can be used either for input or output. Variable
|
|
* 'sb_irq_mode' will be set when the program calls read or write first time
|
|
* after open. Current version doesn't support mode changes without closing
|
|
* and reopening the device. Support for this feature may be implemented in a
|
|
* future version of this driver.
|
|
*/
|
|
|
|
|
|
static int sb_midi_open(int dev, int mode,
|
|
void (*input) (int dev, unsigned char data),
|
|
void (*output) (int dev)
|
|
)
|
|
{
|
|
sb_devc *devc = midi_devs[dev]->devc;
|
|
unsigned long flags;
|
|
|
|
if (devc == NULL)
|
|
return -ENXIO;
|
|
|
|
spin_lock_irqsave(&devc->lock, flags);
|
|
if (devc->opened)
|
|
{
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
|
return -EBUSY;
|
|
}
|
|
devc->opened = 1;
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
|
|
|
devc->irq_mode = IMODE_MIDI;
|
|
devc->midi_broken = 0;
|
|
|
|
sb_dsp_reset(devc);
|
|
|
|
if (!sb_dsp_command(devc, 0x35)) /* Start MIDI UART mode */
|
|
{
|
|
devc->opened = 0;
|
|
return -EIO;
|
|
}
|
|
devc->intr_active = 1;
|
|
|
|
if (mode & OPEN_READ)
|
|
{
|
|
devc->input_opened = 1;
|
|
devc->midi_input_intr = input;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void sb_midi_close(int dev)
|
|
{
|
|
sb_devc *devc = midi_devs[dev]->devc;
|
|
unsigned long flags;
|
|
|
|
if (devc == NULL)
|
|
return;
|
|
|
|
spin_lock_irqsave(&devc->lock, flags);
|
|
sb_dsp_reset(devc);
|
|
devc->intr_active = 0;
|
|
devc->input_opened = 0;
|
|
devc->opened = 0;
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
|
}
|
|
|
|
static int sb_midi_out(int dev, unsigned char midi_byte)
|
|
{
|
|
sb_devc *devc = midi_devs[dev]->devc;
|
|
|
|
if (devc == NULL)
|
|
return 1;
|
|
|
|
if (devc->midi_broken)
|
|
return 1;
|
|
|
|
if (!sb_dsp_command(devc, midi_byte))
|
|
{
|
|
devc->midi_broken = 1;
|
|
return 1;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int sb_midi_start_read(int dev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int sb_midi_end_read(int dev)
|
|
{
|
|
sb_devc *devc = midi_devs[dev]->devc;
|
|
|
|
if (devc == NULL)
|
|
return -ENXIO;
|
|
|
|
sb_dsp_reset(devc);
|
|
devc->intr_active = 0;
|
|
return 0;
|
|
}
|
|
|
|
static int sb_midi_ioctl(int dev, unsigned cmd, void __user *arg)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
void sb_midi_interrupt(sb_devc * devc)
|
|
{
|
|
unsigned long flags;
|
|
unsigned char data;
|
|
|
|
if (devc == NULL)
|
|
return;
|
|
|
|
spin_lock_irqsave(&devc->lock, flags);
|
|
|
|
data = inb(DSP_READ);
|
|
if (devc->input_opened)
|
|
devc->midi_input_intr(devc->my_mididev, data);
|
|
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
|
}
|
|
|
|
#define MIDI_SYNTH_NAME "Sound Blaster Midi"
|
|
#define MIDI_SYNTH_CAPS 0
|
|
#include "midi_synth.h"
|
|
|
|
static struct midi_operations sb_midi_operations =
|
|
{
|
|
.owner = THIS_MODULE,
|
|
.info = {"Sound Blaster", 0, 0, SNDCARD_SB},
|
|
.converter = &std_midi_synth,
|
|
.in_info = {0},
|
|
.open = sb_midi_open,
|
|
.close = sb_midi_close,
|
|
.ioctl = sb_midi_ioctl,
|
|
.outputc = sb_midi_out,
|
|
.start_read = sb_midi_start_read,
|
|
.end_read = sb_midi_end_read,
|
|
};
|
|
|
|
void sb_dsp_midi_init(sb_devc * devc, struct module *owner)
|
|
{
|
|
int dev;
|
|
|
|
if (devc->model < 2) /* No MIDI support for SB 1.x */
|
|
return;
|
|
|
|
dev = sound_alloc_mididev();
|
|
|
|
if (dev == -1)
|
|
{
|
|
printk(KERN_ERR "sb_midi: too many MIDI devices detected\n");
|
|
return;
|
|
}
|
|
std_midi_synth.midi_dev = devc->my_mididev = dev;
|
|
midi_devs[dev] = kmalloc(sizeof(struct midi_operations), GFP_KERNEL);
|
|
if (midi_devs[dev] == NULL)
|
|
{
|
|
printk(KERN_WARNING "Sound Blaster: failed to allocate MIDI memory.\n");
|
|
sound_unload_mididev(dev);
|
|
return;
|
|
}
|
|
memcpy((char *) midi_devs[dev], (char *) &sb_midi_operations,
|
|
sizeof(struct midi_operations));
|
|
|
|
if (owner)
|
|
midi_devs[dev]->owner = owner;
|
|
|
|
midi_devs[dev]->devc = devc;
|
|
|
|
|
|
midi_devs[dev]->converter = kmalloc(sizeof(struct synth_operations), GFP_KERNEL);
|
|
if (midi_devs[dev]->converter == NULL)
|
|
{
|
|
printk(KERN_WARNING "Sound Blaster: failed to allocate MIDI memory.\n");
|
|
kfree(midi_devs[dev]);
|
|
sound_unload_mididev(dev);
|
|
return;
|
|
}
|
|
memcpy((char *) midi_devs[dev]->converter, (char *) &std_midi_synth,
|
|
sizeof(struct synth_operations));
|
|
|
|
midi_devs[dev]->converter->id = "SBMIDI";
|
|
sequencer_init();
|
|
}
|