isight.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Apple iSight audio driver
  4 *
  5 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
  6 */
  7
  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>
 22#include "lib.h"
 23#include "iso-resources.h"
 24#include "packets-buffer.h"
 25
 26#define OUI_APPLE		0x000a27
 27#define MODEL_APPLE_ISIGHT	0x000008
 28#define SW_ISIGHT_AUDIO		0x000010
 29
 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
 44
 45#define MAX_FRAMES_PER_PACKET	475
 46
 47#define QUEUE_LENGTH		20
 48
 49struct isight {
 50	struct snd_card *card;
 51	struct fw_unit *unit;
 52	struct fw_device *device;
 53	u64 audio_base;
 54	struct snd_pcm_substream *pcm;
 55	struct mutex mutex;
 56	struct iso_packets_buffer buffer;
 57	struct fw_iso_resources resources;
 58	struct fw_iso_context *context;
 59	bool pcm_active;
 60	bool pcm_running;
 61	bool first_packet;
 62	int packet_index;
 63	u32 total_samples;
 64	unsigned int buffer_pointer;
 65	unsigned int period_counter;
 66	s32 gain_min, gain_max;
 67	unsigned int gain_tlv[4];
 68};
 69
 70struct audio_payload {
 71	__be32 sample_count;
 72	__be32 signature;
 73	__be32 sample_total;
 74	__be32 reserved;
 75	__be16 samples[2 * MAX_FRAMES_PER_PACKET];
 76};
 77
 78MODULE_DESCRIPTION("iSight audio driver");
 79MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
 80MODULE_LICENSE("GPL");
 81
 82static struct fw_iso_packet audio_packet = {
 83	.payload_length = sizeof(struct audio_payload),
 84	.interrupt = 1,
 85	.header_length = 4,
 86};
 87
 88static void isight_update_pointers(struct isight *isight, unsigned int count)
 89{
 90	struct snd_pcm_runtime *runtime = isight->pcm->runtime;
 91	unsigned int ptr;
 92
 93	smp_wmb(); /* update buffer data before buffer pointer */
 94
 95	ptr = isight->buffer_pointer;
 96	ptr += count;
 97	if (ptr >= runtime->buffer_size)
 98		ptr -= runtime->buffer_size;
 99	WRITE_ONCE(isight->buffer_pointer, ptr);
100
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);
105	}
106}
107
108static void isight_samples(struct isight *isight,
109			   const __be16 *samples, unsigned int count)
110{
111	struct snd_pcm_runtime *runtime;
112	unsigned int count1;
113
114	if (!READ_ONCE(isight->pcm_running))
115		return;
116
117	runtime = isight->pcm->runtime;
118	if (isight->buffer_pointer + count <= runtime->buffer_size) {
119		memcpy(runtime->dma_area + isight->buffer_pointer * 4,
120		       samples, count * 4);
121	} else {
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);
127	}
128
129	isight_update_pointers(isight, count);
130}
131
132static void isight_pcm_abort(struct isight *isight)
133{
134	if (READ_ONCE(isight->pcm_active))
135		snd_pcm_stop_xrun(isight->pcm);
136}
137
138static void isight_dropped_samples(struct isight *isight, unsigned int total)
139{
140	struct snd_pcm_runtime *runtime;
141	u32 dropped;
142	unsigned int count1;
143
144	if (!READ_ONCE(isight->pcm_running))
145		return;
146
147	runtime = isight->pcm->runtime;
148	dropped = total - isight->total_samples;
149	if (dropped < runtime->buffer_size) {
150		if (isight->buffer_pointer + dropped <= runtime->buffer_size) {
151			memset(runtime->dma_area + isight->buffer_pointer * 4,
152			       0, dropped * 4);
153		} else {
154			count1 = runtime->buffer_size - isight->buffer_pointer;
155			memset(runtime->dma_area + isight->buffer_pointer * 4,
156			       0, count1 * 4);
157			memset(runtime->dma_area, 0, (dropped - count1) * 4);
158		}
159		isight_update_pointers(isight, dropped);
160	} else {
161		isight_pcm_abort(isight);
162	}
163}
164
165static void isight_packet(struct fw_iso_context *context, u32 cycle,
166			  size_t header_length, void *header, void *data)
167{
168	struct isight *isight = data;
169	const struct audio_payload *payload;
170	unsigned int index, length, count, total;
171	int err;
172
173	if (isight->packet_index < 0)
174		return;
175	index = isight->packet_index;
176	payload = isight->buffer.packets[index].buffer;
177	length = be32_to_cpup(header) >> 16;
178
179	if (likely(length >= 16 &&
180		   payload->signature == cpu_to_be32(0x73676874/*"sght"*/))) {
181		count = be32_to_cpu(payload->sample_count);
182		if (likely(count <= (length - 16) / 4)) {
183			total = be32_to_cpu(payload->sample_total);
184			if (unlikely(total != isight->total_samples)) {
185				if (!isight->first_packet)
186					isight_dropped_samples(isight, total);
187				isight->first_packet = false;
188				isight->total_samples = total;
189			}
190
191			isight_samples(isight, payload->samples, count);
192			isight->total_samples += count;
193		}
194	}
195
196	err = fw_iso_context_queue(isight->context, &audio_packet,
197				   &isight->buffer.iso_buffer,
198				   isight->buffer.packets[index].offset);
199	if (err < 0) {
200		dev_err(&isight->unit->device, "queueing error: %d\n", err);
201		isight_pcm_abort(isight);
202		isight->packet_index = -1;
203		return;
204	}
205	fw_iso_context_queue_flush(isight->context);
206
207	if (++index >= QUEUE_LENGTH)
208		index = 0;
209	isight->packet_index = index;
210}
211
212static int isight_connect(struct isight *isight)
213{
214	int ch, err;
215	__be32 value;
216
217retry_after_bus_reset:
218	ch = fw_iso_resources_allocate(&isight->resources,
219				       sizeof(struct audio_payload),
220				       isight->device->max_speed);
221	if (ch < 0) {
222		err = ch;
223		goto error;
224	}
225
226	value = cpu_to_be32(ch | (isight->device->max_speed << SPEED_SHIFT));
227	err = snd_fw_transaction(isight->unit, TCODE_WRITE_QUADLET_REQUEST,
228				 isight->audio_base + REG_ISO_TX_CONFIG,
229				 &value, 4, FW_FIXED_GENERATION |
230				 isight->resources.generation);
231	if (err == -EAGAIN) {
232		fw_iso_resources_free(&isight->resources);
233		goto retry_after_bus_reset;
234	} else if (err < 0) {
235		goto err_resources;
236	}
237
238	return 0;
239
240err_resources:
241	fw_iso_resources_free(&isight->resources);
242error:
243	return err;
244}
245
246static int isight_open(struct snd_pcm_substream *substream)
247{
248	static const struct snd_pcm_hardware hardware = {
249		.info = SNDRV_PCM_INFO_MMAP |
250			SNDRV_PCM_INFO_MMAP_VALID |
251			SNDRV_PCM_INFO_BATCH |
252			SNDRV_PCM_INFO_INTERLEAVED |
253			SNDRV_PCM_INFO_BLOCK_TRANSFER,
254		.formats = SNDRV_PCM_FMTBIT_S16_BE,
255		.rates = SNDRV_PCM_RATE_48000,
256		.rate_min = 48000,
257		.rate_max = 48000,
258		.channels_min = 2,
259		.channels_max = 2,
260		.buffer_bytes_max = 4 * 1024 * 1024,
261		.period_bytes_min = MAX_FRAMES_PER_PACKET * 4,
262		.period_bytes_max = 1024 * 1024,
263		.periods_min = 2,
264		.periods_max = UINT_MAX,
265	};
266	struct isight *isight = substream->private_data;
267
268	substream->runtime->hw = hardware;
269
270	return iso_packets_buffer_init(&isight->buffer, isight->unit,
271				       QUEUE_LENGTH,
272				       sizeof(struct audio_payload),
273				       DMA_FROM_DEVICE);
274}
275
276static int isight_close(struct snd_pcm_substream *substream)
277{
278	struct isight *isight = substream->private_data;
279
280	iso_packets_buffer_destroy(&isight->buffer, isight->unit);
281
282	return 0;
283}
284
285static int isight_hw_params(struct snd_pcm_substream *substream,
286			    struct snd_pcm_hw_params *hw_params)
287{
288	struct isight *isight = substream->private_data;
289
290	WRITE_ONCE(isight->pcm_active, true);
291
292	return 0;
293}
294
295static int reg_read(struct isight *isight, int offset, __be32 *value)
296{
297	return snd_fw_transaction(isight->unit, TCODE_READ_QUADLET_REQUEST,
298				  isight->audio_base + offset, value, 4, 0);
299}
300
301static int reg_write(struct isight *isight, int offset, __be32 value)
302{
303	return snd_fw_transaction(isight->unit, TCODE_WRITE_QUADLET_REQUEST,
304				  isight->audio_base + offset, &value, 4, 0);
305}
306
307static void isight_stop_streaming(struct isight *isight)
308{
309	__be32 value;
310
311	if (!isight->context)
312		return;
313
314	fw_iso_context_stop(isight->context);
315	fw_iso_context_destroy(isight->context);
316	isight->context = NULL;
317	fw_iso_resources_free(&isight->resources);
318	value = 0;
319	snd_fw_transaction(isight->unit, TCODE_WRITE_QUADLET_REQUEST,
320			   isight->audio_base + REG_AUDIO_ENABLE,
321			   &value, 4, FW_QUIET);
322}
323
324static int isight_hw_free(struct snd_pcm_substream *substream)
325{
326	struct isight *isight = substream->private_data;
327
328	WRITE_ONCE(isight->pcm_active, false);
329
330	guard(mutex)(&isight->mutex);
331	isight_stop_streaming(isight);
332
333	return 0;
334}
335
336static int isight_start_streaming(struct isight *isight)
337{
338	unsigned int i;
339	int err;
340
341	if (isight->context) {
342		if (isight->packet_index < 0)
343			isight_stop_streaming(isight);
344		else
345			return 0;
346	}
347
348	err = reg_write(isight, REG_SAMPLE_RATE, cpu_to_be32(RATE_48000));
349	if (err < 0)
350		goto error;
351
352	err = isight_connect(isight);
353	if (err < 0)
354		goto error;
355
356	err = reg_write(isight, REG_AUDIO_ENABLE, cpu_to_be32(AUDIO_ENABLE));
357	if (err < 0)
358		goto err_resources;
359
360	isight->context = fw_iso_context_create(isight->device->card,
361						FW_ISO_CONTEXT_RECEIVE,
362						isight->resources.channel,
363						isight->device->max_speed,
364						4, isight_packet, isight);
365	if (IS_ERR(isight->context)) {
366		err = PTR_ERR(isight->context);
367		isight->context = NULL;
368		goto err_resources;
369	}
370
371	for (i = 0; i < QUEUE_LENGTH; ++i) {
372		err = fw_iso_context_queue(isight->context, &audio_packet,
373					   &isight->buffer.iso_buffer,
374					   isight->buffer.packets[i].offset);
375		if (err < 0)
376			goto err_context;
377	}
378
379	isight->first_packet = true;
380	isight->packet_index = 0;
381
382	err = fw_iso_context_start(isight->context, -1, 0,
383				   FW_ISO_CONTEXT_MATCH_ALL_TAGS/*?*/);
384	if (err < 0)
385		goto err_context;
386
387	return 0;
388
389err_context:
390	fw_iso_context_destroy(isight->context);
391	isight->context = NULL;
392err_resources:
393	fw_iso_resources_free(&isight->resources);
394	reg_write(isight, REG_AUDIO_ENABLE, 0);
395error:
396	return err;
397}
398
399static int isight_prepare(struct snd_pcm_substream *substream)
400{
401	struct isight *isight = substream->private_data;
402
403	isight->buffer_pointer = 0;
404	isight->period_counter = 0;
405
406	guard(mutex)(&isight->mutex);
407	return isight_start_streaming(isight);
408}
409
410static int isight_trigger(struct snd_pcm_substream *substream, int cmd)
411{
412	struct isight *isight = substream->private_data;
413
414	switch (cmd) {
415	case SNDRV_PCM_TRIGGER_START:
416		WRITE_ONCE(isight->pcm_running, true);
417		break;
418	case SNDRV_PCM_TRIGGER_STOP:
419		WRITE_ONCE(isight->pcm_running, false);
420		break;
421	default:
422		return -EINVAL;
423	}
424	return 0;
425}
426
427static snd_pcm_uframes_t isight_pointer(struct snd_pcm_substream *substream)
428{
429	struct isight *isight = substream->private_data;
430
431	return READ_ONCE(isight->buffer_pointer);
432}
433
434static int isight_create_pcm(struct isight *isight)
435{
436	static const struct snd_pcm_ops ops = {
437		.open      = isight_open,
438		.close     = isight_close,
439		.hw_params = isight_hw_params,
440		.hw_free   = isight_hw_free,
441		.prepare   = isight_prepare,
442		.trigger   = isight_trigger,
443		.pointer   = isight_pointer,
444	};
445	struct snd_pcm *pcm;
446	int err;
447
448	err = snd_pcm_new(isight->card, "iSight", 0, 0, 1, &pcm);
449	if (err < 0)
450		return err;
451	pcm->private_data = isight;
452	pcm->nonatomic = true;
453	strscpy(pcm->name, "iSight");
454	isight->pcm = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
455	isight->pcm->ops = &ops;
456	snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0);
457
458	return 0;
459}
460
461static int isight_gain_info(struct snd_kcontrol *ctl,
462			    struct snd_ctl_elem_info *info)
463{
464	struct isight *isight = ctl->private_data;
465
466	info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
467	info->count = 1;
468	info->value.integer.min = isight->gain_min;
469	info->value.integer.max = isight->gain_max;
470
471	return 0;
472}
473
474static int isight_gain_get(struct snd_kcontrol *ctl,
475			   struct snd_ctl_elem_value *value)
476{
477	struct isight *isight = ctl->private_data;
478	__be32 gain;
479	int err;
480
481	err = reg_read(isight, REG_GAIN, &gain);
482	if (err < 0)
483		return err;
484
485	value->value.integer.value[0] = (s32)be32_to_cpu(gain);
486
487	return 0;
488}
489
490static int isight_gain_put(struct snd_kcontrol *ctl,
491			   struct snd_ctl_elem_value *value)
492{
493	struct isight *isight = ctl->private_data;
494
495	if (value->value.integer.value[0] < isight->gain_min ||
496	    value->value.integer.value[0] > isight->gain_max)
497		return -EINVAL;
498
499	return reg_write(isight, REG_GAIN,
500			 cpu_to_be32(value->value.integer.value[0]));
501}
502
503static int isight_mute_get(struct snd_kcontrol *ctl,
504			   struct snd_ctl_elem_value *value)
505{
506	struct isight *isight = ctl->private_data;
507	__be32 mute;
508	int err;
509
510	err = reg_read(isight, REG_MUTE, &mute);
511	if (err < 0)
512		return err;
513
514	value->value.integer.value[0] = !mute;
515
516	return 0;
517}
518
519static int isight_mute_put(struct snd_kcontrol *ctl,
520			   struct snd_ctl_elem_value *value)
521{
522	struct isight *isight = ctl->private_data;
523
524	return reg_write(isight, REG_MUTE,
525			 (__force __be32)!value->value.integer.value[0]);
526}
527
528static int isight_create_mixer(struct isight *isight)
529{
530	static const struct snd_kcontrol_new gain_control = {
531		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
532		.name = "Mic Capture Volume",
533		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
534			  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
535		.info = isight_gain_info,
536		.get = isight_gain_get,
537		.put = isight_gain_put,
538	};
539	static const struct snd_kcontrol_new mute_control = {
540		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
541		.name = "Mic Capture Switch",
542		.info = snd_ctl_boolean_mono_info,
543		.get = isight_mute_get,
544		.put = isight_mute_put,
545	};
546	__be32 value;
547	struct snd_kcontrol *ctl;
548	int err;
549
550	err = reg_read(isight, REG_GAIN_RAW_START, &value);
551	if (err < 0)
552		return err;
553	isight->gain_min = be32_to_cpu(value);
554
555	err = reg_read(isight, REG_GAIN_RAW_END, &value);
556	if (err < 0)
557		return err;
558	isight->gain_max = be32_to_cpu(value);
559
560	isight->gain_tlv[SNDRV_CTL_TLVO_TYPE] = SNDRV_CTL_TLVT_DB_MINMAX;
561	isight->gain_tlv[SNDRV_CTL_TLVO_LEN] = 2 * sizeof(unsigned int);
562
563	err = reg_read(isight, REG_GAIN_DB_START, &value);
564	if (err < 0)
565		return err;
566	isight->gain_tlv[SNDRV_CTL_TLVO_DB_MINMAX_MIN] =
567						(s32)be32_to_cpu(value) * 100;
568
569	err = reg_read(isight, REG_GAIN_DB_END, &value);
570	if (err < 0)
571		return err;
572	isight->gain_tlv[SNDRV_CTL_TLVO_DB_MINMAX_MAX] =
573						(s32)be32_to_cpu(value) * 100;
574
575	ctl = snd_ctl_new1(&gain_control, isight);
576	if (ctl)
577		ctl->tlv.p = isight->gain_tlv;
578	err = snd_ctl_add(isight->card, ctl);
579	if (err < 0)
580		return err;
581
582	err = snd_ctl_add(isight->card, snd_ctl_new1(&mute_control, isight));
583	if (err < 0)
584		return err;
585
586	return 0;
587}
588
589static void isight_card_free(struct snd_card *card)
590{
591	struct isight *isight = card->private_data;
592
593	fw_iso_resources_destroy(&isight->resources);
594}
595
596static u64 get_unit_base(struct fw_unit *unit)
597{
598	struct fw_csr_iterator i;
599	int key, value;
600
601	fw_csr_iterator_init(&i, unit->directory);
602	while (fw_csr_iterator_next(&i, &key, &value))
603		if (key == CSR_OFFSET)
604			return CSR_REGISTER_BASE + value * 4;
605	return 0;
606}
607
608static int isight_probe(struct fw_unit *unit,
609			const struct ieee1394_device_id *id)
610{
611	struct fw_device *fw_dev = fw_parent_device(unit);
612	struct snd_card *card;
613	struct isight *isight;
614	int err;
615
616	err = snd_card_new(&unit->device, -1, NULL, THIS_MODULE,
617			   sizeof(*isight), &card);
618	if (err < 0)
619		return err;
620
621	isight = card->private_data;
622	isight->card = card;
623	mutex_init(&isight->mutex);
624	isight->unit = fw_unit_get(unit);
625	isight->device = fw_dev;
626	isight->audio_base = get_unit_base(unit);
627	if (!isight->audio_base) {
628		dev_err(&unit->device, "audio unit base not found\n");
629		err = -ENXIO;
630		goto error;
631	}
632	fw_iso_resources_init(&isight->resources, unit);
633
634	card->private_free = isight_card_free;
635
636	strscpy(card->driver, "iSight");
637	strscpy(card->shortname, "Apple iSight");
638	snprintf(card->longname, sizeof(card->longname),
639		 "Apple iSight (GUID %08x%08x) at %s, S%d",
640		 fw_dev->config_rom[3], fw_dev->config_rom[4],
641		 dev_name(&unit->device), 100 << fw_dev->max_speed);
642	strscpy(card->mixername, "iSight");
643
644	err = isight_create_pcm(isight);
645	if (err < 0)
646		goto error;
647
648	err = isight_create_mixer(isight);
649	if (err < 0)
650		goto error;
651
652	err = snd_card_register(card);
653	if (err < 0)
654		goto error;
655
656	dev_set_drvdata(&unit->device, isight);
657
658	return 0;
659error:
660	snd_card_free(card);
661
662	mutex_destroy(&isight->mutex);
663	fw_unit_put(isight->unit);
664
665	return err;
666}
667
668static void isight_bus_reset(struct fw_unit *unit)
669{
670	struct isight *isight = dev_get_drvdata(&unit->device);
671
672	if (fw_iso_resources_update(&isight->resources) < 0) {
673		isight_pcm_abort(isight);
674
675		guard(mutex)(&isight->mutex);
676		isight_stop_streaming(isight);
677	}
678}
679
680static void isight_remove(struct fw_unit *unit)
681{
682	struct isight *isight = dev_get_drvdata(&unit->device);
683
684	isight_pcm_abort(isight);
685
686	snd_card_disconnect(isight->card);
687
688	scoped_guard(mutex, &isight->mutex) {
689		isight_stop_streaming(isight);
690	}
691
692	// Block till all of ALSA character devices are released.
693	snd_card_free(isight->card);
694
695	mutex_destroy(&isight->mutex);
696	fw_unit_put(isight->unit);
697}
698
699static const struct ieee1394_device_id isight_id_table[] = {
700	{
701		.match_flags  = IEEE1394_MATCH_SPECIFIER_ID |
702				IEEE1394_MATCH_VERSION,
703		.specifier_id = OUI_APPLE,
704		.version      = SW_ISIGHT_AUDIO,
705	},
706	{ }
707};
708MODULE_DEVICE_TABLE(ieee1394, isight_id_table);
709
710static struct fw_driver isight_driver = {
711	.driver   = {
712		.owner	= THIS_MODULE,
713		.name	= KBUILD_MODNAME,
714		.bus	= &fw_bus_type,
715	},
716	.probe    = isight_probe,
717	.update   = isight_bus_reset,
718	.remove   = isight_remove,
719	.id_table = isight_id_table,
720};
721
722static int __init alsa_isight_init(void)
723{
724	return driver_register(&isight_driver.driver);
725}
726
727static void __exit alsa_isight_exit(void)
728{
729	driver_unregister(&isight_driver.driver);
730}
731
732module_init(alsa_isight_init);
733module_exit(alsa_isight_exit);