ALSA: dice: Rename structure and its members

#include "dice-interface.h"

struct dice {

struct snd_dice {

	struct snd_card *card;

	struct fw_unit *unit;

	spinlock_t lock;

	struct completion clock_accepted;

	wait_queue_head_t hwdep_wait;

	u32 notification_bits;

	struct fw_iso_resources resources;

	struct amdtp_stream stream;

	struct fw_iso_resources rx_resources;

	struct amdtp_stream rx_stream;

};

MODULE_DESCRIPTION("DICE driver");

	return ((int)rate_index - 1) / 2;

}

static void dice_lock_changed(struct dice *dice)

static void dice_lock_changed(struct snd_dice *dice)

{

	dice->dev_lock_changed = true;

	wake_up(&dice->hwdep_wait);

}

static int dice_try_lock(struct dice *dice)

static int dice_try_lock(struct snd_dice *dice)

{

	int err;

	return err;

}

static void dice_unlock(struct dice *dice)

static void dice_unlock(struct snd_dice *dice)

{

	spin_lock_irq(&dice->lock);

	spin_unlock_irq(&dice->lock);

}

static inline u64 global_address(struct dice *dice, unsigned int offset)

static inline u64 global_address(struct snd_dice *dice, unsigned int offset)

{

	return DICE_PRIVATE_SPACE + dice->global_offset + offset;

}

/* TODO: rx index */

static inline u64 rx_address(struct dice *dice, unsigned int offset)

static inline u64 rx_address(struct snd_dice *dice, unsigned int offset)

{

	return DICE_PRIVATE_SPACE + dice->rx_offset + offset;

}

static int dice_owner_set(struct dice *dice)

static int dice_owner_set(struct snd_dice *dice)

{

	struct fw_device *device = fw_parent_device(dice->unit);

	__be64 *buffer;

	return err;

}

static int dice_owner_update(struct dice *dice)

static int dice_owner_update(struct snd_dice *dice)

{

	struct fw_device *device = fw_parent_device(dice->unit);

	__be64 *buffer;

	return err;

}

static void dice_owner_clear(struct dice *dice)

static void dice_owner_clear(struct snd_dice *dice)

{

	struct fw_device *device = fw_parent_device(dice->unit);

	__be64 *buffer;

	dice->owner_generation = -1;

}

static int dice_enable_set(struct dice *dice)

static int dice_enable_set(struct snd_dice *dice)

{

	__be32 value;

	int err;

	return 0;

}

static void dice_enable_clear(struct dice *dice)

static void dice_enable_clear(struct snd_dice *dice)

{

	__be32 value;

			      int generation, unsigned long long offset,

			      void *data, size_t length, void *callback_data)

{

	struct dice *dice = callback_data;

	struct snd_dice *dice = callback_data;

	u32 bits;

	unsigned long flags;

static int dice_rate_constraint(struct snd_pcm_hw_params *params,

				struct snd_pcm_hw_rule *rule)

{

	struct dice *dice = rule->private;

	struct snd_dice *dice = rule->private;

	const struct snd_interval *channels =

		hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_CHANNELS);

	struct snd_interval *rate =

static int dice_channels_constraint(struct snd_pcm_hw_params *params,

				    struct snd_pcm_hw_rule *rule)

{

	struct dice *dice = rule->private;

	struct snd_dice *dice = rule->private;

	const struct snd_interval *rate =

		hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_RATE);

	struct snd_interval *channels =

		.periods_min = 1,

		.periods_max = UINT_MAX,

	};

	struct dice *dice = substream->private_data;

	struct snd_dice *dice = substream->private_data;

	struct snd_pcm_runtime *runtime = substream->runtime;

	unsigned int i;

	int err;

	if (err < 0)

		goto err_lock;

	err = amdtp_stream_add_pcm_hw_constraints(&dice->stream, runtime);

	err = amdtp_stream_add_pcm_hw_constraints(&dice->rx_stream, runtime);

	if (err < 0)

		goto err_lock;

static int dice_close(struct snd_pcm_substream *substream)

{

	struct dice *dice = substream->private_data;

	struct snd_dice *dice = substream->private_data;

	dice_unlock(dice);

	return 0;

}

static int dice_stream_start_packets(struct dice *dice)

static int dice_stream_start_packets(struct snd_dice *dice)

{

	int err;

	if (amdtp_stream_running(&dice->stream))

	if (amdtp_stream_running(&dice->rx_stream))

		return 0;

	err = amdtp_stream_start(&dice->stream, dice->resources.channel,

	err = amdtp_stream_start(&dice->rx_stream, dice->rx_resources.channel,

				 fw_parent_device(dice->unit)->max_speed);

	if (err < 0)

		return err;

	err = dice_enable_set(dice);

	if (err < 0) {

		amdtp_stream_stop(&dice->stream);

		amdtp_stream_stop(&dice->rx_stream);

		return err;

	}

	return 0;

}

static int dice_stream_start(struct dice *dice)

static int dice_stream_start(struct snd_dice *dice)

{

	__be32 channel;

	int err;

	if (!dice->resources.allocated) {

		err = fw_iso_resources_allocate(&dice->resources,

				amdtp_stream_get_max_payload(&dice->stream),

	if (!dice->rx_resources.allocated) {

		err = fw_iso_resources_allocate(&dice->rx_resources,

				amdtp_stream_get_max_payload(&dice->rx_stream),

				fw_parent_device(dice->unit)->max_speed);

		if (err < 0)

			goto error;

		channel = cpu_to_be32(dice->resources.channel);

		channel = cpu_to_be32(dice->rx_resources.channel);

		err = snd_fw_transaction(dice->unit,

					 TCODE_WRITE_QUADLET_REQUEST,

					 rx_address(dice, RX_ISOCHRONOUS),

	snd_fw_transaction(dice->unit, TCODE_WRITE_QUADLET_REQUEST,

			   rx_address(dice, RX_ISOCHRONOUS), &channel, 4, 0);

err_resources:

	fw_iso_resources_free(&dice->resources);

	fw_iso_resources_free(&dice->rx_resources);

error:

	return err;

}

static void dice_stream_stop_packets(struct dice *dice)

static void dice_stream_stop_packets(struct snd_dice *dice)

{

	if (amdtp_stream_running(&dice->stream)) {

	if (amdtp_stream_running(&dice->rx_stream)) {

		dice_enable_clear(dice);

		amdtp_stream_stop(&dice->stream);

		amdtp_stream_stop(&dice->rx_stream);

	}

}

static void dice_stream_stop(struct dice *dice)

static void dice_stream_stop(struct snd_dice *dice)

{

	__be32 channel;

	dice_stream_stop_packets(dice);

	if (!dice->resources.allocated)

	if (!dice->rx_resources.allocated)

		return;

	channel = cpu_to_be32((u32)-1);

	snd_fw_transaction(dice->unit, TCODE_WRITE_QUADLET_REQUEST,

			   rx_address(dice, RX_ISOCHRONOUS), &channel, 4, 0);

	fw_iso_resources_free(&dice->resources);

	fw_iso_resources_free(&dice->rx_resources);

}

static int dice_change_rate(struct dice *dice, unsigned int clock_rate)

static int dice_change_rate(struct snd_dice *dice, unsigned int clock_rate)

{

	__be32 value;

	int err;

static int dice_hw_params(struct snd_pcm_substream *substream,

			  struct snd_pcm_hw_params *hw_params)

{

	struct dice *dice = substream->private_data;

	struct snd_dice *dice = substream->private_data;

	unsigned int rate_index, mode, rate, channels, i;

	int err;

		rate /= 2;

		channels *= 2;

		dice->stream.double_pcm_frames = true;

		dice->rx_stream.double_pcm_frames = true;

	} else {

		dice->stream.double_pcm_frames = false;

		dice->rx_stream.double_pcm_frames = false;

	}

	mode = rate_index_to_mode(rate_index);

	amdtp_stream_set_parameters(&dice->stream, rate, channels,

	amdtp_stream_set_parameters(&dice->rx_stream, rate, channels,

				    dice->rx_midi_ports[mode]);

	if (rate_index > 4) {

		channels /= 2;

		for (i = 0; i < channels; i++) {

			dice->stream.pcm_positions[i] = i * 2;

			dice->stream.pcm_positions[i + channels] = i * 2 + 1;

			dice->rx_stream.pcm_positions[i] = i * 2;

			dice->rx_stream.pcm_positions[i + channels] = i * 2 + 1;

		}

	}

	amdtp_stream_set_pcm_format(&dice->stream,

	amdtp_stream_set_pcm_format(&dice->rx_stream,

				    params_format(hw_params));

	return 0;

static int dice_hw_free(struct snd_pcm_substream *substream)

{

	struct dice *dice = substream->private_data;

	struct snd_dice *dice = substream->private_data;

	mutex_lock(&dice->mutex);

	dice_stream_stop(dice);

static int dice_prepare(struct snd_pcm_substream *substream)

{

	struct dice *dice = substream->private_data;

	struct snd_dice *dice = substream->private_data;

	int err;

	mutex_lock(&dice->mutex);

	if (amdtp_streaming_error(&dice->stream))

	if (amdtp_streaming_error(&dice->rx_stream))

		dice_stream_stop_packets(dice);

	err = dice_stream_start(dice);

	mutex_unlock(&dice->mutex);

	amdtp_stream_pcm_prepare(&dice->stream);

	amdtp_stream_pcm_prepare(&dice->rx_stream);

	return 0;

}

static int dice_trigger(struct snd_pcm_substream *substream, int cmd)

{

	struct dice *dice = substream->private_data;

	struct snd_dice *dice = substream->private_data;

	struct snd_pcm_substream *pcm;

	switch (cmd) {

	default:

		return -EINVAL;

	}

	amdtp_stream_pcm_trigger(&dice->stream, pcm);

	amdtp_stream_pcm_trigger(&dice->rx_stream, pcm);

	return 0;

}

static snd_pcm_uframes_t dice_pointer(struct snd_pcm_substream *substream)

{

	struct dice *dice = substream->private_data;

	struct snd_dice *dice = substream->private_data;

	return amdtp_stream_pcm_pointer(&dice->stream);

	return amdtp_stream_pcm_pointer(&dice->rx_stream);

}

static int dice_create_pcm(struct dice *dice)

static int dice_create_pcm(struct snd_dice *dice)

{

	static struct snd_pcm_ops ops = {

		.open      = dice_open,

static long dice_hwdep_read(struct snd_hwdep *hwdep, char __user *buf,

			    long count, loff_t *offset)

{

	struct dice *dice = hwdep->private_data;

	struct snd_dice *dice = hwdep->private_data;

	DEFINE_WAIT(wait);

	union snd_firewire_event event;

static unsigned int dice_hwdep_poll(struct snd_hwdep *hwdep, struct file *file,

				    poll_table *wait)

{

	struct dice *dice = hwdep->private_data;

	struct snd_dice *dice = hwdep->private_data;

	unsigned int events;

	poll_wait(file, &dice->hwdep_wait, wait);

	return events;

}

static int dice_hwdep_get_info(struct dice *dice, void __user *arg)

static int dice_hwdep_get_info(struct snd_dice *dice, void __user *arg)

{

	struct fw_device *dev = fw_parent_device(dice->unit);

	struct snd_firewire_get_info info;

	return 0;

}

static int dice_hwdep_lock(struct dice *dice)

static int dice_hwdep_lock(struct snd_dice *dice)

{

	int err;

	return err;

}

static int dice_hwdep_unlock(struct dice *dice)

static int dice_hwdep_unlock(struct snd_dice *dice)

{

	int err;

static int dice_hwdep_release(struct snd_hwdep *hwdep, struct file *file)

{

	struct dice *dice = hwdep->private_data;

	struct snd_dice *dice = hwdep->private_data;

	spin_lock_irq(&dice->lock);

	if (dice->dev_lock_count == -1)

static int dice_hwdep_ioctl(struct snd_hwdep *hwdep, struct file *file,

			    unsigned int cmd, unsigned long arg)

{

	struct dice *dice = hwdep->private_data;

	struct snd_dice *dice = hwdep->private_data;

	switch (cmd) {

	case SNDRV_FIREWIRE_IOCTL_GET_INFO:

#define dice_hwdep_compat_ioctl NULL

#endif

static int dice_create_hwdep(struct dice *dice)

static int dice_create_hwdep(struct snd_dice *dice)

{

	static const struct snd_hwdep_ops ops = {

		.read         = dice_hwdep_read,

	return 0;

}

static int dice_proc_read_mem(struct dice *dice, void *buffer,

static int dice_proc_read_mem(struct snd_dice *dice, void *buffer,

			      unsigned int offset_q, unsigned int quadlets)

{

	unsigned int i;

{

	if (i < count)

		return strs[i];

	else

	return "(unknown)";

}

		"32000", "44100", "48000", "88200", "96000", "176400", "192000",

		"any low", "any mid", "any high", "none"

	};

	struct dice *dice = entry->private_data;

	struct snd_dice *dice = entry->private_data;

	u32 sections[ARRAY_SIZE(section_names) * 2];

	struct {

		u32 number;

	}

}

static void dice_create_proc(struct dice *dice)

static void dice_create_proc(struct snd_dice *dice)

{

	struct snd_info_entry *entry;

static void dice_card_free(struct snd_card *card)

{

	struct dice *dice = card->private_data;

	struct snd_dice *dice = card->private_data;

	amdtp_stream_destroy(&dice->stream);

	amdtp_stream_destroy(&dice->rx_stream);

	fw_core_remove_address_handler(&dice->notification_handler);

	mutex_destroy(&dice->mutex);

}

	return 0;

}

static int highest_supported_mode_rate(struct dice *dice, unsigned int mode)

static int highest_supported_mode_rate(struct snd_dice *dice, unsigned int mode)

{

	int i;

	return -1;

}

static int dice_read_mode_params(struct dice *dice, unsigned int mode)

static int dice_read_mode_params(struct snd_dice *dice, unsigned int mode)

{

	__be32 values[2];

	int rate_index, err;

	return 0;

}

static int dice_read_params(struct dice *dice)

static int dice_read_params(struct snd_dice *dice)

{

	__be32 pointers[6];

	__be32 value;

	return 0;

}

static void dice_card_strings(struct dice *dice)

static void dice_card_strings(struct snd_dice *dice)

{

	struct snd_card *card = dice->card;

	struct fw_device *dev = fw_parent_device(dice->unit);

static int dice_probe(struct fw_unit *unit, const struct ieee1394_device_id *id)

{

	struct snd_card *card;

	struct dice *dice;

	struct snd_dice *dice;

	__be32 clock_sel;

	int err;

	if (err < 0)

		goto err_owner;

	err = fw_iso_resources_init(&dice->resources, unit);

	err = fw_iso_resources_init(&dice->rx_resources, unit);

	if (err < 0)

		goto err_owner;

	dice->resources.channels_mask = 0x00000000ffffffffuLL;

	dice->rx_resources.channels_mask = 0x00000000ffffffffuLL;

	err = amdtp_stream_init(&dice->stream, unit, AMDTP_OUT_STREAM,

	err = amdtp_stream_init(&dice->rx_stream, unit, AMDTP_OUT_STREAM,

				CIP_BLOCKING);

	if (err < 0)

		goto err_resources;

	return 0;

err_resources:

	fw_iso_resources_destroy(&dice->resources);

	fw_iso_resources_destroy(&dice->rx_resources);

err_owner:

	dice_owner_clear(dice);

err_notification_handler:

static void dice_remove(struct fw_unit *unit)

{

	struct dice *dice = dev_get_drvdata(&unit->device);

	struct snd_dice *dice = dev_get_drvdata(&unit->device);

	amdtp_stream_pcm_abort(&dice->stream);

	amdtp_stream_pcm_abort(&dice->rx_stream);

	snd_card_disconnect(dice->card);

static void dice_bus_reset(struct fw_unit *unit)

{

	struct dice *dice = dev_get_drvdata(&unit->device);

	struct snd_dice *dice = dev_get_drvdata(&unit->device);

	/*

	 * On a bus reset, the DICE firmware disables streaming and then goes

	 * to stop so that the application can restart them in an orderly

	 * manner.

	 */

	amdtp_stream_pcm_abort(&dice->stream);

	amdtp_stream_pcm_abort(&dice->rx_stream);

	mutex_lock(&dice->mutex);

	dice_owner_update(dice);

	fw_iso_resources_update(&dice->resources);

	fw_iso_resources_update(&dice->rx_resources);

	mutex_unlock(&dice->mutex);

}