Commit | Line | Data |
---|---|---|
6a22683e TS |
1 | /* |
2 | * fireworks_proc.c - a part of driver for Fireworks based devices | |
3 | * | |
4 | * Copyright (c) 2009-2010 Clemens Ladisch | |
5 | * Copyright (c) 2013-2014 Takashi Sakamoto | |
6 | * | |
7 | * Licensed under the terms of the GNU General Public License, version 2. | |
8 | */ | |
9 | ||
10 | #include "./fireworks.h" | |
11 | ||
12 | static inline const char* | |
13 | get_phys_name(struct snd_efw_phys_grp *grp, bool input) | |
14 | { | |
15 | const char *const ch_type[] = { | |
16 | "Analog", "S/PDIF", "ADAT", "S/PDIF or ADAT", "Mirroring", | |
17 | "Headphones", "I2S", "Guitar", "Pirzo Guitar", "Guitar String", | |
18 | }; | |
19 | ||
20 | if (grp->type < ARRAY_SIZE(ch_type)) | |
21 | return ch_type[grp->type]; | |
22 | else if (input) | |
23 | return "Input"; | |
24 | else | |
25 | return "Output"; | |
26 | } | |
27 | ||
28 | static void | |
29 | proc_read_hwinfo(struct snd_info_entry *entry, struct snd_info_buffer *buffer) | |
30 | { | |
31 | struct snd_efw *efw = entry->private_data; | |
32 | unsigned short i; | |
33 | struct snd_efw_hwinfo *hwinfo; | |
34 | ||
35 | hwinfo = kmalloc(sizeof(struct snd_efw_hwinfo), GFP_KERNEL); | |
36 | if (hwinfo == NULL) | |
37 | return; | |
38 | ||
39 | if (snd_efw_command_get_hwinfo(efw, hwinfo) < 0) | |
40 | goto end; | |
41 | ||
42 | snd_iprintf(buffer, "guid_hi: 0x%X\n", hwinfo->guid_hi); | |
43 | snd_iprintf(buffer, "guid_lo: 0x%X\n", hwinfo->guid_lo); | |
44 | snd_iprintf(buffer, "type: 0x%X\n", hwinfo->type); | |
45 | snd_iprintf(buffer, "version: 0x%X\n", hwinfo->version); | |
46 | snd_iprintf(buffer, "vendor_name: %s\n", hwinfo->vendor_name); | |
47 | snd_iprintf(buffer, "model_name: %s\n", hwinfo->model_name); | |
48 | ||
49 | snd_iprintf(buffer, "dsp_version: 0x%X\n", hwinfo->dsp_version); | |
50 | snd_iprintf(buffer, "arm_version: 0x%X\n", hwinfo->arm_version); | |
51 | snd_iprintf(buffer, "fpga_version: 0x%X\n", hwinfo->fpga_version); | |
52 | ||
53 | snd_iprintf(buffer, "flags: 0x%X\n", hwinfo->flags); | |
54 | ||
55 | snd_iprintf(buffer, "max_sample_rate: 0x%X\n", hwinfo->max_sample_rate); | |
56 | snd_iprintf(buffer, "min_sample_rate: 0x%X\n", hwinfo->min_sample_rate); | |
57 | snd_iprintf(buffer, "supported_clock: 0x%X\n", | |
58 | hwinfo->supported_clocks); | |
59 | ||
60 | snd_iprintf(buffer, "phys out: 0x%X\n", hwinfo->phys_out); | |
61 | snd_iprintf(buffer, "phys in: 0x%X\n", hwinfo->phys_in); | |
62 | ||
63 | snd_iprintf(buffer, "phys in grps: 0x%X\n", | |
64 | hwinfo->phys_in_grp_count); | |
65 | for (i = 0; i < hwinfo->phys_in_grp_count; i++) { | |
66 | snd_iprintf(buffer, | |
30225ed5 | 67 | "phys in grp[%d]: type 0x%X, count 0x%X\n", |
6a22683e TS |
68 | i, hwinfo->phys_out_grps[i].type, |
69 | hwinfo->phys_out_grps[i].count); | |
70 | } | |
71 | ||
72 | snd_iprintf(buffer, "phys out grps: 0x%X\n", | |
73 | hwinfo->phys_out_grp_count); | |
74 | for (i = 0; i < hwinfo->phys_out_grp_count; i++) { | |
75 | snd_iprintf(buffer, | |
30225ed5 | 76 | "phys out grps[%d]: type 0x%X, count 0x%X\n", |
6a22683e TS |
77 | i, hwinfo->phys_out_grps[i].type, |
78 | hwinfo->phys_out_grps[i].count); | |
79 | } | |
80 | ||
81 | snd_iprintf(buffer, "amdtp rx pcm channels 1x: 0x%X\n", | |
82 | hwinfo->amdtp_rx_pcm_channels); | |
83 | snd_iprintf(buffer, "amdtp tx pcm channels 1x: 0x%X\n", | |
84 | hwinfo->amdtp_tx_pcm_channels); | |
85 | snd_iprintf(buffer, "amdtp rx pcm channels 2x: 0x%X\n", | |
86 | hwinfo->amdtp_rx_pcm_channels_2x); | |
87 | snd_iprintf(buffer, "amdtp tx pcm channels 2x: 0x%X\n", | |
88 | hwinfo->amdtp_tx_pcm_channels_2x); | |
89 | snd_iprintf(buffer, "amdtp rx pcm channels 4x: 0x%X\n", | |
90 | hwinfo->amdtp_rx_pcm_channels_4x); | |
91 | snd_iprintf(buffer, "amdtp tx pcm channels 4x: 0x%X\n", | |
92 | hwinfo->amdtp_tx_pcm_channels_4x); | |
93 | ||
94 | snd_iprintf(buffer, "midi out ports: 0x%X\n", hwinfo->midi_out_ports); | |
95 | snd_iprintf(buffer, "midi in ports: 0x%X\n", hwinfo->midi_in_ports); | |
96 | ||
97 | snd_iprintf(buffer, "mixer playback channels: 0x%X\n", | |
98 | hwinfo->mixer_playback_channels); | |
99 | snd_iprintf(buffer, "mixer capture channels: 0x%X\n", | |
100 | hwinfo->mixer_capture_channels); | |
101 | end: | |
102 | kfree(hwinfo); | |
103 | } | |
104 | ||
105 | static void | |
106 | proc_read_clock(struct snd_info_entry *entry, struct snd_info_buffer *buffer) | |
107 | { | |
108 | struct snd_efw *efw = entry->private_data; | |
109 | enum snd_efw_clock_source clock_source; | |
110 | unsigned int sampling_rate; | |
111 | ||
112 | if (snd_efw_command_get_clock_source(efw, &clock_source) < 0) | |
113 | return; | |
114 | ||
115 | if (snd_efw_command_get_sampling_rate(efw, &sampling_rate) < 0) | |
116 | return; | |
117 | ||
118 | snd_iprintf(buffer, "Clock Source: %d\n", clock_source); | |
119 | snd_iprintf(buffer, "Sampling Rate: %d\n", sampling_rate); | |
120 | } | |
121 | ||
122 | /* | |
123 | * NOTE: | |
124 | * dB = 20 * log10(linear / 0x01000000) | |
125 | * -144.0 dB when linear is 0 | |
126 | */ | |
127 | static void | |
128 | proc_read_phys_meters(struct snd_info_entry *entry, | |
129 | struct snd_info_buffer *buffer) | |
130 | { | |
131 | struct snd_efw *efw = entry->private_data; | |
132 | struct snd_efw_phys_meters *meters; | |
133 | unsigned int g, c, m, max, size; | |
134 | const char *name; | |
135 | u32 *linear; | |
136 | int err; | |
137 | ||
138 | size = sizeof(struct snd_efw_phys_meters) + | |
139 | (efw->phys_in + efw->phys_out) * sizeof(u32); | |
140 | meters = kzalloc(size, GFP_KERNEL); | |
141 | if (meters == NULL) | |
142 | return; | |
143 | ||
144 | err = snd_efw_command_get_phys_meters(efw, meters, size); | |
145 | if (err < 0) | |
146 | goto end; | |
147 | ||
148 | snd_iprintf(buffer, "Physical Meters:\n"); | |
149 | ||
150 | m = 0; | |
151 | max = min(efw->phys_out, meters->out_meters); | |
152 | linear = meters->values; | |
153 | snd_iprintf(buffer, " %d Outputs:\n", max); | |
154 | for (g = 0; g < efw->phys_out_grp_count; g++) { | |
155 | name = get_phys_name(&efw->phys_out_grps[g], false); | |
156 | for (c = 0; c < efw->phys_out_grps[g].count; c++) { | |
157 | if (m < max) | |
158 | snd_iprintf(buffer, "\t%s [%d]: %d\n", | |
159 | name, c, linear[m++]); | |
160 | } | |
161 | } | |
162 | ||
163 | m = 0; | |
164 | max = min(efw->phys_in, meters->in_meters); | |
165 | linear = meters->values + meters->out_meters; | |
166 | snd_iprintf(buffer, " %d Inputs:\n", max); | |
167 | for (g = 0; g < efw->phys_in_grp_count; g++) { | |
168 | name = get_phys_name(&efw->phys_in_grps[g], true); | |
169 | for (c = 0; c < efw->phys_in_grps[g].count; c++) | |
170 | if (m < max) | |
171 | snd_iprintf(buffer, "\t%s [%d]: %d\n", | |
172 | name, c, linear[m++]); | |
173 | } | |
174 | end: | |
175 | kfree(meters); | |
176 | } | |
177 | ||
555e8a8f TS |
178 | static void |
179 | proc_read_queues_state(struct snd_info_entry *entry, | |
180 | struct snd_info_buffer *buffer) | |
181 | { | |
182 | struct snd_efw *efw = entry->private_data; | |
183 | unsigned int consumed; | |
184 | ||
185 | if (efw->pull_ptr > efw->push_ptr) | |
186 | consumed = snd_efw_resp_buf_size - | |
187 | (unsigned int)(efw->pull_ptr - efw->push_ptr); | |
188 | else | |
189 | consumed = (unsigned int)(efw->push_ptr - efw->pull_ptr); | |
190 | ||
191 | snd_iprintf(buffer, "%d %d/%d\n", | |
192 | efw->resp_queues, consumed, snd_efw_resp_buf_size); | |
193 | } | |
194 | ||
6a22683e TS |
195 | static void |
196 | add_node(struct snd_efw *efw, struct snd_info_entry *root, const char *name, | |
197 | void (*op)(struct snd_info_entry *e, struct snd_info_buffer *b)) | |
198 | { | |
199 | struct snd_info_entry *entry; | |
200 | ||
201 | entry = snd_info_create_card_entry(efw->card, name, root); | |
202 | if (entry == NULL) | |
203 | return; | |
204 | ||
205 | snd_info_set_text_ops(entry, efw, op); | |
206 | if (snd_info_register(entry) < 0) | |
207 | snd_info_free_entry(entry); | |
208 | } | |
209 | ||
210 | void snd_efw_proc_init(struct snd_efw *efw) | |
211 | { | |
212 | struct snd_info_entry *root; | |
213 | ||
214 | /* | |
215 | * All nodes are automatically removed at snd_card_disconnect(), | |
216 | * by following to link list. | |
217 | */ | |
218 | root = snd_info_create_card_entry(efw->card, "firewire", | |
219 | efw->card->proc_root); | |
220 | if (root == NULL) | |
221 | return; | |
222 | root->mode = S_IFDIR | S_IRUGO | S_IXUGO; | |
223 | if (snd_info_register(root) < 0) { | |
224 | snd_info_free_entry(root); | |
225 | return; | |
226 | } | |
227 | ||
228 | add_node(efw, root, "clock", proc_read_clock); | |
229 | add_node(efw, root, "firmware", proc_read_hwinfo); | |
230 | add_node(efw, root, "meters", proc_read_phys_meters); | |
555e8a8f | 231 | add_node(efw, root, "queues", proc_read_queues_state); |
6a22683e | 232 | } |