ALSA update

  - added documentation for OSS emulation
  - CMI8330 - duplex/mixer cleanups
  - via82xx - rewritten for 8233+ (multiple playback, S/PDIF, secondary capture)
  - USB - quirk code update

Documentation/sound/alsa/DocBook/writing-an-alsa-driver.tmpl

@@ -4539,28 +4539,13 @@
           <programlisting>
 <![CDATA[
   #include <linux/vmalloc.h>
-  #include <linux/pagemap.h>
 
   /* get the physical page pointer on the given offset */
-  static struct page *mychip_page(snd_pcm_substream_t *subs,
+  static struct page *mychip_page(snd_pcm_substream_t *substream,
                                   unsigned long offset)
   {
-          pgd_t *pgd;
-          pmd_t *pmd;
-          pte_t *pte;
-          unsigned long lpage;
-          void *pageptr = subs->runtime->dma_area + offset;
-          struct page *page = NOPAGE_SIGBUS;
-
-          lpage = VMALLOC_VMADDR(pageptr);
-          spin_lock(&init_mm.page_table_lock);
-          pgd = pgd_offset(&init_mm, lpage);
-          pmd = pmd_offset(pgd, lpage);
-          pte = pte_offset(pmd, lpage);
-          page = pte_page(*pte);
-          spin_unlock(&init_mm.page_table_lock);
-
-          return page;
+          void *pageptr = substream->runtime->dma_area + offset;
+          return vmalloc_to_page(pageptr);
   }
 ]]>
           </programlisting>

include/sound/ad1848.h

@@ -22,7 +22,6 @@
  *
  */
 
-#include "control.h"
 #include "pcm.h"
 
 /* IO ports */
@@ -166,25 +165,40 @@ const snd_pcm_ops_t *snd_ad1848_get_pcm_ops(int direction);
 int snd_ad1848_mixer(ad1848_t * chip);
 void snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 
-#define AD1848_SINGLE(xname, xindex, reg, shift, mask, invert) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
-  .info = snd_ad1848_info_single, \
-  .get = snd_ad1848_get_single, .put = snd_ad1848_put_single, \
-  .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
+/* exported mixer stuffs */
+enum { AD1848_MIX_SINGLE, AD1848_MIX_DOUBLE, AD1848_MIX_CAPTURE };
+
+#define AD1848_MIXVAL_SINGLE(reg, shift, mask, invert) \
+	((reg) | ((shift) << 8) | ((mask) << 16) | ((invert) << 24))
+#define AD1848_MIXVAL_DOUBLE(left_reg, right_reg, shift_left, shift_right, mask, invert) \
+	((left_reg) | ((right_reg) << 8) | ((shift_left) << 16) | ((shift_right) << 19) | ((mask) << 24) | ((invert) << 22))
+
+int snd_ad1848_add_ctl(ad1848_t *chip, const char *name, int index, int type, unsigned long value);
 
-int snd_ad1848_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo);
-int snd_ad1848_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol);
-int snd_ad1848_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol);
+/* for ease of use */
+struct ad1848_mix_elem {
+	const char *name;
+	int index;
+	int type;
+	unsigned long private_value;
+};
+
+#define AD1848_SINGLE(xname, xindex, reg, shift, mask, invert) \
+{ .name = xname, \
+  .index = xindex, \
+  .type = AD1848_MIX_SINGLE, \
+  .private_value = AD1848_MIXVAL_SINGLE(reg, shift, mask, invert) }
 
 #define AD1848_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
-  .info = snd_ad1848_info_double, \
-  .get = snd_ad1848_get_double, .put = snd_ad1848_put_double, \
-  .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
-
-int snd_ad1848_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo);
-int snd_ad1848_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol);
-int snd_ad1848_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol);
+{ .name = xname, \
+  .index = xindex, \
+  .type = AD1848_MIX_DOUBLE, \
+  .private_value = AD1848_MIXVAL_DOUBLE(left_reg, right_reg, shift_left, shift_right, mask, invert) }
+
+static inline int snd_ad1848_add_ctl_elem(ad1848_t *chip, const struct ad1848_mix_elem *c)
+{
+	return snd_ad1848_add_ctl(chip, c->name, c->index, c->type, c->private_value);
+}
 
 #ifdef CONFIG_SND_DEBUG
 void snd_ad1848_debug(ad1848_t *chip);

include/sound/sb.h

@@ -314,4 +314,49 @@ int snd_sb16_capture_open(snd_pcm_substream_t *substream);
 int snd_sb16_playback_close(snd_pcm_substream_t *substream);
 int snd_sb16_capture_close(snd_pcm_substream_t *substream);
 
+/* exported mixer stuffs */
+enum {
+	SB_MIX_SINGLE,
+	SB_MIX_DOUBLE,
+	SB_MIX_INPUT_SW,
+	SB_MIX_CAPTURE_PRO,
+	SB_MIX_CAPTURE_DT019X
+};
+
+#define SB_MIXVAL_DOUBLE(left_reg, right_reg, left_shift, right_shift, mask) \
+  ((left_reg) | ((right_reg) << 8) | ((left_shift) << 16) | ((right_shift) << 19) | ((mask) << 24))
+#define SB_MIXVAL_SINGLE(reg, shift, mask) \
+  ((reg) | ((shift) << 16) | ((mask) << 24))
+#define SB_MIXVAL_INPUT_SW(reg1, reg2, left_shift, right_shift) \
+  ((reg1) | ((reg2) << 8) | ((left_shift) << 16) | ((right_shift) << 24))
+
+int snd_sbmixer_add_ctl(sb_t *chip, const char *name, int index, int type, unsigned long value);
+
+/* for ease of use */
+struct sbmix_elem {
+	const char *name;
+	int type;
+	unsigned long private_value;
+};
+
+#define SB_SINGLE(xname, reg, shift, mask) \
+{ .name = xname, \
+  .type = SB_MIX_SINGLE, \
+  .private_value = SB_MIXVAL_SINGLE(reg, shift, mask) }
+
+#define SB_DOUBLE(xname, left_reg, right_reg, left_shift, right_shift, mask) \
+{ .name = xname, \
+  .type = SB_MIX_DOUBLE, \
+  .private_value = SB_MIXVAL_DOUBLE(left_reg, right_reg, left_shift, right_shift, mask) }
+
+#define SB16_INPUT_SW(xname, reg1, reg2, left_shift, right_shift) \
+{ .name = xname, \
+  .type = SB_MIX_INPUT_SW, \
+  .private_value = SB_MIXVAL_INPUT_SW(reg1, reg2, left_shift, right_shift) }
+
+static inline int snd_sbmixer_add_ctl_elem(sb_t *chip, const struct sbmix_elem *c)
+{
+	return snd_sbmixer_add_ctl(chip, c->name, 0, c->type, c->private_value);
+}
+
 #endif /* __SOUND_SB_H */

include/sound/version.h

 /* include/version.h.  Generated automatically by configure.  */
 #define CONFIG_SND_VERSION "0.9.0rc6"
-#define CONFIG_SND_DATE " (Wed Jan 08 17:04:59 2003 UTC)"
+#define CONFIG_SND_DATE " (Fri Jan 10 18:18:43 2003 UTC)"

sound/core/info.c

@@ -1061,7 +1061,7 @@ snd_info_entry_t *snd_info_create_device(const char *name, unsigned int number,
 		return NULL;
 	entry->content = SNDRV_INFO_CONTENT_DEVICE;
 	entry->mode = mode;
-	entry->c.device.major = major;
+	entry->c.device.major = _major;
 	entry->c.device.minor = minor;
 	down(&info_mutex);
 	p = create_proc_entry(entry->name, entry->mode, snd_proc_dev);
@@ -1085,7 +1085,7 @@ snd_info_entry_t *snd_info_create_device(const char *name, unsigned int number,
 		char dname[32];
 		sprintf(dname, "snd/%s", name);
 		devfs_register(NULL, dname, DEVFS_FL_DEFAULT,
-				major, minor, mode,
+				_major, minor, mode,
 				&snd_fops, NULL);
 	}
 #endif

sound/isa/ad1848/ad1848_lib.c

@@ -28,6 +28,7 @@
 #include <linux/ioport.h>
 #include <sound/core.h>
 #include <sound/ad1848.h>
+#include <sound/control.h>
 #include <sound/pcm_params.h>
 
 #include <asm/io.h>
@@ -996,7 +997,7 @@ static int snd_ad1848_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *
 	return change;
 }
 
-int snd_ad1848_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_ad1848_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 {
 	int mask = (kcontrol->private_value >> 16) & 0xff;
 
@@ -1007,7 +1008,7 @@ int snd_ad1848_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo
 	return 0;
 }
 
-int snd_ad1848_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_ad1848_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
 	ad1848_t *chip = snd_kcontrol_chip(kcontrol);
 	unsigned long flags;
@@ -1024,7 +1025,7 @@ int snd_ad1848_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucon
 	return 0;
 }
 
-int snd_ad1848_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_ad1848_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
 	ad1848_t *chip = snd_kcontrol_chip(kcontrol);
 	unsigned long flags;
@@ -1047,7 +1048,7 @@ int snd_ad1848_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucon
 	return change;
 }
 
-int snd_ad1848_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_ad1848_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 {
 	int mask = (kcontrol->private_value >> 24) & 0xff;
 
@@ -1058,7 +1059,7 @@ int snd_ad1848_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo
 	return 0;
 }
 
-int snd_ad1848_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_ad1848_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
 	ad1848_t *chip = snd_kcontrol_chip(kcontrol);
 	unsigned long flags;
@@ -1080,7 +1081,7 @@ int snd_ad1848_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucon
 	return 0;
 }
 
-int snd_ad1848_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_ad1848_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
 	ad1848_t *chip = snd_kcontrol_chip(kcontrol);
 	unsigned long flags;
@@ -1117,9 +1118,47 @@ int snd_ad1848_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucon
 	return change;
 }
 
-#define AD1848_CONTROLS (sizeof(snd_ad1848_controls)/sizeof(snd_kcontrol_new_t))
+/*
+ */
+int snd_ad1848_add_ctl(ad1848_t *chip, const char *name, int index, int type, unsigned long value)
+{
+	static snd_kcontrol_new_t newctls[] = {
+		[AD1848_MIX_SINGLE] = {
+			.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+			.info = snd_ad1848_info_single,
+			.get = snd_ad1848_get_single,
+			.put = snd_ad1848_put_single,
+		},
+		[AD1848_MIX_DOUBLE] = {
+			.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+			.info = snd_ad1848_info_double,
+			.get = snd_ad1848_get_double,
+			.put = snd_ad1848_put_double,
+		},
+		[AD1848_MIX_CAPTURE] = {
+			.info = snd_ad1848_info_mux,
+			.get = snd_ad1848_get_mux,
+			.put = snd_ad1848_put_mux,
+		},
+	};
+	snd_kcontrol_t *ctl;
+	int err;
 
-static snd_kcontrol_new_t snd_ad1848_controls[] = {
+	ctl = snd_ctl_new1(&newctls[type], chip);
+	if (! ctl)
+		return -ENOMEM;
+	strncpy(ctl->id.name, name, sizeof(ctl->id.name)-1);
+	ctl->id.index = index;
+	ctl->private_value = value;
+	if ((err = snd_ctl_add(chip->card, ctl)) < 0) {
+		snd_ctl_free_one(ctl);
+		return err;
+	}
+	return 0;
+}
+
+
+static struct ad1848_mix_elem snd_ad1848_controls[] = {
 AD1848_DOUBLE("PCM Playback Switch", 0, AD1848_LEFT_OUTPUT, AD1848_RIGHT_OUTPUT, 7, 7, 1, 1),
 AD1848_DOUBLE("PCM Playback Volume", 0, AD1848_LEFT_OUTPUT, AD1848_RIGHT_OUTPUT, 0, 0, 63, 1),
 AD1848_DOUBLE("Aux Playback Switch", 0, AD1848_AUX1_LEFT_INPUT, AD1848_AUX1_RIGHT_INPUT, 7, 7, 1, 1),
@@ -1128,11 +1167,8 @@ AD1848_DOUBLE("Aux Playback Switch", 1, AD1848_AUX2_LEFT_INPUT, AD1848_AUX2_RIGH
 AD1848_DOUBLE("Aux Playback Volume", 1, AD1848_AUX2_LEFT_INPUT, AD1848_AUX2_RIGHT_INPUT, 0, 0, 31, 1),
 AD1848_DOUBLE("Capture Volume", 0, AD1848_LEFT_INPUT, AD1848_RIGHT_INPUT, 0, 0, 15, 0),
 {
-	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 	.name = "Capture Source",
-	.info = snd_ad1848_info_mux,
-	.get = snd_ad1848_get_mux,
-	.put = snd_ad1848_put_mux,
+	.type = AD1848_MIX_CAPTURE,
 },
 AD1848_SINGLE("Loopback Capture Switch", 0, AD1848_LOOPBACK, 0, 1, 0),
 AD1848_SINGLE("Loopback Capture Volume", 0, AD1848_LOOPBACK, 1, 63, 0)
@@ -1151,10 +1187,10 @@ int snd_ad1848_mixer(ad1848_t *chip)
 
 	strcpy(card->mixername, pcm->name);
 
-	for (idx = 0; idx < AD1848_CONTROLS; idx++) {
-		if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_ad1848_controls[idx], chip))) < 0)
+	for (idx = 0; idx < ARRAY_SIZE(snd_ad1848_controls); idx++)
+		if ((err = snd_ad1848_add_ctl_elem(chip, &snd_ad1848_controls[idx])) < 0)
 			return err;
-	}
+
 	return 0;
 }
 
@@ -1168,12 +1204,7 @@ EXPORT_SYMBOL(snd_ad1848_create);
 EXPORT_SYMBOL(snd_ad1848_pcm);
 EXPORT_SYMBOL(snd_ad1848_get_pcm_ops);
 EXPORT_SYMBOL(snd_ad1848_mixer);
-EXPORT_SYMBOL(snd_ad1848_info_single);
-EXPORT_SYMBOL(snd_ad1848_get_single);
-EXPORT_SYMBOL(snd_ad1848_put_single);
-EXPORT_SYMBOL(snd_ad1848_info_double);
-EXPORT_SYMBOL(snd_ad1848_get_double);
-EXPORT_SYMBOL(snd_ad1848_put_double);
+EXPORT_SYMBOL(snd_ad1848_add_ctl);
 
 /*
  *  INIT part

sound/isa/cmi8330.c

@@ -57,6 +57,13 @@
 #define SNDRV_GET_ID
 #include <sound/initval.h>
 
+/*
+ */
+#define ENABLE_SB_MIXER
+#define PLAYBACK_ON_SB
+
+/*
+ */
 MODULE_AUTHOR("George Talusan <gstalusan@uwaterloo.ca>");
 MODULE_DESCRIPTION("C-Media CMI8330");
 MODULE_LICENSE("GPL");
@@ -129,8 +136,12 @@ MODULE_PARM_SYNTAX(wssdma, SNDRV_DMA8_DESC ",prefers:{0}");
 
 static unsigned char snd_cmi8330_image[((CMI8330_CDINGAIN)-16) + 1] =
 {
-	0x0,			/* 16 - recording mux */
-	0x40,			/* 17 - mute mux */
+	0x40,			/* 16 - recording mux (SB-mixer-enabled) */
+#ifdef ENABLE_SB_MIXER
+	0x40,			/* 17 - mute mux (Mode2) */
+#else
+	0x0,			/* 17 - mute mux */
+#endif
 	0x0,			/* 18 - vol */
 	0x0,			/* 19 - master volume */
 	0x0,			/* 20 - line-in volume */
@@ -142,6 +153,8 @@ static unsigned char snd_cmi8330_image[((CMI8330_CDINGAIN)-16) + 1] =
 	0x0			/* 26 - cd-in rec gain */
 };
 
+typedef int (*snd_pcm_open_callback_t)(snd_pcm_substream_t *);
+
 struct snd_cmi8330 {
 #ifdef __ISAPNP__
 	struct isapnp_dev *cap;
@@ -152,10 +165,11 @@ struct snd_cmi8330 {
 	sb_t *sb;
 
 	snd_pcm_t *pcm;
-	snd_pcm_ops_t playback_ops;
-	int (*playback_open)(snd_pcm_substream_t *);
-	snd_pcm_ops_t capture_ops;
-	int (*capture_open)(snd_pcm_substream_t *);
+	struct snd_cmi8330_stream {
+		snd_pcm_ops_t ops;
+		snd_pcm_open_callback_t open;
+		void *private_data; /* sb or wss */
+	} streams[2];
 };
 
 static snd_card_t *snd_cmi8330_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
@@ -182,9 +196,8 @@ ISAPNP_CARD_TABLE(snd_cmi8330_pnpids);
 
 #endif
 
-#define CMI8330_CONTROLS (sizeof(snd_cmi8330_controls)/sizeof(snd_kcontrol_new_t))
 
-static snd_kcontrol_new_t snd_cmi8330_controls[] __devinitdata = {
+static struct ad1848_mix_elem snd_cmi8330_controls[] __initdata = {
 AD1848_DOUBLE("Master Playback Volume", 0, CMI8330_MASTVOL, CMI8330_MASTVOL, 4, 0, 15, 0),
 AD1848_SINGLE("Loud Playback Switch", 0, CMI8330_MUTEMUX, 6, 1, 1),
 AD1848_DOUBLE("PCM Playback Switch", 0, AD1848_LEFT_OUTPUT, AD1848_RIGHT_OUTPUT, 7, 7, 1, 1),
@@ -212,16 +225,79 @@ AD1848_SINGLE("IEC958 Input Capture Switch", 0, CMI8330_RMUX3D, 7, 1, 1),
 AD1848_SINGLE("IEC958 Input Playback Switch", 0, CMI8330_MUTEMUX, 7, 1, 1),
 };
 
-static int __init snd_cmi8330_mixer(snd_card_t *card, ad1848_t *chip)
+#ifdef ENABLE_SB_MIXER
+static struct sbmix_elem cmi8330_sb_mixers[] __initdata = {
+SB_DOUBLE("SB Master Playback Volume", SB_DSP4_MASTER_DEV, (SB_DSP4_MASTER_DEV + 1), 3, 3, 31),
+SB_DOUBLE("Tone Control - Bass", SB_DSP4_BASS_DEV, (SB_DSP4_BASS_DEV + 1), 4, 4, 15),
+SB_DOUBLE("Tone Control - Treble", SB_DSP4_TREBLE_DEV, (SB_DSP4_TREBLE_DEV + 1), 4, 4, 15),
+SB_DOUBLE("SB PCM Playback Volume", SB_DSP4_PCM_DEV, (SB_DSP4_PCM_DEV + 1), 3, 3, 31),
+SB_DOUBLE("SB Synth Playback Volume", SB_DSP4_SYNTH_DEV, (SB_DSP4_SYNTH_DEV + 1), 3, 3, 31),
+SB_DOUBLE("SB CD Playback Switch", SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 2, 1, 1),
+SB_DOUBLE("SB CD Playback Volume", SB_DSP4_CD_DEV, (SB_DSP4_CD_DEV + 1), 3, 3, 31),
+SB_DOUBLE("SB Line Playback Switch", SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 4, 3, 1),
+SB_DOUBLE("SB Line Playback Volume", SB_DSP4_LINE_DEV, (SB_DSP4_LINE_DEV + 1), 3, 3, 31),
+SB_SINGLE("SB Mic Playback Switch", SB_DSP4_OUTPUT_SW, 0, 1),
+SB_SINGLE("SB Mic Playback Volume", SB_DSP4_MIC_DEV, 3, 31),
+SB_SINGLE("SB PC Speaker Volume", SB_DSP4_SPEAKER_DEV, 6, 3),
+SB_DOUBLE("SB Capture Volume", SB_DSP4_IGAIN_DEV, (SB_DSP4_IGAIN_DEV + 1), 6, 6, 3),
+SB_DOUBLE("SB Playback Volume", SB_DSP4_OGAIN_DEV, (SB_DSP4_OGAIN_DEV + 1), 6, 6, 3),
+SB_SINGLE("SB Mic Auto Gain", SB_DSP4_MIC_AGC, 0, 1),
+};
+
+static unsigned char cmi8330_sb_init_values[][2] __initdata = {
+	{ SB_DSP4_MASTER_DEV + 0, 0 },
+	{ SB_DSP4_MASTER_DEV + 1, 0 },
+	{ SB_DSP4_PCM_DEV + 0, 0 },
+	{ SB_DSP4_PCM_DEV + 1, 0 },
+	{ SB_DSP4_SYNTH_DEV + 0, 0 },
+	{ SB_DSP4_SYNTH_DEV + 1, 0 },
+	{ SB_DSP4_INPUT_LEFT, 0 },
+	{ SB_DSP4_INPUT_RIGHT, 0 },
+	{ SB_DSP4_OUTPUT_SW, 0 },
+	{ SB_DSP4_SPEAKER_DEV, 0 },
+};
+
+
+static int __init cmi8330_add_sb_mixers(sb_t *chip)
+{
+	int idx, err;
+	unsigned long flags;
+
+	spin_lock_irqsave(&chip->mixer_lock, flags);
+	snd_sbmixer_write(chip, 0x00, 0x00);		/* mixer reset */
+	spin_unlock_irqrestore(&chip->mixer_lock, flags);
+
+	/* mute and zero volume channels */
+	for (idx = 0; idx < ARRAY_SIZE(cmi8330_sb_init_values); idx++) {
+		spin_lock_irqsave(&chip->mixer_lock, flags);
+		snd_sbmixer_write(chip, cmi8330_sb_init_values[idx][0],
+				  cmi8330_sb_init_values[idx][1]);
+		spin_unlock_irqrestore(&chip->mixer_lock, flags);
+	}
+
+	for (idx = 0; idx < ARRAY_SIZE(cmi8330_sb_mixers); idx++) {
+		if ((err = snd_sbmixer_add_ctl_elem(chip, &cmi8330_sb_mixers[idx])) < 0)
+			return err;
+	}
+	return 0;
+}
+#endif
+
+static int __init snd_cmi8330_mixer(snd_card_t *card, struct snd_cmi8330 *acard)
 {
 	int idx, err;
 
 	strcpy(card->mixername, "CMI8330/C3D");
 
-	for (idx = 0; idx < CMI8330_CONTROLS; idx++)
-		if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_cmi8330_controls[idx], chip))) < 0)
+	for (idx = 0; idx < ARRAY_SIZE(snd_cmi8330_controls); idx++) {
+		if ((err = snd_ad1848_add_ctl_elem(acard->wss, &snd_cmi8330_controls[idx])) < 0)
 			return err;
+	}
 
+#ifdef ENABLE_SB_MIXER
+	if ((err = cmi8330_add_sb_mixers(acard->sb)) < 0)
+		return err;
+#endif
 	return 0;
 }
 
@@ -316,13 +392,21 @@ static void snd_cmi8330_deactivate(struct snd_cmi8330 *acard)
  *
  */
 
+#ifdef PLAYBACK_ON_SB
+#define CMI_SB_STREAM	SNDRV_PCM_STREAM_PLAYBACK
+#define CMI_AD_STREAM	SNDRV_PCM_STREAM_CAPTURE
+#else
+#define CMI_SB_STREAM	SNDRV_PCM_STREAM_CAPTURE
+#define CMI_AD_STREAM	SNDRV_PCM_STREAM_PLAYBACK
+#endif
+
 static int snd_cmi8330_playback_open(snd_pcm_substream_t * substream)
 {
 	struct snd_cmi8330 *chip = (struct snd_cmi8330 *)_snd_pcm_substream_chip(substream);
 
 	/* replace the private_data and call the original open callback */
-	substream->private_data = chip->sb;
-	return chip->playback_open(substream);
+	substream->private_data = chip->streams[SNDRV_PCM_STREAM_PLAYBACK].private_data;
+	return chip->streams[SNDRV_PCM_STREAM_PLAYBACK].open(substream);
 }
 
 static int snd_cmi8330_capture_open(snd_pcm_substream_t * substream)
@@ -330,8 +414,8 @@ static int snd_cmi8330_capture_open(snd_pcm_substream_t * substream)
 	struct snd_cmi8330 *chip = (struct snd_cmi8330 *)_snd_pcm_substream_chip(substream);
 
 	/* replace the private_data and call the original open callback */
-	substream->private_data = chip->wss;
-	return chip->capture_open(substream);
+	substream->private_data = chip->streams[SNDRV_PCM_STREAM_CAPTURE].private_data;
+	return chip->streams[SNDRV_PCM_STREAM_CAPTURE].open(substream);
 }
 
 static void snd_cmi8330_pcm_free(snd_pcm_t *pcm)
@@ -344,6 +428,10 @@ static int __init snd_cmi8330_pcm(snd_card_t *card, struct snd_cmi8330 *chip)
 	snd_pcm_t *pcm;
 	const snd_pcm_ops_t *ops;
 	int err;
+	static snd_pcm_open_callback_t cmi_open_callbacks[2] = {
+		snd_cmi8330_playback_open,
+		snd_cmi8330_capture_open
+	};
 
 	if ((err = snd_pcm_new(card, "CMI8330", 0, 1, 1, &pcm)) < 0)
 		return err;
@@ -351,20 +439,22 @@ static int __init snd_cmi8330_pcm(snd_card_t *card, struct snd_cmi8330 *chip)
 	pcm->private_data = chip;
 	pcm->private_free = snd_cmi8330_pcm_free;
 	
-	/* playback - SB16 */
-	ops = snd_sb16dsp_get_pcm_ops(SNDRV_PCM_STREAM_PLAYBACK);
-	chip->playback_ops = *ops;
-	chip->playback_open = ops->open;
-	chip->playback_ops.open = snd_cmi8330_playback_open;
+	/* SB16 */
+	ops = snd_sb16dsp_get_pcm_ops(CMI_SB_STREAM);
+	chip->streams[CMI_SB_STREAM].ops = *ops;
+	chip->streams[CMI_SB_STREAM].open = ops->open;
+	chip->streams[CMI_SB_STREAM].ops.open = cmi_open_callbacks[CMI_SB_STREAM];
+	chip->streams[CMI_SB_STREAM].private_data = chip->sb;
 
-	/* capture - AD1848 */
-	ops = snd_ad1848_get_pcm_ops(SNDRV_PCM_STREAM_CAPTURE);
-	chip->capture_ops = *ops;
-	chip->capture_open = ops->open;
-	chip->capture_ops.open = snd_cmi8330_capture_open;
+	/* AD1848 */
+	ops = snd_ad1848_get_pcm_ops(CMI_AD_STREAM);
+	chip->streams[CMI_AD_STREAM].ops = *ops;
+	chip->streams[CMI_AD_STREAM].open = ops->open;
+	chip->streams[CMI_AD_STREAM].ops.open = cmi_open_callbacks[CMI_AD_STREAM];
+	chip->streams[CMI_AD_STREAM].private_data = chip->wss;
 
-	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &chip->playback_ops);
-	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &chip->capture_ops);
+	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &chip->streams[SNDRV_PCM_STREAM_PLAYBACK].ops);
+	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &chip->streams[SNDRV_PCM_STREAM_CAPTURE].ops);
 
 	snd_pcm_lib_preallocate_isa_pages_for_all(pcm, 64*1024, 128*1024);
 	chip->pcm = pcm;
@@ -457,22 +547,18 @@ static int __init snd_cmi8330_probe(int dev)
 		snd_card_free(card);
 		return -ENODEV;
 	}
-	memcpy(&acard->wss->image[16], &snd_cmi8330_image, sizeof(snd_cmi8330_image));
 
 	spin_lock_irqsave(&acard->wss->reg_lock, flags);
-	snd_ad1848_out(acard->wss, AD1848_MISC_INFO,	/* switch on MODE2 */
-		       acard->wss->image[AD1848_MISC_INFO] |= 0x40);
+	snd_ad1848_out(acard->wss, AD1848_MISC_INFO, 0x40); /* switch on MODE2 */
+	for (i = CMI8330_RMUX3D; i <= CMI8330_CDINGAIN; i++)
+		snd_ad1848_out(acard->wss, i, snd_cmi8330_image[i - CMI8330_RMUX3D]);
 	spin_unlock_irqrestore(&acard->wss->reg_lock, flags);
 
-	if ((err = snd_cmi8330_mixer(card, acard->wss)) < 0) {
+	if ((err = snd_cmi8330_mixer(card, acard)) < 0) {
 		snd_printk("failed to create mixers\n");
 		snd_card_free(card);
 		return err;
 	}
-	spin_lock_irqsave(&acard->wss->reg_lock, flags);
-	for (i = CMI8330_RMUX3D; i <= CMI8330_CDINGAIN; i++)
-		snd_ad1848_out(acard->wss, i, acard->wss->image[i]);
-	spin_unlock_irqrestore(&acard->wss->reg_lock, flags);
 
 	if ((err = snd_cmi8330_pcm(card, acard)) < 0) {
 		snd_printk("failed to create pcms\n");

sound/isa/sb/sb_common.c

@@ -297,6 +297,7 @@ EXPORT_SYMBOL(snd_sbdsp_create);
 EXPORT_SYMBOL(snd_sbmixer_write);
 EXPORT_SYMBOL(snd_sbmixer_read);
 EXPORT_SYMBOL(snd_sbmixer_new);
+EXPORT_SYMBOL(snd_sbmixer_add_ctl);
 
 /*
  *  INIT part

sound/isa/sgalaxy.c

@@ -30,6 +30,7 @@
 #include <sound/core.h>
 #include <sound/sb.h>
 #include <sound/ad1848.h>
+#include <sound/control.h>
 #define SNDRV_LEGACY_FIND_FREE_IRQ
 #define SNDRV_LEGACY_FIND_FREE_DMA
 #define SNDRV_GET_ID
@@ -176,9 +177,7 @@ static int __init snd_sgalaxy_detect(int dev, int irq, int dma)
 	return snd_sgalaxy_setup_wss(wssport[dev], irq, dma);
 }
 
-#define SGALAXY_CONTROLS 2
-
-static snd_kcontrol_new_t snd_sgalaxy_controls[2] = {
+static struct ad1848_mix_elem snd_sgalaxy_controls[] = {
 AD1848_DOUBLE("Aux Playback Switch", 0, SGALAXY_AUXC_LEFT, SGALAXY_AUXC_RIGHT, 7, 7, 1, 1),
 AD1848_DOUBLE("Aux Playback Volume", 0, SGALAXY_AUXC_LEFT, SGALAXY_AUXC_RIGHT, 0, 0, 31, 0)
 };
@@ -211,8 +210,8 @@ static int __init snd_sgalaxy_mixer(ad1848_t *chip)
 	if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0)
 		return err;
 	/* build AUX2 input */
-	for (idx = 0; idx < SGALAXY_CONTROLS; idx++) {
-		if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_sgalaxy_controls[idx], chip))) < 0)
+	for (idx = 0; idx < ARRAY_SIZE(snd_sgalaxy_controls); idx++) {
+		if ((err = snd_ad1848_add_ctl_elem(chip, &snd_sgalaxy_controls[idx])) < 0)
 			return err;
 	}
 	return 0;

sound/pci/Kconfig

@@ -116,10 +116,10 @@ config SND_ENS1371
 	  Sound Blaster PCI 64 or 128 soundcards.
 
 config SND_ES1938
-	tristate "ESS ES1938/1946 (Solo-1)"
+	tristate "ESS ES1938/1946/1969 (Solo-1)"
 	depends on SND && SOUND_GAMEPORT
 	help
-	  Say 'Y' or 'M' to include support for ESS Solo-1 (ES1938, ES1946)
+	  Say 'Y' or 'M' to include support for ESS Solo-1 (ES1938, ES1946, ES1969)
 	  soundcard.
 
 config SND_ES1968

sound/pci/intel8x0.c

@@ -1278,6 +1278,9 @@ static int __devinit snd_intel8x0_pcm_mic(intel8x0_t *chip, int device, snd_pcm_
 	sprintf(pcm->name, "%s - MIC ADC", chip->card->shortname);
 
 	chip->pcm_mic = pcm;	
+
+	snd_pcm_lib_preallocate_pci_pages_for_all(chip->pci, pcm, 0, 128*1024);
+
 	if (rpcm)
 		*rpcm = pcm;
 	return 0;
@@ -1312,6 +1315,9 @@ static int __devinit snd_intel8x0_pcm_mic2(intel8x0_t *chip, int device, snd_pcm
 	sprintf(pcm->name, "%s - MIC2 ADC", chip->card->shortname);
 
 	chip->pcm_mic2 = pcm;	
+
+	snd_pcm_lib_preallocate_pci_pages_for_all(chip->pci, pcm, 0, 128*1024);
+
 	if (rpcm)
 		*rpcm = pcm;
 	return 0;
@@ -1346,6 +1352,9 @@ static int __devinit snd_intel8x0_pcm_capture2(intel8x0_t *chip, int device, snd
 	sprintf(pcm->name, "%s - ADC2", chip->card->shortname);
 
 	chip->pcm2 = pcm;	
+
+	snd_pcm_lib_preallocate_pci_pages_for_all(chip->pci, pcm, 0, 128*1024);
+
 	if (rpcm)
 		*rpcm = pcm;
 	return 0;
@@ -1380,6 +1389,9 @@ static int __devinit snd_intel8x0_pcm_spdif(intel8x0_t *chip, int device, snd_pc
 	sprintf(pcm->name, "%s - IEC958", chip->card->shortname);
 
 	chip->pcm_spdif = pcm;	
+
+	snd_pcm_lib_preallocate_pci_pages_for_all(chip->pci, pcm, 64*1024, 128*1024);
+
 	if (rpcm)
 		*rpcm = pcm;
 	return 0;
@@ -1415,6 +1427,9 @@ static int __devinit snd_intel8x0_ali_spdif(intel8x0_t *chip, int device, snd_pc
 	sprintf(pcm->name, "%s - IEC958", chip->card->shortname);
 
 	chip->pcm_spdif = pcm;	
+
+	snd_pcm_lib_preallocate_pci_pages_for_all(chip->pci, pcm, 64*1024, 128*1024);
+
 	if (rpcm)
 		*rpcm = pcm;
 	return 0;
@@ -1449,6 +1464,9 @@ static int __devinit snd_intel8x0_ali_ac97spdif(intel8x0_t *chip, int device, sn
 	sprintf(pcm->name, "%s - AC97 IEC958", chip->card->shortname);
 
 	chip->pcm_ac97spdif = pcm;	
+
+	snd_pcm_lib_preallocate_pci_pages_for_all(chip->pci, pcm, 64*1024, 128*1024);
+
 	if (rpcm)
 		*rpcm = pcm;
 	return 0;
@@ -1790,6 +1808,10 @@ static int snd_intel8x0_ich_chip_init(intel8x0_t *chip)
 	} while (time_after_eq(end_time, jiffies));
 
       __ok3:      
+	if (chip->device_type == DEVICE_SIS) {
+		/* unmute the output on SIS7012 */
+		iputword(chip, 0x4c, igetword(chip, 0x4c) | 1);
+	}
       	return 0;
 }
 
@@ -2476,6 +2498,8 @@ static struct pci_driver joystick_driver = {
 	.id_table = snd_intel8x0_joystick_ids,
 	.probe = snd_intel8x0_joystick_probe,
 };
+
+static int have_joystick;
 #endif
 
 static int __init alsa_card_intel8x0_init(void)
@@ -2489,7 +2513,13 @@ static int __init alsa_card_intel8x0_init(void)
                 return err;
         }
 #if defined(SUPPORT_JOYSTICK) || defined(SUPPORT_MIDI)
-	pci_module_init(&joystick_driver);
+	if (pci_module_init(&joystick_driver) < 0) {
+		snd_printdd(KERN_INFO "no joystick found\n");
+		have_joystick = 0;
+	} else {
+		snd_printdd(KERN_INFO "joystick(s) found\n");
+		have_joystick = 1;
+	}
 #endif
         return 0;
 
@@ -2499,6 +2529,7 @@ static void __exit alsa_card_intel8x0_exit(void)
 {
 	pci_unregister_driver(&driver);
 #if defined(SUPPORT_JOYSTICK) || defined(SUPPORT_MIDI)
+	if (have_joystick)
 		pci_unregister_driver(&joystick_driver);
 #endif
 }

sound/pci/rme32.c

 /*
  *   ALSA driver for RME Digi32, Digi32/8 and Digi32 PRO audio interfaces
  *
- *	Copyright (c) 2002 Martin Langer <martin-langer@gmx.de>
+ *	Copyright (c) 2002, 2003 Martin Langer <martin-langer@gmx.de>
  *
  *      Thanks to :        Anders Torger <torger@ludd.luth.se>,
  *                         Henk Hesselink <henk@anda.nl>
@@ -70,6 +70,7 @@
 #include <sound/asoundef.h>
 #define SNDRV_GET_ID
 #include <sound/initval.h>
+#include <sound/info.h>
 
 #include <asm/io.h>
 
@@ -256,8 +257,6 @@ snd_rme32_capture_pointer(snd_pcm_substream_t * substream);
 
 static void snd_rme32_proc_init(rme32_t * rme32);
 
-static void snd_rme32_proc_done(rme32_t * rme32);
-
 static int snd_rme32_create_switches(snd_card_t * card, rme32_t * rme32);
 
 static inline unsigned int snd_rme32_playback_ptr(rme32_t * rme32)
@@ -1830,7 +1829,7 @@ static snd_kcontrol_new_t snd_rme32_controls[] = {
 	},
 	{
 		.iface = SNDRV_CTL_ELEM_IFACE_PCM,
-		.name =	"Clock Mode",
+		.name =	"Sample Clock Source",
 		.info =	snd_rme32_info_clockmode_control,
 		.get =	snd_rme32_get_clockmode_control,
 		.put =	snd_rme32_put_clockmode_control

sound/pci/ymfpci/ymfpci_main.c

@@ -1170,6 +1170,7 @@ static void snd_ymfpci_pcm_spdif_free(snd_pcm_t *pcm)
 {
 	ymfpci_t *chip = snd_magic_cast(ymfpci_t, pcm->private_data, return);
 	chip->pcm_spdif = NULL;
+	snd_pcm_lib_preallocate_free_for_all(pcm);
 }
 
 int __devinit snd_ymfpci_pcm_spdif(ymfpci_t *chip, int device, snd_pcm_t ** rpcm)
@@ -1190,6 +1191,9 @@ int __devinit snd_ymfpci_pcm_spdif(ymfpci_t *chip, int device, snd_pcm_t ** rpcm
 	pcm->info_flags = 0;
 	strcpy(pcm->name, "YMFPCI - IEC958");
 	chip->pcm_spdif = pcm;
+
+	snd_pcm_lib_preallocate_pci_pages_for_all(chip->pci, pcm, 64*1024, 256*1024);
+
 	if (rpcm)
 		*rpcm = pcm;
 	return 0;
@@ -1210,6 +1214,7 @@ static void snd_ymfpci_pcm_4ch_free(snd_pcm_t *pcm)
 {
 	ymfpci_t *chip = snd_magic_cast(ymfpci_t, pcm->private_data, return);
 	chip->pcm_4ch = NULL;
+	snd_pcm_lib_preallocate_free_for_all(pcm);
 }
 
 int __devinit snd_ymfpci_pcm_4ch(ymfpci_t *chip, int device, snd_pcm_t ** rpcm)
@@ -1230,6 +1235,9 @@ int __devinit snd_ymfpci_pcm_4ch(ymfpci_t *chip, int device, snd_pcm_t ** rpcm)
 	pcm->info_flags = 0;
 	strcpy(pcm->name, "YMFPCI - Rear PCM");
 	chip->pcm_4ch = pcm;
+
+	snd_pcm_lib_preallocate_pci_pages_for_all(chip->pci, pcm, 64*1024, 256*1024);
+
 	if (rpcm)
 		*rpcm = pcm;
 	return 0;

sound/usb/usbaudio.c

@@ -1953,7 +1953,6 @@ static int snd_usb_roland_ua100_hack_intf(snd_usb_audio_t *chip, int ifnum)
 static int snd_usb_roland_ua100_hack(snd_usb_audio_t *chip)
 {
 	static const snd_usb_midi_endpoint_info_t ep_quirk = {
-		.epnum = -1,
 		.out_cables = 0x0007,
 		.in_cables  = 0x0007
 	};

sound/usb/usbaudio.h

@@ -165,7 +165,7 @@ struct snd_usb_audio_quirk {
 
 /* data for QUIRK_MIDI_FIXED_ENDPOINT */
 struct snd_usb_midi_endpoint_info {
-	int16_t epnum;		/* ep number, -1 autodetect */
+	int8_t out_ep, in_ep;	/* ep number, 0 autodetect */
 	uint16_t out_cables;	/* bitmask */
 	uint16_t in_cables;	/* bitmask */
 };

sound/usb/usbmidi.c

@@ -579,9 +579,9 @@ static int snd_usbmidi_in_endpoint_create(snd_usb_midi_t* umidi,
 		return -ENOMEM;
 	}
 	if (int_epd)
-		pipe = usb_rcvintpipe(umidi->chip->dev, ep_info->epnum);
+		pipe = usb_rcvintpipe(umidi->chip->dev, ep_info->in_ep);
 	else
-		pipe = usb_rcvbulkpipe(umidi->chip->dev, ep_info->epnum);
+		pipe = usb_rcvbulkpipe(umidi->chip->dev, ep_info->in_ep);
 	length = usb_maxpacket(umidi->chip->dev, pipe, 0);
 	buffer = kmalloc(length, GFP_KERNEL);
 	if (!buffer) {
@@ -652,7 +652,7 @@ static int snd_usbmidi_out_endpoint_create(snd_usb_midi_t* umidi,
 		snd_usbmidi_out_endpoint_delete(ep);
 		return -ENOMEM;
 	}
-	pipe = usb_sndbulkpipe(umidi->chip->dev, ep_info->epnum);
+	pipe = usb_sndbulkpipe(umidi->chip->dev, ep_info->out_ep);
 	ep->max_transfer = usb_maxpacket(umidi->chip->dev, pipe, 1) & ~3;
 	buffer = kmalloc(ep->max_transfer, GFP_KERNEL);
 	if (!buffer) {
@@ -737,8 +737,6 @@ static int snd_usbmidi_create_endpoints(snd_usb_midi_t* umidi,
 	int out_ports = 0, in_ports = 0;
 
 	for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
-		if (!endpoints[i].epnum)
-			continue;
 		if (endpoints[i].out_cables) {
 			err = snd_usbmidi_out_endpoint_create(umidi, &endpoints[i],
 							      &umidi->endpoints[i]);
@@ -812,30 +810,35 @@ static int snd_usbmidi_get_ms_info(snd_usb_midi_t* umidi,
 		    ms_ep->bDescriptorType != USB_DT_CS_ENDPOINT ||
 		    ms_ep->bDescriptorSubtype != MS_GENERAL)
 			continue;
-		if (endpoints[epidx].epnum != 0 &&
-		    endpoints[epidx].epnum != (ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK)) {
-			++epidx;
-			if (epidx >= MIDI_MAX_ENDPOINTS) {
+		if ((ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK) == USB_DIR_OUT) {
+			if (endpoints[epidx].out_ep) {
+				if (++epidx >= MIDI_MAX_ENDPOINTS) {
 					printk(KERN_WARNING "snd-usb-midi: too many endpoints\n");
 					break;
 				}
 			}
-		endpoints[epidx].epnum = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
-		if (ep->bEndpointAddress & USB_DIR_IN) {
-			endpoints[epidx].in_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1;
-		} else {
+			endpoints[epidx].out_ep = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 			endpoints[epidx].out_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1;
+			printk(KERN_INFO "snd-usb-midi: EP %02X: %d jack(s)\n",
+			       ep->bEndpointAddress, ms_ep->bNumEmbMIDIJack);
+		} else {
+			if (endpoints[epidx].in_ep) {
+				if (++epidx >= MIDI_MAX_ENDPOINTS) {
+					printk(KERN_WARNING "snd-usb-midi: too many endpoints\n");
+					break;
+				}
+			}
+			endpoints[epidx].in_ep = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+			endpoints[epidx].in_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1;
+			printk(KERN_INFO "snd-usb-midi: EP %02X: %d jack(s)\n",
+			       ep->bEndpointAddress, ms_ep->bNumEmbMIDIJack);
 		}
-		printk(KERN_INFO "snd-usb-midi: detected %d %s jack(s) on endpoint %d\n",
-		       ms_ep->bNumEmbMIDIJack,
-		       ep->bEndpointAddress & USB_DIR_IN ? "input" : "output",
-		       endpoints[epidx].epnum);
 	}
 	return 0;
 }
 
 /*
- * If the first endpoint isn't specified, use the first endpoint in the
+ * If the endpoints aren't specified, use the first bulk endpoints in the
  * first alternate setting of the interface.
  */
 static int snd_usbmidi_detect_endpoint(snd_usb_midi_t* umidi, 
@@ -845,8 +848,8 @@ static int snd_usbmidi_detect_endpoint(snd_usb_midi_t* umidi,
 	struct usb_host_interface *hostif;
 	struct usb_interface_descriptor* intfd;
 	struct usb_endpoint_descriptor* epd;
+	int i;
 
-	if (endpoint->epnum == -1) {
 	intf = umidi->iface;
 	if (!intf || intf->num_altsetting < 1)
 		return -ENOENT;
@@ -854,8 +857,17 @@ static int snd_usbmidi_detect_endpoint(snd_usb_midi_t* umidi,
 	intfd = get_iface_desc(hostif);
 	if (intfd->bNumEndpoints < 1)
 		return -ENOENT;
-		epd = get_endpoint(hostif, 0);
-		endpoint->epnum = epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+
+	for (i = 0; i < intfd->bNumEndpoints; ++i) {
+		epd = get_endpoint(hostif, i);
+		if ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK)
+			continue;
+		if (!endpoint->out_ep && endpoint->out_cables &&
+		    (epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT)
+			endpoint->out_ep = epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+		if (!endpoint->in_ep && endpoint->in_cables &&
+		    (epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
+			endpoint->in_ep = epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 	}
 	return 0;
 }
@@ -892,7 +904,6 @@ static int snd_usbmidi_detect_yamaha(snd_usb_midi_t* umidi,
 	if (!endpoint->in_cables && !endpoint->out_cables)
 		return -ENOENT;
 
-	endpoint->epnum = -1;
 	return snd_usbmidi_detect_endpoint(umidi, endpoint);
 }
 
@@ -940,13 +951,13 @@ static int snd_usbmidi_create_endpoints_midiman(snd_usb_midi_t* umidi,
 		}
 	}
 
-	ep_info.epnum = get_endpoint(hostif, 2)->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+	ep_info.out_ep = get_endpoint(hostif, 2)->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 	ep_info.out_cables = endpoint->out_cables & 0x5555;
 	err = snd_usbmidi_out_endpoint_create(umidi, &ep_info, &umidi->endpoints[0]);
 	if (err < 0)
 		return err;
 
-	ep_info.epnum = get_endpoint(hostif, 0)->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+	ep_info.in_ep = get_endpoint(hostif, 0)->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 	ep_info.in_cables = endpoint->in_cables;
 	err = snd_usbmidi_in_endpoint_create(umidi, &ep_info, &umidi->endpoints[0]);
 	if (err < 0)
@@ -954,7 +965,7 @@ static int snd_usbmidi_create_endpoints_midiman(snd_usb_midi_t* umidi,
 	umidi->endpoints[0].in->urb->complete = snd_usb_complete_callback(snd_usbmidi_in_midiman_complete);
 
 	if (endpoint->out_cables > 0x0001) {
-		ep_info.epnum = get_endpoint(hostif, 4)->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+		ep_info.out_ep = get_endpoint(hostif, 4)->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 		ep_info.out_cables = endpoint->out_cables & 0xaaaa;
 		err = snd_usbmidi_out_endpoint_create(umidi, &ep_info, &umidi->endpoints[1]);
 		if (err < 0)

sound/usb/usbquirks.h

@@ -245,7 +245,6 @@
 		.ifnum = 2,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x000f,
 			.in_cables  = 0x000f
 		}
@@ -259,7 +258,6 @@
 		.ifnum = 2,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x003f,
 			.in_cables  = 0x003f
 		}
@@ -273,7 +271,6 @@
 		.ifnum = 2,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x0003,
 			.in_cables  = 0x0003
 		}
@@ -287,7 +284,6 @@
 		.ifnum = 2,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x0003,
 			.in_cables  = 0x0003
 		}
@@ -301,7 +297,6 @@
 		.ifnum = 2,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x0013,
 			.in_cables  = 0x0013
 		}
@@ -315,7 +310,6 @@
 		.ifnum = 2,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x0001,
 			.in_cables  = 0x0001
 		}
@@ -329,7 +323,6 @@
 		.ifnum = 2,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x0001,
 			.in_cables  = 0x0001
 		}
@@ -343,7 +336,6 @@
 		.ifnum = 2,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x0013,
 			.in_cables  = 0x0013
 		}
@@ -357,7 +349,6 @@
 		.ifnum = 2,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x0007,
 			.in_cables  = 0x0007
 		}
@@ -371,7 +362,6 @@
 		.ifnum = 0,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x0001,
 			.in_cables  = 0x0001
 		}
@@ -385,7 +375,6 @@
 		.ifnum = 0,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x01ff,
 			.in_cables  = 0x01ff
 		}
@@ -399,7 +388,6 @@
 		.ifnum = 2,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x000f,
 			.in_cables  = 0x000f
 		}
@@ -413,7 +401,6 @@
 		.ifnum = 0,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x003f,
 			.in_cables  = 0x003f
 		}
@@ -427,7 +414,6 @@
 		.ifnum = 3,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x0001,
 			.in_cables  = 0x0001
 		}
@@ -441,7 +427,6 @@
 		.ifnum = 0,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x0003,
 			.in_cables  = 0x0007
 		}
@@ -455,7 +440,6 @@
 		.ifnum = 0,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x000f,
 			.in_cables  = 0x000f
 		}
@@ -469,7 +453,6 @@
 		.ifnum = 3,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x0003,
 			.in_cables  = 0x0003
 		}
@@ -483,7 +466,6 @@
 		.ifnum = 0,
 		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 		.data = & (const snd_usb_midi_endpoint_info_t) {
-			.epnum = -1,
 			.out_cables = 0x0003,
 			.in_cables  = 0x0007
 		}