This source file includes following definitions.
- get_hardware_info
- efw_card_free
- do_registration
- efw_probe
- efw_update
- efw_remove
- snd_efw_init
- snd_efw_exit
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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;
26 unsigned int snd_efw_resp_buf_size = 1024;
27 bool snd_efw_resp_buf_debug = false;
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");
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");
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
53 #define MODEL_ECHO_AUDIOFIRE_8 0x000af8
54 #define MODEL_ECHO_AUDIOFIRE_2 0x000af2
55 #define MODEL_ECHO_AUDIOFIRE_4 0x000af4
56
57 #define MODEL_ECHO_AUDIOFIRE_9 0x000af9
58
59 #define MODEL_ECHO_FIREWORKS_8 0x0000f8
60 #define MODEL_ECHO_FIREWORKS_HDMI 0x00afd1
61
62 #define VENDOR_GIBSON 0x00075b
63
64 #define MODEL_GIBSON_RIP 0x00afb2
65
66 #define MODEL_GIBSON_GOLDTOP 0x00afb9
67
68
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
88 snprintf(version, sizeof(version), "%u.%u",
89 (hwinfo->arm_version >> 24) & 0xff,
90 (hwinfo->arm_version >> 16) & 0xff);
91 efw->firmware_version = hwinfo->arm_version;
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);
101
102 if (hwinfo->flags & BIT(FLAG_RESP_ADDR_CHANGABLE))
103 efw->resp_addr_changable = true;
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
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
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) {
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;
155
156
157 if (hwinfo->phys_in_grp_count > HWINFO_MAX_CAPS_GROUPS ||
158 hwinfo->phys_out_grp_count > HWINFO_MAX_CAPS_GROUPS) {
159 err = -EIO;
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);
170
171
172 if (hwinfo->type == MODEL_ECHO_AUDIOFIRE_9)
173 efw->is_af9 = true;
174
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;
181 end:
182 kfree(hwinfo);
183 return err;
184 }
185
186 static void
187 efw_card_free(struct snd_card *card)
188 {
189 struct snd_efw *efw = card->private_data;
190
191 mutex_lock(&devices_mutex);
192 clear_bit(efw->card_index, devices_used);
193 mutex_unlock(&devices_mutex);
194
195 snd_efw_stream_destroy_duplex(efw);
196 snd_efw_transaction_remove_instance(efw);
197 }
198
199 static void
200 do_registration(struct work_struct *work)
201 {
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;
208
209
210 mutex_lock(&devices_mutex);
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) {
216 mutex_unlock(&devices_mutex);
217 return;
218 }
219
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 }
226 set_bit(card_index, devices_used);
227 mutex_unlock(&devices_mutex);
228
229 efw->card->private_free = efw_card_free;
230 efw->card->private_data = efw;
231
232
233 snd_efw_resp_buf_size = clamp(snd_efw_resp_buf_size,
234 SND_EFW_RESPONSE_MAXIMUM_BYTES, 4096U);
235 efw->resp_buf = devm_kzalloc(&efw->card->card_dev,
236 snd_efw_resp_buf_size, GFP_KERNEL);
237 if (!efw->resp_buf) {
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
244 err = get_hardware_info(efw);
245 if (err < 0)
246 goto error;
247
248 err = snd_efw_stream_init_duplex(efw);
249 if (err < 0)
250 goto error;
251
252 snd_efw_proc_init(efw);
253
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
260 err = snd_efw_create_pcm_devices(efw);
261 if (err < 0)
262 goto error;
263
264 err = snd_efw_create_hwdep_device(efw);
265 if (err < 0)
266 goto error;
267
268 err = snd_card_register(efw->card);
269 if (err < 0)
270 goto error;
271
272 efw->registered = true;
273
274 return;
275 error:
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
286 efw = devm_kzalloc(&unit->device, sizeof(struct snd_efw), GFP_KERNEL);
287 if (efw == NULL)
288 return -ENOMEM;
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
297 INIT_DEFERRABLE_WORK(&efw->dwork, do_registration);
298 snd_fw_schedule_registration(unit, &efw->dwork);
299
300 return 0;
301 }
302
303 static void efw_update(struct fw_unit *unit)
304 {
305 struct snd_efw *efw = dev_get_drvdata(&unit->device);
306
307
308 if (!efw->registered)
309 snd_fw_schedule_registration(unit, &efw->dwork);
310
311 snd_efw_transaction_bus_reset(efw->unit);
312
313
314
315
316
317 if (efw->registered) {
318 mutex_lock(&efw->mutex);
319 snd_efw_stream_update_duplex(efw);
320 mutex_unlock(&efw->mutex);
321 }
322 }
323
324 static void efw_remove(struct fw_unit *unit)
325 {
326 struct snd_efw *efw = dev_get_drvdata(&unit->device);
327
328
329
330
331
332
333 cancel_delayed_work_sync(&efw->dwork);
334
335 if (efw->registered) {
336
337 snd_card_free(efw->card);
338 }
339
340 mutex_destroy(&efw->mutex);
341 fw_unit_put(efw->unit);
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 {
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;
388 }
389
390 static void __exit snd_efw_exit(void)
391 {
392 snd_efw_transaction_unregister();
393 driver_unregister(&efw_driver.driver);
394 }
395
396 module_init(snd_efw_init);
397 module_exit(snd_efw_exit);