blob: 3bd6985430e824b72e2fd71432ff13afd864a000 [file] [log] [blame]
Takashi Iwaid43f30102011-05-03 16:14:46 +02001/*
2 * Support for Digigram Lola PCI-e boards
3 *
4 * Copyright (c) 2011 Takashi Iwai <tiwai@suse.de>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; either version 2 of the License, or (at your option)
9 * any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc., 59
18 * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 */
20
21#include <linux/kernel.h>
22#include <linux/init.h>
23#include <linux/dma-mapping.h>
24#include <linux/pci.h>
Takashi Iwaif0447852011-05-03 18:21:01 +020025#include <linux/delay.h>
Takashi Iwaid43f30102011-05-03 16:14:46 +020026#include <sound/core.h>
27#include <sound/pcm.h>
28#include "lola.h"
29
Takashi Iwai333ff392011-05-03 16:41:02 +020030#define LOLA_MAX_BDL_ENTRIES 8
Takashi Iwaid43f30102011-05-03 16:14:46 +020031#define LOLA_MAX_BUF_SIZE (1024*1024*1024)
Takashi Iwai333ff392011-05-03 16:41:02 +020032#define LOLA_BDL_ENTRY_SIZE (16 * 16)
33
Takashi Iwaid43f30102011-05-03 16:14:46 +020034static struct lola_pcm *lola_get_pcm(struct snd_pcm_substream *substream)
35{
36 struct lola *chip = snd_pcm_substream_chip(substream);
37 return &chip->pcm[substream->stream];
38}
39
40static struct lola_stream *lola_get_stream(struct snd_pcm_substream *substream)
41{
42 struct lola_pcm *pcm = lola_get_pcm(substream);
43 unsigned int idx = substream->number;
44 return &pcm->streams[idx];
45}
46
47static unsigned int lola_get_lrc(struct lola *chip)
48{
49 return lola_readl(chip, BAR1, LRC);
50}
51
52static unsigned int lola_get_tstamp(struct lola *chip, bool quick_no_sync)
53{
54 unsigned int tstamp = lola_get_lrc(chip) >> 8;
55 if (chip->granularity) {
56 unsigned int wait_banks = quick_no_sync ? 0 : 8;
57 tstamp += (wait_banks + 1) * chip->granularity - 1;
58 tstamp -= tstamp % chip->granularity;
59 }
60 return tstamp << 8;
61}
62
63/* clear any pending interrupt status */
64static void lola_stream_clear_pending_irq(struct lola *chip,
65 struct lola_stream *str)
66{
67 unsigned int val = lola_dsd_read(chip, str->dsd, STS);
68 val &= LOLA_DSD_STS_DESE | LOLA_DSD_STS_BCIS;
69 if (val)
70 lola_dsd_write(chip, str->dsd, STS, val);
71}
72
73static void lola_stream_start(struct lola *chip, struct lola_stream *str,
74 unsigned int tstamp)
75{
76 lola_stream_clear_pending_irq(chip, str);
77 lola_dsd_write(chip, str->dsd, CTL,
78 LOLA_DSD_CTL_SRUN |
79 LOLA_DSD_CTL_IOCE |
80 LOLA_DSD_CTL_DEIE |
81 LOLA_DSD_CTL_VLRCV |
82 tstamp);
83}
84
85static void lola_stream_stop(struct lola *chip, struct lola_stream *str,
86 unsigned int tstamp)
87{
88 lola_dsd_write(chip, str->dsd, CTL,
89 LOLA_DSD_CTL_IOCE |
90 LOLA_DSD_CTL_DEIE |
91 LOLA_DSD_CTL_VLRCV |
92 tstamp);
93 lola_stream_clear_pending_irq(chip, str);
94}
95
Takashi Iwaid43f30102011-05-03 16:14:46 +020096static void wait_for_srst_clear(struct lola *chip, struct lola_stream *str)
97{
Takashi Iwai333ff392011-05-03 16:41:02 +020098 unsigned long end_time = jiffies + msecs_to_jiffies(200);
Takashi Iwaid43f30102011-05-03 16:14:46 +020099 while (time_before(jiffies, end_time)) {
100 unsigned int val;
101 val = lola_dsd_read(chip, str->dsd, CTL);
102 if (!(val & LOLA_DSD_CTL_SRST))
103 return;
104 msleep(1);
105 }
Takashi Iwaif58e2fc2014-02-25 17:23:57 +0100106 dev_warn(chip->card->dev, "SRST not clear (stream %d)\n", str->dsd);
Takashi Iwaid43f30102011-05-03 16:14:46 +0200107}
108
Takashi Iwai0f8f56c2011-05-03 16:47:03 +0200109static int lola_stream_wait_for_fifo(struct lola *chip,
110 struct lola_stream *str,
111 bool ready)
Takashi Iwaid43f30102011-05-03 16:14:46 +0200112{
Takashi Iwai0f8f56c2011-05-03 16:47:03 +0200113 unsigned int val = ready ? LOLA_DSD_STS_FIFORDY : 0;
114 unsigned long end_time = jiffies + msecs_to_jiffies(200);
Takashi Iwaid43f30102011-05-03 16:14:46 +0200115 while (time_before(jiffies, end_time)) {
Takashi Iwai0f8f56c2011-05-03 16:47:03 +0200116 unsigned int reg = lola_dsd_read(chip, str->dsd, STS);
117 if ((reg & LOLA_DSD_STS_FIFORDY) == val)
Takashi Iwaid43f30102011-05-03 16:14:46 +0200118 return 0;
119 msleep(1);
120 }
Takashi Iwaif58e2fc2014-02-25 17:23:57 +0100121 dev_warn(chip->card->dev, "FIFO not ready (stream %d)\n", str->dsd);
Takashi Iwaid43f30102011-05-03 16:14:46 +0200122 return -EIO;
123}
124
Takashi Iwaic7aad3c2011-05-03 17:02:35 +0200125/* sync for FIFO ready/empty for all linked streams;
126 * clear paused flag when FIFO gets ready again
127 */
128static int lola_sync_wait_for_fifo(struct lola *chip,
129 struct snd_pcm_substream *substream,
130 bool ready)
131{
132 unsigned int val = ready ? LOLA_DSD_STS_FIFORDY : 0;
133 unsigned long end_time = jiffies + msecs_to_jiffies(200);
134 struct snd_pcm_substream *s;
135 int pending = 0;
136
137 while (time_before(jiffies, end_time)) {
138 pending = 0;
139 snd_pcm_group_for_each_entry(s, substream) {
140 struct lola_stream *str;
141 if (s->pcm->card != substream->pcm->card)
142 continue;
143 str = lola_get_stream(s);
144 if (str->prepared && str->paused) {
145 unsigned int reg;
146 reg = lola_dsd_read(chip, str->dsd, STS);
147 if ((reg & LOLA_DSD_STS_FIFORDY) != val) {
148 pending = str->dsd + 1;
149 break;
150 }
151 if (ready)
152 str->paused = 0;
153 }
154 }
155 if (!pending)
156 return 0;
157 msleep(1);
158 }
Takashi Iwaif58e2fc2014-02-25 17:23:57 +0100159 dev_warn(chip->card->dev, "FIFO not ready (pending %d)\n", pending - 1);
Takashi Iwaic7aad3c2011-05-03 17:02:35 +0200160 return -EIO;
161}
162
163/* finish pause - prepare for a new resume */
164static void lola_sync_pause(struct lola *chip,
165 struct snd_pcm_substream *substream)
166{
167 struct snd_pcm_substream *s;
168
169 lola_sync_wait_for_fifo(chip, substream, false);
170 snd_pcm_group_for_each_entry(s, substream) {
171 struct lola_stream *str;
172 if (s->pcm->card != substream->pcm->card)
173 continue;
174 str = lola_get_stream(s);
175 if (str->paused && str->prepared)
176 lola_dsd_write(chip, str->dsd, CTL, LOLA_DSD_CTL_SRUN |
177 LOLA_DSD_CTL_IOCE | LOLA_DSD_CTL_DEIE);
178 }
179 lola_sync_wait_for_fifo(chip, substream, true);
180}
181
Takashi Iwai0f8f56c2011-05-03 16:47:03 +0200182static void lola_stream_reset(struct lola *chip, struct lola_stream *str)
183{
184 if (str->prepared) {
Takashi Iwaic7aad3c2011-05-03 17:02:35 +0200185 if (str->paused)
186 lola_sync_pause(chip, str->substream);
Takashi Iwai0f8f56c2011-05-03 16:47:03 +0200187 str->prepared = 0;
Takashi Iwai0f8f56c2011-05-03 16:47:03 +0200188 lola_dsd_write(chip, str->dsd, CTL,
189 LOLA_DSD_CTL_IOCE | LOLA_DSD_CTL_DEIE);
190 lola_stream_wait_for_fifo(chip, str, false);
191 lola_stream_clear_pending_irq(chip, str);
192 lola_dsd_write(chip, str->dsd, CTL, LOLA_DSD_CTL_SRST);
193 lola_dsd_write(chip, str->dsd, LVI, 0);
194 lola_dsd_write(chip, str->dsd, BDPU, 0);
195 lola_dsd_write(chip, str->dsd, BDPL, 0);
196 wait_for_srst_clear(chip, str);
197 }
198}
199
Takashi Iwaid43f30102011-05-03 16:14:46 +0200200static struct snd_pcm_hardware lola_pcm_hw = {
201 .info = (SNDRV_PCM_INFO_MMAP |
202 SNDRV_PCM_INFO_INTERLEAVED |
203 SNDRV_PCM_INFO_BLOCK_TRANSFER |
204 SNDRV_PCM_INFO_MMAP_VALID |
205 SNDRV_PCM_INFO_PAUSE),
206 .formats = (SNDRV_PCM_FMTBIT_S16_LE |
207 SNDRV_PCM_FMTBIT_S24_LE |
208 SNDRV_PCM_FMTBIT_S32_LE |
209 SNDRV_PCM_FMTBIT_FLOAT_LE),
Takashi Iwai0f8f56c2011-05-03 16:47:03 +0200210 .rates = SNDRV_PCM_RATE_8000_192000,
211 .rate_min = 8000,
212 .rate_max = 192000,
Takashi Iwaid43f30102011-05-03 16:14:46 +0200213 .channels_min = 1,
214 .channels_max = 2,
215 .buffer_bytes_max = LOLA_MAX_BUF_SIZE,
216 .period_bytes_min = 128,
217 .period_bytes_max = LOLA_MAX_BUF_SIZE / 2,
218 .periods_min = 2,
Takashi Iwai0f8f56c2011-05-03 16:47:03 +0200219 .periods_max = LOLA_MAX_BDL_ENTRIES,
Takashi Iwaid43f30102011-05-03 16:14:46 +0200220 .fifo_size = 0,
221};
222
223static int lola_pcm_open(struct snd_pcm_substream *substream)
224{
225 struct lola *chip = snd_pcm_substream_chip(substream);
226 struct lola_pcm *pcm = lola_get_pcm(substream);
227 struct lola_stream *str = lola_get_stream(substream);
228 struct snd_pcm_runtime *runtime = substream->runtime;
Takashi Iwaid43f30102011-05-03 16:14:46 +0200229
230 mutex_lock(&chip->open_mutex);
231 if (str->opened) {
232 mutex_unlock(&chip->open_mutex);
233 return -EBUSY;
234 }
Takashi Iwaid43f30102011-05-03 16:14:46 +0200235 str->substream = substream;
236 str->master = NULL;
237 str->opened = 1;
238 runtime->hw = lola_pcm_hw;
239 runtime->hw.channels_max = pcm->num_streams - str->index;
Takashi Iwai7e79f222011-05-03 16:59:27 +0200240 if (chip->sample_rate) {
241 /* sample rate is locked */
242 runtime->hw.rate_min = chip->sample_rate;
243 runtime->hw.rate_max = chip->sample_rate;
244 } else {
245 runtime->hw.rate_min = chip->sample_rate_min;
246 runtime->hw.rate_max = chip->sample_rate_max;
247 }
248 chip->ref_count_rate++;
Takashi Iwaid43f30102011-05-03 16:14:46 +0200249 snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
Takashi Iwai7e79f222011-05-03 16:59:27 +0200250 /* period size = multiple of chip->granularity (8, 16 or 32 frames)*/
Takashi Iwai0f8f56c2011-05-03 16:47:03 +0200251 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
Takashi Iwai8bd172d2011-05-03 16:51:56 +0200252 chip->granularity);
Takashi Iwai0f8f56c2011-05-03 16:47:03 +0200253 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
Takashi Iwai8bd172d2011-05-03 16:51:56 +0200254 chip->granularity);
Takashi Iwaid43f30102011-05-03 16:14:46 +0200255 mutex_unlock(&chip->open_mutex);
256 return 0;
257}
258
259static void lola_cleanup_slave_streams(struct lola_pcm *pcm,
260 struct lola_stream *str)
261{
262 int i;
263 for (i = str->index + 1; i < pcm->num_streams; i++) {
264 struct lola_stream *s = &pcm->streams[i];
265 if (s->master != str)
266 break;
267 s->master = NULL;
268 s->opened = 0;
269 }
270}
271
272static int lola_pcm_close(struct snd_pcm_substream *substream)
273{
274 struct lola *chip = snd_pcm_substream_chip(substream);
275 struct lola_stream *str = lola_get_stream(substream);
276
277 mutex_lock(&chip->open_mutex);
278 if (str->substream == substream) {
279 str->substream = NULL;
280 str->opened = 0;
281 }
Takashi Iwai7e79f222011-05-03 16:59:27 +0200282 if (--chip->ref_count_rate == 0) {
283 /* release sample rate */
284 chip->sample_rate = 0;
285 }
Takashi Iwaid43f30102011-05-03 16:14:46 +0200286 mutex_unlock(&chip->open_mutex);
287 return 0;
288}
289
290static int lola_pcm_hw_params(struct snd_pcm_substream *substream,
291 struct snd_pcm_hw_params *hw_params)
292{
293 struct lola_stream *str = lola_get_stream(substream);
294
295 str->bufsize = 0;
296 str->period_bytes = 0;
297 str->format_verb = 0;
298 return snd_pcm_lib_malloc_pages(substream,
299 params_buffer_bytes(hw_params));
300}
301
302static int lola_pcm_hw_free(struct snd_pcm_substream *substream)
303{
304 struct lola *chip = snd_pcm_substream_chip(substream);
305 struct lola_pcm *pcm = lola_get_pcm(substream);
306 struct lola_stream *str = lola_get_stream(substream);
307
308 mutex_lock(&chip->open_mutex);
309 lola_stream_reset(chip, str);
310 lola_cleanup_slave_streams(pcm, str);
311 mutex_unlock(&chip->open_mutex);
312 return snd_pcm_lib_free_pages(substream);
313}
314
315/*
316 * set up a BDL entry
317 */
318static int setup_bdle(struct snd_pcm_substream *substream,
319 struct lola_stream *str, u32 **bdlp,
320 int ofs, int size)
321{
322 u32 *bdl = *bdlp;
323
324 while (size > 0) {
325 dma_addr_t addr;
326 int chunk;
327
328 if (str->frags >= LOLA_MAX_BDL_ENTRIES)
329 return -EINVAL;
330
Takashi Iwai972505c2011-05-03 16:50:51 +0200331 addr = snd_pcm_sgbuf_get_addr(substream, ofs);
Takashi Iwaid43f30102011-05-03 16:14:46 +0200332 /* program the address field of the BDL entry */
333 bdl[0] = cpu_to_le32((u32)addr);
334 bdl[1] = cpu_to_le32(upper_32_bits(addr));
335 /* program the size field of the BDL entry */
Takashi Iwai972505c2011-05-03 16:50:51 +0200336 chunk = snd_pcm_sgbuf_get_chunk_size(substream, ofs, size);
Takashi Iwaid43f30102011-05-03 16:14:46 +0200337 bdl[2] = cpu_to_le32(chunk);
338 /* program the IOC to enable interrupt
339 * only when the whole fragment is processed
340 */
341 size -= chunk;
342 bdl[3] = size ? 0 : cpu_to_le32(0x01);
343 bdl += 4;
344 str->frags++;
345 ofs += chunk;
346 }
347 *bdlp = bdl;
348 return ofs;
349}
350
351/*
352 * set up BDL entries
353 */
Takashi Iwai333ff392011-05-03 16:41:02 +0200354static int lola_setup_periods(struct lola *chip, struct lola_pcm *pcm,
Takashi Iwaid43f30102011-05-03 16:14:46 +0200355 struct snd_pcm_substream *substream,
356 struct lola_stream *str)
357{
358 u32 *bdl;
359 int i, ofs, periods, period_bytes;
360
361 period_bytes = str->period_bytes;
362 periods = str->bufsize / period_bytes;
363
364 /* program the initial BDL entries */
Takashi Iwai333ff392011-05-03 16:41:02 +0200365 bdl = (u32 *)(pcm->bdl.area + LOLA_BDL_ENTRY_SIZE * str->index);
Takashi Iwaid43f30102011-05-03 16:14:46 +0200366 ofs = 0;
367 str->frags = 0;
368 for (i = 0; i < periods; i++) {
369 ofs = setup_bdle(substream, str, &bdl, ofs, period_bytes);
370 if (ofs < 0)
371 goto error;
372 }
373 return 0;
374
375 error:
Takashi Iwaif58e2fc2014-02-25 17:23:57 +0100376 dev_err(chip->card->dev, "Too many BDL entries: buffer=%d, period=%d\n",
Takashi Iwaid43f30102011-05-03 16:14:46 +0200377 str->bufsize, period_bytes);
378 return -EINVAL;
379}
380
381static unsigned int lola_get_format_verb(struct snd_pcm_substream *substream)
382{
383 unsigned int verb;
384
385 switch (substream->runtime->format) {
386 case SNDRV_PCM_FORMAT_S16_LE:
387 verb = 0x00000000;
388 break;
389 case SNDRV_PCM_FORMAT_S24_LE:
390 verb = 0x00000200;
391 break;
392 case SNDRV_PCM_FORMAT_S32_LE:
393 verb = 0x00000300;
394 break;
395 case SNDRV_PCM_FORMAT_FLOAT_LE:
396 verb = 0x00001300;
397 break;
398 default:
399 return 0;
400 }
401 verb |= substream->runtime->channels;
402 return verb;
403}
404
405static int lola_set_stream_config(struct lola *chip,
406 struct lola_stream *str,
407 int channels)
408{
409 int i, err;
410 unsigned int verb, val;
411
412 /* set format info for all channels
413 * (with only one command for the first channel)
414 */
415 err = lola_codec_read(chip, str->nid, LOLA_VERB_SET_STREAM_FORMAT,
416 str->format_verb, 0, &val, NULL);
417 if (err < 0) {
Takashi Iwaif58e2fc2014-02-25 17:23:57 +0100418 dev_err(chip->card->dev, "Cannot set stream format 0x%x\n",
Takashi Iwaid43f30102011-05-03 16:14:46 +0200419 str->format_verb);
420 return err;
421 }
422
423 /* update stream - channel config */
424 for (i = 0; i < channels; i++) {
425 verb = (str->index << 6) | i;
426 err = lola_codec_read(chip, str[i].nid,
427 LOLA_VERB_SET_CHANNEL_STREAMID, 0, verb,
428 &val, NULL);
429 if (err < 0) {
Takashi Iwaif58e2fc2014-02-25 17:23:57 +0100430 dev_err(chip->card->dev,
431 "Cannot set stream channel %d\n", i);
Takashi Iwaid43f30102011-05-03 16:14:46 +0200432 return err;
433 }
434 }
435 return 0;
436}
437
438/*
439 * set up the SD for streaming
440 */
Takashi Iwai333ff392011-05-03 16:41:02 +0200441static int lola_setup_controller(struct lola *chip, struct lola_pcm *pcm,
442 struct lola_stream *str)
Takashi Iwaid43f30102011-05-03 16:14:46 +0200443{
Takashi Iwai333ff392011-05-03 16:41:02 +0200444 dma_addr_t bdl;
Takashi Iwai0f8f56c2011-05-03 16:47:03 +0200445
446 if (str->prepared)
447 return -EINVAL;
448
Takashi Iwaid43f30102011-05-03 16:14:46 +0200449 /* set up BDL */
Takashi Iwai333ff392011-05-03 16:41:02 +0200450 bdl = pcm->bdl.addr + LOLA_BDL_ENTRY_SIZE * str->index;
451 lola_dsd_write(chip, str->dsd, BDPL, (u32)bdl);
452 lola_dsd_write(chip, str->dsd, BDPU, upper_32_bits(bdl));
Takashi Iwaid43f30102011-05-03 16:14:46 +0200453 /* program the stream LVI (last valid index) of the BDL */
454 lola_dsd_write(chip, str->dsd, LVI, str->frags - 1);
Takashi Iwai0f8f56c2011-05-03 16:47:03 +0200455 lola_stream_clear_pending_irq(chip, str);
Takashi Iwaid43f30102011-05-03 16:14:46 +0200456
Takashi Iwai0f8f56c2011-05-03 16:47:03 +0200457 lola_dsd_write(chip, str->dsd, CTL,
458 LOLA_DSD_CTL_IOCE | LOLA_DSD_CTL_DEIE | LOLA_DSD_CTL_SRUN);
459
460 str->prepared = 1;
461
462 return lola_stream_wait_for_fifo(chip, str, true);
Takashi Iwaid43f30102011-05-03 16:14:46 +0200463}
464
465static int lola_pcm_prepare(struct snd_pcm_substream *substream)
466{
467 struct lola *chip = snd_pcm_substream_chip(substream);
468 struct lola_pcm *pcm = lola_get_pcm(substream);
469 struct lola_stream *str = lola_get_stream(substream);
470 struct snd_pcm_runtime *runtime = substream->runtime;
471 unsigned int bufsize, period_bytes, format_verb;
472 int i, err;
473
474 mutex_lock(&chip->open_mutex);
475 lola_stream_reset(chip, str);
476 lola_cleanup_slave_streams(pcm, str);
Takashi Iwai2db30022011-05-03 17:05:08 +0200477 if (str->index + runtime->channels > pcm->num_streams) {
Takashi Iwaid43f30102011-05-03 16:14:46 +0200478 mutex_unlock(&chip->open_mutex);
479 return -EINVAL;
480 }
481 for (i = 1; i < runtime->channels; i++) {
482 str[i].master = str;
483 str[i].opened = 1;
484 }
485 mutex_unlock(&chip->open_mutex);
486
487 bufsize = snd_pcm_lib_buffer_bytes(substream);
488 period_bytes = snd_pcm_lib_period_bytes(substream);
489 format_verb = lola_get_format_verb(substream);
490
Takashi Iwai0f8f56c2011-05-03 16:47:03 +0200491 str->bufsize = bufsize;
492 str->period_bytes = period_bytes;
493 str->format_verb = format_verb;
494
495 err = lola_setup_periods(chip, pcm, substream, str);
496 if (err < 0)
497 return err;
Takashi Iwaid43f30102011-05-03 16:14:46 +0200498
Takashi Iwai7e79f222011-05-03 16:59:27 +0200499 err = lola_set_sample_rate(chip, runtime->rate);
500 if (err < 0)
501 return err;
502 chip->sample_rate = runtime->rate; /* sample rate gets locked */
503
Takashi Iwaid43f30102011-05-03 16:14:46 +0200504 err = lola_set_stream_config(chip, str, runtime->channels);
505 if (err < 0)
506 return err;
507
Takashi Iwai0f8f56c2011-05-03 16:47:03 +0200508 err = lola_setup_controller(chip, pcm, str);
509 if (err < 0) {
510 lola_stream_reset(chip, str);
511 return err;
512 }
513
514 return 0;
Takashi Iwaid43f30102011-05-03 16:14:46 +0200515}
516
517static int lola_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
518{
519 struct lola *chip = snd_pcm_substream_chip(substream);
520 struct lola_stream *str;
521 struct snd_pcm_substream *s;
522 unsigned int start;
523 unsigned int tstamp;
Takashi Iwai7e79f222011-05-03 16:59:27 +0200524 bool sync_streams;
Takashi Iwaid43f30102011-05-03 16:14:46 +0200525
526 switch (cmd) {
527 case SNDRV_PCM_TRIGGER_START:
528 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
529 case SNDRV_PCM_TRIGGER_RESUME:
530 start = 1;
531 break;
532 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
533 case SNDRV_PCM_TRIGGER_SUSPEND:
534 case SNDRV_PCM_TRIGGER_STOP:
535 start = 0;
536 break;
537 default:
538 return -EINVAL;
539 }
540
Takashi Iwai7e79f222011-05-03 16:59:27 +0200541 /*
542 * sample correct synchronization is only needed starting several
Takashi Iwai2db30022011-05-03 17:05:08 +0200543 * streams. On stop or if only one stream do as quick as possible
Takashi Iwai7e79f222011-05-03 16:59:27 +0200544 */
545 sync_streams = (start && snd_pcm_stream_linked(substream));
546 tstamp = lola_get_tstamp(chip, !sync_streams);
Takashi Iwaid43f30102011-05-03 16:14:46 +0200547 spin_lock(&chip->reg_lock);
548 snd_pcm_group_for_each_entry(s, substream) {
549 if (s->pcm->card != substream->pcm->card)
550 continue;
551 str = lola_get_stream(s);
552 if (start)
553 lola_stream_start(chip, str, tstamp);
554 else
555 lola_stream_stop(chip, str, tstamp);
556 str->running = start;
Takashi Iwai7e79f222011-05-03 16:59:27 +0200557 str->paused = !start;
Takashi Iwaid43f30102011-05-03 16:14:46 +0200558 snd_pcm_trigger_done(s, substream);
559 }
560 spin_unlock(&chip->reg_lock);
561 return 0;
562}
563
564static snd_pcm_uframes_t lola_pcm_pointer(struct snd_pcm_substream *substream)
565{
566 struct lola *chip = snd_pcm_substream_chip(substream);
567 struct lola_stream *str = lola_get_stream(substream);
568 unsigned int pos = lola_dsd_read(chip, str->dsd, LPIB);
569
570 if (pos >= str->bufsize)
571 pos = 0;
572 return bytes_to_frames(substream->runtime, pos);
573}
574
575void lola_pcm_update(struct lola *chip, struct lola_pcm *pcm, unsigned int bits)
576{
577 int i;
578
579 for (i = 0; bits && i < pcm->num_streams; i++) {
580 if (bits & (1 << i)) {
581 struct lola_stream *str = &pcm->streams[i];
582 if (str->substream && str->running)
583 snd_pcm_period_elapsed(str->substream);
584 bits &= ~(1 << i);
585 }
586 }
587}
588
589static struct snd_pcm_ops lola_pcm_ops = {
590 .open = lola_pcm_open,
591 .close = lola_pcm_close,
592 .ioctl = snd_pcm_lib_ioctl,
593 .hw_params = lola_pcm_hw_params,
594 .hw_free = lola_pcm_hw_free,
595 .prepare = lola_pcm_prepare,
596 .trigger = lola_pcm_trigger,
597 .pointer = lola_pcm_pointer,
Takashi Iwai972505c2011-05-03 16:50:51 +0200598 .page = snd_pcm_sgbuf_ops_page,
Takashi Iwaid43f30102011-05-03 16:14:46 +0200599};
600
Bill Pembertone23e7a12012-12-06 12:35:10 -0500601int lola_create_pcm(struct lola *chip)
Takashi Iwaid43f30102011-05-03 16:14:46 +0200602{
603 struct snd_pcm *pcm;
604 int i, err;
605
Takashi Iwai333ff392011-05-03 16:41:02 +0200606 for (i = 0; i < 2; i++) {
607 err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
608 snd_dma_pci_data(chip->pci),
609 PAGE_SIZE, &chip->pcm[i].bdl);
610 if (err < 0)
611 return err;
612 }
613
Takashi Iwaid43f30102011-05-03 16:14:46 +0200614 err = snd_pcm_new(chip->card, "Digigram Lola", 0,
615 chip->pcm[SNDRV_PCM_STREAM_PLAYBACK].num_streams,
616 chip->pcm[SNDRV_PCM_STREAM_CAPTURE].num_streams,
617 &pcm);
618 if (err < 0)
619 return err;
620 strlcpy(pcm->name, "Digigram Lola", sizeof(pcm->name));
621 pcm->private_data = chip;
622 for (i = 0; i < 2; i++) {
623 if (chip->pcm[i].num_streams)
624 snd_pcm_set_ops(pcm, i, &lola_pcm_ops);
625 }
626 /* buffer pre-allocation */
Takashi Iwai972505c2011-05-03 16:50:51 +0200627 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
Takashi Iwaid43f30102011-05-03 16:14:46 +0200628 snd_dma_pci_data(chip->pci),
629 1024 * 64, 32 * 1024 * 1024);
630 return 0;
631}
632
633void lola_free_pcm(struct lola *chip)
634{
Takashi Iwai333ff392011-05-03 16:41:02 +0200635 snd_dma_free_pages(&chip->pcm[0].bdl);
636 snd_dma_free_pages(&chip->pcm[1].bdl);
Takashi Iwaid43f30102011-05-03 16:14:46 +0200637}
638
639/*
640 */
641
642static int lola_init_stream(struct lola *chip, struct lola_stream *str,
643 int idx, int nid, int dir)
644{
645 unsigned int val;
646 int err;
647
648 str->nid = nid;
649 str->index = idx;
650 str->dsd = idx;
651 if (dir == PLAY)
652 str->dsd += MAX_STREAM_IN_COUNT;
653 err = lola_read_param(chip, nid, LOLA_PAR_AUDIO_WIDGET_CAP, &val);
654 if (err < 0) {
Takashi Iwaif58e2fc2014-02-25 17:23:57 +0100655 dev_err(chip->card->dev, "Can't read wcaps for 0x%x\n", nid);
Takashi Iwaid43f30102011-05-03 16:14:46 +0200656 return err;
657 }
658 if (dir == PLAY) {
659 /* test TYPE and bits 0..11 (no test bit9 : Digital = 0/1) */
660 if ((val & 0x00f00dff) != 0x00000010) {
Takashi Iwaif58e2fc2014-02-25 17:23:57 +0100661 dev_err(chip->card->dev,
662 "Invalid wcaps 0x%x for 0x%x\n",
Takashi Iwaid43f30102011-05-03 16:14:46 +0200663 val, nid);
664 return -EINVAL;
665 }
666 } else {
667 /* test TYPE and bits 0..11 (no test bit9 : Digital = 0/1)
668 * (bug : ignore bit8: Conn list = 0/1)
669 */
670 if ((val & 0x00f00cff) != 0x00100010) {
Takashi Iwaif58e2fc2014-02-25 17:23:57 +0100671 dev_err(chip->card->dev,
672 "Invalid wcaps 0x%x for 0x%x\n",
Takashi Iwaid43f30102011-05-03 16:14:46 +0200673 val, nid);
674 return -EINVAL;
675 }
676 /* test bit9:DIGITAL and bit12:SRC_PRESENT*/
677 if ((val & 0x00001200) == 0x00001200)
678 chip->input_src_caps_mask |= (1 << idx);
679 }
680
681 err = lola_read_param(chip, nid, LOLA_PAR_STREAM_FORMATS, &val);
682 if (err < 0) {
Takashi Iwaif58e2fc2014-02-25 17:23:57 +0100683 dev_err(chip->card->dev, "Can't read FORMATS 0x%x\n", nid);
Takashi Iwaid43f30102011-05-03 16:14:46 +0200684 return err;
685 }
686 val &= 3;
687 if (val == 3)
688 str->can_float = true;
689 if (!(val & 1)) {
Takashi Iwaif58e2fc2014-02-25 17:23:57 +0100690 dev_err(chip->card->dev,
691 "Invalid formats 0x%x for 0x%x", val, nid);
Takashi Iwaid43f30102011-05-03 16:14:46 +0200692 return -EINVAL;
693 }
694 return 0;
695}
696
Bill Pembertone23e7a12012-12-06 12:35:10 -0500697int lola_init_pcm(struct lola *chip, int dir, int *nidp)
Takashi Iwaid43f30102011-05-03 16:14:46 +0200698{
699 struct lola_pcm *pcm = &chip->pcm[dir];
700 int i, nid, err;
701
702 nid = *nidp;
703 for (i = 0; i < pcm->num_streams; i++, nid++) {
704 err = lola_init_stream(chip, &pcm->streams[i], i, nid, dir);
705 if (err < 0)
706 return err;
707 }
708 *nidp = nid;
709 return 0;
710}