xref: /linux/sound/aoa/soundbus/i2sbus/pcm.c (revision 05a54fa773284d1a7923cdfdd8f0c8dabb98bd26)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * i2sbus driver -- pcm routines
4  *
5  * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
6  */
7 
8 #include <linux/io.h>
9 #include <linux/delay.h>
10 #include <linux/slab.h>
11 #include <sound/core.h>
12 #include <asm/macio.h>
13 #include <linux/pci.h>
14 #include <linux/module.h>
15 #include "../soundbus.h"
16 #include "i2sbus.h"
17 
18 static inline void get_pcm_info(struct i2sbus_dev *i2sdev, int in,
19 				struct pcm_info **pi, struct pcm_info **other)
20 {
21 	if (in) {
22 		if (pi)
23 			*pi = &i2sdev->in;
24 		if (other)
25 			*other = &i2sdev->out;
26 	} else {
27 		if (pi)
28 			*pi = &i2sdev->out;
29 		if (other)
30 			*other = &i2sdev->in;
31 	}
32 }
33 
34 static int clock_and_divisors(int mclk, int sclk, int rate, int *out)
35 {
36 	/* sclk must be derived from mclk! */
37 	if (mclk % sclk)
38 		return -1;
39 	/* derive sclk register value */
40 	if (i2s_sf_sclkdiv(mclk / sclk, out))
41 		return -1;
42 
43 	if (I2S_CLOCK_SPEED_18MHz % (rate * mclk) == 0) {
44 		if (!i2s_sf_mclkdiv(I2S_CLOCK_SPEED_18MHz / (rate * mclk), out)) {
45 			*out |= I2S_SF_CLOCK_SOURCE_18MHz;
46 			return 0;
47 		}
48 	}
49 	if (I2S_CLOCK_SPEED_45MHz % (rate * mclk) == 0) {
50 		if (!i2s_sf_mclkdiv(I2S_CLOCK_SPEED_45MHz / (rate * mclk), out)) {
51 			*out |= I2S_SF_CLOCK_SOURCE_45MHz;
52 			return 0;
53 		}
54 	}
55 	if (I2S_CLOCK_SPEED_49MHz % (rate * mclk) == 0) {
56 		if (!i2s_sf_mclkdiv(I2S_CLOCK_SPEED_49MHz / (rate * mclk), out)) {
57 			*out |= I2S_SF_CLOCK_SOURCE_49MHz;
58 			return 0;
59 		}
60 	}
61 	return -1;
62 }
63 
64 #define CHECK_RATE(rate)						\
65 	do { if (rates & SNDRV_PCM_RATE_ ##rate) {			\
66 		int dummy;						\
67 		if (clock_and_divisors(sysclock_factor,			\
68 				       bus_factor, rate, &dummy))	\
69 			rates &= ~SNDRV_PCM_RATE_ ##rate;		\
70 	} } while (0)
71 
72 static int i2sbus_pcm_open(struct i2sbus_dev *i2sdev, int in)
73 {
74 	struct pcm_info *pi, *other;
75 	struct soundbus_dev *sdev;
76 	int masks_inited = 0, err;
77 	struct codec_info_item *cii, *rev;
78 	struct snd_pcm_hardware *hw;
79 	u64 formats = 0;
80 	unsigned int rates = 0;
81 	struct transfer_info v;
82 	int bus_factor = 0, sysclock_factor = 0;
83 	int found_this;
84 
85 	guard(mutex)(&i2sdev->lock);
86 
87 	get_pcm_info(i2sdev, in, &pi, &other);
88 
89 	hw = &pi->substream->runtime->hw;
90 	sdev = &i2sdev->sound;
91 
92 	if (pi->active) {
93 		/* alsa messed up */
94 		return -EBUSY;
95 	}
96 
97 	/* we now need to assign the hw */
98 	list_for_each_entry(cii, &sdev->codec_list, list) {
99 		struct transfer_info *ti = cii->codec->transfers;
100 		bus_factor = cii->codec->bus_factor;
101 		sysclock_factor = cii->codec->sysclock_factor;
102 		while (ti->formats && ti->rates) {
103 			v = *ti;
104 			if (ti->transfer_in == in
105 			    && cii->codec->usable(cii, ti, &v)) {
106 				if (masks_inited) {
107 					formats &= v.formats;
108 					rates &= v.rates;
109 				} else {
110 					formats = v.formats;
111 					rates = v.rates;
112 					masks_inited = 1;
113 				}
114 			}
115 			ti++;
116 		}
117 	}
118 	if (!masks_inited || !bus_factor || !sysclock_factor)
119 		return -ENODEV;
120 	/* bus dependent stuff */
121 	hw->info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
122 		   SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_RESUME |
123 		   SNDRV_PCM_INFO_JOINT_DUPLEX;
124 
125 	CHECK_RATE(5512);
126 	CHECK_RATE(8000);
127 	CHECK_RATE(11025);
128 	CHECK_RATE(16000);
129 	CHECK_RATE(22050);
130 	CHECK_RATE(32000);
131 	CHECK_RATE(44100);
132 	CHECK_RATE(48000);
133 	CHECK_RATE(64000);
134 	CHECK_RATE(88200);
135 	CHECK_RATE(96000);
136 	CHECK_RATE(176400);
137 	CHECK_RATE(192000);
138 	hw->rates = rates;
139 
140 	/* well. the codec might want 24 bits only, and we'll
141 	 * ever only transfer 24 bits, but they are top-aligned!
142 	 * So for alsa, we claim that we're doing full 32 bit
143 	 * while in reality we'll ignore the lower 8 bits of
144 	 * that when doing playback (they're transferred as 0
145 	 * as far as I know, no codecs we have are 32-bit capable
146 	 * so I can't really test) and when doing recording we'll
147 	 * always have those lower 8 bits recorded as 0 */
148 	if (formats & SNDRV_PCM_FMTBIT_S24_BE)
149 		formats |= SNDRV_PCM_FMTBIT_S32_BE;
150 	if (formats & SNDRV_PCM_FMTBIT_U24_BE)
151 		formats |= SNDRV_PCM_FMTBIT_U32_BE;
152 	/* now mask off what we can support. I suppose we could
153 	 * also support S24_3LE and some similar formats, but I
154 	 * doubt there's a codec that would be able to use that,
155 	 * so we don't support it here. */
156 	hw->formats = formats & (SNDRV_PCM_FMTBIT_S16_BE |
157 				 SNDRV_PCM_FMTBIT_U16_BE |
158 				 SNDRV_PCM_FMTBIT_S32_BE |
159 				 SNDRV_PCM_FMTBIT_U32_BE);
160 
161 	/* we need to set the highest and lowest rate possible.
162 	 * These are the highest and lowest rates alsa can
163 	 * support properly in its bitfield.
164 	 * Below, we'll use that to restrict to the rate
165 	 * currently in use (if any). */
166 	hw->rate_min = 5512;
167 	hw->rate_max = 192000;
168 	/* if the other stream is active, then we can only
169 	 * support what it is currently using.
170 	 * FIXME: I lied. This comment is wrong. We can support
171 	 * anything that works with the same serial format, ie.
172 	 * when recording 24 bit sound we can well play 16 bit
173 	 * sound at the same time iff using the same transfer mode.
174 	 */
175 	if (other->active) {
176 		/* FIXME: is this guaranteed by the alsa api? */
177 		hw->formats &= pcm_format_to_bits(i2sdev->format);
178 		/* see above, restrict rates to the one we already have */
179 		hw->rate_min = i2sdev->rate;
180 		hw->rate_max = i2sdev->rate;
181 	}
182 
183 	hw->channels_min = 2;
184 	hw->channels_max = 2;
185 	/* these are somewhat arbitrary */
186 	hw->buffer_bytes_max = 131072;
187 	hw->period_bytes_min = 256;
188 	hw->period_bytes_max = 16384;
189 	hw->periods_min = 3;
190 	hw->periods_max = MAX_DBDMA_COMMANDS;
191 	err = snd_pcm_hw_constraint_integer(pi->substream->runtime,
192 					    SNDRV_PCM_HW_PARAM_PERIODS);
193 	if (err < 0)
194 		return err;
195 	list_for_each_entry(cii, &sdev->codec_list, list) {
196 		if (cii->codec->open) {
197 			err = cii->codec->open(cii, pi->substream);
198 			if (err) {
199 				/* unwind */
200 				found_this = 0;
201 				list_for_each_entry_reverse(rev,
202 				    &sdev->codec_list, list) {
203 					if (found_this && rev->codec->close) {
204 						rev->codec->close(rev,
205 								pi->substream);
206 					}
207 					if (rev == cii)
208 						found_this = 1;
209 				}
210 				return err;
211 			}
212 		}
213 	}
214 
215 	return 0;
216 }
217 
218 #undef CHECK_RATE
219 
220 static int i2sbus_pcm_close(struct i2sbus_dev *i2sdev, int in)
221 {
222 	struct codec_info_item *cii;
223 	struct pcm_info *pi;
224 	int err = 0, tmp;
225 
226 	guard(mutex)(&i2sdev->lock);
227 
228 	get_pcm_info(i2sdev, in, &pi, NULL);
229 
230 	list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
231 		if (cii->codec->close) {
232 			tmp = cii->codec->close(cii, pi->substream);
233 			if (tmp)
234 				err = tmp;
235 		}
236 	}
237 
238 	pi->substream = NULL;
239 	pi->active = 0;
240 	return err;
241 }
242 
243 static void i2sbus_wait_for_stop(struct i2sbus_dev *i2sdev,
244 				 struct pcm_info *pi)
245 {
246 	unsigned long flags;
247 	DECLARE_COMPLETION_ONSTACK(done);
248 	unsigned long time_left;
249 
250 	spin_lock_irqsave(&i2sdev->low_lock, flags);
251 	if (pi->dbdma_ring.stopping) {
252 		pi->stop_completion = &done;
253 		spin_unlock_irqrestore(&i2sdev->low_lock, flags);
254 		time_left = wait_for_completion_timeout(&done, HZ);
255 		spin_lock_irqsave(&i2sdev->low_lock, flags);
256 		pi->stop_completion = NULL;
257 		if (time_left == 0) {
258 			/* timeout expired, stop dbdma forcefully */
259 			printk(KERN_ERR "i2sbus_wait_for_stop: timed out\n");
260 			/* make sure RUN, PAUSE and S0 bits are cleared */
261 			out_le32(&pi->dbdma->control, (RUN | PAUSE | 1) << 16);
262 			pi->dbdma_ring.stopping = 0;
263 			time_left = 10;
264 			while (in_le32(&pi->dbdma->status) & ACTIVE) {
265 				if (--time_left <= 0)
266 					break;
267 				udelay(1);
268 			}
269 		}
270 	}
271 	spin_unlock_irqrestore(&i2sdev->low_lock, flags);
272 }
273 
274 #ifdef CONFIG_PM
275 void i2sbus_wait_for_stop_both(struct i2sbus_dev *i2sdev)
276 {
277 	struct pcm_info *pi;
278 
279 	get_pcm_info(i2sdev, 0, &pi, NULL);
280 	i2sbus_wait_for_stop(i2sdev, pi);
281 	get_pcm_info(i2sdev, 1, &pi, NULL);
282 	i2sbus_wait_for_stop(i2sdev, pi);
283 }
284 #endif
285 
286 static inline int i2sbus_hw_free(struct snd_pcm_substream *substream, int in)
287 {
288 	struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
289 	struct pcm_info *pi;
290 
291 	get_pcm_info(i2sdev, in, &pi, NULL);
292 	if (pi->dbdma_ring.stopping)
293 		i2sbus_wait_for_stop(i2sdev, pi);
294 	return 0;
295 }
296 
297 static int i2sbus_playback_hw_free(struct snd_pcm_substream *substream)
298 {
299 	return i2sbus_hw_free(substream, 0);
300 }
301 
302 static int i2sbus_record_hw_free(struct snd_pcm_substream *substream)
303 {
304 	return i2sbus_hw_free(substream, 1);
305 }
306 
307 static int i2sbus_pcm_prepare(struct i2sbus_dev *i2sdev, int in)
308 {
309 	/* whee. Hard work now. The user has selected a bitrate
310 	 * and bit format, so now we have to program our
311 	 * I2S controller appropriately. */
312 	struct snd_pcm_runtime *runtime;
313 	struct dbdma_cmd *command;
314 	int i, periodsize, nperiods;
315 	dma_addr_t offset;
316 	struct bus_info bi;
317 	struct codec_info_item *cii;
318 	int sfr = 0;		/* serial format register */
319 	int dws = 0;		/* data word sizes reg */
320 	int input_16bit;
321 	struct pcm_info *pi, *other;
322 	int cnt;
323 	unsigned int cmd, stopaddr;
324 
325 	guard(mutex)(&i2sdev->lock);
326 
327 	get_pcm_info(i2sdev, in, &pi, &other);
328 
329 	if (pi->dbdma_ring.running)
330 		return -EBUSY;
331 	if (pi->dbdma_ring.stopping)
332 		i2sbus_wait_for_stop(i2sdev, pi);
333 
334 	if (!pi->substream || !pi->substream->runtime)
335 		return -EINVAL;
336 
337 	runtime = pi->substream->runtime;
338 	pi->active = 1;
339 	if (other->active &&
340 	    ((i2sdev->format != runtime->format)
341 	     || (i2sdev->rate != runtime->rate)))
342 		return -EINVAL;
343 
344 	i2sdev->format = runtime->format;
345 	i2sdev->rate = runtime->rate;
346 
347 	periodsize = snd_pcm_lib_period_bytes(pi->substream);
348 	nperiods = pi->substream->runtime->periods;
349 	pi->current_period = 0;
350 
351 	/* generate dbdma command ring first */
352 	command = pi->dbdma_ring.cmds;
353 	memset(command, 0, (nperiods + 2) * sizeof(struct dbdma_cmd));
354 
355 	/* commands to DMA to/from the ring */
356 	/*
357 	 * For input, we need to do a graceful stop; if we abort
358 	 * the DMA, we end up with leftover bytes that corrupt
359 	 * the next recording.  To do this we set the S0 status
360 	 * bit and wait for the DMA controller to stop.  Each
361 	 * command has a branch condition to
362 	 * make it branch to a stop command if S0 is set.
363 	 * On input we also need to wait for the S7 bit to be
364 	 * set before turning off the DMA controller.
365 	 * In fact we do the graceful stop for output as well.
366 	 */
367 	offset = runtime->dma_addr;
368 	cmd = (in? INPUT_MORE: OUTPUT_MORE) | BR_IFSET | INTR_ALWAYS;
369 	stopaddr = pi->dbdma_ring.bus_cmd_start +
370 		(nperiods + 1) * sizeof(struct dbdma_cmd);
371 	for (i = 0; i < nperiods; i++, command++, offset += periodsize) {
372 		command->command = cpu_to_le16(cmd);
373 		command->cmd_dep = cpu_to_le32(stopaddr);
374 		command->phy_addr = cpu_to_le32(offset);
375 		command->req_count = cpu_to_le16(periodsize);
376 	}
377 
378 	/* branch back to beginning of ring */
379 	command->command = cpu_to_le16(DBDMA_NOP | BR_ALWAYS);
380 	command->cmd_dep = cpu_to_le32(pi->dbdma_ring.bus_cmd_start);
381 	command++;
382 
383 	/* set stop command */
384 	command->command = cpu_to_le16(DBDMA_STOP);
385 
386 	/* ok, let's set the serial format and stuff */
387 	switch (runtime->format) {
388 	/* 16 bit formats */
389 	case SNDRV_PCM_FORMAT_S16_BE:
390 	case SNDRV_PCM_FORMAT_U16_BE:
391 		/* FIXME: if we add different bus factors we need to
392 		 * do more here!! */
393 		bi.bus_factor = 0;
394 		list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
395 			bi.bus_factor = cii->codec->bus_factor;
396 			break;
397 		}
398 		if (!bi.bus_factor)
399 			return -ENODEV;
400 		input_16bit = 1;
401 		break;
402 	case SNDRV_PCM_FORMAT_S32_BE:
403 	case SNDRV_PCM_FORMAT_U32_BE:
404 		/* force 64x bus speed, otherwise the data cannot be
405 		 * transferred quickly enough! */
406 		bi.bus_factor = 64;
407 		input_16bit = 0;
408 		break;
409 	default:
410 		return -EINVAL;
411 	}
412 	/* we assume all sysclocks are the same! */
413 	list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
414 		bi.sysclock_factor = cii->codec->sysclock_factor;
415 		break;
416 	}
417 
418 	if (clock_and_divisors(bi.sysclock_factor,
419 			       bi.bus_factor,
420 			       runtime->rate,
421 			       &sfr) < 0)
422 		return -EINVAL;
423 	switch (bi.bus_factor) {
424 	case 32:
425 		sfr |= I2S_SF_SERIAL_FORMAT_I2S_32X;
426 		break;
427 	case 64:
428 		sfr |= I2S_SF_SERIAL_FORMAT_I2S_64X;
429 		break;
430 	}
431 	/* FIXME: THIS ASSUMES MASTER ALL THE TIME */
432 	sfr |= I2S_SF_SCLK_MASTER;
433 
434 	list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
435 		int err = 0;
436 		if (cii->codec->prepare)
437 			err = cii->codec->prepare(cii, &bi, pi->substream);
438 		if (err)
439 			return err;
440 	}
441 	/* codecs are fine with it, so set our clocks */
442 	if (input_16bit)
443 		dws =	(2 << I2S_DWS_NUM_CHANNELS_IN_SHIFT) |
444 			(2 << I2S_DWS_NUM_CHANNELS_OUT_SHIFT) |
445 			I2S_DWS_DATA_IN_16BIT | I2S_DWS_DATA_OUT_16BIT;
446 	else
447 		dws =	(2 << I2S_DWS_NUM_CHANNELS_IN_SHIFT) |
448 			(2 << I2S_DWS_NUM_CHANNELS_OUT_SHIFT) |
449 			I2S_DWS_DATA_IN_24BIT | I2S_DWS_DATA_OUT_24BIT;
450 
451 	/* early exit if already programmed correctly */
452 	/* not locking these is fine since we touch them only in this function */
453 	if (in_le32(&i2sdev->intfregs->serial_format) == sfr
454 	 && in_le32(&i2sdev->intfregs->data_word_sizes) == dws)
455 		return 0;
456 
457 	/* let's notify the codecs about clocks going away.
458 	 * For now we only do mastering on the i2s cell... */
459 	list_for_each_entry(cii, &i2sdev->sound.codec_list, list)
460 		if (cii->codec->switch_clock)
461 			cii->codec->switch_clock(cii, CLOCK_SWITCH_PREPARE_SLAVE);
462 
463 	i2sbus_control_enable(i2sdev->control, i2sdev);
464 	i2sbus_control_cell(i2sdev->control, i2sdev, 1);
465 
466 	out_le32(&i2sdev->intfregs->intr_ctl, I2S_PENDING_CLOCKS_STOPPED);
467 
468 	i2sbus_control_clock(i2sdev->control, i2sdev, 0);
469 
470 	msleep(1);
471 
472 	/* wait for clock stopped. This can apparently take a while... */
473 	cnt = 100;
474 	while (cnt-- &&
475 	    !(in_le32(&i2sdev->intfregs->intr_ctl) & I2S_PENDING_CLOCKS_STOPPED)) {
476 		msleep(5);
477 	}
478 	out_le32(&i2sdev->intfregs->intr_ctl, I2S_PENDING_CLOCKS_STOPPED);
479 
480 	/* not locking these is fine since we touch them only in this function */
481 	out_le32(&i2sdev->intfregs->serial_format, sfr);
482 	out_le32(&i2sdev->intfregs->data_word_sizes, dws);
483 
484         i2sbus_control_enable(i2sdev->control, i2sdev);
485         i2sbus_control_cell(i2sdev->control, i2sdev, 1);
486         i2sbus_control_clock(i2sdev->control, i2sdev, 1);
487 	msleep(1);
488 
489 	list_for_each_entry(cii, &i2sdev->sound.codec_list, list)
490 		if (cii->codec->switch_clock)
491 			cii->codec->switch_clock(cii, CLOCK_SWITCH_SLAVE);
492 
493 	return 0;
494 }
495 
496 #ifdef CONFIG_PM
497 void i2sbus_pcm_prepare_both(struct i2sbus_dev *i2sdev)
498 {
499 	i2sbus_pcm_prepare(i2sdev, 0);
500 	i2sbus_pcm_prepare(i2sdev, 1);
501 }
502 #endif
503 
504 static int i2sbus_pcm_trigger(struct i2sbus_dev *i2sdev, int in, int cmd)
505 {
506 	struct codec_info_item *cii;
507 	struct pcm_info *pi;
508 
509 	guard(spinlock_irqsave)(&i2sdev->low_lock);
510 
511 	get_pcm_info(i2sdev, in, &pi, NULL);
512 
513 	switch (cmd) {
514 	case SNDRV_PCM_TRIGGER_START:
515 	case SNDRV_PCM_TRIGGER_RESUME:
516 		if (pi->dbdma_ring.running)
517 			return -EALREADY;
518 		list_for_each_entry(cii, &i2sdev->sound.codec_list, list)
519 			if (cii->codec->start)
520 				cii->codec->start(cii, pi->substream);
521 		pi->dbdma_ring.running = 1;
522 
523 		if (pi->dbdma_ring.stopping) {
524 			/* Clear the S0 bit, then see if we stopped yet */
525 			out_le32(&pi->dbdma->control, 1 << 16);
526 			if (in_le32(&pi->dbdma->status) & ACTIVE) {
527 				/* possible race here? */
528 				udelay(10);
529 				if (in_le32(&pi->dbdma->status) & ACTIVE) {
530 					pi->dbdma_ring.stopping = 0;
531 					return 0; /* keep running */
532 				}
533 			}
534 		}
535 
536 		/* make sure RUN, PAUSE and S0 bits are cleared */
537 		out_le32(&pi->dbdma->control, (RUN | PAUSE | 1) << 16);
538 
539 		/* set branch condition select register */
540 		out_le32(&pi->dbdma->br_sel, (1 << 16) | 1);
541 
542 		/* write dma command buffer address to the dbdma chip */
543 		out_le32(&pi->dbdma->cmdptr, pi->dbdma_ring.bus_cmd_start);
544 
545 		/* initialize the frame count and current period */
546 		pi->current_period = 0;
547 		pi->frame_count = in_le32(&i2sdev->intfregs->frame_count);
548 
549 		/* set the DMA controller running */
550 		out_le32(&pi->dbdma->control, (RUN << 16) | RUN);
551 
552 		/* off you go! */
553 		break;
554 
555 	case SNDRV_PCM_TRIGGER_STOP:
556 	case SNDRV_PCM_TRIGGER_SUSPEND:
557 		if (!pi->dbdma_ring.running)
558 			return -EALREADY;
559 		pi->dbdma_ring.running = 0;
560 
561 		/* Set the S0 bit to make the DMA branch to the stop cmd */
562 		out_le32(&pi->dbdma->control, (1 << 16) | 1);
563 		pi->dbdma_ring.stopping = 1;
564 
565 		list_for_each_entry(cii, &i2sdev->sound.codec_list, list)
566 			if (cii->codec->stop)
567 				cii->codec->stop(cii, pi->substream);
568 		break;
569 	default:
570 		return -EINVAL;
571 	}
572 
573 	return 0;
574 }
575 
576 static snd_pcm_uframes_t i2sbus_pcm_pointer(struct i2sbus_dev *i2sdev, int in)
577 {
578 	struct pcm_info *pi;
579 	u32 fc;
580 
581 	get_pcm_info(i2sdev, in, &pi, NULL);
582 
583 	fc = in_le32(&i2sdev->intfregs->frame_count);
584 	fc = fc - pi->frame_count;
585 
586 	if (fc >= pi->substream->runtime->buffer_size)
587 		fc %= pi->substream->runtime->buffer_size;
588 	return fc;
589 }
590 
591 static inline void handle_interrupt(struct i2sbus_dev *i2sdev, int in)
592 {
593 	struct pcm_info *pi;
594 	u32 fc, nframes;
595 	u32 status;
596 	int timeout, i;
597 	int dma_stopped = 0;
598 	struct snd_pcm_runtime *runtime;
599 
600 	scoped_guard(spinlock, &i2sdev->low_lock) {
601 		get_pcm_info(i2sdev, in, &pi, NULL);
602 		if (!pi->dbdma_ring.running && !pi->dbdma_ring.stopping)
603 			return;
604 
605 		i = pi->current_period;
606 		runtime = pi->substream->runtime;
607 		while (pi->dbdma_ring.cmds[i].xfer_status) {
608 			if (le16_to_cpu(pi->dbdma_ring.cmds[i].xfer_status) & BT)
609 				/*
610 				 * BT is the branch taken bit.  If it took a branch
611 				 * it is because we set the S0 bit to make it
612 				 * branch to the stop command.
613 				 */
614 				dma_stopped = 1;
615 			pi->dbdma_ring.cmds[i].xfer_status = 0;
616 
617 			if (++i >= runtime->periods) {
618 				i = 0;
619 				pi->frame_count += runtime->buffer_size;
620 			}
621 			pi->current_period = i;
622 
623 			/*
624 			 * Check the frame count.  The DMA tends to get a bit
625 			 * ahead of the frame counter, which confuses the core.
626 			 */
627 			fc = in_le32(&i2sdev->intfregs->frame_count);
628 			nframes = i * runtime->period_size;
629 			if (fc < pi->frame_count + nframes)
630 				pi->frame_count = fc - nframes;
631 		}
632 
633 		if (dma_stopped) {
634 			timeout = 1000;
635 			for (;;) {
636 				status = in_le32(&pi->dbdma->status);
637 				if (!(status & ACTIVE) && (!in || (status & 0x80)))
638 					break;
639 				if (--timeout <= 0) {
640 					printk(KERN_ERR
641 					       "i2sbus: timed out waiting for DMA to stop!\n");
642 					break;
643 				}
644 				udelay(1);
645 			}
646 
647 			/* Turn off DMA controller, clear S0 bit */
648 			out_le32(&pi->dbdma->control, (RUN | PAUSE | 1) << 16);
649 
650 			pi->dbdma_ring.stopping = 0;
651 			if (pi->stop_completion)
652 				complete(pi->stop_completion);
653 		}
654 
655 		if (!pi->dbdma_ring.running)
656 			return;
657 	}
658 
659 	/* may call _trigger again, hence needs to be unlocked */
660 	snd_pcm_period_elapsed(pi->substream);
661 }
662 
663 irqreturn_t i2sbus_tx_intr(int irq, void *devid)
664 {
665 	handle_interrupt((struct i2sbus_dev *)devid, 0);
666 	return IRQ_HANDLED;
667 }
668 
669 irqreturn_t i2sbus_rx_intr(int irq, void *devid)
670 {
671 	handle_interrupt((struct i2sbus_dev *)devid, 1);
672 	return IRQ_HANDLED;
673 }
674 
675 static int i2sbus_playback_open(struct snd_pcm_substream *substream)
676 {
677 	struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
678 
679 	if (!i2sdev)
680 		return -EINVAL;
681 	i2sdev->out.substream = substream;
682 	return i2sbus_pcm_open(i2sdev, 0);
683 }
684 
685 static int i2sbus_playback_close(struct snd_pcm_substream *substream)
686 {
687 	struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
688 	int err;
689 
690 	if (!i2sdev)
691 		return -EINVAL;
692 	if (i2sdev->out.substream != substream)
693 		return -EINVAL;
694 	err = i2sbus_pcm_close(i2sdev, 0);
695 	if (!err)
696 		i2sdev->out.substream = NULL;
697 	return err;
698 }
699 
700 static int i2sbus_playback_prepare(struct snd_pcm_substream *substream)
701 {
702 	struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
703 
704 	if (!i2sdev)
705 		return -EINVAL;
706 	if (i2sdev->out.substream != substream)
707 		return -EINVAL;
708 	return i2sbus_pcm_prepare(i2sdev, 0);
709 }
710 
711 static int i2sbus_playback_trigger(struct snd_pcm_substream *substream, int cmd)
712 {
713 	struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
714 
715 	if (!i2sdev)
716 		return -EINVAL;
717 	if (i2sdev->out.substream != substream)
718 		return -EINVAL;
719 	return i2sbus_pcm_trigger(i2sdev, 0, cmd);
720 }
721 
722 static snd_pcm_uframes_t i2sbus_playback_pointer(struct snd_pcm_substream
723 						 *substream)
724 {
725 	struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
726 
727 	if (!i2sdev)
728 		return -EINVAL;
729 	if (i2sdev->out.substream != substream)
730 		return 0;
731 	return i2sbus_pcm_pointer(i2sdev, 0);
732 }
733 
734 static const struct snd_pcm_ops i2sbus_playback_ops = {
735 	.open =		i2sbus_playback_open,
736 	.close =	i2sbus_playback_close,
737 	.hw_free =	i2sbus_playback_hw_free,
738 	.prepare =	i2sbus_playback_prepare,
739 	.trigger =	i2sbus_playback_trigger,
740 	.pointer =	i2sbus_playback_pointer,
741 };
742 
743 static int i2sbus_record_open(struct snd_pcm_substream *substream)
744 {
745 	struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
746 
747 	if (!i2sdev)
748 		return -EINVAL;
749 	i2sdev->in.substream = substream;
750 	return i2sbus_pcm_open(i2sdev, 1);
751 }
752 
753 static int i2sbus_record_close(struct snd_pcm_substream *substream)
754 {
755 	struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
756 	int err;
757 
758 	if (!i2sdev)
759 		return -EINVAL;
760 	if (i2sdev->in.substream != substream)
761 		return -EINVAL;
762 	err = i2sbus_pcm_close(i2sdev, 1);
763 	if (!err)
764 		i2sdev->in.substream = NULL;
765 	return err;
766 }
767 
768 static int i2sbus_record_prepare(struct snd_pcm_substream *substream)
769 {
770 	struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
771 
772 	if (!i2sdev)
773 		return -EINVAL;
774 	if (i2sdev->in.substream != substream)
775 		return -EINVAL;
776 	return i2sbus_pcm_prepare(i2sdev, 1);
777 }
778 
779 static int i2sbus_record_trigger(struct snd_pcm_substream *substream, int cmd)
780 {
781 	struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
782 
783 	if (!i2sdev)
784 		return -EINVAL;
785 	if (i2sdev->in.substream != substream)
786 		return -EINVAL;
787 	return i2sbus_pcm_trigger(i2sdev, 1, cmd);
788 }
789 
790 static snd_pcm_uframes_t i2sbus_record_pointer(struct snd_pcm_substream
791 					       *substream)
792 {
793 	struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
794 
795 	if (!i2sdev)
796 		return -EINVAL;
797 	if (i2sdev->in.substream != substream)
798 		return 0;
799 	return i2sbus_pcm_pointer(i2sdev, 1);
800 }
801 
802 static const struct snd_pcm_ops i2sbus_record_ops = {
803 	.open =		i2sbus_record_open,
804 	.close =	i2sbus_record_close,
805 	.hw_free =	i2sbus_record_hw_free,
806 	.prepare =	i2sbus_record_prepare,
807 	.trigger =	i2sbus_record_trigger,
808 	.pointer =	i2sbus_record_pointer,
809 };
810 
811 static void i2sbus_private_free(struct snd_pcm *pcm)
812 {
813 	struct i2sbus_dev *i2sdev = snd_pcm_chip(pcm);
814 	struct codec_info_item *p, *tmp;
815 
816 	i2sdev->sound.pcm = NULL;
817 	i2sdev->out.created = 0;
818 	i2sdev->in.created = 0;
819 	list_for_each_entry_safe(p, tmp, &i2sdev->sound.codec_list, list) {
820 		printk(KERN_ERR "i2sbus: a codec didn't unregister!\n");
821 		list_del(&p->list);
822 		module_put(p->codec->owner);
823 		kfree(p);
824 	}
825 	soundbus_dev_put(&i2sdev->sound);
826 	module_put(THIS_MODULE);
827 }
828 
829 int
830 i2sbus_attach_codec(struct soundbus_dev *dev, struct snd_card *card,
831 		    struct codec_info *ci, void *data)
832 {
833 	int err, in = 0, out = 0;
834 	struct transfer_info *tmp;
835 	struct i2sbus_dev *i2sdev = soundbus_dev_to_i2sbus_dev(dev);
836 	struct codec_info_item *cii;
837 
838 	if (!dev->pcmname || dev->pcmid == -1) {
839 		printk(KERN_ERR "i2sbus: pcm name and id must be set!\n");
840 		return -EINVAL;
841 	}
842 
843 	list_for_each_entry(cii, &dev->codec_list, list) {
844 		if (cii->codec_data == data)
845 			return -EALREADY;
846 	}
847 
848 	if (!ci->transfers || !ci->transfers->formats
849 	    || !ci->transfers->rates || !ci->usable)
850 		return -EINVAL;
851 
852 	/* we currently code the i2s transfer on the clock, and support only
853 	 * 32 and 64 */
854 	if (ci->bus_factor != 32 && ci->bus_factor != 64)
855 		return -EINVAL;
856 
857 	/* If you want to fix this, you need to keep track of what transport infos
858 	 * are to be used, which codecs they belong to, and then fix all the
859 	 * sysclock/busclock stuff above to depend on which is usable */
860 	list_for_each_entry(cii, &dev->codec_list, list) {
861 		if (cii->codec->sysclock_factor != ci->sysclock_factor) {
862 			printk(KERN_DEBUG
863 			       "cannot yet handle multiple different sysclocks!\n");
864 			return -EINVAL;
865 		}
866 		if (cii->codec->bus_factor != ci->bus_factor) {
867 			printk(KERN_DEBUG
868 			       "cannot yet handle multiple different bus clocks!\n");
869 			return -EINVAL;
870 		}
871 	}
872 
873 	tmp = ci->transfers;
874 	while (tmp->formats && tmp->rates) {
875 		if (tmp->transfer_in)
876 			in = 1;
877 		else
878 			out = 1;
879 		tmp++;
880 	}
881 
882 	cii = kzalloc(sizeof(struct codec_info_item), GFP_KERNEL);
883 	if (!cii)
884 		return -ENOMEM;
885 
886 	/* use the private data to point to the codec info */
887 	cii->sdev = soundbus_dev_get(dev);
888 	cii->codec = ci;
889 	cii->codec_data = data;
890 
891 	if (!cii->sdev) {
892 		printk(KERN_DEBUG
893 		       "i2sbus: failed to get soundbus dev reference\n");
894 		err = -ENODEV;
895 		goto out_free_cii;
896 	}
897 
898 	if (!try_module_get(THIS_MODULE)) {
899 		printk(KERN_DEBUG "i2sbus: failed to get module reference!\n");
900 		err = -EBUSY;
901 		goto out_put_sdev;
902 	}
903 
904 	if (!try_module_get(ci->owner)) {
905 		printk(KERN_DEBUG
906 		       "i2sbus: failed to get module reference to codec owner!\n");
907 		err = -EBUSY;
908 		goto out_put_this_module;
909 	}
910 
911 	if (!dev->pcm) {
912 		err = snd_pcm_new(card, dev->pcmname, dev->pcmid, 0, 0,
913 				  &dev->pcm);
914 		if (err) {
915 			printk(KERN_DEBUG "i2sbus: failed to create pcm\n");
916 			goto out_put_ci_module;
917 		}
918 	}
919 
920 	/* ALSA yet again sucks.
921 	 * If it is ever fixed, remove this line. See below. */
922 	out = in = 1;
923 
924 	if (!i2sdev->out.created && out) {
925 		if (dev->pcm->card != card) {
926 			/* eh? */
927 			printk(KERN_ERR
928 			       "Can't attach same bus to different cards!\n");
929 			err = -EINVAL;
930 			goto out_put_ci_module;
931 		}
932 		err = snd_pcm_new_stream(dev->pcm, SNDRV_PCM_STREAM_PLAYBACK, 1);
933 		if (err)
934 			goto out_put_ci_module;
935 		snd_pcm_set_ops(dev->pcm, SNDRV_PCM_STREAM_PLAYBACK,
936 				&i2sbus_playback_ops);
937 		dev->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].dev->parent =
938 			&dev->ofdev.dev;
939 		i2sdev->out.created = 1;
940 	}
941 
942 	if (!i2sdev->in.created && in) {
943 		if (dev->pcm->card != card) {
944 			printk(KERN_ERR
945 			       "Can't attach same bus to different cards!\n");
946 			err = -EINVAL;
947 			goto out_put_ci_module;
948 		}
949 		err = snd_pcm_new_stream(dev->pcm, SNDRV_PCM_STREAM_CAPTURE, 1);
950 		if (err)
951 			goto out_put_ci_module;
952 		snd_pcm_set_ops(dev->pcm, SNDRV_PCM_STREAM_CAPTURE,
953 				&i2sbus_record_ops);
954 		dev->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].dev->parent =
955 			&dev->ofdev.dev;
956 		i2sdev->in.created = 1;
957 	}
958 
959 	/* so we have to register the pcm after adding any substream
960 	 * to it because alsa doesn't create the devices for the
961 	 * substreams when we add them later.
962 	 * Therefore, force in and out on both busses (above) and
963 	 * register the pcm now instead of just after creating it.
964 	 */
965 	err = snd_device_register(card, dev->pcm);
966 	if (err) {
967 		printk(KERN_ERR "i2sbus: error registering new pcm\n");
968 		goto out_put_ci_module;
969 	}
970 	/* no errors any more, so let's add this to our list */
971 	list_add(&cii->list, &dev->codec_list);
972 
973 	dev->pcm->private_data = i2sdev;
974 	dev->pcm->private_free = i2sbus_private_free;
975 
976 	/* well, we really should support scatter/gather DMA */
977 	snd_pcm_set_managed_buffer_all(
978 		dev->pcm, SNDRV_DMA_TYPE_DEV,
979 		&macio_get_pci_dev(i2sdev->macio)->dev,
980 		64 * 1024, 64 * 1024);
981 
982 	return 0;
983  out_put_ci_module:
984 	module_put(ci->owner);
985  out_put_this_module:
986 	module_put(THIS_MODULE);
987  out_put_sdev:
988 	soundbus_dev_put(dev);
989  out_free_cii:
990 	kfree(cii);
991 	return err;
992 }
993 
994 void i2sbus_detach_codec(struct soundbus_dev *dev, void *data)
995 {
996 	struct codec_info_item *cii = NULL, *i;
997 
998 	list_for_each_entry(i, &dev->codec_list, list) {
999 		if (i->codec_data == data) {
1000 			cii = i;
1001 			break;
1002 		}
1003 	}
1004 	if (cii) {
1005 		list_del(&cii->list);
1006 		module_put(cii->codec->owner);
1007 		kfree(cii);
1008 	}
1009 	/* no more codecs, but still a pcm? */
1010 	if (list_empty(&dev->codec_list) && dev->pcm) {
1011 		/* the actual cleanup is done by the callback above! */
1012 		snd_device_free(dev->pcm->card, dev->pcm);
1013 	}
1014 }
1015