[deliverable/linux.git] / sound / firewire / isight.c

/*
 * Apple iSight audio driver
 *
 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
 * Licensed under the terms of the GNU General Public License, version 2.
 */

#include <asm/byteorder.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/firewire.h>
#include <linux/firewire-constants.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/mutex.h>
#include <linux/string.h>
#include <sound/control.h>
#include <sound/core.h>
#include <sound/initval.h>
#include <sound/pcm.h>
#include <sound/tlv.h>
#include "lib.h"
#include "iso-resources.h"
#include "packets-buffer.h"

#define OUI_APPLE		0x000a27
#define MODEL_APPLE_ISIGHT	0x000008
#define SW_ISIGHT_AUDIO		0x000010

#define REG_AUDIO_ENABLE	0x000
#define  AUDIO_ENABLE		0x80000000
#define REG_DEF_AUDIO_GAIN	0x204
#define REG_GAIN_RAW_START	0x210
#define REG_GAIN_RAW_END	0x214
#define REG_GAIN_DB_START	0x218
#define REG_GAIN_DB_END		0x21c
#define REG_SAMPLE_RATE_INQUIRY	0x280
#define REG_ISO_TX_CONFIG	0x300
#define  SPEED_SHIFT		16
#define REG_SAMPLE_RATE		0x400
#define  RATE_48000		0x80000000
#define REG_GAIN		0x500
#define REG_MUTE		0x504

#define MAX_FRAMES_PER_PACKET	475

#define QUEUE_LENGTH		20

struct isight {
	struct snd_card *card;
	struct fw_unit *unit;
	struct fw_device *device;
	u64 audio_base;
	struct fw_address_handler iris_handler;
	struct snd_pcm_substream *pcm;
	struct mutex mutex;
	struct iso_packets_buffer buffer;
	struct fw_iso_resources resources;
	struct fw_iso_context *context;
	bool pcm_active;
	bool pcm_running;
	bool first_packet;
	int packet_index;
	u32 total_samples;
	unsigned int buffer_pointer;
	unsigned int period_counter;
	s32 gain_min, gain_max;
	unsigned int gain_tlv[4];
};

struct audio_payload {
	__be32 sample_count;
	__be32 signature;
	__be32 sample_total;
	__be32 reserved;
	__be16 samples[2 * MAX_FRAMES_PER_PACKET];
};

MODULE_DESCRIPTION("iSight audio driver");
MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
MODULE_LICENSE("GPL v2");

static struct fw_iso_packet audio_packet = {
	.payload_length = sizeof(struct audio_payload),
	.interrupt = 1,
	.header_length = 4,
};

static void isight_update_pointers(struct isight *isight, unsigned int count)
{
	struct snd_pcm_runtime *runtime = isight->pcm->runtime;
	unsigned int ptr;

	smp_wmb(); /* update buffer data before buffer pointer */

	ptr = isight->buffer_pointer;
	ptr += count;
	if (ptr >= runtime->buffer_size)
		ptr -= runtime->buffer_size;
	ACCESS_ONCE(isight->buffer_pointer) = ptr;

	isight->period_counter += count;
	if (isight->period_counter >= runtime->period_size) {
		isight->period_counter -= runtime->period_size;
		snd_pcm_period_elapsed(isight->pcm);
	}
}

static void isight_samples(struct isight *isight,
			   const __be16 *samples, unsigned int count)
{
	struct snd_pcm_runtime *runtime;
	unsigned int count1;

	if (!ACCESS_ONCE(isight->pcm_running))
		return;

	runtime = isight->pcm->runtime;
	if (isight->buffer_pointer + count <= runtime->buffer_size) {
		memcpy(runtime->dma_area + isight->buffer_pointer * 4,
		       samples, count * 4);
	} else {
		count1 = runtime->buffer_size - isight->buffer_pointer;
		memcpy(runtime->dma_area + isight->buffer_pointer * 4,
		       samples, count1 * 4);
		samples += count1 * 2;
		memcpy(runtime->dma_area, samples, (count - count1) * 4);
	}

	isight_update_pointers(isight, count);
}

static void isight_pcm_abort(struct isight *isight)
{
	unsigned long flags;

	if (ACCESS_ONCE(isight->pcm_active)) {
		snd_pcm_stream_lock_irqsave(isight->pcm, flags);
		if (snd_pcm_running(isight->pcm))
			snd_pcm_stop(isight->pcm, SNDRV_PCM_STATE_XRUN);
		snd_pcm_stream_unlock_irqrestore(isight->pcm, flags);
	}
}

static void isight_dropped_samples(struct isight *isight, unsigned int total)
{
	struct snd_pcm_runtime *runtime;
	u32 dropped;
	unsigned int count1;

	if (!ACCESS_ONCE(isight->pcm_running))
		return;

	runtime = isight->pcm->runtime;
	dropped = total - isight->total_samples;
	if (dropped < runtime->buffer_size) {
		if (isight->buffer_pointer + dropped <= runtime->buffer_size) {
			memset(runtime->dma_area + isight->buffer_pointer * 4,
			       0, dropped * 4);
		} else {
			count1 = runtime->buffer_size - isight->buffer_pointer;
			memset(runtime->dma_area + isight->buffer_pointer * 4,
			       0, count1 * 4);
			memset(runtime->dma_area, 0, (dropped - count1) * 4);
		}
		isight_update_pointers(isight, dropped);
	} else {
		isight_pcm_abort(isight);
	}
}

static void isight_packet(struct fw_iso_context *context, u32 cycle,
			  size_t header_length, void *header, void *data)
{
	struct isight *isight = data;
	const struct audio_payload *payload;
	unsigned int index, length, count, total;
	int err;

	if (isight->packet_index < 0)
		return;
	index = isight->packet_index;
	payload = isight->buffer.packets[index].buffer;
	length = be32_to_cpup(header) >> 16;

	if (likely(length >= 16 &&
		   payload->signature == cpu_to_be32(0x73676874/*"sght"*/))) {
		count = be32_to_cpu(payload->sample_count);
		if (likely(count <= (length - 16) / 4)) {
			total = be32_to_cpu(payload->sample_total);
			if (unlikely(total != isight->total_samples)) {
				if (!isight->first_packet)
					isight_dropped_samples(isight, total);
				isight->first_packet = false;
				isight->total_samples = total;
			}

			isight_samples(isight, payload->samples, count);
			isight->total_samples += count;
		}
	}

	err = fw_iso_context_queue(isight->context, &audio_packet,
				   &isight->buffer.iso_buffer,
				   isight->buffer.packets[index].offset);
	if (err < 0) {
		dev_err(&isight->unit->device, "queueing error: %d\n", err);
		isight_pcm_abort(isight);
		isight->packet_index = -1;
		return;
	}
	fw_iso_context_queue_flush(isight->context);

	if (++index >= QUEUE_LENGTH)
		index = 0;
	isight->packet_index = index;
}

static int isight_connect(struct isight *isight)
{
	int ch, err, rcode, errors = 0;
	__be32 value;

retry_after_bus_reset:
	ch = fw_iso_resources_allocate(&isight->resources,
				       sizeof(struct audio_payload),
				       isight->device->max_speed);
	if (ch < 0) {
		err = ch;
		goto error;
	}

	value = cpu_to_be32(ch | (isight->device->max_speed << SPEED_SHIFT));
	for (;;) {
		rcode = fw_run_transaction(
				isight->device->card,
				TCODE_WRITE_QUADLET_REQUEST,
				isight->device->node_id,
				isight->resources.generation,
				isight->device->max_speed,
				isight->audio_base + REG_ISO_TX_CONFIG,
				&value, 4);
		if (rcode == RCODE_COMPLETE) {
			return 0;
		} else if (rcode == RCODE_GENERATION) {
			fw_iso_resources_free(&isight->resources);
			goto retry_after_bus_reset;
		} else if (rcode_is_permanent_error(rcode) || ++errors >= 3) {
			err = -EIO;
			goto err_resources;
		}
		msleep(5);
	}

err_resources:
	fw_iso_resources_free(&isight->resources);
error:
	return err;
}

static int isight_open(struct snd_pcm_substream *substream)
{
	static const struct snd_pcm_hardware hardware = {
		.info = SNDRV_PCM_INFO_MMAP |
			SNDRV_PCM_INFO_MMAP_VALID |
			SNDRV_PCM_INFO_BATCH |
			SNDRV_PCM_INFO_INTERLEAVED |
			SNDRV_PCM_INFO_BLOCK_TRANSFER,
		.formats = SNDRV_PCM_FMTBIT_S16_BE,
		.rates = SNDRV_PCM_RATE_48000,
		.rate_min = 48000,
		.rate_max = 48000,
		.channels_min = 2,
		.channels_max = 2,
		.buffer_bytes_max = 4 * 1024 * 1024,
		.period_bytes_min = MAX_FRAMES_PER_PACKET * 4,
		.period_bytes_max = 1024 * 1024,
		.periods_min = 2,
		.periods_max = UINT_MAX,
	};
	struct isight *isight = substream->private_data;

	substream->runtime->hw = hardware;

	return iso_packets_buffer_init(&isight->buffer, isight->unit,
				       QUEUE_LENGTH,
				       sizeof(struct audio_payload),
				       DMA_FROM_DEVICE);
}

static int isight_close(struct snd_pcm_substream *substream)
{
	struct isight *isight = substream->private_data;

	iso_packets_buffer_destroy(&isight->buffer, isight->unit);

	return 0;
}

static int isight_hw_params(struct snd_pcm_substream *substream,
			    struct snd_pcm_hw_params *hw_params)
{
	struct isight *isight = substream->private_data;
	int err;

	err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
					       params_buffer_bytes(hw_params));
	if (err < 0)
		return err;

	ACCESS_ONCE(isight->pcm_active) = true;

	return 0;
}

static int reg_read(struct isight *isight, int offset, __be32 *value)
{
	return snd_fw_transaction(isight->unit, TCODE_READ_QUADLET_REQUEST,
				  isight->audio_base + offset, value, 4);
}

static int reg_write(struct isight *isight, int offset, __be32 value)
{
	return snd_fw_transaction(isight->unit, TCODE_WRITE_QUADLET_REQUEST,
				  isight->audio_base + offset, &value, 4);
}

static void isight_stop_streaming(struct isight *isight)
{
	if (!isight->context)
		return;

	fw_iso_context_stop(isight->context);
	fw_iso_context_destroy(isight->context);
	isight->context = NULL;
	fw_iso_resources_free(&isight->resources);
	reg_write(isight, REG_AUDIO_ENABLE, 0);
}

static int isight_hw_free(struct snd_pcm_substream *substream)
{
	struct isight *isight = substream->private_data;

	ACCESS_ONCE(isight->pcm_active) = false;

	mutex_lock(&isight->mutex);
	isight_stop_streaming(isight);
	mutex_unlock(&isight->mutex);

	return snd_pcm_lib_free_vmalloc_buffer(substream);
}

static int isight_start_streaming(struct isight *isight)
{
	unsigned int i;
	int err;

	if (isight->context) {
		if (isight->packet_index < 0)
			isight_stop_streaming(isight);
		else
			return 0;
	}

	err = reg_write(isight, REG_SAMPLE_RATE, cpu_to_be32(RATE_48000));
	if (err < 0)
		goto error;

	err = isight_connect(isight);
	if (err < 0)
		goto error;

	err = reg_write(isight, REG_AUDIO_ENABLE, cpu_to_be32(AUDIO_ENABLE));
	if (err < 0)
		goto err_resources;

	isight->context = fw_iso_context_create(isight->device->card,
						FW_ISO_CONTEXT_RECEIVE,
						isight->resources.channel,
						isight->device->max_speed,
						4, isight_packet, isight);
	if (IS_ERR(isight->context)) {
		err = PTR_ERR(isight->context);
		isight->context = NULL;
		goto err_resources;
	}

	for (i = 0; i < QUEUE_LENGTH; ++i) {
		err = fw_iso_context_queue(isight->context, &audio_packet,
					   &isight->buffer.iso_buffer,
					   isight->buffer.packets[i].offset);
		if (err < 0)
			goto err_context;
	}

	isight->first_packet = true;
	isight->packet_index = 0;

	err = fw_iso_context_start(isight->context, -1, 0,
				   FW_ISO_CONTEXT_MATCH_ALL_TAGS/*?*/);
	if (err < 0)
		goto err_context;

	return 0;

err_context:
	fw_iso_context_destroy(isight->context);
	isight->context = NULL;
err_resources:
	fw_iso_resources_free(&isight->resources);
	reg_write(isight, REG_AUDIO_ENABLE, 0);
error:
	return err;
}

static int isight_prepare(struct snd_pcm_substream *substream)
{
	struct isight *isight = substream->private_data;
	int err;

	isight->buffer_pointer = 0;
	isight->period_counter = 0;

	mutex_lock(&isight->mutex);
	err = isight_start_streaming(isight);
	mutex_unlock(&isight->mutex);

	return err;
}

static int isight_trigger(struct snd_pcm_substream *substream, int cmd)
{
	struct isight *isight = substream->private_data;

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
		ACCESS_ONCE(isight->pcm_running) = true;
		break;
	case SNDRV_PCM_TRIGGER_STOP:
		ACCESS_ONCE(isight->pcm_running) = false;
		break;
	default:
		return -EINVAL;
	}
	return 0;
}

static snd_pcm_uframes_t isight_pointer(struct snd_pcm_substream *substream)
{
	struct isight *isight = substream->private_data;

	return ACCESS_ONCE(isight->buffer_pointer);
}

static int isight_create_pcm(struct isight *isight)
{
	static struct snd_pcm_ops ops = {
		.open      = isight_open,
		.close     = isight_close,
		.ioctl     = snd_pcm_lib_ioctl,
		.hw_params = isight_hw_params,
		.hw_free   = isight_hw_free,
		.prepare   = isight_prepare,
		.trigger   = isight_trigger,
		.pointer   = isight_pointer,
		.page      = snd_pcm_lib_get_vmalloc_page,
		.mmap      = snd_pcm_lib_mmap_vmalloc,
	};
	struct snd_pcm *pcm;
	int err;

	err = snd_pcm_new(isight->card, "iSight", 0, 0, 1, &pcm);
	if (err < 0)
		return err;
	pcm->private_data = isight;
	strcpy(pcm->name, "iSight");
	isight->pcm = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
	isight->pcm->ops = &ops;

	return 0;
}

static int isight_gain_info(struct snd_kcontrol *ctl,
			    struct snd_ctl_elem_info *info)
{
	struct isight *isight = ctl->private_data;

	info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	info->count = 1;
	info->value.integer.min = isight->gain_min;
	info->value.integer.max = isight->gain_max;

	return 0;
}

static int isight_gain_get(struct snd_kcontrol *ctl,
			   struct snd_ctl_elem_value *value)
{
	struct isight *isight = ctl->private_data;
	__be32 gain;
	int err;

	err = reg_read(isight, REG_GAIN, &gain);
	if (err < 0)
		return err;

	value->value.integer.value[0] = (s32)be32_to_cpu(gain);

	return 0;
}

static int isight_gain_put(struct snd_kcontrol *ctl,
			   struct snd_ctl_elem_value *value)
{
	struct isight *isight = ctl->private_data;

	if (value->value.integer.value[0] < isight->gain_min ||
	    value->value.integer.value[0] > isight->gain_max)
		return -EINVAL;

	return reg_write(isight, REG_GAIN,
			 cpu_to_be32(value->value.integer.value[0]));
}

static int isight_mute_get(struct snd_kcontrol *ctl,
			   struct snd_ctl_elem_value *value)
{
	struct isight *isight = ctl->private_data;
	__be32 mute;
	int err;

	err = reg_read(isight, REG_MUTE, &mute);
	if (err < 0)
		return err;

	value->value.integer.value[0] = !mute;

	return 0;
}

static int isight_mute_put(struct snd_kcontrol *ctl,
			   struct snd_ctl_elem_value *value)
{
	struct isight *isight = ctl->private_data;

	return reg_write(isight, REG_MUTE,
			 (__force __be32)!value->value.integer.value[0]);
}

static int isight_create_mixer(struct isight *isight)
{
	static const struct snd_kcontrol_new gain_control = {
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = "Mic Capture Volume",
		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
			  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
		.info = isight_gain_info,
		.get = isight_gain_get,
		.put = isight_gain_put,
	};
	static const struct snd_kcontrol_new mute_control = {
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = "Mic Capture Switch",
		.info = snd_ctl_boolean_mono_info,
		.get = isight_mute_get,
		.put = isight_mute_put,
	};
	__be32 value;
	struct snd_kcontrol *ctl;
	int err;

	err = reg_read(isight, REG_GAIN_RAW_START, &value);
	if (err < 0)
		return err;
	isight->gain_min = be32_to_cpu(value);

	err = reg_read(isight, REG_GAIN_RAW_END, &value);
	if (err < 0)
		return err;
	isight->gain_max = be32_to_cpu(value);

	isight->gain_tlv[0] = SNDRV_CTL_TLVT_DB_MINMAX;
	isight->gain_tlv[1] = 2 * sizeof(unsigned int);

	err = reg_read(isight, REG_GAIN_DB_START, &value);
	if (err < 0)
		return err;
	isight->gain_tlv[2] = (s32)be32_to_cpu(value) * 100;

	err = reg_read(isight, REG_GAIN_DB_END, &value);
	if (err < 0)
		return err;
	isight->gain_tlv[3] = (s32)be32_to_cpu(value) * 100;

	ctl = snd_ctl_new1(&gain_control, isight);
	if (ctl)
		ctl->tlv.p = isight->gain_tlv;
	err = snd_ctl_add(isight->card, ctl);
	if (err < 0)
		return err;

	err = snd_ctl_add(isight->card, snd_ctl_new1(&mute_control, isight));
	if (err < 0)
		return err;

	return 0;
}

static void isight_card_free(struct snd_card *card)
{
	struct isight *isight = card->private_data;

	fw_iso_resources_destroy(&isight->resources);
	fw_unit_put(isight->unit);
	fw_device_put(isight->device);
	mutex_destroy(&isight->mutex);
}

static u64 get_unit_base(struct fw_unit *unit)
{
	struct fw_csr_iterator i;
	int key, value;

	fw_csr_iterator_init(&i, unit->directory);
	while (fw_csr_iterator_next(&i, &key, &value))
		if (key == CSR_OFFSET)
			return CSR_REGISTER_BASE + value * 4;
	return 0;
}

static int isight_probe(struct device *unit_dev)
{
	struct fw_unit *unit = fw_unit(unit_dev);
	struct fw_device *fw_dev = fw_parent_device(unit);
	struct snd_card *card;
	struct isight *isight;
	int err;

	err = snd_card_create(-1, NULL, THIS_MODULE, sizeof(*isight), &card);
	if (err < 0)
		return err;
	snd_card_set_dev(card, unit_dev);

	isight = card->private_data;
	isight->card = card;
	mutex_init(&isight->mutex);
	isight->unit = fw_unit_get(unit);
	isight->device = fw_device_get(fw_dev);
	isight->audio_base = get_unit_base(unit);
	if (!isight->audio_base) {
		dev_err(&unit->device, "audio unit base not found\n");
		err = -ENXIO;
		goto err_unit;
	}
	fw_iso_resources_init(&isight->resources, unit);

	card->private_free = isight_card_free;

	strcpy(card->driver, "iSight");
	strcpy(card->shortname, "Apple iSight");
	snprintf(card->longname, sizeof(card->longname),
		 "Apple iSight (GUID %08x%08x) at %s, S%d",
		 fw_dev->config_rom[3], fw_dev->config_rom[4],
		 dev_name(&unit->device), 100 << fw_dev->max_speed);
	strcpy(card->mixername, "iSight");

	err = isight_create_pcm(isight);
	if (err < 0)
		goto error;

	err = isight_create_mixer(isight);
	if (err < 0)
		goto error;

	err = snd_card_register(card);
	if (err < 0)
		goto error;

	dev_set_drvdata(unit_dev, isight);

	return 0;

err_unit:
	fw_unit_put(isight->unit);
	fw_device_put(isight->device);
	mutex_destroy(&isight->mutex);
error:
	snd_card_free(card);
	return err;
}

static int isight_remove(struct device *dev)
{
	struct isight *isight = dev_get_drvdata(dev);

	isight_pcm_abort(isight);

	snd_card_disconnect(isight->card);

	mutex_lock(&isight->mutex);
	isight_stop_streaming(isight);
	mutex_unlock(&isight->mutex);

	snd_card_free_when_closed(isight->card);

	return 0;
}

static void isight_bus_reset(struct fw_unit *unit)
{
	struct isight *isight = dev_get_drvdata(&unit->device);

	if (fw_iso_resources_update(&isight->resources) < 0) {
		isight_pcm_abort(isight);

		mutex_lock(&isight->mutex);
		isight_stop_streaming(isight);
		mutex_unlock(&isight->mutex);
	}
}

static const struct ieee1394_device_id isight_id_table[] = {
	{
		.match_flags  = IEEE1394_MATCH_SPECIFIER_ID |
				IEEE1394_MATCH_VERSION,
		.specifier_id = OUI_APPLE,
		.version      = SW_ISIGHT_AUDIO,
	},
	{ }
};
MODULE_DEVICE_TABLE(ieee1394, isight_id_table);

static struct fw_driver isight_driver = {
	.driver   = {
		.owner	= THIS_MODULE,
		.name	= KBUILD_MODNAME,
		.bus	= &fw_bus_type,
		.probe	= isight_probe,
		.remove	= isight_remove,
	},
	.update   = isight_bus_reset,
	.id_table = isight_id_table,
};

static int __init alsa_isight_init(void)
{
	return driver_register(&isight_driver.driver);
}

static void __exit alsa_isight_exit(void)
{
	driver_unregister(&isight_driver.driver);
}

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