Lines Matching +full:chip +full:- +full:wide
1 // SPDX-License-Identifier: GPL-2.0-or-later
17 void snd_sbmixer_write(struct snd_sb *chip, unsigned char reg, unsigned char data)
19 outb(reg, SBP(chip, MIXER_ADDR));
21 outb(data, SBP(chip, MIXER_DATA));
24 dev_dbg(chip->card->dev, "mixer_write 0x%x 0x%x\n", reg, data);
28 unsigned char snd_sbmixer_read(struct snd_sb *chip, unsigned char reg)
32 outb(reg, SBP(chip, MIXER_ADDR));
34 result = inb(SBP(chip, MIXER_DATA));
37 dev_dbg(chip->card->dev, "mixer_read 0x%x 0x%x\n", reg, result);
48 int mask = (kcontrol->private_value >> 24) & 0xff;
50 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
51 uinfo->count = 1;
52 uinfo->value.integer.min = 0;
53 uinfo->value.integer.max = mask;
60 int reg = kcontrol->private_value & 0xff;
61 int shift = (kcontrol->private_value >> 16) & 0xff;
62 int mask = (kcontrol->private_value >> 24) & 0xff;
65 guard(spinlock_irqsave)(&sb->mixer_lock);
67 ucontrol->value.integer.value[0] = val;
74 int reg = kcontrol->private_value & 0xff;
75 int shift = (kcontrol->private_value >> 16) & 0x07;
76 int mask = (kcontrol->private_value >> 24) & 0xff;
80 val = (ucontrol->value.integer.value[0] & mask) << shift;
81 guard(spinlock_irqsave)(&sb->mixer_lock);
96 int mask = (kcontrol->private_value >> 24) & 0xff;
98 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
99 uinfo->count = 2;
100 uinfo->value.integer.min = 0;
101 uinfo->value.integer.max = mask;
108 int left_reg = kcontrol->private_value & 0xff;
109 int right_reg = (kcontrol->private_value >> 8) & 0xff;
110 int left_shift = (kcontrol->private_value >> 16) & 0x07;
111 int right_shift = (kcontrol->private_value >> 19) & 0x07;
112 int mask = (kcontrol->private_value >> 24) & 0xff;
115 guard(spinlock_irqsave)(&sb->mixer_lock);
118 ucontrol->value.integer.value[0] = left;
119 ucontrol->value.integer.value[1] = right;
126 int left_reg = kcontrol->private_value & 0xff;
127 int right_reg = (kcontrol->private_value >> 8) & 0xff;
128 int left_shift = (kcontrol->private_value >> 16) & 0x07;
129 int right_shift = (kcontrol->private_value >> 19) & 0x07;
130 int mask = (kcontrol->private_value >> 24) & 0xff;
134 left = (ucontrol->value.integer.value[0] & mask) << left_shift;
135 right = (ucontrol->value.integer.value[1] & mask) << right_shift;
136 guard(spinlock_irqsave)(&sb->mixer_lock);
158 * DT-019x / ALS-007 capture/input switch
175 scoped_guard(spinlock_irqsave, &sb->mixer_lock) {
180 ucontrol->value.enumerated.item[0] = 0;
183 ucontrol->value.enumerated.item[0] = 1;
186 ucontrol->value.enumerated.item[0] = 2;
189 ucontrol->value.enumerated.item[0] = 4;
195 * ucontrol->value.enumerated.item[0] = 3;
199 ucontrol->value.enumerated.item[0] = 4;
211 if (ucontrol->value.enumerated.item[0] > 4)
212 return -EINVAL;
213 switch (ucontrol->value.enumerated.item[0]) {
232 guard(spinlock_irqsave)(&sb->mixer_lock);
260 guard(spinlock_irqsave)(&sb->mixer_lock);
266 ucontrol->value.enumerated.item[0] = oval;
277 if (ucontrol->value.enumerated.item[0] > 2)
278 return -EINVAL;
279 guard(spinlock_irqsave)(&sb->mixer_lock);
283 | (ucontrol->value.enumerated.item[0] << 6);
309 guard(spinlock_irqsave)(&sb->mixer_lock);
313 ucontrol->value.enumerated.item[0] = 1;
316 ucontrol->value.enumerated.item[0] = 2;
319 ucontrol->value.enumerated.item[0] = 0;
331 if (ucontrol->value.enumerated.item[0] > 2)
332 return -EINVAL;
333 switch (ucontrol->value.enumerated.item[0]) {
344 guard(spinlock_irqsave)(&sb->mixer_lock);
359 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
360 uinfo->count = 4;
361 uinfo->value.integer.min = 0;
362 uinfo->value.integer.max = 1;
369 int reg1 = kcontrol->private_value & 0xff;
370 int reg2 = (kcontrol->private_value >> 8) & 0xff;
371 int left_shift = (kcontrol->private_value >> 16) & 0x0f;
372 int right_shift = (kcontrol->private_value >> 24) & 0x0f;
375 guard(spinlock_irqsave)(&sb->mixer_lock);
378 ucontrol->value.integer.value[0] = (val1 >> left_shift) & 0x01;
379 ucontrol->value.integer.value[1] = (val2 >> left_shift) & 0x01;
380 ucontrol->value.integer.value[2] = (val1 >> right_shift) & 0x01;
381 ucontrol->value.integer.value[3] = (val2 >> right_shift) & 0x01;
388 int reg1 = kcontrol->private_value & 0xff;
389 int reg2 = (kcontrol->private_value >> 8) & 0xff;
390 int left_shift = (kcontrol->private_value >> 16) & 0x0f;
391 int right_shift = (kcontrol->private_value >> 24) & 0x0f;
395 guard(spinlock_irqsave)(&sb->mixer_lock);
400 val1 |= (ucontrol->value.integer.value[0] & 1) << left_shift;
401 val2 |= (ucontrol->value.integer.value[1] & 1) << left_shift;
402 val1 |= (ucontrol->value.integer.value[2] & 1) << right_shift;
403 val2 |= (ucontrol->value.integer.value[3] & 1) << right_shift;
417 int snd_sbmixer_add_ctl(struct snd_sb *chip, const char *name, int index, int type, unsigned long value)
460 ctl = snd_ctl_new1(&newctls[type], chip);
462 return -ENOMEM;
463 strscpy(ctl->id.name, name, sizeof(ctl->id.name));
464 ctl->id.index = index;
465 ctl->private_value = value;
466 err = snd_ctl_add(chip->card, ctl);
508 SB_SINGLE("Capture Low-Pass Filter", SB_DSP_CAPTURE_FILT, 3, 1)
552 SB_DOUBLE("Tone Control - Bass",
554 SB_DOUBLE("Tone Control - Treble",
576 * e.g. snd_als4000_ctl_mono_playback_switch - check it! */
609 { SB_DT019X_MIC_DEV, 0 }, /* Includes PC-speaker in high nibble */
632 SB_SINGLE("3D Control - Switch", SB_ALS4000_3D_SND_FX, 6, 0x01),
637 SB_SINGLE("3D Control - Level", SB_ALS4000_3D_SND_FX, 0, 0x07),
639 SB_SINGLE("3D Control - Freq", SB_ALS4000_3D_SND_FX, 4, 0x03),
642 * "Wide" or "Space" or even "Level"? Assuming "Wide" for now... */
643 SB_SINGLE("3D Control - Wide", SB_ALS4000_3D_TIME_DELAY, 0, 0x0f),
670 static int snd_sbmixer_init(struct snd_sb *chip,
677 struct snd_card *card = chip->card;
681 scoped_guard(spinlock_irqsave, &chip->mixer_lock) {
682 snd_sbmixer_write(chip, 0x00, 0x00);
687 guard(spinlock_irqsave)(&chip->mixer_lock);
688 snd_sbmixer_write(chip, map[idx][0], map[idx][1]);
692 err = snd_sbmixer_add_ctl_elem(chip, &controls[idx]);
697 strscpy(card->mixername, name);
701 int snd_sbmixer_new(struct snd_sb *chip)
706 if (snd_BUG_ON(!chip || !chip->card))
707 return -EINVAL;
709 card = chip->card;
711 switch (chip->hardware) {
713 return 0; /* no mixer chip on SB1.x */
716 err = snd_sbmixer_init(chip,
727 err = snd_sbmixer_init(chip,
739 err = snd_sbmixer_init(chip,
750 err = snd_sbmixer_init(chip,
758 err = snd_sbmixer_init(chip,
768 err = snd_sbmixer_init(chip,
778 strscpy(card->mixername, "???");
856 static void save_mixer(struct snd_sb *chip, const unsigned char *regs, int num_regs)
858 unsigned char *val = chip->saved_regs;
859 if (snd_BUG_ON(num_regs > ARRAY_SIZE(chip->saved_regs)))
861 for (; num_regs; num_regs--)
862 *val++ = snd_sbmixer_read(chip, *regs++);
865 static void restore_mixer(struct snd_sb *chip, const unsigned char *regs, int num_regs)
867 unsigned char *val = chip->saved_regs;
868 if (snd_BUG_ON(num_regs > ARRAY_SIZE(chip->saved_regs)))
870 for (; num_regs; num_regs--)
871 snd_sbmixer_write(chip, *regs++, *val++);
874 void snd_sbmixer_suspend(struct snd_sb *chip)
876 switch (chip->hardware) {
879 save_mixer(chip, sb20_saved_regs, ARRAY_SIZE(sb20_saved_regs));
883 save_mixer(chip, sbpro_saved_regs, ARRAY_SIZE(sbpro_saved_regs));
888 save_mixer(chip, sb16_saved_regs, ARRAY_SIZE(sb16_saved_regs));
891 save_mixer(chip, als4000_saved_regs, ARRAY_SIZE(als4000_saved_regs));
894 save_mixer(chip, dt019x_saved_regs, ARRAY_SIZE(dt019x_saved_regs));
901 void snd_sbmixer_resume(struct snd_sb *chip)
903 switch (chip->hardware) {
906 restore_mixer(chip, sb20_saved_regs, ARRAY_SIZE(sb20_saved_regs));
910 restore_mixer(chip, sbpro_saved_regs, ARRAY_SIZE(sbpro_saved_regs));
915 restore_mixer(chip, sb16_saved_regs, ARRAY_SIZE(sb16_saved_regs));
918 restore_mixer(chip, als4000_saved_regs, ARRAY_SIZE(als4000_saved_regs));
921 restore_mixer(chip, dt019x_saved_regs, ARRAY_SIZE(dt019x_saved_regs));