+ &macio_get_pci_dev(i2sdev->macio)->dev,

+ default y

+ If you disable this option, the ALSA's OSS PCM API will not

+ support conversion of channels, formats and rates. It will

+ behave like most of new OSS/Free drivers in 2.4/2.6 kernels.

+ bool "Sound Proc FS Support" if EXPERT

+ depends on PROC_FS

+ default y

+ help

+ Say 'N' to disable Sound proc FS, which may reduce code size about

+ 9KB on x86_64 platform.

+ If unsure say Y.

+ useful information to developers when a problem occurs). On the

+ other side, it makes the ALSA subsystem larger.

+

+ card->sync_irq = -1;

+#include <linux/vmalloc.h>

+static inline gfp_t snd_mem_get_gfp_flags(const struct device *dev,

+ gfp_t default_gfp)

+{

+ if (!dev)

+ return default_gfp;

+ else

+ return (__force gfp_t)(unsigned long)dev;

+}

+ gfp_t gfp;

+

+ gfp = snd_mem_get_gfp_flags(device, GFP_KERNEL);

+ dmab->area = alloc_pages_exact(size, gfp);

+ dmab->addr = 0;

+ break;

+ case SNDRV_DMA_TYPE_VMALLOC:

+ gfp = snd_mem_get_gfp_flags(device, GFP_KERNEL | __GFP_HIGHMEM);

+ dmab->area = __vmalloc(size, gfp, PAGE_KERNEL);

+ case SNDRV_DMA_TYPE_VMALLOC:

+ vfree(dmab->area);

+ break;

+ if (frames > dst_channels[0].frames)

+ frames = dst_channels[0].frames;

+ if (frames > dst_channels[0].frames)

+ frames = dst_channels[0].frames;

+ /*

+ * Everything is compatbile except SNDCTL_DSP_MAPINBUF/SNDCTL_DSP_MAPOUTBUF,

+ * which are not implemented for the native case either

+ */

+ if (frames > dst_channels[0].frames)

+ frames = dst_channels[0].frames;

+ if (snd_BUG_ON(!substream))

+ if (PCM_RUNTIME_CHECK(substream))

+ goto _unlock;

+ runtime = substream->runtime;

+

+ _unlock:

+#ifdef CONFIG_SND_DMA_SGBUF

+struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream,

+ unsigned long offset);

+#endif

+

+#define PCM_RUNTIME_CHECK(sub) snd_BUG_ON(!(sub) || !(sub)->runtime)

+

+#include "pcm_local.h"

+static void preallocate_pages(struct snd_pcm_substream *substream,

+ int type, struct device *data,

+ size_t size, size_t max, bool managed)

+ if (snd_BUG_ON(substream->dma_buffer.dev.type))

+ return;

+

+ substream->dma_buffer.dev.type = type;

+ substream->dma_buffer.dev.dev = data;

+ if (max > 0)

+ preallocate_info_init(substream);

+ if (managed)

+ substream->managed_buffer_alloc = 1;

+static void preallocate_pages_for_all(struct snd_pcm *pcm, int type,

+ void *data, size_t size, size_t max,

+ bool managed)

+{

+ struct snd_pcm_substream *substream;

+ int stream;

+

+ for (stream = 0; stream < 2; stream++)

+ for (substream = pcm->streams[stream].substream; substream;

+ substream = substream->next)

+ preallocate_pages(substream, type, data, size, max,

+ managed);

+}

+ preallocate_pages(substream, type, data, size, max, false);

+ preallocate_pages_for_all(pcm, type, data, size, max, false);

+ * snd_pcm_set_managed_buffer - set up buffer management for a substream

+ * @substream: the pcm substream instance

+ * @type: DMA type (SNDRV_DMA_TYPE_*)

+ * @data: DMA type dependent data

+ * @size: the requested pre-allocation size in bytes

+ * @max: the max. allowed pre-allocation size

+ *

+ * Do pre-allocation for the given DMA buffer type, and set the managed

+ * buffer allocation mode to the given substream.

+ * In this mode, PCM core will allocate a buffer automatically before PCM

+ * hw_params ops call, and release the buffer after PCM hw_free ops call

+ * as well, so that the driver doesn't need to invoke the allocation and

+ * the release explicitly in its callback.

+ * When a buffer is actually allocated before the PCM hw_params call, it

+ * turns on the runtime buffer_changed flag for drivers changing their h/w

+ * parameters accordingly.

+ */

+void snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type,

+ struct device *data, size_t size, size_t max)

+{

+ preallocate_pages(substream, type, data, size, max, true);

+}

+EXPORT_SYMBOL(snd_pcm_set_managed_buffer);

+

+/**

+ * snd_pcm_set_managed_buffer_all - set up buffer management for all substreams

+ * for all substreams

+ * @pcm: the pcm instance

+ * @type: DMA type (SNDRV_DMA_TYPE_*)

+ * @data: DMA type dependent data

+ * @size: the requested pre-allocation size in bytes

+ * @max: the max. allowed pre-allocation size

+ *

+ * Do pre-allocation to all substreams of the given pcm for the specified DMA

+ * type and size, and set the managed_buffer_alloc flag to each substream.

+ */

+void snd_pcm_set_managed_buffer_all(struct snd_pcm *pcm, int type,

+ struct device *data,

+ size_t size, size_t max)

+{

+ preallocate_pages_for_all(pcm, type, data, size, max, true);

+}

+EXPORT_SYMBOL(snd_pcm_set_managed_buffer_all);

+

+#ifdef CONFIG_SND_DMA_SGBUF

+/*

+#include <linux/vmalloc.h>

+/* Run PCM ioctl ops */

+static int snd_pcm_ops_ioctl(struct snd_pcm_substream *substream,

+ unsigned cmd, void *arg)

+{

+ if (substream->ops->ioctl)

+ return substream->ops->ioctl(substream, cmd, arg);

+ else

+ return snd_pcm_lib_ioctl(substream, cmd, arg);

+}

+

+ (substream->dma_buffer.dev.type != SNDRV_DMA_TYPE_DEV &&

+ substream->dma_buffer.dev.type != SNDRV_DMA_TYPE_DEV_UC))

+ err = snd_pcm_ops_ioctl(substream,

+ SNDRV_PCM_IOCTL1_FIFO_SIZE,

+ params);

+static void snd_pcm_sync_stop(struct snd_pcm_substream *substream)

+{

+ if (substream->runtime->stop_operating) {

+ substream->runtime->stop_operating = false;

+ if (substream->ops->sync_stop)

+ substream->ops->sync_stop(substream);

+ else if (substream->pcm->card->sync_irq > 0)

+ synchronize_irq(substream->pcm->card->sync_irq);

+ }

+}

+

+ snd_pcm_sync_stop(substream);

+

+ if (substream->managed_buffer_alloc) {

+ err = snd_pcm_lib_malloc_pages(substream,

+ params_buffer_bytes(params));

+ if (err < 0)

+ goto _error;

+ runtime->buffer_changed = err > 0;

+ }

+

+ if (substream->managed_buffer_alloc)

+ snd_pcm_lib_free_pages(substream);

+ snd_pcm_sync_stop(substream);

+ if (substream->managed_buffer_alloc)

+ snd_pcm_lib_free_pages(substream);

+ return snd_pcm_ops_ioctl(substream, SNDRV_PCM_IOCTL1_CHANNEL_INFO, info);

+ runtime->stop_operating = true;

+ snd_pcm_sync_stop(substream);

+ int err = snd_pcm_ops_ioctl(substream, SNDRV_PCM_IOCTL1_RESET, NULL);

+ snd_pcm_sync_stop(substream);

+

+ switch (substream->dma_buffer.dev.type) {

+#ifdef CONFIG_SND_DMA_SGBUF

+ case SNDRV_DMA_TYPE_DEV_SG:

+ case SNDRV_DMA_TYPE_DEV_UC_SG:

+ return snd_pcm_sgbuf_ops_page(substream, ofs);

+#endif /* CONFIG_SND_DMA_SGBUF */

+ case SNDRV_DMA_TYPE_VMALLOC:

+ return vmalloc_to_page(vaddr);

+ default:

+ return virt_to_page(vaddr);

+ }

+ (substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV ||

+ substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV_UC))

+ t = snd_timer_instance_new(str);

+ if (!t)

+ return -ENOMEM;

+ t->callback = snd_seq_timer_interrupt;

+ t->callback_data = q;

+ t->flags |= SNDRV_TIMER_IFLG_AUTO;

+ err = snd_timer_open(t, &tmr->alsa_id, q->queue);

+ err = snd_timer_open(t, &tid, q->queue);

+ snd_timer_instance_free(t);

+ if (t) {

+ snd_timer_instance_free(t);

+ }

+#define MAX_SLAVE_INSTANCES 1000

+static int num_slaves;

+

+struct snd_timer_instance *snd_timer_instance_new(const char *owner)

+

+ return timeri;

+}

+EXPORT_SYMBOL(snd_timer_instance_new);

+

+void snd_timer_instance_free(struct snd_timer_instance *timeri)

+{

+ if (timeri) {

+ if (timeri->private_free)

+ timeri->private_free(timeri);

+EXPORT_SYMBOL(snd_timer_instance_free);

+/* move the slave if it belongs to the master; return 1 if match */

+static int check_matching_master_slave(struct snd_timer_instance *master,

+ struct snd_timer_instance *slave)

+{

+ if (slave->slave_class != master->slave_class ||

+ slave->slave_id != master->slave_id)

+ return 0;

+ if (master->timer->num_instances >= master->timer->max_instances)

+ return -EBUSY;

+ list_move_tail(&slave->open_list, &master->slave_list_head);

+ master->timer->num_instances++;

+ spin_lock_irq(&slave_active_lock);

+ spin_lock(&master->timer->lock);

+ slave->master = master;

+ slave->timer = master->timer;

+ if (slave->flags & SNDRV_TIMER_IFLG_RUNNING)

+ list_add_tail(&slave->active_list, &master->slave_active_head);

+ spin_unlock(&master->timer->lock);

+ spin_unlock_irq(&slave_active_lock);

+ return 1;

+}

+

+ int err = 0;

+ err = check_matching_master_slave(master, slave);

+ if (err != 0) /* match found or error */

+ goto out;

+ out:

+ return err < 0 ? err : 0;

+ int err = 0;

+ err = check_matching_master_slave(master, slave);

+ if (err < 0)

+ break;

+ return err < 0 ? err : 0;

+static void snd_timer_close_locked(struct snd_timer_instance *timeri,

+ struct device **card_devp_to_put);

+int snd_timer_open(struct snd_timer_instance *timeri,

+ struct snd_timer_id *tid,

+ struct device *card_dev_to_put = NULL;

+ if (num_slaves >= MAX_SLAVE_INSTANCES) {

+ err = -EBUSY;

+ num_slaves++;

+ goto list_added;

+ struct snd_timer_instance *t =

+ list_entry(timer->open_list_head.next,

+ if (t->flags & SNDRV_TIMER_IFLG_EXCLUSIVE) {

+ if (!try_module_get(timer->module)) {

+ err = -EBUSY;

+ if (timer->card) {

+ card_dev_to_put = &timer->card->card_dev;

+ }

+ timeri->timer = timer;

+ timeri->slave_class = tid->dev_sclass;

+ timeri->slave_id = slave_id;

+

+list_added:

+ if (err < 0)

+ snd_timer_close_locked(timeri, &card_dev_to_put);

+ /* put_device() is called after unlock for avoiding deadlock */

+ if (err < 0 && card_dev_to_put)

+ put_device(card_dev_to_put);

+static void snd_timer_close_locked(struct snd_timer_instance *timeri,

+ struct device **card_devp_to_put)

+ if (!list_empty(&timeri->open_list)) {

+ list_del_init(&timeri->open_list);

+ if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE)

+ num_slaves--;

+ }

+ timeri->timer = NULL;

+ *card_devp_to_put = &timer->card->card_dev;

+void snd_timer_close(struct snd_timer_instance *timeri)

+ struct device *card_dev_to_put = NULL;

+ return;

+ snd_timer_close_locked(timeri, &card_dev_to_put);

+ /* put_device() is called after unlock for avoiding deadlock */

+ if (card_dev_to_put)

+ put_device(card_dev_to_put);

+ if (tu->timeri) {

+ snd_timer_instance_free(tu->timeri);

+ }

+ snd_timer_instance_free(tu->timeri);

+ tu->timeri = snd_timer_instance_new(str);

+ if (!tu->timeri) {

+ err = -ENOMEM;

+ }

+ err = snd_timer_open(tu->timeri, &tselect.id, current->pid);

+ if (err < 0) {

+ snd_timer_instance_free(tu->timeri);

+ tu->timeri = NULL;

+ }

+

+ tristate

+ select SND_RAWMIDI

+ tristate "Generic loopback driver (PCM)"

+ select SND_PCM

+ select SND_TIMER

+ help

+ Say 'Y' or 'M' to include support for the PCM loopback device.

+ 1->0, where first number is the playback PCM device and second

+ parameter).

+ additional SMPTE Timecode capabilities for the parallel port.

+ will be called snd-mts64.

+#include <sound/timer.h>

+static char *timer_source[SNDRV_CARDS];

+module_param_array(timer_source, charp, NULL, 0444);

+MODULE_PARM_DESC(timer_source, "Sound card name or number and device/subdevice number of timer to be used. Empty string for jiffies timer [default].");

+#define CABLE_VALID_PLAYBACK BIT(SNDRV_PCM_STREAM_PLAYBACK)

+#define CABLE_VALID_CAPTURE BIT(SNDRV_PCM_STREAM_CAPTURE)

+#define CABLE_VALID_BOTH (CABLE_VALID_PLAYBACK | CABLE_VALID_CAPTURE)

+

+struct loopback_cable;

+struct loopback_ops {

+ /* optional

+ * call in loopback->cable_lock

+ */

+ int (*open)(struct loopback_pcm *dpcm);

+ /* required

+ * call in cable->lock

+ */

+ int (*start)(struct loopback_pcm *dpcm);

+ /* required

+ * call in cable->lock

+ */

+ int (*stop)(struct loopback_pcm *dpcm);

+ /* optional */

+ int (*stop_sync)(struct loopback_pcm *dpcm);

+ /* optional */

+ int (*close_substream)(struct loopback_pcm *dpcm);

+ /* optional

+ * call in loopback->cable_lock

+ */

+ int (*close_cable)(struct loopback_pcm *dpcm);

+ /* optional

+ * call in cable->lock

+ */

+ unsigned int (*pos_update)(struct loopback_cable *cable);

+ /* optional */

+ void (*dpcm_info)(struct loopback_pcm *dpcm,

+ struct snd_info_buffer *buffer);

+};

+

+ /* timer specific */

+ struct loopback_ops *ops;

+ /* If sound timer is used */

+ struct {

+ int stream;

+ struct snd_timer_id id;

+ struct tasklet_struct event_tasklet;

+ struct snd_timer_instance *instance;

+ } snd_timer;

+ const char *timer_source;

+ unsigned int irq_pos; /* fractional IRQ position in jiffies

+ * ticks

+ */

+ unsigned int period_size_frac; /* period size in jiffies ticks */

+ /* If jiffies timer is used */

+static int loopback_jiffies_timer_start(struct loopback_pcm *dpcm)

+

+ return 0;

+static int loopback_snd_timer_start(struct loopback_pcm *dpcm)

+{

+ struct loopback_cable *cable = dpcm->cable;

+ int err;

+

+ /* Loopback device has to use same period as timer card. Therefore

+ * wake up for each snd_pcm_period_elapsed() call of timer card.

+ */

+ err = snd_timer_start(cable->snd_timer.instance, 1);

+ if (err < 0) {

+ /* do not report error if trying to start but already

+ * running. For example called by opposite substream

+ * of the same cable

+ */

+ if (err == -EBUSY)

+ return 0;

+

+ pcm_err(dpcm->substream->pcm,

+ "snd_timer_start(%d,%d,%d) failed with %d",

+ cable->snd_timer.id.card,

+ cable->snd_timer.id.device,

+ cable->snd_timer.id.subdevice,

+ err);

+ }

+

+ return err;

+}

+

+/* call in cable->lock */

+static inline int loopback_jiffies_timer_stop(struct loopback_pcm *dpcm)

+

+ return 0;

+}

+

+/* call in cable->lock */

+static int loopback_snd_timer_stop(struct loopback_pcm *dpcm)

+{

+ struct loopback_cable *cable = dpcm->cable;

+ int err;

+

+ /* only stop if both devices (playback and capture) are not running */

+ if (cable->running ^ cable->pause)

+ return 0;

+

+ err = snd_timer_stop(cable->snd_timer.instance);

+ if (err < 0) {

+ pcm_err(dpcm->substream->pcm,

+ "snd_timer_stop(%d,%d,%d) failed with %d",

+ cable->snd_timer.id.card,

+ cable->snd_timer.id.device,

+ cable->snd_timer.id.subdevice,

+ err);

+ }

+

+ return err;

+static inline int loopback_jiffies_timer_stop_sync(struct loopback_pcm *dpcm)

+

+ return 0;

+/* call in loopback->cable_lock */

+static int loopback_snd_timer_close_cable(struct loopback_pcm *dpcm)

+{

+ struct loopback_cable *cable = dpcm->cable;

+

+ /* snd_timer was not opened */

+ if (!cable->snd_timer.instance)

+ return 0;

+

+ /* will only be called from free_cable() when other stream was

+ * already closed. Other stream cannot be reopened as long as

+ * loopback->cable_lock is locked. Therefore no need to lock

+ * cable->lock;

+ */

+ snd_timer_close(cable->snd_timer.instance);

+

+ /* wait till drain tasklet has finished if requested */

+ tasklet_kill(&cable->snd_timer.event_tasklet);

+

+ snd_timer_instance_free(cable->snd_timer.instance);

+ memset(&cable->snd_timer, 0, sizeof(cable->snd_timer));

+

+ return 0;

+}

+ int err = 0, stream = 1 << substream->stream;

+ err = cable->ops->start(dpcm);

+ err = cable->ops->stop(dpcm);

+ err = cable->ops->stop(dpcm);

+ err = cable->ops->start(dpcm);

+ return err;

+

+ if (cable->snd_timer.instance) {

+ cable->hw.period_bytes_min =

+ frames_to_bytes(runtime, runtime->period_size);

+ cable->hw.period_bytes_max = cable->hw.period_bytes_min;

+ }

+

+ int err, bps, salign;

+ if (cable->ops->stop_sync) {

+ err = cable->ops->stop_sync(dpcm);

+ if (err < 0)

+ return err;

+ }

+static unsigned int loopback_jiffies_timer_pos_update

+ (struct loopback_cable *cable)

+static void loopback_jiffies_timer_function(struct timer_list *t)

+ if (loopback_jiffies_timer_pos_update(dpcm->cable) &

+ (1 << dpcm->substream->stream)) {

+ loopback_jiffies_timer_start(dpcm);

+/* call in cable->lock */

+static int loopback_snd_timer_check_resolution(struct snd_pcm_runtime *runtime,

+ unsigned long resolution)

+{

+ if (resolution != runtime->timer_resolution) {

+ struct loopback_pcm *dpcm = runtime->private_data;

+ struct loopback_cable *cable = dpcm->cable;

+ /* Worst case estimation of possible values for resolution

+ * resolution <= (512 * 1024) frames / 8kHz in nsec

+ * resolution <= 65.536.000.000 nsec

+ *

+ * period_size <= 65.536.000.000 nsec / 1000nsec/usec * 192kHz +

+ * 500.000

+ * period_size <= 12.582.912.000.000 <64bit

+ * / 1.000.000 usec/sec

+ */

+ snd_pcm_uframes_t period_size_usec =

+ resolution / 1000 * runtime->rate;

+ /* round to nearest sample rate */

+ snd_pcm_uframes_t period_size =

+ (period_size_usec + 500 * 1000) / (1000 * 1000);

+

+ pcm_err(dpcm->substream->pcm,

+ "Period size (%lu frames) of loopback device is not corresponding to timer resolution (%lu nsec = %lu frames) of card timer %d,%d,%d. Use period size of %lu frames for loopback device.",

+ runtime->period_size, resolution, period_size,

+ cable->snd_timer.id.card,

+ cable->snd_timer.id.device,

+ cable->snd_timer.id.subdevice,

+ period_size);

+ return -EINVAL;

+ }

+ return 0;

+}

+

+static void loopback_snd_timer_period_elapsed(struct loopback_cable *cable,

+ int event,

+ unsigned long resolution)

+{

+ struct loopback_pcm *dpcm_play, *dpcm_capt;

+ struct snd_pcm_substream *substream_play, *substream_capt;

+ struct snd_pcm_runtime *valid_runtime;

+ unsigned int running, elapsed_bytes;

+ unsigned long flags;

+

+ spin_lock_irqsave(&cable->lock, flags);

+ running = cable->running ^ cable->pause;

+ /* no need to do anything if no stream is running */

+ if (!running) {

+ spin_unlock_irqrestore(&cable->lock, flags);

+ return;

+ }

+

+ dpcm_play = cable->streams[SNDRV_PCM_STREAM_PLAYBACK];

+ dpcm_capt = cable->streams[SNDRV_PCM_STREAM_CAPTURE];

+

+ if (event == SNDRV_TIMER_EVENT_MSTOP) {

+ if (!dpcm_play ||

+ dpcm_play->substream->runtime->status->state !=

+ SNDRV_PCM_STATE_DRAINING) {

+ spin_unlock_irqrestore(&cable->lock, flags);

+ return;

+ }

+ }

+

+ substream_play = (running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) ?

+ dpcm_play->substream : NULL;

+ substream_capt = (running & (1 << SNDRV_PCM_STREAM_CAPTURE)) ?

+ dpcm_capt->substream : NULL;

+ valid_runtime = (running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) ?

+ dpcm_play->substream->runtime :

+ dpcm_capt->substream->runtime;

+

+ /* resolution is only valid for SNDRV_TIMER_EVENT_TICK events */

+ if (event == SNDRV_TIMER_EVENT_TICK) {

+ /* The hardware rules guarantee that playback and capture period

+ * are the same. Therefore only one device has to be checked

+ * here.

+ */

+ if (loopback_snd_timer_check_resolution(valid_runtime,

+ resolution) < 0) {

+ spin_unlock_irqrestore(&cable->lock, flags);

+ if (substream_play)

+ snd_pcm_stop_xrun(substream_play);

+ if (substream_capt)

+ snd_pcm_stop_xrun(substream_capt);

+ return;

+ }

+ }

+

+ elapsed_bytes = frames_to_bytes(valid_runtime,

+ valid_runtime->period_size);

+ /* The same timer interrupt is used for playback and capture device */

+ if ((running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) &&

+ (running & (1 << SNDRV_PCM_STREAM_CAPTURE))) {

+ copy_play_buf(dpcm_play, dpcm_capt, elapsed_bytes);

+ bytepos_finish(dpcm_play, elapsed_bytes);

+ bytepos_finish(dpcm_capt, elapsed_bytes);

+ } else if (running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) {

+ bytepos_finish(dpcm_play, elapsed_bytes);

+ } else if (running & (1 << SNDRV_PCM_STREAM_CAPTURE)) {

+ clear_capture_buf(dpcm_capt, elapsed_bytes);

+ bytepos_finish(dpcm_capt, elapsed_bytes);

+ }

+ spin_unlock_irqrestore(&cable->lock, flags);

+

+ if (substream_play)

+ snd_pcm_period_elapsed(substream_play);

+ if (substream_capt)

+ snd_pcm_period_elapsed(substream_capt);

+}

+

+static void loopback_snd_timer_function(struct snd_timer_instance *timeri,

+ unsigned long resolution,

+ unsigned long ticks)

+{

+ struct loopback_cable *cable = timeri->callback_data;

+

+ loopback_snd_timer_period_elapsed(cable, SNDRV_TIMER_EVENT_TICK,

+ resolution);

+}

+

+static void loopback_snd_timer_tasklet(unsigned long arg)

+{

+ struct snd_timer_instance *timeri = (struct snd_timer_instance *)arg;

+ struct loopback_cable *cable = timeri->callback_data;

+

+ loopback_snd_timer_period_elapsed(cable, SNDRV_TIMER_EVENT_MSTOP, 0);

+}

+

+static void loopback_snd_timer_event(struct snd_timer_instance *timeri,

+ int event,

+ struct timespec *tstamp,

+ unsigned long resolution)

+{

+ /* Do not lock cable->lock here because timer->lock is already hold.

+ * There are other functions which first lock cable->lock and than

+ * timer->lock e.g.

+ * loopback_trigger()

+ * spin_lock(&cable->lock)

+ * loopback_snd_timer_start()

+ * snd_timer_start()

+ * spin_lock(&timer->lock)

+ * Therefore when using the oposit order of locks here it could result

+ * in a deadlock.

+ */

+

+ if (event == SNDRV_TIMER_EVENT_MSTOP) {

+ struct loopback_cable *cable = timeri->callback_data;

+

+ /* sound card of the timer was stopped. Therefore there will not

+ * be any further timer callbacks. Due to this forward audio

+ * data from here if in draining state. When still in running

+ * state the streaming will be aborted by the usual timeout. It

+ * should not be aborted here because may be the timer sound

+ * card does only a recovery and the timer is back soon.

+ * This tasklet triggers loopback_snd_timer_tasklet()

+ */

+ tasklet_schedule(&cable->snd_timer.event_tasklet);

+ }

+}

+

+static void loopback_jiffies_timer_dpcm_info(struct loopback_pcm *dpcm,

+ struct snd_info_buffer *buffer)

+{

+ snd_iprintf(buffer, " update_pending:\t%u\n",

+ dpcm->period_update_pending);

+ snd_iprintf(buffer, " irq_pos:\t\t%u\n", dpcm->irq_pos);

+ snd_iprintf(buffer, " period_frac:\t%u\n", dpcm->period_size_frac);

+ snd_iprintf(buffer, " last_jiffies:\t%lu (%lu)\n",

+ dpcm->last_jiffies, jiffies);

+ snd_iprintf(buffer, " timer_expires:\t%lu\n", dpcm->timer.expires);

+}

+

+static void loopback_snd_timer_dpcm_info(struct loopback_pcm *dpcm,

+ struct snd_info_buffer *buffer)

+{

+ struct loopback_cable *cable = dpcm->cable;

+

+ snd_iprintf(buffer, " sound timer:\thw:%d,%d,%d\n",

+ cable->snd_timer.id.card,

+ cable->snd_timer.id.device,

+ cable->snd_timer.id.subdevice);

+ snd_iprintf(buffer, " timer open:\t\t%s\n",

+ (cable->snd_timer.stream == SNDRV_PCM_STREAM_CAPTURE) ?

+ "capture" : "playback");

+}

+

+ if (dpcm->cable->ops->pos_update)

+ dpcm->cable->ops->pos_update(dpcm->cable);

+ return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));

+ return snd_pcm_lib_free_pages(substream);

+static int rule_period_bytes(struct snd_pcm_hw_params *params,

+ struct snd_pcm_hw_rule *rule)

+{

+ struct loopback_pcm *dpcm = rule->private;

+ struct loopback_cable *cable = dpcm->cable;

+ struct snd_interval t;

+

+ mutex_lock(&dpcm->loopback->cable_lock);

+ t.min = cable->hw.period_bytes_min;

+ t.max = cable->hw.period_bytes_max;

+ mutex_unlock(&dpcm->loopback->cable_lock);

+ t.openmin = 0;

+ t.openmax = 0;

+ t.integer = 0;

+ return snd_interval_refine(hw_param_interval(params, rule->var), &t);

+}

+

+ struct loopback_pcm *dpcm = substream->runtime->private_data;

+

+ if (cable->ops && cable->ops->close_cable && dpcm)

+ cable->ops->close_cable(dpcm);

+static int loopback_jiffies_timer_open(struct loopback_pcm *dpcm)

+{

+ timer_setup(&dpcm->timer, loopback_jiffies_timer_function, 0);

+

+ return 0;

+}

+

+static struct loopback_ops loopback_jiffies_timer_ops = {

+ .open = loopback_jiffies_timer_open,

+ .start = loopback_jiffies_timer_start,

+ .stop = loopback_jiffies_timer_stop,

+ .stop_sync = loopback_jiffies_timer_stop_sync,

+ .close_substream = loopback_jiffies_timer_stop_sync,

+ .pos_update = loopback_jiffies_timer_pos_update,

+ .dpcm_info = loopback_jiffies_timer_dpcm_info,

+};

+

+static int loopback_parse_timer_id(const char *str,

+ struct snd_timer_id *tid)

+{

+ /* [<pref>:](<card name>|<card idx>)[{.,}<dev idx>[{.,}<subdev idx>]] */

+ const char * const sep_dev = ".,";

+ const char * const sep_pref = ":";

+ const char *name = str;

+ char *sep, save = '\0';

+ int card_idx = 0, dev = 0, subdev = 0;

+ int err;

+

+ sep = strpbrk(str, sep_pref);

+ if (sep)

+ name = sep + 1;

+ sep = strpbrk(name, sep_dev);

+ if (sep) {

+ save = *sep;

+ *sep = '\0';

+ }

+ err = kstrtoint(name, 0, &card_idx);

+ if (err == -EINVAL) {

+ /* Must be the name, not number */

+ for (card_idx = 0; card_idx < snd_ecards_limit; card_idx++) {

+ struct snd_card *card = snd_card_ref(card_idx);

+

+ if (card) {

+ if (!strcmp(card->id, name))

+ err = 0;

+ snd_card_unref(card);

+ }

+ if (!err)

+ break;

+ }

+ }

+ if (sep) {

+ *sep = save;

+ if (!err) {

+ char *sep2, save2 = '\0';

+

+ sep2 = strpbrk(sep + 1, sep_dev);

+ if (sep2) {

+ save2 = *sep2;

+ *sep2 = '\0';

+ }

+ err = kstrtoint(sep + 1, 0, &dev);

+ if (sep2) {

+ *sep2 = save2;

+ if (!err)

+ err = kstrtoint(sep2 + 1, 0, &subdev);

+ }

+ }

+ }

+ if (!err && tid) {

+ tid->card = card_idx;

+ tid->device = dev;

+ tid->subdevice = subdev;

+ }

+ return err;

+}

+

+/* call in loopback->cable_lock */

+static int loopback_snd_timer_open(struct loopback_pcm *dpcm)

+{

+ int err = 0;

+ struct snd_timer_id tid = {

+ .dev_class = SNDRV_TIMER_CLASS_PCM,

+ .dev_sclass = SNDRV_TIMER_SCLASS_APPLICATION,

+ };

+ struct snd_timer_instance *timeri;

+ struct loopback_cable *cable = dpcm->cable;

+

+ /* check if timer was already opened. It is only opened once

+ * per playback and capture subdevice (aka cable).

+ */

+ if (cable->snd_timer.instance)

+ goto exit;

+

+ err = loopback_parse_timer_id(dpcm->loopback->timer_source, &tid);

+ if (err < 0) {

+ pcm_err(dpcm->substream->pcm,

+ "Parsing timer source \'%s\' failed with %d",

+ dpcm->loopback->timer_source, err);

+ goto exit;

+ }

+

+ cable->snd_timer.stream = dpcm->substream->stream;

+ cable->snd_timer.id = tid;

+

+ timeri = snd_timer_instance_new(dpcm->loopback->card->id);

+ if (!timeri) {

+ err = -ENOMEM;

+ goto exit;

+ }

+ /* The callback has to be called from another tasklet. If

+ * SNDRV_TIMER_IFLG_FAST is specified it will be called from the

+ * snd_pcm_period_elapsed() call of the selected sound card.

+ * snd_pcm_period_elapsed() helds snd_pcm_stream_lock_irqsave().

+ * Due to our callback loopback_snd_timer_function() also calls

+ * snd_pcm_period_elapsed() which calls snd_pcm_stream_lock_irqsave().

+ * This would end up in a dead lock.

+ */

+ timeri->flags |= SNDRV_TIMER_IFLG_AUTO;

+ timeri->callback = loopback_snd_timer_function;

+ timeri->callback_data = (void *)cable;

+ timeri->ccallback = loopback_snd_timer_event;

+

+ /* initialise a tasklet used for draining */

+ tasklet_init(&cable->snd_timer.event_tasklet,

+ loopback_snd_timer_tasklet, (unsigned long)timeri);

+

+ /* The mutex loopback->cable_lock is kept locked.

+ * Therefore snd_timer_open() cannot be called a second time

+ * by the other device of the same cable.

+ * Therefore the following issue cannot happen:

+ * [proc1] Call loopback_timer_open() ->

+ * Unlock cable->lock for snd_timer_close/open() call

+ * [proc2] Call loopback_timer_open() -> snd_timer_open(),

+ * snd_timer_start()

+ * [proc1] Call snd_timer_open() and overwrite running timer

+ * instance

+ */

+ err = snd_timer_open(timeri, &cable->snd_timer.id, current->pid);

+ if (err < 0) {

+ pcm_err(dpcm->substream->pcm,

+ "snd_timer_open (%d,%d,%d) failed with %d",

+ cable->snd_timer.id.card,

+ cable->snd_timer.id.device,

+ cable->snd_timer.id.subdevice,

+ err);

+ snd_timer_instance_free(timeri);

+ goto exit;

+ }

+

+ cable->snd_timer.instance = timeri;

+

+exit:

+ return err;

+}

+

+/* stop_sync() is not required for sound timer because it does not need to be

+ * restarted in loopback_prepare() on Xrun recovery

+ */

+static struct loopback_ops loopback_snd_timer_ops = {

+ .open = loopback_snd_timer_open,

+ .start = loopback_snd_timer_start,

+ .stop = loopback_snd_timer_stop,

+ .close_cable = loopback_snd_timer_close_cable,

+ .dpcm_info = loopback_snd_timer_dpcm_info,

+};

+

+ if (loopback->timer_source)

+ cable->ops = &loopback_snd_timer_ops;

+ else

+ cable->ops = &loopback_jiffies_timer_ops;

+ runtime->private_data = dpcm;

+

+ if (cable->ops->open) {

+ err = cable->ops->open(dpcm);

+ if (err < 0)

+ goto unlock;

+ }

+ /* In case of sound timer the period time of both devices of the same

+ * loop has to be the same.

+ * This rule only takes effect if a sound timer was chosen

+ */

+ if (cable->snd_timer.instance) {

+ err = snd_pcm_hw_rule_add(runtime, 0,

+ SNDRV_PCM_HW_PARAM_PERIOD_BYTES,

+ rule_period_bytes, dpcm,

+ SNDRV_PCM_HW_PARAM_PERIOD_BYTES, -1);

+ if (err < 0)

+ goto unlock;

+ }

+

+ /* loopback_runtime_free() has not to be called if kfree(dpcm) was

+ * already called here. Otherwise it will end up with a double free.

+ */

+ int err = 0;

+ if (dpcm->cable->ops->close_substream)

+ err = dpcm->cable->ops->close_substream(dpcm);

+ return err;

+ snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_VMALLOC,

+ NULL, 0, 0);

+ if (dpcm->cable->ops->dpcm_info)

+ dpcm->cable->ops->dpcm_info(dpcm, buffer);

+static int loopback_cable_proc_new(struct loopback *loopback, int cidx)

+static void loopback_set_timer_source(struct loopback *loopback,

+ const char *value)

+{

+ if (loopback->timer_source) {

+ devm_kfree(loopback->card->dev, loopback->timer_source);

+ loopback->timer_source = NULL;

+ }

+ if (value && *value)

+ loopback->timer_source = devm_kstrdup(loopback->card->dev,

+ value, GFP_KERNEL);

+}

+

+static void print_timer_source_info(struct snd_info_entry *entry,

+ struct snd_info_buffer *buffer)

+{

+ struct loopback *loopback = entry->private_data;

+

+ mutex_lock(&loopback->cable_lock);

+ snd_iprintf(buffer, "%s\n",

+ loopback->timer_source ? loopback->timer_source : "");

+ mutex_unlock(&loopback->cable_lock);

+}

+

+static void change_timer_source_info(struct snd_info_entry *entry,

+ struct snd_info_buffer *buffer)

+{

+ struct loopback *loopback = entry->private_data;

+ char line[64];

+

+ mutex_lock(&loopback->cable_lock);

+ if (!snd_info_get_line(buffer, line, sizeof(line)))

+ loopback_set_timer_source(loopback, strim(line));

+ mutex_unlock(&loopback->cable_lock);

+}

+

+static int loopback_timer_source_proc_new(struct loopback *loopback)

+{

+ return snd_card_rw_proc_new(loopback->card, "timer_source", loopback,

+ print_timer_source_info,

+ change_timer_source_info);

+}

+

+ loopback_set_timer_source(loopback, timer_source[dev]);

+

+ loopback_cable_proc_new(loopback, 0);

+ loopback_cable_proc_new(loopback, 1);

+ loopback_timer_source_proc_new(loopback);

+ NULL,

+ NULL,

+ NULL,

+ PCSP_BUFFER_SIZE,

+ return snd_pcm_lib_malloc_pages(subs, params_buffer_bytes(hw_params));

+ return snd_pcm_lib_free_pages(subs);

+ snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_VMALLOC,

+ snd_dma_continuous_data(GFP_KERNEL | GFP_DMA32),

+ 0, 0);

+ help

+ To compile this driver as a module, choose M here: the module

+ will be called snd-bebob.

+#include <linux/firewire-constants.h>

+ unsigned int ctx_header_size;

+ unsigned int maximum_usec_per_period;

+ // Linux driver for 1394 OHCI controller voluntarily flushes isoc

+ // context when total size of accumulated context header reaches

+ // PAGE_SIZE. This kicks tasklet for the isoc context and brings

+ // callback in the middle of scheduled interrupts.

+ // Although AMDTP streams in the same domain use the same events per

+ // IRQ, use the largest size of context header between IT/IR contexts.

+ // Here, use the value of context header in IR context is for both

+ // contexts.

+ if (!(s->flags & CIP_NO_HEADER))

+ ctx_header_size = IR_CTX_HEADER_SIZE_CIP;

+ else

+ ctx_header_size = IR_CTX_HEADER_SIZE_NO_CIP;

+ maximum_usec_per_period = USEC_PER_SEC * PAGE_SIZE /

+ CYCLES_PER_SECOND / ctx_header_size;

+

+ // In IEC 61883-6, one isoc packet can transfer events up to the value

+ // of syt interval. This comes from the interval of isoc cycle. As 1394

+ // OHCI controller can generate hardware IRQ per isoc packet, the

+ // interval is 125 usec.

+ // However, there are two ways of transmission in IEC 61883-6; blocking

+ // and non-blocking modes. In blocking mode, the sequence of isoc packet

+ // includes 'empty' or 'NODATA' packets which include no event. In

+ // non-blocking mode, the number of events per packet is variable up to

+ // the syt interval.

+ // Due to the above protocol design, the minimum PCM frames per

+ // interrupt should be double of the value of syt interval, thus it is

+ // 250 usec.

+ 250, maximum_usec_per_period);

+static int queue_packet(struct amdtp_stream *s, struct fw_iso_packet *params,

+ bool sched_irq)

+ params->interrupt = sched_irq;

+ if (++s->packet_index >= s->queue_size)

+ struct fw_iso_packet *params, bool sched_irq)

+ return queue_packet(s, params, sched_irq);

+ return queue_packet(s, params, false);

+// This module queued the same number of isochronous cycle as the size of queue

+// to kip isochronous cycle, therefore it's OK to just increment the cycle by

+// the size of queue for scheduled cycle.

+static inline u32 compute_it_cycle(const __be32 ctx_header_tstamp,

+ unsigned int queue_size)

+ return increment_cycle_count(cycle, queue_size);

+ unsigned int index = (s->packet_index + i) % s->queue_size;

+ unsigned int index = (s->packet_index + i) % s->queue_size;

+ desc->cycle = compute_it_cycle(*ctx_header, s->queue_size);

+static void amdtp_stream_master_callback(struct fw_iso_context *context,

+ u32 tstamp, size_t header_length,

+ void *header, void *private_data);

+

+static void amdtp_stream_master_first_callback(struct fw_iso_context *context,

+ u32 tstamp, size_t header_length,

+ void *header, void *private_data);

+

+ unsigned int events_per_period = s->ctx_data.rx.events_per_period;

+ unsigned int event_count = s->ctx_data.rx.event_count;

+ unsigned int packets;

+ bool is_irq_target;

+ // Calculate the number of packets in buffer and check XRUN.

+ packets = header_length / sizeof(*ctx_header);

+

+ is_irq_target =

+ !!(context->callback.sc == amdtp_stream_master_callback ||

+ context->callback.sc == amdtp_stream_master_first_callback);

+

+ bool sched_irq = false;

+ if (is_irq_target) {

+ event_count += desc->data_blocks;

+ if (event_count >= events_per_period) {

+ event_count -= events_per_period;

+ sched_irq = true;

+ }

+ }

+

+ if (queue_out_packet(s, &template.params, sched_irq) < 0) {

+ s->ctx_data.rx.event_count = event_count;

+ unsigned int packets;

+ // Calculate the number of packets in buffer and check XRUN.

+}

+

+static void amdtp_stream_master_callback(struct fw_iso_context *context,

+ u32 tstamp, size_t header_length,

+ void *header, void *private_data)

+{

+ struct amdtp_domain *d = private_data;

+ struct amdtp_stream *irq_target = d->irq_target;

+ struct amdtp_stream *s;

+

+ out_stream_callback(context, tstamp, header_length, header, irq_target);

+ if (amdtp_streaming_error(irq_target))

+ goto error;

+

+ list_for_each_entry(s, &d->streams, list) {

+ if (s != irq_target && amdtp_stream_running(s)) {

+ fw_iso_context_flush_completions(s->context);

+ if (amdtp_streaming_error(s))

+ goto error;

+ }

+ }

+ return;

+error:

+ if (amdtp_stream_running(irq_target))

+ cancel_stream(irq_target);

+

+ list_for_each_entry(s, &d->streams, list) {

+ if (amdtp_stream_running(s))

+ cancel_stream(s);

+ }

+// this is executed one time.

+ cycle = compute_it_cycle(*ctx_header, s->queue_size);

+static void amdtp_stream_master_first_callback(struct fw_iso_context *context,

+ u32 tstamp, size_t header_length,

+ void *header, void *private_data)

+{

+ struct amdtp_domain *d = private_data;

+ struct amdtp_stream *s = d->irq_target;

+ const __be32 *ctx_header = header;

+

+ s->callbacked = true;

+ wake_up(&s->callback_wait);

+

+ s->start_cycle = compute_it_cycle(*ctx_header, s->queue_size);

+

+ context->callback.sc = amdtp_stream_master_callback;

+

+ context->callback.sc(context, tstamp, header_length, header, d);

+}

+

+ * @d: the AMDTP domain to which the AMDTP stream belongs

+ * @is_irq_target: whether isoc context for the AMDTP stream is used to generate

+ * hardware IRQ.

+ * @start_cycle: the isochronous cycle to start the context. Start immediately

+ * if negative value is given.

+static int amdtp_stream_start(struct amdtp_stream *s, int channel, int speed,

+ struct amdtp_domain *d, bool is_irq_target,

+ int start_cycle)

+ unsigned int events_per_buffer = d->events_per_buffer;

+ unsigned int events_per_period = d->events_per_period;

+ unsigned int idle_irq_interval;

+ fw_iso_callback_t ctx_cb;

+ void *ctx_data;

+ // NOTE: IT context should be used for constant IRQ.

+ if (is_irq_target) {

+ err = -EINVAL;

+ goto err_unlock;

+ }

+

+ // This is a case that AMDTP streams in domain run just for MIDI

+ // substream. Use the number of events equivalent to 10 msec as

+ // interval of hardware IRQ.

+ if (events_per_period == 0)

+ events_per_period = amdtp_rate_table[s->sfc] / 100;

+ if (events_per_buffer == 0)

+ events_per_buffer = events_per_period * 3;

+

+ idle_irq_interval = DIV_ROUND_UP(CYCLES_PER_SECOND * events_per_period,

+ amdtp_rate_table[s->sfc]);

+ s->queue_size = DIV_ROUND_UP(CYCLES_PER_SECOND * events_per_buffer,

+ amdtp_rate_table[s->sfc]);

+

+ err = iso_packets_buffer_init(&s->buffer, s->unit, s->queue_size,

+ if (is_irq_target) {

+ s->ctx_data.rx.events_per_period = events_per_period;

+ s->ctx_data.rx.event_count = 0;

+ ctx_cb = amdtp_stream_master_first_callback;

+ ctx_data = d;

+ } else {

+ ctx_cb = amdtp_stream_first_callback;

+ ctx_data = s;

+ }

+

+ ctx_cb, ctx_data);

+ s->pkt_descs = kcalloc(s->queue_size, sizeof(*s->pkt_descs),

+

+ bool sched_irq = false;

+

+

+ if (is_irq_target) {

+ sched_irq = !((s->packet_index + 1) %

+ idle_irq_interval);

+ }

+

+ err = queue_out_packet(s, &params, sched_irq);

+ err = fw_iso_context_start(s->context, start_cycle, 0, tag);

+ * amdtp_domain_stream_pcm_pointer - get the PCM buffer position

+ * @d: the AMDTP domain.

+unsigned long amdtp_domain_stream_pcm_pointer(struct amdtp_domain *d,

+ struct amdtp_stream *s)

+ struct amdtp_stream *irq_target = d->irq_target;

+

+ if (irq_target && amdtp_stream_running(irq_target)) {

+ // This function is called in software IRQ context of

+ // period_tasklet or process context.

+ //

+ // When the software IRQ context was scheduled by software IRQ

+ // context of IT contexts, queued packets were already handled.

+ // Therefore, no need to flush the queue in buffer furthermore.

+ //

+ // When the process context reach here, some packets will be

+ // already queued in the buffer. These packets should be handled

+ // immediately to keep better granularity of PCM pointer.

+ //

+ // Later, the process context will sometimes schedules software

+ // IRQ context of the period_tasklet. Then, no need to flush the

+ // queue by the same reason as described in the above

+ if (!in_interrupt()) {

+ // Queued packet should be processed without any kernel

+ // preemption to keep latency against bus cycle.

+ preempt_disable();

+ fw_iso_context_flush_completions(irq_target->context);

+ preempt_enable();

+ }

+ }

+EXPORT_SYMBOL_GPL(amdtp_domain_stream_pcm_pointer);

+ * amdtp_domain_stream_pcm_ack - acknowledge queued PCM frames

+ * @d: the AMDTP domain.

+int amdtp_domain_stream_pcm_ack(struct amdtp_domain *d, struct amdtp_stream *s)

+ struct amdtp_stream *irq_target = d->irq_target;

+

+ // Process isochronous packets for recent isochronous cycle to handle

+ // queued PCM frames.

+ if (irq_target && amdtp_stream_running(irq_target)) {

+ // Queued packet should be processed without any kernel

+ // preemption to keep latency against bus cycle.

+ preempt_disable();

+ fw_iso_context_flush_completions(irq_target->context);

+ preempt_enable();

+ }

+EXPORT_SYMBOL_GPL(amdtp_domain_stream_pcm_ack);

+ d->events_per_period = 0;

+

+static int get_current_cycle_time(struct fw_card *fw_card, int *cur_cycle)

+{

+ int generation;

+ int rcode;

+ __be32 reg;

+ u32 data;

+

+ // This is a request to local 1394 OHCI controller and expected to

+ // complete without any event waiting.

+ generation = fw_card->generation;

+ smp_rmb(); // node_id vs. generation.

+ rcode = fw_run_transaction(fw_card, TCODE_READ_QUADLET_REQUEST,

+ fw_card->node_id, generation, SCODE_100,

+ CSR_REGISTER_BASE + CSR_CYCLE_TIME,

+ &reg, sizeof(reg));

+ if (rcode != RCODE_COMPLETE)

+ return -EIO;

+

+ data = be32_to_cpu(reg);

+ *cur_cycle = data >> 12;

+

+ return 0;

+}

+

+ * @ir_delay_cycle: the cycle delay to start all IR contexts.

+int amdtp_domain_start(struct amdtp_domain *d, unsigned int ir_delay_cycle)

+ int cycle;

+ int err;

+ // Select an IT context as IRQ target.

+ if (s->direction == AMDTP_OUT_STREAM)

+ if (!s)

+ return -ENXIO;

+ d->irq_target = s;

+ if (ir_delay_cycle > 0) {

+ struct fw_card *fw_card = fw_parent_device(s->unit)->card;

+

+ err = get_current_cycle_time(fw_card, &cycle);

+ if (err < 0)

+ return err;

+

+ // No need to care overflow in cycle field because of enough

+ // width.

+ cycle += ir_delay_cycle;

+

+ // Round up to sec field.

+ if ((cycle & 0x00001fff) >= CYCLES_PER_SECOND) {

+ unsigned int sec;

+

+ // The sec field can overflow.

+ sec = (cycle & 0xffffe000) >> 13;

+ cycle = (++sec << 13) |

+ ((cycle & 0x00001fff) / CYCLES_PER_SECOND);

+ }

+

+ // In OHCI 1394 specification, lower 2 bits are available for

+ // sec field.

+ cycle &= 0x00007fff;

+ } else {

+ cycle = -1;

+ }

+

+ list_for_each_entry(s, &d->streams, list) {

+ int cycle_match;

+

+ if (s->direction == AMDTP_IN_STREAM) {

+ cycle_match = cycle;

+ } else {

+ // IT context starts immediately.

+ cycle_match = -1;

+ }

+

+ if (s != d->irq_target) {

+ err = amdtp_stream_start(s, s->channel, s->speed, d,

+ false, cycle_match);

+ if (err < 0)

+ goto error;

+ }

+ s = d->irq_target;

+ err = amdtp_stream_start(s, s->channel, s->speed, d, true, -1);

+ if (err < 0)

+ goto error;

+

+ return 0;

+error:

+ list_for_each_entry(s, &d->streams, list)

+ amdtp_stream_stop(s);

+ if (d->irq_target)

+ amdtp_stream_stop(d->irq_target);

+

+ if (s != d->irq_target)

+ amdtp_stream_stop(s);

+

+ d->events_per_period = 0;

+ d->irq_target = NULL;

+ unsigned int queue_size;

+

+ // To generate constant hardware IRQ.

+ unsigned int event_count;

+ unsigned int events_per_period;

+

+ unsigned int events_per_period;

+ unsigned int events_per_buffer;

+

+ struct amdtp_stream *irq_target;

+int amdtp_domain_start(struct amdtp_domain *d, unsigned int ir_delay_cycle);

+static inline int amdtp_domain_set_events_per_period(struct amdtp_domain *d,

+ unsigned int events_per_period,

+ unsigned int events_per_buffer)

+{

+ d->events_per_period = events_per_period;

+ d->events_per_buffer = events_per_buffer;

+

+ return 0;

+}

+

+unsigned long amdtp_domain_stream_pcm_pointer(struct amdtp_domain *d,

+ struct amdtp_stream *s);

+int amdtp_domain_stream_pcm_ack(struct amdtp_domain *d, struct amdtp_stream *s);

+

+int snd_bebob_stream_reserve_duplex(struct snd_bebob *bebob, unsigned int rate,

+ unsigned int frames_per_period,

+ unsigned int frames_per_buffer);

+#define SAFFIREPRO_CLOCK_SOURCE_SELECT_MASK 0x000000ff

+#define SAFFIREPRO_CLOCK_SOURCE_DETECT_MASK 0x0000ff00

+ value &= SAFFIREPRO_CLOCK_SOURCE_SELECT_MASK;

+ err = snd_bebob_stream_reserve_duplex(bebob, 0, 0, 0);

+static int pcm_open(struct snd_pcm_substream *substream)

+ struct amdtp_domain *d = &bebob->domain;

+ return err;

+ mutex_lock(&bebob->mutex);

+

+ // When source of clock is not internal or any stream is reserved for

+ // transmission of PCM frames, the available sampling rate is limited

+ // at current one.

+ (bebob->substreams_counter > 0 && d->events_per_period > 0)) {

+ unsigned int frames_per_period = d->events_per_period;

+ unsigned int frames_per_buffer = d->events_per_buffer;

+ unsigned int sampling_rate;

+

+ mutex_unlock(&bebob->mutex);

+

+ if (frames_per_period > 0) {

+ err = snd_pcm_hw_constraint_minmax(substream->runtime,

+ SNDRV_PCM_HW_PARAM_PERIOD_SIZE,

+ frames_per_period, frames_per_period);

+ if (err < 0) {

+ mutex_unlock(&bebob->mutex);

+ goto err_locked;

+ }

+

+ err = snd_pcm_hw_constraint_minmax(substream->runtime,

+ SNDRV_PCM_HW_PARAM_BUFFER_SIZE,

+ frames_per_buffer, frames_per_buffer);

+ if (err < 0) {

+ mutex_unlock(&bebob->mutex);

+ goto err_locked;

+ }

+ }

+ mutex_unlock(&bebob->mutex);

+

+

+ return 0;

+ err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));

+ unsigned int frames_per_period = params_period_size(hw_params);

+ unsigned int frames_per_buffer = params_buffer_size(hw_params);

+ err = snd_bebob_stream_reserve_duplex(bebob, rate,

+ frames_per_period, frames_per_buffer);

+ return snd_pcm_lib_free_pages(substream);

+static snd_pcm_uframes_t pcm_capture_pointer(struct snd_pcm_substream *sbstrm)

+

+ return amdtp_domain_stream_pcm_pointer(&bebob->domain,

+ &bebob->tx_stream);

+static snd_pcm_uframes_t pcm_playback_pointer(struct snd_pcm_substream *sbstrm)

+

+ return amdtp_domain_stream_pcm_pointer(&bebob->domain,

+ &bebob->rx_stream);

+ return amdtp_domain_stream_pcm_ack(&bebob->domain, &bebob->tx_stream);

+ return amdtp_domain_stream_pcm_ack(&bebob->domain, &bebob->rx_stream);

+ snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_VMALLOC,

+ NULL, 0, 0);

+#define CALLBACK_TIMEOUT 2500

+static int map_data_channels(struct snd_bebob *bebob, struct amdtp_stream *s)

+static void break_both_connections(struct snd_bebob *bebob)

+ // These models seem to be in transition state for a longer time. When

+ // accessing in the state, any transactions is corrupted. In the worst

+ // case, the device is going to reboot.

+ if (bebob->version < 2)

+ msleep(600);

+static int start_stream(struct snd_bebob *bebob, struct amdtp_stream *stream)

+ // channel mapping.

+ return err;

+ err = cmp_connection_establish(conn);

+ if (err < 0)

+ return err;

+

+ return amdtp_domain_add_stream(&bebob->domain, stream,

+ conn->resources.channel, conn->speed);

+int snd_bebob_stream_reserve_duplex(struct snd_bebob *bebob, unsigned int rate,

+ unsigned int frames_per_period,

+ unsigned int frames_per_buffer)

+

+ err = amdtp_domain_set_events_per_period(&bebob->domain,

+ frames_per_period, frames_per_buffer);

+ if (err < 0) {

+ cmp_connection_release(&bebob->out_conn);

+ cmp_connection_release(&bebob->in_conn);

+ return err;

+ }

+ enum snd_bebob_clock_type src;

+ struct amdtp_stream *master, *slave;

+ unsigned int ir_delay_cycle;

+ err = snd_bebob_stream_get_clock_src(bebob, &src);

+ if (src != SND_BEBOB_CLOCK_TYPE_SYT) {

+ master = &bebob->tx_stream;

+ slave = &bebob->rx_stream;

+ } else {

+ master = &bebob->rx_stream;

+ slave = &bebob->tx_stream;

+ }

+

+ err = start_stream(bebob, master);

+ err = start_stream(bebob, slave);

+ // The device postpones start of transmission mostly for 1 sec

+ // after receives packets firstly. For safe, IR context starts

+ // 0.4 sec (=3200 cycles) later to version 1 or 2 firmware,

+ // 2.0 sec (=16000 cycles) for version 3 firmware. This is

+ // within 2.5 sec (=CALLBACK_TIMEOUT).

+ // Furthermore, some devices transfer isoc packets with

+ // discontinuous counter in the beginning of packet streaming.

+ // The delay has an effect to avoid detection of this

+ // discontinuity.

+ if (bebob->version < 2)

+ ir_delay_cycle = 3200;

+ else

+ ir_delay_cycle = 16000;

+ err = amdtp_domain_start(&bebob->domain, ir_delay_cycle);

+ err = snd_dice_stream_reserve_duplex(dice, 0, 0, 0);

+ struct amdtp_domain *d = &dice->domain;

+ return err;

+ mutex_lock(&dice->mutex);

+

+ // When source of clock is not internal or any stream is reserved for

+ // transmission of PCM frames, the available sampling rate is limited

+ // at current one.

+ (dice->substreams_counter > 0 && d->events_per_period > 0)) {

+ unsigned int frames_per_period = d->events_per_period;

+ unsigned int frames_per_buffer = d->events_per_buffer;

+ if (err < 0) {

+ mutex_unlock(&dice->mutex);

+ }

+

+

+ if (frames_per_period > 0) {

+ // For double_pcm_frame quirk.

+ if (rate > 96000) {

+ frames_per_period *= 2;

+ frames_per_buffer *= 2;

+ }

+

+ err = snd_pcm_hw_constraint_minmax(substream->runtime,

+ SNDRV_PCM_HW_PARAM_PERIOD_SIZE,

+ frames_per_period, frames_per_period);

+ if (err < 0) {

+ mutex_unlock(&dice->mutex);

+ goto err_locked;

+ }

+

+ err = snd_pcm_hw_constraint_minmax(substream->runtime,

+ SNDRV_PCM_HW_PARAM_BUFFER_SIZE,

+ frames_per_buffer, frames_per_buffer);

+ if (err < 0) {

+ mutex_unlock(&dice->mutex);

+ goto err_locked;

+ }

+ }

+ mutex_unlock(&dice->mutex);

+

+

+ return 0;

+ err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));

+ unsigned int events_per_period = params_period_size(hw_params);

+ unsigned int events_per_buffer = params_buffer_size(hw_params);

+ // For double_pcm_frame quirk.

+ if (rate > 96000) {

+ events_per_period /= 2;

+ events_per_buffer /= 2;

+ }

+ err = snd_dice_stream_reserve_duplex(dice, rate,

+ events_per_period, events_per_buffer);