]>
Commit | Line | Data |
---|---|---|
da607e19 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
b5b04336 TS |
2 | /* |
3 | * fireworks.c - a part of driver for Fireworks based devices | |
4 | * | |
5 | * Copyright (c) 2009-2010 Clemens Ladisch | |
6 | * Copyright (c) 2013-2014 Takashi Sakamoto | |
b5b04336 TS |
7 | */ |
8 | ||
9 | /* | |
10 | * Fireworks is a board module which Echo Audio produced. This module consists | |
11 | * of three chipsets: | |
12 | * - Communication chipset for IEEE1394 PHY/Link and IEC 61883-1/6 | |
13 | * - DSP or/and FPGA for signal processing | |
14 | * - Flash Memory to store firmwares | |
15 | */ | |
16 | ||
17 | #include "fireworks.h" | |
18 | ||
19 | MODULE_DESCRIPTION("Echo Fireworks driver"); | |
20 | MODULE_AUTHOR("Takashi Sakamoto <o-takashi@sakamocchi.jp>"); | |
21 | MODULE_LICENSE("GPL v2"); | |
22 | ||
23 | static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; | |
24 | static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; | |
25 | static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; | |
555e8a8f TS |
26 | unsigned int snd_efw_resp_buf_size = 1024; |
27 | bool snd_efw_resp_buf_debug = false; | |
b5b04336 TS |
28 | |
29 | module_param_array(index, int, NULL, 0444); | |
30 | MODULE_PARM_DESC(index, "card index"); | |
31 | module_param_array(id, charp, NULL, 0444); | |
32 | MODULE_PARM_DESC(id, "ID string"); | |
33 | module_param_array(enable, bool, NULL, 0444); | |
34 | MODULE_PARM_DESC(enable, "enable Fireworks sound card"); | |
555e8a8f TS |
35 | module_param_named(resp_buf_size, snd_efw_resp_buf_size, uint, 0444); |
36 | MODULE_PARM_DESC(resp_buf_size, | |
37 | "response buffer size (max 4096, default 1024)"); | |
38 | module_param_named(resp_buf_debug, snd_efw_resp_buf_debug, bool, 0444); | |
39 | MODULE_PARM_DESC(resp_buf_debug, "store all responses to buffer"); | |
b5b04336 TS |
40 | |
41 | static DEFINE_MUTEX(devices_mutex); | |
42 | static DECLARE_BITMAP(devices_used, SNDRV_CARDS); | |
43 | ||
44 | #define VENDOR_LOUD 0x000ff2 | |
45 | #define MODEL_MACKIE_400F 0x00400f | |
46 | #define MODEL_MACKIE_1200F 0x01200f | |
47 | ||
48 | #define VENDOR_ECHO 0x001486 | |
49 | #define MODEL_ECHO_AUDIOFIRE_12 0x00af12 | |
50 | #define MODEL_ECHO_AUDIOFIRE_12HD 0x0af12d | |
51 | #define MODEL_ECHO_AUDIOFIRE_12_APPLE 0x0af12a | |
52 | /* This is applied for AudioFire8 (until 2009 July) */ | |
53 | #define MODEL_ECHO_AUDIOFIRE_8 0x000af8 | |
54 | #define MODEL_ECHO_AUDIOFIRE_2 0x000af2 | |
55 | #define MODEL_ECHO_AUDIOFIRE_4 0x000af4 | |
56 | /* AudioFire9 is applied for AudioFire8(since 2009 July) and AudioFirePre8 */ | |
57 | #define MODEL_ECHO_AUDIOFIRE_9 0x000af9 | |
58 | /* unknown as product */ | |
59 | #define MODEL_ECHO_FIREWORKS_8 0x0000f8 | |
60 | #define MODEL_ECHO_FIREWORKS_HDMI 0x00afd1 | |
61 | ||
62 | #define VENDOR_GIBSON 0x00075b | |
63 | /* for Robot Interface Pack of Dark Fire, Dusk Tiger, Les Paul Standard 2010 */ | |
64 | #define MODEL_GIBSON_RIP 0x00afb2 | |
65 | /* unknown as product */ | |
66 | #define MODEL_GIBSON_GOLDTOP 0x00afb9 | |
67 | ||
bde8a8f2 TS |
68 | /* part of hardware capability flags */ |
69 | #define FLAG_RESP_ADDR_CHANGABLE 0 | |
70 | ||
71 | static int | |
72 | get_hardware_info(struct snd_efw *efw) | |
73 | { | |
74 | struct fw_device *fw_dev = fw_parent_device(efw->unit); | |
75 | struct snd_efw_hwinfo *hwinfo; | |
76 | char version[12] = {0}; | |
77 | int err; | |
78 | ||
79 | hwinfo = kzalloc(sizeof(struct snd_efw_hwinfo), GFP_KERNEL); | |
80 | if (hwinfo == NULL) | |
81 | return -ENOMEM; | |
82 | ||
83 | err = snd_efw_command_get_hwinfo(efw, hwinfo); | |
84 | if (err < 0) | |
85 | goto end; | |
86 | ||
87 | /* firmware version for communication chipset */ | |
88 | snprintf(version, sizeof(version), "%u.%u", | |
89 | (hwinfo->arm_version >> 24) & 0xff, | |
90 | (hwinfo->arm_version >> 16) & 0xff); | |
d9cd0065 | 91 | efw->firmware_version = hwinfo->arm_version; |
bde8a8f2 TS |
92 | |
93 | strcpy(efw->card->driver, "Fireworks"); | |
94 | strcpy(efw->card->shortname, hwinfo->model_name); | |
95 | strcpy(efw->card->mixername, hwinfo->model_name); | |
96 | snprintf(efw->card->longname, sizeof(efw->card->longname), | |
97 | "%s %s v%s, GUID %08x%08x at %s, S%d", | |
98 | hwinfo->vendor_name, hwinfo->model_name, version, | |
99 | hwinfo->guid_hi, hwinfo->guid_lo, | |
100 | dev_name(&efw->unit->device), 100 << fw_dev->max_speed); | |
bde8a8f2 TS |
101 | |
102 | if (hwinfo->flags & BIT(FLAG_RESP_ADDR_CHANGABLE)) | |
103 | efw->resp_addr_changable = true; | |
315fd41f TS |
104 | |
105 | efw->supported_sampling_rate = 0; | |
106 | if ((hwinfo->min_sample_rate <= 22050) | |
107 | && (22050 <= hwinfo->max_sample_rate)) | |
108 | efw->supported_sampling_rate |= SNDRV_PCM_RATE_22050; | |
109 | if ((hwinfo->min_sample_rate <= 32000) | |
110 | && (32000 <= hwinfo->max_sample_rate)) | |
111 | efw->supported_sampling_rate |= SNDRV_PCM_RATE_32000; | |
112 | if ((hwinfo->min_sample_rate <= 44100) | |
113 | && (44100 <= hwinfo->max_sample_rate)) | |
114 | efw->supported_sampling_rate |= SNDRV_PCM_RATE_44100; | |
115 | if ((hwinfo->min_sample_rate <= 48000) | |
116 | && (48000 <= hwinfo->max_sample_rate)) | |
117 | efw->supported_sampling_rate |= SNDRV_PCM_RATE_48000; | |
118 | if ((hwinfo->min_sample_rate <= 88200) | |
119 | && (88200 <= hwinfo->max_sample_rate)) | |
120 | efw->supported_sampling_rate |= SNDRV_PCM_RATE_88200; | |
121 | if ((hwinfo->min_sample_rate <= 96000) | |
122 | && (96000 <= hwinfo->max_sample_rate)) | |
123 | efw->supported_sampling_rate |= SNDRV_PCM_RATE_96000; | |
124 | if ((hwinfo->min_sample_rate <= 176400) | |
125 | && (176400 <= hwinfo->max_sample_rate)) | |
126 | efw->supported_sampling_rate |= SNDRV_PCM_RATE_176400; | |
127 | if ((hwinfo->min_sample_rate <= 192000) | |
128 | && (192000 <= hwinfo->max_sample_rate)) | |
129 | efw->supported_sampling_rate |= SNDRV_PCM_RATE_192000; | |
130 | ||
131 | /* the number of MIDI ports, not of MIDI conformant data channels */ | |
132 | if (hwinfo->midi_out_ports > SND_EFW_MAX_MIDI_OUT_PORTS || | |
133 | hwinfo->midi_in_ports > SND_EFW_MAX_MIDI_IN_PORTS) { | |
134 | err = -EIO; | |
135 | goto end; | |
136 | } | |
137 | efw->midi_out_ports = hwinfo->midi_out_ports; | |
138 | efw->midi_in_ports = hwinfo->midi_in_ports; | |
139 | ||
49c7b3fc TS |
140 | if (hwinfo->amdtp_tx_pcm_channels > AM824_MAX_CHANNELS_FOR_PCM || |
141 | hwinfo->amdtp_tx_pcm_channels_2x > AM824_MAX_CHANNELS_FOR_PCM || | |
142 | hwinfo->amdtp_tx_pcm_channels_4x > AM824_MAX_CHANNELS_FOR_PCM || | |
143 | hwinfo->amdtp_rx_pcm_channels > AM824_MAX_CHANNELS_FOR_PCM || | |
144 | hwinfo->amdtp_rx_pcm_channels_2x > AM824_MAX_CHANNELS_FOR_PCM || | |
145 | hwinfo->amdtp_rx_pcm_channels_4x > AM824_MAX_CHANNELS_FOR_PCM) { | |
315fd41f TS |
146 | err = -ENOSYS; |
147 | goto end; | |
148 | } | |
149 | efw->pcm_capture_channels[0] = hwinfo->amdtp_tx_pcm_channels; | |
150 | efw->pcm_capture_channels[1] = hwinfo->amdtp_tx_pcm_channels_2x; | |
151 | efw->pcm_capture_channels[2] = hwinfo->amdtp_tx_pcm_channels_4x; | |
152 | efw->pcm_playback_channels[0] = hwinfo->amdtp_rx_pcm_channels; | |
153 | efw->pcm_playback_channels[1] = hwinfo->amdtp_rx_pcm_channels_2x; | |
154 | efw->pcm_playback_channels[2] = hwinfo->amdtp_rx_pcm_channels_4x; | |
6a22683e TS |
155 | |
156 | /* Hardware metering. */ | |
157 | if (hwinfo->phys_in_grp_count > HWINFO_MAX_CAPS_GROUPS || | |
158 | hwinfo->phys_out_grp_count > HWINFO_MAX_CAPS_GROUPS) { | |
39617837 | 159 | err = -EIO; |
6a22683e TS |
160 | goto end; |
161 | } | |
162 | efw->phys_in = hwinfo->phys_in; | |
163 | efw->phys_out = hwinfo->phys_out; | |
164 | efw->phys_in_grp_count = hwinfo->phys_in_grp_count; | |
165 | efw->phys_out_grp_count = hwinfo->phys_out_grp_count; | |
166 | memcpy(&efw->phys_in_grps, hwinfo->phys_in_grps, | |
167 | sizeof(struct snd_efw_phys_grp) * hwinfo->phys_in_grp_count); | |
168 | memcpy(&efw->phys_out_grps, hwinfo->phys_out_grps, | |
169 | sizeof(struct snd_efw_phys_grp) * hwinfo->phys_out_grp_count); | |
0655ac2f TS |
170 | |
171 | /* AudioFire8 (since 2009) and AudioFirePre8 */ | |
172 | if (hwinfo->type == MODEL_ECHO_AUDIOFIRE_9) | |
173 | efw->is_af9 = true; | |
174 | /* These models uses the same firmware. */ | |
175 | if (hwinfo->type == MODEL_ECHO_AUDIOFIRE_2 || | |
176 | hwinfo->type == MODEL_ECHO_AUDIOFIRE_4 || | |
177 | hwinfo->type == MODEL_ECHO_AUDIOFIRE_9 || | |
178 | hwinfo->type == MODEL_GIBSON_RIP || | |
179 | hwinfo->type == MODEL_GIBSON_GOLDTOP) | |
180 | efw->is_fireworks3 = true; | |
bde8a8f2 TS |
181 | end: |
182 | kfree(hwinfo); | |
183 | return err; | |
184 | } | |
185 | ||
3babca45 TS |
186 | static void |
187 | efw_card_free(struct snd_card *card) | |
7d3c1d59 | 188 | { |
3babca45 TS |
189 | struct snd_efw *efw = card->private_data; |
190 | ||
873608dc TS |
191 | mutex_lock(&devices_mutex); |
192 | clear_bit(efw->card_index, devices_used); | |
193 | mutex_unlock(&devices_mutex); | |
194 | ||
7d3c1d59 TS |
195 | snd_efw_stream_destroy_duplex(efw); |
196 | snd_efw_transaction_remove_instance(efw); | |
7d3c1d59 TS |
197 | } |
198 | ||
7d3c1d59 TS |
199 | static void |
200 | do_registration(struct work_struct *work) | |
b5b04336 | 201 | { |
7d3c1d59 TS |
202 | struct snd_efw *efw = container_of(work, struct snd_efw, dwork.work); |
203 | unsigned int card_index; | |
204 | int err; | |
205 | ||
206 | if (efw->registered) | |
207 | return; | |
b5b04336 | 208 | |
b5b04336 | 209 | /* check registered cards */ |
873608dc | 210 | mutex_lock(&devices_mutex); |
b5b04336 TS |
211 | for (card_index = 0; card_index < SNDRV_CARDS; ++card_index) { |
212 | if (!test_bit(card_index, devices_used) && enable[card_index]) | |
213 | break; | |
214 | } | |
215 | if (card_index >= SNDRV_CARDS) { | |
7d3c1d59 TS |
216 | mutex_unlock(&devices_mutex); |
217 | return; | |
b5b04336 TS |
218 | } |
219 | ||
7d3c1d59 TS |
220 | err = snd_card_new(&efw->unit->device, index[card_index], |
221 | id[card_index], THIS_MODULE, 0, &efw->card); | |
222 | if (err < 0) { | |
223 | mutex_unlock(&devices_mutex); | |
224 | return; | |
225 | } | |
873608dc TS |
226 | set_bit(card_index, devices_used); |
227 | mutex_unlock(&devices_mutex); | |
b5b04336 | 228 | |
3babca45 TS |
229 | efw->card->private_free = efw_card_free; |
230 | efw->card->private_data = efw; | |
231 | ||
555e8a8f TS |
232 | /* prepare response buffer */ |
233 | snd_efw_resp_buf_size = clamp(snd_efw_resp_buf_size, | |
234 | SND_EFW_RESPONSE_MAXIMUM_BYTES, 4096U); | |
784fffbc TS |
235 | efw->resp_buf = devm_kzalloc(&efw->card->card_dev, |
236 | snd_efw_resp_buf_size, GFP_KERNEL); | |
237 | if (!efw->resp_buf) { | |
555e8a8f TS |
238 | err = -ENOMEM; |
239 | goto error; | |
240 | } | |
241 | efw->pull_ptr = efw->push_ptr = efw->resp_buf; | |
242 | snd_efw_transaction_add_instance(efw); | |
243 | ||
bde8a8f2 TS |
244 | err = get_hardware_info(efw); |
245 | if (err < 0) | |
246 | goto error; | |
b5b04336 | 247 | |
7d3c1d59 TS |
248 | err = snd_efw_stream_init_duplex(efw); |
249 | if (err < 0) | |
250 | goto error; | |
251 | ||
6a22683e TS |
252 | snd_efw_proc_init(efw); |
253 | ||
a63d3ff1 TS |
254 | if (efw->midi_out_ports || efw->midi_in_ports) { |
255 | err = snd_efw_create_midi_devices(efw); | |
256 | if (err < 0) | |
257 | goto error; | |
258 | } | |
259 | ||
aa02bb6e TS |
260 | err = snd_efw_create_pcm_devices(efw); |
261 | if (err < 0) | |
262 | goto error; | |
263 | ||
594ddced TS |
264 | err = snd_efw_create_hwdep_device(efw); |
265 | if (err < 0) | |
266 | goto error; | |
267 | ||
7d3c1d59 | 268 | err = snd_card_register(efw->card); |
b5b04336 TS |
269 | if (err < 0) |
270 | goto error; | |
bde8a8f2 | 271 | |
7d3c1d59 TS |
272 | efw->registered = true; |
273 | ||
274 | return; | |
b5b04336 | 275 | error: |
7d3c1d59 TS |
276 | snd_card_free(efw->card); |
277 | dev_info(&efw->unit->device, | |
278 | "Sound card registration failed: %d\n", err); | |
279 | } | |
280 | ||
281 | static int | |
282 | efw_probe(struct fw_unit *unit, const struct ieee1394_device_id *entry) | |
283 | { | |
284 | struct snd_efw *efw; | |
285 | ||
366a20d7 | 286 | efw = devm_kzalloc(&unit->device, sizeof(struct snd_efw), GFP_KERNEL); |
7d3c1d59 TS |
287 | if (efw == NULL) |
288 | return -ENOMEM; | |
7d3c1d59 TS |
289 | efw->unit = fw_unit_get(unit); |
290 | dev_set_drvdata(&unit->device, efw); | |
291 | ||
292 | mutex_init(&efw->mutex); | |
293 | spin_lock_init(&efw->lock); | |
294 | init_waitqueue_head(&efw->hwdep_wait); | |
295 | ||
296 | /* Allocate and register this sound card later. */ | |
297 | INIT_DEFERRABLE_WORK(&efw->dwork, do_registration); | |
298 | snd_fw_schedule_registration(unit, &efw->dwork); | |
299 | ||
300 | return 0; | |
b5b04336 TS |
301 | } |
302 | ||
303 | static void efw_update(struct fw_unit *unit) | |
304 | { | |
bde8a8f2 | 305 | struct snd_efw *efw = dev_get_drvdata(&unit->device); |
315fd41f | 306 | |
7d3c1d59 TS |
307 | /* Postpone a workqueue for deferred registration. */ |
308 | if (!efw->registered) | |
309 | snd_fw_schedule_registration(unit, &efw->dwork); | |
310 | ||
bde8a8f2 | 311 | snd_efw_transaction_bus_reset(efw->unit); |
99d73559 | 312 | |
7d3c1d59 TS |
313 | /* |
314 | * After registration, userspace can start packet streaming, then this | |
315 | * code block works fine. | |
316 | */ | |
317 | if (efw->registered) { | |
318 | mutex_lock(&efw->mutex); | |
319 | snd_efw_stream_update_duplex(efw); | |
320 | mutex_unlock(&efw->mutex); | |
321 | } | |
b5b04336 TS |
322 | } |
323 | ||
324 | static void efw_remove(struct fw_unit *unit) | |
325 | { | |
326 | struct snd_efw *efw = dev_get_drvdata(&unit->device); | |
315fd41f | 327 | |
7d3c1d59 TS |
328 | /* |
329 | * Confirm to stop the work for registration before the sound card is | |
330 | * going to be released. The work is not scheduled again because bus | |
331 | * reset handler is not called anymore. | |
332 | */ | |
333 | cancel_delayed_work_sync(&efw->dwork); | |
334 | ||
335 | if (efw->registered) { | |
61ccc6f6 TS |
336 | // Block till all of ALSA character devices are released. |
337 | snd_card_free(efw->card); | |
7d3c1d59 | 338 | } |
5b14ec25 TS |
339 | |
340 | mutex_destroy(&efw->mutex); | |
341 | fw_unit_put(efw->unit); | |
b5b04336 TS |
342 | } |
343 | ||
344 | static const struct ieee1394_device_id efw_id_table[] = { | |
345 | SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_400F), | |
346 | SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_1200F), | |
347 | SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_8), | |
348 | SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12), | |
349 | SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12HD), | |
350 | SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12_APPLE), | |
351 | SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_2), | |
352 | SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_4), | |
353 | SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_9), | |
354 | SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_8), | |
355 | SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_HDMI), | |
356 | SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_RIP), | |
357 | SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_GOLDTOP), | |
358 | {} | |
359 | }; | |
360 | MODULE_DEVICE_TABLE(ieee1394, efw_id_table); | |
361 | ||
362 | static struct fw_driver efw_driver = { | |
363 | .driver = { | |
364 | .owner = THIS_MODULE, | |
365 | .name = "snd-fireworks", | |
366 | .bus = &fw_bus_type, | |
367 | }, | |
368 | .probe = efw_probe, | |
369 | .update = efw_update, | |
370 | .remove = efw_remove, | |
371 | .id_table = efw_id_table, | |
372 | }; | |
373 | ||
374 | static int __init snd_efw_init(void) | |
375 | { | |
bde8a8f2 TS |
376 | int err; |
377 | ||
378 | err = snd_efw_transaction_register(); | |
379 | if (err < 0) | |
380 | goto end; | |
381 | ||
382 | err = driver_register(&efw_driver.driver); | |
383 | if (err < 0) | |
384 | snd_efw_transaction_unregister(); | |
385 | ||
386 | end: | |
387 | return err; | |
b5b04336 TS |
388 | } |
389 | ||
390 | static void __exit snd_efw_exit(void) | |
391 | { | |
bde8a8f2 | 392 | snd_efw_transaction_unregister(); |
b5b04336 | 393 | driver_unregister(&efw_driver.driver); |
b5b04336 TS |
394 | } |
395 | ||
396 | module_init(snd_efw_init); | |
397 | module_exit(snd_efw_exit); |