Skip to content

L
linux
Commit a3954fd2 authored by Jaroslav Kysela's avatar Jaroslav Kysela Committed by Jaroslav Kysela
Browse files
Options

[PATCH] ALSA update [4/12] - 2002/08/14 

  - added USB Audio and USB MIDI drivers
  - VIA686
    - AC97 cold reset only when AC-link is down
parent 8122d638
Show whitespace changes
Inline Side-by-side
Showing with 4930 additions and 2 deletions
include/sound/version.h
View file @ a3954fd2
/* include/version.h. Generated automatically by configure. */ /* include/version.h. Generated automatically by configure. */
#define CONFIG_SND_VERSION "0.9.0rc2" #define CONFIG_SND_VERSION "0.9.0rc2"
#define CONFIG_SND_DATE " (Tue Aug 13 16:29:18 2002 UTC)" #define CONFIG_SND_DATE " (Wed Aug 14 17:22:18 2002 UTC)"
sound/Makefile
View file @ a3954fd2
...@@ -5,7 +5,7 @@ export-objs := sound_core.o ...@@ -5,7 +5,7 @@ export-objs := sound_core.o
obj-$(CONFIG_SOUND) += soundcore.o obj-$(CONFIG_SOUND) += soundcore.o
obj-$(CONFIG_SOUND_PRIME) += oss/ obj-$(CONFIG_SOUND_PRIME) += oss/
obj-$(CONFIG_SND) += core/ i2c/ drivers/ isa/ pci/ ppc/ arm/ synth/ sparc/ obj-$(CONFIG_SND) += core/ i2c/ drivers/ isa/ pci/ ppc/ arm/ synth/ usb/ sparc/
ifeq ($(CONFIG_SND),y) ifeq ($(CONFIG_SND),y)
obj-y += last.o obj-y += last.o
......
sound/pci/via686.c
View file @ a3954fd2
...@@ -878,6 +878,16 @@ static int __devinit snd_via686a_chip_init(via686a_t *chip) ...@@ -878,6 +878,16 @@ static int __devinit snd_via686a_chip_init(via686a_t *chip)
udelay(100); udelay(100);
} }
/* Make sure VRA is enabled, in case we didn't do a
* complete codec reset, above */
pci_read_config_byte(chip->pci, 0x41, &pval);
if ((pval & 0xcc) != 0xcc) {
/* ACLink on, deassert ACLink reset, VSR, SGD data out */
/* note - FM data out has trouble with non VRA codecs !! */
pci_write_config_byte(chip->pci, 0x41, 0xcc);
udelay(100);
}
/* wait until codec ready */ /* wait until codec ready */
max_count = ((3 * HZ) / 4) + 1; max_count = ((3 * HZ) / 4) + 1;
do { do {
......
sound/usb/Config.help 0 → 100644
View file @ a3954fd2
CONFIG_SND_USB_AUDIO
Say 'Y' or 'M' to include support for USB audio devices.
CONFIG_SND_USB_MIDI
Say 'Y' or 'M' to include support for MIDI devices connected via USB.
sound/usb/Config.in 0 → 100644
View file @ a3954fd2
# ALSA USB drivers
mainmenu_option next_comment
comment 'ALSA USB devices'
dep_tristate 'USB Audio driver' CONFIG_SND_USB_AUDIO $CONFIG_SND
dep_tristate 'USB MIDI driver' CONFIG_SND_USB_MIDI $CONFIG_SND $CONFIG_SND_SEQUENCER
endmenu
sound/usb/Makefile 0 → 100644
View file @ a3954fd2
#
# Makefile for ALSA
#
snd-usb-audio-objs := usbaudio.o usbmixer.o
snd-usb-midi-objs := usbmidi.o
# Toplevel Module Dependency
obj-$(CONFIG_SND_USB_AUDIO) += snd-usb-audio.o
obj-$(CONFIG_SND_USB_MIDI) += snd-usb-midi.o
include $(TOPDIR)/Rules.make
sound/usb/usbaudio.c 0 → 100644
View file @ a3954fd2
/*
* (Tentative) USB Audio Driver for ALSA
*
* Main and PCM part
*
* Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
*
* Many codes borrowed from audio.c by
* Alan Cox (alan@lxorguk.ukuu.org.uk)
* Thomas Sailer (sailer@ife.ee.ethz.ch)
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <sound/driver.h>
#include <linux/bitops.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/usb.h>
#include <sound/core.h>
#include <sound/info.h>
#include <sound/pcm.h>
#define SNDRV_GET_ID
#include <sound/initval.h>
#include "usbaudio.h"
MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
MODULE_DESCRIPTION("USB Audio");
MODULE_LICENSE("GPL");
MODULE_CLASSES("{sound}");
MODULE_DEVICES("{{Generic,USB Audio}}");
static int snd_index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
static char *snd_id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
static int snd_enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */
MODULE_PARM(snd_index, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
MODULE_PARM_DESC(snd_index, "Index value for the USB audio adapter.");
MODULE_PARM_SYNTAX(snd_index, SNDRV_INDEX_DESC);
MODULE_PARM(snd_id, "1-" __MODULE_STRING(SNDRV_CARDS) "s");
MODULE_PARM_DESC(snd_id, "ID string for the USB audio adapter.");
MODULE_PARM_SYNTAX(snd_id, SNDRV_ID_DESC);
MODULE_PARM(snd_enable, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
MODULE_PARM_DESC(snd_enable, "Enable USB audio adapter.");
MODULE_PARM_SYNTAX(snd_enable, SNDRV_ENABLE_DESC);
/*
*
*/
#define NRPACKS 4 /* 4ms per urb */
#define MAX_URBS 5 /* max. 20ms long packets */
#define SYNC_URBS 2 /* always two urbs for sync */
#define MIN_PACKS_URB 1 /* minimum 1 packet per urb */
typedef struct snd_usb_substream snd_usb_substream_t;
typedef struct snd_usb_stream snd_usb_stream_t;
typedef struct snd_urb_ctx snd_urb_ctx_t;
struct audioformat {
struct list_head list;
snd_pcm_format_t format; /* format type */
int channels; /* # channels */
unsigned char altsetting; /* corresponding alternate setting */
unsigned char altset_idx; /* array index of altenate setting */
unsigned char attributes; /* corresponding attributes of cs endpoint */
unsigned char endpoint; /* endpoint */
unsigned char ep_attr; /* endpoint attributes */
unsigned int rates; /* rate bitmasks */
int rate_min, rate_max; /* min/max rates */
int nr_rates; /* number of rate table entries */
int *rate_table; /* rate table */
};
struct snd_urb_ctx {
struct urb *urb;
snd_usb_substream_t *subs;
int index; /* index for urb array */
int packets; /* number of packets per urb */
int transfer; /* transferred size */
char *buf; /* buffer for capture */
};
struct snd_urb_ops {
int (*prepare)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u);
int (*retire)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u);
int (*prepare_sync)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u);
int (*retire_sync)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u);
};
struct snd_usb_substream {
snd_usb_stream_t *stream;
struct usb_device *dev;
snd_pcm_substream_t *pcm_substream;
int interface; /* Interface number, -1 means not used */
unsigned int format; /* USB data format */
unsigned int datapipe; /* the data i/o pipe */
unsigned int syncpipe; /* 1 - async out or adaptive in */
unsigned int syncinterval; /* P for adaptive mode, 0 otherwise */
unsigned int freqn; /* nominal sampling rate in USB format, i.e. fs/1000 in Q10.14 */
unsigned int freqm; /* momentary sampling rate in USB format, i.e. fs/1000 in Q10.14 */
unsigned int freqmax; /* maximum sampling rate, used for buffer management */
unsigned int phase; /* phase accumulator */
unsigned int maxpacksize; /* max packet size in bytes */
unsigned int maxframesize; /* max packet size in frames */
unsigned int curpacksize; /* current packet size in bytes */
unsigned int curframesize; /* current packet size in frames */
unsigned int fill_max: 1; /* fill max packet size always */
unsigned int running: 1; /* running status */
int hwptr; /* free frame position in the buffer (only for playback) */
int hwptr_done; /* processed frame position in the buffer */
int transfer_sched; /* scheduled frames since last period (for playback) */
int transfer_done; /* processed frames since last period update */
unsigned long active_mask; /* bitmask of active urbs */
unsigned long unlink_mask; /* bitmask of unlinked urbs */
int nurbs; /* # urbs */
snd_urb_ctx_t dataurb[MAX_URBS]; /* data urb table */
snd_urb_ctx_t syncurb[SYNC_URBS]; /* sync urb table */
char syncbuf[SYNC_URBS * NRPACKS * 3]; /* sync buffer; it's so small - let's get static */
char *tmpbuf; /* temporary buffer for playback */
u64 formats; /* format bitmasks (all or'ed) */
int num_formats; /* number of supported audio formats (list) */
struct list_head fmt_list; /* format list */
spinlock_t lock;
struct snd_urb_ops ops; /* callbacks (must be filled at init) */
};
struct snd_usb_stream {
snd_usb_audio_t *chip;
snd_pcm_t *pcm;
int pcm_index;
snd_usb_substream_t substream[2];
struct list_head list;
snd_info_entry_t *proc_entry;
};
#define chip_t snd_usb_stream_t
/*
* we keep the snd_usb_audio_t instances by ourselves for merging
* the all interfaces on the same card as one sound device.
*/
static DECLARE_MUTEX(register_mutex);
static snd_usb_audio_t *usb_chip[SNDRV_CARDS];
/*
* convert a sampling rate into USB format (fs/1000 in Q10.14)
* this will overflow at approx 2MSPS
*/
inline static unsigned get_usb_rate(unsigned int rate)
{
return ((rate << 11) + 62) / 125;
}
/*
* prepare urb for capture sync pipe
*
* fill the length and offset of each urb descriptor.
* the fixed 10.14 frequency is passed through the pipe.
*/
static int prepare_capture_sync_urb(snd_usb_substream_t *subs,
snd_pcm_runtime_t *runtime,
struct urb *urb)
{
unsigned char *cp = urb->transfer_buffer;
snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
int i, offs;
urb->number_of_packets = ctx->packets;
urb->dev = ctx->subs->dev; /* we need to set this at each time */
for (i = offs = 0; i < urb->number_of_packets; i++, offs += 3, cp += 3) {
urb->iso_frame_desc[i].length = 3;
urb->iso_frame_desc[i].offset = offs;
cp[0] = subs->freqn;
cp[1] = subs->freqn >> 8;
cp[2] = subs->freqn >> 16;
}
urb->interval = 1;
return 0;
}
/*
* process after capture sync complete
* - nothing to do
*/
static int retire_capture_sync_urb(snd_usb_substream_t *subs,
snd_pcm_runtime_t *runtime,
struct urb *urb)
{
return 0;
}
/*
* prepare urb for capture data pipe
*
* fill the offset and length of each descriptor.
*
* we use a temporary buffer to write the captured data.
* since the length of written data is determined by host, we cannot
* write onto the pcm buffer directly... the data is thus copied
* later at complete callback to the global buffer.
*/
static int prepare_capture_urb(snd_usb_substream_t *subs,
snd_pcm_runtime_t *runtime,
struct urb *urb)
{
int i, offs;
unsigned long flags;
snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
offs = 0;
urb->dev = ctx->subs->dev; /* we need to set this at each time */
urb->number_of_packets = 0;
spin_lock_irqsave(&subs->lock, flags);
for (i = 0; i < ctx->packets; i++) {
urb->iso_frame_desc[i].offset = offs;
urb->iso_frame_desc[i].length = subs->curpacksize;
offs += subs->curpacksize;
urb->number_of_packets++;
subs->transfer_sched += subs->curframesize;
if (subs->transfer_sched >= runtime->period_size) {
subs->transfer_sched -= runtime->period_size;
break;
}
}
spin_unlock_irqrestore(&subs->lock, flags);
urb->transfer_buffer = ctx->buf;
urb->transfer_buffer_length = offs;
urb->interval = 1;
return 0;
}
/*
* process after capture complete
*
* copy the data from each desctiptor to the pcm buffer, and
* update the current position.
*/
static int retire_capture_urb(snd_usb_substream_t *subs,
snd_pcm_runtime_t *runtime,
struct urb *urb)
{
unsigned long flags;
unsigned char *cp;
int stride, i, len, oldptr;
stride = runtime->frame_bits >> 3;
for (i = 0; i < urb->number_of_packets; i++) {
cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset;
if (urb->iso_frame_desc[i].status) /* active? hmm, skip this */
continue;
len = urb->iso_frame_desc[i].actual_length / stride;
if (! len)
continue;
/* update the current pointer */
spin_lock_irqsave(&subs->lock, flags);
oldptr = subs->hwptr_done;
subs->hwptr_done += len;
if (subs->hwptr_done >= runtime->buffer_size)
subs->hwptr_done -= runtime->buffer_size;
subs->transfer_done += len;
spin_unlock_irqrestore(&subs->lock, flags);
/* copy a data chunk */
if (oldptr + len > runtime->buffer_size) {
int cnt = runtime->buffer_size - oldptr;
int blen = cnt * stride;
memcpy(runtime->dma_area + oldptr * stride, cp, blen);
memcpy(runtime->dma_area, cp + blen, len * stride - blen);
} else {
memcpy(runtime->dma_area + oldptr * stride, cp, len * stride);
}
/* update the pointer, call callback if necessary */
spin_lock_irqsave(&subs->lock, flags);
if (subs->transfer_done >= runtime->period_size) {
subs->transfer_done -= runtime->period_size;
spin_unlock_irqrestore(&subs->lock, flags);
snd_pcm_period_elapsed(subs->pcm_substream);
} else
spin_unlock_irqrestore(&subs->lock, flags);
}
return 0;
}
/*
* prepare urb for playback sync pipe
*
* set up the offset and length to receive the current frequency.
*/
static int prepare_playback_sync_urb(snd_usb_substream_t *subs,
snd_pcm_runtime_t *runtime,
struct urb *urb)
{
int i, offs;
snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
urb->number_of_packets = ctx->packets;
urb->dev = ctx->subs->dev; /* we need to set this at each time */
for (i = offs = 0; i < urb->number_of_packets; i++, offs += 3) {
urb->iso_frame_desc[i].length = 3;
urb->iso_frame_desc[i].offset = offs;
}
return 0;
}
/*
* process after playback sync complete
*
* retrieve the current 10.14 frequency from pipe, and set it.
* the value is referred in prepare_playback_urb().
*/
static int retire_playback_sync_urb(snd_usb_substream_t *subs,
snd_pcm_runtime_t *runtime,
struct urb *urb)
{
unsigned int f, i, found;
unsigned char *cp = urb->transfer_buffer;
unsigned long flags;
found = 0;
for (i = 0; i < urb->number_of_packets; i++, cp += 3) {
if (urb->iso_frame_desc[i].status ||
urb->iso_frame_desc[i].actual_length < 3)
continue;
f = combine_triple(cp);
if (f < subs->freqn - (subs->freqn>>3) || f > subs->freqmax) {
snd_printd(KERN_WARNING "requested frequency %u (nominal %u) out of range!\n", f, subs->freqn);
continue;
}
found = f;
}
if (found) {
spin_lock_irqsave(&subs->lock, flags);
subs->freqm = found;
spin_unlock_irqrestore(&subs->lock, flags);
}
return 0;
}
/*
* prepare urb for playback data pipe
*
* we copy the data directly from the pcm buffer.
* the current position to be copied is held in hwptr field.
* since a urb can handle only a single linear buffer, if the total
* transferred area overflows the buffer boundary, we cannot send
* it directly from the buffer. thus the data is once copied to
* a temporary buffer and urb points to that.
*/
static int prepare_playback_urb(snd_usb_substream_t *subs,
snd_pcm_runtime_t *runtime,
struct urb *urb)
{
int i, stride, offs;
int counts;
unsigned long flags;
snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
stride = runtime->frame_bits >> 3;
offs = 0;
urb->dev = ctx->subs->dev; /* we need to set this at each time */
urb->number_of_packets = 0;
spin_lock_irqsave(&subs->lock, flags);
for (i = 0; i < ctx->packets; i++) {
/* calculate the size of a packet */
if (subs->fill_max)
counts = subs->maxframesize; /* fixed */
else {
subs->phase = (subs->phase & 0x3fff) + subs->freqm;
counts = subs->phase >> 14;
if (counts > subs->maxframesize)
counts = subs->maxframesize;
}
/* set up descriptor */
urb->iso_frame_desc[i].offset = offs * stride;
urb->iso_frame_desc[i].length = counts * stride;
offs += counts;
urb->number_of_packets++;
subs->transfer_sched += counts;
if (subs->transfer_sched >= runtime->period_size) {
subs->transfer_sched -= runtime->period_size;
break;
}
}
if (subs->hwptr + offs > runtime->buffer_size) {
/* err, the transferred area goes over buffer boundary.
* copy the data to the temp buffer.
*/
int len;
len = runtime->buffer_size - subs->hwptr;
urb->transfer_buffer = subs->tmpbuf;
memcpy(subs->tmpbuf, runtime->dma_area + subs->hwptr * stride, len * stride);
memcpy(subs->tmpbuf + len * stride, runtime->dma_area, (offs - len) * stride);
subs->hwptr += offs;
subs->hwptr -= runtime->buffer_size;
} else {
/* set the buffer pointer */
urb->transfer_buffer = runtime->dma_area + subs->hwptr * stride;
subs->hwptr += offs;
}
spin_unlock_irqrestore(&subs->lock, flags);
urb->transfer_buffer_length = offs * stride;
ctx->transfer = offs;
return 0;
}
/*
* process after playback data complete
*
* update the current position and call callback if a period is processed.
*/
static int retire_playback_urb(snd_usb_substream_t *subs,
snd_pcm_runtime_t *runtime,
struct urb *urb)
{
unsigned long flags;
snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
spin_lock_irqsave(&subs->lock, flags);
subs->transfer_done += ctx->transfer;
subs->hwptr_done += ctx->transfer;
ctx->transfer = 0;
if (subs->hwptr_done >= runtime->buffer_size)
subs->hwptr_done -= runtime->buffer_size;
if (subs->transfer_done >= runtime->period_size) {
subs->transfer_done -= runtime->period_size;
spin_unlock_irqrestore(&subs->lock, flags);
snd_pcm_period_elapsed(subs->pcm_substream);
} else
spin_unlock_irqrestore(&subs->lock, flags);
return 0;
}
/*
* complete callback from data urb
*/
static void snd_complete_urb(struct urb *urb)
{
snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
snd_usb_substream_t *subs = ctx->subs;
snd_pcm_substream_t *substream = ctx->subs->pcm_substream;
int err;
clear_bit(ctx->index, &subs->active_mask);
if (subs->running && subs->ops.retire(subs, substream->runtime, urb))
return;
if (! subs->running) /* can be stopped during retire callback */
return;
if ((err = subs->ops.prepare(subs, substream->runtime, urb) < 0) ||
(err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
snd_printd(KERN_ERR "cannot submit urb (err = %d)\n", err);
snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
return;
}
set_bit(ctx->index, &subs->active_mask);
}
/*
* complete callback from sync urb
*/
static void snd_complete_sync_urb(struct urb *urb)
{
snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
snd_usb_substream_t *subs = ctx->subs;
snd_pcm_substream_t *substream = ctx->subs->pcm_substream;
int err;
clear_bit(ctx->index + 16, &subs->active_mask);
if (subs->running && subs->ops.retire_sync(subs, substream->runtime, urb))
return;
if (! subs->running) /* can be stopped during retire callback */
return;
if ((err = subs->ops.prepare_sync(subs, substream->runtime, urb)) < 0 ||
(err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
snd_printd(KERN_ERR "cannot submit sync urb (err = %d)\n", err);
snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
return;
}
set_bit(ctx->index + 16, &subs->active_mask);
}
/*
* unlink active urbs.
* return the number of active urbs.
*/
static int deactivate_urbs(snd_usb_substream_t *subs)
{
int i, alive;
subs->running = 0;
alive = 0;
for (i = 0; i < subs->nurbs; i++) {
if (test_bit(i, &subs->active_mask)) {
alive++;
if (! test_and_set_bit(i, &subs->unlink_mask))
usb_unlink_urb(subs->dataurb[i].urb);
}
}
if (subs->syncpipe) {
for (i = 0; i < SYNC_URBS; i++) {
if (test_bit(i+16, &subs->active_mask)) {
alive++;
if (! test_and_set_bit(i+16, &subs->unlink_mask))
usb_unlink_urb(subs->syncurb[i].urb);
}
}
}
return alive;
}
/*
* set up and start data/sync urbs
*/
static int start_urbs(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime)
{
int i, err;
for (i = 0; i < subs->nurbs; i++) {
snd_assert(subs->dataurb[i].urb, return -EINVAL);
if (subs->ops.prepare(subs, runtime, subs->dataurb[i].urb) < 0) {
snd_printk(KERN_ERR "cannot prepare datapipe for urb %d\n", i);
goto __error;
}
}
if (subs->syncpipe) {
for (i = 0; i < SYNC_URBS; i++) {
snd_assert(subs->syncurb[i].urb, return -EINVAL);
if (subs->ops.prepare_sync(subs, runtime, subs->syncurb[i].urb) < 0) {
snd_printk(KERN_ERR "cannot prepare syncpipe for urb %d\n", i);
goto __error;
}
}
}
subs->running = 1;
for (i = 0; i < subs->nurbs; i++) {
if ((err = usb_submit_urb(subs->dataurb[i].urb, GFP_KERNEL)) < 0) {
snd_printk(KERN_ERR "cannot submit datapipe for urb %d, err = %d\n", i, err);
goto __error;
}
set_bit(i, &subs->active_mask);
}
if (subs->syncpipe) {
for (i = 0; i < SYNC_URBS; i++) {
if ((err = usb_submit_urb(subs->syncurb[i].urb, GFP_KERNEL)) < 0) {
snd_printk(KERN_ERR "cannot submit syncpipe for urb %d, err = %d\n", i, err);
goto __error;
}
set_bit(i + 16, &subs->active_mask);
}
}
return 0;
__error:
// snd_pcm_stop(subs->pcm_substream, SNDRV_PCM_STATE_XRUN);
deactivate_urbs(subs);
return -EPIPE;
}
/*
* wait until all urbs are processed.
*/
static int wait_clear_urbs(snd_usb_substream_t *subs)
{
int timeout = HZ;
int i, alive;
do {
alive = 0;
for (i = 0; i < subs->nurbs; i++) {
if (test_bit(i, &subs->active_mask))
alive++;
}
if (subs->syncpipe) {
for (i = 0; i < SYNC_URBS; i++) {
if (test_bit(i + 16, &subs->active_mask))
alive++;
}
}
if (! alive)
break;
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout(1);
set_current_state(TASK_RUNNING);
} while (--timeout > 0);
if (alive)
snd_printk(KERN_ERR "timeout: still %d active urbs..\n", alive);
return 0;
}
/*
* return the current pcm pointer. just return the hwptr_done value.
*/
static snd_pcm_uframes_t snd_usb_pcm_pointer(snd_pcm_substream_t *substream)
{
snd_usb_substream_t *subs = (snd_usb_substream_t *)substream->runtime->private_data;
return subs->hwptr_done;
}
/*
* start/stop substream
*/
static int snd_usb_pcm_trigger(snd_pcm_substream_t *substream, int cmd)
{
snd_usb_substream_t *subs = (snd_usb_substream_t *)substream->runtime->private_data;
int err;
switch (cmd) {
case SNDRV_PCM_TRIGGER_START:
err = start_urbs(subs, substream->runtime);
break;
case SNDRV_PCM_TRIGGER_STOP:
err = deactivate_urbs(subs);
break;
default:
err = -EINVAL;
break;
}
return err < 0 ? err : 0;
}
/*
* release a urb data
*/
static void release_urb_ctx(snd_urb_ctx_t *u)
{
if (u->urb) {
usb_free_urb(u->urb);
u->urb = 0;
}
if (u->buf) {
kfree(u->buf);
u->buf = 0;
}
}
/*
* release a substream
*/
static void release_substream_urbs(snd_usb_substream_t *subs)
{
int i;
/* stop urbs (to be sure) */
if (deactivate_urbs(subs) > 0)
wait_clear_urbs(subs);
for (i = 0; i < MAX_URBS; i++)
release_urb_ctx(&subs->dataurb[i]);
for (i = 0; i < SYNC_URBS; i++)
release_urb_ctx(&subs->syncurb[i]);
if (subs->tmpbuf) {
kfree(subs->tmpbuf);
subs->tmpbuf = 0;
}
subs->nurbs = 0;
}
/*
* initialize a substream for plaback/capture
*/
static int init_substream_urbs(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime)
{
int maxsize, n, i;
int is_playback = subs->pcm_substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
int npacks[MAX_URBS], total_packs;
/* calculate the frequency in 10.14 format */
subs->freqn = subs->freqm = get_usb_rate(runtime->rate);
subs->freqmax = subs->freqn + (subs->freqn >> 2); /* max. allowed frequency */
subs->phase = 0;
/* reset the pointer */
subs->hwptr = 0;
subs->hwptr_done = 0;
subs->transfer_sched = 0;
subs->transfer_done = 0;
subs->active_mask = 0;
subs->unlink_mask = 0;
/* calculate the max. size of packet */
maxsize = ((subs->freqmax + 0x3fff) * (runtime->frame_bits >> 3)) >> 14;
if (subs->maxpacksize && maxsize > subs->maxpacksize) {
//snd_printd(KERN_DEBUG "maxsize %d is greater than defined size %d\n",
// maxsize, subs->maxpacksize);
maxsize = subs->maxpacksize;
}
if (subs->fill_max)
subs->curpacksize = subs->maxpacksize;
else
subs->curpacksize = maxsize;
/* allocate a temporary buffer for playback */
if (is_playback) {
subs->tmpbuf = kmalloc(maxsize * NRPACKS, GFP_KERNEL);
if (! subs->tmpbuf) {
snd_printk(KERN_ERR "cannot malloc tmpbuf\n");
return -ENOMEM;
}
}
/* decide how many packets to be used */
total_packs = (frames_to_bytes(runtime, runtime->period_size) + maxsize - 1) / maxsize;
if (total_packs < 2 * MIN_PACKS_URB)
total_packs = 2 * MIN_PACKS_URB;
subs->nurbs = (total_packs + NRPACKS - 1) / NRPACKS;
if (subs->nurbs > MAX_URBS) {
/* too much... */
subs->nurbs = MAX_URBS;
total_packs = MAX_URBS * NRPACKS;
}
n = total_packs;
for (i = 0; i < subs->nurbs; i++) {
npacks[i] = n > NRPACKS ? NRPACKS : n;
n -= NRPACKS;
}
if (subs->nurbs <= 1) {
/* too little - we need at least two packets
* to ensure contiguous playback/capture
*/
subs->nurbs = 2;
npacks[0] = (total_packs + 1) / 2;
npacks[1] = total_packs - npacks[0];
} else if (npacks[subs->nurbs-1] < MIN_PACKS_URB) {
/* the last packet is too small.. */
if (subs->nurbs > 2) {
/* merge to the first one */
npacks[0] += npacks[subs->nurbs - 1];
subs->nurbs--;
} else {
/* divide to two */
subs->nurbs = 2;
npacks[0] = (total_packs + 1) / 2;
npacks[1] = total_packs - npacks[0];
}
}
/* allocate and initialize data urbs */
for (i = 0; i < subs->nurbs; i++) {
snd_urb_ctx_t *u = &subs->dataurb[i];
u->index = i;
u->subs = subs;
u->transfer = 0;
u->packets = npacks[i];
if (! is_playback) {
/* allocate a capture buffer per urb */
u->buf = kmalloc(maxsize * u->packets, GFP_KERNEL);
if (! u->buf) {
release_substream_urbs(subs);
return -ENOMEM;
}
}
u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
if (! u->urb) {
release_substream_urbs(subs);
return -ENOMEM;
}
u->urb->dev = subs->dev;
u->urb->pipe = subs->datapipe;
u->urb->transfer_flags = USB_ISO_ASAP | USB_ASYNC_UNLINK;
u->urb->number_of_packets = u->packets;
u->urb->context = u;
u->urb->complete = snd_complete_urb;
}
if (subs->syncpipe) {
/* allocate and initialize sync urbs */
for (i = 0; i < SYNC_URBS; i++) {
snd_urb_ctx_t *u = &subs->syncurb[i];
u->index = i;
u->subs = subs;
u->packets = NRPACKS;
u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
if (! u->urb) {
release_substream_urbs(subs);
return -ENOMEM;
}
u->urb->transfer_buffer = subs->syncbuf + i * NRPACKS * 3;
u->urb->transfer_buffer_length = NRPACKS * 3;
u->urb->dev = subs->dev;
u->urb->pipe = subs->syncpipe;
u->urb->transfer_flags = USB_ISO_ASAP | USB_ASYNC_UNLINK;
u->urb->number_of_packets = u->packets;
u->urb->context = u;
u->urb->complete = snd_complete_sync_urb;
}
}
return 0;
}
/*
* find a matching audio format
*/
static struct audioformat *find_format(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime)
{
struct list_head *p;
list_for_each(p, &subs->fmt_list) {
struct audioformat *fp;
fp = list_entry(p, struct audioformat, list);
if (fp->format != runtime->format ||
fp->channels != runtime->channels)
continue;
if (runtime->rate < fp->rate_min || runtime->rate > fp->rate_max)
continue;
if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)
return fp;
else {
int i;
for (i = 0; i < fp->nr_rates; i++)
if (fp->rate_table[i] == runtime->rate)
return fp;
}
}
return NULL;
}
/*
* find a matching format and set up the interface
*/
static int set_format(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime)
{
struct usb_device *dev = subs->dev;
struct usb_config_descriptor *config = dev->actconfig;
struct usb_interface_descriptor *alts;
struct usb_interface *iface;
struct audioformat *fmt;
unsigned int ep, attr;
unsigned char data[3];
int is_playback = subs->pcm_substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
int err;
fmt = find_format(subs, runtime);
if (! fmt) {
snd_printd(KERN_DEBUG "cannot set format: format = %s, rate = %d, channels = %d\n",
snd_pcm_format_name(runtime->format), runtime->rate, runtime->channels);
return -EINVAL;
}
iface = &config->interface[subs->interface];
alts = &iface->altsetting[fmt->altset_idx];
snd_assert(alts->bAlternateSetting == fmt->altsetting, return -EINVAL);
/* create a data pipe */
ep = alts->endpoint[0].bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
if (is_playback)
subs->datapipe = usb_sndisocpipe(dev, ep);
else
subs->datapipe = usb_rcvisocpipe(dev, ep);
subs->format = fmt->altset_idx;
subs->syncpipe = subs->syncinterval = 0;
subs->maxpacksize = alts->endpoint[0].wMaxPacketSize;
subs->maxframesize = bytes_to_frames(runtime, subs->maxpacksize);
subs->fill_max = 0;
/* we need a sync pipe in async OUT or adaptive IN mode */
attr = alts->endpoint[0].bmAttributes & EP_ATTR_MASK;
if ((is_playback && attr == EP_ATTR_ASYNC) ||
(! is_playback && attr == EP_ATTR_ADAPTIVE)) {
/* check endpoint */
if (alts->bNumEndpoints < 2 ||
alts->endpoint[1].bmAttributes != 0x01 ||
alts->endpoint[1].bSynchAddress != 0) {
snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
dev->devnum, subs->interface, fmt->altsetting);
return -EINVAL;
}
ep = alts->endpoint[1].bEndpointAddress;
if ((is_playback && ep != (alts->endpoint[0].bSynchAddress | USB_DIR_IN)) ||
(! is_playback && ep != (alts->endpoint[0].bSynchAddress & ~USB_DIR_IN))) {
snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
dev->devnum, subs->interface, fmt->altsetting);
return -EINVAL;
}
ep &= USB_ENDPOINT_NUMBER_MASK;
if (is_playback)
subs->syncpipe = usb_rcvisocpipe(dev, ep);
else
subs->syncpipe = usb_sndisocpipe(dev, ep);
subs->syncinterval = alts->endpoint[1].bRefresh;
}
/* set interface */
if (usb_set_interface(dev, subs->interface, fmt->altset_idx) < 0) {
snd_printk(KERN_ERR "%d:%d:%d: usb_set_interface failed\n",
dev->devnum, subs->interface, fmt->altsetting);
return -EIO;
}
ep = usb_pipeendpoint(subs->datapipe) | (subs->datapipe & USB_DIR_IN);
/* if endpoint has pitch control, enable it */
if (fmt->attributes & EP_CS_ATTR_PITCH_CONTROL) {
data[0] = 1;
if ((err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
PITCH_CONTROL << 8, ep, data, 1, HZ)) < 0) {
snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH\n",
dev->devnum, subs->interface, ep);
return err;
}
}
/* if endpoint has sampling rate control, set it */
if (fmt->attributes & EP_CS_ATTR_SAMPLE_RATE) {
data[0] = runtime->rate;
data[1] = runtime->rate >> 8;
data[2] = runtime->rate >> 16;
if ((err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
SAMPLING_FREQ_CONTROL << 8, ep, data, 3, HZ)) < 0) {
snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep 0x%x\n",
dev->devnum, subs->interface, fmt->altsetting, runtime->rate, ep);
return err;
}
if ((err = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR,
USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
SAMPLING_FREQ_CONTROL << 8, ep, data, 3, HZ)) < 0) {
snd_printk(KERN_ERR "%d:%d:%d: cannot get freq at ep 0x%x\n",
dev->devnum, subs->interface, fmt->altsetting, ep);
return err;
}
runtime->rate = data[0] | (data[1] << 8) | (data[2] << 16);
// printk("ok, getting back rate to %d\n", runtime->rate);
}
/* always fill max packet size */
if (fmt->attributes & EP_CS_ATTR_FILL_MAX)
subs->fill_max = 1;
#if 0
printk("setting done: format = %d, rate = %d, channels = %d\n",
runtime->format, runtime->rate, runtime->channels);
printk(" datapipe = 0x%0x, syncpipe = 0x%0x\n",
subs->datapipe, subs->syncpipe);
#endif
return 0;
}
/*
* allocate a buffer.
*
* so far we use a physically linear buffer although packetize transfer
* doesn't need a continuous area.
* if sg buffer is supported on the later version of alsa, we'll follow
* that.
*/
static int snd_usb_hw_params(snd_pcm_substream_t *substream,
snd_pcm_hw_params_t *hw_params)
{
return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
}
/*
* free the buffer
*/
static int snd_usb_hw_free(snd_pcm_substream_t *substream)
{
return snd_pcm_lib_free_pages(substream);
}
/*
* prepare callback
*
* set format and initialize urbs
*/
static int snd_usb_pcm_prepare(snd_pcm_substream_t *substream)
{
snd_pcm_runtime_t *runtime = substream->runtime;
snd_usb_substream_t *subs = (snd_usb_substream_t *)runtime->private_data;
int err;
release_substream_urbs(subs);
if ((err = set_format(subs, runtime)) < 0)
return err;
return init_substream_urbs(subs, runtime);
}
static snd_pcm_hardware_t snd_usb_playback =
{
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_BLOCK_TRANSFER |
SNDRV_PCM_INFO_MMAP_VALID),
.buffer_bytes_max = (128*1024),
.period_bytes_min = 64,
.period_bytes_max = (128*1024),
.periods_min = 2,
.periods_max = 1024,
};
static snd_pcm_hardware_t snd_usb_capture =
{
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_BLOCK_TRANSFER |
SNDRV_PCM_INFO_MMAP_VALID),
.buffer_bytes_max = (128*1024),
.period_bytes_min = 64,
.period_bytes_max = (128*1024),
.periods_min = 2,
.periods_max = 1024,
};
/*
* set up the runtime hardware information.
*/
static void setup_hw_info(snd_pcm_runtime_t *runtime, snd_usb_substream_t *subs)
{
struct list_head *p;
runtime->hw.formats = subs->formats;
runtime->hw.rate_min = 0x7fffffff;
runtime->hw.rate_max = 0;
runtime->hw.channels_min = 256;
runtime->hw.channels_max = 0;
runtime->hw.rates = 0;
/* check min/max rates and channels */
list_for_each(p, &subs->fmt_list) {
struct audioformat *fp;
fp = list_entry(p, struct audioformat, list);
runtime->hw.rates |= fp->rates;
if (runtime->hw.rate_min > fp->rate_min)
runtime->hw.rate_min = fp->rate_min;
if (runtime->hw.rate_max < fp->rate_max)
runtime->hw.rate_max = fp->rate_max;
if (runtime->hw.channels_min > fp->channels)
runtime->hw.channels_min = fp->channels;
if (runtime->hw.channels_max < fp->channels)
runtime->hw.channels_max = fp->channels;
}
/* set the period time minimum 1ms */
snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME,
1000 * MIN_PACKS_URB,
/*(NRPACKS * MAX_URBS) * 1000*/ UINT_MAX);
/* FIXME: we need more constraints to restrict the format type,
* channels and rates according to the audioformat list!
*/
}
static int snd_usb_pcm_open(snd_pcm_substream_t *substream, int direction,
snd_pcm_hardware_t *hw)
{
snd_usb_stream_t *as = snd_pcm_substream_chip(substream);
snd_pcm_runtime_t *runtime = substream->runtime;
snd_usb_substream_t *subs = &as->substream[direction];
runtime->hw = *hw;
runtime->private_data = subs;
subs->pcm_substream = substream;
setup_hw_info(runtime, subs);
return 0;
}
static int snd_usb_pcm_close(snd_pcm_substream_t *substream, int direction)
{
snd_usb_stream_t *as = snd_pcm_substream_chip(substream);
snd_usb_substream_t *subs = &as->substream[direction];
release_substream_urbs(subs);
usb_set_interface(subs->dev, subs->interface, 0);
subs->pcm_substream = NULL;
return 0;
}
static int snd_usb_playback_open(snd_pcm_substream_t *substream)
{
return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_PLAYBACK, &snd_usb_playback);
}
static int snd_usb_playback_close(snd_pcm_substream_t *substream)
{
return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_PLAYBACK);
}
static int snd_usb_capture_open(snd_pcm_substream_t *substream)
{
return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_CAPTURE, &snd_usb_capture);
}
static int snd_usb_capture_close(snd_pcm_substream_t *substream)
{
return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_CAPTURE);
}
static snd_pcm_ops_t snd_usb_playback_ops = {
.open = snd_usb_playback_open,
.close = snd_usb_playback_close,
.ioctl = snd_pcm_lib_ioctl,
.hw_params = snd_usb_hw_params,
.hw_free = snd_usb_hw_free,
.prepare = snd_usb_pcm_prepare,
.trigger = snd_usb_pcm_trigger,
.pointer = snd_usb_pcm_pointer,
};
static snd_pcm_ops_t snd_usb_capture_ops = {
.open = snd_usb_capture_open,
.close = snd_usb_capture_close,
.ioctl = snd_pcm_lib_ioctl,
.hw_params = snd_usb_hw_params,
.hw_free = snd_usb_hw_free,
.prepare = snd_usb_pcm_prepare,
.trigger = snd_usb_pcm_trigger,
.pointer = snd_usb_pcm_pointer,
};
/*
* helper functions
*/
/*
* combine bytes and get an integer value
*/
unsigned int snd_usb_combine_bytes(unsigned char *bytes, int size)
{
switch (size) {
case 1: return *bytes;
case 2: return combine_word(bytes);
case 3: return combine_triple(bytes);
case 4: return combine_quad(bytes);
default: return 0;
}
}
/*
* parse descriptor buffer and return the pointer starting the given
* descriptor type and interface.
* if altsetting is not -1, seek the buffer until the matching alternate
* setting is found.
*/
void *snd_usb_find_desc(void *descstart, int desclen, void *after,
u8 dtype, int iface, int altsetting)
{
u8 *p, *end, *next;
int ifc = -1, as = -1;
p = descstart;
end = p + desclen;
for (; p < end;) {
if (p[0] < 2)
return NULL;
next = p + p[0];
if (next > end)
return NULL;
if (p[1] == USB_DT_INTERFACE) {
/* minimum length of interface descriptor */
if (p[0] < 9)
return NULL;
ifc = p[2];
as = p[3];
}
if (p[1] == dtype && (!after || (void *)p > after) &&
(iface == -1 || iface == ifc) && (altsetting == -1 || altsetting == as)) {
return p;
}
p = next;
}
return NULL;
}
/*
* find a class-specified interface descriptor with the given subtype.
*/
void *snd_usb_find_csint_desc(void *buffer, int buflen, void *after, u8 dsubtype, int iface, int altsetting)
{
unsigned char *p = after;
while ((p = snd_usb_find_desc(buffer, buflen, p,
USB_DT_CS_INTERFACE, iface, altsetting)) != NULL) {
if (p[0] >= 3 && p[2] == dsubtype)
return p;
}
return NULL;
}
/*
* entry point for linux usb interface
*/
static void * usb_audio_probe(struct usb_device *dev, unsigned int ifnum,
const struct usb_device_id *id);
static void usb_audio_disconnect(struct usb_device *dev, void *ptr);
static struct usb_device_id usb_audio_ids [] = {
{ .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS),
.bInterfaceClass = USB_CLASS_AUDIO,
.bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL },
{ } /* Terminating entry */
};
MODULE_DEVICE_TABLE (usb, usb_audio_ids);
static struct usb_driver usb_audio_driver = {
.name = "snd-usb-audio",
.probe = usb_audio_probe,
.disconnect = usb_audio_disconnect,
.driver_list = LIST_HEAD_INIT(usb_audio_driver.driver_list),
.id_table = usb_audio_ids,
};
/*
* intialize the substream instance.
*/
static void init_substream(snd_usb_stream_t *stream, snd_usb_substream_t *subs,
int iface_no, int is_input,
unsigned char *buffer, int buflen)
{
struct usb_device *dev;
struct usb_config_descriptor *config;
struct usb_interface *iface;
struct usb_interface_descriptor *alts;
int i, pcm_format, altno;
int format, channels, format_type, nr_rates;
struct audioformat *fp;
unsigned char *fmt, *csep;
dev = stream->chip->dev;
config = dev->actconfig;
subs->stream = stream;
subs->dev = dev;
subs->interface = iface_no;
INIT_LIST_HEAD(&subs->fmt_list);
spin_lock_init(&subs->lock);
if (is_input) {
subs->ops.prepare = prepare_capture_urb;
subs->ops.retire = retire_capture_urb;
subs->ops.prepare_sync = prepare_capture_sync_urb;
subs->ops.retire_sync = retire_capture_sync_urb;
} else {
subs->ops.prepare = prepare_playback_urb;
subs->ops.retire = retire_playback_urb;
subs->ops.prepare_sync = prepare_playback_sync_urb;
subs->ops.retire_sync = retire_playback_sync_urb;
}
if (iface_no < 0)
return;
/* parse the interface's altsettings */
iface = &config->interface[iface_no];
for (i = 0; i < iface->num_altsetting; i++) {
alts = &iface->altsetting[i];
/* skip invalid one */
if (alts->bInterfaceClass != USB_CLASS_AUDIO ||
alts->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING ||
alts->bNumEndpoints < 1)
continue;
/* must be isochronous */
if ((alts->endpoint[0].bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
USB_ENDPOINT_XFER_ISOC)
continue;
/* check direction */
if (alts->endpoint[0].bEndpointAddress & USB_DIR_IN) {
if (! is_input)
continue;
} else {
if (is_input)
continue;
}
altno = alts->bAlternateSetting;
/* get audio formats */
fmt = snd_usb_find_csint_desc(buffer, buflen, NULL, AS_GENERAL, iface_no, altno);
if (!fmt) {
snd_printk(KERN_ERR "%d:%u:%d : AS_GENERAL descriptor not found\n",
dev->devnum, iface_no, altno);
continue;
}
if (fmt[0] < 7) {
snd_printk(KERN_ERR "%d:%u:%d : invalid AS_GENERAL desc\n",
dev->devnum, iface_no, altno);
continue;
}
format = (fmt[6] << 8) | fmt[5]; /* remember the format value */
/* get format type */
fmt = snd_usb_find_csint_desc(buffer, buflen, NULL, FORMAT_TYPE, iface_no, altno);
if (!fmt) {
snd_printk(KERN_ERR "%d:%u:%d : no FORMAT_TYPE desc\n",
dev->devnum, iface_no, altno);
continue;
}
if (fmt[0] < 8) {
snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n",
dev->devnum, iface_no, altno);
continue;
}
format_type = fmt[3];
/* FIXME: needed support for TYPE II and III */
if (format_type != USB_FORMAT_TYPE_I) {
snd_printd(KERN_INFO "%d:%u:%d : format type %d is not supported yet\n",
dev->devnum, iface_no, altno, format_type);
continue;
}
nr_rates = fmt[7];
if (fmt[0] < 8 + 3 * (nr_rates ? nr_rates : 2)) {
snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n",
dev->devnum, iface_no, altno);
continue;
}
/* FIXME: correct endianess and sign? */
pcm_format = -1;
switch (format) {
case USB_AUDIO_FORMAT_PCM:
/* check the format byte size */
switch (fmt[6]) {
case 8:
subs->formats |= SNDRV_PCM_FMTBIT_U8;
pcm_format = SNDRV_PCM_FORMAT_U8;
break;
case 16:
subs->formats |= SNDRV_PCM_FMTBIT_S16_LE;
pcm_format = SNDRV_PCM_FORMAT_S16_LE;
break;
case 18:
case 20:
if (fmt[5] == 3) {
subs->formats |= SNDRV_PCM_FMTBIT_S24_3LE;
pcm_format = SNDRV_PCM_FORMAT_S24_3LE;
} else {
snd_printk(KERN_ERR "%d:%u:%d : non-supported sample bit %d in %d bytes\n",
dev->devnum, iface_no, altno, fmt[6], fmt[5]);
}
break;
case 24:
if (fmt[5] == 4) {
/* FIXME: correct? or S32_LE? */
subs->formats |= SNDRV_PCM_FMTBIT_S24_LE;
pcm_format = SNDRV_PCM_FORMAT_S24_LE;
} else if (fmt[5] == 3) {
subs->formats |= SNDRV_PCM_FMTBIT_S24_3LE;
pcm_format = SNDRV_PCM_FORMAT_S24_3LE;
} else {
snd_printk(KERN_ERR "%d:%u:%d : non-supported sample bit %d in %d bytes\n",
dev->devnum, iface_no, altno, format, fmt[5]);
}
break;
case 32:
subs->formats |= SNDRV_PCM_FMTBIT_S32_LE;
pcm_format = SNDRV_PCM_FORMAT_S32_LE;
break;
default:
snd_printk(KERN_INFO "%d:%u:%d : unsupported sample bitwidth %d in %d bytes\n",
dev->devnum, iface_no, altno, fmt[6], fmt[5]);
break;
}
break;
case USB_AUDIO_FORMAT_PCM8:
/* Dallas DS4201 workaround */
if (dev->descriptor.idVendor == 0x04fa && dev->descriptor.idProduct == 0x4201) {
subs->formats |= ~SNDRV_PCM_FMTBIT_S8;
pcm_format = SNDRV_PCM_FORMAT_S8;
} else {
subs->formats |= SNDRV_PCM_FMTBIT_U8;
pcm_format = SNDRV_PCM_FORMAT_U8;
}
break;
case USB_AUDIO_FORMAT_IEEE_FLOAT:
subs->formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
pcm_format = SNDRV_PCM_FORMAT_FLOAT_LE;
break;
case USB_AUDIO_FORMAT_ALAW:
subs->formats |= SNDRV_PCM_FMTBIT_A_LAW;
pcm_format = SNDRV_PCM_FORMAT_A_LAW;
break;
case USB_AUDIO_FORMAT_MU_LAW:
subs->formats |= SNDRV_PCM_FMTBIT_MU_LAW;
pcm_format = SNDRV_PCM_FORMAT_MU_LAW;
break;
default:
snd_printk(KERN_INFO "%d:%u:%d : unsupported format type %d\n",
dev->devnum, iface_no, altno, format);
break;
}
if (pcm_format < 0)
continue;
channels = fmt[4];
if (channels < 1) {
snd_printk(KERN_ERR "%d:%u:%d : invalid channels %d\n",
dev->devnum, iface_no, altno, channels);
continue;
}
csep = snd_usb_find_desc(buffer, buflen, NULL, USB_DT_CS_ENDPOINT, iface_no, altno);
if (!csep || csep[0] < 7 || csep[2] != EP_GENERAL) {
snd_printk(KERN_ERR "%d:%u:%d : no or invalid class specific endpoint descriptor\n",
dev->devnum, iface_no, altno);
continue;
}
fp = kmalloc(sizeof(*fp), GFP_KERNEL);
if (! fp) {
snd_printk(KERN_ERR "cannot malloc\n");
break;
}
memset(fp, 0, sizeof(*fp));
fp->format = pcm_format;
fp->altsetting = altno;
fp->altset_idx = i;
fp->endpoint = alts->endpoint[0].bEndpointAddress;
fp->ep_attr = alts->endpoint[0].bmAttributes;
fp->channels = channels;
fp->attributes = csep[3];
if (nr_rates) {
/*
* build the rate table and bitmap flags
*/
int r, idx, c;
/* this table corresponds to the SNDRV_PCM_RATE_XXX bit */
static int conv_rates[] = {
5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000,
64000, 88200, 96000, 176400, 192000
};
fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
if (fp->rate_table == NULL) {
snd_printk(KERN_ERR "cannot malloc\n");
kfree(fp);
break;
}
fp->nr_rates = nr_rates;
fp->rate_min = fp->rate_max = combine_triple(&fmt[8]);
for (r = 0, idx = 8; r < nr_rates; r++, idx += 3) {
int rate = fp->rate_table[r] = combine_triple(&fmt[idx]);
if (rate < fp->rate_min)
fp->rate_min = rate;
else if (rate > fp->rate_max)
fp->rate_max = rate;
for (c = 0; c < 13; c++) {
if (rate == conv_rates[c]) {
fp->rates |= (1 << c);
break;
}
}
#if 0 // FIXME - we need to define constraint
if (c >= 13)
fp->rates |= SNDRV_PCM_KNOT; /* unconventional rate */
#endif
}
} else {
/* continuous rates */
fp->rates = SNDRV_PCM_RATE_CONTINUOUS;
fp->rate_min = combine_triple(&fmt[8]);
fp->rate_max = combine_triple(&fmt[11]);
}
list_add_tail(&fp->list, &subs->fmt_list);
subs->num_formats++;
}
}
/*
* free a substream
*/
static void free_substream(snd_usb_substream_t *subs)
{
struct list_head *p, *n;
if (subs->interface < 0)
return;
list_for_each_safe(p, n, &subs->fmt_list) {
struct audioformat *fp = list_entry(p, struct audioformat, list);
if (fp->rate_table)
kfree(fp->rate_table);
kfree(fp);
}
}
/*
* proc interface for list the supported pcm formats
*/
static void proc_dump_substream_formats(snd_usb_substream_t *subs, snd_info_buffer_t *buffer)
{
struct list_head *p;
static char *sync_types[4] = {
"NONE", "ASYNC", "ADAPTIVE", "SYNC"
};
list_for_each(p, &subs->fmt_list) {
struct audioformat *fp;
fp = list_entry(p, struct audioformat, list);
snd_iprintf(buffer, " Altset %d\n", fp->altset_idx);
snd_iprintf(buffer, " Format: %s\n", snd_pcm_format_name(fp->format));
snd_iprintf(buffer, " Channels: %d\n", fp->channels);
snd_iprintf(buffer, " Endpoint: %d %s (%s)\n",
fp->endpoint & USB_ENDPOINT_NUMBER_MASK,
fp->endpoint & USB_DIR_IN ? "IN" : "OUT",
sync_types[(fp->ep_attr & EP_ATTR_MASK) >> 2]);
if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) {
snd_iprintf(buffer, " Rates: %d - %d (continous)\n",
fp->rate_min, fp->rate_max);
} else {
int i;
snd_iprintf(buffer, " Rates: ");
for (i = 0; i < fp->nr_rates; i++) {
if (i > 0)
snd_iprintf(buffer, ", ");
snd_iprintf(buffer, "%d", fp->rate_table[i]);
}
snd_iprintf(buffer, "\n");
}
}
}
static void proc_dump_substream_status(snd_usb_substream_t *subs, snd_info_buffer_t *buffer)
{
if (subs->running) {
int i;
snd_iprintf(buffer, " Status: Running\n");
snd_iprintf(buffer, " Altset = %d\n", subs->format);
snd_iprintf(buffer, " URBs = %d [ ", subs->nurbs);
for (i = 0; i < subs->nurbs; i++)
snd_iprintf(buffer, "%d ", subs->dataurb[i].packets);
snd_iprintf(buffer, "]\n");
snd_iprintf(buffer, " Packet Size = %d\n", subs->curpacksize);
snd_iprintf(buffer, " Momentary freq = %d,%03d Hz\n",
subs->freqm >> 14,
((subs->freqm & ((1 << 14) - 1)) * 1000) / ((1 << 14) - 1));
} else {
snd_iprintf(buffer, " Status: Stop\n");
}
}
static void proc_pcm_format_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer)
{
snd_usb_stream_t *stream = snd_magic_cast(snd_usb_stream_t, entry->private_data, return);
snd_iprintf(buffer, "%s : %s\n", stream->chip->card->longname, stream->pcm->name);
if (stream->substream[SNDRV_PCM_STREAM_PLAYBACK].num_formats) {
snd_iprintf(buffer, "\nPlayback:\n");
proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
}
if (stream->substream[SNDRV_PCM_STREAM_CAPTURE].num_formats) {
snd_iprintf(buffer, "\nCapture:\n");
proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
}
}
static void proc_pcm_format_add(snd_usb_stream_t *stream)
{
snd_info_entry_t *entry;
char name[32];
snd_card_t *card = stream->chip->card;
sprintf(name, "stream%d", stream->pcm_index);
if ((entry = snd_info_create_card_entry(card, name, card->proc_root)) != NULL) {
entry->content = SNDRV_INFO_CONTENT_TEXT;
entry->private_data = stream;
entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
entry->c.text.read_size = 4096;
entry->c.text.read = proc_pcm_format_read;
if (snd_info_register(entry) < 0) {
snd_info_free_entry(entry);
entry = NULL;
}
}
stream->proc_entry = entry;
}
/*
* free a usb stream instance
*/
static void snd_usb_audio_stream_free(snd_usb_stream_t *stream)
{
if (stream->proc_entry) {
snd_info_unregister(stream->proc_entry);
stream->proc_entry = NULL;
}
free_substream(&stream->substream[0]);
free_substream(&stream->substream[1]);
list_del(&stream->list);
snd_magic_kfree(stream);
}
static void snd_usb_audio_pcm_free(snd_pcm_t *pcm)
{
snd_usb_stream_t *stream = pcm->private_data;
if (stream) {
stream->pcm = NULL;
snd_pcm_lib_preallocate_free_for_all(pcm);
snd_usb_audio_stream_free(stream);
}
}
static int snd_usb_audio_stream_new(snd_usb_audio_t *chip, unsigned char *buffer, int buflen, int asifin, int asifout)
{
snd_usb_stream_t *as;
snd_pcm_t *pcm;
char name[32];
int err;
as = snd_magic_kmalloc(snd_usb_stream_t, 0, GFP_KERNEL);
if (as == NULL) {
snd_printk(KERN_ERR "cannot malloc\n");
return -ENOMEM;
}
memset(as, 0, sizeof(*as));
as->chip = chip;
INIT_LIST_HEAD(&as->list);
init_substream(as, &as->substream[SNDRV_PCM_STREAM_PLAYBACK], asifout, 0, buffer, buflen);
init_substream(as, &as->substream[SNDRV_PCM_STREAM_CAPTURE], asifin, 1, buffer, buflen);
if (as->substream[0].num_formats == 0 && as->substream[1].num_formats == 0) {
snd_usb_audio_stream_free(as);
return 0;
}
if (chip->pcm_devs > 0)
sprintf(name, "USB Audio #%d", chip->pcm_devs);
else
strcpy(name, "USB Audio");
err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs,
as->substream[SNDRV_PCM_STREAM_PLAYBACK].num_formats ? 1 : 0,
as->substream[SNDRV_PCM_STREAM_CAPTURE].num_formats ? 1 : 0,
&pcm);
if (err < 0) {
snd_usb_audio_stream_free(as);
return err;
}
as->pcm = pcm;
as->pcm_index = chip->pcm_devs;
if (as->substream[SNDRV_PCM_STREAM_PLAYBACK].num_formats)
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_usb_playback_ops);
if (as->substream[SNDRV_PCM_STREAM_CAPTURE].num_formats)
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usb_capture_ops);
pcm->private_data = as;
pcm->private_free = snd_usb_audio_pcm_free;
pcm->info_flags = 0;
strcpy(pcm->name, name);
snd_pcm_lib_preallocate_pages_for_all(pcm, 64*1024, 128*1024, GFP_ATOMIC);
list_add(&as->list, &chip->pcm_list);
chip->pcm_devs++;
proc_pcm_format_add(as);
return 0;
}
/*
* parse audio control descriptor and create pcm streams
*/
static int snd_usb_create_pcm(snd_usb_audio_t *chip, int ctrlif,
unsigned char *buffer, int buflen)
{
struct usb_device *dev = chip->dev;
struct usb_config_descriptor *config;
struct usb_interface *iface;
unsigned char *p1;
unsigned char ifin[USB_MAXINTERFACES], ifout[USB_MAXINTERFACES];
int numifin = 0, numifout = 0;
int i, j, k;
/* find audiocontrol interface */
if (!(p1 = snd_usb_find_csint_desc(buffer, buflen, NULL, HEADER, ctrlif, -1))) {
snd_printk(KERN_ERR "cannot find HEADER\n");
return -EINVAL;
}
if (! p1[7] || p1[0] < 8 + p1[7]) {
snd_printk(KERN_ERR "invalid HEADER\n");
return -EINVAL;
}
/*
* parse all USB audio streaming interfaces
*/
config = dev->actconfig;
for (i = 0; i < p1[7]; i++) {
j = p1[8 + i];
if (j >= config->bNumInterfaces) {
snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",
dev->devnum, ctrlif, j);
continue;
}
iface = &config->interface[j];
if (iface->altsetting[0].bInterfaceClass != USB_CLASS_AUDIO ||
iface->altsetting[0].bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING) {
snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n", dev->devnum, ctrlif, j, iface->altsetting[0].bInterfaceClass);
/* skip non-supported classes */
continue;
}
if (iface->num_altsetting < 2) {
snd_printdd(KERN_ERR "%d:%u:%d: skipping - no valid interface.\n",
dev->devnum, ctrlif, j);
continue;
}
if (iface->altsetting[0].bNumEndpoints > 0) {
/* Check all endpoints; should they all have a bandwidth of 0 ? */
for (k = 0; k < iface->altsetting[0].bNumEndpoints; k++) {
if (iface->altsetting[0].endpoint[k].wMaxPacketSize > 0) {
snd_printk(KERN_ERR "%d:%u:%d ep%d : have no bandwith at alt[0]\n", dev->devnum, ctrlif, j, k);
break;
}
}
if (k < iface->altsetting[0].bNumEndpoints)
continue;
}
if (iface->altsetting[1].bNumEndpoints < 1) {
snd_printk(KERN_ERR "%d:%u:%d : has no endpoint\n",
dev->devnum, ctrlif, j);
continue;
}
/* note: this requires the data endpoint to be ep0 and
* the optional sync ep to be ep1, which seems to be the case
*/
if (iface->altsetting[1].endpoint[0].bEndpointAddress & USB_DIR_IN) {
if (numifin < USB_MAXINTERFACES) {
snd_printdd(KERN_INFO "adding an input interface %d:%u:%d\n", dev->devnum, ctrlif, j);
ifin[numifin++] = j;
usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1);
}
} else {
if (numifout < USB_MAXINTERFACES) {
snd_printdd(KERN_INFO "adding an output interface %d:%u:%d\n", dev->devnum, ctrlif, j);
ifout[numifout++] = j;
usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1);
}
}
}
/* all endpoints are parsed. now create pcm streams */
for (i = 0; i < numifin && i < numifout; i++)
snd_usb_audio_stream_new(chip, buffer, buflen, ifin[i], ifout[i]);
for (j = i; j < numifin; j++)
snd_usb_audio_stream_new(chip, buffer, buflen, ifin[i], -1);
for (j = i; j < numifout; j++)
snd_usb_audio_stream_new(chip, buffer, buflen, -1, ifout[i]);
return 0;
}
/*
* free the chip instance
*
* here we have to do not much, since pcm and controls are already freed
*
*/
static int snd_usb_audio_free(snd_usb_audio_t *chip)
{
down(&register_mutex);
usb_chip[chip->index] = NULL;
up(&register_mutex);
snd_magic_kfree(chip);
return 0;
}
static int snd_usb_audio_dev_free(snd_device_t *device)
{
snd_usb_audio_t *chip = snd_magic_cast(snd_usb_audio_t, device->device_data, return -ENXIO);
return snd_usb_audio_free(chip);
}
/*
* create a chip instance and set its names.
*/
static int snd_usb_audio_create(snd_card_t *card, struct usb_device *dev, snd_usb_audio_t **rchip)
{
snd_usb_audio_t *chip;
int err, len;
static snd_device_ops_t ops = {
dev_free: snd_usb_audio_dev_free,
};
*rchip = NULL;
chip = snd_magic_kcalloc(snd_usb_audio_t, 0, GFP_KERNEL);
if (! chip)
return -ENOMEM;
chip->dev = dev;
chip->card = card;
INIT_LIST_HEAD(&chip->pcm_list);
if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
snd_usb_audio_free(chip);
return err;
}
strcpy(card->driver, "USB-Audio");
strcpy(card->shortname, "USB Audio Driver");
/* retrieve the vendor and device strings as longname */
len = usb_string(dev, 1, card->longname, sizeof(card->longname) - 1);
if (len <= 0)
len = 0;
else {
card->longname[len] = ' ';
len++;
}
card->longname[len] = 0;
usb_string(dev, 2, card->longname + len, sizeof(card->longname) - len);
*rchip = chip;
return 0;
}
/*
* allocate and get description buffer
* must be freed later.
*/
static int alloc_desc_buffer(struct usb_device *dev, int index, unsigned char **bufptr)
{
int err, buflen;
unsigned char buf[8];
unsigned char *buffer;
*bufptr = 0;
err = usb_get_descriptor(dev, USB_DT_CONFIG, index, buf, 8);
if (err < 0) {
snd_printk(KERN_ERR "%d:%d: cannot get first 8 bytes\n", index, dev->devnum);
return err;
}
if (buf[1] != USB_DT_CONFIG || buf[0] < 9) {
snd_printk(KERN_ERR "%d:%d: invalid config desc\n", index, dev->devnum);
return -EINVAL;
}
buflen = combine_word(&buf[2]);
if (!(buffer = kmalloc(buflen, GFP_KERNEL))) {
snd_printk(KERN_ERR "cannot malloc descriptor (size = %d)\n", buflen);
return -ENOMEM;
}
err = usb_get_descriptor(dev, USB_DT_CONFIG, index, buffer, buflen);
if (err < 0) {
snd_printk(KERN_ERR "%d:%d: cannot get DT_CONFIG: error %d\n", index, dev->devnum, err);
kfree(buffer);
return err;
}
*bufptr = buffer;
return buflen;
}
/*
* probe the active usb device
*
* note that this can be called multiple times per a device, when it
* includes multiple audio control interfaces.
*
* thus we check the usb device pointer and creates the card instance
* only at the first time. the successive calls of this function will
* append the pcm interface to the corresponding card.
*/
static void *usb_audio_probe(struct usb_device *dev, unsigned int ifnum,
const struct usb_device_id *id)
{
struct usb_config_descriptor *config = dev->actconfig;
unsigned char *buffer;
unsigned int index;
int i, buflen;
snd_card_t *card;
snd_usb_audio_t *chip;
if (usb_set_configuration(dev, config->bConfigurationValue) < 0) {
snd_printk(KERN_ERR "cannot set configuration (value 0x%x)\n", config->bConfigurationValue);
return NULL;
}
index = dev->actconfig - config;
buflen = alloc_desc_buffer(dev, index, &buffer);
if (buflen <= 0)
return NULL;
/*
* found a config. now register to ALSA
*/
/* check whether it's already registered */
chip = NULL;
down(&register_mutex);
for (i = 0; i < SNDRV_CARDS; i++) {
if (usb_chip[i] && usb_chip[i]->dev == dev) {
chip = usb_chip[i];
break;
}
}
if (! chip) {
/* it's a fresh one.
* now look for an empty slot and create a new card instance
*/
for (i = 0; i < SNDRV_CARDS; i++)
if (snd_enable[i] && ! usb_chip[i]) {
card = snd_card_new(snd_index[i], snd_id[i], THIS_MODULE, 0);
if (card == NULL) {
snd_printk(KERN_ERR "cannot create a card instance %d\n", i);
goto __error;
}
if (snd_usb_audio_create(card, dev, &chip) < 0) {
snd_card_free(card);
goto __error;
}
chip->index = i;
usb_chip[i] = chip;
break;
}
if (! chip) {
snd_printk(KERN_ERR "no available usb audio device\n");
goto __error;
}
}
if (snd_usb_create_pcm(chip, ifnum, buffer, buflen) < 0)
goto __error;
if (snd_usb_create_mixer(chip, ifnum, buffer, buflen) < 0)
goto __error;
/* we are allowed to call snd_card_register() many times */
if (snd_card_register(chip->card) < 0) {
if (! chip->num_interfaces)
snd_card_free(chip->card);
goto __error;
}
chip->num_interfaces++;
up(&register_mutex);
kfree(buffer);
return chip;
__error:
up(&register_mutex);
kfree(buffer);
return NULL;
}
/*
* we need to take care of counter, since disconnection can be called also
* many times as well as usb_audio_probe().
*/
static void usb_audio_disconnect(struct usb_device *dev, void *ptr)
{
snd_usb_audio_t *chip;
if (ptr == (void *)-1)
return;
chip = snd_magic_cast(snd_usb_audio_t, ptr, return);
chip->num_interfaces--;
if (chip->num_interfaces <= 0)
snd_card_free(chip->card);
}
static int __init snd_usb_audio_init(void)
{
usb_register(&usb_audio_driver);
return 0;
}
static void __exit snd_usb_audio_cleanup(void)
{
usb_deregister(&usb_audio_driver);
}
module_init(snd_usb_audio_init);
module_exit(snd_usb_audio_cleanup);
#ifndef MODULE
/*
* format is snd-usb-audio=snd_enable,snd_index,snd_id
*/
static int __init snd_usb_audio_module_setup(char* str)
{
static unsigned __initdata nr_dev = 0;
if (nr_dev >= SNDRV_CARDS)
return 0;
(void)(get_option(&str, &snd_enable[nr_dev]) == 2 &&
get_option(&str, &snd_index[nr_dev]) == 2 &&
get_id(&str, &snd_id[nr_dev]) == 2);
++nr_dev;
return 1;
}
__setup("snd-usb-audio=", snd_usb_audio_module_setup);
#endif /* !MODULE */
sound/usb/usbaudio.h 0 → 100644
View file @ a3954fd2
#ifndef __USBAUDIO_H
#define __USBAUDIO_H
/*
* (Tentative) USB Audio Driver for ALSA
*
* Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
*/
#define USB_SUBCLASS_AUDIO_CONTROL 0x01
#define USB_SUBCLASS_AUDIO_STREAMING 0x02
#define USB_DT_CS_DEVICE 0x21
#define USB_DT_CS_CONFIG 0x22
#define USB_DT_CS_STRING 0x23
#define USB_DT_CS_INTERFACE 0x24
#define USB_DT_CS_ENDPOINT 0x25
#define CS_AUDIO_UNDEFINED 0x20
#define CS_AUDIO_DEVICE 0x21
#define CS_AUDIO_CONFIGURATION 0x22
#define CS_AUDIO_STRING 0x23
#define CS_AUDIO_INTERFACE 0x24
#define CS_AUDIO_ENDPOINT 0x25
#define HEADER 0x01
#define INPUT_TERMINAL 0x02
#define OUTPUT_TERMINAL 0x03
#define MIXER_UNIT 0x04
#define SELECTOR_UNIT 0x05
#define FEATURE_UNIT 0x06
#define PROCESSING_UNIT 0x07
#define EXTENSION_UNIT 0x08
#define AS_GENERAL 0x01
#define FORMAT_TYPE 0x02
#define FORMAT_SPECIFIC 0x03
#define EP_GENERAL 0x01
/* endpoint attributes */
#define EP_ATTR_MASK 0x0c
#define EP_ATTR_ASYNC 0x04
#define EP_ATTR_ADAPTIVE 0x08
#define EP_ATTR_SYNC 0x0c
/* cs endpoint attributes */
#define EP_CS_ATTR_SAMPLE_RATE 0x01
#define EP_CS_ATTR_PITCH_CONTROL 0x02
#define EP_CS_ATTR_FILL_MAX 0x80
/* Audio Class specific Request Codes */
#define SET_CUR 0x01
#define GET_CUR 0x81
#define SET_MIN 0x02
#define GET_MIN 0x82
#define SET_MAX 0x03
#define GET_MAX 0x83
#define SET_RES 0x04
#define GET_RES 0x84
#define SET_MEM 0x05
#define GET_MEM 0x85
#define GET_STAT 0xff
/* Terminal Control Selectors */
#define COPY_PROTECT_CONTROL 0x01
/* Endpoint Control Selectors */
#define SAMPLING_FREQ_CONTROL 0x01
#define PITCH_CONTROL 0x02
/* Format Types */
#define USB_FORMAT_TYPE_I 0x01
#define USB_FORMAT_TYPE_II 0x02
#define USB_FORMAT_TYPE_III 0x03
/* type I */
#define USB_AUDIO_FORMAT_PCM 0x01
#define USB_AUDIO_FORMAT_PCM8 0x02
#define USB_AUDIO_FORMAT_IEEE_FLOAT 0x03
#define USB_AUDIO_FORMAT_ALAW 0x04
#define USB_AUDIO_FORMAT_MU_LAW 0x05
/* type II */
#define USB_AUDIO_FORMAT_MPEG 0x1001
#define USB_AUDIO_FORMAT_AC3 0x1002
/* type III */
#define USB_AUDIO_FORMAT_IEC1937_AC3 0x2001
#define USB_AUDIO_FORMAT_IEC1937_MPEG1_LAYER1 0x2002
#define USB_AUDIO_FORMAT_IEC1937_MPEG2_NOEXT 0x2003
#define USB_AUDIO_FORMAT_IEC1937_MPEG2_EXT 0x2004
#define USB_AUDIO_FORMAT_IEC1937_MPEG2_LAYER1_LS 0x2005
#define USB_AUDIO_FORMAT_IEC1937_MPEG2_LAYER23_LS 0x2006
/*
*/
typedef struct snd_usb_audio snd_usb_audio_t;
struct snd_usb_audio {
int index;
struct usb_device *dev;
snd_card_t *card;
int num_interfaces;
struct list_head pcm_list; /* list of pcm streams */
int pcm_devs;
};
/*
*/
#define combine_word(s) ((*s) | ((unsigned int)(s)[1] << 8))
#define combine_triple(s) (combine_word(s) | ((unsigned int)(s)[2] << 16))
#define combine_quad(s) (combine_triple(s) | ((unsigned int)(s)[3] << 24))
unsigned int snd_usb_combine_bytes(unsigned char *bytes, int size);
void *snd_usb_find_desc(void *descstart, int desclen, void *after, u8 dtype, int iface, int altsetting);
void *snd_usb_find_csint_desc(void *descstart, int desclen, void *after, u8 dsubtype, int iface, int altsetting);
int snd_usb_create_mixer(snd_usb_audio_t *chip, int ctrlif, unsigned char *buffer, int buflen);
#endif /* __USBAUDIO_H */
sound/usb/usbmidi.c 0 → 100644
View file @ a3954fd2
/*
* usbmidi.c - ALSA USB MIDI driver
*
* Copyright (c) 2002 Clemens Ladisch
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions, and the following disclaimer,
* without modification.
* 2. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* Alternatively, this software may be distributed and/or modified under the
* terms of the GNU General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option) any later
* version.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sound/driver.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/usb.h>
#include <asm/semaphore.h>
#include <sound/core.h>
#include <sound/minors.h>
#include <sound/asequencer.h>
#include <sound/seq_device.h>
#include <sound/seq_kernel.h>
#include <sound/seq_virmidi.h>
#include <sound/seq_midi_event.h>
#define SNDRV_GET_ID
#include <sound/initval.h>
MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
MODULE_DESCRIPTION("USB MIDI");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_CLASSES("{sound}");
MODULE_DEVICES("{{Generic,USB MIDI},"
"{Roland/EDIROL,PC-300},"
"{Roland/EDIROL,SC-8820},"
"{Roland/EDIROL,SC-8850},"
"{Roland/EDIROL,SC-D70},"
"{Roland/EDIROL,SD-90},"
"{Roland/EDIROL,SK-500},"
"{Roland/EDIROL,U-8},"
"{Roland/EDIROL,UA-100(G)},"
"{Roland/EDIROL,UM-1(S)},"
"{Roland/EDIROL,UM-2(E)},"
"{Roland/EDIROL,UM-4},"
"{Roland/EDIROL,UM-550},"
"{Roland/EDIROL,UM-880},"
"{Roland/EDIROL,XV-5050},"
"{Yamaha,MU1000},"
"{Yamaha,UX256}}");
static int snd_index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-max */
static char* snd_id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* Id for this card */
static int snd_enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */
static int snd_vid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 }; /* Vendor id of this card */
static int snd_pid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 }; /* Product id of this card */
static int snd_int_transfer[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 0 }; /* Use interrupt transfers for this card */
MODULE_PARM(snd_index, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
MODULE_PARM_DESC(snd_index, "Index value for USB MIDI.");
MODULE_PARM_SYNTAX(snd_index, SNDRV_INDEX_DESC);
MODULE_PARM(snd_id, "1-" __MODULE_STRING(SNDRV_CARDS) "s");
MODULE_PARM_DESC(snd_id, "ID string for USB MIDI.");
MODULE_PARM_SYNTAX(snd_id, SNDRV_ID_DESC);
MODULE_PARM(snd_enable, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
MODULE_PARM_DESC(snd_enable, "Enable USB MIDI.");
MODULE_PARM_SYNTAX(snd_enable, SNDRV_ENABLE_DESC);
MODULE_PARM(snd_vid, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
MODULE_PARM_DESC(snd_vid, "USB Vendor ID for USB MIDI.");
MODULE_PARM_SYNTAX(snd_vid, SNDRV_ENABLED ",allows:{{-1,0xffff}},base:16");
MODULE_PARM(snd_pid, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
MODULE_PARM_DESC(snd_pid, "USB Product ID for USB MIDI.");
MODULE_PARM_SYNTAX(snd_pid, SNDRV_ENABLED ",allows:{{-1,0xffff}},base:16");
MODULE_PARM(snd_int_transfer, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
MODULE_PARM_DESC(snd_int_transfer, "Use interrupt transfers for USB MIDI input.");
MODULE_PARM_SYNTAX(snd_int_transfer, SNDRV_ENABLED "," SNDRV_BOOLEAN_FALSE_DESC ",skill:advanced");
/* size of the per-endpoint output buffer, must be a multiple of 4 */
#define OUTPUT_BUFFER_SIZE 0x400
/* max. size of incoming sysex messages */
#define INPUT_BUFFER_SIZE 0x200
#define MAX_ENDPOINTS 2
#define SNDRV_SEQ_DEV_ID_USBMIDI "usb-midi"
#ifndef USB_SUBCLASS_MIDISTREAMING
#define USB_SUBCLASS_MIDISTREAMING 3
#endif
#ifndef USB_DT_CS_INTERFACE
#define USB_DT_CS_INTERFACE (USB_TYPE_CLASS | USB_DT_INTERFACE)
#define USB_DT_CS_ENDPOINT (USB_TYPE_CLASS | USB_DT_ENDPOINT)
#endif
#ifndef USB_DST_MS_HEADER
#define USB_DST_MS_HEADER 0x01
#define USB_DST_MS_GENERAL 0x01
#define USB_DST_MS_HEADER_SIZE 7
#define USB_DST_MS_GENERAL_SIZE 4
#endif
typedef struct usb_driver usb_driver_t;
typedef struct usb_device usb_device_t;
typedef struct usb_device_id usb_device_id_t;
typedef struct usb_interface usb_interface_t;
typedef struct usb_interface_descriptor usb_interface_descriptor_t;
typedef struct usb_ms_header_descriptor usb_ms_header_descriptor_t;
typedef struct usb_endpoint_descriptor usb_endpoint_descriptor_t;
typedef struct usb_ms_endpoint_descriptor usb_ms_endpoint_descriptor_t;
struct usb_ms_header_descriptor {
__u8 bLength;
__u8 bDescriptorType;
__u8 bDescriptorSubtype;
__u8 bcdMSC[2];
__u16 wTotalLength;
} __attribute__ ((packed));
struct usb_ms_endpoint_descriptor {
__u8 bLength;
__u8 bDescriptorType;
__u8 bDescriptorSubtype;
__u8 bNumEmbMIDIJack;
__u8 baAssocJackID[0];
} __attribute__ ((packed));
typedef struct usbmidi usbmidi_t;
typedef struct usbmidi_device_info usbmidi_device_info_t;
typedef struct usbmidi_endpoint_info usbmidi_endpoint_info_t;
typedef struct usbmidi_endpoint usbmidi_endpoint_t;
typedef struct usbmidi_out_endpoint usbmidi_out_endpoint_t;
typedef struct usbmidi_out_port usbmidi_out_port_t;
typedef struct usbmidi_in_endpoint usbmidi_in_endpoint_t;
typedef struct usbmidi_in_port usbmidi_in_port_t;
/*
* Describes the capabilities of a USB MIDI device.
* This structure is filled after parsing the USB descriptors,
* or is supplied explicitly for broken devices.
*/
struct usbmidi_device_info {
char vendor[32]; /* vendor name */
char product[32]; /* device name */
int16_t ifnum; /* interface number */
struct usbmidi_endpoint_info {
int16_t epnum; /* endpoint number,
-1: autodetect (first ep only) */
uint16_t out_cables; /* bitmask */
uint16_t in_cables; /* bitmask */
} endpoints[MAX_ENDPOINTS];
};
struct usbmidi {
snd_card_t* card;
usb_device_t* usb_device;
int dev;
int seq_client;
usbmidi_device_info_t device_info;
struct usbmidi_endpoint {
usbmidi_out_endpoint_t* out;
usbmidi_in_endpoint_t* in;
snd_rawmidi_t* rmidi[0x10];
} endpoints[MAX_ENDPOINTS];
};
struct usbmidi_out_endpoint {
usbmidi_t* umidi;
urb_t* urb;
int max_transfer; /* size of urb buffer */
struct tasklet_struct tasklet;
uint8_t buffer[OUTPUT_BUFFER_SIZE]; /* ring buffer */
int data_begin;
int data_size;
spinlock_t buffer_lock;
struct usbmidi_out_port {
usbmidi_out_endpoint_t* ep;
uint8_t cable; /* cable number << 4 */
uint8_t sysex_len;
uint8_t sysex[2];
} ports[0x10];
};
struct usbmidi_in_endpoint {
usbmidi_t* umidi;
usbmidi_endpoint_t* ep;
urb_t* urb;
struct usbmidi_in_port {
int seq_port;
snd_midi_event_t* midi_event;
} ports[0x10];
};
static int snd_usbmidi_card_used[SNDRV_CARDS];
static DECLARE_MUTEX(snd_usbmidi_open_mutex);
static void snd_usbmidi_do_output(usbmidi_out_endpoint_t* ep);
/*
* Submits the URB, with error handling.
*/
static int snd_usbmidi_submit_urb(urb_t* urb, int flags)
{
int err = usb_submit_urb(urb, flags);
if (err < 0 && err != -ENODEV)
printk(KERN_ERR "snd-usb-midi: usb_submit_urb: %d\n", err);
return err;
}
/*
* Error handling for URB completion functions.
*/
static int snd_usbmidi_urb_error(int status)
{
if (status == -ENOENT)
return status; /* killed */
if (status == -ENODEV ||
status == -EILSEQ ||
status == -ETIMEDOUT)
return -ENODEV; /* device removed */
printk(KERN_ERR "snd-usb-midi: urb status %d\n", status);
return 0; /* continue */
}
/*
* Converts a USB MIDI packet into an ALSA sequencer event.
*/
static void snd_usbmidi_input_packet(usbmidi_in_endpoint_t* ep,
uint8_t packet[4])
{
static const uint8_t cin_length[] = {
0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1
};
int cable = packet[0] >> 4;
usbmidi_in_port_t* port = &ep->ports[cable];
snd_seq_event_t ev;
if (!port->midi_event)
return;
memset(&ev, 0, sizeof(ev));
if (snd_midi_event_encode(port->midi_event, &packet[1],
cin_length[packet[0] & 0x0f], &ev) > 0
&& ev.type != SNDRV_SEQ_EVENT_NONE) {
ev.source.port = port->seq_port;
ev.dest.client = SNDRV_SEQ_ADDRESS_SUBSCRIBERS;
snd_seq_kernel_client_dispatch(ep->umidi->seq_client,
&ev, 1, 0);
if (ep->ep->rmidi[cable])
snd_virmidi_receive(ep->ep->rmidi[cable], &ev);
}
}
/*
* Processes the data read from the device.
*/
static void snd_usbmidi_in_urb_complete(urb_t* urb)
{
usbmidi_in_endpoint_t* ep = snd_magic_cast(usbmidi_in_endpoint_t, urb->context, return);
if (urb->status == 0) {
uint8_t* buffer = (uint8_t*)ep->urb->transfer_buffer;
int i;
for (i = 0; i + 4 <= urb->actual_length; i += 4)
if (buffer[i] != 0)
snd_usbmidi_input_packet(ep, &buffer[i]);
} else {
if (snd_usbmidi_urb_error(urb->status) < 0)
return;
}
if (!usb_pipeint(urb->pipe)) {
urb->dev = ep->umidi->usb_device;
snd_usbmidi_submit_urb(urb, GFP_ATOMIC);
}
}
static void snd_usbmidi_out_urb_complete(urb_t* urb)
{
usbmidi_out_endpoint_t* ep = snd_magic_cast(usbmidi_out_endpoint_t, urb->context, return);
unsigned long flags;
if (urb->status < 0) {
if (snd_usbmidi_urb_error(urb->status) < 0)
return;
}
spin_lock_irqsave(&ep->buffer_lock, flags);
snd_usbmidi_do_output(ep);
spin_unlock_irqrestore(&ep->buffer_lock, flags);
}
/*
* This is called when some data should be transferred to the device
* (after the reception of one or more sequencer events, or after completion
* of the previous transfer). ep->buffer_lock must be held.
*/
static void snd_usbmidi_do_output(usbmidi_out_endpoint_t* ep)
{
int len;
uint8_t* buffer;
if (ep->urb->status == -EINPROGRESS ||
ep->data_size == 0)
return;
buffer = (uint8_t*)ep->urb->transfer_buffer;
/* first chunk, up to the end of the buffer */
len = OUTPUT_BUFFER_SIZE - ep->data_begin;
if (len > ep->data_size)
len = ep->data_size;
if (len > ep->max_transfer)
len = ep->max_transfer;
if (len > 0) {
memcpy(buffer, ep->buffer + ep->data_begin, len);
ep->data_begin = (ep->data_begin + len) % OUTPUT_BUFFER_SIZE;
ep->data_size -= len;
buffer += len;
ep->urb->transfer_buffer_length = len;
}
/* second chunk (after wraparound) */
if (ep->data_begin == 0 && ep->data_size > 0 &&
len < ep->max_transfer) {
len = ep->max_transfer - len;
if (len > ep->data_size)
len = ep->data_size;
memcpy(buffer, ep->buffer, len);
ep->data_begin = len;
ep->data_size -= len;
ep->urb->transfer_buffer_length += len;
}
if (len > 0) {
ep->urb->dev = ep->umidi->usb_device;
snd_usbmidi_submit_urb(ep->urb, GFP_ATOMIC);
}
}
static void snd_usbmidi_out_tasklet(unsigned long data)
{
usbmidi_out_endpoint_t* ep = snd_magic_cast(usbmidi_out_endpoint_t, (void*)data, return);
unsigned long flags;
spin_lock_irqsave(&ep->buffer_lock, flags);
snd_usbmidi_do_output(ep);
spin_unlock_irqrestore(&ep->buffer_lock, flags);
}
/*
* Adds one USB MIDI packet to the output buffer.
*/
static void output_packet(usbmidi_out_port_t* port,
uint8_t p0, uint8_t p1, uint8_t p2, uint8_t p3)
{
usbmidi_out_endpoint_t* ep = port->ep;
unsigned long flags;
spin_lock_irqsave(&ep->buffer_lock, flags);
if (ep->data_size < OUTPUT_BUFFER_SIZE) {
uint8_t* buf = ep->buffer + (ep->data_begin + ep->data_size) % OUTPUT_BUFFER_SIZE;
buf[0] = p0;
buf[1] = p1;
buf[2] = p2;
buf[3] = p3;
ep->data_size += 4;
if (ep->data_size == ep->max_transfer)
snd_usbmidi_do_output(ep);
}
spin_unlock_irqrestore(&ep->buffer_lock, flags);
}
/*
* Callback for snd_seq_dump_var_event.
*/
static int snd_usbmidi_sysex_dump(void* ptr, void* buf, int count)
{
usbmidi_out_port_t* port = (usbmidi_out_port_t*)ptr;
const uint8_t* dump = (const uint8_t*)buf;
for (; count; --count) {
uint8_t byte = *dump++;
if (byte == 0xf0 && port->sysex_len > 0) {
/*
* The previous SysEx wasn't terminated correctly.
* Send the last bytes anyway, and hope that the
* receiving device won't be too upset about the
* missing F7.
*/
output_packet(port,
port->cable | (0x04 + port->sysex_len),
port->sysex[0],
port->sysex_len >= 2 ? port->sysex[1] : 0,
0);
port->sysex_len = 0;
}
if (byte != 0xf7) {
if (port->sysex_len >= 2) {
output_packet(port,
port->cable | 0x04,
port->sysex[0],
port->sysex[1],
byte);
port->sysex_len = 0;
} else {
port->sysex[port->sysex_len++] = byte;
}
} else {
uint8_t cin, data[3];
int i;
for (i = 0; i < port->sysex_len; ++i)
data[i] = port->sysex[i];
data[i++] = 0xf7;
cin = port->cable | (0x04 + i);
for (; i < 3; ++i)
data[i] = 0;
/*
* cin,data[] is x5,{F7 00 00}
* or x6,{xx F7 00}
* or x7,{xx xx F7}
*/
output_packet(port, cin, data[0], data[1], data[2]);
port->sysex_len = 0;
}
}
return 0;
}
/*
* Converts an ALSA sequencer event into USB MIDI packets.
*/
static int snd_usbmidi_event_input(snd_seq_event_t* ev, int direct,
void* private_data, int atomic, int hop)
{
usbmidi_out_port_t* port = (usbmidi_out_port_t*)private_data;
int err;
uint8_t p0, p1;
p0 = port->cable;
p1 = ev->data.note.channel & 0xf;
switch (ev->type) {
case SNDRV_SEQ_EVENT_NOTEON:
output_packet(port, p0 | 0x09, p1 | 0x90,
ev->data.note.note & 0x7f,
ev->data.note.velocity & 0x7f);
break;
case SNDRV_SEQ_EVENT_NOTEOFF:
output_packet(port, p0 | 0x08, p1 | 0x80,
ev->data.note.note & 0x7f,
ev->data.note.velocity & 0x7f);
break;
case SNDRV_SEQ_EVENT_KEYPRESS:
output_packet(port, p0 | 0x0a, p1 | 0xa0,
ev->data.note.note & 0x7f,
ev->data.note.velocity & 0x7f);
break;
case SNDRV_SEQ_EVENT_CONTROLLER:
output_packet(port, p0 | 0x0b, p1 | 0xb0,
ev->data.control.param & 0x7f,
ev->data.control.value & 0x7f);
break;
case SNDRV_SEQ_EVENT_PGMCHANGE:
output_packet(port, p0 | 0x0c, p1 | 0xc0,
ev->data.control.value & 0x7f, 0);
break;
case SNDRV_SEQ_EVENT_CHANPRESS:
output_packet(port, p0 | 0x0d, p1 | 0xd0,
ev->data.control.value & 0x7f, 0);
break;
case SNDRV_SEQ_EVENT_PITCHBEND:
output_packet(port, p0 | 0x0e, p1 | 0xe0,
(ev->data.control.value + 0x2000) & 0x7f,
((ev->data.control.value + 0x2000) >> 7) & 0x7f);
break;
case SNDRV_SEQ_EVENT_CONTROL14:
if (ev->data.control.param < 0x20) {
output_packet(port, p0 | 0x0b, p1 | 0xb0,
ev->data.control.param,
(ev->data.control.value >> 7) & 0x7f);
output_packet(port, p0 | 0x0b, p1 | 0xb0,
ev->data.control.param + 0x20,
ev->data.control.value & 0x7f);
} else {
output_packet(port, p0 | 0x0b, p1 | 0xb0,
ev->data.control.param & 0x7f,
ev->data.control.value & 0x7f);
}
break;
case SNDRV_SEQ_EVENT_SONGPOS:
output_packet(port, p0 | 0x03, 0xf2,
ev->data.control.value & 0x7f,
(ev->data.control.value >> 7) & 0x7f);
break;
case SNDRV_SEQ_EVENT_SONGSEL:
output_packet(port, p0 | 0x02, 0xf3,
ev->data.control.value & 0x7f, 0);
break;
case SNDRV_SEQ_EVENT_QFRAME:
output_packet(port, p0 | 0x02, 0xf1,
ev->data.control.value & 0x7f, 0);
break;
case SNDRV_SEQ_EVENT_START:
output_packet(port, p0 | 0x0f, 0xfa, 0, 0);
break;
case SNDRV_SEQ_EVENT_CONTINUE:
output_packet(port, p0 | 0x0f, 0xfb, 0, 0);
break;
case SNDRV_SEQ_EVENT_STOP:
output_packet(port, p0 | 0x0f, 0xfc, 0, 0);
break;
case SNDRV_SEQ_EVENT_CLOCK:
output_packet(port, p0 | 0x0f, 0xf8, 0, 0);
break;
case SNDRV_SEQ_EVENT_TUNE_REQUEST:
output_packet(port, p0 | 0x05, 0xf6, 0, 0);
break;
case SNDRV_SEQ_EVENT_RESET:
output_packet(port, p0 | 0x0f, 0xff, 0, 0);
break;
case SNDRV_SEQ_EVENT_SENSING:
output_packet(port, p0 | 0x0f, 0xfe, 0, 0);
break;
case SNDRV_SEQ_EVENT_SYSEX:
err = snd_seq_dump_var_event(ev, snd_usbmidi_sysex_dump, port);
if (err < 0)
return err;
break;
default:
return 0;
}
tasklet_hi_schedule(&port->ep->tasklet);
return 0;
}
/*
* Frees an input endpoint.
* May be called when ep hasn't been initialized completely.
*/
static void snd_usbmidi_in_endpoint_delete(usbmidi_in_endpoint_t* ep)
{
int i;
if (ep->urb) {
if (ep->urb->transfer_buffer) {
usb_unlink_urb(ep->urb);
kfree(ep->urb->transfer_buffer);
}
usb_free_urb(ep->urb);
}
for (i = 0; i < 0x10; ++i)
if (ep->ports[i].midi_event)
snd_midi_event_free(ep->ports[i].midi_event);
snd_magic_kfree(ep);
}
/*
* Searches for an alternate setting in which the endpoint uses interrupt
* transfers for input.
*/
static int snd_usbmidi_get_int_ep(usbmidi_t* umidi, uint8_t epnum,
usb_endpoint_descriptor_t** descriptor)
{
usb_interface_t* intf;
int i, j;
*descriptor = NULL;
intf = usb_ifnum_to_if(umidi->usb_device, umidi->device_info.ifnum);
if (!intf)
return -ENXIO;
for (i = 0; i < intf->num_altsetting; ++i) {
usb_interface_descriptor_t* intfd = &intf->altsetting[i];
for (j = 0; j < intfd->bNumEndpoints; ++j) {
usb_endpoint_descriptor_t* epd = &intfd->endpoint[j];
if ((epd->bEndpointAddress & (USB_ENDPOINT_NUMBER_MASK | USB_ENDPOINT_DIR_MASK)) == (epnum | USB_DIR_IN) &&
(epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT) {
usb_set_interface(umidi->usb_device,
intfd->bInterfaceNumber,
intfd->bAlternateSetting);
*descriptor = &intfd->endpoint[j];
return 0;
}
}
}
return -ENXIO;
}
/*
* Creates an input endpoint, and initalizes input ports.
* ALSA ports are created later.
*/
static int snd_usbmidi_in_endpoint_create(usbmidi_t* umidi,
usbmidi_endpoint_info_t* ep_info,
usbmidi_endpoint_t* rep)
{
usbmidi_in_endpoint_t* ep;
int do_int_transfer;
usb_endpoint_descriptor_t* epd;
void* buffer;
unsigned int pipe;
int length, i, err;
rep->in = NULL;
ep = snd_magic_kcalloc(usbmidi_in_endpoint_t, 0, GFP_KERNEL);
if (!ep)
return -ENOMEM;
ep->umidi = umidi;
ep->ep = rep;
for (i = 0; i < 0x10; ++i)
ep->ports[i].seq_port = -1;
do_int_transfer = snd_int_transfer[umidi->dev];
if (do_int_transfer) {
if (snd_usbmidi_get_int_ep(umidi, ep_info->epnum, &epd) < 0) {
printk(KERN_WARNING "snd-usb-midi: interrupt endpoint not found\n");
do_int_transfer = 0;
}
}
ep->urb = usb_alloc_urb(0, GFP_KERNEL);
if (!ep->urb) {
snd_usbmidi_in_endpoint_delete(ep);
return -ENOMEM;
}
if (do_int_transfer)
pipe = usb_rcvintpipe(umidi->usb_device, ep_info->epnum);
else
pipe = usb_rcvbulkpipe(umidi->usb_device, ep_info->epnum);
length = usb_maxpacket(umidi->usb_device, pipe, 0);
buffer = kmalloc(length, GFP_KERNEL);
if (!buffer) {
snd_usbmidi_in_endpoint_delete(ep);
return -ENOMEM;
}
if (do_int_transfer)
FILL_INT_URB(ep->urb, umidi->usb_device, pipe, buffer, length,
snd_usbmidi_in_urb_complete, ep, epd->bInterval);
else
FILL_BULK_URB(ep->urb, umidi->usb_device, pipe, buffer, length,
snd_usbmidi_in_urb_complete, ep);
for (i = 0; i < 0x10; ++i)
if (ep_info->in_cables & (1 << i)) {
err = snd_midi_event_new(INPUT_BUFFER_SIZE,
&ep->ports[i].midi_event);
if (err < 0) {
snd_usbmidi_in_endpoint_delete(ep);
return -ENOMEM;
}
}
rep->in = ep;
return 0;
}
static int snd_usbmidi_count_bits(uint16_t x)
{
int i, bits = 0;
for (i = 0; i < 16; ++i)
bits += (x & (1 << i)) != 0;
return bits;
}
/*
* Frees an output endpoint.
* May be called when ep hasn't been initialized completely.
*/
static void snd_usbmidi_out_endpoint_delete(usbmidi_out_endpoint_t* ep)
{
if (ep->tasklet.func)
tasklet_kill(&ep->tasklet);
if (ep->urb) {
if (ep->urb->transfer_buffer) {
usb_unlink_urb(ep->urb);
kfree(ep->urb->transfer_buffer);
}
usb_free_urb(ep->urb);
}
snd_magic_kfree(ep);
}
/*
* Creates an output endpoint, and initializes output ports.
* ALSA ports are created later.
*/
static int snd_usbmidi_out_endpoint_create(usbmidi_t* umidi,
usbmidi_endpoint_info_t* ep_info,
usbmidi_endpoint_t* rep)
{
usbmidi_out_endpoint_t* ep;
int i;
unsigned int pipe;
void* buffer;
rep->out = NULL;
ep = snd_magic_kcalloc(usbmidi_out_endpoint_t, 0, GFP_KERNEL);
if (!ep)
return -ENOMEM;
ep->umidi = umidi;
ep->urb = usb_alloc_urb(0, GFP_KERNEL);
if (!ep->urb) {
snd_usbmidi_out_endpoint_delete(ep);
return -ENOMEM;
}
pipe = usb_sndbulkpipe(umidi->usb_device, ep_info->epnum);
ep->max_transfer = usb_maxpacket(umidi->usb_device, pipe, 1) & ~3;
buffer = kmalloc(ep->max_transfer, GFP_KERNEL);
if (!buffer) {
snd_usbmidi_out_endpoint_delete(ep);
return -ENOMEM;
}
FILL_BULK_URB(ep->urb, umidi->usb_device, pipe, buffer,
ep->max_transfer, snd_usbmidi_out_urb_complete, ep);
spin_lock_init(&ep->buffer_lock);
tasklet_init(&ep->tasklet, snd_usbmidi_out_tasklet, (unsigned long)ep);
for (i = 0; i < 0x10; ++i)
if (ep_info->out_cables & (1 << i)) {
ep->ports[i].ep = ep;
ep->ports[i].cable = i << 4;
}
rep->out = ep;
return 0;
}
/*
* Frees the sequencer client, endpoints and ports.
*/
static int snd_usbmidi_seq_device_delete(snd_seq_device_t* seq_device)
{
usbmidi_t* umidi;
int i, j;
umidi = (usbmidi_t*)SNDRV_SEQ_DEVICE_ARGPTR(seq_device);
if (umidi->seq_client >= 0) {
snd_seq_delete_kernel_client(umidi->seq_client);
umidi->seq_client = -1;
}
for (i = 0; i < MAX_ENDPOINTS; ++i) {
usbmidi_endpoint_t* ep = &umidi->endpoints[i];
if (ep->out) {
snd_usbmidi_out_endpoint_delete(ep->out);
ep->out = NULL;
}
if (ep->in) {
snd_usbmidi_in_endpoint_delete(ep->in);
ep->in = NULL;
}
for (j = 0; j < 0x10; ++j)
if (ep->rmidi[j]) {
snd_device_free(umidi->card, ep->rmidi[j]);
ep->rmidi[j] = NULL;
}
}
return 0;
}
/*
* After input and output endpoints have been initialized, create
* the ALSA port for each input/output port pair in the endpoint.
* *port_idx is the port number, which must be unique over all endpoints.
*/
static int snd_usbmidi_create_endpoint_ports(usbmidi_t* umidi, int ep,
int* port_idx)
{
usbmidi_endpoint_info_t* ep_info = &umidi->device_info.endpoints[ep];
int c, err;
int cap, type, port;
int out, in;
snd_seq_port_callback_t port_callback;
char port_name[48];
for (c = 0; c < 0x10; ++c) {
out = ep_info->out_cables & (1 << c);
in = ep_info->in_cables & (1 << c);
if (!(in || out))
continue;
cap = 0;
memset(&port_callback, 0, sizeof(port_callback));
port_callback.owner = THIS_MODULE;
if (out) {
port_callback.event_input = snd_usbmidi_event_input;
port_callback.private_data = &umidi->endpoints[ep].out->ports[c];
cap |= SNDRV_SEQ_PORT_CAP_WRITE |
SNDRV_SEQ_PORT_CAP_SUBS_WRITE;
}
if (in) {
cap |= SNDRV_SEQ_PORT_CAP_READ |
SNDRV_SEQ_PORT_CAP_SUBS_READ;
}
if (out && in) {
cap |= SNDRV_SEQ_PORT_CAP_DUPLEX;
}
/* TODO: read type bits from element descriptor */
type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC;
/* TODO: read port name from jack descriptor */
sprintf(port_name, "%s Port %d",
umidi->device_info.product, *port_idx);
port = snd_seq_event_port_attach(umidi->seq_client,
&port_callback,
cap, type, port_name);
if (port < 0) {
snd_printk(KERN_ERR "cannot create port (error code %d)\n", port);
return port;
}
if (in)
umidi->endpoints[ep].in->ports[c].seq_port = port;
if (*port_idx < SNDRV_MINOR_RAWMIDIS) {
snd_rawmidi_t *rmidi;
snd_virmidi_dev_t *rdev;
err = snd_virmidi_new(umidi->card, *port_idx, &rmidi);
if (err < 0)
return err;
rdev = snd_magic_cast(snd_virmidi_dev_t, rmidi->private_data, return -ENXIO);
strcpy(rmidi->name, port_name);
rdev->seq_mode = SNDRV_VIRMIDI_SEQ_ATTACH;
rdev->client = umidi->seq_client;
rdev->port = port;
err = snd_device_register(umidi->card, rmidi);
if (err < 0) {
snd_device_free(umidi->card, rmidi);
return err;
}
umidi->endpoints[ep].rmidi[c] = rmidi;
}
++*port_idx;
}
return 0;
}
/*
* Create the endpoints and their ports.
*/
static int snd_usbmidi_create_endpoints(usbmidi_t* umidi)
{
int i, err, port_idx = 0;
for (i = 0; i < MAX_ENDPOINTS; ++i) {
usbmidi_endpoint_info_t* ep_info = &umidi->device_info.endpoints[i];
if (!ep_info->epnum)
continue;
if (ep_info->out_cables) {
err = snd_usbmidi_out_endpoint_create(umidi, ep_info,
&umidi->endpoints[i]);
if (err < 0)
return err;
}
if (ep_info->in_cables) {
err = snd_usbmidi_in_endpoint_create(umidi, ep_info,
&umidi->endpoints[i]);
if (err < 0)
return err;
}
err = snd_usbmidi_create_endpoint_ports(umidi, i, &port_idx);
if (err < 0)
return err;
printk(KERN_INFO "snd-usb-midi: endpoint %d: created %d output and %d input ports\n",
ep_info->epnum,
snd_usbmidi_count_bits(ep_info->out_cables),
snd_usbmidi_count_bits(ep_info->in_cables));
}
return 0;
}
/*
* Initialize the sequencer device.
*/
static int snd_usbmidi_seq_device_new(snd_seq_device_t* seq_device)
{
usbmidi_t* umidi;
snd_seq_client_callback_t client_callback;
snd_seq_client_info_t client_info;
int i, err;
umidi = (usbmidi_t*)SNDRV_SEQ_DEVICE_ARGPTR(seq_device);
memset(&client_callback, 0, sizeof(client_callback));
client_callback.allow_output = 1;
client_callback.allow_input = 1;
umidi->seq_client = snd_seq_create_kernel_client(umidi->card, 0,
&client_callback);
if (umidi->seq_client < 0)
return umidi->seq_client;
memset(&client_info, 0, sizeof(client_info));
client_info.client = umidi->seq_client;
client_info.type = KERNEL_CLIENT;
sprintf(client_info.name, "%s %s",
umidi->device_info.vendor, umidi->device_info.product);
snd_seq_kernel_client_ctl(umidi->seq_client,
SNDRV_SEQ_IOCTL_SET_CLIENT_INFO,
&client_info);
err = snd_usbmidi_create_endpoints(umidi);
if (err < 0) {
snd_usbmidi_seq_device_delete(seq_device);
return err;
}
for (i = 0; i < MAX_ENDPOINTS; ++i)
if (umidi->endpoints[i].in)
snd_usbmidi_submit_urb(umidi->endpoints[i].in->urb,
GFP_KERNEL);
return 0;
}
static int snd_usbmidi_card_create(usb_device_t* usb_device,
usbmidi_device_info_t* device_info,
snd_card_t** rcard)
{
snd_card_t* card;
snd_seq_device_t* seq_device;
usbmidi_t* umidi;
int dev, err;
if (rcard)
*rcard = NULL;
down(&snd_usbmidi_open_mutex);
for (dev = 0; dev < SNDRV_CARDS; ++dev) {
if (snd_enable[dev] && !snd_usbmidi_card_used[dev] &&
(snd_vid[dev] == -1 ||
snd_vid[dev] == usb_device->descriptor.idVendor) &&
(snd_pid[dev] == -1 ||
snd_pid[dev] == usb_device->descriptor.idProduct))
break;
}
if (dev >= SNDRV_CARDS) {
up(&snd_usbmidi_open_mutex);
return -ENOENT;
}
card = snd_card_new(snd_index[dev], snd_id[dev], THIS_MODULE, 0);
if (!card) {
up(&snd_usbmidi_open_mutex);
return -ENOMEM;
}
strcpy(card->driver, "USB MIDI");
snprintf(card->shortname, sizeof(card->shortname), "%s %s",
device_info->vendor, device_info->product);
snprintf(card->longname, sizeof(card->longname), "%s %s at %03d/%03d if %d",
device_info->vendor, device_info->product,
usb_device->bus->busnum, usb_device->devnum,
device_info->ifnum);
card->private_data = (void*)dev;
err = snd_seq_device_new(card, 0, SNDRV_SEQ_DEV_ID_USBMIDI,
sizeof(usbmidi_t), &seq_device);
if (err < 0) {
snd_card_free(card);
up(&snd_usbmidi_open_mutex);
return err;
}
strcpy(seq_device->name, card->shortname);
umidi = (usbmidi_t*)SNDRV_SEQ_DEVICE_ARGPTR(seq_device);
umidi->card = card;
umidi->usb_device = usb_device;
umidi->dev = dev;
umidi->seq_client = -1;
umidi->device_info = *device_info;
err = snd_card_register(card);
if (err < 0) {
snd_card_free(card);
up(&snd_usbmidi_open_mutex);
return err;
}
snd_usbmidi_card_used[dev] = 1;
up(&snd_usbmidi_open_mutex);
if (rcard)
*rcard = card;
return 0;
}
/*
* If the first endpoint isn't specified, use the first endpoint in the
* first alternate setting of the interface.
*/
static int snd_usbmidi_detect_endpoint(usb_device_t* usb_device,
usbmidi_device_info_t* device_info)
{
usb_interface_t* intf;
usb_interface_descriptor_t* intfd;
usb_endpoint_descriptor_t* epd;
if (device_info->endpoints[0].epnum == -1) {
intf = usb_ifnum_to_if(usb_device, device_info->ifnum);
if (!intf || intf->num_altsetting < 1)
return -ENOENT;
intfd = intf->altsetting;
if (intfd->bNumEndpoints < 1)
return -ENOENT;
epd = intfd->endpoint;
device_info->endpoints[0].epnum = epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
}
return 0;
}
/*
* Searches for the alternate setting with the greatest number of bulk transfer
* endpoints.
*/
static usb_interface_descriptor_t* snd_usbmidi_get_altsetting(usb_device_t* usb_device,
usb_interface_t* intf)
{
int i, best = -1;
int best_out = 0, best_in = 0;
usb_interface_descriptor_t* intfd;
if (intf->num_altsetting == 1)
return &intf->altsetting[0];
for (i = 0; i < intf->num_altsetting; ++i) {
int out = 0, in = 0, j;
for (j = 0; j < intf->altsetting[i].bNumEndpoints; ++j) {
usb_endpoint_descriptor_t* ep = &intf->altsetting[i].endpoint[j];
if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK) {
if (ep->bEndpointAddress & USB_DIR_IN)
++in;
else
++out;
}
}
if ((out >= best_out && in >= best_in) &&
(out > best_out || in > best_in)) {
best_out = out;
best_in = in;
best = i;
}
}
if (best < 0)
return NULL;
intfd = &intf->altsetting[best];
usb_set_interface(usb_device, intfd->bInterfaceNumber, intfd->bAlternateSetting);
return intfd;
}
/*
* Returns MIDIStreaming device capabilities in device_info.
*/
static int snd_usbmidi_get_ms_info(usb_device_t* usb_device,
unsigned int ifnum,
usbmidi_device_info_t* device_info)
{
usb_interface_t* intf;
usb_interface_descriptor_t* intfd;
usb_ms_header_descriptor_t* ms_header;
usb_endpoint_descriptor_t* ep;
usb_ms_endpoint_descriptor_t* ms_ep;
int i, epidx;
memset(device_info, 0, sizeof(*device_info));
if (usb_device->descriptor.iManufacturer == 0 ||
usb_string(usb_device, usb_device->descriptor.iManufacturer,
device_info->vendor, sizeof(device_info->vendor)) < 0)
sprintf(device_info->vendor, "Unknown Vendor %x", usb_device->descriptor.idVendor);
if (usb_device->descriptor.iProduct == 0 ||
usb_string(usb_device, usb_device->descriptor.iProduct,
device_info->product, sizeof(device_info->product)) < 0)
sprintf(device_info->product, "Unknown Device %x", usb_device->descriptor.idProduct);
intf = usb_ifnum_to_if(usb_device, ifnum);
if (!intf)
return -ENXIO;
device_info->ifnum = ifnum;
printk(KERN_INFO "snd-usb-midi: using interface %d\n",
intf->altsetting[0].bInterfaceNumber);
intfd = snd_usbmidi_get_altsetting(usb_device, intf);
if (!intfd) {
printk(KERN_ERR "snd-usb-midi: could not determine altsetting\n");
return -ENXIO;
}
ms_header = (usb_ms_header_descriptor_t*)intfd->extra;
if (intfd->extralen >= USB_DST_MS_HEADER_SIZE &&
ms_header->bLength >= USB_DST_MS_HEADER_SIZE &&
ms_header->bDescriptorType == USB_DT_CS_INTERFACE &&
ms_header->bDescriptorSubtype == USB_DST_MS_HEADER)
printk(KERN_INFO "snd-usb-midi: MIDIStreaming version %02x.%02x\n",
ms_header->bcdMSC[1], ms_header->bcdMSC[0]);
else
printk(KERN_WARNING "snd-usb-midi: MIDIStreaming interface descriptor not found\n");
epidx = 0;
for (i = 0; i < intfd->bNumEndpoints; ++i) {
ep = &intfd->endpoint[i];
if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK)
continue;
ms_ep = (usb_ms_endpoint_descriptor_t*)ep->extra;
if (ep->extralen < USB_DST_MS_GENERAL_SIZE ||
ms_ep->bLength < USB_DST_MS_GENERAL_SIZE ||
ms_ep->bDescriptorType != USB_DT_CS_ENDPOINT ||
ms_ep->bDescriptorSubtype != USB_DST_MS_GENERAL)
continue;
if (device_info->endpoints[epidx].epnum != 0 &&
device_info->endpoints[epidx].epnum != (ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK)) {
++epidx;
if (epidx >= MAX_ENDPOINTS) {
printk(KERN_WARNING "snd-usb-midi: too many endpoints\n");
break;
}
}
device_info->endpoints[epidx].epnum = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
if (ep->bEndpointAddress & USB_DIR_IN) {
device_info->endpoints[epidx].in_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1;
} else {
device_info->endpoints[epidx].out_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1;
}
printk(KERN_INFO "snd-usb-midi: detected %d %s jack(s) on endpoint %d\n",
ms_ep->bNumEmbMIDIJack,
ep->bEndpointAddress & USB_DIR_IN ? "input" : "output",
device_info->endpoints[epidx].epnum);
}
return 0;
}
/*
* Returns device capabilities, either explicitly supplied or from the
* class-specific descriptors.
*/
static int snd_usbmidi_get_device_info(usb_device_t* usb_device,
unsigned int ifnum,
const usb_device_id_t* usb_device_id,
usbmidi_device_info_t* device_info)
{
if (usb_device_id->driver_info) {
usbmidi_device_info_t* id_info = (usbmidi_device_info_t*)usb_device_id->driver_info;
if (ifnum != id_info->ifnum)
return -ENXIO;
*device_info = *id_info;
if (snd_usbmidi_detect_endpoint(usb_device, device_info) < 0)
return -ENXIO;
} else {
if (snd_usbmidi_get_ms_info(usb_device, ifnum, device_info) < 0)
return -ENXIO;
}
return 0;
}
/*
* Probes for a supported device.
*/
static void* snd_usbmidi_usb_probe(usb_device_t* device,
unsigned int ifnum,
const usb_device_id_t* device_id)
{
usbmidi_device_info_t device_info;
snd_card_t* card = NULL;
int err;
if (snd_usbmidi_get_device_info(device, ifnum, device_id,
&device_info) == 0) {
printk(KERN_INFO "snd-usb-midi: detected %s %s\n",
device_info.vendor, device_info.product);
err = snd_usbmidi_card_create(device, &device_info, &card);
if (err < 0)
snd_printk(KERN_ERR "cannot create card (error code %d)\n", err);
}
return card;
}
/*
* Frees the device.
*/
static void snd_usbmidi_usb_disconnect(usb_device_t* usb_device, void* ptr)
{
snd_card_t* card = (snd_card_t*)ptr;
int dev = (int)card->private_data;
snd_card_free(card);
down(&snd_usbmidi_open_mutex);
snd_usbmidi_card_used[dev] = 0;
up(&snd_usbmidi_open_mutex);
}
/*
* Information about devices with broken descriptors.
*/
static usbmidi_device_info_t snd_usbmidi_yamaha_ux256_info = {
/* from NetBSD's umidi driver */
.vendor = "Yamaha", .product = "UX256",
.ifnum = 0,
.endpoints = {{ -1, 0xffff, 0x00ff }}
};
static usbmidi_device_info_t snd_usbmidi_yamaha_mu1000_info = {
/* from Nagano Daisuke's usb-midi driver */
.vendor = "Yamaha", .product = "MU1000",
.ifnum = 0,
.endpoints = {{ 1, 0x000f, 0x0001 }}
};
/*
* There ain't no such thing as a standard-compliant Roland device.
* Apparently, Roland decided not to risk to have wrong entries in the USB
* descriptors. The consequence is that class-specific descriptors are
* conspicuous by their absence.
*
* And now you may guess which company was responsible for writing the
* USB Device Class Definition for MIDI Devices.
*/
static usbmidi_device_info_t snd_usbmidi_roland_ua100_info = {
.vendor = "Roland", .product = "UA-100",
.ifnum = 2,
.endpoints = {{ -1, 0x0007, 0x0007 }}
};
static usbmidi_device_info_t snd_usbmidi_roland_um4_info = {
.vendor = "EDIROL", .product = "UM-4",
.ifnum = 2,
.endpoints = {{ -1, 0x000f, 0x000f }}
};
static usbmidi_device_info_t snd_usbmidi_roland_sc8850_info = {
.vendor = "Roland", .product = "SC-8850",
.ifnum = 2,
.endpoints = {{ -1, 0x003f, 0x003f }}
};
static usbmidi_device_info_t snd_usbmidi_roland_u8_info = {
.vendor = "Roland", .product = "U-8",
.ifnum = 2,
.endpoints = {{ -1, 0x0003, 0x0003 }}
};
static usbmidi_device_info_t snd_usbmidi_roland_um2_info = {
.vendor = "EDIROL", .product = "UM-2",
.ifnum = 2,
.endpoints = {{ -1, 0x0003, 0x0003 }}
};
static usbmidi_device_info_t snd_usbmidi_roland_sc8820_info = {
.vendor = "Roland", .product = "SC-8820",
.ifnum = 2,
.endpoints = {{ -1, 0x0013, 0x0013 }}
};
static usbmidi_device_info_t snd_usbmidi_roland_pc300_info = {
.vendor = "Roland", .product = "PC-300",
.ifnum = 2,
.endpoints = {{ -1, 0x0001, 0x0001 }}
};
static usbmidi_device_info_t snd_usbmidi_roland_um1_info = {
.vendor = "EDIROL", .product = "UM-1",
.ifnum = 2,
.endpoints = {{ -1, 0x0001, 0x0001 }}
};
static usbmidi_device_info_t snd_usbmidi_roland_sk500_info = {
.vendor = "Roland", .product = "SK-500",
.ifnum = 2,
.endpoints = {{ -1, 0x0013, 0x0013 }}
};
static usbmidi_device_info_t snd_usbmidi_roland_scd70_info = {
.vendor = "Roland", .product = "SC-D70",
.ifnum = 2,
.endpoints = {{ -1, 0x0007, 0x0007 }}
};
static usbmidi_device_info_t snd_usbmidi_roland_xv5050_info = {
.vendor = "Roland", .product = "XV-5050",
.ifnum = 0,
.endpoints = {{ -1, 0x0001, 0x0001 }}
};
static usbmidi_device_info_t snd_usbmidi_roland_um880_info = {
.vendor = "EDIROL", .product = "UM-880",
.ifnum = 0,
.endpoints = {{ -1, 0x01ff, 0x01ff }}
};
static usbmidi_device_info_t snd_usbmidi_roland_sd90_info = {
.vendor = "EDIROL", .product = "SD-90",
.ifnum = 2,
.endpoints = {{ -1, 0x000f, 0x000f }}
};
static usbmidi_device_info_t snd_usbmidi_roland_um550_info = {
.vendor = "EDIROL", .product = "UM-550",
.ifnum = 0,
.endpoints = {{ -1, 0x003f, 0x003f }}
};
#define USBMIDI_NONCOMPLIANT_DEVICE(vid, pid, name) \
USB_DEVICE(vid, pid), \
driver_info: (unsigned long)&snd_usbmidi_##name##_info
static usb_device_id_t snd_usbmidi_usb_id_table[] = {
{ match_flags: USB_DEVICE_ID_MATCH_INT_CLASS |
USB_DEVICE_ID_MATCH_INT_SUBCLASS,
bInterfaceClass: USB_CLASS_AUDIO,
bInterfaceSubClass: USB_SUBCLASS_MIDISTREAMING },
{ USBMIDI_NONCOMPLIANT_DEVICE(0x0499, 0x1000, yamaha_ux256) },
{ USBMIDI_NONCOMPLIANT_DEVICE(0x0499, 0x1001, yamaha_mu1000) },
{ USBMIDI_NONCOMPLIANT_DEVICE(0x0582, 0x0000, roland_ua100) },
{ USBMIDI_NONCOMPLIANT_DEVICE(0x0582, 0x0002, roland_um4) },
{ USBMIDI_NONCOMPLIANT_DEVICE(0x0582, 0x0003, roland_sc8850) },
{ USBMIDI_NONCOMPLIANT_DEVICE(0x0582, 0x0004, roland_u8) },
{ USBMIDI_NONCOMPLIANT_DEVICE(0x0582, 0x0005, roland_um2) },
{ USBMIDI_NONCOMPLIANT_DEVICE(0x0582, 0x0007, roland_sc8820) },
{ USBMIDI_NONCOMPLIANT_DEVICE(0x0582, 0x0008, roland_pc300) },
{ USBMIDI_NONCOMPLIANT_DEVICE(0x0582, 0x0009, roland_um1) },
{ USBMIDI_NONCOMPLIANT_DEVICE(0x0582, 0x000b, roland_sk500) },
{ USBMIDI_NONCOMPLIANT_DEVICE(0x0582, 0x000c, roland_scd70) },
{ USBMIDI_NONCOMPLIANT_DEVICE(0x0582, 0x0012, roland_xv5050) },
{ USBMIDI_NONCOMPLIANT_DEVICE(0x0582, 0x0014, roland_um880) },
{ USBMIDI_NONCOMPLIANT_DEVICE(0x0582, 0x0016, roland_sd90) },
{ USBMIDI_NONCOMPLIANT_DEVICE(0x0582, 0x0023, roland_um550) },
{ /* terminator */ }
};
MODULE_DEVICE_TABLE(usb, snd_usbmidi_usb_id_table);
static usb_driver_t snd_usbmidi_usb_driver = {
.name = "snd-usb-midi",
.probe = snd_usbmidi_usb_probe,
.disconnect = snd_usbmidi_usb_disconnect,
.id_table = snd_usbmidi_usb_id_table,
.driver_list = LIST_HEAD_INIT(snd_usbmidi_usb_driver.driver_list)
};
static int __init snd_usbmidi_module_init(void)
{
static snd_seq_dev_ops_t ops = {
snd_usbmidi_seq_device_new,
snd_usbmidi_seq_device_delete
};
int err;
err = snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_USBMIDI, &ops,
sizeof(usbmidi_t));
if (err < 0)
return err;
err = usb_register(&snd_usbmidi_usb_driver);
if (err < 0) {
snd_seq_device_unregister_driver(SNDRV_SEQ_DEV_ID_USBMIDI);
return err;
}
return 0;
}
static void __exit snd_usbmidi_module_exit(void)
{
usb_deregister(&snd_usbmidi_usb_driver);
snd_seq_device_unregister_driver(SNDRV_SEQ_DEV_ID_USBMIDI);
}
module_init(snd_usbmidi_module_init)
module_exit(snd_usbmidi_module_exit)
#ifndef MODULE
/*
* format is snd-usb-midi=snd_enable,snd_index,snd_id,
* snd_vid,snd_pid,snd_int_transfer
*/
static int __init snd_usbmidi_module_setup(char* str)
{
static unsigned __initdata nr_dev = 0;
if (nr_dev >= SNDRV_CARDS)
return 0;
(void)(get_option(&str, &snd_enable[nr_dev]) == 2 &&
get_option(&str, &snd_index[nr_dev]) == 2 &&
get_id(&str, &snd_id[nr_dev]) == 2 &&
get_option(&str, &snd_vid[nr_dev]) == 2 &&
get_option(&str, &snd_pid[nr_dev]) == 2 &&
get_option(&str, &snd_int_transfer[nr_dev]) == 2);
++nr_dev;
return 1;
}
__setup("snd-usb-midi=", snd_usbmidi_module_setup);
#endif /* !MODULE */
sound/usb/usbmixer.c 0 → 100644
View file @ a3954fd2
/*
* (Tentative) USB Audio Driver for ALSA
*
* Mixer control part
*
* Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
*
* Many codes borrowed from audio.c by
* Alan Cox (alan@lxorguk.ukuu.org.uk)
* Thomas Sailer (sailer@ife.ee.ethz.ch)
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include <sound/driver.h>
#include <linux/bitops.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/usb.h>
#include <sound/core.h>
#include <sound/control.h>
#include "usbaudio.h"
/*
*/
typedef struct usb_mixer_build mixer_build_t;
typedef struct usb_audio_term usb_audio_term_t;
typedef struct usb_mixer_elem_info usb_mixer_elem_info_t;
struct usb_audio_term {
int id;
int type;
int channels;
unsigned int chconfig;
int name;
};
struct usb_mixer_build {
snd_usb_audio_t *chip;
unsigned char *buffer;
unsigned int buflen;
unsigned int ctrlif;
unsigned long unitbitmap[32/sizeof(unsigned long)];
usb_audio_term_t oterm;
};
struct usb_mixer_elem_info {
snd_usb_audio_t *chip;
unsigned int ctrlif;
unsigned int id;
unsigned int control;
unsigned int cmask; /* channel mask bitmap: 0 = master */
int channels;
int val_type;
int min, max;
};
enum {
USB_FEATURE_MUTE = 0,
USB_FEATURE_VOLUME,
USB_FEATURE_BASS,
USB_FEATURE_MID,
USB_FEATURE_TREBLE,
USB_FEATURE_GEQ,
USB_FEATURE_AGC,
USB_FEATURE_DELAY,
USB_FEATURE_BASSBOOST,
FSB_FEATURE_LOUDNESS
};
enum {
USB_MIXER_BOOLEAN,
USB_MIXER_INV_BOOLEAN,
USB_MIXER_S8,
USB_MIXER_U8,
USB_MIXER_S16,
USB_MIXER_U16,
};
#define MAX_CHANNELS 10 /* max logical channels */
/*
* find an audio control unit with the given unit id
*/
static void *find_audio_control_unit(mixer_build_t *state, unsigned char unit)
{
unsigned char *p;
p = NULL;
while ((p = snd_usb_find_desc(state->buffer, state->buflen, p,
USB_DT_CS_INTERFACE, state->ctrlif, -1)) != NULL) {
if (p[0] >= 4 && p[2] >= INPUT_TERMINAL && p[2] <= EXTENSION_UNIT && p[3] == unit)
return p;
}
return NULL;
}
/*
* copy a string with the given id
*/
static int snd_usb_copy_string_desc(mixer_build_t *state, int index, char *buf, int maxlen)
{
int len = usb_string(state->chip->dev, index, buf, maxlen - 1);
buf[len] = 0;
return len;
}
/*
* convert from the byte/word on usb descriptor to the zero-based integer
*/
static int convert_signed_value(usb_mixer_elem_info_t *cval, int val)
{
switch (cval->val_type) {
case USB_MIXER_BOOLEAN:
return !!val;
case USB_MIXER_INV_BOOLEAN:
return !val;
case USB_MIXER_U8:
val &= 0xff;
break;
case USB_MIXER_S8:
val &= 0xff;
if (val >= 0x80)
val -= 0x100;
break;
case USB_MIXER_U16:
val &= 0xffff;
break;
case USB_MIXER_S16:
val &= 0xffff;
if (val >= 0x8000)
val -= 0x10000;
break;
}
return val;
}
/*
* convert from the zero-based int to the byte/word for usb descriptor
*/
static int convert_bytes_value(usb_mixer_elem_info_t *cval, int val)
{
switch (cval->val_type) {
case USB_MIXER_BOOLEAN:
return !!val;
case USB_MIXER_INV_BOOLEAN:
return !val;
case USB_MIXER_S8:
case USB_MIXER_U8:
return val & 0xff;
case USB_MIXER_S16:
case USB_MIXER_U16:
return val & 0xffff;
}
return 0; /* not reached */
}
static int get_relative_value(usb_mixer_elem_info_t *cval, int val)
{
if (val < cval->min)
return 0;
else if (val > cval->max)
return cval->max - cval->min;
else
return val - cval->min;
}
static int get_abs_value(usb_mixer_elem_info_t *cval, int val)
{
if (val < 0)
return cval->min;
val += cval->min;
if (val > cval->max)
return cval->max;
return val;
}
/*
* retrieve a mixer value
*/
static int get_ctl_value(usb_mixer_elem_info_t *cval, int request, int validx, int *value_ret)
{
unsigned char buf[2];
int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
if (usb_control_msg(cval->chip->dev, usb_rcvctrlpipe(cval->chip->dev, 0),
request,
USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
validx, cval->ctrlif | (cval->id << 8),
buf, val_len, HZ) < 0)
return -EINVAL;
*value_ret = convert_signed_value(cval, snd_usb_combine_bytes(buf, val_len));
return 0;
}
static int get_cur_ctl_value(usb_mixer_elem_info_t *cval, int validx, int *value)
{
return get_ctl_value(cval, GET_CUR, validx, value);
}
/* channel = 0: master, 1 = first channel */
inline static int get_cur_mix_value(usb_mixer_elem_info_t *cval, int channel, int *value)
{
return get_ctl_value(cval, GET_CUR, ((cval->control + 1) << 8) | channel, value);
}
/*
* set a mixer value
*/
static int set_ctl_value(usb_mixer_elem_info_t *cval, int request, int validx, int value_set)
{
unsigned char buf[2];
int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
value_set = convert_bytes_value(cval, value_set);
buf[0] = value_set & 0xff;
buf[1] = (value_set >> 8) & 0xff;
return usb_control_msg(cval->chip->dev, usb_sndctrlpipe(cval->chip->dev, 0),
request,
USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
validx, cval->ctrlif | (cval->id << 8),
buf, val_len, HZ);
}
static int set_cur_ctl_value(usb_mixer_elem_info_t *cval, int validx, int value)
{
return set_ctl_value(cval, SET_CUR, validx, value);
}
inline static int set_cur_mix_value(usb_mixer_elem_info_t *cval, int channel, int value)
{
return set_ctl_value(cval, SET_CUR, ((cval->control + 1) << 8) | channel, value);
}
/*
* parser routines begin here...
*/
static int parse_audio_unit(mixer_build_t *state, int unitid);
/*
* check if the input/output channel routing is enabled on the given bitmap.
* used for mixer unit parser
*/
static int check_matrix_bitmap(unsigned char *bmap, int ich, int och, int num_outs)
{
int idx = ich * num_outs + och;
return bmap[-(idx >> 3)] & (0x80 >> (idx & 7));
}
/*
* add an alsa control element
* search and increment the index until an empty slot is found.
*
* if failed, give up and free the control instance.
*/
static int add_control_to_empty(snd_card_t *card, snd_kcontrol_t *kctl)
{
int err;
while (snd_ctl_find_id(card, &kctl->id))
kctl->id.index++;
if ((err = snd_ctl_add(card, kctl)) < 0) {
snd_printk(KERN_ERR "cannot add control\n");
snd_ctl_free_one(kctl);
}
return err;
}
/*
* get a terminal name string
*/
static struct iterm_name_combo {
int type;
char *name;
} iterm_names[] = {
{ 0x0300, "Output" },
{ 0x0301, "Speaker" },
{ 0x0302, "Headphone" },
{ 0x0303, "HMD Audio" },
{ 0x0304, "Desktop Speaker" },
{ 0x0305, "Room Speaker" },
{ 0x0306, "Com Speaker" },
{ 0x0307, "LFE" },
{ 0x0600, "External In" },
{ 0x0601, "Analog In" },
{ 0x0602, "Digital In" },
{ 0x0603, "Line" },
{ 0x0604, "Legacy In" },
{ 0x0605, "IEC958 In" },
{ 0x0606, "1394 DA Stream" },
{ 0x0607, "1394 DV Stream" },
{ 0x0700, "Embedded" },
{ 0x0701, "Noise Source" },
{ 0x0702, "Equalization Noise" },
{ 0x0703, "CD" },
{ 0x0704, "DAT" },
{ 0x0705, "DCC" },
{ 0x0706, "MiniDisk" },
{ 0x0707, "Analog Tape" },
{ 0x0708, "Phonograph" },
{ 0x0709, "VCR Audio" },
{ 0x070a, "Video Disk Audio" },
{ 0x070b, "DVD Audio" },
{ 0x070c, "TV Tuner Audio" },
{ 0x070d, "Satellite Rec Audio" },
{ 0x070e, "Cable Tuner Audio" },
{ 0x070f, "DSS Audio" },
{ 0x0710, "Radio Receiver" },
{ 0x0711, "Radio Transmitter" },
{ 0x0712, "Multi-Track Recorder" },
{ 0x0713, "Synthesizer" },
{ 0 },
};
static int get_term_name(mixer_build_t *state, usb_audio_term_t *iterm,
unsigned char *name, int maxlen, int term_only)
{
struct iterm_name_combo *names;
if (iterm->name)
return snd_usb_copy_string_desc(state, iterm->name, name, maxlen);
/* virtual type - not a real terminal */
if (iterm->type >> 16) {
if (term_only)
return 0;
switch (iterm->type >> 16) {
case SELECTOR_UNIT:
strcpy(name, "Selector"); return 8;
case PROCESSING_UNIT:
strcpy(name, "Process Unit"); return 12;
case EXTENSION_UNIT:
strcpy(name, "Ext Unit"); return 8;
case MIXER_UNIT:
strcpy(name, "Mixer"); return 5;
default:
return sprintf(name, "Unit %d", iterm->id);
}
}
switch (iterm->type & 0xff00) {
case 0x0100:
strcpy(name, "PCM"); return 3;
case 0x0200:
strcpy(name, "Mic"); return 3;
case 0x0400:
strcpy(name, "Headset"); return 7;
case 0x0500:
strcpy(name, "Phone"); return 5;
}
for (names = iterm_names; names->type; names++)
if (names->type == iterm->type) {
strcpy(name, names->name);
return strlen(names->name);
}
return 0;
}
/*
* parse the source unit recursively until it reaches to a terminal
* or a branched unit.
*/
static int check_input_term(mixer_build_t *state, int id, usb_audio_term_t *term)
{
unsigned char *p1;
memset(term, 0, sizeof(*term));
while ((p1 = find_audio_control_unit(state, id)) != NULL) {
term->id = id;
switch (p1[2]) {
case INPUT_TERMINAL:
term->type = combine_word(p1 + 4);
term->channels = p1[7];
term->chconfig = combine_word(p1 + 8);
term->name = p1[11];
return 0;
case FEATURE_UNIT:
id = p1[4];
break; /* continue to parse */
case MIXER_UNIT:
term->type = p1[2] << 16; /* virtual type */
term->channels = p1[5 + p1[4]];
term->chconfig = combine_word(p1 + 6 + p1[4]);
term->name = p1[p1[0] - 1];
return 0;
case SELECTOR_UNIT:
/* call recursively to retrieve the channel info */
if (check_input_term(state, p1[5], term) < 0)
return -ENODEV;
term->type = p1[2] << 16; /* virtual type */
term->id = id;
term->name = p1[9 + p1[0] - 1];
return 0;
case PROCESSING_UNIT:
case EXTENSION_UNIT:
if (p1[6] == 1) {
id = p1[7];
break; /* continue to parse */
}
term->type = p1[2] << 16; /* virtual type */
term->channels = p1[7 + p1[6]];
term->chconfig = combine_word(p1 + 8 + p1[6]);
term->name = p1[12 + p1[6] + p1[11 + p1[6]]];
return 0;
default:
return -ENODEV;
}
}
return -ENODEV;
}
/*
* Feature Unit
*/
/* feature unit control information */
struct usb_feature_control_info {
const char *name;
unsigned int type; /* control type (mute, volume, etc.) */
};
static struct usb_feature_control_info audio_feature_info[] = {
{ "Mute", USB_MIXER_INV_BOOLEAN },
{ "Volume", USB_MIXER_S16 },
{ "Tone Control - Bass", USB_MIXER_S8 },
{ "Tone Control - Mid", USB_MIXER_S8 },
{ "Tone Control - Treble", USB_MIXER_S8 },
{ "Graphic Equalizer", USB_MIXER_S8 }, /* FIXME: not implemeted yet */
{ "Auto Gain Control", USB_MIXER_BOOLEAN },
{ "Delay Control", USB_MIXER_U16 },
{ "Bass Boost", USB_MIXER_BOOLEAN },
{ "Loudness", USB_MIXER_BOOLEAN },
};
/* private_free callback */
static void usb_mixer_elem_free(snd_kcontrol_t *kctl)
{
if (kctl->private_data) {
snd_magic_kfree((void *)kctl->private_data);
kctl->private_data = 0;
}
}
/*
* interface to ALSA control for feature/mixer units
*/
/* get a feature/mixer unit info */
static int mixer_ctl_feature_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
{
usb_mixer_elem_info_t *cval = snd_magic_cast(usb_mixer_elem_info_t, kcontrol->private_data, return -EINVAL);
if (cval->val_type == USB_MIXER_BOOLEAN ||
cval->val_type == USB_MIXER_INV_BOOLEAN)
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
else
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = cval->channels;
if (cval->val_type == USB_MIXER_BOOLEAN ||
cval->val_type == USB_MIXER_INV_BOOLEAN) {
uinfo->value.integer.min = 0;
uinfo->value.integer.max = 1;
} else {
uinfo->value.integer.min = 0;
uinfo->value.integer.max = cval->max - cval->min;
}
return 0;
}
/* get the current value from feature/mixer unit */
static int mixer_ctl_feature_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
{
usb_mixer_elem_info_t *cval = snd_magic_cast(usb_mixer_elem_info_t, kcontrol->private_data, return -EINVAL);
int c, cnt, val, err;
if (cval->cmask) {
cnt = 0;
for (c = 0; c < MAX_CHANNELS; c++) {
if (cval->cmask & (1 << c)) {
err = get_cur_mix_value(cval, c + 1, &val);
if (err < 0)
return err;
val = get_relative_value(cval, val);
ucontrol->value.integer.value[cnt] = val;
cnt++;
}
}
} else {
/* master channel */
err = get_cur_mix_value(cval, 0, &val);
if (err < 0)
return err;
val = get_relative_value(cval, val);
ucontrol->value.integer.value[0] = val;
}
return 0;
}
/* put the current value to feature/mixer unit */
static int mixer_ctl_feature_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
{
usb_mixer_elem_info_t *cval = snd_magic_cast(usb_mixer_elem_info_t, kcontrol->private_data, return -EINVAL);
int c, cnt, val, oval, err;
int changed = 0;
if (cval->cmask) {
cnt = 0;
for (c = 0; c < MAX_CHANNELS; c++) {
if (cval->cmask & (1 << c)) {
err = get_cur_mix_value(cval, c + 1, &oval);
if (err < 0)
return err;
val = ucontrol->value.integer.value[cnt];
val = get_abs_value(cval, val);
if (oval != val) {
set_cur_mix_value(cval, c + 1, val);
changed = 1;
}
cnt++;
}
}
} else {
/* master channel */
err = get_cur_mix_value(cval, 0, &oval);
if (err < 0)
return err;
val = ucontrol->value.integer.value[0];
val = get_abs_value(cval, val);
if (val != oval) {
set_cur_mix_value(cval, 0, val);
changed = 1;
}
}
return changed;
}
static snd_kcontrol_new_t usb_feature_unit_ctl = {
iface: SNDRV_CTL_ELEM_IFACE_MIXER,
name: "", /* will be filled later manually */
info: mixer_ctl_feature_info,
get: mixer_ctl_feature_get,
put: mixer_ctl_feature_put,
};
/*
* build a feature control
*/
static void build_feature_ctl(mixer_build_t *state, unsigned char *desc,
unsigned int ctl_mask, int control,
usb_audio_term_t *iterm, int unitid)
{
int len = 0;
int nameid = desc[desc[0] - 1];
snd_kcontrol_t *kctl;
usb_mixer_elem_info_t *cval;
if (control == USB_FEATURE_GEQ) {
/* FIXME: not supported yet */
return;
}
cval = snd_magic_kcalloc(usb_mixer_elem_info_t, 0, GFP_KERNEL);
if (! cval) {
snd_printk(KERN_ERR "cannot malloc kcontrol");
return;
}
cval->chip = state->chip;
cval->ctrlif = state->ctrlif;
cval->id = unitid;
cval->control = control;
cval->cmask = ctl_mask;
cval->val_type = audio_feature_info[control].type;
if (ctl_mask == 0)
cval->channels = 1; /* master channel */
else {
int i, c = 0;
for (i = 0; i < 16; i++)
if (ctl_mask & (1 << i))
c++;
cval->channels = c;
}
/* get min/max values */
if (cval->val_type == USB_MIXER_BOOLEAN ||
cval->val_type == USB_MIXER_INV_BOOLEAN)
cval->max = 1;
else {
if (get_ctl_value(cval, GET_MAX, ((cval->control+1) << 8) | (ctl_mask ? 1 : 0), &cval->max) < 0 ||
get_ctl_value(cval, GET_MIN, ((cval->control+1) << 8) | (ctl_mask ? 1 : 0), &cval->min) < 0) {
snd_printk(KERN_ERR "%d:%d: cannot get min/max values for control %d\n", cval->id, cval->ctrlif, control);
snd_magic_kfree(cval);
return;
}
}
kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
if (! kctl) {
snd_printk(KERN_ERR "cannot malloc kcontrol");
snd_magic_kfree(cval);
return;
}
kctl->private_free = usb_mixer_elem_free;
if (nameid)
len = snd_usb_copy_string_desc(state, nameid, kctl->id.name, sizeof(kctl->id.name));
switch (control) {
case USB_FEATURE_MUTE:
case USB_FEATURE_VOLUME:
/* determine the control name. the rule is:
* - if a name id is given in descriptor, use it.
* - if the connected input can be determined, then use the name
* of terminal type.
* - if the connected output can be determined, use it.
* - otherwise, anonymous name.
*/
if (! nameid) {
len = get_term_name(state, iterm, kctl->id.name, sizeof(kctl->id.name), 1);
if (! len)
len = get_term_name(state, &state->oterm, kctl->id.name, sizeof(kctl->id.name), 1);
if (! len)
len = sprintf(kctl->id.name, "Feature %d", unitid);
}
/* determine the stream direction:
* if the connected output is USB stream, then it's likely a
* capture stream. otherwise it should be playback (hopefully :)
*/
if (! (state->oterm.type >> 16)) {
if ((state->oterm.type & 0xff00) == 0x0100) {
strcpy(kctl->id.name + len, " Capture");
len += 8;
} else {
strcpy(kctl->id.name + len, " Playback");
len += 9;
}
}
strcpy(kctl->id.name + len, control == USB_FEATURE_MUTE ? " Switch" : " Volume");
break;
default:
if (! nameid)
strcpy(kctl->id.name, audio_feature_info[control].name);
break;
}
snd_printdd(KERN_INFO "[%d] FU [%s] ch = %d, val = %d/%d\n",
cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
add_control_to_empty(state->chip->card, kctl);
}
/*
* parse a feature unit
*
* most of controlls are defined here.
*/
static int parse_audio_feature_unit(mixer_build_t *state, int unitid, unsigned char *ftr)
{
int channels, i, j;
usb_audio_term_t iterm;
unsigned int master_bits, first_ch_bits;
int err, csize;
if (ftr[0] < 7 || ! (csize = ftr[5]) || ftr[0] < 7 + csize) {
snd_printk(KERN_ERR "usbaudio: unit %u: invalid FEATURE_UNIT descriptor\n", unitid);
return -EINVAL;
}
/* parse the source unit */
if ((err = parse_audio_unit(state, ftr[4])) < 0)
return err;
/* determine the input source type and name */
if (check_input_term(state, ftr[4], &iterm) < 0)
return -EINVAL;
channels = (ftr[0] - 7) / csize - 1;
master_bits = snd_usb_combine_bytes(ftr + 6, csize);
if (channels > 0)
first_ch_bits = snd_usb_combine_bytes(ftr + 6 + csize, csize);
else
first_ch_bits = 0;
/* check all control types */
for (i = 0; i < 10; i++) {
unsigned int ch_bits = 0;
for (j = 0; j < channels; j++) {
unsigned int mask = snd_usb_combine_bytes(ftr + 6 + csize * (j+1), csize);
if (mask & (1 << i))
ch_bits |= (1 << j);
}
if (ch_bits & 1) /* the first channel must be set (for ease of programming) */
build_feature_ctl(state, ftr, ch_bits, i, &iterm, unitid);
if (master_bits & (1 << i))
build_feature_ctl(state, ftr, 0, i, &iterm, unitid);
}
return 0;
}
/*
* Mixer Unit
*/
/*
* build a mixer unit control
*
* the callbacks are identical with feature unit.
* input channel number (zero based) is given in control field instead.
*/
static void build_mixer_unit_ctl(mixer_build_t *state, unsigned char *desc,
int in_ch, int unitid)
{
usb_mixer_elem_info_t *cval;
int num_ins = desc[4];
int num_outs = desc[5 + num_ins];
int i, len;
snd_kcontrol_t *kctl;
usb_audio_term_t iterm;
cval = snd_magic_kcalloc(usb_mixer_elem_info_t, 0, GFP_KERNEL);
if (! cval)
return;
if (check_input_term(state, desc[5 + in_ch], &iterm) < 0)
return;
cval->chip = state->chip;
cval->ctrlif = state->ctrlif;
cval->id = unitid;
cval->control = in_ch;
cval->val_type = USB_MIXER_S16;
for (i = 0; i < num_outs; i++) {
if (check_matrix_bitmap(desc + 9 + num_ins, in_ch, i, num_outs)) {
cval->cmask |= (1 << i);
cval->channels++;
}
}
/* get min/max values */
if (get_ctl_value(cval, GET_MAX, ((in_ch+1) << 8) | 1, &cval->max) < 0 ||
get_ctl_value(cval, GET_MIN, ((in_ch+1) << 8) | 1, &cval->min) < 0) {
snd_printk(KERN_ERR "cannot get min/max values for mixer\n");
snd_magic_kfree(cval);
return;
}
kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
if (! kctl) {
snd_printk(KERN_ERR "cannot malloc kcontrol");
snd_magic_kfree(cval);
return;
}
kctl->private_free = usb_mixer_elem_free;
len = get_term_name(state, &iterm, kctl->id.name, sizeof(kctl->id.name), 0);
if (! len)
len = sprintf(kctl->id.name, "Mixer Source %d", in_ch);
strcpy(kctl->id.name + len, " Volume");
snd_printdd(KERN_INFO "[%d] MU [%s] ch = %d, val = %d/%d\n",
cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
add_control_to_empty(state->chip->card, kctl);
}
/*
* parse a mixer unit
*/
static int parse_audio_mixer_unit(mixer_build_t *state, int unitid, unsigned char *desc)
{
int num_ins, num_outs;
int i, err;
if (desc[0] < 12 || ! (num_ins = desc[4]) || ! (num_outs = desc[5 + num_ins]))
return -EINVAL;
for (i = 0; i < num_ins; i++) {
err = parse_audio_unit(state, desc[5 + i]);
if (err < 0)
return err;
if (check_matrix_bitmap(desc + 9 + num_ins, i, 0, num_outs))
build_mixer_unit_ctl(state, desc, i, unitid);
}
return 0;
}
/*
* Processing Unit / Extension Unit
*/
/* get callback for processing/extension unit */
static int mixer_ctl_procunit_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
{
usb_mixer_elem_info_t *cval = snd_magic_cast(usb_mixer_elem_info_t, kcontrol->private_data, return -EINVAL);
int err, val;
err = get_cur_ctl_value(cval, cval->control, &val);
if (err < 0)
return err;
val = get_relative_value(cval, val);
ucontrol->value.integer.value[0] = val;
return 0;
}
/* put callback for processing/extension unit */
static int mixer_ctl_procunit_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
{
usb_mixer_elem_info_t *cval = snd_magic_cast(usb_mixer_elem_info_t, kcontrol->private_data, return -EINVAL);
int val, oval, err;
err = get_cur_ctl_value(cval, cval->control, &oval);
if (err < 0)
return err;
val = ucontrol->value.integer.value[0];
val = get_abs_value(cval, val);
if (val != oval) {
set_cur_ctl_value(cval, cval->control, val);
return 1;
}
return 0;
}
/* alsa control interface for processing/extension unit */
static snd_kcontrol_new_t mixer_procunit_ctl = {
iface: SNDRV_CTL_ELEM_IFACE_MIXER,
name: "", /* will be filled later */
info: mixer_ctl_feature_info,
get: mixer_ctl_procunit_get,
put: mixer_ctl_procunit_put,
};
/*
* predefined data for processing units
*/
struct procunit_value_info {
int control;
char *suffix;
int val_type;
};
struct procunit_info {
int type;
char *name;
struct procunit_value_info *values;
};
static struct procunit_value_info updown_proc_info[] = {
{ 0x01, "Switch", USB_MIXER_BOOLEAN },
{ 0x02, "Mode Select", USB_MIXER_U8 },
{ 0 }
};
static struct procunit_value_info prologic_proc_info[] = {
{ 0x01, "Switch", USB_MIXER_BOOLEAN },
{ 0x02, "Mode Select", USB_MIXER_U8 },
{ 0 }
};
static struct procunit_value_info threed_enh_proc_info[] = {
{ 0x01, "Switch", USB_MIXER_BOOLEAN },
{ 0x02, "Spaciousness", USB_MIXER_U8 },
{ 0 }
};
static struct procunit_value_info reverb_proc_info[] = {
{ 0x01, "Switch", USB_MIXER_BOOLEAN },
{ 0x02, "Level", USB_MIXER_U8 },
{ 0x03, "Time", USB_MIXER_U16 },
{ 0x04, "Delay", USB_MIXER_U8 },
{ 0 }
};
static struct procunit_value_info chorus_proc_info[] = {
{ 0x01, "Switch", USB_MIXER_BOOLEAN },
{ 0x02, "Level", USB_MIXER_U8 },
{ 0x03, "Rate", USB_MIXER_U16 },
{ 0x04, "Depth", USB_MIXER_U16 },
{ 0 }
};
static struct procunit_value_info dcr_proc_info[] = {
{ 0x01, "Switch", USB_MIXER_BOOLEAN },
{ 0x02, "Ratio", USB_MIXER_U16 },
{ 0x03, "Max Amp", USB_MIXER_S16 },
{ 0x04, "Threshold", USB_MIXER_S16 },
{ 0x05, "Attack Time", USB_MIXER_U16 },
{ 0x06, "Release Time", USB_MIXER_U16 },
{ 0 }
};
static struct procunit_info procunits[] = {
{ 0x01, "Up Down", updown_proc_info },
{ 0x02, "Dolby Prologic", prologic_proc_info },
{ 0x03, "3D Stereo Extender", threed_enh_proc_info },
{ 0x04, "Reverb", reverb_proc_info },
{ 0x05, "Chorus", chorus_proc_info },
{ 0x06, "DCR", dcr_proc_info },
{ 0 },
};
/*
* build a processing/extension unit
*/
static int build_audio_procunit(mixer_build_t *state, int unitid, unsigned char *dsc, struct procunit_info *list, char *name)
{
int num_ins = dsc[6];
usb_mixer_elem_info_t *cval;
snd_kcontrol_t *kctl;
int i, err, nameid, type;
struct procunit_info *info;
struct procunit_value_info *valinfo;
static struct procunit_value_info default_value_info[] = {
{ 0x01, "Switch", USB_MIXER_BOOLEAN },
{ 0 }
};
static struct procunit_info default_info = {
0, NULL, default_value_info
};
if (dsc[0] < 13 || dsc[0] < 13 + num_ins || dsc[0] < num_ins + dsc[11 + num_ins]) {
snd_printk(KERN_ERR "invalid %s descriptor %d\n", name, unitid);
return -EINVAL;
}
for (i = 0; i < num_ins; i++) {
if ((err = parse_audio_unit(state, dsc[7 + i])) < 0)
return err;
}
type = combine_word(&dsc[4]);
if (! type)
return 0; /* undefined? */
for (info = list; info && info->type; info++)
if (info->type == type)
break;
if (! info || ! info->type)
info = &default_info;
for (valinfo = info->values; valinfo->control; valinfo++) {
/* FIXME: bitmap might be longer than 8bit */
if (! (dsc[12 + num_ins] & (1 << (valinfo->control - 1))))
continue;
cval = snd_magic_kcalloc(usb_mixer_elem_info_t, 0, GFP_KERNEL);
if (! cval) {
snd_printk(KERN_ERR "cannot malloc kcontrol");
return -ENOMEM;
}
cval->chip = state->chip;
cval->ctrlif = state->ctrlif;
cval->id = unitid;
cval->control = valinfo->control;
cval->val_type = valinfo->val_type;
cval->channels = 1;
/* get min/max values */
if (get_ctl_value(cval, GET_MAX, cval->control, &cval->max) < 0 ||
get_ctl_value(cval, GET_MIN, cval->control, &cval->min) < 0) {
snd_printk(KERN_ERR "cannot get min/max values for proc/ext unit\n");
snd_magic_kfree(cval);
continue;
}
kctl = snd_ctl_new1(&mixer_procunit_ctl, cval);
if (! kctl) {
snd_printk(KERN_ERR "cannot malloc kcontrol");
snd_magic_kfree(cval);
return -ENOMEM;
}
kctl->private_free = usb_mixer_elem_free;
if (info->name)
sprintf(kctl->id.name, "%s %s", info->name, valinfo->suffix);
else {
nameid = dsc[12 + num_ins + dsc[11 + num_ins]];
if (nameid) {
int len = snd_usb_copy_string_desc(state, nameid, kctl->id.name, sizeof(kctl->id.name));
strcpy(kctl->id.name + len, valinfo->suffix);
} else
sprintf(kctl->id.name, "%s %s", name, valinfo->suffix);
}
snd_printdd(KERN_INFO "[%d] PU [%s] ch = %d, val = %d/%d\n",
cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
if ((err = add_control_to_empty(state->chip->card, kctl)) < 0)
return err;
}
return 0;
}
static int parse_audio_processing_unit(mixer_build_t *state, int unitid, unsigned char *desc)
{
return build_audio_procunit(state, unitid, desc, procunits, "Processing Unit");
}
static int parse_audio_extension_unit(mixer_build_t *state, int unitid, unsigned char *desc)
{
return build_audio_procunit(state, unitid, desc, NULL, "Extension Unit");
}
/*
* Selector Unit
*/
/* info callback for selector unit
* use an enumerator type for routing
*/
static int mixer_ctl_selector_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
{
usb_mixer_elem_info_t *cval = snd_magic_cast(usb_mixer_elem_info_t, kcontrol->private_data, return -EINVAL);
char **itemlist = (char **)kcontrol->private_value;
snd_assert(itemlist, return -EINVAL);
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
uinfo->count = 1;
uinfo->value.enumerated.items = cval->max;
if (uinfo->value.enumerated.item >= cval->max)
uinfo->value.enumerated.item = cval->max - 1;
strcpy(uinfo->value.enumerated.name, itemlist[uinfo->value.enumerated.item]);
return 0;
}
/* get callback for selector unit */
static int mixer_ctl_selector_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
{
usb_mixer_elem_info_t *cval = snd_magic_cast(usb_mixer_elem_info_t, kcontrol->private_data, return -EINVAL);
int val, err;
err = get_cur_ctl_value(cval, 0, &val);
if (err < 0)
return err;
val = get_relative_value(cval, val);
ucontrol->value.enumerated.item[0] = val;
return 0;
}
/* put callback for selector unit */
static int mixer_ctl_selector_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
{
usb_mixer_elem_info_t *cval = snd_magic_cast(usb_mixer_elem_info_t, kcontrol->private_data, return -EINVAL);
int val, oval, err;
err = get_cur_ctl_value(cval, 0, &oval);
if (err < 0)
return err;
val = ucontrol->value.enumerated.item[0];
val = get_abs_value(cval, val);
if (val != oval) {
set_cur_ctl_value(cval, 0, val);
return 1;
}
return 0;
}
/* alsa control interface for selector unit */
static snd_kcontrol_new_t mixer_selectunit_ctl = {
iface: SNDRV_CTL_ELEM_IFACE_MIXER,
name: "", /* will be filled later */
info: mixer_ctl_selector_info,
get: mixer_ctl_selector_get,
put: mixer_ctl_selector_put,
};
/* private free callback.
* free both private_data and private_value
*/
static void usb_mixer_selector_elem_free(snd_kcontrol_t *kctl)
{
int i, num_ins = 0;
if (kctl->private_data) {
usb_mixer_elem_info_t *cval = snd_magic_cast(usb_mixer_elem_info_t, kctl->private_data,);
num_ins = cval->max;
snd_magic_kfree(cval);
kctl->private_data = 0;
}
if (kctl->private_value) {
char **itemlist = (char **)kctl->private_value;
for (i = 0; i < num_ins; i++)
kfree(itemlist[i]);
kfree(itemlist);
kctl->private_value = 0;
}
}
/*
* parse a selector unit
*/
static int parse_audio_selector_unit(mixer_build_t *state, int unitid, unsigned char *desc)
{
int num_ins = desc[4];
int i, err, nameid;
usb_mixer_elem_info_t *cval;
snd_kcontrol_t *kctl;
char **namelist;
if (! num_ins || desc[0] < 6 + num_ins) {
snd_printk(KERN_ERR "invalid SELECTOR UNIT descriptor %d\n", unitid);
return -EINVAL;
}
for (i = 0; i < num_ins; i++) {
if ((err = parse_audio_unit(state, desc[5 + i])) < 0)
return err;
}
cval = snd_magic_kcalloc(usb_mixer_elem_info_t, 0, GFP_KERNEL);
if (! cval) {
snd_printk(KERN_ERR "cannot malloc kcontrol");
return -ENOMEM;
}
cval->chip = state->chip;
cval->ctrlif = state->ctrlif;
cval->id = unitid;
cval->val_type = USB_MIXER_U8;
cval->channels = 1;
cval->min = 1;
cval->max = num_ins;
namelist = kmalloc(sizeof(char *) * num_ins, GFP_KERNEL);
if (! namelist) {
snd_printk(KERN_ERR "cannot malloc\n");
snd_magic_kfree(cval);
return -ENOMEM;
}
#define MAX_ITEM_NAME_LEN 64
for (i = 0; i < num_ins; i++) {
usb_audio_term_t iterm;
int len = 0;
namelist[i] = kmalloc(MAX_ITEM_NAME_LEN, GFP_KERNEL);
if (! namelist[i]) {
snd_printk(KERN_ERR "cannot malloc\n");
while (--i > 0)
kfree(namelist[i]);
kfree(namelist);
snd_magic_kfree(cval);
return -ENOMEM;
}
if (check_input_term(state, desc[5 + i], &iterm) >= 0)
len = get_term_name(state, &iterm, namelist[i], MAX_ITEM_NAME_LEN, 0);
if (! len)
sprintf(namelist[i], "Input %d", i);
}
kctl = snd_ctl_new1(&mixer_selectunit_ctl, cval);
if (! kctl) {
snd_printk(KERN_ERR "cannot malloc kcontrol");
snd_magic_kfree(cval);
return -ENOMEM;
}
kctl->private_value = (unsigned long)namelist;
kctl->private_free = usb_mixer_selector_elem_free;
nameid = desc[desc[0] - 1];
if (nameid)
snd_usb_copy_string_desc(state, nameid, kctl->id.name, sizeof(kctl->id.name));
else {
int len = get_term_name(state, &state->oterm,
kctl->id.name, sizeof(kctl->id.name), 0);
if (! len)
len = sprintf(kctl->id.name, "USB");
if ((state->oterm.type & 0xff00) == 0x0100)
strcpy(kctl->id.name + len, " Capture Source");
else
strcpy(kctl->id.name + len, " Playback Source");
}
snd_printdd(KERN_INFO "[%d] SU [%s] items = %d\n",
cval->id, kctl->id.name, num_ins);
if ((err = add_control_to_empty(state->chip->card, kctl)) < 0)
return err;
return 0;
}
/*
* parse an audio unit recursively
*/
static int parse_audio_unit(mixer_build_t *state, int unitid)
{
unsigned char *p1;
if (test_and_set_bit(unitid, &state->unitbitmap))
return 0; /* the unit already visited */
p1 = find_audio_control_unit(state, unitid);
if (!p1) {
snd_printk(KERN_ERR "usbaudio: unit %d not found!\n", unitid);
return -EINVAL;
}
switch (p1[2]) {
case INPUT_TERMINAL:
return 0; /* NOP */
case MIXER_UNIT:
return parse_audio_mixer_unit(state, unitid, p1);
case SELECTOR_UNIT:
return parse_audio_selector_unit(state, unitid, p1);
case FEATURE_UNIT:
return parse_audio_feature_unit(state, unitid, p1);
case PROCESSING_UNIT:
return parse_audio_processing_unit(state, unitid, p1);
case EXTENSION_UNIT:
return parse_audio_extension_unit(state, unitid, p1);
default:
snd_printk(KERN_ERR "usbaudio: unit %u: unexpected type 0x%02x\n", unitid, p1[2]);
return -EINVAL;
}
}
/*
* create mixer controls
*
* walk through all OUTPUT_TERMINAL descriptors to search for mixers
*/
int snd_usb_create_mixer(snd_usb_audio_t *chip, int ctrlif, unsigned char *buffer, int buflen)
{
unsigned char *desc;
mixer_build_t state;
int err;
strcpy(chip->card->mixername, "USB Mixer");
memset(&state, 0, sizeof(state));
state.chip = chip;
state.buffer = buffer;
state.buflen = buflen;
state.ctrlif = ctrlif;
desc = NULL;
while ((desc = snd_usb_find_csint_desc(buffer, buflen, desc, OUTPUT_TERMINAL, ctrlif, -1)) != NULL) {
if (desc[0] < 9)
continue; /* invalid descriptor? */
set_bit(desc[3], &state.unitbitmap); /* mark terminal ID as visited */
state.oterm.id = desc[3];
state.oterm.type = combine_word(&desc[4]);
state.oterm.name = desc[8];
err = parse_audio_unit(&state, desc[7]);
if (err < 0)
return err;
}
return 0;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7