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