ALSA: firewire: Replace tasklet with work

#define IT_PKT_HEADER_SIZE_CIP		8 // For 2 CIP header.

#define IT_PKT_HEADER_SIZE_NO_CIP	0 // Nothing.

static void pcm_period_tasklet(struct tasklet_struct *t);

static void pcm_period_work(struct work_struct *work);

/**

 * amdtp_stream_init - initialize an AMDTP stream structure

	s->flags = flags;

	s->context = ERR_PTR(-1);

	mutex_init(&s->mutex);

	tasklet_setup(&s->period_tasklet, pcm_period_tasklet);

	INIT_WORK(&s->period_work, pcm_period_work);

	s->packet_index = 0;

	init_waitqueue_head(&s->callback_wait);

	// 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

	// PAGE_SIZE. This kicks work 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.

 */

void amdtp_stream_pcm_prepare(struct amdtp_stream *s)

{

	tasklet_kill(&s->period_tasklet);

	cancel_work_sync(&s->period_work);

	s->pcm_buffer_pointer = 0;

	s->pcm_period_pointer = 0;

}

	s->pcm_period_pointer += frames;

	if (s->pcm_period_pointer >= pcm->runtime->period_size) {

		s->pcm_period_pointer -= pcm->runtime->period_size;

		tasklet_hi_schedule(&s->period_tasklet);

		queue_work(system_highpri_wq, &s->period_work);

	}

}

static void pcm_period_tasklet(struct tasklet_struct *t)

static void pcm_period_work(struct work_struct *work)

{

	struct amdtp_stream *s = from_tasklet(s, t, period_tasklet);

	struct amdtp_stream *s = container_of(work, struct amdtp_stream,

					      period_work);

	struct snd_pcm_substream *pcm = READ_ONCE(s->pcm);

	if (pcm)

static inline void cancel_stream(struct amdtp_stream *s)

{

	s->packet_index = -1;

	if (in_interrupt())

	if (current_work() == &s->period_work)

		amdtp_stream_pcm_abort(s);

	WRITE_ONCE(s->pcm_buffer_pointer, SNDRV_PCM_POS_XRUN);

}

	if (irq_target && amdtp_stream_running(irq_target)) {

		// This function is called in software IRQ context of

		// period_tasklet or process context.

		// period_work or process context.

		//

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

		// context of IT contexts, queued packets were already 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

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

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

		if (!in_interrupt()) {

		if (current_work() != &s->period_work) {

			// Queued packet should be processed without any kernel

			// preemption to keep latency against bus cycle.

			preempt_disable();

		return;

	}

	tasklet_kill(&s->period_tasklet);

	cancel_work_sync(&s->period_work);

	fw_iso_context_stop(s->context);

	fw_iso_context_destroy(s->context);

	s->context = ERR_PTR(-1);

	/* For a PCM substream processing. */

	struct snd_pcm_substream *pcm;

	struct tasklet_struct period_tasklet;

	struct work_struct period_work;

	snd_pcm_uframes_t pcm_buffer_pointer;

	unsigned int pcm_period_pointer;