1
2
3
4
5
6
7
8#include <linux/device.h>
9#include <linux/firewire.h>
10#include <linux/firewire-constants.h>
11#include <linux/module.h>
12#include <linux/mod_devicetable.h>
13#include <linux/mutex.h>
14#include <linux/slab.h>
15#include <sound/control.h>
16#include <sound/core.h>
17#include <sound/initval.h>
18#include <sound/pcm.h>
19#include <sound/pcm_params.h>
20#include "cmp.h"
21#include "fcp.h"
22#include "amdtp.h"
23#include "lib.h"
24
25#define OXFORD_FIRMWARE_ID_ADDRESS (CSR_REGISTER_BASE + 0x50000)
26
27
28#define OXFORD_HARDWARE_ID_ADDRESS (CSR_REGISTER_BASE + 0x90020)
29#define OXFORD_HARDWARE_ID_OXFW970 0x39443841
30#define OXFORD_HARDWARE_ID_OXFW971 0x39373100
31
32#define VENDOR_GRIFFIN 0x001292
33#define VENDOR_LACIE 0x00d04b
34
35#define SPECIFIER_1394TA 0x00a02d
36#define VERSION_AVC 0x010001
37
38struct device_info {
39 const char *driver_name;
40 const char *short_name;
41 const char *long_name;
42 int (*pcm_constraints)(struct snd_pcm_runtime *runtime);
43 unsigned int mixer_channels;
44 u8 mute_fb_id;
45 u8 volume_fb_id;
46};
47
48struct fwspk {
49 struct snd_card *card;
50 struct fw_unit *unit;
51 const struct device_info *device_info;
52 struct snd_pcm_substream *pcm;
53 struct mutex mutex;
54 struct cmp_connection connection;
55 struct amdtp_out_stream stream;
56 bool stream_running;
57 bool mute;
58 s16 volume[6];
59 s16 volume_min;
60 s16 volume_max;
61};
62
63MODULE_DESCRIPTION("FireWire speakers driver");
64MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
65MODULE_LICENSE("GPL v2");
66
67static int firewave_rate_constraint(struct snd_pcm_hw_params *params,
68 struct snd_pcm_hw_rule *rule)
69{
70 static unsigned int stereo_rates[] = { 48000, 96000 };
71 struct snd_interval *channels =
72 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
73 struct snd_interval *rate =
74 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
75
76
77 if (snd_interval_max(channels) < 6)
78 return snd_interval_list(rate, 2, stereo_rates, 0);
79 return 0;
80}
81
82static int firewave_channels_constraint(struct snd_pcm_hw_params *params,
83 struct snd_pcm_hw_rule *rule)
84{
85 static const struct snd_interval all_channels = { .min = 6, .max = 6 };
86 struct snd_interval *rate =
87 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
88 struct snd_interval *channels =
89 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
90
91
92 if (snd_interval_max(rate) < 48000)
93 return snd_interval_refine(channels, &all_channels);
94 return 0;
95}
96
97static int firewave_constraints(struct snd_pcm_runtime *runtime)
98{
99 static unsigned int channels_list[] = { 2, 6 };
100 static struct snd_pcm_hw_constraint_list channels_list_constraint = {
101 .count = 2,
102 .list = channels_list,
103 };
104 int err;
105
106 runtime->hw.rates = SNDRV_PCM_RATE_32000 |
107 SNDRV_PCM_RATE_44100 |
108 SNDRV_PCM_RATE_48000 |
109 SNDRV_PCM_RATE_96000;
110 runtime->hw.channels_max = 6;
111
112 err = snd_pcm_hw_constraint_list(runtime, 0,
113 SNDRV_PCM_HW_PARAM_CHANNELS,
114 &channels_list_constraint);
115 if (err < 0)
116 return err;
117 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
118 firewave_rate_constraint, NULL,
119 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
120 if (err < 0)
121 return err;
122 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
123 firewave_channels_constraint, NULL,
124 SNDRV_PCM_HW_PARAM_RATE, -1);
125 if (err < 0)
126 return err;
127
128 return 0;
129}
130
131static int lacie_speakers_constraints(struct snd_pcm_runtime *runtime)
132{
133 runtime->hw.rates = SNDRV_PCM_RATE_32000 |
134 SNDRV_PCM_RATE_44100 |
135 SNDRV_PCM_RATE_48000 |
136 SNDRV_PCM_RATE_88200 |
137 SNDRV_PCM_RATE_96000;
138
139 return 0;
140}
141
142static int fwspk_open(struct snd_pcm_substream *substream)
143{
144 static const struct snd_pcm_hardware hardware = {
145 .info = SNDRV_PCM_INFO_MMAP |
146 SNDRV_PCM_INFO_MMAP_VALID |
147 SNDRV_PCM_INFO_BATCH |
148 SNDRV_PCM_INFO_INTERLEAVED |
149 SNDRV_PCM_INFO_BLOCK_TRANSFER,
150 .formats = AMDTP_OUT_PCM_FORMAT_BITS,
151 .channels_min = 2,
152 .channels_max = 2,
153 .buffer_bytes_max = 4 * 1024 * 1024,
154 .period_bytes_min = 1,
155 .period_bytes_max = UINT_MAX,
156 .periods_min = 1,
157 .periods_max = UINT_MAX,
158 };
159 struct fwspk *fwspk = substream->private_data;
160 struct snd_pcm_runtime *runtime = substream->runtime;
161 int err;
162
163 runtime->hw = hardware;
164
165 err = fwspk->device_info->pcm_constraints(runtime);
166 if (err < 0)
167 return err;
168 err = snd_pcm_limit_hw_rates(runtime);
169 if (err < 0)
170 return err;
171
172 err = snd_pcm_hw_constraint_minmax(runtime,
173 SNDRV_PCM_HW_PARAM_PERIOD_TIME,
174 5000, UINT_MAX);
175 if (err < 0)
176 return err;
177
178 err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
179 if (err < 0)
180 return err;
181
182 return 0;
183}
184
185static int fwspk_close(struct snd_pcm_substream *substream)
186{
187 return 0;
188}
189
190static void fwspk_stop_stream(struct fwspk *fwspk)
191{
192 if (fwspk->stream_running) {
193 amdtp_out_stream_stop(&fwspk->stream);
194 cmp_connection_break(&fwspk->connection);
195 fwspk->stream_running = false;
196 }
197}
198
199static int fwspk_set_rate(struct fwspk *fwspk, unsigned int sfc)
200{
201 u8 *buf;
202 int err;
203
204 buf = kmalloc(8, GFP_KERNEL);
205 if (!buf)
206 return -ENOMEM;
207
208 buf[0] = 0x00;
209 buf[1] = 0xff;
210 buf[2] = 0x19;
211 buf[3] = 0x00;
212 buf[4] = 0x90;
213 buf[5] = 0x00 | sfc;
214 buf[6] = 0xff;
215 buf[7] = 0xff;
216
217 err = fcp_avc_transaction(fwspk->unit, buf, 8, buf, 8,
218 BIT(1) | BIT(2) | BIT(3) | BIT(4) | BIT(5));
219 if (err < 0)
220 goto error;
221 if (err < 6 || buf[0] != 0x09 ) {
222 dev_err(&fwspk->unit->device, "failed to set sample rate\n");
223 err = -EIO;
224 goto error;
225 }
226
227 err = 0;
228
229error:
230 kfree(buf);
231
232 return err;
233}
234
235static int fwspk_hw_params(struct snd_pcm_substream *substream,
236 struct snd_pcm_hw_params *hw_params)
237{
238 struct fwspk *fwspk = substream->private_data;
239 int err;
240
241 mutex_lock(&fwspk->mutex);
242 fwspk_stop_stream(fwspk);
243 mutex_unlock(&fwspk->mutex);
244
245 err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
246 params_buffer_bytes(hw_params));
247 if (err < 0)
248 goto error;
249
250 amdtp_out_stream_set_rate(&fwspk->stream, params_rate(hw_params));
251 amdtp_out_stream_set_pcm(&fwspk->stream, params_channels(hw_params));
252
253 amdtp_out_stream_set_pcm_format(&fwspk->stream,
254 params_format(hw_params));
255
256 err = fwspk_set_rate(fwspk, fwspk->stream.sfc);
257 if (err < 0)
258 goto err_buffer;
259
260 return 0;
261
262err_buffer:
263 snd_pcm_lib_free_vmalloc_buffer(substream);
264error:
265 return err;
266}
267
268static int fwspk_hw_free(struct snd_pcm_substream *substream)
269{
270 struct fwspk *fwspk = substream->private_data;
271
272 mutex_lock(&fwspk->mutex);
273 fwspk_stop_stream(fwspk);
274 mutex_unlock(&fwspk->mutex);
275
276 return snd_pcm_lib_free_vmalloc_buffer(substream);
277}
278
279static int fwspk_prepare(struct snd_pcm_substream *substream)
280{
281 struct fwspk *fwspk = substream->private_data;
282 int err;
283
284 mutex_lock(&fwspk->mutex);
285
286 if (amdtp_out_streaming_error(&fwspk->stream))
287 fwspk_stop_stream(fwspk);
288
289 if (!fwspk->stream_running) {
290 err = cmp_connection_establish(&fwspk->connection,
291 amdtp_out_stream_get_max_payload(&fwspk->stream));
292 if (err < 0)
293 goto err_mutex;
294
295 err = amdtp_out_stream_start(&fwspk->stream,
296 fwspk->connection.resources.channel,
297 fwspk->connection.speed);
298 if (err < 0)
299 goto err_connection;
300
301 fwspk->stream_running = true;
302 }
303
304 mutex_unlock(&fwspk->mutex);
305
306 amdtp_out_stream_pcm_prepare(&fwspk->stream);
307
308 return 0;
309
310err_connection:
311 cmp_connection_break(&fwspk->connection);
312err_mutex:
313 mutex_unlock(&fwspk->mutex);
314
315 return err;
316}
317
318static int fwspk_trigger(struct snd_pcm_substream *substream, int cmd)
319{
320 struct fwspk *fwspk = substream->private_data;
321 struct snd_pcm_substream *pcm;
322
323 switch (cmd) {
324 case SNDRV_PCM_TRIGGER_START:
325 pcm = substream;
326 break;
327 case SNDRV_PCM_TRIGGER_STOP:
328 pcm = NULL;
329 break;
330 default:
331 return -EINVAL;
332 }
333 amdtp_out_stream_pcm_trigger(&fwspk->stream, pcm);
334 return 0;
335}
336
337static snd_pcm_uframes_t fwspk_pointer(struct snd_pcm_substream *substream)
338{
339 struct fwspk *fwspk = substream->private_data;
340
341 return amdtp_out_stream_pcm_pointer(&fwspk->stream);
342}
343
344static int fwspk_create_pcm(struct fwspk *fwspk)
345{
346 static struct snd_pcm_ops ops = {
347 .open = fwspk_open,
348 .close = fwspk_close,
349 .ioctl = snd_pcm_lib_ioctl,
350 .hw_params = fwspk_hw_params,
351 .hw_free = fwspk_hw_free,
352 .prepare = fwspk_prepare,
353 .trigger = fwspk_trigger,
354 .pointer = fwspk_pointer,
355 .page = snd_pcm_lib_get_vmalloc_page,
356 .mmap = snd_pcm_lib_mmap_vmalloc,
357 };
358 struct snd_pcm *pcm;
359 int err;
360
361 err = snd_pcm_new(fwspk->card, "OXFW970", 0, 1, 0, &pcm);
362 if (err < 0)
363 return err;
364 pcm->private_data = fwspk;
365 strcpy(pcm->name, fwspk->device_info->short_name);
366 fwspk->pcm = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
367 fwspk->pcm->ops = &ops;
368 return 0;
369}
370
371enum control_action { CTL_READ, CTL_WRITE };
372enum control_attribute {
373 CTL_MIN = 0x02,
374 CTL_MAX = 0x03,
375 CTL_CURRENT = 0x10,
376};
377
378static int fwspk_mute_command(struct fwspk *fwspk, bool *value,
379 enum control_action action)
380{
381 u8 *buf;
382 u8 response_ok;
383 int err;
384
385 buf = kmalloc(11, GFP_KERNEL);
386 if (!buf)
387 return -ENOMEM;
388
389 if (action == CTL_READ) {
390 buf[0] = 0x01;
391 response_ok = 0x0c;
392 } else {
393 buf[0] = 0x00;
394 response_ok = 0x09;
395 }
396 buf[1] = 0x08;
397 buf[2] = 0xb8;
398 buf[3] = 0x81;
399 buf[4] = fwspk->device_info->mute_fb_id;
400 buf[5] = 0x10;
401 buf[6] = 0x02;
402 buf[7] = 0x00;
403 buf[8] = 0x01;
404 buf[9] = 0x01;
405 if (action == CTL_READ)
406 buf[10] = 0xff;
407 else
408 buf[10] = *value ? 0x70 : 0x60;
409
410 err = fcp_avc_transaction(fwspk->unit, buf, 11, buf, 11, 0x3fe);
411 if (err < 0)
412 goto error;
413 if (err < 11) {
414 dev_err(&fwspk->unit->device, "short FCP response\n");
415 err = -EIO;
416 goto error;
417 }
418 if (buf[0] != response_ok) {
419 dev_err(&fwspk->unit->device, "mute command failed\n");
420 err = -EIO;
421 goto error;
422 }
423 if (action == CTL_READ)
424 *value = buf[10] == 0x70;
425
426 err = 0;
427
428error:
429 kfree(buf);
430
431 return err;
432}
433
434static int fwspk_volume_command(struct fwspk *fwspk, s16 *value,
435 unsigned int channel,
436 enum control_attribute attribute,
437 enum control_action action)
438{
439 u8 *buf;
440 u8 response_ok;
441 int err;
442
443 buf = kmalloc(12, GFP_KERNEL);
444 if (!buf)
445 return -ENOMEM;
446
447 if (action == CTL_READ) {
448 buf[0] = 0x01;
449 response_ok = 0x0c;
450 } else {
451 buf[0] = 0x00;
452 response_ok = 0x09;
453 }
454 buf[1] = 0x08;
455 buf[2] = 0xb8;
456 buf[3] = 0x81;
457 buf[4] = fwspk->device_info->volume_fb_id;
458 buf[5] = attribute;
459 buf[6] = 0x02;
460 buf[7] = channel;
461 buf[8] = 0x02;
462 buf[9] = 0x02;
463 if (action == CTL_READ) {
464 buf[10] = 0xff;
465 buf[11] = 0xff;
466 } else {
467 buf[10] = *value >> 8;
468 buf[11] = *value;
469 }
470
471 err = fcp_avc_transaction(fwspk->unit, buf, 12, buf, 12, 0x3fe);
472 if (err < 0)
473 goto error;
474 if (err < 12) {
475 dev_err(&fwspk->unit->device, "short FCP response\n");
476 err = -EIO;
477 goto error;
478 }
479 if (buf[0] != response_ok) {
480 dev_err(&fwspk->unit->device, "volume command failed\n");
481 err = -EIO;
482 goto error;
483 }
484 if (action == CTL_READ)
485 *value = (buf[10] << 8) | buf[11];
486
487 err = 0;
488
489error:
490 kfree(buf);
491
492 return err;
493}
494
495static int fwspk_mute_get(struct snd_kcontrol *control,
496 struct snd_ctl_elem_value *value)
497{
498 struct fwspk *fwspk = control->private_data;
499
500 value->value.integer.value[0] = !fwspk->mute;
501
502 return 0;
503}
504
505static int fwspk_mute_put(struct snd_kcontrol *control,
506 struct snd_ctl_elem_value *value)
507{
508 struct fwspk *fwspk = control->private_data;
509 bool mute;
510 int err;
511
512 mute = !value->value.integer.value[0];
513
514 if (mute == fwspk->mute)
515 return 0;
516
517 err = fwspk_mute_command(fwspk, &mute, CTL_WRITE);
518 if (err < 0)
519 return err;
520 fwspk->mute = mute;
521
522 return 1;
523}
524
525static int fwspk_volume_info(struct snd_kcontrol *control,
526 struct snd_ctl_elem_info *info)
527{
528 struct fwspk *fwspk = control->private_data;
529
530 info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
531 info->count = fwspk->device_info->mixer_channels;
532 info->value.integer.min = fwspk->volume_min;
533 info->value.integer.max = fwspk->volume_max;
534
535 return 0;
536}
537
538static const u8 channel_map[6] = { 0, 1, 4, 5, 2, 3 };
539
540static int fwspk_volume_get(struct snd_kcontrol *control,
541 struct snd_ctl_elem_value *value)
542{
543 struct fwspk *fwspk = control->private_data;
544 unsigned int i;
545
546 for (i = 0; i < fwspk->device_info->mixer_channels; ++i)
547 value->value.integer.value[channel_map[i]] = fwspk->volume[i];
548
549 return 0;
550}
551
552static int fwspk_volume_put(struct snd_kcontrol *control,
553 struct snd_ctl_elem_value *value)
554{
555 struct fwspk *fwspk = control->private_data;
556 unsigned int i, changed_channels;
557 bool equal_values = true;
558 s16 volume;
559 int err;
560
561 for (i = 0; i < fwspk->device_info->mixer_channels; ++i) {
562 if (value->value.integer.value[i] < fwspk->volume_min ||
563 value->value.integer.value[i] > fwspk->volume_max)
564 return -EINVAL;
565 if (value->value.integer.value[i] !=
566 value->value.integer.value[0])
567 equal_values = false;
568 }
569
570 changed_channels = 0;
571 for (i = 0; i < fwspk->device_info->mixer_channels; ++i)
572 if (value->value.integer.value[channel_map[i]] !=
573 fwspk->volume[i])
574 changed_channels |= 1 << (i + 1);
575
576 if (equal_values && changed_channels != 0)
577 changed_channels = 1 << 0;
578
579 for (i = 0; i <= fwspk->device_info->mixer_channels; ++i) {
580 volume = value->value.integer.value[channel_map[i ? i - 1 : 0]];
581 if (changed_channels & (1 << i)) {
582 err = fwspk_volume_command(fwspk, &volume, i,
583 CTL_CURRENT, CTL_WRITE);
584 if (err < 0)
585 return err;
586 }
587 if (i > 0)
588 fwspk->volume[i - 1] = volume;
589 }
590
591 return changed_channels != 0;
592}
593
594static int fwspk_create_mixer(struct fwspk *fwspk)
595{
596 static const struct snd_kcontrol_new controls[] = {
597 {
598 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
599 .name = "PCM Playback Switch",
600 .info = snd_ctl_boolean_mono_info,
601 .get = fwspk_mute_get,
602 .put = fwspk_mute_put,
603 },
604 {
605 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
606 .name = "PCM Playback Volume",
607 .info = fwspk_volume_info,
608 .get = fwspk_volume_get,
609 .put = fwspk_volume_put,
610 },
611 };
612 unsigned int i, first_ch;
613 int err;
614
615 err = fwspk_volume_command(fwspk, &fwspk->volume_min,
616 0, CTL_MIN, CTL_READ);
617 if (err < 0)
618 return err;
619 err = fwspk_volume_command(fwspk, &fwspk->volume_max,
620 0, CTL_MAX, CTL_READ);
621 if (err < 0)
622 return err;
623
624 err = fwspk_mute_command(fwspk, &fwspk->mute, CTL_READ);
625 if (err < 0)
626 return err;
627
628 first_ch = fwspk->device_info->mixer_channels == 1 ? 0 : 1;
629 for (i = 0; i < fwspk->device_info->mixer_channels; ++i) {
630 err = fwspk_volume_command(fwspk, &fwspk->volume[i],
631 first_ch + i, CTL_CURRENT, CTL_READ);
632 if (err < 0)
633 return err;
634 }
635
636 for (i = 0; i < ARRAY_SIZE(controls); ++i) {
637 err = snd_ctl_add(fwspk->card,
638 snd_ctl_new1(&controls[i], fwspk));
639 if (err < 0)
640 return err;
641 }
642
643 return 0;
644}
645
646static u32 fwspk_read_firmware_version(struct fw_unit *unit)
647{
648 __be32 data;
649 int err;
650
651 err = snd_fw_transaction(unit, TCODE_READ_QUADLET_REQUEST,
652 OXFORD_FIRMWARE_ID_ADDRESS, &data, 4);
653 return err >= 0 ? be32_to_cpu(data) : 0;
654}
655
656static void fwspk_card_free(struct snd_card *card)
657{
658 struct fwspk *fwspk = card->private_data;
659
660 amdtp_out_stream_destroy(&fwspk->stream);
661 cmp_connection_destroy(&fwspk->connection);
662 fw_unit_put(fwspk->unit);
663 mutex_destroy(&fwspk->mutex);
664}
665
666static int fwspk_probe(struct fw_unit *unit,
667 const struct ieee1394_device_id *id)
668{
669 struct fw_device *fw_dev = fw_parent_device(unit);
670 struct snd_card *card;
671 struct fwspk *fwspk;
672 u32 firmware;
673 int err;
674
675 err = snd_card_create(-1, NULL, THIS_MODULE, sizeof(*fwspk), &card);
676 if (err < 0)
677 return err;
678 snd_card_set_dev(card, &unit->device);
679
680 fwspk = card->private_data;
681 fwspk->card = card;
682 mutex_init(&fwspk->mutex);
683 fwspk->unit = fw_unit_get(unit);
684 fwspk->device_info = (const struct device_info *)id->driver_data;
685
686 err = cmp_connection_init(&fwspk->connection, unit, 0);
687 if (err < 0)
688 goto err_unit;
689
690 err = amdtp_out_stream_init(&fwspk->stream, unit, CIP_NONBLOCKING);
691 if (err < 0)
692 goto err_connection;
693
694 card->private_free = fwspk_card_free;
695
696 strcpy(card->driver, fwspk->device_info->driver_name);
697 strcpy(card->shortname, fwspk->device_info->short_name);
698 firmware = fwspk_read_firmware_version(unit);
699 snprintf(card->longname, sizeof(card->longname),
700 "%s (OXFW%x %04x), GUID %08x%08x at %s, S%d",
701 fwspk->device_info->long_name,
702 firmware >> 20, firmware & 0xffff,
703 fw_dev->config_rom[3], fw_dev->config_rom[4],
704 dev_name(&unit->device), 100 << fw_dev->max_speed);
705 strcpy(card->mixername, "OXFW970");
706
707 err = fwspk_create_pcm(fwspk);
708 if (err < 0)
709 goto error;
710
711 err = fwspk_create_mixer(fwspk);
712 if (err < 0)
713 goto error;
714
715 err = snd_card_register(card);
716 if (err < 0)
717 goto error;
718
719 dev_set_drvdata(&unit->device, fwspk);
720
721 return 0;
722
723err_connection:
724 cmp_connection_destroy(&fwspk->connection);
725err_unit:
726 fw_unit_put(fwspk->unit);
727 mutex_destroy(&fwspk->mutex);
728error:
729 snd_card_free(card);
730 return err;
731}
732
733static void fwspk_bus_reset(struct fw_unit *unit)
734{
735 struct fwspk *fwspk = dev_get_drvdata(&unit->device);
736
737 fcp_bus_reset(fwspk->unit);
738
739 if (cmp_connection_update(&fwspk->connection) < 0) {
740 amdtp_out_stream_pcm_abort(&fwspk->stream);
741 mutex_lock(&fwspk->mutex);
742 fwspk_stop_stream(fwspk);
743 mutex_unlock(&fwspk->mutex);
744 return;
745 }
746
747 amdtp_out_stream_update(&fwspk->stream);
748}
749
750static void fwspk_remove(struct fw_unit *unit)
751{
752 struct fwspk *fwspk = dev_get_drvdata(&unit->device);
753
754 amdtp_out_stream_pcm_abort(&fwspk->stream);
755 snd_card_disconnect(fwspk->card);
756
757 mutex_lock(&fwspk->mutex);
758 fwspk_stop_stream(fwspk);
759 mutex_unlock(&fwspk->mutex);
760
761 snd_card_free_when_closed(fwspk->card);
762}
763
764static const struct device_info griffin_firewave = {
765 .driver_name = "FireWave",
766 .short_name = "FireWave",
767 .long_name = "Griffin FireWave Surround",
768 .pcm_constraints = firewave_constraints,
769 .mixer_channels = 6,
770 .mute_fb_id = 0x01,
771 .volume_fb_id = 0x02,
772};
773
774static const struct device_info lacie_speakers = {
775 .driver_name = "FWSpeakers",
776 .short_name = "FireWire Speakers",
777 .long_name = "LaCie FireWire Speakers",
778 .pcm_constraints = lacie_speakers_constraints,
779 .mixer_channels = 1,
780 .mute_fb_id = 0x01,
781 .volume_fb_id = 0x01,
782};
783
784static const struct ieee1394_device_id fwspk_id_table[] = {
785 {
786 .match_flags = IEEE1394_MATCH_VENDOR_ID |
787 IEEE1394_MATCH_MODEL_ID |
788 IEEE1394_MATCH_SPECIFIER_ID |
789 IEEE1394_MATCH_VERSION,
790 .vendor_id = VENDOR_GRIFFIN,
791 .model_id = 0x00f970,
792 .specifier_id = SPECIFIER_1394TA,
793 .version = VERSION_AVC,
794 .driver_data = (kernel_ulong_t)&griffin_firewave,
795 },
796 {
797 .match_flags = IEEE1394_MATCH_VENDOR_ID |
798 IEEE1394_MATCH_MODEL_ID |
799 IEEE1394_MATCH_SPECIFIER_ID |
800 IEEE1394_MATCH_VERSION,
801 .vendor_id = VENDOR_LACIE,
802 .model_id = 0x00f970,
803 .specifier_id = SPECIFIER_1394TA,
804 .version = VERSION_AVC,
805 .driver_data = (kernel_ulong_t)&lacie_speakers,
806 },
807 { }
808};
809MODULE_DEVICE_TABLE(ieee1394, fwspk_id_table);
810
811static struct fw_driver fwspk_driver = {
812 .driver = {
813 .owner = THIS_MODULE,
814 .name = KBUILD_MODNAME,
815 .bus = &fw_bus_type,
816 },
817 .probe = fwspk_probe,
818 .update = fwspk_bus_reset,
819 .remove = fwspk_remove,
820 .id_table = fwspk_id_table,
821};
822
823static int __init alsa_fwspk_init(void)
824{
825 return driver_register(&fwspk_driver.driver);
826}
827
828static void __exit alsa_fwspk_exit(void)
829{
830 driver_unregister(&fwspk_driver.driver);
831}
832
833module_init(alsa_fwspk_init);
834module_exit(alsa_fwspk_exit);
835
