?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Prefetch inodes in readdir
[pohmelfs.git] / sound / firewire / speakers.c
blobcbe6bb9e53b6fa2a268580da649f78885ca31863
1 /*
2 * OXFW970-based speakers driver
3 *
4 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
5 * Licensed under the terms of the GNU General Public License, version 2.
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 /* 0x970?vvvv or 0x971?vvvv, where vvvv = firmware version */
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
38 struct 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
48 struct 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
63 MODULE_DESCRIPTION("FireWire speakers driver");
64 MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
65 MODULE_LICENSE("GPL v2");
66
67 static 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 /* two channels work only at 48/96 kHz */
77 if (snd_interval_max(channels) < 6)
78 return snd_interval_list(rate, 2, stereo_rates, 0);
79 return 0;
80 }
81
82 static 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 /* 32/44.1 kHz work only with all six channels */
92 if (snd_interval_max(rate) < 48000)
93 return snd_interval_refine(channels, &all_channels);
94 return 0;
95 }
96
97 static 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
131 static 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
142 static 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
185 static int fwspk_close(struct snd_pcm_substream *substream)
186 {
187 return 0;
188 }
189
190 static 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
199 static 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; /* AV/C, CONTROL */
209 buf[1] = 0xff; /* unit */
210 buf[2] = 0x19; /* INPUT PLUG SIGNAL FORMAT */
211 buf[3] = 0x00; /* plug 0 */
212 buf[4] = 0x90; /* format: audio */
213 buf[5] = 0x00 | sfc; /* AM824, frequency */
214 buf[6] = 0xff; /* SYT (not used) */
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 /* ACCEPTED */) {
222 dev_err(&fwspk->unit->device, "failed to set sample rate\n");
223 err = -EIO;
224 goto error;
225 }
226
227 err = 0;
228
229 error:
230 kfree(buf);
231
232 return err;
233 }
234
235 static 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
262 err_buffer:
263 snd_pcm_lib_free_vmalloc_buffer(substream);
264 error:
265 return err;
266 }
267
268 static 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
279 static 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
310 err_connection:
311 cmp_connection_break(&fwspk->connection);
312 err_mutex:
313 mutex_unlock(&fwspk->mutex);
314
315 return err;
316 }
317
318 static 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
337 static 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
344 static 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
371 enum control_action { CTL_READ, CTL_WRITE };
372 enum control_attribute {
373 CTL_MIN = 0x02,
374 CTL_MAX = 0x03,
375 CTL_CURRENT = 0x10,
376 };
377
378 static 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; /* AV/C, STATUS */
391 response_ok = 0x0c; /* STABLE */
392 } else {
393 buf[0] = 0x00; /* AV/C, CONTROL */
394 response_ok = 0x09; /* ACCEPTED */
395 }
396 buf[1] = 0x08; /* audio unit 0 */
397 buf[2] = 0xb8; /* FUNCTION BLOCK */
398 buf[3] = 0x81; /* function block type: feature */
399 buf[4] = fwspk->device_info->mute_fb_id; /* function block ID */
400 buf[5] = 0x10; /* control attribute: current */
401 buf[6] = 0x02; /* selector length */
402 buf[7] = 0x00; /* audio channel number */
403 buf[8] = 0x01; /* control selector: mute */
404 buf[9] = 0x01; /* control data length */
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
428 error:
429 kfree(buf);
430
431 return err;
432 }
433
434 static 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; /* AV/C, STATUS */
449 response_ok = 0x0c; /* STABLE */
450 } else {
451 buf[0] = 0x00; /* AV/C, CONTROL */
452 response_ok = 0x09; /* ACCEPTED */
453 }
454 buf[1] = 0x08; /* audio unit 0 */
455 buf[2] = 0xb8; /* FUNCTION BLOCK */
456 buf[3] = 0x81; /* function block type: feature */
457 buf[4] = fwspk->device_info->volume_fb_id; /* function block ID */
458 buf[5] = attribute; /* control attribute */
459 buf[6] = 0x02; /* selector length */
460 buf[7] = channel; /* audio channel number */
461 buf[8] = 0x02; /* control selector: volume */
462 buf[9] = 0x02; /* control data length */
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
489 error:
490 kfree(buf);
491
492 return err;
493 }
494
495 static 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
505 static 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
525 static 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
538 static const u8 channel_map[6] = { 0, 1, 4, 5, 2, 3 };
539
540 static 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
552 static 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
594 static 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
646 static 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
656 static void fwspk_card_free(struct snd_card *card)
657 {
658 struct fwspk *fwspk = card->private_data;
659 struct fw_device *dev = fw_parent_device(fwspk->unit);
660
661 amdtp_out_stream_destroy(&fwspk->stream);
662 cmp_connection_destroy(&fwspk->connection);
663 fw_unit_put(fwspk->unit);
664 fw_device_put(dev);
665 mutex_destroy(&fwspk->mutex);
666 }
667
668 static const struct device_info *__devinit fwspk_detect(struct fw_device *dev)
669 {
670 static const struct device_info griffin_firewave = {
671 .driver_name = "FireWave",
672 .short_name = "FireWave",
673 .long_name = "Griffin FireWave Surround",
674 .pcm_constraints = firewave_constraints,
675 .mixer_channels = 6,
676 .mute_fb_id = 0x01,
677 .volume_fb_id = 0x02,
678 };
679 static const struct device_info lacie_speakers = {
680 .driver_name = "FWSpeakers",
681 .short_name = "FireWire Speakers",
682 .long_name = "LaCie FireWire Speakers",
683 .pcm_constraints = lacie_speakers_constraints,
684 .mixer_channels = 1,
685 .mute_fb_id = 0x01,
686 .volume_fb_id = 0x01,
687 };
688 struct fw_csr_iterator i;
689 int key, value;
690
691 fw_csr_iterator_init(&i, dev->config_rom);
692 while (fw_csr_iterator_next(&i, &key, &value))
693 if (key == CSR_VENDOR)
694 switch (value) {
695 case VENDOR_GRIFFIN:
696 return &griffin_firewave;
697 case VENDOR_LACIE:
698 return &lacie_speakers;
699 }
700
701 return NULL;
702 }
703
704 static int __devinit fwspk_probe(struct device *unit_dev)
705 {
706 struct fw_unit *unit = fw_unit(unit_dev);
707 struct fw_device *fw_dev = fw_parent_device(unit);
708 struct snd_card *card;
709 struct fwspk *fwspk;
710 u32 firmware;
711 int err;
712
713 err = snd_card_create(-1, NULL, THIS_MODULE, sizeof(*fwspk), &card);
714 if (err < 0)
715 return err;
716 snd_card_set_dev(card, unit_dev);
717
718 fwspk = card->private_data;
719 fwspk->card = card;
720 mutex_init(&fwspk->mutex);
721 fw_device_get(fw_dev);
722 fwspk->unit = fw_unit_get(unit);
723 fwspk->device_info = fwspk_detect(fw_dev);
724 if (!fwspk->device_info) {
725 err = -ENODEV;
726 goto err_unit;
727 }
728
729 err = cmp_connection_init(&fwspk->connection, unit, 0);
730 if (err < 0)
731 goto err_unit;
732
733 err = amdtp_out_stream_init(&fwspk->stream, unit, CIP_NONBLOCKING);
734 if (err < 0)
735 goto err_connection;
736
737 card->private_free = fwspk_card_free;
738
739 strcpy(card->driver, fwspk->device_info->driver_name);
740 strcpy(card->shortname, fwspk->device_info->short_name);
741 firmware = fwspk_read_firmware_version(unit);
742 snprintf(card->longname, sizeof(card->longname),
743 "%s (OXFW%x %04x), GUID %08x%08x at %s, S%d",
744 fwspk->device_info->long_name,
745 firmware >> 20, firmware & 0xffff,
746 fw_dev->config_rom[3], fw_dev->config_rom[4],
747 dev_name(&unit->device), 100 << fw_dev->max_speed);
748 strcpy(card->mixername, "OXFW970");
749
750 err = fwspk_create_pcm(fwspk);
751 if (err < 0)
752 goto error;
753
754 err = fwspk_create_mixer(fwspk);
755 if (err < 0)
756 goto error;
757
758 err = snd_card_register(card);
759 if (err < 0)
760 goto error;
761
762 dev_set_drvdata(unit_dev, fwspk);
763
764 return 0;
765
766 err_connection:
767 cmp_connection_destroy(&fwspk->connection);
768 err_unit:
769 fw_unit_put(fwspk->unit);
770 fw_device_put(fw_dev);
771 mutex_destroy(&fwspk->mutex);
772 error:
773 snd_card_free(card);
774 return err;
775 }
776
777 static int __devexit fwspk_remove(struct device *dev)
778 {
779 struct fwspk *fwspk = dev_get_drvdata(dev);
780
781 amdtp_out_stream_pcm_abort(&fwspk->stream);
782 snd_card_disconnect(fwspk->card);
783
784 mutex_lock(&fwspk->mutex);
785 fwspk_stop_stream(fwspk);
786 mutex_unlock(&fwspk->mutex);
787
788 snd_card_free_when_closed(fwspk->card);
789
790 return 0;
791 }
792
793 static void fwspk_bus_reset(struct fw_unit *unit)
794 {
795 struct fwspk *fwspk = dev_get_drvdata(&unit->device);
796
797 fcp_bus_reset(fwspk->unit);
798
799 if (cmp_connection_update(&fwspk->connection) < 0) {
800 amdtp_out_stream_pcm_abort(&fwspk->stream);
801 mutex_lock(&fwspk->mutex);
802 fwspk_stop_stream(fwspk);
803 mutex_unlock(&fwspk->mutex);
804 return;
805 }
806
807 amdtp_out_stream_update(&fwspk->stream);
808 }
809
810 static const struct ieee1394_device_id fwspk_id_table[] = {
811 {
812 .match_flags = IEEE1394_MATCH_VENDOR_ID |
813 IEEE1394_MATCH_MODEL_ID |
814 IEEE1394_MATCH_SPECIFIER_ID |
815 IEEE1394_MATCH_VERSION,
816 .vendor_id = VENDOR_GRIFFIN,
817 .model_id = 0x00f970,
818 .specifier_id = SPECIFIER_1394TA,
819 .version = VERSION_AVC,
820 },
821 {
822 .match_flags = IEEE1394_MATCH_VENDOR_ID |
823 IEEE1394_MATCH_MODEL_ID |
824 IEEE1394_MATCH_SPECIFIER_ID |
825 IEEE1394_MATCH_VERSION,
826 .vendor_id = VENDOR_LACIE,
827 .model_id = 0x00f970,
828 .specifier_id = SPECIFIER_1394TA,
829 .version = VERSION_AVC,
830 },
831 { }
832 };
833 MODULE_DEVICE_TABLE(ieee1394, fwspk_id_table);
834
835 static struct fw_driver fwspk_driver = {
836 .driver = {
837 .owner = THIS_MODULE,
838 .name = KBUILD_MODNAME,
839 .bus = &fw_bus_type,
840 .probe = fwspk_probe,
841 .remove = __devexit_p(fwspk_remove),
842 },
843 .update = fwspk_bus_reset,
844 .id_table = fwspk_id_table,
845 };
846
847 static int __init alsa_fwspk_init(void)
848 {
849 return driver_register(&fwspk_driver.driver);
850 }
851
852 static void __exit alsa_fwspk_exit(void)
853 {
854 driver_unregister(&fwspk_driver.driver);
855 }
856
857 module_init(alsa_fwspk_init);
858 module_exit(alsa_fwspk_exit);