ALSA: drivers: Constify snd_kcontrol_new items
[muen/linux.git] / sound / drivers / pcsp / pcsp_mixer.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * PC-Speaker driver for Linux
4  *
5  * Mixer implementation.
6  * Copyright (C) 2001-2008  Stas Sergeev
7  */
8
9 #include <sound/core.h>
10 #include <sound/control.h>
11 #include "pcsp.h"
12
13
14 static int pcsp_enable_info(struct snd_kcontrol *kcontrol,
15                             struct snd_ctl_elem_info *uinfo)
16 {
17         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
18         uinfo->count = 1;
19         uinfo->value.integer.min = 0;
20         uinfo->value.integer.max = 1;
21         return 0;
22 }
23
24 static int pcsp_enable_get(struct snd_kcontrol *kcontrol,
25                            struct snd_ctl_elem_value *ucontrol)
26 {
27         struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
28         ucontrol->value.integer.value[0] = chip->enable;
29         return 0;
30 }
31
32 static int pcsp_enable_put(struct snd_kcontrol *kcontrol,
33                            struct snd_ctl_elem_value *ucontrol)
34 {
35         struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
36         int changed = 0;
37         int enab = ucontrol->value.integer.value[0];
38         if (enab != chip->enable) {
39                 chip->enable = enab;
40                 changed = 1;
41         }
42         return changed;
43 }
44
45 static int pcsp_treble_info(struct snd_kcontrol *kcontrol,
46                             struct snd_ctl_elem_info *uinfo)
47 {
48         struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
49         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
50         uinfo->count = 1;
51         uinfo->value.enumerated.items = chip->max_treble + 1;
52         if (uinfo->value.enumerated.item > chip->max_treble)
53                 uinfo->value.enumerated.item = chip->max_treble;
54         sprintf(uinfo->value.enumerated.name, "%lu",
55                 (unsigned long)PCSP_CALC_RATE(uinfo->value.enumerated.item));
56         return 0;
57 }
58
59 static int pcsp_treble_get(struct snd_kcontrol *kcontrol,
60                            struct snd_ctl_elem_value *ucontrol)
61 {
62         struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
63         ucontrol->value.enumerated.item[0] = chip->treble;
64         return 0;
65 }
66
67 static int pcsp_treble_put(struct snd_kcontrol *kcontrol,
68                            struct snd_ctl_elem_value *ucontrol)
69 {
70         struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
71         int changed = 0;
72         int treble = ucontrol->value.enumerated.item[0];
73         if (treble != chip->treble) {
74                 chip->treble = treble;
75 #if PCSP_DEBUG
76                 printk(KERN_INFO "PCSP: rate set to %li\n", PCSP_RATE());
77 #endif
78                 changed = 1;
79         }
80         return changed;
81 }
82
83 static int pcsp_pcspkr_info(struct snd_kcontrol *kcontrol,
84                             struct snd_ctl_elem_info *uinfo)
85 {
86         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
87         uinfo->count = 1;
88         uinfo->value.integer.min = 0;
89         uinfo->value.integer.max = 1;
90         return 0;
91 }
92
93 static int pcsp_pcspkr_get(struct snd_kcontrol *kcontrol,
94                            struct snd_ctl_elem_value *ucontrol)
95 {
96         struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
97         ucontrol->value.integer.value[0] = chip->pcspkr;
98         return 0;
99 }
100
101 static int pcsp_pcspkr_put(struct snd_kcontrol *kcontrol,
102                            struct snd_ctl_elem_value *ucontrol)
103 {
104         struct snd_pcsp *chip = snd_kcontrol_chip(kcontrol);
105         int changed = 0;
106         int spkr = ucontrol->value.integer.value[0];
107         if (spkr != chip->pcspkr) {
108                 chip->pcspkr = spkr;
109                 changed = 1;
110         }
111         return changed;
112 }
113
114 #define PCSP_MIXER_CONTROL(ctl_type, ctl_name) \
115 { \
116         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER, \
117         .name =         ctl_name, \
118         .info =         pcsp_##ctl_type##_info, \
119         .get =          pcsp_##ctl_type##_get, \
120         .put =          pcsp_##ctl_type##_put, \
121 }
122
123 static const struct snd_kcontrol_new snd_pcsp_controls_pcm[] = {
124         PCSP_MIXER_CONTROL(enable, "Master Playback Switch"),
125         PCSP_MIXER_CONTROL(treble, "BaseFRQ Playback Volume"),
126 };
127
128 static const struct snd_kcontrol_new snd_pcsp_controls_spkr[] = {
129         PCSP_MIXER_CONTROL(pcspkr, "Beep Playback Switch"),
130 };
131
132 static int snd_pcsp_ctls_add(struct snd_pcsp *chip,
133                              const struct snd_kcontrol_new *ctls, int num)
134 {
135         int i, err;
136         struct snd_card *card = chip->card;
137         for (i = 0; i < num; i++) {
138                 err = snd_ctl_add(card, snd_ctl_new1(ctls + i, chip));
139                 if (err < 0)
140                         return err;
141         }
142         return 0;
143 }
144
145 int snd_pcsp_new_mixer(struct snd_pcsp *chip, int nopcm)
146 {
147         int err;
148         struct snd_card *card = chip->card;
149
150         if (!nopcm) {
151                 err = snd_pcsp_ctls_add(chip, snd_pcsp_controls_pcm,
152                         ARRAY_SIZE(snd_pcsp_controls_pcm));
153                 if (err < 0)
154                         return err;
155         }
156         err = snd_pcsp_ctls_add(chip, snd_pcsp_controls_spkr,
157                 ARRAY_SIZE(snd_pcsp_controls_spkr));
158         if (err < 0)
159                 return err;
160
161         strcpy(card->mixername, "PC-Speaker");
162
163         return 0;
164 }