ALSA: isight: remove superfluous field
[linux-2.6.git] / sound / firewire / speakers.c
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         mutex_lock(&fwspk->mutex);
782         amdtp_out_stream_pcm_abort(&fwspk->stream);
783         snd_card_disconnect(fwspk->card);
784         fwspk_stop_stream(fwspk);
785         mutex_unlock(&fwspk->mutex);
786
787         snd_card_free_when_closed(fwspk->card);
788
789         return 0;
790 }
791
792 static void fwspk_bus_reset(struct fw_unit *unit)
793 {
794         struct fwspk *fwspk = dev_get_drvdata(&unit->device);
795
796         fcp_bus_reset(fwspk->unit);
797
798         if (cmp_connection_update(&fwspk->connection) < 0) {
799                 mutex_lock(&fwspk->mutex);
800                 amdtp_out_stream_pcm_abort(&fwspk->stream);
801                 fwspk_stop_stream(fwspk);
802                 mutex_unlock(&fwspk->mutex);
803                 return;
804         }
805
806         amdtp_out_stream_update(&fwspk->stream);
807 }
808
809 static const struct ieee1394_device_id fwspk_id_table[] = {
810         {
811                 .match_flags  = IEEE1394_MATCH_VENDOR_ID |
812                                 IEEE1394_MATCH_MODEL_ID |
813                                 IEEE1394_MATCH_SPECIFIER_ID |
814                                 IEEE1394_MATCH_VERSION,
815                 .vendor_id    = VENDOR_GRIFFIN,
816                 .model_id     = 0x00f970,
817                 .specifier_id = SPECIFIER_1394TA,
818                 .version      = VERSION_AVC,
819         },
820         {
821                 .match_flags  = IEEE1394_MATCH_VENDOR_ID |
822                                 IEEE1394_MATCH_MODEL_ID |
823                                 IEEE1394_MATCH_SPECIFIER_ID |
824                                 IEEE1394_MATCH_VERSION,
825                 .vendor_id    = VENDOR_LACIE,
826                 .model_id     = 0x00f970,
827                 .specifier_id = SPECIFIER_1394TA,
828                 .version      = VERSION_AVC,
829         },
830         { }
831 };
832 MODULE_DEVICE_TABLE(ieee1394, fwspk_id_table);
833
834 static struct fw_driver fwspk_driver = {
835         .driver   = {
836                 .owner  = THIS_MODULE,
837                 .name   = KBUILD_MODNAME,
838                 .bus    = &fw_bus_type,
839                 .probe  = fwspk_probe,
840                 .remove = __devexit_p(fwspk_remove),
841         },
842         .update   = fwspk_bus_reset,
843         .id_table = fwspk_id_table,
844 };
845
846 static int __init alsa_fwspk_init(void)
847 {
848         return driver_register(&fwspk_driver.driver);
849 }
850
851 static void __exit alsa_fwspk_exit(void)
852 {
853         driver_unregister(&fwspk_driver.driver);
854 }
855
856 module_init(alsa_fwspk_init);
857 module_exit(alsa_fwspk_exit);