#include <sound/core.h>
#include <linux/major.h>
#include <linux/init.h>
+#include <linux/smp_lock.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/time.h>
static int boot_devs;
module_param_array(midi_map, int, boot_devs, 0444);
MODULE_PARM_DESC(midi_map, "Raw MIDI device number assigned to 1st OSS device.");
-MODULE_PARM_SYNTAX(midi_map, "default:0,skill:advanced");
module_param_array(amidi_map, int, boot_devs, 0444);
MODULE_PARM_DESC(amidi_map, "Raw MIDI device number assigned to 2nd OSS device.");
-MODULE_PARM_SYNTAX(amidi_map, "default:1,skill:advanced");
#endif /* CONFIG_SND_OSSEMUL */
static int snd_rawmidi_free(snd_rawmidi_t *rawmidi);
list2 = list2->next;
}
if (mode & SNDRV_RAWMIDI_LFLG_INPUT) {
- input = snd_kcalloc(sizeof(snd_rawmidi_runtime_t), GFP_KERNEL);
+ input = kcalloc(1, sizeof(*input), GFP_KERNEL);
if (input == NULL) {
err = -ENOMEM;
goto __error;
if (mode & SNDRV_RAWMIDI_LFLG_OUTPUT) {
if (soutput->opened)
goto __skip_output;
- output = snd_kcalloc(sizeof(snd_rawmidi_runtime_t), GFP_KERNEL);
+ output = kcalloc(1, sizeof(*output), GFP_KERNEL);
if (output == NULL) {
err = -ENOMEM;
goto __error;
if ((file->f_flags & O_APPEND) || maj != CONFIG_SND_MAJOR) /* OSS emul? */
fflags |= SNDRV_RAWMIDI_LFLG_APPEND;
fflags |= SNDRV_RAWMIDI_LFLG_NOOPENLOCK;
- rawmidi_file = snd_magic_kmalloc(snd_rawmidi_file_t, 0, GFP_KERNEL);
+ rawmidi_file = kmalloc(sizeof(*rawmidi_file), GFP_KERNEL);
if (rawmidi_file == NULL) {
snd_card_file_remove(card, file);
return -ENOMEM;
file->private_data = rawmidi_file;
} else {
snd_card_file_remove(card, file);
- snd_magic_kfree(rawmidi_file);
+ kfree(rawmidi_file);
}
up(&rmidi->open_mutex);
return err;
snd_rawmidi_t *rmidi;
int err;
- rfile = snd_magic_cast(snd_rawmidi_file_t, file->private_data, return -ENXIO);
+ rfile = file->private_data;
err = snd_rawmidi_kernel_release(rfile);
rmidi = rfile->rmidi;
wake_up(&rmidi->open_wait);
- snd_magic_kfree(rfile);
+ kfree(rfile);
snd_card_file_remove(rmidi->card, file);
return err;
}
return 0;
}
-static int snd_rawmidi_ioctl(struct inode *inode, struct file *file,
- unsigned int cmd, unsigned long arg)
+static inline int _snd_rawmidi_ioctl(struct inode *inode, struct file *file,
+ unsigned int cmd, unsigned long arg)
{
snd_rawmidi_file_t *rfile;
void __user *argp = (void __user *)arg;
- rfile = snd_magic_cast(snd_rawmidi_file_t, file->private_data, return -ENXIO);
+ rfile = file->private_data;
if (((cmd >> 8) & 0xff) != 'W')
return -ENOTTY;
switch (cmd) {
return -ENOTTY;
}
+/* FIXME: need to unlock BKL to allow preemption */
+static int snd_rawmidi_ioctl(struct inode *inode, struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ int err;
+ unlock_kernel();
+ err = _snd_rawmidi_ioctl(inode, file, cmd, arg);
+ lock_kernel();
+ return err;
+}
+
int snd_rawmidi_control_ioctl(snd_card_t * card, snd_ctl_file_t * control,
unsigned int cmd, unsigned long arg)
{
snd_rawmidi_substream_t *substream;
snd_rawmidi_runtime_t *runtime;
- rfile = snd_magic_cast(snd_rawmidi_file_t, file->private_data, return -ENXIO);
+ rfile = file->private_data;
substream = rfile->input;
if (substream == NULL)
return -EIO;
}
spin_unlock_irq(&runtime->lock);
count1 = snd_rawmidi_kernel_read1(substream, buf, count, 0);
+ if (count1 < 0)
+ return result > 0 ? result : count1;
result += count1;
buf += count1;
count -= count1;
snd_rawmidi_runtime_t *runtime;
snd_rawmidi_substream_t *substream;
- rfile = snd_magic_cast(snd_rawmidi_file_t, file->private_data, return -ENXIO);
+ rfile = file->private_data;
substream = rfile->output;
runtime = substream->runtime;
/* we cannot put an atomic message to our buffer */
spin_unlock_irq(&runtime->lock);
count1 = snd_rawmidi_kernel_write1(substream, buf, count, 0);
if (count1 < 0)
- continue;
+ return result > 0 ? result : count1;
result += count1;
buf += count1;
if ((size_t)count1 < count && (file->f_flags & O_NONBLOCK))
break;
count -= count1;
}
- while (file->f_flags & O_SYNC) {
+ if (file->f_flags & O_SYNC) {
spin_lock_irq(&runtime->lock);
while (runtime->avail != runtime->buffer_size) {
wait_queue_t wait;
snd_rawmidi_runtime_t *runtime;
unsigned int mask;
- rfile = snd_magic_cast(snd_rawmidi_file_t, file->private_data, return 0);
+ rfile = file->private_data;
if (rfile->input != NULL) {
runtime = rfile->input->runtime;
runtime->trigger = 1;
snd_rawmidi_runtime_t *runtime;
struct list_head *list;
- rmidi = snd_magic_cast(snd_rawmidi_t, entry->private_data, return);
+ rmidi = entry->private_data;
snd_iprintf(buffer, "%s\n\n", rmidi->name);
down(&rmidi->open_mutex);
if (rmidi->info_flags & SNDRV_RAWMIDI_INFO_OUTPUT) {
INIT_LIST_HEAD(&stream->substreams);
for (idx = 0; idx < count; idx++) {
- substream = snd_kcalloc(sizeof(snd_rawmidi_substream_t), GFP_KERNEL);
+ substream = kcalloc(1, sizeof(*substream), GFP_KERNEL);
if (substream == NULL)
return -ENOMEM;
substream->stream = direction;
snd_assert(rrawmidi != NULL, return -EINVAL);
*rrawmidi = NULL;
snd_assert(card != NULL, return -ENXIO);
- rmidi = snd_magic_kcalloc(snd_rawmidi_t, 0, GFP_KERNEL);
+ rmidi = kcalloc(1, sizeof(*rmidi), GFP_KERNEL);
if (rmidi == NULL)
return -ENOMEM;
rmidi->card = card;
snd_rawmidi_free_substreams(&rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT]);
if (rmidi->private_free)
rmidi->private_free(rmidi);
- snd_magic_kfree(rmidi);
+ kfree(rmidi);
return 0;
}
static int snd_rawmidi_dev_free(snd_device_t *device)
{
- snd_rawmidi_t *rmidi = snd_magic_cast(snd_rawmidi_t, device->device_data, return -ENXIO);
+ snd_rawmidi_t *rmidi = device->device_data;
return snd_rawmidi_free(rmidi);
}
#if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
static void snd_rawmidi_dev_seq_free(snd_seq_device_t *device)
{
- snd_rawmidi_t *rmidi = snd_magic_cast(snd_rawmidi_t, device->private_data, return);
+ snd_rawmidi_t *rmidi = device->private_data;
rmidi->seq_dev = NULL;
}
#endif
int idx, err;
snd_info_entry_t *entry;
char name[16];
- snd_rawmidi_t *rmidi = snd_magic_cast(snd_rawmidi_t, device->device_data, return -ENXIO);
+ snd_rawmidi_t *rmidi = device->device_data;
if (rmidi->device >= SNDRV_RAWMIDI_DEVICES)
return -ENOMEM;
static int snd_rawmidi_dev_disconnect(snd_device_t *device)
{
- snd_rawmidi_t *rmidi = snd_magic_cast(snd_rawmidi_t, device->device_data, return -ENXIO);
+ snd_rawmidi_t *rmidi = device->device_data;
int idx;
down(®ister_mutex);
static int snd_rawmidi_dev_unregister(snd_device_t *device)
{
int idx;
- snd_rawmidi_t *rmidi = snd_magic_cast(snd_rawmidi_t, device->device_data, return -ENXIO);
+ snd_rawmidi_t *rmidi = device->device_data;
snd_assert(rmidi != NULL, return -ENXIO);
down(®ister_mutex);