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,
67 			    "phys in grp[%d]: type 0x%X, count 0x%X\n",
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,
76 			    "phys out grps[%d]: type 0x%X, count 0x%X\n",
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 
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\n",
192 		    consumed, snd_efw_resp_buf_size);
193 }
194 
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);
231 	add_node(efw, root, "queues", proc_read_queues_state);
232 }
233