2 * Apple iSight audio driver
4 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
5 * Licensed under the terms of the GNU General Public License, version 2.
8 #include <asm/byteorder.h>
9 #include <linux/delay.h>
10 #include <linux/device.h>
11 #include <linux/firewire.h>
12 #include <linux/firewire-constants.h>
13 #include <linux/module.h>
14 #include <linux/mod_devicetable.h>
15 #include <linux/mutex.h>
16 #include <linux/string.h>
17 #include <sound/control.h>
18 #include <sound/core.h>
19 #include <sound/initval.h>
20 #include <sound/pcm.h>
21 #include <sound/tlv.h>
23 #include "iso-resources.h"
24 #include "packets-buffer.h"
26 #define OUI_APPLE 0x000a27
27 #define MODEL_APPLE_ISIGHT 0x000008
28 #define SW_ISIGHT_AUDIO 0x000010
30 #define REG_AUDIO_ENABLE 0x000
31 #define AUDIO_ENABLE 0x80000000
32 #define REG_DEF_AUDIO_GAIN 0x204
33 #define REG_GAIN_RAW_START 0x210
34 #define REG_GAIN_RAW_END 0x214
35 #define REG_GAIN_DB_START 0x218
36 #define REG_GAIN_DB_END 0x21c
37 #define REG_SAMPLE_RATE_INQUIRY 0x280
38 #define REG_ISO_TX_CONFIG 0x300
39 #define SPEED_SHIFT 16
40 #define REG_SAMPLE_RATE 0x400
41 #define RATE_48000 0x80000000
42 #define REG_GAIN 0x500
43 #define REG_MUTE 0x504
45 #define MAX_FRAMES_PER_PACKET 475
47 #define QUEUE_LENGTH 20
50 struct snd_card
*card
;
52 struct fw_device
*device
;
54 struct snd_pcm_substream
*pcm
;
56 struct iso_packets_buffer buffer
;
57 struct fw_iso_resources resources
;
58 struct fw_iso_context
*context
;
64 unsigned int buffer_pointer
;
65 unsigned int period_counter
;
66 s32 gain_min
, gain_max
;
67 unsigned int gain_tlv
[4];
70 struct audio_payload
{
75 __be16 samples
[2 * MAX_FRAMES_PER_PACKET
];
78 MODULE_DESCRIPTION("iSight audio driver");
79 MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
80 MODULE_LICENSE("GPL v2");
82 static struct fw_iso_packet audio_packet
= {
83 .payload_length
= sizeof(struct audio_payload
),
88 static void isight_update_pointers(struct isight
*isight
, unsigned int count
)
90 struct snd_pcm_runtime
*runtime
= isight
->pcm
->runtime
;
93 smp_wmb(); /* update buffer data before buffer pointer */
95 ptr
= isight
->buffer_pointer
;
97 if (ptr
>= runtime
->buffer_size
)
98 ptr
-= runtime
->buffer_size
;
99 ACCESS_ONCE(isight
->buffer_pointer
) = ptr
;
101 isight
->period_counter
+= count
;
102 if (isight
->period_counter
>= runtime
->period_size
) {
103 isight
->period_counter
-= runtime
->period_size
;
104 snd_pcm_period_elapsed(isight
->pcm
);
108 static void isight_samples(struct isight
*isight
,
109 const __be16
*samples
, unsigned int count
)
111 struct snd_pcm_runtime
*runtime
;
114 if (!ACCESS_ONCE(isight
->pcm_running
))
117 runtime
= isight
->pcm
->runtime
;
118 if (isight
->buffer_pointer
+ count
<= runtime
->buffer_size
) {
119 memcpy(runtime
->dma_area
+ isight
->buffer_pointer
* 4,
122 count1
= runtime
->buffer_size
- isight
->buffer_pointer
;
123 memcpy(runtime
->dma_area
+ isight
->buffer_pointer
* 4,
124 samples
, count1
* 4);
125 samples
+= count1
* 2;
126 memcpy(runtime
->dma_area
, samples
, (count
- count1
) * 4);
129 isight_update_pointers(isight
, count
);
132 static void isight_pcm_abort(struct isight
*isight
)
136 if (ACCESS_ONCE(isight
->pcm_active
)) {
137 snd_pcm_stream_lock_irqsave(isight
->pcm
, flags
);
138 if (snd_pcm_running(isight
->pcm
))
139 snd_pcm_stop(isight
->pcm
, SNDRV_PCM_STATE_XRUN
);
140 snd_pcm_stream_unlock_irqrestore(isight
->pcm
, flags
);
144 static void isight_dropped_samples(struct isight
*isight
, unsigned int total
)
146 struct snd_pcm_runtime
*runtime
;
150 if (!ACCESS_ONCE(isight
->pcm_running
))
153 runtime
= isight
->pcm
->runtime
;
154 dropped
= total
- isight
->total_samples
;
155 if (dropped
< runtime
->buffer_size
) {
156 if (isight
->buffer_pointer
+ dropped
<= runtime
->buffer_size
) {
157 memset(runtime
->dma_area
+ isight
->buffer_pointer
* 4,
160 count1
= runtime
->buffer_size
- isight
->buffer_pointer
;
161 memset(runtime
->dma_area
+ isight
->buffer_pointer
* 4,
163 memset(runtime
->dma_area
, 0, (dropped
- count1
) * 4);
165 isight_update_pointers(isight
, dropped
);
167 isight_pcm_abort(isight
);
171 static void isight_packet(struct fw_iso_context
*context
, u32 cycle
,
172 size_t header_length
, void *header
, void *data
)
174 struct isight
*isight
= data
;
175 const struct audio_payload
*payload
;
176 unsigned int index
, length
, count
, total
;
179 if (isight
->packet_index
< 0)
181 index
= isight
->packet_index
;
182 payload
= isight
->buffer
.packets
[index
].buffer
;
183 length
= be32_to_cpup(header
) >> 16;
185 if (likely(length
>= 16 &&
186 payload
->signature
== cpu_to_be32(0x73676874/*"sght"*/))) {
187 count
= be32_to_cpu(payload
->sample_count
);
188 if (likely(count
<= (length
- 16) / 4)) {
189 total
= be32_to_cpu(payload
->sample_total
);
190 if (unlikely(total
!= isight
->total_samples
)) {
191 if (!isight
->first_packet
)
192 isight_dropped_samples(isight
, total
);
193 isight
->first_packet
= false;
194 isight
->total_samples
= total
;
197 isight_samples(isight
, payload
->samples
, count
);
198 isight
->total_samples
+= count
;
202 err
= fw_iso_context_queue(isight
->context
, &audio_packet
,
203 &isight
->buffer
.iso_buffer
,
204 isight
->buffer
.packets
[index
].offset
);
206 dev_err(&isight
->unit
->device
, "queueing error: %d\n", err
);
207 isight_pcm_abort(isight
);
208 isight
->packet_index
= -1;
211 fw_iso_context_queue_flush(isight
->context
);
213 if (++index
>= QUEUE_LENGTH
)
215 isight
->packet_index
= index
;
218 static int isight_connect(struct isight
*isight
)
220 int ch
, err
, rcode
, errors
= 0;
223 retry_after_bus_reset
:
224 ch
= fw_iso_resources_allocate(&isight
->resources
,
225 sizeof(struct audio_payload
),
226 isight
->device
->max_speed
);
232 value
= cpu_to_be32(ch
| (isight
->device
->max_speed
<< SPEED_SHIFT
));
234 rcode
= fw_run_transaction(
235 isight
->device
->card
,
236 TCODE_WRITE_QUADLET_REQUEST
,
237 isight
->device
->node_id
,
238 isight
->resources
.generation
,
239 isight
->device
->max_speed
,
240 isight
->audio_base
+ REG_ISO_TX_CONFIG
,
242 if (rcode
== RCODE_COMPLETE
) {
244 } else if (rcode
== RCODE_GENERATION
) {
245 fw_iso_resources_free(&isight
->resources
);
246 goto retry_after_bus_reset
;
247 } else if (rcode_is_permanent_error(rcode
) || ++errors
>= 3) {
255 fw_iso_resources_free(&isight
->resources
);
260 static int isight_open(struct snd_pcm_substream
*substream
)
262 static const struct snd_pcm_hardware hardware
= {
263 .info
= SNDRV_PCM_INFO_MMAP
|
264 SNDRV_PCM_INFO_MMAP_VALID
|
265 SNDRV_PCM_INFO_BATCH
|
266 SNDRV_PCM_INFO_INTERLEAVED
|
267 SNDRV_PCM_INFO_BLOCK_TRANSFER
,
268 .formats
= SNDRV_PCM_FMTBIT_S16_BE
,
269 .rates
= SNDRV_PCM_RATE_48000
,
274 .buffer_bytes_max
= 4 * 1024 * 1024,
275 .period_bytes_min
= MAX_FRAMES_PER_PACKET
* 4,
276 .period_bytes_max
= 1024 * 1024,
278 .periods_max
= UINT_MAX
,
280 struct isight
*isight
= substream
->private_data
;
282 substream
->runtime
->hw
= hardware
;
284 return iso_packets_buffer_init(&isight
->buffer
, isight
->unit
,
286 sizeof(struct audio_payload
),
290 static int isight_close(struct snd_pcm_substream
*substream
)
292 struct isight
*isight
= substream
->private_data
;
294 iso_packets_buffer_destroy(&isight
->buffer
, isight
->unit
);
299 static int isight_hw_params(struct snd_pcm_substream
*substream
,
300 struct snd_pcm_hw_params
*hw_params
)
302 struct isight
*isight
= substream
->private_data
;
305 err
= snd_pcm_lib_alloc_vmalloc_buffer(substream
,
306 params_buffer_bytes(hw_params
));
310 ACCESS_ONCE(isight
->pcm_active
) = true;
315 static int reg_read(struct isight
*isight
, int offset
, __be32
*value
)
317 return snd_fw_transaction(isight
->unit
, TCODE_READ_QUADLET_REQUEST
,
318 isight
->audio_base
+ offset
, value
, 4);
321 static int reg_write(struct isight
*isight
, int offset
, __be32 value
)
323 return snd_fw_transaction(isight
->unit
, TCODE_WRITE_QUADLET_REQUEST
,
324 isight
->audio_base
+ offset
, &value
, 4);
327 static void isight_stop_streaming(struct isight
*isight
)
329 if (!isight
->context
)
332 fw_iso_context_stop(isight
->context
);
333 fw_iso_context_destroy(isight
->context
);
334 isight
->context
= NULL
;
335 fw_iso_resources_free(&isight
->resources
);
336 reg_write(isight
, REG_AUDIO_ENABLE
, 0);
339 static int isight_hw_free(struct snd_pcm_substream
*substream
)
341 struct isight
*isight
= substream
->private_data
;
343 ACCESS_ONCE(isight
->pcm_active
) = false;
345 mutex_lock(&isight
->mutex
);
346 isight_stop_streaming(isight
);
347 mutex_unlock(&isight
->mutex
);
349 return snd_pcm_lib_free_vmalloc_buffer(substream
);
352 static int isight_start_streaming(struct isight
*isight
)
357 if (isight
->context
) {
358 if (isight
->packet_index
< 0)
359 isight_stop_streaming(isight
);
364 err
= reg_write(isight
, REG_SAMPLE_RATE
, cpu_to_be32(RATE_48000
));
368 err
= isight_connect(isight
);
372 err
= reg_write(isight
, REG_AUDIO_ENABLE
, cpu_to_be32(AUDIO_ENABLE
));
376 isight
->context
= fw_iso_context_create(isight
->device
->card
,
377 FW_ISO_CONTEXT_RECEIVE
,
378 isight
->resources
.channel
,
379 isight
->device
->max_speed
,
380 4, isight_packet
, isight
);
381 if (IS_ERR(isight
->context
)) {
382 err
= PTR_ERR(isight
->context
);
383 isight
->context
= NULL
;
387 for (i
= 0; i
< QUEUE_LENGTH
; ++i
) {
388 err
= fw_iso_context_queue(isight
->context
, &audio_packet
,
389 &isight
->buffer
.iso_buffer
,
390 isight
->buffer
.packets
[i
].offset
);
395 isight
->first_packet
= true;
396 isight
->packet_index
= 0;
398 err
= fw_iso_context_start(isight
->context
, -1, 0,
399 FW_ISO_CONTEXT_MATCH_ALL_TAGS
/*?*/);
406 fw_iso_context_destroy(isight
->context
);
407 isight
->context
= NULL
;
409 fw_iso_resources_free(&isight
->resources
);
410 reg_write(isight
, REG_AUDIO_ENABLE
, 0);
415 static int isight_prepare(struct snd_pcm_substream
*substream
)
417 struct isight
*isight
= substream
->private_data
;
420 isight
->buffer_pointer
= 0;
421 isight
->period_counter
= 0;
423 mutex_lock(&isight
->mutex
);
424 err
= isight_start_streaming(isight
);
425 mutex_unlock(&isight
->mutex
);
430 static int isight_trigger(struct snd_pcm_substream
*substream
, int cmd
)
432 struct isight
*isight
= substream
->private_data
;
435 case SNDRV_PCM_TRIGGER_START
:
436 ACCESS_ONCE(isight
->pcm_running
) = true;
438 case SNDRV_PCM_TRIGGER_STOP
:
439 ACCESS_ONCE(isight
->pcm_running
) = false;
447 static snd_pcm_uframes_t
isight_pointer(struct snd_pcm_substream
*substream
)
449 struct isight
*isight
= substream
->private_data
;
451 return ACCESS_ONCE(isight
->buffer_pointer
);
454 static int isight_create_pcm(struct isight
*isight
)
456 static struct snd_pcm_ops ops
= {
458 .close
= isight_close
,
459 .ioctl
= snd_pcm_lib_ioctl
,
460 .hw_params
= isight_hw_params
,
461 .hw_free
= isight_hw_free
,
462 .prepare
= isight_prepare
,
463 .trigger
= isight_trigger
,
464 .pointer
= isight_pointer
,
465 .page
= snd_pcm_lib_get_vmalloc_page
,
466 .mmap
= snd_pcm_lib_mmap_vmalloc
,
471 err
= snd_pcm_new(isight
->card
, "iSight", 0, 0, 1, &pcm
);
474 pcm
->private_data
= isight
;
475 strcpy(pcm
->name
, "iSight");
476 isight
->pcm
= pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
;
477 isight
->pcm
->ops
= &ops
;
482 static int isight_gain_info(struct snd_kcontrol
*ctl
,
483 struct snd_ctl_elem_info
*info
)
485 struct isight
*isight
= ctl
->private_data
;
487 info
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
489 info
->value
.integer
.min
= isight
->gain_min
;
490 info
->value
.integer
.max
= isight
->gain_max
;
495 static int isight_gain_get(struct snd_kcontrol
*ctl
,
496 struct snd_ctl_elem_value
*value
)
498 struct isight
*isight
= ctl
->private_data
;
502 err
= reg_read(isight
, REG_GAIN
, &gain
);
506 value
->value
.integer
.value
[0] = (s32
)be32_to_cpu(gain
);
511 static int isight_gain_put(struct snd_kcontrol
*ctl
,
512 struct snd_ctl_elem_value
*value
)
514 struct isight
*isight
= ctl
->private_data
;
516 if (value
->value
.integer
.value
[0] < isight
->gain_min
||
517 value
->value
.integer
.value
[0] > isight
->gain_max
)
520 return reg_write(isight
, REG_GAIN
,
521 cpu_to_be32(value
->value
.integer
.value
[0]));
524 static int isight_mute_get(struct snd_kcontrol
*ctl
,
525 struct snd_ctl_elem_value
*value
)
527 struct isight
*isight
= ctl
->private_data
;
531 err
= reg_read(isight
, REG_MUTE
, &mute
);
535 value
->value
.integer
.value
[0] = !mute
;
540 static int isight_mute_put(struct snd_kcontrol
*ctl
,
541 struct snd_ctl_elem_value
*value
)
543 struct isight
*isight
= ctl
->private_data
;
545 return reg_write(isight
, REG_MUTE
,
546 (__force __be32
)!value
->value
.integer
.value
[0]);
549 static int isight_create_mixer(struct isight
*isight
)
551 static const struct snd_kcontrol_new gain_control
= {
552 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
553 .name
= "Mic Capture Volume",
554 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
|
555 SNDRV_CTL_ELEM_ACCESS_TLV_READ
,
556 .info
= isight_gain_info
,
557 .get
= isight_gain_get
,
558 .put
= isight_gain_put
,
560 static const struct snd_kcontrol_new mute_control
= {
561 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
562 .name
= "Mic Capture Switch",
563 .info
= snd_ctl_boolean_mono_info
,
564 .get
= isight_mute_get
,
565 .put
= isight_mute_put
,
568 struct snd_kcontrol
*ctl
;
571 err
= reg_read(isight
, REG_GAIN_RAW_START
, &value
);
574 isight
->gain_min
= be32_to_cpu(value
);
576 err
= reg_read(isight
, REG_GAIN_RAW_END
, &value
);
579 isight
->gain_max
= be32_to_cpu(value
);
581 isight
->gain_tlv
[0] = SNDRV_CTL_TLVT_DB_MINMAX
;
582 isight
->gain_tlv
[1] = 2 * sizeof(unsigned int);
584 err
= reg_read(isight
, REG_GAIN_DB_START
, &value
);
587 isight
->gain_tlv
[2] = (s32
)be32_to_cpu(value
) * 100;
589 err
= reg_read(isight
, REG_GAIN_DB_END
, &value
);
592 isight
->gain_tlv
[3] = (s32
)be32_to_cpu(value
) * 100;
594 ctl
= snd_ctl_new1(&gain_control
, isight
);
596 ctl
->tlv
.p
= isight
->gain_tlv
;
597 err
= snd_ctl_add(isight
->card
, ctl
);
601 err
= snd_ctl_add(isight
->card
, snd_ctl_new1(&mute_control
, isight
));
608 static void isight_card_free(struct snd_card
*card
)
610 struct isight
*isight
= card
->private_data
;
612 fw_iso_resources_destroy(&isight
->resources
);
613 fw_unit_put(isight
->unit
);
614 mutex_destroy(&isight
->mutex
);
617 static u64
get_unit_base(struct fw_unit
*unit
)
619 struct fw_csr_iterator i
;
622 fw_csr_iterator_init(&i
, unit
->directory
);
623 while (fw_csr_iterator_next(&i
, &key
, &value
))
624 if (key
== CSR_OFFSET
)
625 return CSR_REGISTER_BASE
+ value
* 4;
629 static int isight_probe(struct fw_unit
*unit
,
630 const struct ieee1394_device_id
*id
)
632 struct fw_device
*fw_dev
= fw_parent_device(unit
);
633 struct snd_card
*card
;
634 struct isight
*isight
;
637 err
= snd_card_create(-1, NULL
, THIS_MODULE
, sizeof(*isight
), &card
);
640 snd_card_set_dev(card
, &unit
->device
);
642 isight
= card
->private_data
;
644 mutex_init(&isight
->mutex
);
645 isight
->unit
= fw_unit_get(unit
);
646 isight
->device
= fw_dev
;
647 isight
->audio_base
= get_unit_base(unit
);
648 if (!isight
->audio_base
) {
649 dev_err(&unit
->device
, "audio unit base not found\n");
653 fw_iso_resources_init(&isight
->resources
, unit
);
655 card
->private_free
= isight_card_free
;
657 strcpy(card
->driver
, "iSight");
658 strcpy(card
->shortname
, "Apple iSight");
659 snprintf(card
->longname
, sizeof(card
->longname
),
660 "Apple iSight (GUID %08x%08x) at %s, S%d",
661 fw_dev
->config_rom
[3], fw_dev
->config_rom
[4],
662 dev_name(&unit
->device
), 100 << fw_dev
->max_speed
);
663 strcpy(card
->mixername
, "iSight");
665 err
= isight_create_pcm(isight
);
669 err
= isight_create_mixer(isight
);
673 err
= snd_card_register(card
);
677 dev_set_drvdata(&unit
->device
, isight
);
682 fw_unit_put(isight
->unit
);
683 mutex_destroy(&isight
->mutex
);
689 static void isight_bus_reset(struct fw_unit
*unit
)
691 struct isight
*isight
= dev_get_drvdata(&unit
->device
);
693 if (fw_iso_resources_update(&isight
->resources
) < 0) {
694 isight_pcm_abort(isight
);
696 mutex_lock(&isight
->mutex
);
697 isight_stop_streaming(isight
);
698 mutex_unlock(&isight
->mutex
);
702 static void isight_remove(struct fw_unit
*unit
)
704 struct isight
*isight
= dev_get_drvdata(&unit
->device
);
706 isight_pcm_abort(isight
);
708 snd_card_disconnect(isight
->card
);
710 mutex_lock(&isight
->mutex
);
711 isight_stop_streaming(isight
);
712 mutex_unlock(&isight
->mutex
);
714 snd_card_free_when_closed(isight
->card
);
717 static const struct ieee1394_device_id isight_id_table
[] = {
719 .match_flags
= IEEE1394_MATCH_SPECIFIER_ID
|
720 IEEE1394_MATCH_VERSION
,
721 .specifier_id
= OUI_APPLE
,
722 .version
= SW_ISIGHT_AUDIO
,
726 MODULE_DEVICE_TABLE(ieee1394
, isight_id_table
);
728 static struct fw_driver isight_driver
= {
730 .owner
= THIS_MODULE
,
731 .name
= KBUILD_MODNAME
,
734 .probe
= isight_probe
,
735 .update
= isight_bus_reset
,
736 .remove
= isight_remove
,
737 .id_table
= isight_id_table
,
740 static int __init
alsa_isight_init(void)
742 return driver_register(&isight_driver
.driver
);
745 static void __exit
alsa_isight_exit(void)
747 driver_unregister(&isight_driver
.driver
);
750 module_init(alsa_isight_init
);
751 module_exit(alsa_isight_exit
);