2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* (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 <linux/bitops.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/usb.h>
|
2010-02-22 23:49:09 +01:00
|
|
|
#include <linux/usb/audio.h>
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <sound/core.h>
|
|
|
|
#include <sound/control.h>
|
2005-04-29 16:29:28 +02:00
|
|
|
#include <sound/hwdep.h>
|
2005-05-10 14:47:38 +02:00
|
|
|
#include <sound/info.h>
|
2006-07-14 15:18:19 +02:00
|
|
|
#include <sound/tlv.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#include "usbaudio.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* ignore error from controls - for debugging */
|
|
|
|
/* #define IGNORE_CTL_ERROR */
|
|
|
|
|
2006-05-05 09:49:53 +02:00
|
|
|
/*
|
|
|
|
* Sound Blaster remote control configuration
|
|
|
|
*
|
|
|
|
* format of remote control data:
|
|
|
|
* Extigy: xx 00
|
|
|
|
* Audigy 2 NX: 06 80 xx 00 00 00
|
|
|
|
* Live! 24-bit: 06 80 xx yy 22 83
|
|
|
|
*/
|
|
|
|
static const struct rc_config {
|
|
|
|
u32 usb_id;
|
|
|
|
u8 offset;
|
|
|
|
u8 length;
|
|
|
|
u8 packet_length;
|
2008-08-05 11:01:00 +02:00
|
|
|
u8 min_packet_length; /* minimum accepted length of the URB result */
|
2006-05-05 09:49:53 +02:00
|
|
|
u8 mute_mixer_id;
|
|
|
|
u32 mute_code;
|
|
|
|
} rc_configs[] = {
|
2008-08-05 11:01:00 +02:00
|
|
|
{ USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */
|
|
|
|
{ USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */
|
|
|
|
{ USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */
|
2009-01-07 22:58:50 +01:00
|
|
|
{ USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */
|
2006-05-05 09:49:53 +02:00
|
|
|
};
|
|
|
|
|
2010-02-16 11:17:09 +01:00
|
|
|
#define MAX_ID_ELEMS 256
|
|
|
|
|
2005-04-29 16:23:13 +02:00
|
|
|
struct usb_mixer_interface {
|
2005-11-17 15:08:02 +01:00
|
|
|
struct snd_usb_audio *chip;
|
2005-04-29 16:23:13 +02:00
|
|
|
unsigned int ctrlif;
|
|
|
|
struct list_head list;
|
|
|
|
unsigned int ignore_ctl_error;
|
2005-04-29 16:26:14 +02:00
|
|
|
struct urb *urb;
|
2010-02-16 11:17:09 +01:00
|
|
|
/* array[MAX_ID_ELEMS], indexed by unit id */
|
|
|
|
struct usb_mixer_elem_info **id_elems;
|
2005-04-29 16:29:28 +02:00
|
|
|
|
|
|
|
/* Sound Blaster remote control stuff */
|
2006-05-05 09:49:53 +02:00
|
|
|
const struct rc_config *rc_cfg;
|
2005-04-29 16:29:28 +02:00
|
|
|
u32 rc_code;
|
|
|
|
wait_queue_head_t rc_waitq;
|
|
|
|
struct urb *rc_urb;
|
|
|
|
struct usb_ctrlrequest *rc_setup_packet;
|
|
|
|
u8 rc_buffer[6];
|
2005-05-03 08:02:40 +02:00
|
|
|
|
|
|
|
u8 audigy2nx_leds[3];
|
2009-07-13 11:39:29 +02:00
|
|
|
u8 xonar_u1_status;
|
2005-04-29 16:23:13 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
struct usb_audio_term {
|
|
|
|
int id;
|
|
|
|
int type;
|
|
|
|
int channels;
|
|
|
|
unsigned int chconfig;
|
|
|
|
int name;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct usbmix_name_map;
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
struct mixer_build {
|
|
|
|
struct snd_usb_audio *chip;
|
2005-04-29 16:23:13 +02:00
|
|
|
struct usb_mixer_interface *mixer;
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned char *buffer;
|
|
|
|
unsigned int buflen;
|
2010-02-16 11:55:18 +01:00
|
|
|
DECLARE_BITMAP(unitbitmap, MAX_ID_ELEMS);
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_audio_term oterm;
|
2005-04-17 00:20:36 +02:00
|
|
|
const struct usbmix_name_map *map;
|
2005-04-22 15:49:52 +02:00
|
|
|
const struct usbmix_selector_map *selector_map;
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
2009-01-15 17:05:24 +01:00
|
|
|
#define MAX_CHANNELS 10 /* max logical channels */
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
struct usb_mixer_elem_info {
|
2005-04-29 16:23:13 +02:00
|
|
|
struct usb_mixer_interface *mixer;
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_mixer_elem_info *next_id_elem; /* list of controls with same id */
|
|
|
|
struct snd_ctl_elem_id *elem_id;
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned int id;
|
|
|
|
unsigned int control; /* CS or ICN (high byte) */
|
|
|
|
unsigned int cmask; /* channel mask bitmap: 0 = master */
|
|
|
|
int channels;
|
|
|
|
int val_type;
|
|
|
|
int min, max, res;
|
2010-02-11 17:50:44 +01:00
|
|
|
int dBmin, dBmax;
|
2009-01-15 17:05:24 +01:00
|
|
|
int cached;
|
|
|
|
int cache_val[MAX_CHANNELS];
|
2005-04-29 16:26:14 +02:00
|
|
|
u8 initialized;
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
enum {
|
|
|
|
USB_FEATURE_NONE = 0,
|
|
|
|
USB_FEATURE_MUTE = 1,
|
|
|
|
USB_FEATURE_VOLUME,
|
|
|
|
USB_FEATURE_BASS,
|
|
|
|
USB_FEATURE_MID,
|
|
|
|
USB_FEATURE_TREBLE,
|
|
|
|
USB_FEATURE_GEQ,
|
|
|
|
USB_FEATURE_AGC,
|
|
|
|
USB_FEATURE_DELAY,
|
|
|
|
USB_FEATURE_BASSBOOST,
|
|
|
|
USB_FEATURE_LOUDNESS
|
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
|
|
|
USB_MIXER_BOOLEAN,
|
|
|
|
USB_MIXER_INV_BOOLEAN,
|
|
|
|
USB_MIXER_S8,
|
|
|
|
USB_MIXER_U8,
|
|
|
|
USB_MIXER_S16,
|
|
|
|
USB_MIXER_U16,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
|
|
|
USB_PROC_UPDOWN = 1,
|
|
|
|
USB_PROC_UPDOWN_SWITCH = 1,
|
|
|
|
USB_PROC_UPDOWN_MODE_SEL = 2,
|
|
|
|
|
|
|
|
USB_PROC_PROLOGIC = 2,
|
|
|
|
USB_PROC_PROLOGIC_SWITCH = 1,
|
|
|
|
USB_PROC_PROLOGIC_MODE_SEL = 2,
|
|
|
|
|
|
|
|
USB_PROC_3DENH = 3,
|
|
|
|
USB_PROC_3DENH_SWITCH = 1,
|
|
|
|
USB_PROC_3DENH_SPACE = 2,
|
|
|
|
|
|
|
|
USB_PROC_REVERB = 4,
|
|
|
|
USB_PROC_REVERB_SWITCH = 1,
|
|
|
|
USB_PROC_REVERB_LEVEL = 2,
|
|
|
|
USB_PROC_REVERB_TIME = 3,
|
|
|
|
USB_PROC_REVERB_DELAY = 4,
|
|
|
|
|
|
|
|
USB_PROC_CHORUS = 5,
|
|
|
|
USB_PROC_CHORUS_SWITCH = 1,
|
|
|
|
USB_PROC_CHORUS_LEVEL = 2,
|
|
|
|
USB_PROC_CHORUS_RATE = 3,
|
|
|
|
USB_PROC_CHORUS_DEPTH = 4,
|
|
|
|
|
|
|
|
USB_PROC_DCR = 6,
|
|
|
|
USB_PROC_DCR_SWITCH = 1,
|
|
|
|
USB_PROC_DCR_RATIO = 2,
|
|
|
|
USB_PROC_DCR_MAX_AMP = 3,
|
|
|
|
USB_PROC_DCR_THRESHOLD = 4,
|
|
|
|
USB_PROC_DCR_ATTACK = 5,
|
|
|
|
USB_PROC_DCR_RELEASE = 6,
|
|
|
|
};
|
|
|
|
|
2009-12-27 18:13:41 +01:00
|
|
|
/*E-mu 0202(0404) eXtension Unit(XU) control*/
|
|
|
|
enum {
|
|
|
|
USB_XU_CLOCK_RATE = 0xe301,
|
|
|
|
USB_XU_CLOCK_SOURCE = 0xe302,
|
|
|
|
USB_XU_DIGITAL_IO_STATUS = 0xe303,
|
|
|
|
USB_XU_DEVICE_OPTIONS = 0xe304,
|
|
|
|
USB_XU_DIRECT_MONITORING = 0xe305,
|
|
|
|
USB_XU_METERING = 0xe306
|
|
|
|
};
|
|
|
|
enum {
|
|
|
|
USB_XU_CLOCK_SOURCE_SELECTOR = 0x02, /* clock source*/
|
|
|
|
USB_XU_CLOCK_RATE_SELECTOR = 0x03, /* clock rate */
|
|
|
|
USB_XU_DIGITAL_FORMAT_SELECTOR = 0x01, /* the spdif format */
|
|
|
|
USB_XU_SOFT_LIMIT_SELECTOR = 0x03 /* soft limiter */
|
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* manual mapping of mixer names
|
|
|
|
* if the mixer topology is too complicated and the parsed names are
|
|
|
|
* ambiguous, add the entries in usbmixer_maps.c.
|
|
|
|
*/
|
|
|
|
#include "usbmixer_maps.c"
|
|
|
|
|
2010-02-11 17:50:44 +01:00
|
|
|
static const struct usbmix_name_map *
|
|
|
|
find_map(struct mixer_build *state, int unitid, int control)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-02-11 17:50:44 +01:00
|
|
|
const struct usbmix_name_map *p = state->map;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-02-11 17:50:44 +01:00
|
|
|
if (!p)
|
|
|
|
return NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
for (p = state->map; p->id; p++) {
|
2010-02-11 17:50:44 +01:00
|
|
|
if (p->id == unitid &&
|
|
|
|
(!control || !p->control || control == p->control))
|
|
|
|
return p;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2010-02-11 17:50:44 +01:00
|
|
|
return NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2010-02-11 17:50:44 +01:00
|
|
|
/* get the mapped name if the unit matches */
|
|
|
|
static int
|
|
|
|
check_mapped_name(const struct usbmix_name_map *p, char *buf, int buflen)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-02-11 17:50:44 +01:00
|
|
|
if (!p || !p->name)
|
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-02-11 17:50:44 +01:00
|
|
|
buflen--;
|
|
|
|
return strlcpy(buf, p->name, buflen);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check whether the control should be ignored */
|
|
|
|
static inline int
|
|
|
|
check_ignored_ctl(const struct usbmix_name_map *p)
|
|
|
|
{
|
|
|
|
if (!p || p->name || p->dB)
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
2010-02-11 17:50:44 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* dB mapping */
|
|
|
|
static inline void check_mapped_dB(const struct usbmix_name_map *p,
|
|
|
|
struct usb_mixer_elem_info *cval)
|
|
|
|
{
|
|
|
|
if (p && p->dB) {
|
|
|
|
cval->dBmin = p->dB->min;
|
|
|
|
cval->dBmax = p->dB->max;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-22 15:49:52 +02:00
|
|
|
/* get the mapped selector source name */
|
2005-11-17 15:08:02 +01:00
|
|
|
static int check_mapped_selector_name(struct mixer_build *state, int unitid,
|
2005-04-22 15:49:52 +02:00
|
|
|
int index, char *buf, int buflen)
|
|
|
|
{
|
|
|
|
const struct usbmix_selector_map *p;
|
|
|
|
|
|
|
|
if (! state->selector_map)
|
|
|
|
return 0;
|
|
|
|
for (p = state->selector_map; p->id; p++) {
|
|
|
|
if (p->id == unitid && index < p->count)
|
|
|
|
return strlcpy(buf, p->names[index], buflen);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* find an audio control unit with the given unit id
|
|
|
|
*/
|
2005-11-17 15:08:02 +01:00
|
|
|
static void *find_audio_control_unit(struct mixer_build *state, unsigned char unit)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
unsigned char *p;
|
|
|
|
|
|
|
|
p = NULL;
|
|
|
|
while ((p = snd_usb_find_desc(state->buffer, state->buflen, p,
|
|
|
|
USB_DT_CS_INTERFACE)) != NULL) {
|
2010-02-22 23:49:13 +01:00
|
|
|
if (p[0] >= 4 && p[2] >= UAC_INPUT_TERMINAL && p[2] <= UAC_EXTENSION_UNIT_V1 && p[3] == unit)
|
2005-04-17 00:20:36 +02:00
|
|
|
return p;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* copy a string with the given id
|
|
|
|
*/
|
2005-11-17 15:08:02 +01:00
|
|
|
static int snd_usb_copy_string_desc(struct mixer_build *state, int index, char *buf, int maxlen)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
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
|
|
|
|
*/
|
2005-11-17 15:08:02 +01:00
|
|
|
static int convert_signed_value(struct usb_mixer_elem_info *cval, int val)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
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
|
|
|
|
*/
|
2005-11-17 15:08:02 +01:00
|
|
|
static int convert_bytes_value(struct usb_mixer_elem_info *cval, int val)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
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 */
|
|
|
|
}
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static int get_relative_value(struct usb_mixer_elem_info *cval, int val)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
if (! cval->res)
|
|
|
|
cval->res = 1;
|
|
|
|
if (val < cval->min)
|
|
|
|
return 0;
|
2006-03-28 17:58:28 +02:00
|
|
|
else if (val >= cval->max)
|
|
|
|
return (cval->max - cval->min + cval->res - 1) / cval->res;
|
2005-04-17 00:20:36 +02:00
|
|
|
else
|
|
|
|
return (val - cval->min) / cval->res;
|
|
|
|
}
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static int get_abs_value(struct usb_mixer_elem_info *cval, int val)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
if (val < 0)
|
|
|
|
return cval->min;
|
|
|
|
if (! cval->res)
|
|
|
|
cval->res = 1;
|
|
|
|
val *= cval->res;
|
|
|
|
val += cval->min;
|
|
|
|
if (val > cval->max)
|
|
|
|
return cval->max;
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* retrieve a mixer value
|
|
|
|
*/
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static int get_ctl_value(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
unsigned char buf[2];
|
|
|
|
int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
|
|
|
|
int timeout = 10;
|
|
|
|
|
|
|
|
while (timeout-- > 0) {
|
2005-04-29 16:23:13 +02:00
|
|
|
if (snd_usb_ctl_msg(cval->mixer->chip->dev,
|
|
|
|
usb_rcvctrlpipe(cval->mixer->chip->dev, 0),
|
2005-04-17 00:20:36 +02:00
|
|
|
request,
|
|
|
|
USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
|
2005-04-29 16:23:13 +02:00
|
|
|
validx, cval->mixer->ctrlif | (cval->id << 8),
|
2007-05-15 11:47:48 +02:00
|
|
|
buf, val_len, 100) >= val_len) {
|
2005-04-17 00:20:36 +02:00
|
|
|
*value_ret = convert_signed_value(cval, snd_usb_combine_bytes(buf, val_len));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2005-04-29 16:23:13 +02:00
|
|
|
snd_printdd(KERN_ERR "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
|
|
|
|
request, validx, cval->mixer->ctrlif | (cval->id << 8), cval->val_type);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static int get_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int *value)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-02-22 23:49:13 +01:00
|
|
|
return get_ctl_value(cval, UAC_GET_CUR, validx, value);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* channel = 0: master, 1 = first channel */
|
2009-01-15 17:05:24 +01:00
|
|
|
static inline int get_cur_mix_raw(struct usb_mixer_elem_info *cval,
|
|
|
|
int channel, int *value)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-02-22 23:49:13 +01:00
|
|
|
return get_ctl_value(cval, UAC_GET_CUR, (cval->control << 8) | channel, value);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2009-01-15 17:05:24 +01:00
|
|
|
static int get_cur_mix_value(struct usb_mixer_elem_info *cval,
|
|
|
|
int channel, int index, int *value)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (cval->cached & (1 << channel)) {
|
|
|
|
*value = cval->cache_val[index];
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
err = get_cur_mix_raw(cval, channel, value);
|
|
|
|
if (err < 0) {
|
|
|
|
if (!cval->mixer->ignore_ctl_error)
|
|
|
|
snd_printd(KERN_ERR "cannot get current value for "
|
|
|
|
"control %d ch %d: err = %d\n",
|
|
|
|
cval->control, channel, err);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
cval->cached |= 1 << channel;
|
|
|
|
cval->cache_val[index] = *value;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* set a mixer value
|
|
|
|
*/
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static int set_ctl_value(struct usb_mixer_elem_info *cval, int request, int validx, int value_set)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
unsigned char buf[2];
|
|
|
|
int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
|
|
|
|
int timeout = 10;
|
|
|
|
|
|
|
|
value_set = convert_bytes_value(cval, value_set);
|
|
|
|
buf[0] = value_set & 0xff;
|
|
|
|
buf[1] = (value_set >> 8) & 0xff;
|
2009-04-03 09:38:14 +02:00
|
|
|
while (timeout-- > 0)
|
2005-04-29 16:23:13 +02:00
|
|
|
if (snd_usb_ctl_msg(cval->mixer->chip->dev,
|
|
|
|
usb_sndctrlpipe(cval->mixer->chip->dev, 0),
|
2005-04-17 00:20:36 +02:00
|
|
|
request,
|
|
|
|
USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
|
2005-04-29 16:23:13 +02:00
|
|
|
validx, cval->mixer->ctrlif | (cval->id << 8),
|
2005-04-17 00:20:36 +02:00
|
|
|
buf, val_len, 100) >= 0)
|
|
|
|
return 0;
|
2005-04-29 16:23:13 +02:00
|
|
|
snd_printdd(KERN_ERR "cannot set ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d, data = %#x/%#x\n",
|
|
|
|
request, validx, cval->mixer->ctrlif | (cval->id << 8), cval->val_type, buf[0], buf[1]);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static int set_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int value)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-02-22 23:49:13 +01:00
|
|
|
return set_ctl_value(cval, UAC_SET_CUR, validx, value);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2009-01-15 17:05:24 +01:00
|
|
|
static int set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel,
|
|
|
|
int index, int value)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2009-01-15 17:05:24 +01:00
|
|
|
int err;
|
2010-02-22 23:49:13 +01:00
|
|
|
err = set_ctl_value(cval, UAC_SET_CUR, (cval->control << 8) | channel,
|
2009-01-15 17:05:24 +01:00
|
|
|
value);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
cval->cached |= 1 << channel;
|
|
|
|
cval->cache_val[index] = value;
|
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-07-14 15:18:19 +02:00
|
|
|
/*
|
|
|
|
* TLV callback for mixer volume controls
|
|
|
|
*/
|
|
|
|
static int mixer_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
|
|
|
|
unsigned int size, unsigned int __user *_tlv)
|
|
|
|
{
|
|
|
|
struct usb_mixer_elem_info *cval = kcontrol->private_data;
|
2009-06-16 14:04:37 +02:00
|
|
|
DECLARE_TLV_DB_MINMAX(scale, 0, 0);
|
2006-07-14 15:18:19 +02:00
|
|
|
|
|
|
|
if (size < sizeof(scale))
|
|
|
|
return -ENOMEM;
|
2010-02-11 17:50:44 +01:00
|
|
|
scale[2] = cval->dBmin;
|
|
|
|
scale[3] = cval->dBmax;
|
2006-07-14 15:18:19 +02:00
|
|
|
if (copy_to_user(_tlv, scale, sizeof(scale)))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* parser routines begin here...
|
|
|
|
*/
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static int parse_audio_unit(struct mixer_build *state, int unitid);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static int add_control_to_empty(struct mixer_build *state, struct snd_kcontrol *kctl)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_mixer_elem_info *cval = kctl->private_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
int err;
|
2005-04-29 16:23:13 +02:00
|
|
|
|
|
|
|
while (snd_ctl_find_id(state->chip->card, &kctl->id))
|
2005-04-17 00:20:36 +02:00
|
|
|
kctl->id.index++;
|
2005-04-29 16:23:13 +02:00
|
|
|
if ((err = snd_ctl_add(state->chip->card, kctl)) < 0) {
|
2005-04-17 00:20:36 +02:00
|
|
|
snd_printd(KERN_ERR "cannot add control (err = %d)\n", err);
|
2005-04-29 16:26:14 +02:00
|
|
|
return err;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2005-04-29 16:26:14 +02:00
|
|
|
cval->elem_id = &kctl->id;
|
|
|
|
cval->next_id_elem = state->mixer->id_elems[cval->id];
|
|
|
|
state->mixer->id_elems[cval->id] = cval;
|
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 },
|
|
|
|
};
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static int get_term_name(struct mixer_build *state, struct usb_audio_term *iterm,
|
2005-04-17 00:20:36 +02:00
|
|
|
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) {
|
2010-02-22 23:49:13 +01:00
|
|
|
case UAC_SELECTOR_UNIT:
|
2005-04-17 00:20:36 +02:00
|
|
|
strcpy(name, "Selector"); return 8;
|
2010-02-22 23:49:13 +01:00
|
|
|
case UAC_PROCESSING_UNIT_V1:
|
2005-04-17 00:20:36 +02:00
|
|
|
strcpy(name, "Process Unit"); return 12;
|
2010-02-22 23:49:13 +01:00
|
|
|
case UAC_EXTENSION_UNIT_V1:
|
2005-04-17 00:20:36 +02:00
|
|
|
strcpy(name, "Ext Unit"); return 8;
|
2010-02-22 23:49:13 +01:00
|
|
|
case UAC_MIXER_UNIT:
|
2005-04-17 00:20:36 +02:00
|
|
|
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.
|
|
|
|
*/
|
2005-11-17 15:08:02 +01:00
|
|
|
static int check_input_term(struct mixer_build *state, int id, struct usb_audio_term *term)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
unsigned char *p1;
|
|
|
|
|
|
|
|
memset(term, 0, sizeof(*term));
|
|
|
|
while ((p1 = find_audio_control_unit(state, id)) != NULL) {
|
|
|
|
term->id = id;
|
|
|
|
switch (p1[2]) {
|
2010-02-22 23:49:13 +01:00
|
|
|
case UAC_INPUT_TERMINAL:
|
2005-04-17 00:20:36 +02:00
|
|
|
term->type = combine_word(p1 + 4);
|
|
|
|
term->channels = p1[7];
|
|
|
|
term->chconfig = combine_word(p1 + 8);
|
|
|
|
term->name = p1[11];
|
|
|
|
return 0;
|
2010-02-22 23:49:13 +01:00
|
|
|
case UAC_FEATURE_UNIT:
|
2005-04-17 00:20:36 +02:00
|
|
|
id = p1[4];
|
|
|
|
break; /* continue to parse */
|
2010-02-22 23:49:13 +01:00
|
|
|
case UAC_MIXER_UNIT:
|
2005-04-17 00:20:36 +02:00
|
|
|
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;
|
2010-02-22 23:49:13 +01:00
|
|
|
case UAC_SELECTOR_UNIT:
|
2005-04-17 00:20:36 +02:00
|
|
|
/* 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;
|
2010-02-22 23:49:13 +01:00
|
|
|
case UAC_PROCESSING_UNIT_V1:
|
|
|
|
case UAC_EXTENSION_UNIT_V1:
|
2005-04-17 00:20:36 +02:00
|
|
|
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 */
|
2005-11-17 15:08:02 +01:00
|
|
|
static void usb_mixer_elem_free(struct snd_kcontrol *kctl)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
[ALSA] Remove redundant NULL checks before kfree
Timer Midlevel,ALSA sequencer,ALSA<-OSS sequencer,Digigram VX core
I2C tea6330t,GUS Library,VIA82xx driver,VIA82xx-modem driver
CA0106 driver,CS46xx driver,EMU10K1/EMU10K2 driver,YMFPCI driver
Digigram VX Pocket driver,Common EMU synth,USB generic driver,USB USX2Y
Checking a pointer for NULL before calling kfree() on it is redundant,
kfree() deals with NULL pointers just fine.
This patch removes such checks from sound/
This patch also makes another, but closely related, change.
It avoids casting pointers about to be kfree()'ed.
Signed-off-by: Jesper Juhl <juhl-lkml@dif.dk>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2005-05-30 17:30:32 +02:00
|
|
|
kfree(kctl->private_data);
|
|
|
|
kctl->private_data = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* interface to ALSA control for feature/mixer units
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* retrieve the minimum and maximum values for the specified control
|
|
|
|
*/
|
2005-11-17 15:08:02 +01:00
|
|
|
static int get_min_max(struct usb_mixer_elem_info *cval, int default_min)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
/* for failsafe */
|
|
|
|
cval->min = default_min;
|
|
|
|
cval->max = cval->min + 1;
|
|
|
|
cval->res = 1;
|
2010-02-11 17:50:44 +01:00
|
|
|
cval->dBmin = cval->dBmax = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (cval->val_type == USB_MIXER_BOOLEAN ||
|
|
|
|
cval->val_type == USB_MIXER_INV_BOOLEAN) {
|
|
|
|
cval->initialized = 1;
|
|
|
|
} else {
|
|
|
|
int minchn = 0;
|
|
|
|
if (cval->cmask) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_CHANNELS; i++)
|
|
|
|
if (cval->cmask & (1 << i)) {
|
|
|
|
minchn = i + 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-02-22 23:49:13 +01:00
|
|
|
if (get_ctl_value(cval, UAC_GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
|
|
|
|
get_ctl_value(cval, UAC_GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
|
2005-04-29 16:23:13 +02:00
|
|
|
snd_printd(KERN_ERR "%d:%d: cannot get min/max values for control %d (id %d)\n",
|
|
|
|
cval->id, cval->mixer->ctrlif, cval->control, cval->id);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-02-22 23:49:13 +01:00
|
|
|
if (get_ctl_value(cval, UAC_GET_RES, (cval->control << 8) | minchn, &cval->res) < 0) {
|
2005-04-17 00:20:36 +02:00
|
|
|
cval->res = 1;
|
|
|
|
} else {
|
|
|
|
int last_valid_res = cval->res;
|
|
|
|
|
|
|
|
while (cval->res > 1) {
|
2010-02-22 23:49:13 +01:00
|
|
|
if (set_ctl_value(cval, UAC_SET_RES, (cval->control << 8) | minchn, cval->res / 2) < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
cval->res /= 2;
|
|
|
|
}
|
2010-02-22 23:49:13 +01:00
|
|
|
if (get_ctl_value(cval, UAC_GET_RES, (cval->control << 8) | minchn, &cval->res) < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
cval->res = last_valid_res;
|
|
|
|
}
|
|
|
|
if (cval->res == 0)
|
|
|
|
cval->res = 1;
|
2006-03-28 17:58:28 +02:00
|
|
|
|
|
|
|
/* Additional checks for the proper resolution
|
|
|
|
*
|
|
|
|
* Some devices report smaller resolutions than actually
|
|
|
|
* reacting. They don't return errors but simply clip
|
|
|
|
* to the lower aligned value.
|
|
|
|
*/
|
|
|
|
if (cval->min + cval->res < cval->max) {
|
|
|
|
int last_valid_res = cval->res;
|
|
|
|
int saved, test, check;
|
2009-01-15 17:05:24 +01:00
|
|
|
get_cur_mix_raw(cval, minchn, &saved);
|
2006-03-28 17:58:28 +02:00
|
|
|
for (;;) {
|
|
|
|
test = saved;
|
|
|
|
if (test < cval->max)
|
|
|
|
test += cval->res;
|
|
|
|
else
|
|
|
|
test -= cval->res;
|
|
|
|
if (test < cval->min || test > cval->max ||
|
2009-01-15 17:05:24 +01:00
|
|
|
set_cur_mix_value(cval, minchn, 0, test) ||
|
|
|
|
get_cur_mix_raw(cval, minchn, &check)) {
|
2006-03-28 17:58:28 +02:00
|
|
|
cval->res = last_valid_res;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (test == check)
|
|
|
|
break;
|
|
|
|
cval->res *= 2;
|
|
|
|
}
|
2009-01-15 17:05:24 +01:00
|
|
|
set_cur_mix_value(cval, minchn, 0, saved);
|
2006-03-28 17:58:28 +02:00
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
cval->initialized = 1;
|
|
|
|
}
|
2010-02-11 17:50:44 +01:00
|
|
|
|
|
|
|
/* USB descriptions contain the dB scale in 1/256 dB unit
|
|
|
|
* while ALSA TLV contains in 1/100 dB unit
|
|
|
|
*/
|
|
|
|
cval->dBmin = (convert_signed_value(cval, cval->min) * 100) / 256;
|
|
|
|
cval->dBmax = (convert_signed_value(cval, cval->max) * 100) / 256;
|
|
|
|
if (cval->dBmin > cval->dBmax) {
|
|
|
|
/* something is wrong; assume it's either from/to 0dB */
|
|
|
|
if (cval->dBmin < 0)
|
|
|
|
cval->dBmax = 0;
|
|
|
|
else if (cval->dBmin > 0)
|
|
|
|
cval->dBmin = 0;
|
|
|
|
if (cval->dBmin > cval->dBmax) {
|
|
|
|
/* totally crap, return an error */
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* get a feature/mixer unit info */
|
2005-11-17 15:08:02 +01:00
|
|
|
static int mixer_ctl_feature_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_mixer_elem_info *cval = kcontrol->private_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
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 {
|
|
|
|
if (! cval->initialized)
|
|
|
|
get_min_max(cval, 0);
|
|
|
|
uinfo->value.integer.min = 0;
|
2006-03-28 17:58:28 +02:00
|
|
|
uinfo->value.integer.max =
|
|
|
|
(cval->max - cval->min + cval->res - 1) / cval->res;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* get the current value from feature/mixer unit */
|
2005-11-17 15:08:02 +01:00
|
|
|
static int mixer_ctl_feature_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_mixer_elem_info *cval = kcontrol->private_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
int c, cnt, val, err;
|
|
|
|
|
2009-01-15 17:05:24 +01:00
|
|
|
ucontrol->value.integer.value[0] = cval->min;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (cval->cmask) {
|
|
|
|
cnt = 0;
|
|
|
|
for (c = 0; c < MAX_CHANNELS; c++) {
|
2009-01-15 17:05:24 +01:00
|
|
|
if (!(cval->cmask & (1 << c)))
|
|
|
|
continue;
|
|
|
|
err = get_cur_mix_value(cval, c + 1, cnt, &val);
|
|
|
|
if (err < 0)
|
|
|
|
return cval->mixer->ignore_ctl_error ? 0 : err;
|
|
|
|
val = get_relative_value(cval, val);
|
|
|
|
ucontrol->value.integer.value[cnt] = val;
|
|
|
|
cnt++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2009-01-15 17:05:24 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
} else {
|
|
|
|
/* master channel */
|
2009-01-15 17:05:24 +01:00
|
|
|
err = get_cur_mix_value(cval, 0, 0, &val);
|
|
|
|
if (err < 0)
|
|
|
|
return cval->mixer->ignore_ctl_error ? 0 : err;
|
2005-04-17 00:20:36 +02:00
|
|
|
val = get_relative_value(cval, val);
|
|
|
|
ucontrol->value.integer.value[0] = val;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* put the current value to feature/mixer unit */
|
2005-11-17 15:08:02 +01:00
|
|
|
static int mixer_ctl_feature_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_mixer_elem_info *cval = kcontrol->private_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
int c, cnt, val, oval, err;
|
|
|
|
int changed = 0;
|
|
|
|
|
|
|
|
if (cval->cmask) {
|
|
|
|
cnt = 0;
|
|
|
|
for (c = 0; c < MAX_CHANNELS; c++) {
|
2009-01-15 17:05:24 +01:00
|
|
|
if (!(cval->cmask & (1 << c)))
|
|
|
|
continue;
|
|
|
|
err = get_cur_mix_value(cval, c + 1, cnt, &oval);
|
|
|
|
if (err < 0)
|
|
|
|
return cval->mixer->ignore_ctl_error ? 0 : err;
|
|
|
|
val = ucontrol->value.integer.value[cnt];
|
|
|
|
val = get_abs_value(cval, val);
|
|
|
|
if (oval != val) {
|
|
|
|
set_cur_mix_value(cval, c + 1, cnt, val);
|
|
|
|
changed = 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2009-01-15 17:05:24 +01:00
|
|
|
cnt++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* master channel */
|
2009-01-15 17:05:24 +01:00
|
|
|
err = get_cur_mix_value(cval, 0, 0, &oval);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (err < 0)
|
2009-01-15 17:05:24 +01:00
|
|
|
return cval->mixer->ignore_ctl_error ? 0 : err;
|
2005-04-17 00:20:36 +02:00
|
|
|
val = ucontrol->value.integer.value[0];
|
|
|
|
val = get_abs_value(cval, val);
|
|
|
|
if (val != oval) {
|
2009-01-15 17:05:24 +01:00
|
|
|
set_cur_mix_value(cval, 0, 0, val);
|
2005-04-17 00:20:36 +02:00
|
|
|
changed = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static struct snd_kcontrol_new usb_feature_unit_ctl = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.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
|
|
|
|
*/
|
|
|
|
|
2009-10-02 14:06:08 +02:00
|
|
|
static size_t append_ctl_name(struct snd_kcontrol *kctl, const char *str)
|
|
|
|
{
|
|
|
|
return strlcat(kctl->id.name, str, sizeof(kctl->id.name));
|
|
|
|
}
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned int ctl_mask, int control,
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_audio_term *iterm, int unitid)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
unsigned int len = 0;
|
|
|
|
int mapped_name = 0;
|
|
|
|
int nameid = desc[desc[0] - 1];
|
2005-11-17 15:08:02 +01:00
|
|
|
struct snd_kcontrol *kctl;
|
|
|
|
struct usb_mixer_elem_info *cval;
|
2010-02-11 17:50:44 +01:00
|
|
|
const struct usbmix_name_map *map;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
control++; /* change from zero-based to 1-based value */
|
|
|
|
|
|
|
|
if (control == USB_FEATURE_GEQ) {
|
|
|
|
/* FIXME: not supported yet */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-02-11 17:50:44 +01:00
|
|
|
map = find_map(state, unitid, control);
|
|
|
|
if (check_ignored_ctl(map))
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
|
|
|
|
[ALSA] Replace with kzalloc() - others
Documentation,SA11xx UDA1341 driver,Generic drivers,MPU401 UART,OPL3
OPL4,Digigram VX core,I2C cs8427,I2C lib core,I2C tea6330t,L3 drivers
AK4114 receiver,AK4117 receiver,PDAudioCF driver,PPC PMAC driver
SPARC AMD7930 driver,SPARC cs4231 driver,Synth,Common EMU synth
USB generic driver,USB USX2Y
Replace kcalloc(1,..) with kzalloc().
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2005-09-09 14:22:34 +02:00
|
|
|
cval = kzalloc(sizeof(*cval), GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (! cval) {
|
|
|
|
snd_printk(KERN_ERR "cannot malloc kcontrol\n");
|
|
|
|
return;
|
|
|
|
}
|
2005-04-29 16:23:13 +02:00
|
|
|
cval->mixer = state->mixer;
|
2005-04-17 00:20:36 +02:00
|
|
|
cval->id = unitid;
|
|
|
|
cval->control = control;
|
|
|
|
cval->cmask = ctl_mask;
|
|
|
|
cval->val_type = audio_feature_info[control-1].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 */
|
|
|
|
get_min_max(cval, 0);
|
|
|
|
|
|
|
|
kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
|
|
|
|
if (! kctl) {
|
|
|
|
snd_printk(KERN_ERR "cannot malloc kcontrol\n");
|
|
|
|
kfree(cval);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
kctl->private_free = usb_mixer_elem_free;
|
|
|
|
|
2010-02-11 17:50:44 +01:00
|
|
|
len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
|
2005-04-17 00:20:36 +02:00
|
|
|
mapped_name = len != 0;
|
|
|
|
if (! len && nameid)
|
2010-02-11 17:50:44 +01:00
|
|
|
len = snd_usb_copy_string_desc(state, nameid,
|
|
|
|
kctl->id.name, sizeof(kctl->id.name));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
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 (! len) {
|
|
|
|
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 = snprintf(kctl->id.name, sizeof(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 (! mapped_name && ! (state->oterm.type >> 16)) {
|
|
|
|
if ((state->oterm.type & 0xff00) == 0x0100) {
|
2009-10-02 14:06:08 +02:00
|
|
|
len = append_ctl_name(kctl, " Capture");
|
2005-04-17 00:20:36 +02:00
|
|
|
} else {
|
2009-10-02 14:06:08 +02:00
|
|
|
len = append_ctl_name(kctl, " Playback");
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
2009-10-02 14:06:08 +02:00
|
|
|
append_ctl_name(kctl, control == USB_FEATURE_MUTE ?
|
|
|
|
" Switch" : " Volume");
|
2006-07-14 15:18:19 +02:00
|
|
|
if (control == USB_FEATURE_VOLUME) {
|
|
|
|
kctl->tlv.c = mixer_vol_tlv;
|
|
|
|
kctl->vd[0].access |=
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_TLV_READ |
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
|
2010-02-11 17:50:44 +01:00
|
|
|
check_mapped_dB(map, cval);
|
2006-07-14 15:18:19 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
if (! len)
|
|
|
|
strlcpy(kctl->id.name, audio_feature_info[control-1].name,
|
|
|
|
sizeof(kctl->id.name));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-07-22 14:57:54 +02:00
|
|
|
/* volume control quirks */
|
2005-05-02 08:51:26 +02:00
|
|
|
switch (state->chip->usb_id) {
|
|
|
|
case USB_ID(0x0471, 0x0101):
|
|
|
|
case USB_ID(0x0471, 0x0104):
|
|
|
|
case USB_ID(0x0471, 0x0105):
|
|
|
|
case USB_ID(0x0672, 0x1041):
|
2009-07-22 14:57:54 +02:00
|
|
|
/* quirk for UDA1321/N101.
|
|
|
|
* note that detection between firmware 2.1.1.7 (N101)
|
|
|
|
* and later 2.1.1.21 is not very clear from datasheets.
|
|
|
|
* I hope that the min value is -15360 for newer firmware --jk
|
|
|
|
*/
|
2005-05-02 08:51:26 +02:00
|
|
|
if (!strcmp(kctl->id.name, "PCM Playback Volume") &&
|
|
|
|
cval->min == -15616) {
|
2009-07-22 14:57:54 +02:00
|
|
|
snd_printk(KERN_INFO
|
|
|
|
"set volume quirk for UDA1321/N101 chip\n");
|
2005-05-02 08:51:26 +02:00
|
|
|
cval->max = -256;
|
|
|
|
}
|
2009-07-22 14:57:54 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case USB_ID(0x046d, 0x09a4):
|
|
|
|
if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
|
|
|
|
snd_printk(KERN_INFO
|
|
|
|
"set volume quirk for QuickCam E3500\n");
|
|
|
|
cval->min = 6080;
|
|
|
|
cval->max = 8768;
|
|
|
|
cval->res = 192;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
snd_printdd(KERN_INFO "[%d] FU [%s] ch = %d, val = %d/%d/%d\n",
|
|
|
|
cval->id, kctl->id.name, cval->channels, cval->min, cval->max, cval->res);
|
2005-04-29 16:23:13 +02:00
|
|
|
add_control_to_empty(state, kctl);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* parse a feature unit
|
|
|
|
*
|
|
|
|
* most of controlls are defined here.
|
|
|
|
*/
|
2010-02-22 23:49:09 +01:00
|
|
|
static int parse_audio_feature_unit(struct mixer_build *state, int unitid, void *_ftr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int channels, i, j;
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_audio_term iterm;
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned int master_bits, first_ch_bits;
|
|
|
|
int err, csize;
|
2010-02-22 23:49:09 +01:00
|
|
|
struct uac_feature_unit_descriptor *ftr = _ftr;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-02-22 23:49:09 +01:00
|
|
|
if (ftr->bLength < 7 || ! (csize = ftr->bControlSize) || ftr->bLength < 7 + csize) {
|
2010-02-22 23:49:13 +01:00
|
|
|
snd_printk(KERN_ERR "usbaudio: unit %u: invalid UAC_FEATURE_UNIT descriptor\n", unitid);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* parse the source unit */
|
2010-02-22 23:49:09 +01:00
|
|
|
if ((err = parse_audio_unit(state, ftr->bSourceID)) < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
return err;
|
|
|
|
|
|
|
|
/* determine the input source type and name */
|
2010-02-22 23:49:09 +01:00
|
|
|
if (check_input_term(state, ftr->bSourceID, &iterm) < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINVAL;
|
|
|
|
|
2010-02-22 23:49:09 +01:00
|
|
|
channels = (ftr->bLength - 7) / csize - 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-02-22 23:49:09 +01:00
|
|
|
master_bits = snd_usb_combine_bytes(ftr->controls, csize);
|
2009-11-17 15:36:13 +01:00
|
|
|
/* master configuration quirks */
|
|
|
|
switch (state->chip->usb_id) {
|
|
|
|
case USB_ID(0x08bb, 0x2702):
|
|
|
|
snd_printk(KERN_INFO
|
|
|
|
"usbmixer: master volume quirk for PCM2702 chip\n");
|
|
|
|
/* disable non-functional volume control */
|
|
|
|
master_bits &= ~(1 << (USB_FEATURE_VOLUME - 1));
|
|
|
|
break;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
if (channels > 0)
|
2010-02-22 23:49:09 +01:00
|
|
|
first_ch_bits = snd_usb_combine_bytes(ftr->controls + csize, csize);
|
2005-04-17 00:20:36 +02:00
|
|
|
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++) {
|
2010-02-22 23:49:09 +01:00
|
|
|
unsigned int mask = snd_usb_combine_bytes(ftr->controls + csize * (j+1), csize);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (mask & (1 << i))
|
|
|
|
ch_bits |= (1 << j);
|
|
|
|
}
|
|
|
|
if (ch_bits & 1) /* the first channel must be set (for ease of programming) */
|
2010-02-22 23:49:09 +01:00
|
|
|
build_feature_ctl(state, _ftr, ch_bits, i, &iterm, unitid);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (master_bits & (1 << i))
|
2010-02-22 23:49:09 +01:00
|
|
|
build_feature_ctl(state, _ftr, 0, i, &iterm, unitid);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static void build_mixer_unit_ctl(struct mixer_build *state, unsigned char *desc,
|
2005-04-17 00:20:36 +02:00
|
|
|
int in_pin, int in_ch, int unitid,
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_audio_term *iterm)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_mixer_elem_info *cval;
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned int input_pins = desc[4];
|
|
|
|
unsigned int num_outs = desc[5 + input_pins];
|
|
|
|
unsigned int i, len;
|
2005-11-17 15:08:02 +01:00
|
|
|
struct snd_kcontrol *kctl;
|
2010-02-11 17:50:44 +01:00
|
|
|
const struct usbmix_name_map *map;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-02-11 17:50:44 +01:00
|
|
|
map = find_map(state, unitid, 0);
|
|
|
|
if (check_ignored_ctl(map))
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
|
|
|
|
[ALSA] Replace with kzalloc() - others
Documentation,SA11xx UDA1341 driver,Generic drivers,MPU401 UART,OPL3
OPL4,Digigram VX core,I2C cs8427,I2C lib core,I2C tea6330t,L3 drivers
AK4114 receiver,AK4117 receiver,PDAudioCF driver,PPC PMAC driver
SPARC AMD7930 driver,SPARC cs4231 driver,Synth,Common EMU synth
USB generic driver,USB USX2Y
Replace kcalloc(1,..) with kzalloc().
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2005-09-09 14:22:34 +02:00
|
|
|
cval = kzalloc(sizeof(*cval), GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (! cval)
|
|
|
|
return;
|
|
|
|
|
2005-04-29 16:23:13 +02:00
|
|
|
cval->mixer = state->mixer;
|
2005-04-17 00:20:36 +02:00
|
|
|
cval->id = unitid;
|
|
|
|
cval->control = in_ch + 1; /* based on 1 */
|
|
|
|
cval->val_type = USB_MIXER_S16;
|
|
|
|
for (i = 0; i < num_outs; i++) {
|
|
|
|
if (check_matrix_bitmap(desc + 9 + input_pins, in_ch, i, num_outs)) {
|
|
|
|
cval->cmask |= (1 << i);
|
|
|
|
cval->channels++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* get min/max values */
|
|
|
|
get_min_max(cval, 0);
|
|
|
|
|
|
|
|
kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
|
|
|
|
if (! kctl) {
|
|
|
|
snd_printk(KERN_ERR "cannot malloc kcontrol\n");
|
|
|
|
kfree(cval);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
kctl->private_free = usb_mixer_elem_free;
|
|
|
|
|
2010-02-11 17:50:44 +01:00
|
|
|
len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
|
2005-04-17 00:20:36 +02:00
|
|
|
if (! len)
|
|
|
|
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 + 1);
|
2009-10-02 14:06:08 +02:00
|
|
|
append_ctl_name(kctl, " Volume");
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
snd_printdd(KERN_INFO "[%d] MU [%s] ch = %d, val = %d/%d\n",
|
|
|
|
cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
|
2005-04-29 16:23:13 +02:00
|
|
|
add_control_to_empty(state, kctl);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* parse a mixer unit
|
|
|
|
*/
|
2005-11-17 15:08:02 +01:00
|
|
|
static int parse_audio_mixer_unit(struct mixer_build *state, int unitid, unsigned char *desc)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_audio_term iterm;
|
2005-04-17 00:20:36 +02:00
|
|
|
int input_pins, num_ins, num_outs;
|
|
|
|
int pin, ich, err;
|
|
|
|
|
|
|
|
if (desc[0] < 11 || ! (input_pins = desc[4]) || ! (num_outs = desc[5 + input_pins])) {
|
|
|
|
snd_printk(KERN_ERR "invalid MIXER UNIT descriptor %d\n", unitid);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
/* no bmControls field (e.g. Maya44) -> ignore */
|
|
|
|
if (desc[0] <= 10 + input_pins) {
|
|
|
|
snd_printdd(KERN_INFO "MU %d has no bmControls field\n", unitid);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
num_ins = 0;
|
|
|
|
ich = 0;
|
|
|
|
for (pin = 0; pin < input_pins; pin++) {
|
|
|
|
err = parse_audio_unit(state, desc[5 + pin]);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
err = check_input_term(state, desc[5 + pin], &iterm);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
num_ins += iterm.channels;
|
|
|
|
for (; ich < num_ins; ++ich) {
|
|
|
|
int och, ich_has_controls = 0;
|
|
|
|
|
|
|
|
for (och = 0; och < num_outs; ++och) {
|
|
|
|
if (check_matrix_bitmap(desc + 9 + input_pins,
|
|
|
|
ich, och, num_outs)) {
|
|
|
|
ich_has_controls = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (ich_has_controls)
|
|
|
|
build_mixer_unit_ctl(state, desc, pin, ich,
|
|
|
|
unitid, &iterm);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Processing Unit / Extension Unit
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* get callback for processing/extension unit */
|
2005-11-17 15:08:02 +01:00
|
|
|
static int mixer_ctl_procunit_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_mixer_elem_info *cval = kcontrol->private_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
int err, val;
|
|
|
|
|
|
|
|
err = get_cur_ctl_value(cval, cval->control << 8, &val);
|
2005-04-29 16:23:13 +02:00
|
|
|
if (err < 0 && cval->mixer->ignore_ctl_error) {
|
2005-04-17 00:20:36 +02:00
|
|
|
ucontrol->value.integer.value[0] = cval->min;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
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 */
|
2005-11-17 15:08:02 +01:00
|
|
|
static int mixer_ctl_procunit_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_mixer_elem_info *cval = kcontrol->private_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
int val, oval, err;
|
|
|
|
|
|
|
|
err = get_cur_ctl_value(cval, cval->control << 8, &oval);
|
|
|
|
if (err < 0) {
|
2005-04-29 16:23:13 +02:00
|
|
|
if (cval->mixer->ignore_ctl_error)
|
2005-04-17 00:20:36 +02:00
|
|
|
return 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 << 8, val);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* alsa control interface for processing/extension unit */
|
2005-11-17 15:08:02 +01:00
|
|
|
static struct snd_kcontrol_new mixer_procunit_ctl = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.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;
|
|
|
|
int min_value;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct procunit_info {
|
|
|
|
int type;
|
|
|
|
char *name;
|
|
|
|
struct procunit_value_info *values;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct procunit_value_info updown_proc_info[] = {
|
|
|
|
{ USB_PROC_UPDOWN_SWITCH, "Switch", USB_MIXER_BOOLEAN },
|
|
|
|
{ USB_PROC_UPDOWN_MODE_SEL, "Mode Select", USB_MIXER_U8, 1 },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
static struct procunit_value_info prologic_proc_info[] = {
|
|
|
|
{ USB_PROC_PROLOGIC_SWITCH, "Switch", USB_MIXER_BOOLEAN },
|
|
|
|
{ USB_PROC_PROLOGIC_MODE_SEL, "Mode Select", USB_MIXER_U8, 1 },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
static struct procunit_value_info threed_enh_proc_info[] = {
|
|
|
|
{ USB_PROC_3DENH_SWITCH, "Switch", USB_MIXER_BOOLEAN },
|
|
|
|
{ USB_PROC_3DENH_SPACE, "Spaciousness", USB_MIXER_U8 },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
static struct procunit_value_info reverb_proc_info[] = {
|
|
|
|
{ USB_PROC_REVERB_SWITCH, "Switch", USB_MIXER_BOOLEAN },
|
|
|
|
{ USB_PROC_REVERB_LEVEL, "Level", USB_MIXER_U8 },
|
|
|
|
{ USB_PROC_REVERB_TIME, "Time", USB_MIXER_U16 },
|
|
|
|
{ USB_PROC_REVERB_DELAY, "Delay", USB_MIXER_U8 },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
static struct procunit_value_info chorus_proc_info[] = {
|
|
|
|
{ USB_PROC_CHORUS_SWITCH, "Switch", USB_MIXER_BOOLEAN },
|
|
|
|
{ USB_PROC_CHORUS_LEVEL, "Level", USB_MIXER_U8 },
|
|
|
|
{ USB_PROC_CHORUS_RATE, "Rate", USB_MIXER_U16 },
|
|
|
|
{ USB_PROC_CHORUS_DEPTH, "Depth", USB_MIXER_U16 },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
static struct procunit_value_info dcr_proc_info[] = {
|
|
|
|
{ USB_PROC_DCR_SWITCH, "Switch", USB_MIXER_BOOLEAN },
|
|
|
|
{ USB_PROC_DCR_RATIO, "Ratio", USB_MIXER_U16 },
|
|
|
|
{ USB_PROC_DCR_MAX_AMP, "Max Amp", USB_MIXER_S16 },
|
|
|
|
{ USB_PROC_DCR_THRESHOLD, "Threshold", USB_MIXER_S16 },
|
|
|
|
{ USB_PROC_DCR_ATTACK, "Attack Time", USB_MIXER_U16 },
|
|
|
|
{ USB_PROC_DCR_RELEASE, "Release Time", USB_MIXER_U16 },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct procunit_info procunits[] = {
|
|
|
|
{ USB_PROC_UPDOWN, "Up Down", updown_proc_info },
|
|
|
|
{ USB_PROC_PROLOGIC, "Dolby Prologic", prologic_proc_info },
|
|
|
|
{ USB_PROC_3DENH, "3D Stereo Extender", threed_enh_proc_info },
|
|
|
|
{ USB_PROC_REVERB, "Reverb", reverb_proc_info },
|
|
|
|
{ USB_PROC_CHORUS, "Chorus", chorus_proc_info },
|
|
|
|
{ USB_PROC_DCR, "DCR", dcr_proc_info },
|
|
|
|
{ 0 },
|
|
|
|
};
|
2009-12-27 18:13:41 +01:00
|
|
|
/*
|
|
|
|
* predefined data for extension units
|
|
|
|
*/
|
|
|
|
static struct procunit_value_info clock_rate_xu_info[] = {
|
|
|
|
{ USB_XU_CLOCK_RATE_SELECTOR, "Selector", USB_MIXER_U8, 0 },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
static struct procunit_value_info clock_source_xu_info[] = {
|
|
|
|
{ USB_XU_CLOCK_SOURCE_SELECTOR, "External", USB_MIXER_BOOLEAN },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
static struct procunit_value_info spdif_format_xu_info[] = {
|
|
|
|
{ USB_XU_DIGITAL_FORMAT_SELECTOR, "SPDIF/AC3", USB_MIXER_BOOLEAN },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
static struct procunit_value_info soft_limit_xu_info[] = {
|
|
|
|
{ USB_XU_SOFT_LIMIT_SELECTOR, " ", USB_MIXER_BOOLEAN },
|
|
|
|
{ 0 }
|
|
|
|
};
|
|
|
|
static struct procunit_info extunits[] = {
|
|
|
|
{ USB_XU_CLOCK_RATE, "Clock rate", clock_rate_xu_info },
|
|
|
|
{ USB_XU_CLOCK_SOURCE, "DigitalIn CLK source", clock_source_xu_info },
|
|
|
|
{ USB_XU_DIGITAL_IO_STATUS, "DigitalOut format:", spdif_format_xu_info },
|
|
|
|
{ USB_XU_DEVICE_OPTIONS, "AnalogueIn Soft Limit", soft_limit_xu_info },
|
|
|
|
{ 0 }
|
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* build a processing/extension unit
|
|
|
|
*/
|
2005-11-17 15:08:02 +01:00
|
|
|
static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned char *dsc, struct procunit_info *list, char *name)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int num_ins = dsc[6];
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_mixer_elem_info *cval;
|
|
|
|
struct snd_kcontrol *kctl;
|
2005-04-17 00:20:36 +02:00
|
|
|
int i, err, nameid, type, len;
|
|
|
|
struct procunit_info *info;
|
|
|
|
struct procunit_value_info *valinfo;
|
2010-02-11 17:50:44 +01:00
|
|
|
const struct usbmix_name_map *map;
|
2005-04-17 00:20:36 +02:00
|
|
|
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 (id %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]);
|
|
|
|
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;
|
2010-02-11 17:50:44 +01:00
|
|
|
map = find_map(state, unitid, valinfo->control);
|
|
|
|
if (check_ignored_ctl(map))
|
2005-04-17 00:20:36 +02:00
|
|
|
continue;
|
[ALSA] Replace with kzalloc() - others
Documentation,SA11xx UDA1341 driver,Generic drivers,MPU401 UART,OPL3
OPL4,Digigram VX core,I2C cs8427,I2C lib core,I2C tea6330t,L3 drivers
AK4114 receiver,AK4117 receiver,PDAudioCF driver,PPC PMAC driver
SPARC AMD7930 driver,SPARC cs4231 driver,Synth,Common EMU synth
USB generic driver,USB USX2Y
Replace kcalloc(1,..) with kzalloc().
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2005-09-09 14:22:34 +02:00
|
|
|
cval = kzalloc(sizeof(*cval), GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (! cval) {
|
|
|
|
snd_printk(KERN_ERR "cannot malloc kcontrol\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2005-04-29 16:23:13 +02:00
|
|
|
cval->mixer = state->mixer;
|
2005-04-17 00:20:36 +02:00
|
|
|
cval->id = unitid;
|
|
|
|
cval->control = valinfo->control;
|
|
|
|
cval->val_type = valinfo->val_type;
|
|
|
|
cval->channels = 1;
|
|
|
|
|
|
|
|
/* get min/max values */
|
|
|
|
if (type == USB_PROC_UPDOWN && cval->control == USB_PROC_UPDOWN_MODE_SEL) {
|
|
|
|
/* FIXME: hard-coded */
|
|
|
|
cval->min = 1;
|
|
|
|
cval->max = dsc[15];
|
|
|
|
cval->res = 1;
|
|
|
|
cval->initialized = 1;
|
2009-12-27 18:13:41 +01:00
|
|
|
} else {
|
|
|
|
if (type == USB_XU_CLOCK_RATE) {
|
|
|
|
/* E-Mu USB 0404/0202/TrackerPre
|
|
|
|
* samplerate control quirk
|
|
|
|
*/
|
|
|
|
cval->min = 0;
|
|
|
|
cval->max = 5;
|
|
|
|
cval->res = 1;
|
|
|
|
cval->initialized = 1;
|
|
|
|
} else
|
|
|
|
get_min_max(cval, valinfo->min_value);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
kctl = snd_ctl_new1(&mixer_procunit_ctl, cval);
|
|
|
|
if (! kctl) {
|
|
|
|
snd_printk(KERN_ERR "cannot malloc kcontrol\n");
|
|
|
|
kfree(cval);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
kctl->private_free = usb_mixer_elem_free;
|
|
|
|
|
2010-02-11 17:50:44 +01:00
|
|
|
if (check_mapped_name(map, kctl->id.name,
|
|
|
|
sizeof(kctl->id.name)))
|
|
|
|
/* nothing */ ;
|
2005-04-17 00:20:36 +02:00
|
|
|
else if (info->name)
|
|
|
|
strlcpy(kctl->id.name, info->name, sizeof(kctl->id.name));
|
|
|
|
else {
|
|
|
|
nameid = dsc[12 + num_ins + dsc[11 + num_ins]];
|
|
|
|
len = 0;
|
|
|
|
if (nameid)
|
|
|
|
len = snd_usb_copy_string_desc(state, nameid, kctl->id.name, sizeof(kctl->id.name));
|
|
|
|
if (! len)
|
|
|
|
strlcpy(kctl->id.name, name, sizeof(kctl->id.name));
|
|
|
|
}
|
2009-10-02 14:06:08 +02:00
|
|
|
append_ctl_name(kctl, " ");
|
|
|
|
append_ctl_name(kctl, valinfo->suffix);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
snd_printdd(KERN_INFO "[%d] PU [%s] ch = %d, val = %d/%d\n",
|
|
|
|
cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
|
2005-04-29 16:23:13 +02:00
|
|
|
if ((err = add_control_to_empty(state, kctl)) < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static int parse_audio_processing_unit(struct mixer_build *state, int unitid, unsigned char *desc)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
return build_audio_procunit(state, unitid, desc, procunits, "Processing Unit");
|
|
|
|
}
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static int parse_audio_extension_unit(struct mixer_build *state, int unitid, unsigned char *desc)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2009-12-27 18:13:41 +01:00
|
|
|
return build_audio_procunit(state, unitid, desc, extunits, "Extension Unit");
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Selector Unit
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* info callback for selector unit
|
|
|
|
* use an enumerator type for routing
|
|
|
|
*/
|
2005-11-17 15:08:02 +01:00
|
|
|
static int mixer_ctl_selector_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_mixer_elem_info *cval = kcontrol->private_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
char **itemlist = (char **)kcontrol->private_value;
|
|
|
|
|
2008-08-08 17:12:47 +02:00
|
|
|
if (snd_BUG_ON(!itemlist))
|
|
|
|
return -EINVAL;
|
2005-04-17 00:20:36 +02:00
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
|
|
|
|
uinfo->count = 1;
|
|
|
|
uinfo->value.enumerated.items = cval->max;
|
|
|
|
if ((int)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 */
|
2005-11-17 15:08:02 +01:00
|
|
|
static int mixer_ctl_selector_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_mixer_elem_info *cval = kcontrol->private_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
int val, err;
|
|
|
|
|
|
|
|
err = get_cur_ctl_value(cval, 0, &val);
|
|
|
|
if (err < 0) {
|
2005-04-29 16:23:13 +02:00
|
|
|
if (cval->mixer->ignore_ctl_error) {
|
2005-04-17 00:20:36 +02:00
|
|
|
ucontrol->value.enumerated.item[0] = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
val = get_relative_value(cval, val);
|
|
|
|
ucontrol->value.enumerated.item[0] = val;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* put callback for selector unit */
|
2005-11-17 15:08:02 +01:00
|
|
|
static int mixer_ctl_selector_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_mixer_elem_info *cval = kcontrol->private_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
int val, oval, err;
|
|
|
|
|
|
|
|
err = get_cur_ctl_value(cval, 0, &oval);
|
|
|
|
if (err < 0) {
|
2005-04-29 16:23:13 +02:00
|
|
|
if (cval->mixer->ignore_ctl_error)
|
2005-04-17 00:20:36 +02:00
|
|
|
return 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 */
|
2005-11-17 15:08:02 +01:00
|
|
|
static struct snd_kcontrol_new mixer_selectunit_ctl = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.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
|
|
|
|
*/
|
2005-11-17 15:08:02 +01:00
|
|
|
static void usb_mixer_selector_elem_free(struct snd_kcontrol *kctl)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int i, num_ins = 0;
|
|
|
|
|
|
|
|
if (kctl->private_data) {
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_mixer_elem_info *cval = kctl->private_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
num_ins = cval->max;
|
|
|
|
kfree(cval);
|
|
|
|
kctl->private_data = NULL;
|
|
|
|
}
|
|
|
|
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
|
|
|
|
*/
|
2005-11-17 15:08:02 +01:00
|
|
|
static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsigned char *desc)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
unsigned int num_ins = desc[4];
|
|
|
|
unsigned int i, nameid, len;
|
|
|
|
int err;
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_mixer_elem_info *cval;
|
|
|
|
struct snd_kcontrol *kctl;
|
2010-02-11 17:50:44 +01:00
|
|
|
const struct usbmix_name_map *map;
|
2005-04-17 00:20:36 +02:00
|
|
|
char **namelist;
|
|
|
|
|
2007-08-06 15:37:58 +02:00
|
|
|
if (! num_ins || desc[0] < 5 + num_ins) {
|
2005-04-17 00:20:36 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (num_ins == 1) /* only one ? nonsense! */
|
|
|
|
return 0;
|
|
|
|
|
2010-02-11 17:50:44 +01:00
|
|
|
map = find_map(state, unitid, 0);
|
|
|
|
if (check_ignored_ctl(map))
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
|
[ALSA] Replace with kzalloc() - others
Documentation,SA11xx UDA1341 driver,Generic drivers,MPU401 UART,OPL3
OPL4,Digigram VX core,I2C cs8427,I2C lib core,I2C tea6330t,L3 drivers
AK4114 receiver,AK4117 receiver,PDAudioCF driver,PPC PMAC driver
SPARC AMD7930 driver,SPARC cs4231 driver,Synth,Common EMU synth
USB generic driver,USB USX2Y
Replace kcalloc(1,..) with kzalloc().
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2005-09-09 14:22:34 +02:00
|
|
|
cval = kzalloc(sizeof(*cval), GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (! cval) {
|
|
|
|
snd_printk(KERN_ERR "cannot malloc kcontrol\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2005-04-29 16:23:13 +02:00
|
|
|
cval->mixer = state->mixer;
|
2005-04-17 00:20:36 +02:00
|
|
|
cval->id = unitid;
|
|
|
|
cval->val_type = USB_MIXER_U8;
|
|
|
|
cval->channels = 1;
|
|
|
|
cval->min = 1;
|
|
|
|
cval->max = num_ins;
|
|
|
|
cval->res = 1;
|
|
|
|
cval->initialized = 1;
|
|
|
|
|
|
|
|
namelist = kmalloc(sizeof(char *) * num_ins, GFP_KERNEL);
|
|
|
|
if (! namelist) {
|
|
|
|
snd_printk(KERN_ERR "cannot malloc\n");
|
|
|
|
kfree(cval);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
#define MAX_ITEM_NAME_LEN 64
|
|
|
|
for (i = 0; i < num_ins; i++) {
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_audio_term iterm;
|
2005-04-17 00:20:36 +02:00
|
|
|
len = 0;
|
|
|
|
namelist[i] = kmalloc(MAX_ITEM_NAME_LEN, GFP_KERNEL);
|
|
|
|
if (! namelist[i]) {
|
|
|
|
snd_printk(KERN_ERR "cannot malloc\n");
|
2007-01-08 11:25:30 +01:00
|
|
|
while (i--)
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree(namelist[i]);
|
|
|
|
kfree(namelist);
|
|
|
|
kfree(cval);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2005-04-22 15:49:52 +02:00
|
|
|
len = check_mapped_selector_name(state, unitid, i, namelist[i],
|
|
|
|
MAX_ITEM_NAME_LEN);
|
|
|
|
if (! len && check_input_term(state, desc[5 + i], &iterm) >= 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
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\n");
|
2006-03-20 11:27:13 +01:00
|
|
|
kfree(namelist);
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree(cval);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
kctl->private_value = (unsigned long)namelist;
|
|
|
|
kctl->private_free = usb_mixer_selector_elem_free;
|
|
|
|
|
|
|
|
nameid = desc[desc[0] - 1];
|
2010-02-11 17:50:44 +01:00
|
|
|
len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
|
2005-04-17 00:20:36 +02:00
|
|
|
if (len)
|
|
|
|
;
|
|
|
|
else if (nameid)
|
|
|
|
snd_usb_copy_string_desc(state, nameid, kctl->id.name, sizeof(kctl->id.name));
|
|
|
|
else {
|
|
|
|
len = get_term_name(state, &state->oterm,
|
|
|
|
kctl->id.name, sizeof(kctl->id.name), 0);
|
|
|
|
if (! len)
|
|
|
|
strlcpy(kctl->id.name, "USB", sizeof(kctl->id.name));
|
|
|
|
|
|
|
|
if ((state->oterm.type & 0xff00) == 0x0100)
|
2009-10-02 14:06:08 +02:00
|
|
|
append_ctl_name(kctl, " Capture Source");
|
2005-04-17 00:20:36 +02:00
|
|
|
else
|
2009-10-02 14:06:08 +02:00
|
|
|
append_ctl_name(kctl, " Playback Source");
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
snd_printdd(KERN_INFO "[%d] SU [%s] items = %d\n",
|
|
|
|
cval->id, kctl->id.name, num_ins);
|
2005-04-29 16:23:13 +02:00
|
|
|
if ((err = add_control_to_empty(state, kctl)) < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
return err;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* parse an audio unit recursively
|
|
|
|
*/
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static int parse_audio_unit(struct mixer_build *state, int unitid)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
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]) {
|
2010-02-22 23:49:13 +01:00
|
|
|
case UAC_INPUT_TERMINAL:
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0; /* NOP */
|
2010-02-22 23:49:13 +01:00
|
|
|
case UAC_MIXER_UNIT:
|
2005-04-17 00:20:36 +02:00
|
|
|
return parse_audio_mixer_unit(state, unitid, p1);
|
2010-02-22 23:49:13 +01:00
|
|
|
case UAC_SELECTOR_UNIT:
|
2005-04-17 00:20:36 +02:00
|
|
|
return parse_audio_selector_unit(state, unitid, p1);
|
2010-02-22 23:49:13 +01:00
|
|
|
case UAC_FEATURE_UNIT:
|
2005-04-17 00:20:36 +02:00
|
|
|
return parse_audio_feature_unit(state, unitid, p1);
|
2010-02-22 23:49:13 +01:00
|
|
|
case UAC_PROCESSING_UNIT_V1:
|
2005-04-17 00:20:36 +02:00
|
|
|
return parse_audio_processing_unit(state, unitid, p1);
|
2010-02-22 23:49:13 +01:00
|
|
|
case UAC_EXTENSION_UNIT_V1:
|
2005-04-17 00:20:36 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-29 16:23:13 +02:00
|
|
|
static void snd_usb_mixer_free(struct usb_mixer_interface *mixer)
|
|
|
|
{
|
2005-04-29 16:26:14 +02:00
|
|
|
kfree(mixer->id_elems);
|
|
|
|
if (mixer->urb) {
|
|
|
|
kfree(mixer->urb->transfer_buffer);
|
|
|
|
usb_free_urb(mixer->urb);
|
|
|
|
}
|
2006-11-08 15:37:04 +01:00
|
|
|
usb_free_urb(mixer->rc_urb);
|
2005-04-29 16:29:28 +02:00
|
|
|
kfree(mixer->rc_setup_packet);
|
2005-04-29 16:23:13 +02:00
|
|
|
kfree(mixer);
|
|
|
|
}
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static int snd_usb_mixer_dev_free(struct snd_device *device)
|
2005-04-29 16:23:13 +02:00
|
|
|
{
|
|
|
|
struct usb_mixer_interface *mixer = device->device_data;
|
|
|
|
snd_usb_mixer_free(mixer);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* create mixer controls
|
|
|
|
*
|
2010-02-22 23:49:13 +01:00
|
|
|
* walk through all UAC_OUTPUT_TERMINAL descriptors to search for mixers
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2005-04-29 16:23:13 +02:00
|
|
|
static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-02-22 23:49:09 +01:00
|
|
|
struct uac_output_terminal_descriptor_v1 *desc;
|
2005-11-17 15:08:02 +01:00
|
|
|
struct mixer_build state;
|
2005-04-17 00:20:36 +02:00
|
|
|
int err;
|
|
|
|
const struct usbmix_ctl_map *map;
|
2005-04-29 16:23:13 +02:00
|
|
|
struct usb_host_interface *hostif;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-04-29 16:23:13 +02:00
|
|
|
hostif = &usb_ifnum_to_if(mixer->chip->dev, mixer->ctrlif)->altsetting[0];
|
2005-04-17 00:20:36 +02:00
|
|
|
memset(&state, 0, sizeof(state));
|
2005-04-29 16:23:13 +02:00
|
|
|
state.chip = mixer->chip;
|
|
|
|
state.mixer = mixer;
|
2005-04-17 00:20:36 +02:00
|
|
|
state.buffer = hostif->extra;
|
|
|
|
state.buflen = hostif->extralen;
|
|
|
|
|
|
|
|
/* check the mapping table */
|
2005-05-02 08:51:26 +02:00
|
|
|
for (map = usbmix_ctl_maps; map->id; map++) {
|
|
|
|
if (map->id == state.chip->usb_id) {
|
2005-04-17 00:20:36 +02:00
|
|
|
state.map = map->map;
|
2005-04-22 15:49:52 +02:00
|
|
|
state.selector_map = map->selector_map;
|
2005-04-29 16:23:13 +02:00
|
|
|
mixer->ignore_ctl_error = map->ignore_ctl_error;
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
desc = NULL;
|
2010-02-22 23:49:13 +01:00
|
|
|
while ((desc = snd_usb_find_csint_desc(hostif->extra, hostif->extralen, desc, UAC_OUTPUT_TERMINAL)) != NULL) {
|
2010-02-22 23:49:09 +01:00
|
|
|
if (desc->bLength < 9)
|
2005-04-17 00:20:36 +02:00
|
|
|
continue; /* invalid descriptor? */
|
2010-02-22 23:49:09 +01:00
|
|
|
set_bit(desc->bTerminalID, state.unitbitmap); /* mark terminal ID as visited */
|
|
|
|
state.oterm.id = desc->bTerminalID;
|
|
|
|
state.oterm.type = le16_to_cpu(desc->wTerminalType);
|
|
|
|
state.oterm.name = desc->iTerminal;
|
|
|
|
err = parse_audio_unit(&state, desc->bSourceID);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-29 16:23:13 +02:00
|
|
|
|
2005-04-29 16:26:14 +02:00
|
|
|
static void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer,
|
|
|
|
int unitid)
|
|
|
|
{
|
2005-11-17 15:08:02 +01:00
|
|
|
struct usb_mixer_elem_info *info;
|
2005-04-29 16:26:14 +02:00
|
|
|
|
|
|
|
for (info = mixer->id_elems[unitid]; info; info = info->next_id_elem)
|
|
|
|
snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
|
|
|
|
info->elem_id);
|
|
|
|
}
|
|
|
|
|
2010-02-16 11:17:09 +01:00
|
|
|
static void snd_usb_mixer_dump_cval(struct snd_info_buffer *buffer,
|
|
|
|
int unitid,
|
|
|
|
struct usb_mixer_elem_info *cval)
|
|
|
|
{
|
|
|
|
static char *val_types[] = {"BOOLEAN", "INV_BOOLEAN",
|
|
|
|
"S8", "U8", "S16", "U16"};
|
|
|
|
snd_iprintf(buffer, " Unit: %i\n", unitid);
|
|
|
|
if (cval->elem_id)
|
|
|
|
snd_iprintf(buffer, " Control: name=\"%s\", index=%i\n",
|
|
|
|
cval->elem_id->name, cval->elem_id->index);
|
|
|
|
snd_iprintf(buffer, " Info: id=%i, control=%i, cmask=0x%x, "
|
|
|
|
"channels=%i, type=\"%s\"\n", cval->id,
|
|
|
|
cval->control, cval->cmask, cval->channels,
|
|
|
|
val_types[cval->val_type]);
|
|
|
|
snd_iprintf(buffer, " Volume: min=%i, max=%i, dBmin=%i, dBmax=%i\n",
|
|
|
|
cval->min, cval->max, cval->dBmin, cval->dBmax);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void snd_usb_mixer_proc_read(struct snd_info_entry *entry,
|
|
|
|
struct snd_info_buffer *buffer)
|
|
|
|
{
|
|
|
|
struct snd_usb_audio *chip = entry->private_data;
|
|
|
|
struct usb_mixer_interface *mixer;
|
|
|
|
struct usb_mixer_elem_info *cval;
|
|
|
|
int unitid;
|
|
|
|
|
|
|
|
list_for_each_entry(mixer, &chip->mixer_list, list) {
|
|
|
|
snd_iprintf(buffer,
|
2010-02-16 11:52:27 +01:00
|
|
|
"USB Mixer: usb_id=0x%08x, ctrlif=%i, ctlerr=%i\n",
|
|
|
|
chip->usb_id, mixer->ctrlif,
|
|
|
|
mixer->ignore_ctl_error);
|
2010-02-16 11:17:09 +01:00
|
|
|
snd_iprintf(buffer, "Card: %s\n", chip->card->longname);
|
|
|
|
for (unitid = 0; unitid < MAX_ID_ELEMS; unitid++) {
|
|
|
|
for (cval = mixer->id_elems[unitid]; cval;
|
|
|
|
cval = cval->next_id_elem)
|
|
|
|
snd_usb_mixer_dump_cval(buffer, unitid, cval);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-29 16:29:28 +02:00
|
|
|
static void snd_usb_mixer_memory_change(struct usb_mixer_interface *mixer,
|
|
|
|
int unitid)
|
|
|
|
{
|
2006-05-05 09:49:53 +02:00
|
|
|
if (!mixer->rc_cfg)
|
2005-05-10 14:47:38 +02:00
|
|
|
return;
|
|
|
|
/* unit ids specific to Extigy/Audigy 2 NX: */
|
|
|
|
switch (unitid) {
|
|
|
|
case 0: /* remote control */
|
2005-04-29 16:29:28 +02:00
|
|
|
mixer->rc_urb->dev = mixer->chip->dev;
|
|
|
|
usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
|
2005-05-10 14:47:38 +02:00
|
|
|
break;
|
|
|
|
case 4: /* digital in jack */
|
|
|
|
case 7: /* line in jacks */
|
|
|
|
case 19: /* speaker out jacks */
|
|
|
|
case 20: /* headphones out jack */
|
|
|
|
break;
|
2007-10-30 15:28:14 +01:00
|
|
|
/* live24ext: 4 = line-in jack */
|
|
|
|
case 3: /* hp-out jack (may actuate Mute) */
|
2009-01-07 22:58:50 +01:00
|
|
|
if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
|
|
|
|
mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
|
2007-10-30 15:28:14 +01:00
|
|
|
snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
|
|
|
|
break;
|
2005-05-10 14:47:38 +02:00
|
|
|
default:
|
|
|
|
snd_printd(KERN_DEBUG "memory change in unknown unit %d\n", unitid);
|
|
|
|
break;
|
2005-04-29 16:29:28 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 15:55:46 +02:00
|
|
|
static void snd_usb_mixer_status_complete(struct urb *urb)
|
2005-04-29 16:26:14 +02:00
|
|
|
{
|
|
|
|
struct usb_mixer_interface *mixer = urb->context;
|
|
|
|
|
|
|
|
if (urb->status == 0) {
|
|
|
|
u8 *buf = urb->transfer_buffer;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = urb->actual_length; i >= 2; buf += 2, i -= 2) {
|
|
|
|
snd_printd(KERN_DEBUG "status interrupt: %02x %02x\n",
|
|
|
|
buf[0], buf[1]);
|
|
|
|
/* ignore any notifications not from the control interface */
|
|
|
|
if ((buf[0] & 0x0f) != 0)
|
|
|
|
continue;
|
|
|
|
if (!(buf[0] & 0x40))
|
|
|
|
snd_usb_mixer_notify_id(mixer, buf[1]);
|
2005-04-29 16:29:28 +02:00
|
|
|
else
|
|
|
|
snd_usb_mixer_memory_change(mixer, buf[1]);
|
2005-04-29 16:26:14 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (urb->status != -ENOENT && urb->status != -ECONNRESET) {
|
|
|
|
urb->dev = mixer->chip->dev;
|
|
|
|
usb_submit_urb(urb, GFP_ATOMIC);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* create the handler for the optional status interrupt endpoint */
|
|
|
|
static int snd_usb_mixer_status_create(struct usb_mixer_interface *mixer)
|
|
|
|
{
|
|
|
|
struct usb_host_interface *hostif;
|
|
|
|
struct usb_endpoint_descriptor *ep;
|
|
|
|
void *transfer_buffer;
|
|
|
|
int buffer_length;
|
|
|
|
unsigned int epnum;
|
|
|
|
|
|
|
|
hostif = &usb_ifnum_to_if(mixer->chip->dev, mixer->ctrlif)->altsetting[0];
|
|
|
|
/* we need one interrupt input endpoint */
|
|
|
|
if (get_iface_desc(hostif)->bNumEndpoints < 1)
|
|
|
|
return 0;
|
|
|
|
ep = get_endpoint(hostif, 0);
|
2009-01-03 17:54:53 +01:00
|
|
|
if (!usb_endpoint_dir_in(ep) || !usb_endpoint_xfer_int(ep))
|
2005-04-29 16:26:14 +02:00
|
|
|
return 0;
|
|
|
|
|
2008-12-29 11:23:02 +01:00
|
|
|
epnum = usb_endpoint_num(ep);
|
2005-04-29 16:26:14 +02:00
|
|
|
buffer_length = le16_to_cpu(ep->wMaxPacketSize);
|
|
|
|
transfer_buffer = kmalloc(buffer_length, GFP_KERNEL);
|
|
|
|
if (!transfer_buffer)
|
|
|
|
return -ENOMEM;
|
|
|
|
mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
|
|
|
|
if (!mixer->urb) {
|
|
|
|
kfree(transfer_buffer);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
usb_fill_int_urb(mixer->urb, mixer->chip->dev,
|
|
|
|
usb_rcvintpipe(mixer->chip->dev, epnum),
|
|
|
|
transfer_buffer, buffer_length,
|
|
|
|
snd_usb_mixer_status_complete, mixer, ep->bInterval);
|
|
|
|
usb_submit_urb(mixer->urb, GFP_KERNEL);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 15:55:46 +02:00
|
|
|
static void snd_usb_soundblaster_remote_complete(struct urb *urb)
|
2005-04-29 16:29:28 +02:00
|
|
|
{
|
|
|
|
struct usb_mixer_interface *mixer = urb->context;
|
2006-05-05 09:49:53 +02:00
|
|
|
const struct rc_config *rc = mixer->rc_cfg;
|
2005-04-29 16:29:28 +02:00
|
|
|
u32 code;
|
|
|
|
|
2008-08-05 11:01:00 +02:00
|
|
|
if (urb->status < 0 || urb->actual_length < rc->min_packet_length)
|
2005-04-29 16:29:28 +02:00
|
|
|
return;
|
2006-05-05 09:49:53 +02:00
|
|
|
|
|
|
|
code = mixer->rc_buffer[rc->offset];
|
|
|
|
if (rc->length == 2)
|
|
|
|
code |= mixer->rc_buffer[rc->offset + 1] << 8;
|
|
|
|
|
2005-04-29 16:29:28 +02:00
|
|
|
/* the Mute button actually changes the mixer control */
|
2006-05-05 09:49:53 +02:00
|
|
|
if (code == rc->mute_code)
|
|
|
|
snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
|
2005-04-29 16:29:28 +02:00
|
|
|
mixer->rc_code = code;
|
|
|
|
wmb();
|
|
|
|
wake_up(&mixer->rc_waitq);
|
|
|
|
}
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf,
|
2005-04-29 16:29:28 +02:00
|
|
|
long count, loff_t *offset)
|
|
|
|
{
|
|
|
|
struct usb_mixer_interface *mixer = hw->private_data;
|
|
|
|
int err;
|
|
|
|
u32 rc_code;
|
|
|
|
|
2005-05-02 08:58:31 +02:00
|
|
|
if (count != 1 && count != 4)
|
2005-04-29 16:29:28 +02:00
|
|
|
return -EINVAL;
|
|
|
|
err = wait_event_interruptible(mixer->rc_waitq,
|
|
|
|
(rc_code = xchg(&mixer->rc_code, 0)) != 0);
|
|
|
|
if (err == 0) {
|
2005-05-02 08:58:31 +02:00
|
|
|
if (count == 1)
|
|
|
|
err = put_user(rc_code, buf);
|
|
|
|
else
|
|
|
|
err = put_user(rc_code, (u32 __user *)buf);
|
2005-04-29 16:29:28 +02:00
|
|
|
}
|
|
|
|
return err < 0 ? err : count;
|
|
|
|
}
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file,
|
2005-04-29 16:29:28 +02:00
|
|
|
poll_table *wait)
|
|
|
|
{
|
|
|
|
struct usb_mixer_interface *mixer = hw->private_data;
|
|
|
|
|
|
|
|
poll_wait(file, &mixer->rc_waitq, wait);
|
|
|
|
return mixer->rc_code ? POLLIN | POLLRDNORM : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
|
|
|
|
{
|
2005-11-17 15:08:02 +01:00
|
|
|
struct snd_hwdep *hwdep;
|
2006-05-05 09:49:53 +02:00
|
|
|
int err, len, i;
|
2005-04-29 16:29:28 +02:00
|
|
|
|
2006-05-05 09:49:53 +02:00
|
|
|
for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
|
|
|
|
if (rc_configs[i].usb_id == mixer->chip->usb_id)
|
|
|
|
break;
|
|
|
|
if (i >= ARRAY_SIZE(rc_configs))
|
2005-04-29 16:29:28 +02:00
|
|
|
return 0;
|
2006-05-05 09:49:53 +02:00
|
|
|
mixer->rc_cfg = &rc_configs[i];
|
2005-04-29 16:29:28 +02:00
|
|
|
|
2006-05-05 09:49:53 +02:00
|
|
|
len = mixer->rc_cfg->packet_length;
|
|
|
|
|
2005-04-29 16:29:28 +02:00
|
|
|
init_waitqueue_head(&mixer->rc_waitq);
|
|
|
|
err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
snprintf(hwdep->name, sizeof(hwdep->name),
|
|
|
|
"%s remote control", mixer->chip->card->shortname);
|
|
|
|
hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
|
|
|
|
hwdep->private_data = mixer;
|
|
|
|
hwdep->ops.read = snd_usb_sbrc_hwdep_read;
|
|
|
|
hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
|
2009-02-05 09:28:08 +01:00
|
|
|
hwdep->exclusive = 1;
|
2005-04-29 16:29:28 +02:00
|
|
|
|
|
|
|
mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
|
|
|
|
if (!mixer->rc_urb)
|
|
|
|
return -ENOMEM;
|
|
|
|
mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
|
|
|
|
if (!mixer->rc_setup_packet) {
|
|
|
|
usb_free_urb(mixer->rc_urb);
|
|
|
|
mixer->rc_urb = NULL;
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
mixer->rc_setup_packet->bRequestType =
|
|
|
|
USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
|
2010-02-22 23:49:13 +01:00
|
|
|
mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
|
2005-04-29 16:29:28 +02:00
|
|
|
mixer->rc_setup_packet->wValue = cpu_to_le16(0);
|
|
|
|
mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
|
|
|
|
mixer->rc_setup_packet->wLength = cpu_to_le16(len);
|
|
|
|
usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
|
|
|
|
usb_rcvctrlpipe(mixer->chip->dev, 0),
|
|
|
|
(u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
|
|
|
|
snd_usb_soundblaster_remote_complete, mixer);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-23 15:42:26 +02:00
|
|
|
#define snd_audigy2nx_led_info snd_ctl_boolean_mono_info
|
2005-05-03 08:02:40 +02:00
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
|
2005-05-03 08:02:40 +02:00
|
|
|
{
|
|
|
|
struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
|
|
|
|
int index = kcontrol->private_value;
|
|
|
|
|
|
|
|
ucontrol->value.integer.value[0] = mixer->audigy2nx_leds[index];
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
|
2005-05-03 08:02:40 +02:00
|
|
|
{
|
|
|
|
struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
|
|
|
|
int index = kcontrol->private_value;
|
|
|
|
int value = ucontrol->value.integer.value[0];
|
|
|
|
int err, changed;
|
|
|
|
|
|
|
|
if (value > 1)
|
|
|
|
return -EINVAL;
|
|
|
|
changed = value != mixer->audigy2nx_leds[index];
|
|
|
|
err = snd_usb_ctl_msg(mixer->chip->dev,
|
|
|
|
usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
|
|
|
|
USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
|
|
|
|
value, index + 2, NULL, 0, 100);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
mixer->audigy2nx_leds[index] = value;
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static struct snd_kcontrol_new snd_audigy2nx_controls[] = {
|
2005-05-03 08:02:40 +02:00
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "CMSS LED Switch",
|
|
|
|
.info = snd_audigy2nx_led_info,
|
|
|
|
.get = snd_audigy2nx_led_get,
|
|
|
|
.put = snd_audigy2nx_led_put,
|
|
|
|
.private_value = 0,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Power LED Switch",
|
|
|
|
.info = snd_audigy2nx_led_info,
|
|
|
|
.get = snd_audigy2nx_led_get,
|
|
|
|
.put = snd_audigy2nx_led_put,
|
|
|
|
.private_value = 1,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Dolby Digital LED Switch",
|
|
|
|
.info = snd_audigy2nx_led_info,
|
|
|
|
.get = snd_audigy2nx_led_get,
|
|
|
|
.put = snd_audigy2nx_led_put,
|
|
|
|
.private_value = 2,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
|
|
|
|
{
|
|
|
|
int i, err;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_controls); ++i) {
|
2009-01-07 22:58:50 +01:00
|
|
|
if (i > 1 && /* Live24ext has 2 LEDs only */
|
|
|
|
(mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
|
|
|
|
mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
|
2007-10-30 15:28:14 +01:00
|
|
|
break;
|
2005-05-03 08:02:40 +02:00
|
|
|
err = snd_ctl_add(mixer->chip->card,
|
|
|
|
snd_ctl_new1(&snd_audigy2nx_controls[i], mixer));
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
mixer->audigy2nx_leds[1] = 1; /* Power LED is on by default */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-17 15:08:02 +01:00
|
|
|
static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
|
|
|
|
struct snd_info_buffer *buffer)
|
2005-05-10 14:47:38 +02:00
|
|
|
{
|
2007-10-30 15:28:14 +01:00
|
|
|
static const struct sb_jack {
|
2005-05-10 14:47:38 +02:00
|
|
|
int unitid;
|
|
|
|
const char *name;
|
2007-10-30 15:28:14 +01:00
|
|
|
} jacks_audigy2nx[] = {
|
2005-05-10 14:47:38 +02:00
|
|
|
{4, "dig in "},
|
|
|
|
{7, "line in"},
|
|
|
|
{19, "spk out"},
|
|
|
|
{20, "hph out"},
|
2007-10-30 15:28:14 +01:00
|
|
|
{-1, NULL}
|
|
|
|
}, jacks_live24ext[] = {
|
|
|
|
{4, "line in"}, /* &1=Line, &2=Mic*/
|
|
|
|
{3, "hph out"}, /* headphones */
|
|
|
|
{0, "RC "}, /* last command, 6 bytes see rc_config above */
|
|
|
|
{-1, NULL}
|
2005-05-10 14:47:38 +02:00
|
|
|
};
|
2007-10-30 15:28:14 +01:00
|
|
|
const struct sb_jack *jacks;
|
2005-05-10 14:47:38 +02:00
|
|
|
struct usb_mixer_interface *mixer = entry->private_data;
|
|
|
|
int i, err;
|
|
|
|
u8 buf[3];
|
|
|
|
|
|
|
|
snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
|
2007-10-30 15:28:14 +01:00
|
|
|
if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
|
|
|
|
jacks = jacks_audigy2nx;
|
2009-01-07 22:58:50 +01:00
|
|
|
else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
|
|
|
|
mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
|
2007-10-30 15:28:14 +01:00
|
|
|
jacks = jacks_live24ext;
|
|
|
|
else
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; jacks[i].name; ++i) {
|
2005-05-10 14:47:38 +02:00
|
|
|
snd_iprintf(buffer, "%s: ", jacks[i].name);
|
|
|
|
err = snd_usb_ctl_msg(mixer->chip->dev,
|
|
|
|
usb_rcvctrlpipe(mixer->chip->dev, 0),
|
2010-02-22 23:49:13 +01:00
|
|
|
UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
|
2005-05-10 14:47:38 +02:00
|
|
|
USB_RECIP_INTERFACE, 0,
|
|
|
|
jacks[i].unitid << 8, buf, 3, 100);
|
2007-10-30 15:28:14 +01:00
|
|
|
if (err == 3 && (buf[0] == 3 || buf[0] == 6))
|
2005-05-10 14:47:38 +02:00
|
|
|
snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]);
|
|
|
|
else
|
|
|
|
snd_iprintf(buffer, "?\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-13 11:39:29 +02:00
|
|
|
static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
|
|
|
|
|
|
|
|
ucontrol->value.integer.value[0] = !!(mixer->xonar_u1_status & 0x02);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
|
|
|
|
u8 old_status, new_status;
|
|
|
|
int err, changed;
|
|
|
|
|
|
|
|
old_status = mixer->xonar_u1_status;
|
|
|
|
if (ucontrol->value.integer.value[0])
|
|
|
|
new_status = old_status | 0x02;
|
|
|
|
else
|
|
|
|
new_status = old_status & ~0x02;
|
|
|
|
changed = new_status != old_status;
|
|
|
|
err = snd_usb_ctl_msg(mixer->chip->dev,
|
|
|
|
usb_sndctrlpipe(mixer->chip->dev, 0), 0x08,
|
|
|
|
USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
|
|
|
|
50, 0, &new_status, 1, 100);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
mixer->xonar_u1_status = new_status;
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct snd_kcontrol_new snd_xonar_u1_output_switch = {
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Digital Playback Switch",
|
|
|
|
.info = snd_ctl_boolean_mono_info,
|
|
|
|
.get = snd_xonar_u1_switch_get,
|
|
|
|
.put = snd_xonar_u1_switch_put,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = snd_ctl_add(mixer->chip->card,
|
|
|
|
snd_ctl_new1(&snd_xonar_u1_output_switch, mixer));
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
mixer->xonar_u1_status = 0x05;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-27 18:13:41 +01:00
|
|
|
void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
|
2010-02-16 11:17:09 +01:00
|
|
|
unsigned char samplerate_id)
|
2009-12-27 18:13:41 +01:00
|
|
|
{
|
2010-02-16 11:17:09 +01:00
|
|
|
struct usb_mixer_interface *mixer;
|
|
|
|
struct usb_mixer_elem_info *cval;
|
|
|
|
int unitid = 12; /* SamleRate ExtensionUnit ID */
|
2009-12-27 18:13:41 +01:00
|
|
|
|
2010-02-16 11:17:09 +01:00
|
|
|
list_for_each_entry(mixer, &chip->mixer_list, list) {
|
|
|
|
cval = mixer->id_elems[unitid];
|
|
|
|
if (cval) {
|
|
|
|
set_cur_ctl_value(cval, cval->control << 8,
|
|
|
|
samplerate_id);
|
2009-12-27 18:13:41 +01:00
|
|
|
snd_usb_mixer_notify_id(mixer, unitid);
|
2010-02-16 11:17:09 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2009-12-27 18:13:41 +01:00
|
|
|
}
|
|
|
|
|
2008-08-13 15:40:53 +02:00
|
|
|
int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
|
|
|
|
int ignore_error)
|
2005-04-29 16:23:13 +02:00
|
|
|
{
|
2005-11-17 15:08:02 +01:00
|
|
|
static struct snd_device_ops dev_ops = {
|
2005-04-29 16:23:13 +02:00
|
|
|
.dev_free = snd_usb_mixer_dev_free
|
|
|
|
};
|
|
|
|
struct usb_mixer_interface *mixer;
|
2010-02-16 11:17:09 +01:00
|
|
|
struct snd_info_entry *entry;
|
2010-02-22 23:49:12 +01:00
|
|
|
struct usb_host_interface *host_iface;
|
|
|
|
int err, protocol;
|
2005-04-29 16:23:13 +02:00
|
|
|
|
|
|
|
strcpy(chip->card->mixername, "USB Mixer");
|
|
|
|
|
[ALSA] Replace with kzalloc() - others
Documentation,SA11xx UDA1341 driver,Generic drivers,MPU401 UART,OPL3
OPL4,Digigram VX core,I2C cs8427,I2C lib core,I2C tea6330t,L3 drivers
AK4114 receiver,AK4117 receiver,PDAudioCF driver,PPC PMAC driver
SPARC AMD7930 driver,SPARC cs4231 driver,Synth,Common EMU synth
USB generic driver,USB USX2Y
Replace kcalloc(1,..) with kzalloc().
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2005-09-09 14:22:34 +02:00
|
|
|
mixer = kzalloc(sizeof(*mixer), GFP_KERNEL);
|
2005-04-29 16:23:13 +02:00
|
|
|
if (!mixer)
|
|
|
|
return -ENOMEM;
|
|
|
|
mixer->chip = chip;
|
|
|
|
mixer->ctrlif = ctrlif;
|
2008-08-13 15:40:53 +02:00
|
|
|
mixer->ignore_ctl_error = ignore_error;
|
2010-02-16 11:55:18 +01:00
|
|
|
mixer->id_elems = kcalloc(MAX_ID_ELEMS, sizeof(*mixer->id_elems),
|
|
|
|
GFP_KERNEL);
|
2005-04-29 16:26:14 +02:00
|
|
|
if (!mixer->id_elems) {
|
|
|
|
kfree(mixer);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2005-04-29 16:23:13 +02:00
|
|
|
|
2010-02-22 23:49:12 +01:00
|
|
|
host_iface = &usb_ifnum_to_if(chip->dev, ctrlif)->altsetting[0];
|
|
|
|
protocol = host_iface->desc.bInterfaceProtocol;
|
|
|
|
|
|
|
|
/* FIXME! */
|
|
|
|
if (protocol != UAC_VERSION_1) {
|
|
|
|
snd_printk(KERN_WARNING "mixer interface protocol 0x%02x not yet supported\n",
|
|
|
|
protocol);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-29 16:26:14 +02:00
|
|
|
if ((err = snd_usb_mixer_controls(mixer)) < 0 ||
|
2005-05-03 08:02:40 +02:00
|
|
|
(err = snd_usb_mixer_status_create(mixer)) < 0)
|
|
|
|
goto _error;
|
2005-04-29 16:23:13 +02:00
|
|
|
|
2005-05-03 08:02:40 +02:00
|
|
|
if ((err = snd_usb_soundblaster_remote_init(mixer)) < 0)
|
|
|
|
goto _error;
|
|
|
|
|
2007-10-30 15:28:14 +01:00
|
|
|
if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020) ||
|
2009-01-07 22:58:50 +01:00
|
|
|
mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
|
|
|
|
mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) {
|
2005-05-03 08:02:40 +02:00
|
|
|
if ((err = snd_audigy2nx_controls_create(mixer)) < 0)
|
|
|
|
goto _error;
|
2005-05-10 14:47:38 +02:00
|
|
|
if (!snd_card_proc_new(chip->card, "audigy2nx", &entry))
|
2006-04-28 15:13:41 +02:00
|
|
|
snd_info_set_text_ops(entry, mixer,
|
2005-05-10 14:47:38 +02:00
|
|
|
snd_audigy2nx_proc_read);
|
2005-04-29 16:29:28 +02:00
|
|
|
}
|
|
|
|
|
2009-07-13 11:39:29 +02:00
|
|
|
if (mixer->chip->usb_id == USB_ID(0x0b05, 0x1739) ||
|
|
|
|
mixer->chip->usb_id == USB_ID(0x0b05, 0x1743)) {
|
|
|
|
err = snd_xonar_u1_controls_create(mixer);
|
|
|
|
if (err < 0)
|
|
|
|
goto _error;
|
|
|
|
}
|
|
|
|
|
2005-04-29 16:23:13 +02:00
|
|
|
err = snd_device_new(chip->card, SNDRV_DEV_LOWLEVEL, mixer, &dev_ops);
|
2005-05-03 08:02:40 +02:00
|
|
|
if (err < 0)
|
|
|
|
goto _error;
|
2010-02-16 11:17:09 +01:00
|
|
|
|
|
|
|
if (list_empty(&chip->mixer_list) &&
|
|
|
|
!snd_card_proc_new(chip->card, "usbmixer", &entry))
|
|
|
|
snd_info_set_text_ops(entry, chip, snd_usb_mixer_proc_read);
|
|
|
|
|
2005-04-29 16:23:13 +02:00
|
|
|
list_add(&mixer->list, &chip->mixer_list);
|
|
|
|
return 0;
|
2005-05-03 08:02:40 +02:00
|
|
|
|
|
|
|
_error:
|
|
|
|
snd_usb_mixer_free(mixer);
|
|
|
|
return err;
|
2005-04-29 16:23:13 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void snd_usb_mixer_disconnect(struct list_head *p)
|
|
|
|
{
|
2005-04-29 16:26:14 +02:00
|
|
|
struct usb_mixer_interface *mixer;
|
|
|
|
|
|
|
|
mixer = list_entry(p, struct usb_mixer_interface, list);
|
2006-11-08 15:37:04 +01:00
|
|
|
usb_kill_urb(mixer->urb);
|
|
|
|
usb_kill_urb(mixer->rc_urb);
|
2005-04-29 16:23:13 +02:00
|
|
|
}
|