gus_mixer.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
  4 *  Routines for control of ICS 2101 chip and "mixer" in GF1 chip
  5 */
  6
  7#include <linux/time.h>
  8#include <linux/wait.h>
  9#include <sound/core.h>
 10#include <sound/control.h>
 11#include <sound/gus.h>
 12
 13/*
 14 *
 15 */
 16
 17#define GF1_SINGLE(xname, xindex, shift, invert) \
 18{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
 19  .info = snd_gf1_info_single, \
 20  .get = snd_gf1_get_single, .put = snd_gf1_put_single, \
 21  .private_value = shift | (invert << 8) }
 22
 23#define snd_gf1_info_single	snd_ctl_boolean_mono_info
 24
 25static int snd_gf1_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 26{
 27	struct snd_gus_card *gus = snd_kcontrol_chip(kcontrol);
 28	int shift = kcontrol->private_value & 0xff;
 29	int invert = (kcontrol->private_value >> 8) & 1;
 30	
 31	ucontrol->value.integer.value[0] = (gus->mix_cntrl_reg >> shift) & 1;
 32	if (invert)
 33		ucontrol->value.integer.value[0] ^= 1;
 34	return 0;
 35}
 36
 37static int snd_gf1_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 38{
 39	struct snd_gus_card *gus = snd_kcontrol_chip(kcontrol);
 40	int shift = kcontrol->private_value & 0xff;
 41	int invert = (kcontrol->private_value >> 8) & 1;
 42	int change;
 43	unsigned char oval, nval;
 44	
 45	nval = ucontrol->value.integer.value[0] & 1;
 46	if (invert)
 47		nval ^= 1;
 48	nval <<= shift;
 49	guard(spinlock_irqsave)(&gus->reg_lock);
 50	oval = gus->mix_cntrl_reg;
 51	nval = (oval & ~(1 << shift)) | nval;
 52	change = nval != oval;
 53	outb(gus->mix_cntrl_reg = nval, GUSP(gus, MIXCNTRLREG));
 54	outb(gus->gf1.active_voice = 0, GUSP(gus, GF1PAGE));
 55	return change;
 56}
 57
 58#define ICS_DOUBLE(xname, xindex, addr) \
 59{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
 60  .info = snd_ics_info_double, \
 61  .get = snd_ics_get_double, .put = snd_ics_put_double, \
 62  .private_value = addr }
 63
 64static int snd_ics_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 65{
 66	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 67	uinfo->count = 2;
 68	uinfo->value.integer.min = 0;
 69	uinfo->value.integer.max = 127;
 70	return 0;
 71}
 72
 73static int snd_ics_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 74{
 75	struct snd_gus_card *gus = snd_kcontrol_chip(kcontrol);
 76	int addr = kcontrol->private_value & 0xff;
 77	unsigned char left, right;
 78	
 79	guard(spinlock_irqsave)(&gus->reg_lock);
 80	left = gus->gf1.ics_regs[addr][0];
 81	right = gus->gf1.ics_regs[addr][1];
 82	ucontrol->value.integer.value[0] = left & 127;
 83	ucontrol->value.integer.value[1] = right & 127;
 84	return 0;
 85}
 86
 87static int snd_ics_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 88{
 89	struct snd_gus_card *gus = snd_kcontrol_chip(kcontrol);
 90	int addr = kcontrol->private_value & 0xff;
 91	int change;
 92	unsigned char val1, val2, oval1, oval2;
 93	
 94	val1 = ucontrol->value.integer.value[0] & 127;
 95	val2 = ucontrol->value.integer.value[1] & 127;
 96	guard(spinlock_irqsave)(&gus->reg_lock);
 97	oval1 = gus->gf1.ics_regs[addr][0];
 98	oval2 = gus->gf1.ics_regs[addr][1];
 99	change = val1 != oval1 || val2 != oval2;
100	gus->gf1.ics_regs[addr][0] = val1;
101	gus->gf1.ics_regs[addr][1] = val2;
102	if (gus->ics_flag && gus->ics_flipped &&
103	    (addr == SNDRV_ICS_GF1_DEV || addr == SNDRV_ICS_MASTER_DEV))
104		swap(val1, val2);
105	addr <<= 3;
106	outb(addr | 0, GUSP(gus, MIXCNTRLPORT));
107	outb(1, GUSP(gus, MIXDATAPORT));
108	outb(addr | 2, GUSP(gus, MIXCNTRLPORT));
109	outb((unsigned char) val1, GUSP(gus, MIXDATAPORT));
110	outb(addr | 1, GUSP(gus, MIXCNTRLPORT));
111	outb(2, GUSP(gus, MIXDATAPORT));
112	outb(addr | 3, GUSP(gus, MIXCNTRLPORT));
113	outb((unsigned char) val2, GUSP(gus, MIXDATAPORT));
114	return change;
115}
116
117static const struct snd_kcontrol_new snd_gf1_controls[] = {
118GF1_SINGLE("Master Playback Switch", 0, 1, 1),
119GF1_SINGLE("Line Switch", 0, 0, 1),
120GF1_SINGLE("Mic Switch", 0, 2, 0)
121};
122
123static const struct snd_kcontrol_new snd_ics_controls[] = {
124GF1_SINGLE("Master Playback Switch", 0, 1, 1),
125ICS_DOUBLE("Master Playback Volume", 0, SNDRV_ICS_MASTER_DEV),
126ICS_DOUBLE("Synth Playback Volume", 0, SNDRV_ICS_GF1_DEV),
127GF1_SINGLE("Line Switch", 0, 0, 1),
128ICS_DOUBLE("Line Playback Volume", 0, SNDRV_ICS_LINE_DEV),
129GF1_SINGLE("Mic Switch", 0, 2, 0),
130ICS_DOUBLE("Mic Playback Volume", 0, SNDRV_ICS_MIC_DEV),
131ICS_DOUBLE("CD Playback Volume", 0, SNDRV_ICS_CD_DEV)
132};
133
134int snd_gf1_new_mixer(struct snd_gus_card * gus)
135{
136	struct snd_card *card;
137	unsigned int idx, max;
138	int err;
139
140	if (snd_BUG_ON(!gus))
141		return -EINVAL;
142	card = gus->card;
143	if (snd_BUG_ON(!card))
144		return -EINVAL;
145
146	if (gus->ics_flag)
147		snd_component_add(card, "ICS2101");
148	if (card->mixername[0] == '\0') {
149		strscpy(card->mixername, gus->ics_flag ? "GF1,ICS2101" : "GF1");
150	} else {
151		if (gus->ics_flag)
152			strcat(card->mixername, ",ICS2101");
153		strcat(card->mixername, ",GF1");
154	}
155
156	if (!gus->ics_flag) {
157		max = gus->ess_flag ? 1 : ARRAY_SIZE(snd_gf1_controls);
158		for (idx = 0; idx < max; idx++) {
159			err = snd_ctl_add(card, snd_ctl_new1(&snd_gf1_controls[idx], gus));
160			if (err < 0)
161				return err;
162		}
163	} else {
164		for (idx = 0; idx < ARRAY_SIZE(snd_ics_controls); idx++) {
165			err = snd_ctl_add(card, snd_ctl_new1(&snd_ics_controls[idx], gus));
166			if (err < 0)
167				return err;
168		}
169	}
170	return 0;
171}