xref: /openbmc/linux/sound/drivers/vx/vx_pcm.c (revision a5ed0c54)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Driver for Digigram VX soundcards
4  *
5  * PCM part
6  *
7  * Copyright (c) 2002,2003 by Takashi Iwai <tiwai@suse.de>
8  *
9  * STRATEGY
10  *  for playback, we send series of "chunks", which size is equal with the
11  *  IBL size, typically 126 samples.  at each end of chunk, the end-of-buffer
12  *  interrupt is notified, and the interrupt handler will feed the next chunk.
13  *
14  *  the current position is calculated from the sample count RMH.
15  *  pipe->transferred is the counter of data which has been already transferred.
16  *  if this counter reaches to the period size, snd_pcm_period_elapsed() will
17  *  be issued.
18  *
19  *  for capture, the situation is much easier.
20  *  to get a low latency response, we'll check the capture streams at each
21  *  interrupt (capture stream has no EOB notification).  if the pending
22  *  data is accumulated to the period size, snd_pcm_period_elapsed() is
23  *  called and the pointer is updated.
24  *
25  *  the current point of read buffer is kept in pipe->hw_ptr.  note that
26  *  this is in bytes.
27  *
28  * TODO
29  *  - linked trigger for full-duplex mode.
30  *  - scheduled action on the stream.
31  */
32 
33 #include <linux/slab.h>
34 #include <linux/delay.h>
35 #include <sound/core.h>
36 #include <sound/asoundef.h>
37 #include <sound/pcm.h>
38 #include <sound/vx_core.h>
39 #include "vx_cmd.h"
40 
41 
42 /*
43  * read three pending pcm bytes via inb()
44  */
vx_pcm_read_per_bytes(struct vx_core * chip,struct snd_pcm_runtime * runtime,struct vx_pipe * pipe)45 static void vx_pcm_read_per_bytes(struct vx_core *chip, struct snd_pcm_runtime *runtime,
46 				  struct vx_pipe *pipe)
47 {
48 	int offset = pipe->hw_ptr;
49 	unsigned char *buf = (unsigned char *)(runtime->dma_area + offset);
50 	*buf++ = vx_inb(chip, RXH);
51 	if (++offset >= pipe->buffer_bytes) {
52 		offset = 0;
53 		buf = (unsigned char *)runtime->dma_area;
54 	}
55 	*buf++ = vx_inb(chip, RXM);
56 	if (++offset >= pipe->buffer_bytes) {
57 		offset = 0;
58 		buf = (unsigned char *)runtime->dma_area;
59 	}
60 	*buf++ = vx_inb(chip, RXL);
61 	if (++offset >= pipe->buffer_bytes) {
62 		offset = 0;
63 	}
64 	pipe->hw_ptr = offset;
65 }
66 
67 /*
68  * vx_set_pcx_time - convert from the PC time to the RMH status time.
69  * @pc_time: the pointer for the PC-time to set
70  * @dsp_time: the pointer for RMH status time array
71  */
vx_set_pcx_time(struct vx_core * chip,pcx_time_t * pc_time,unsigned int * dsp_time)72 static void vx_set_pcx_time(struct vx_core *chip, pcx_time_t *pc_time,
73 			    unsigned int *dsp_time)
74 {
75 	dsp_time[0] = (unsigned int)((*pc_time) >> 24) & PCX_TIME_HI_MASK;
76 	dsp_time[1] = (unsigned int)(*pc_time) &  MASK_DSP_WORD;
77 }
78 
79 /*
80  * vx_set_differed_time - set the differed time if specified
81  * @rmh: the rmh record to modify
82  * @pipe: the pipe to be checked
83  *
84  * if the pipe is programmed with the differed time, set the DSP time
85  * on the rmh and changes its command length.
86  *
87  * returns the increase of the command length.
88  */
vx_set_differed_time(struct vx_core * chip,struct vx_rmh * rmh,struct vx_pipe * pipe)89 static int vx_set_differed_time(struct vx_core *chip, struct vx_rmh *rmh,
90 				struct vx_pipe *pipe)
91 {
92 	/* Update The length added to the RMH command by the timestamp */
93 	if (! (pipe->differed_type & DC_DIFFERED_DELAY))
94 		return 0;
95 
96 	/* Set the T bit */
97 	rmh->Cmd[0] |= DSP_DIFFERED_COMMAND_MASK;
98 
99 	/* Time stamp is the 1st following parameter */
100 	vx_set_pcx_time(chip, &pipe->pcx_time, &rmh->Cmd[1]);
101 
102 	/* Add the flags to a notified differed command */
103 	if (pipe->differed_type & DC_NOTIFY_DELAY)
104 		rmh->Cmd[1] |= NOTIFY_MASK_TIME_HIGH ;
105 
106 	/* Add the flags to a multiple differed command */
107 	if (pipe->differed_type & DC_MULTIPLE_DELAY)
108 		rmh->Cmd[1] |= MULTIPLE_MASK_TIME_HIGH;
109 
110 	/* Add the flags to a stream-time differed command */
111 	if (pipe->differed_type & DC_STREAM_TIME_DELAY)
112 		rmh->Cmd[1] |= STREAM_MASK_TIME_HIGH;
113 
114 	rmh->LgCmd += 2;
115 	return 2;
116 }
117 
118 /*
119  * vx_set_stream_format - send the stream format command
120  * @pipe: the affected pipe
121  * @data: format bitmask
122  */
vx_set_stream_format(struct vx_core * chip,struct vx_pipe * pipe,unsigned int data)123 static int vx_set_stream_format(struct vx_core *chip, struct vx_pipe *pipe,
124 				unsigned int data)
125 {
126 	struct vx_rmh rmh;
127 
128 	vx_init_rmh(&rmh, pipe->is_capture ?
129 		    CMD_FORMAT_STREAM_IN : CMD_FORMAT_STREAM_OUT);
130 	rmh.Cmd[0] |= pipe->number << FIELD_SIZE;
131 
132         /* Command might be longer since we may have to add a timestamp */
133 	vx_set_differed_time(chip, &rmh, pipe);
134 
135 	rmh.Cmd[rmh.LgCmd] = (data & 0xFFFFFF00) >> 8;
136 	rmh.Cmd[rmh.LgCmd + 1] = (data & 0xFF) << 16 /*| (datal & 0xFFFF00) >> 8*/;
137 	rmh.LgCmd += 2;
138 
139 	return vx_send_msg(chip, &rmh);
140 }
141 
142 
143 /*
144  * vx_set_format - set the format of a pipe
145  * @pipe: the affected pipe
146  * @runtime: pcm runtime instance to be referred
147  *
148  * returns 0 if successful, or a negative error code.
149  */
vx_set_format(struct vx_core * chip,struct vx_pipe * pipe,struct snd_pcm_runtime * runtime)150 static int vx_set_format(struct vx_core *chip, struct vx_pipe *pipe,
151 			 struct snd_pcm_runtime *runtime)
152 {
153 	unsigned int header = HEADER_FMT_BASE;
154 
155 	if (runtime->channels == 1)
156 		header |= HEADER_FMT_MONO;
157 	if (snd_pcm_format_little_endian(runtime->format))
158 		header |= HEADER_FMT_INTEL;
159 	if (runtime->rate < 32000 && runtime->rate > 11025)
160 		header |= HEADER_FMT_UPTO32;
161 	else if (runtime->rate <= 11025)
162 		header |= HEADER_FMT_UPTO11;
163 
164 	switch (snd_pcm_format_physical_width(runtime->format)) {
165 	// case 8: break;
166 	case 16: header |= HEADER_FMT_16BITS; break;
167 	case 24: header |= HEADER_FMT_24BITS; break;
168 	default :
169 		snd_BUG();
170 		return -EINVAL;
171 	}
172 
173 	return vx_set_stream_format(chip, pipe, header);
174 }
175 
176 /*
177  * set / query the IBL size
178  */
vx_set_ibl(struct vx_core * chip,struct vx_ibl_info * info)179 static int vx_set_ibl(struct vx_core *chip, struct vx_ibl_info *info)
180 {
181 	int err;
182 	struct vx_rmh rmh;
183 
184 	vx_init_rmh(&rmh, CMD_IBL);
185 	rmh.Cmd[0] |= info->size & 0x03ffff;
186 	err = vx_send_msg(chip, &rmh);
187 	if (err < 0)
188 		return err;
189 	info->size = rmh.Stat[0];
190 	info->max_size = rmh.Stat[1];
191 	info->min_size = rmh.Stat[2];
192 	info->granularity = rmh.Stat[3];
193 	snd_printdd(KERN_DEBUG "vx_set_ibl: size = %d, max = %d, min = %d, gran = %d\n",
194 		   info->size, info->max_size, info->min_size, info->granularity);
195 	return 0;
196 }
197 
198 
199 /*
200  * vx_get_pipe_state - get the state of a pipe
201  * @pipe: the pipe to be checked
202  * @state: the pointer for the returned state
203  *
204  * checks the state of a given pipe, and stores the state (1 = running,
205  * 0 = paused) on the given pointer.
206  *
207  * called from trigger callback only
208  */
vx_get_pipe_state(struct vx_core * chip,struct vx_pipe * pipe,int * state)209 static int vx_get_pipe_state(struct vx_core *chip, struct vx_pipe *pipe, int *state)
210 {
211 	int err;
212 	struct vx_rmh rmh;
213 
214 	vx_init_rmh(&rmh, CMD_PIPE_STATE);
215 	vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
216 	err = vx_send_msg(chip, &rmh);
217 	if (! err)
218 		*state = (rmh.Stat[0] & (1 << pipe->number)) ? 1 : 0;
219 	return err;
220 }
221 
222 
223 /*
224  * vx_query_hbuffer_size - query available h-buffer size in bytes
225  * @pipe: the pipe to be checked
226  *
227  * return the available size on h-buffer in bytes,
228  * or a negative error code.
229  *
230  * NOTE: calling this function always switches to the stream mode.
231  *       you'll need to disconnect the host to get back to the
232  *       normal mode.
233  */
vx_query_hbuffer_size(struct vx_core * chip,struct vx_pipe * pipe)234 static int vx_query_hbuffer_size(struct vx_core *chip, struct vx_pipe *pipe)
235 {
236 	int result;
237 	struct vx_rmh rmh;
238 
239 	vx_init_rmh(&rmh, CMD_SIZE_HBUFFER);
240 	vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
241 	if (pipe->is_capture)
242 		rmh.Cmd[0] |= 0x00000001;
243 	result = vx_send_msg(chip, &rmh);
244 	if (! result)
245 		result = rmh.Stat[0] & 0xffff;
246 	return result;
247 }
248 
249 
250 /*
251  * vx_pipe_can_start - query whether a pipe is ready for start
252  * @pipe: the pipe to be checked
253  *
254  * return 1 if ready, 0 if not ready, and negative value on error.
255  *
256  * called from trigger callback only
257  */
vx_pipe_can_start(struct vx_core * chip,struct vx_pipe * pipe)258 static int vx_pipe_can_start(struct vx_core *chip, struct vx_pipe *pipe)
259 {
260 	int err;
261 	struct vx_rmh rmh;
262 
263 	vx_init_rmh(&rmh, CMD_CAN_START_PIPE);
264 	vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
265 	rmh.Cmd[0] |= 1;
266 
267 	err = vx_send_msg(chip, &rmh);
268 	if (! err) {
269 		if (rmh.Stat[0])
270 			err = 1;
271 	}
272 	return err;
273 }
274 
275 /*
276  * vx_conf_pipe - tell the pipe to stand by and wait for IRQA.
277  * @pipe: the pipe to be configured
278  */
vx_conf_pipe(struct vx_core * chip,struct vx_pipe * pipe)279 static int vx_conf_pipe(struct vx_core *chip, struct vx_pipe *pipe)
280 {
281 	struct vx_rmh rmh;
282 
283 	vx_init_rmh(&rmh, CMD_CONF_PIPE);
284 	if (pipe->is_capture)
285 		rmh.Cmd[0] |= COMMAND_RECORD_MASK;
286 	rmh.Cmd[1] = 1 << pipe->number;
287 	return vx_send_msg(chip, &rmh);
288 }
289 
290 /*
291  * vx_send_irqa - trigger IRQA
292  */
vx_send_irqa(struct vx_core * chip)293 static int vx_send_irqa(struct vx_core *chip)
294 {
295 	struct vx_rmh rmh;
296 
297 	vx_init_rmh(&rmh, CMD_SEND_IRQA);
298 	return vx_send_msg(chip, &rmh);
299 }
300 
301 
302 #define MAX_WAIT_FOR_DSP        250
303 /*
304  * vx boards do not support inter-card sync, besides
305  * only 126 samples require to be prepared before a pipe can start
306  */
307 #define CAN_START_DELAY         2	/* wait 2ms only before asking if the pipe is ready*/
308 #define WAIT_STATE_DELAY        2	/* wait 2ms after irqA was requested and check if the pipe state toggled*/
309 
310 /*
311  * vx_toggle_pipe - start / pause a pipe
312  * @pipe: the pipe to be triggered
313  * @state: start = 1, pause = 0
314  *
315  * called from trigger callback only
316  *
317  */
vx_toggle_pipe(struct vx_core * chip,struct vx_pipe * pipe,int state)318 static int vx_toggle_pipe(struct vx_core *chip, struct vx_pipe *pipe, int state)
319 {
320 	int err, i, cur_state;
321 
322 	/* Check the pipe is not already in the requested state */
323 	if (vx_get_pipe_state(chip, pipe, &cur_state) < 0)
324 		return -EBADFD;
325 	if (state == cur_state)
326 		return 0;
327 
328 	/* If a start is requested, ask the DSP to get prepared
329 	 * and wait for a positive acknowledge (when there are
330 	 * enough sound buffer for this pipe)
331 	 */
332 	if (state) {
333 		for (i = 0 ; i < MAX_WAIT_FOR_DSP; i++) {
334 			err = vx_pipe_can_start(chip, pipe);
335 			if (err > 0)
336 				break;
337 			/* Wait for a few, before asking again
338 			 * to avoid flooding the DSP with our requests
339 			 */
340 			mdelay(1);
341 		}
342 	}
343 
344 	err = vx_conf_pipe(chip, pipe);
345 	if (err < 0)
346 		return err;
347 
348 	err = vx_send_irqa(chip);
349 	if (err < 0)
350 		return err;
351 
352 	/* If it completes successfully, wait for the pipes
353 	 * reaching the expected state before returning
354 	 * Check one pipe only (since they are synchronous)
355 	 */
356 	for (i = 0; i < MAX_WAIT_FOR_DSP; i++) {
357 		err = vx_get_pipe_state(chip, pipe, &cur_state);
358 		if (err < 0 || cur_state == state)
359 			break;
360 		err = -EIO;
361 		mdelay(1);
362 	}
363 	return err < 0 ? -EIO : 0;
364 }
365 
366 
367 /*
368  * vx_stop_pipe - stop a pipe
369  * @pipe: the pipe to be stopped
370  *
371  * called from trigger callback only
372  */
vx_stop_pipe(struct vx_core * chip,struct vx_pipe * pipe)373 static int vx_stop_pipe(struct vx_core *chip, struct vx_pipe *pipe)
374 {
375 	struct vx_rmh rmh;
376 	vx_init_rmh(&rmh, CMD_STOP_PIPE);
377 	vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
378 	return vx_send_msg(chip, &rmh);
379 }
380 
381 
382 /*
383  * vx_alloc_pipe - allocate a pipe and initialize the pipe instance
384  * @capture: 0 = playback, 1 = capture operation
385  * @audioid: the audio id to be assigned
386  * @num_audio: number of audio channels
387  * @pipep: the returned pipe instance
388  *
389  * return 0 on success, or a negative error code.
390  */
vx_alloc_pipe(struct vx_core * chip,int capture,int audioid,int num_audio,struct vx_pipe ** pipep)391 static int vx_alloc_pipe(struct vx_core *chip, int capture,
392 			 int audioid, int num_audio,
393 			 struct vx_pipe **pipep)
394 {
395 	int err;
396 	struct vx_pipe *pipe;
397 	struct vx_rmh rmh;
398 	int data_mode;
399 
400 	*pipep = NULL;
401 	vx_init_rmh(&rmh, CMD_RES_PIPE);
402 	vx_set_pipe_cmd_params(&rmh, capture, audioid, num_audio);
403 #if 0	// NYI
404 	if (underrun_skip_sound)
405 		rmh.Cmd[0] |= BIT_SKIP_SOUND;
406 #endif	// NYI
407 	data_mode = (chip->uer_bits & IEC958_AES0_NONAUDIO) != 0;
408 	if (! capture && data_mode)
409 		rmh.Cmd[0] |= BIT_DATA_MODE;
410 	err = vx_send_msg(chip, &rmh);
411 	if (err < 0)
412 		return err;
413 
414 	/* initialize the pipe record */
415 	pipe = kzalloc(sizeof(*pipe), GFP_KERNEL);
416 	if (! pipe) {
417 		/* release the pipe */
418 		vx_init_rmh(&rmh, CMD_FREE_PIPE);
419 		vx_set_pipe_cmd_params(&rmh, capture, audioid, 0);
420 		vx_send_msg(chip, &rmh);
421 		return -ENOMEM;
422 	}
423 
424 	/* the pipe index should be identical with the audio index */
425 	pipe->number = audioid;
426 	pipe->is_capture = capture;
427 	pipe->channels = num_audio;
428 	pipe->differed_type = 0;
429 	pipe->pcx_time = 0;
430 	pipe->data_mode = data_mode;
431 	*pipep = pipe;
432 
433 	return 0;
434 }
435 
436 
437 /*
438  * vx_free_pipe - release a pipe
439  * @pipe: pipe to be released
440  */
vx_free_pipe(struct vx_core * chip,struct vx_pipe * pipe)441 static int vx_free_pipe(struct vx_core *chip, struct vx_pipe *pipe)
442 {
443 	struct vx_rmh rmh;
444 
445 	vx_init_rmh(&rmh, CMD_FREE_PIPE);
446 	vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
447 	vx_send_msg(chip, &rmh);
448 
449 	kfree(pipe);
450 	return 0;
451 }
452 
453 
454 /*
455  * vx_start_stream - start the stream
456  *
457  * called from trigger callback only
458  */
vx_start_stream(struct vx_core * chip,struct vx_pipe * pipe)459 static int vx_start_stream(struct vx_core *chip, struct vx_pipe *pipe)
460 {
461 	struct vx_rmh rmh;
462 
463 	vx_init_rmh(&rmh, CMD_START_ONE_STREAM);
464 	vx_set_stream_cmd_params(&rmh, pipe->is_capture, pipe->number);
465 	vx_set_differed_time(chip, &rmh, pipe);
466 	return vx_send_msg(chip, &rmh);
467 }
468 
469 
470 /*
471  * vx_stop_stream - stop the stream
472  *
473  * called from trigger callback only
474  */
vx_stop_stream(struct vx_core * chip,struct vx_pipe * pipe)475 static int vx_stop_stream(struct vx_core *chip, struct vx_pipe *pipe)
476 {
477 	struct vx_rmh rmh;
478 
479 	vx_init_rmh(&rmh, CMD_STOP_STREAM);
480 	vx_set_stream_cmd_params(&rmh, pipe->is_capture, pipe->number);
481 	return vx_send_msg(chip, &rmh);
482 }
483 
484 
485 /*
486  * playback hw information
487  */
488 
489 static const struct snd_pcm_hardware vx_pcm_playback_hw = {
490 	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
491 				 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID /*|*/
492 				 /*SNDRV_PCM_INFO_RESUME*/),
493 	.formats =		(/*SNDRV_PCM_FMTBIT_U8 |*/
494 				 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE),
495 	.rates =		SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
496 	.rate_min =		5000,
497 	.rate_max =		48000,
498 	.channels_min =		1,
499 	.channels_max =		2,
500 	.buffer_bytes_max =	(128*1024),
501 	.period_bytes_min =	126,
502 	.period_bytes_max =	(128*1024),
503 	.periods_min =		2,
504 	.periods_max =		VX_MAX_PERIODS,
505 	.fifo_size =		126,
506 };
507 
508 
509 /*
510  * vx_pcm_playback_open - open callback for playback
511  */
vx_pcm_playback_open(struct snd_pcm_substream * subs)512 static int vx_pcm_playback_open(struct snd_pcm_substream *subs)
513 {
514 	struct snd_pcm_runtime *runtime = subs->runtime;
515 	struct vx_core *chip = snd_pcm_substream_chip(subs);
516 	struct vx_pipe *pipe = NULL;
517 	unsigned int audio;
518 	int err;
519 
520 	if (chip->chip_status & VX_STAT_IS_STALE)
521 		return -EBUSY;
522 
523 	audio = subs->pcm->device * 2;
524 	if (snd_BUG_ON(audio >= chip->audio_outs))
525 		return -EINVAL;
526 
527 	/* playback pipe may have been already allocated for monitoring */
528 	pipe = chip->playback_pipes[audio];
529 	if (! pipe) {
530 		/* not allocated yet */
531 		err = vx_alloc_pipe(chip, 0, audio, 2, &pipe); /* stereo playback */
532 		if (err < 0)
533 			return err;
534 	}
535 	/* open for playback */
536 	pipe->references++;
537 
538 	pipe->substream = subs;
539 	chip->playback_pipes[audio] = pipe;
540 
541 	runtime->hw = vx_pcm_playback_hw;
542 	runtime->hw.period_bytes_min = chip->ibl.size;
543 	runtime->private_data = pipe;
544 
545 	/* align to 4 bytes (otherwise will be problematic when 24bit is used) */
546 	snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 4);
547 	snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 4);
548 
549 	return 0;
550 }
551 
552 /*
553  * vx_pcm_playback_close - close callback for playback
554  */
vx_pcm_playback_close(struct snd_pcm_substream * subs)555 static int vx_pcm_playback_close(struct snd_pcm_substream *subs)
556 {
557 	struct vx_core *chip = snd_pcm_substream_chip(subs);
558 	struct vx_pipe *pipe;
559 
560 	if (! subs->runtime->private_data)
561 		return -EINVAL;
562 
563 	pipe = subs->runtime->private_data;
564 
565 	if (--pipe->references == 0) {
566 		chip->playback_pipes[pipe->number] = NULL;
567 		vx_free_pipe(chip, pipe);
568 	}
569 
570 	return 0;
571 
572 }
573 
574 
575 /*
576  * vx_notify_end_of_buffer - send "end-of-buffer" notifier at the given pipe
577  * @pipe: the pipe to notify
578  *
579  * NB: call with a certain lock.
580  */
vx_notify_end_of_buffer(struct vx_core * chip,struct vx_pipe * pipe)581 static int vx_notify_end_of_buffer(struct vx_core *chip, struct vx_pipe *pipe)
582 {
583 	int err;
584 	struct vx_rmh rmh;  /* use a temporary rmh here */
585 
586 	/* Toggle Dsp Host Interface into Message mode */
587 	vx_send_rih_nolock(chip, IRQ_PAUSE_START_CONNECT);
588 	vx_init_rmh(&rmh, CMD_NOTIFY_END_OF_BUFFER);
589 	vx_set_stream_cmd_params(&rmh, 0, pipe->number);
590 	err = vx_send_msg_nolock(chip, &rmh);
591 	if (err < 0)
592 		return err;
593 	/* Toggle Dsp Host Interface back to sound transfer mode */
594 	vx_send_rih_nolock(chip, IRQ_PAUSE_START_CONNECT);
595 	return 0;
596 }
597 
598 /*
599  * vx_pcm_playback_transfer_chunk - transfer a single chunk
600  * @subs: substream
601  * @pipe: the pipe to transfer
602  * @size: chunk size in bytes
603  *
604  * transfer a single buffer chunk.  EOB notificaton is added after that.
605  * called from the interrupt handler, too.
606  *
607  * return 0 if ok.
608  */
vx_pcm_playback_transfer_chunk(struct vx_core * chip,struct snd_pcm_runtime * runtime,struct vx_pipe * pipe,int size)609 static int vx_pcm_playback_transfer_chunk(struct vx_core *chip,
610 					  struct snd_pcm_runtime *runtime,
611 					  struct vx_pipe *pipe, int size)
612 {
613 	int space, err = 0;
614 
615 	space = vx_query_hbuffer_size(chip, pipe);
616 	if (space < 0) {
617 		/* disconnect the host, SIZE_HBUF command always switches to the stream mode */
618 		vx_send_rih(chip, IRQ_CONNECT_STREAM_NEXT);
619 		snd_printd("error hbuffer\n");
620 		return space;
621 	}
622 	if (space < size) {
623 		vx_send_rih(chip, IRQ_CONNECT_STREAM_NEXT);
624 		snd_printd("no enough hbuffer space %d\n", space);
625 		return -EIO; /* XRUN */
626 	}
627 
628 	/* we don't need irqsave here, because this function
629 	 * is called from either trigger callback or irq handler
630 	 */
631 	mutex_lock(&chip->lock);
632 	vx_pseudo_dma_write(chip, runtime, pipe, size);
633 	err = vx_notify_end_of_buffer(chip, pipe);
634 	/* disconnect the host, SIZE_HBUF command always switches to the stream mode */
635 	vx_send_rih_nolock(chip, IRQ_CONNECT_STREAM_NEXT);
636 	mutex_unlock(&chip->lock);
637 	return err;
638 }
639 
640 /*
641  * update the position of the given pipe.
642  * pipe->position is updated and wrapped within the buffer size.
643  * pipe->transferred is updated, too, but the size is not wrapped,
644  * so that the caller can check the total transferred size later
645  * (to call snd_pcm_period_elapsed).
646  */
vx_update_pipe_position(struct vx_core * chip,struct snd_pcm_runtime * runtime,struct vx_pipe * pipe)647 static int vx_update_pipe_position(struct vx_core *chip,
648 				   struct snd_pcm_runtime *runtime,
649 				   struct vx_pipe *pipe)
650 {
651 	struct vx_rmh rmh;
652 	int err, update;
653 	u64 count;
654 
655 	vx_init_rmh(&rmh, CMD_STREAM_SAMPLE_COUNT);
656 	vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
657 	err = vx_send_msg(chip, &rmh);
658 	if (err < 0)
659 		return err;
660 
661 	count = ((u64)(rmh.Stat[0] & 0xfffff) << 24) | (u64)rmh.Stat[1];
662 	update = (int)(count - pipe->cur_count);
663 	pipe->cur_count = count;
664 	pipe->position += update;
665 	if (pipe->position >= (int)runtime->buffer_size)
666 		pipe->position %= runtime->buffer_size;
667 	pipe->transferred += update;
668 	return 0;
669 }
670 
671 /*
672  * transfer the pending playback buffer data to DSP
673  * called from interrupt handler
674  */
vx_pcm_playback_transfer(struct vx_core * chip,struct snd_pcm_substream * subs,struct vx_pipe * pipe,int nchunks)675 static void vx_pcm_playback_transfer(struct vx_core *chip,
676 				     struct snd_pcm_substream *subs,
677 				     struct vx_pipe *pipe, int nchunks)
678 {
679 	int i, err;
680 	struct snd_pcm_runtime *runtime = subs->runtime;
681 
682 	if (! pipe->prepared || (chip->chip_status & VX_STAT_IS_STALE))
683 		return;
684 	for (i = 0; i < nchunks; i++) {
685 		err = vx_pcm_playback_transfer_chunk(chip, runtime, pipe,
686 						     chip->ibl.size);
687 		if (err < 0)
688 			return;
689 	}
690 }
691 
692 /*
693  * update the playback position and call snd_pcm_period_elapsed() if necessary
694  * called from interrupt handler
695  */
vx_pcm_playback_update(struct vx_core * chip,struct snd_pcm_substream * subs,struct vx_pipe * pipe)696 static void vx_pcm_playback_update(struct vx_core *chip,
697 				   struct snd_pcm_substream *subs,
698 				   struct vx_pipe *pipe)
699 {
700 	int err;
701 	struct snd_pcm_runtime *runtime = subs->runtime;
702 
703 	if (pipe->running && ! (chip->chip_status & VX_STAT_IS_STALE)) {
704 		err = vx_update_pipe_position(chip, runtime, pipe);
705 		if (err < 0)
706 			return;
707 		if (pipe->transferred >= (int)runtime->period_size) {
708 			pipe->transferred %= runtime->period_size;
709 			snd_pcm_period_elapsed(subs);
710 		}
711 	}
712 }
713 
714 /*
715  * vx_pcm_playback_trigger - trigger callback for playback
716  */
vx_pcm_trigger(struct snd_pcm_substream * subs,int cmd)717 static int vx_pcm_trigger(struct snd_pcm_substream *subs, int cmd)
718 {
719 	struct vx_core *chip = snd_pcm_substream_chip(subs);
720 	struct vx_pipe *pipe = subs->runtime->private_data;
721 	int err;
722 
723 	if (chip->chip_status & VX_STAT_IS_STALE)
724 		return -EBUSY;
725 
726 	switch (cmd) {
727 	case SNDRV_PCM_TRIGGER_START:
728 	case SNDRV_PCM_TRIGGER_RESUME:
729 		if (! pipe->is_capture)
730 			vx_pcm_playback_transfer(chip, subs, pipe, 2);
731 		err = vx_start_stream(chip, pipe);
732 		if (err < 0) {
733 			pr_debug("vx: cannot start stream\n");
734 			return err;
735 		}
736 		err = vx_toggle_pipe(chip, pipe, 1);
737 		if (err < 0) {
738 			pr_debug("vx: cannot start pipe\n");
739 			vx_stop_stream(chip, pipe);
740 			return err;
741 		}
742 		chip->pcm_running++;
743 		pipe->running = 1;
744 		break;
745 	case SNDRV_PCM_TRIGGER_STOP:
746 	case SNDRV_PCM_TRIGGER_SUSPEND:
747 		vx_toggle_pipe(chip, pipe, 0);
748 		vx_stop_pipe(chip, pipe);
749 		vx_stop_stream(chip, pipe);
750 		chip->pcm_running--;
751 		pipe->running = 0;
752 		break;
753 	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
754 		err = vx_toggle_pipe(chip, pipe, 0);
755 		if (err < 0)
756 			return err;
757 		break;
758 	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
759 		err = vx_toggle_pipe(chip, pipe, 1);
760 		if (err < 0)
761 			return err;
762 		break;
763 	default:
764 		return -EINVAL;
765 	}
766 	return 0;
767 }
768 
769 /*
770  * vx_pcm_playback_pointer - pointer callback for playback
771  */
vx_pcm_playback_pointer(struct snd_pcm_substream * subs)772 static snd_pcm_uframes_t vx_pcm_playback_pointer(struct snd_pcm_substream *subs)
773 {
774 	struct snd_pcm_runtime *runtime = subs->runtime;
775 	struct vx_pipe *pipe = runtime->private_data;
776 	return pipe->position;
777 }
778 
779 /*
780  * vx_pcm_prepare - prepare callback for playback and capture
781  */
vx_pcm_prepare(struct snd_pcm_substream * subs)782 static int vx_pcm_prepare(struct snd_pcm_substream *subs)
783 {
784 	struct vx_core *chip = snd_pcm_substream_chip(subs);
785 	struct snd_pcm_runtime *runtime = subs->runtime;
786 	struct vx_pipe *pipe = runtime->private_data;
787 	int err, data_mode;
788 	// int max_size, nchunks;
789 
790 	if (chip->chip_status & VX_STAT_IS_STALE)
791 		return -EBUSY;
792 
793 	data_mode = (chip->uer_bits & IEC958_AES0_NONAUDIO) != 0;
794 	if (data_mode != pipe->data_mode && ! pipe->is_capture) {
795 		/* IEC958 status (raw-mode) was changed */
796 		/* we reopen the pipe */
797 		struct vx_rmh rmh;
798 		snd_printdd(KERN_DEBUG "reopen the pipe with data_mode = %d\n", data_mode);
799 		vx_init_rmh(&rmh, CMD_FREE_PIPE);
800 		vx_set_pipe_cmd_params(&rmh, 0, pipe->number, 0);
801 		err = vx_send_msg(chip, &rmh);
802 		if (err < 0)
803 			return err;
804 		vx_init_rmh(&rmh, CMD_RES_PIPE);
805 		vx_set_pipe_cmd_params(&rmh, 0, pipe->number, pipe->channels);
806 		if (data_mode)
807 			rmh.Cmd[0] |= BIT_DATA_MODE;
808 		err = vx_send_msg(chip, &rmh);
809 		if (err < 0)
810 			return err;
811 		pipe->data_mode = data_mode;
812 	}
813 
814 	if (chip->pcm_running && chip->freq != runtime->rate) {
815 		snd_printk(KERN_ERR "vx: cannot set different clock %d "
816 			   "from the current %d\n", runtime->rate, chip->freq);
817 		return -EINVAL;
818 	}
819 	vx_set_clock(chip, runtime->rate);
820 
821 	err = vx_set_format(chip, pipe, runtime);
822 	if (err < 0)
823 		return err;
824 
825 	if (vx_is_pcmcia(chip)) {
826 		pipe->align = 2; /* 16bit word */
827 	} else {
828 		pipe->align = 4; /* 32bit word */
829 	}
830 
831 	pipe->buffer_bytes = frames_to_bytes(runtime, runtime->buffer_size);
832 	pipe->period_bytes = frames_to_bytes(runtime, runtime->period_size);
833 	pipe->hw_ptr = 0;
834 
835 	/* set the timestamp */
836 	vx_update_pipe_position(chip, runtime, pipe);
837 	/* clear again */
838 	pipe->transferred = 0;
839 	pipe->position = 0;
840 
841 	pipe->prepared = 1;
842 
843 	return 0;
844 }
845 
846 
847 /*
848  * operators for PCM playback
849  */
850 static const struct snd_pcm_ops vx_pcm_playback_ops = {
851 	.open =		vx_pcm_playback_open,
852 	.close =	vx_pcm_playback_close,
853 	.prepare =	vx_pcm_prepare,
854 	.trigger =	vx_pcm_trigger,
855 	.pointer =	vx_pcm_playback_pointer,
856 };
857 
858 
859 /*
860  * playback hw information
861  */
862 
863 static const struct snd_pcm_hardware vx_pcm_capture_hw = {
864 	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
865 				 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID /*|*/
866 				 /*SNDRV_PCM_INFO_RESUME*/),
867 	.formats =		(/*SNDRV_PCM_FMTBIT_U8 |*/
868 				 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE),
869 	.rates =		SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
870 	.rate_min =		5000,
871 	.rate_max =		48000,
872 	.channels_min =		1,
873 	.channels_max =		2,
874 	.buffer_bytes_max =	(128*1024),
875 	.period_bytes_min =	126,
876 	.period_bytes_max =	(128*1024),
877 	.periods_min =		2,
878 	.periods_max =		VX_MAX_PERIODS,
879 	.fifo_size =		126,
880 };
881 
882 
883 /*
884  * vx_pcm_capture_open - open callback for capture
885  */
vx_pcm_capture_open(struct snd_pcm_substream * subs)886 static int vx_pcm_capture_open(struct snd_pcm_substream *subs)
887 {
888 	struct snd_pcm_runtime *runtime = subs->runtime;
889 	struct vx_core *chip = snd_pcm_substream_chip(subs);
890 	struct vx_pipe *pipe;
891 	struct vx_pipe *pipe_out_monitoring = NULL;
892 	unsigned int audio;
893 	int err;
894 
895 	if (chip->chip_status & VX_STAT_IS_STALE)
896 		return -EBUSY;
897 
898 	audio = subs->pcm->device * 2;
899 	if (snd_BUG_ON(audio >= chip->audio_ins))
900 		return -EINVAL;
901 	err = vx_alloc_pipe(chip, 1, audio, 2, &pipe);
902 	if (err < 0)
903 		return err;
904 	pipe->substream = subs;
905 	chip->capture_pipes[audio] = pipe;
906 
907 	/* check if monitoring is needed */
908 	if (chip->audio_monitor_active[audio]) {
909 		pipe_out_monitoring = chip->playback_pipes[audio];
910 		if (! pipe_out_monitoring) {
911 			/* allocate a pipe */
912 			err = vx_alloc_pipe(chip, 0, audio, 2, &pipe_out_monitoring);
913 			if (err < 0)
914 				return err;
915 			chip->playback_pipes[audio] = pipe_out_monitoring;
916 		}
917 		pipe_out_monitoring->references++;
918 		/*
919 		   if an output pipe is available, it's audios still may need to be
920 		   unmuted. hence we'll have to call a mixer entry point.
921 		*/
922 		vx_set_monitor_level(chip, audio, chip->audio_monitor[audio],
923 				     chip->audio_monitor_active[audio]);
924 		/* assuming stereo */
925 		vx_set_monitor_level(chip, audio+1, chip->audio_monitor[audio+1],
926 				     chip->audio_monitor_active[audio+1]);
927 	}
928 
929 	pipe->monitoring_pipe = pipe_out_monitoring; /* default value NULL */
930 
931 	runtime->hw = vx_pcm_capture_hw;
932 	runtime->hw.period_bytes_min = chip->ibl.size;
933 	runtime->private_data = pipe;
934 
935 	/* align to 4 bytes (otherwise will be problematic when 24bit is used) */
936 	snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 4);
937 	snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 4);
938 
939 	return 0;
940 }
941 
942 /*
943  * vx_pcm_capture_close - close callback for capture
944  */
vx_pcm_capture_close(struct snd_pcm_substream * subs)945 static int vx_pcm_capture_close(struct snd_pcm_substream *subs)
946 {
947 	struct vx_core *chip = snd_pcm_substream_chip(subs);
948 	struct vx_pipe *pipe;
949 	struct vx_pipe *pipe_out_monitoring;
950 
951 	if (! subs->runtime->private_data)
952 		return -EINVAL;
953 	pipe = subs->runtime->private_data;
954 	chip->capture_pipes[pipe->number] = NULL;
955 
956 	pipe_out_monitoring = pipe->monitoring_pipe;
957 
958 	/*
959 	  if an output pipe is attached to this input,
960 	  check if it needs to be released.
961 	*/
962 	if (pipe_out_monitoring) {
963 		if (--pipe_out_monitoring->references == 0) {
964 			vx_free_pipe(chip, pipe_out_monitoring);
965 			chip->playback_pipes[pipe->number] = NULL;
966 			pipe->monitoring_pipe = NULL;
967 		}
968 	}
969 
970 	vx_free_pipe(chip, pipe);
971 	return 0;
972 }
973 
974 
975 
976 #define DMA_READ_ALIGN	6	/* hardware alignment for read */
977 
978 /*
979  * vx_pcm_capture_update - update the capture buffer
980  */
vx_pcm_capture_update(struct vx_core * chip,struct snd_pcm_substream * subs,struct vx_pipe * pipe)981 static void vx_pcm_capture_update(struct vx_core *chip, struct snd_pcm_substream *subs,
982 				  struct vx_pipe *pipe)
983 {
984 	int size, space, count;
985 	struct snd_pcm_runtime *runtime = subs->runtime;
986 
987 	if (!pipe->running || (chip->chip_status & VX_STAT_IS_STALE))
988 		return;
989 
990 	size = runtime->buffer_size - snd_pcm_capture_avail(runtime);
991 	if (! size)
992 		return;
993 	size = frames_to_bytes(runtime, size);
994 	space = vx_query_hbuffer_size(chip, pipe);
995 	if (space < 0)
996 		goto _error;
997 	if (size > space)
998 		size = space;
999 	size = (size / 3) * 3; /* align to 3 bytes */
1000 	if (size < DMA_READ_ALIGN)
1001 		goto _error;
1002 
1003 	/* keep the last 6 bytes, they will be read after disconnection */
1004 	count = size - DMA_READ_ALIGN;
1005 	/* read bytes until the current pointer reaches to the aligned position
1006 	 * for word-transfer
1007 	 */
1008 	while (count > 0) {
1009 		if ((pipe->hw_ptr % pipe->align) == 0)
1010 			break;
1011 		if (vx_wait_for_rx_full(chip) < 0)
1012 			goto _error;
1013 		vx_pcm_read_per_bytes(chip, runtime, pipe);
1014 		count -= 3;
1015 	}
1016 	if (count > 0) {
1017 		/* ok, let's accelerate! */
1018 		int align = pipe->align * 3;
1019 		space = (count / align) * align;
1020 		if (space > 0) {
1021 			vx_pseudo_dma_read(chip, runtime, pipe, space);
1022 			count -= space;
1023 		}
1024 	}
1025 	/* read the rest of bytes */
1026 	while (count > 0) {
1027 		if (vx_wait_for_rx_full(chip) < 0)
1028 			goto _error;
1029 		vx_pcm_read_per_bytes(chip, runtime, pipe);
1030 		count -= 3;
1031 	}
1032 	/* disconnect the host, SIZE_HBUF command always switches to the stream mode */
1033 	vx_send_rih(chip, IRQ_CONNECT_STREAM_NEXT);
1034 	/* read the last pending 6 bytes */
1035 	count = DMA_READ_ALIGN;
1036 	while (count > 0) {
1037 		vx_pcm_read_per_bytes(chip, runtime, pipe);
1038 		count -= 3;
1039 	}
1040 	/* update the position */
1041 	pipe->transferred += size;
1042 	if (pipe->transferred >= pipe->period_bytes) {
1043 		pipe->transferred %= pipe->period_bytes;
1044 		snd_pcm_period_elapsed(subs);
1045 	}
1046 	return;
1047 
1048  _error:
1049 	/* disconnect the host, SIZE_HBUF command always switches to the stream mode */
1050 	vx_send_rih(chip, IRQ_CONNECT_STREAM_NEXT);
1051 	return;
1052 }
1053 
1054 /*
1055  * vx_pcm_capture_pointer - pointer callback for capture
1056  */
vx_pcm_capture_pointer(struct snd_pcm_substream * subs)1057 static snd_pcm_uframes_t vx_pcm_capture_pointer(struct snd_pcm_substream *subs)
1058 {
1059 	struct snd_pcm_runtime *runtime = subs->runtime;
1060 	struct vx_pipe *pipe = runtime->private_data;
1061 	return bytes_to_frames(runtime, pipe->hw_ptr);
1062 }
1063 
1064 /*
1065  * operators for PCM capture
1066  */
1067 static const struct snd_pcm_ops vx_pcm_capture_ops = {
1068 	.open =		vx_pcm_capture_open,
1069 	.close =	vx_pcm_capture_close,
1070 	.prepare =	vx_pcm_prepare,
1071 	.trigger =	vx_pcm_trigger,
1072 	.pointer =	vx_pcm_capture_pointer,
1073 };
1074 
1075 
1076 /*
1077  * interrupt handler for pcm streams
1078  */
vx_pcm_update_intr(struct vx_core * chip,unsigned int events)1079 void vx_pcm_update_intr(struct vx_core *chip, unsigned int events)
1080 {
1081 	unsigned int i;
1082 	struct vx_pipe *pipe;
1083 
1084 #define EVENT_MASK	(END_OF_BUFFER_EVENTS_PENDING|ASYNC_EVENTS_PENDING)
1085 
1086 	if (events & EVENT_MASK) {
1087 		vx_init_rmh(&chip->irq_rmh, CMD_ASYNC);
1088 		if (events & ASYNC_EVENTS_PENDING)
1089 			chip->irq_rmh.Cmd[0] |= 0x00000001;	/* SEL_ASYNC_EVENTS */
1090 		if (events & END_OF_BUFFER_EVENTS_PENDING)
1091 			chip->irq_rmh.Cmd[0] |= 0x00000002;	/* SEL_END_OF_BUF_EVENTS */
1092 
1093 		if (vx_send_msg(chip, &chip->irq_rmh) < 0) {
1094 			snd_printdd(KERN_ERR "msg send error!!\n");
1095 			return;
1096 		}
1097 
1098 		i = 1;
1099 		while (i < chip->irq_rmh.LgStat) {
1100 			int p, buf, capture, eob;
1101 			p = chip->irq_rmh.Stat[i] & MASK_FIRST_FIELD;
1102 			capture = (chip->irq_rmh.Stat[i] & 0x400000) ? 1 : 0;
1103 			eob = (chip->irq_rmh.Stat[i] & 0x800000) ? 1 : 0;
1104 			i++;
1105 			if (events & ASYNC_EVENTS_PENDING)
1106 				i++;
1107 			buf = 1; /* force to transfer */
1108 			if (events & END_OF_BUFFER_EVENTS_PENDING) {
1109 				if (eob)
1110 					buf = chip->irq_rmh.Stat[i];
1111 				i++;
1112 			}
1113 			if (capture)
1114 				continue;
1115 			if (snd_BUG_ON(p < 0 || p >= chip->audio_outs))
1116 				continue;
1117 			pipe = chip->playback_pipes[p];
1118 			if (pipe && pipe->substream) {
1119 				vx_pcm_playback_update(chip, pipe->substream, pipe);
1120 				vx_pcm_playback_transfer(chip, pipe->substream, pipe, buf);
1121 			}
1122 		}
1123 	}
1124 
1125 	/* update the capture pcm pointers as frequently as possible */
1126 	for (i = 0; i < chip->audio_ins; i++) {
1127 		pipe = chip->capture_pipes[i];
1128 		if (pipe && pipe->substream)
1129 			vx_pcm_capture_update(chip, pipe->substream, pipe);
1130 	}
1131 }
1132 
1133 
1134 /*
1135  * vx_init_audio_io - check the available audio i/o and allocate pipe arrays
1136  */
vx_init_audio_io(struct vx_core * chip)1137 static int vx_init_audio_io(struct vx_core *chip)
1138 {
1139 	struct vx_rmh rmh;
1140 	int preferred;
1141 
1142 	vx_init_rmh(&rmh, CMD_SUPPORTED);
1143 	if (vx_send_msg(chip, &rmh) < 0) {
1144 		snd_printk(KERN_ERR "vx: cannot get the supported audio data\n");
1145 		return -ENXIO;
1146 	}
1147 
1148 	chip->audio_outs = rmh.Stat[0] & MASK_FIRST_FIELD;
1149 	chip->audio_ins = (rmh.Stat[0] >> (FIELD_SIZE*2)) & MASK_FIRST_FIELD;
1150 	chip->audio_info = rmh.Stat[1];
1151 
1152 	/* allocate pipes */
1153 	chip->playback_pipes = kcalloc(chip->audio_outs, sizeof(struct vx_pipe *), GFP_KERNEL);
1154 	if (!chip->playback_pipes)
1155 		return -ENOMEM;
1156 	chip->capture_pipes = kcalloc(chip->audio_ins, sizeof(struct vx_pipe *), GFP_KERNEL);
1157 	if (!chip->capture_pipes) {
1158 		kfree(chip->playback_pipes);
1159 		return -ENOMEM;
1160 	}
1161 
1162 	preferred = chip->ibl.size;
1163 	chip->ibl.size = 0;
1164 	vx_set_ibl(chip, &chip->ibl); /* query the info */
1165 	if (preferred > 0) {
1166 		chip->ibl.size = roundup(preferred, chip->ibl.granularity);
1167 		if (chip->ibl.size > chip->ibl.max_size)
1168 			chip->ibl.size = chip->ibl.max_size;
1169 	} else
1170 		chip->ibl.size = chip->ibl.min_size; /* set to the minimum */
1171 	vx_set_ibl(chip, &chip->ibl);
1172 
1173 	return 0;
1174 }
1175 
1176 
1177 /*
1178  * free callback for pcm
1179  */
snd_vx_pcm_free(struct snd_pcm * pcm)1180 static void snd_vx_pcm_free(struct snd_pcm *pcm)
1181 {
1182 	struct vx_core *chip = pcm->private_data;
1183 	chip->pcm[pcm->device] = NULL;
1184 	kfree(chip->playback_pipes);
1185 	chip->playback_pipes = NULL;
1186 	kfree(chip->capture_pipes);
1187 	chip->capture_pipes = NULL;
1188 }
1189 
1190 /*
1191  * snd_vx_pcm_new - create and initialize a pcm
1192  */
snd_vx_pcm_new(struct vx_core * chip)1193 int snd_vx_pcm_new(struct vx_core *chip)
1194 {
1195 	struct snd_pcm *pcm;
1196 	unsigned int i;
1197 	int err;
1198 
1199 	err = vx_init_audio_io(chip);
1200 	if (err < 0)
1201 		return err;
1202 
1203 	for (i = 0; i < chip->hw->num_codecs; i++) {
1204 		unsigned int outs, ins;
1205 		outs = chip->audio_outs > i * 2 ? 1 : 0;
1206 		ins = chip->audio_ins > i * 2 ? 1 : 0;
1207 		if (! outs && ! ins)
1208 			break;
1209 		err = snd_pcm_new(chip->card, "VX PCM", i,
1210 				  outs, ins, &pcm);
1211 		if (err < 0)
1212 			return err;
1213 		if (outs)
1214 			snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &vx_pcm_playback_ops);
1215 		if (ins)
1216 			snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &vx_pcm_capture_ops);
1217 		snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC,
1218 					       NULL, 0, 0);
1219 
1220 		pcm->private_data = chip;
1221 		pcm->private_free = snd_vx_pcm_free;
1222 		pcm->info_flags = 0;
1223 		pcm->nonatomic = true;
1224 		strcpy(pcm->name, chip->card->shortname);
1225 		chip->pcm[i] = pcm;
1226 	}
1227 
1228 	return 0;
1229 }
1230