sound/pci/lola/lola_pcm.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Support for Digigram Lola PCI-e boards
   4  *
   5  *  Copyright (c) 2011 Takashi Iwai <tiwai@suse.de>
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/init.h>
  10 #include <linux/dma-mapping.h>
  11 #include <linux/pci.h>
  12 #include <linux/delay.h>
  13 #include <sound/core.h>
  14 #include <sound/pcm.h>
  15 #include "lola.h"
  16
  17 #define LOLA_MAX_BDL_ENTRIES    8
  18 #define LOLA_MAX_BUF_SIZE       (1024*1024*1024)
  19 #define LOLA_BDL_ENTRY_SIZE     (16 * 16)
  20
  21 static struct lola_pcm *lola_get_pcm(struct snd_pcm_substream *substream)
  22 {
  23         struct lola *chip = snd_pcm_substream_chip(substream);
  24         return &chip->pcm[substream->stream];
  25 }
  26
  27 static struct lola_stream *lola_get_stream(struct snd_pcm_substream *substream)
  28 {
  29         struct lola_pcm *pcm = lola_get_pcm(substream);
  30         unsigned int idx = substream->number;
  31         return &pcm->streams[idx];
  32 }
  33
  34 static unsigned int lola_get_lrc(struct lola *chip)
  35 {
  36         return lola_readl(chip, BAR1, LRC);
  37 }
  38
  39 static unsigned int lola_get_tstamp(struct lola *chip, bool quick_no_sync)
  40 {
  41         unsigned int tstamp = lola_get_lrc(chip) >> 8;
  42         if (chip->granularity) {
  43                 unsigned int wait_banks = quick_no_sync ? 0 : 8;
  44                 tstamp += (wait_banks + 1) * chip->granularity - 1;
  45                 tstamp -= tstamp % chip->granularity;
  46         }
  47         return tstamp << 8;
  48 }
  49
  50 /* clear any pending interrupt status */
  51 static void lola_stream_clear_pending_irq(struct lola *chip,
  52                                           struct lola_stream *str)
  53 {
  54         unsigned int val = lola_dsd_read(chip, str->dsd, STS);
  55         val &= LOLA_DSD_STS_DESE | LOLA_DSD_STS_BCIS;
  56         if (val)
  57                 lola_dsd_write(chip, str->dsd, STS, val);
  58 }
  59
  60 static void lola_stream_start(struct lola *chip, struct lola_stream *str,
  61                               unsigned int tstamp)
  62 {
  63         lola_stream_clear_pending_irq(chip, str);
  64         lola_dsd_write(chip, str->dsd, CTL,
  65                        LOLA_DSD_CTL_SRUN |
  66                        LOLA_DSD_CTL_IOCE |
  67                        LOLA_DSD_CTL_DEIE |
  68                        LOLA_DSD_CTL_VLRCV |
  69                        tstamp);
  70 }
  71
  72 static void lola_stream_stop(struct lola *chip, struct lola_stream *str,
  73                              unsigned int tstamp)
  74 {
  75         lola_dsd_write(chip, str->dsd, CTL,
  76                        LOLA_DSD_CTL_IOCE |
  77                        LOLA_DSD_CTL_DEIE |
  78                        LOLA_DSD_CTL_VLRCV |
  79                        tstamp);
  80         lola_stream_clear_pending_irq(chip, str);
  81 }
  82
  83 static void wait_for_srst_clear(struct lola *chip, struct lola_stream *str)
  84 {
  85         unsigned long end_time = jiffies + msecs_to_jiffies(200);
  86         while (time_before(jiffies, end_time)) {
  87                 unsigned int val;
  88                 val = lola_dsd_read(chip, str->dsd, CTL);
  89                 if (!(val & LOLA_DSD_CTL_SRST))
  90                         return;
  91                 msleep(1);
  92         }
  93         dev_warn(chip->card->dev, "SRST not clear (stream %d)\n", str->dsd);
  94 }
  95
  96 static int lola_stream_wait_for_fifo(struct lola *chip,
  97                                      struct lola_stream *str,
  98                                      bool ready)
  99 {
 100         unsigned int val = ready ? LOLA_DSD_STS_FIFORDY : 0;
 101         unsigned long end_time = jiffies + msecs_to_jiffies(200);
 102         while (time_before(jiffies, end_time)) {
 103                 unsigned int reg = lola_dsd_read(chip, str->dsd, STS);
 104                 if ((reg & LOLA_DSD_STS_FIFORDY) == val)
 105                         return 0;
 106                 msleep(1);
 107         }
 108         dev_warn(chip->card->dev, "FIFO not ready (stream %d)\n", str->dsd);
 109         return -EIO;
 110 }
 111
 112 /* sync for FIFO ready/empty for all linked streams;
 113  * clear paused flag when FIFO gets ready again
 114  */
 115 static int lola_sync_wait_for_fifo(struct lola *chip,
 116                                    struct snd_pcm_substream *substream,
 117                                    bool ready)
 118 {
 119         unsigned int val = ready ? LOLA_DSD_STS_FIFORDY : 0;
 120         unsigned long end_time = jiffies + msecs_to_jiffies(200);
 121         struct snd_pcm_substream *s;
 122         int pending = 0;
 123
 124         while (time_before(jiffies, end_time)) {
 125                 pending = 0;
 126                 snd_pcm_group_for_each_entry(s, substream) {
 127                         struct lola_stream *str;
 128                         if (s->pcm->card != substream->pcm->card)
 129                                 continue;
 130                         str = lola_get_stream(s);
 131                         if (str->prepared && str->paused) {
 132                                 unsigned int reg;
 133                                 reg = lola_dsd_read(chip, str->dsd, STS);
 134                                 if ((reg & LOLA_DSD_STS_FIFORDY) != val) {
 135                                         pending = str->dsd + 1;
 136                                         break;
 137                                 }
 138                                 if (ready)
 139                                         str->paused = 0;
 140                         }
 141                 }
 142                 if (!pending)
 143                         return 0;
 144                 msleep(1);
 145         }
 146         dev_warn(chip->card->dev, "FIFO not ready (pending %d)\n", pending - 1);
 147         return -EIO;
 148 }
 149
 150 /* finish pause - prepare for a new resume */
 151 static void lola_sync_pause(struct lola *chip,
 152                             struct snd_pcm_substream *substream)
 153 {
 154         struct snd_pcm_substream *s;
 155
 156         lola_sync_wait_for_fifo(chip, substream, false);
 157         snd_pcm_group_for_each_entry(s, substream) {
 158                 struct lola_stream *str;
 159                 if (s->pcm->card != substream->pcm->card)
 160                         continue;
 161                 str = lola_get_stream(s);
 162                 if (str->paused && str->prepared)
 163                         lola_dsd_write(chip, str->dsd, CTL, LOLA_DSD_CTL_SRUN |
 164                                        LOLA_DSD_CTL_IOCE | LOLA_DSD_CTL_DEIE);
 165         }
 166         lola_sync_wait_for_fifo(chip, substream, true);
 167 }
 168
 169 static void lola_stream_reset(struct lola *chip, struct lola_stream *str)
 170 {
 171         if (str->prepared) {
 172                 if (str->paused)
 173                         lola_sync_pause(chip, str->substream);
 174                 str->prepared = 0;
 175                 lola_dsd_write(chip, str->dsd, CTL,
 176                                LOLA_DSD_CTL_IOCE | LOLA_DSD_CTL_DEIE);
 177                 lola_stream_wait_for_fifo(chip, str, false);
 178                 lola_stream_clear_pending_irq(chip, str);
 179                 lola_dsd_write(chip, str->dsd, CTL, LOLA_DSD_CTL_SRST);
 180                 lola_dsd_write(chip, str->dsd, LVI, 0);
 181                 lola_dsd_write(chip, str->dsd, BDPU, 0);
 182                 lola_dsd_write(chip, str->dsd, BDPL, 0);
 183                 wait_for_srst_clear(chip, str);
 184         }
 185 }
 186
 187 static const struct snd_pcm_hardware lola_pcm_hw = {
 188         .info =                 (SNDRV_PCM_INFO_MMAP |
 189                                  SNDRV_PCM_INFO_INTERLEAVED |
 190                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
 191                                  SNDRV_PCM_INFO_MMAP_VALID |
 192                                  SNDRV_PCM_INFO_PAUSE),
 193         .formats =              (SNDRV_PCM_FMTBIT_S16_LE |
 194                                  SNDRV_PCM_FMTBIT_S24_LE |
 195                                  SNDRV_PCM_FMTBIT_S32_LE |
 196                                  SNDRV_PCM_FMTBIT_FLOAT_LE),
 197         .rates =                SNDRV_PCM_RATE_8000_192000,
 198         .rate_min =             8000,
 199         .rate_max =             192000,
 200         .channels_min =         1,
 201         .channels_max =         2,
 202         .buffer_bytes_max =     LOLA_MAX_BUF_SIZE,
 203         .period_bytes_min =     128,
 204         .period_bytes_max =     LOLA_MAX_BUF_SIZE / 2,
 205         .periods_min =          2,
 206         .periods_max =          LOLA_MAX_BDL_ENTRIES,
 207         .fifo_size =            0,
 208 };
 209
 210 static int lola_pcm_open(struct snd_pcm_substream *substream)
 211 {
 212         struct lola *chip = snd_pcm_substream_chip(substream);
 213         struct lola_pcm *pcm = lola_get_pcm(substream);
 214         struct lola_stream *str = lola_get_stream(substream);
 215         struct snd_pcm_runtime *runtime = substream->runtime;
 216
 217         mutex_lock(&chip->open_mutex);
 218         if (str->opened) {
 219                 mutex_unlock(&chip->open_mutex);
 220                 return -EBUSY;
 221         }
 222         str->substream = substream;
 223         str->master = NULL;
 224         str->opened = 1;
 225         runtime->hw = lola_pcm_hw;
 226         runtime->hw.channels_max = pcm->num_streams - str->index;
 227         if (chip->sample_rate) {
 228                 /* sample rate is locked */
 229                 runtime->hw.rate_min = chip->sample_rate;
 230                 runtime->hw.rate_max = chip->sample_rate;
 231         } else {
 232                 runtime->hw.rate_min = chip->sample_rate_min;
 233                 runtime->hw.rate_max = chip->sample_rate_max;
 234         }
 235         chip->ref_count_rate++;
 236         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
 237         /* period size = multiple of chip->granularity (8, 16 or 32 frames)*/
 238         snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
 239                                    chip->granularity);
 240         snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
 241                                    chip->granularity);
 242         mutex_unlock(&chip->open_mutex);
 243         return 0;
 244 }
 245
 246 static void lola_cleanup_slave_streams(struct lola_pcm *pcm,
 247                                        struct lola_stream *str)
 248 {
 249         int i;
 250         for (i = str->index + 1; i < pcm->num_streams; i++) {
 251                 struct lola_stream *s = &pcm->streams[i];
 252                 if (s->master != str)
 253                         break;
 254                 s->master = NULL;
 255                 s->opened = 0;
 256         }
 257 }
 258
 259 static int lola_pcm_close(struct snd_pcm_substream *substream)
 260 {
 261         struct lola *chip = snd_pcm_substream_chip(substream);
 262         struct lola_stream *str = lola_get_stream(substream);
 263
 264         mutex_lock(&chip->open_mutex);
 265         if (str->substream == substream) {
 266                 str->substream = NULL;
 267                 str->opened = 0;
 268         }
 269         if (--chip->ref_count_rate == 0) {
 270                 /* release sample rate */
 271                 chip->sample_rate = 0;
 272         }
 273         mutex_unlock(&chip->open_mutex);
 274         return 0;
 275 }
 276
 277 static int lola_pcm_hw_params(struct snd_pcm_substream *substream,
 278                               struct snd_pcm_hw_params *hw_params)
 279 {
 280         struct lola_stream *str = lola_get_stream(substream);
 281
 282         str->bufsize = 0;
 283         str->period_bytes = 0;
 284         str->format_verb = 0;
 285         return 0;
 286 }
 287
 288 static int lola_pcm_hw_free(struct snd_pcm_substream *substream)
 289 {
 290         struct lola *chip = snd_pcm_substream_chip(substream);
 291         struct lola_pcm *pcm = lola_get_pcm(substream);
 292         struct lola_stream *str = lola_get_stream(substream);
 293
 294         mutex_lock(&chip->open_mutex);
 295         lola_stream_reset(chip, str);
 296         lola_cleanup_slave_streams(pcm, str);
 297         mutex_unlock(&chip->open_mutex);
 298         return 0;
 299 }
 300
 301 /*
 302  * set up a BDL entry
 303  */
 304 static int setup_bdle(struct snd_pcm_substream *substream,
 305                       struct lola_stream *str, __le32 **bdlp,
 306                       int ofs, int size)
 307 {
 308         __le32 *bdl = *bdlp;
 309
 310         while (size > 0) {
 311                 dma_addr_t addr;
 312                 int chunk;
 313
 314                 if (str->frags >= LOLA_MAX_BDL_ENTRIES)
 315                         return -EINVAL;
 316
 317                 addr = snd_pcm_sgbuf_get_addr(substream, ofs);
 318                 /* program the address field of the BDL entry */
 319                 bdl[0] = cpu_to_le32((u32)addr);
 320                 bdl[1] = cpu_to_le32(upper_32_bits(addr));
 321                 /* program the size field of the BDL entry */
 322                 chunk = snd_pcm_sgbuf_get_chunk_size(substream, ofs, size);
 323                 bdl[2] = cpu_to_le32(chunk);
 324                 /* program the IOC to enable interrupt
 325                  * only when the whole fragment is processed
 326                  */
 327                 size -= chunk;
 328                 bdl[3] = size ? 0 : cpu_to_le32(0x01);
 329                 bdl += 4;
 330                 str->frags++;
 331                 ofs += chunk;
 332         }
 333         *bdlp = bdl;
 334         return ofs;
 335 }
 336
 337 /*
 338  * set up BDL entries
 339  */
 340 static int lola_setup_periods(struct lola *chip, struct lola_pcm *pcm,
 341                               struct snd_pcm_substream *substream,
 342                               struct lola_stream *str)
 343 {
 344         __le32 *bdl;
 345         int i, ofs, periods, period_bytes;
 346
 347         period_bytes = str->period_bytes;
 348         periods = str->bufsize / period_bytes;
 349
 350         /* program the initial BDL entries */
 351         bdl = (__le32 *)(pcm->bdl.area + LOLA_BDL_ENTRY_SIZE * str->index);
 352         ofs = 0;
 353         str->frags = 0;
 354         for (i = 0; i < periods; i++) {
 355                 ofs = setup_bdle(substream, str, &bdl, ofs, period_bytes);
 356                 if (ofs < 0)
 357                         goto error;
 358         }
 359         return 0;
 360
 361  error:
 362         dev_err(chip->card->dev, "Too many BDL entries: buffer=%d, period=%d\n",
 363                    str->bufsize, period_bytes);
 364         return -EINVAL;
 365 }
 366
 367 static unsigned int lola_get_format_verb(struct snd_pcm_substream *substream)
 368 {
 369         unsigned int verb;
 370
 371         switch (substream->runtime->format) {
 372         case SNDRV_PCM_FORMAT_S16_LE:
 373                 verb = 0x00000000;
 374                 break;
 375         case SNDRV_PCM_FORMAT_S24_LE:
 376                 verb = 0x00000200;
 377                 break;
 378         case SNDRV_PCM_FORMAT_S32_LE:
 379                 verb = 0x00000300;
 380                 break;
 381         case SNDRV_PCM_FORMAT_FLOAT_LE:
 382                 verb = 0x00001300;
 383                 break;
 384         default:
 385                 return 0;
 386         }
 387         verb |= substream->runtime->channels;
 388         return verb;
 389 }
 390
 391 static int lola_set_stream_config(struct lola *chip,
 392                                   struct lola_stream *str,
 393                                   int channels)
 394 {
 395         int i, err;
 396         unsigned int verb, val;
 397
 398         /* set format info for all channels
 399          * (with only one command for the first channel)
 400          */
 401         err = lola_codec_read(chip, str->nid, LOLA_VERB_SET_STREAM_FORMAT,
 402                               str->format_verb, 0, &val, NULL);
 403         if (err < 0) {
 404                 dev_err(chip->card->dev, "Cannot set stream format 0x%x\n",
 405                        str->format_verb);
 406                 return err;
 407         }
 408
 409         /* update stream - channel config */
 410         for (i = 0; i < channels; i++) {
 411                 verb = (str->index << 6) | i;
 412                 err = lola_codec_read(chip, str[i].nid,
 413                                       LOLA_VERB_SET_CHANNEL_STREAMID, 0, verb,
 414                                       &val, NULL);
 415                 if (err < 0) {
 416                         dev_err(chip->card->dev,
 417                                 "Cannot set stream channel %d\n", i);
 418                         return err;
 419                 }
 420         }
 421         return 0;
 422 }
 423
 424 /*
 425  * set up the SD for streaming
 426  */
 427 static int lola_setup_controller(struct lola *chip, struct lola_pcm *pcm,
 428                                  struct lola_stream *str)
 429 {
 430         dma_addr_t bdl;
 431
 432         if (str->prepared)
 433                 return -EINVAL;
 434
 435         /* set up BDL */
 436         bdl = pcm->bdl.addr + LOLA_BDL_ENTRY_SIZE * str->index;
 437         lola_dsd_write(chip, str->dsd, BDPL, (u32)bdl);
 438         lola_dsd_write(chip, str->dsd, BDPU, upper_32_bits(bdl));
 439         /* program the stream LVI (last valid index) of the BDL */
 440         lola_dsd_write(chip, str->dsd, LVI, str->frags - 1);
 441         lola_stream_clear_pending_irq(chip, str);
 442
 443         lola_dsd_write(chip, str->dsd, CTL,
 444                        LOLA_DSD_CTL_IOCE | LOLA_DSD_CTL_DEIE | LOLA_DSD_CTL_SRUN);
 445
 446         str->prepared = 1;
 447
 448         return lola_stream_wait_for_fifo(chip, str, true);
 449 }
 450
 451 static int lola_pcm_prepare(struct snd_pcm_substream *substream)
 452 {
 453         struct lola *chip = snd_pcm_substream_chip(substream);
 454         struct lola_pcm *pcm = lola_get_pcm(substream);
 455         struct lola_stream *str = lola_get_stream(substream);
 456         struct snd_pcm_runtime *runtime = substream->runtime;
 457         unsigned int bufsize, period_bytes, format_verb;
 458         int i, err;
 459
 460         mutex_lock(&chip->open_mutex);
 461         lola_stream_reset(chip, str);
 462         lola_cleanup_slave_streams(pcm, str);
 463         if (str->index + runtime->channels > pcm->num_streams) {
 464                 mutex_unlock(&chip->open_mutex);
 465                 return -EINVAL;
 466         }
 467         for (i = 1; i < runtime->channels; i++) {
 468                 str[i].master = str;
 469                 str[i].opened = 1;
 470         }
 471         mutex_unlock(&chip->open_mutex);
 472
 473         bufsize = snd_pcm_lib_buffer_bytes(substream);
 474         period_bytes = snd_pcm_lib_period_bytes(substream);
 475         format_verb = lola_get_format_verb(substream);
 476
 477         str->bufsize = bufsize;
 478         str->period_bytes = period_bytes;
 479         str->format_verb = format_verb;
 480
 481         err = lola_setup_periods(chip, pcm, substream, str);
 482         if (err < 0)
 483                 return err;
 484
 485         err = lola_set_sample_rate(chip, runtime->rate);
 486         if (err < 0)
 487                 return err;
 488         chip->sample_rate = runtime->rate;      /* sample rate gets locked */
 489
 490         err = lola_set_stream_config(chip, str, runtime->channels);
 491         if (err < 0)
 492                 return err;
 493
 494         err = lola_setup_controller(chip, pcm, str);
 495         if (err < 0) {
 496                 lola_stream_reset(chip, str);
 497                 return err;
 498         }
 499
 500         return 0;
 501 }
 502
 503 static int lola_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 504 {
 505         struct lola *chip = snd_pcm_substream_chip(substream);
 506         struct lola_stream *str;
 507         struct snd_pcm_substream *s;
 508         unsigned int start;
 509         unsigned int tstamp;
 510         bool sync_streams;
 511
 512         switch (cmd) {
 513         case SNDRV_PCM_TRIGGER_START:
 514         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 515         case SNDRV_PCM_TRIGGER_RESUME:
 516                 start = 1;
 517                 break;
 518         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 519         case SNDRV_PCM_TRIGGER_SUSPEND:
 520         case SNDRV_PCM_TRIGGER_STOP:
 521                 start = 0;
 522                 break;
 523         default:
 524                 return -EINVAL;
 525         }
 526
 527         /*
 528          * sample correct synchronization is only needed starting several
 529          * streams. On stop or if only one stream do as quick as possible
 530          */
 531         sync_streams = (start && snd_pcm_stream_linked(substream));
 532         tstamp = lola_get_tstamp(chip, !sync_streams);
 533         spin_lock(&chip->reg_lock);
 534         snd_pcm_group_for_each_entry(s, substream) {
 535                 if (s->pcm->card != substream->pcm->card)
 536                         continue;
 537                 str = lola_get_stream(s);
 538                 if (start)
 539                         lola_stream_start(chip, str, tstamp);
 540                 else
 541                         lola_stream_stop(chip, str, tstamp);
 542                 str->running = start;
 543                 str->paused = !start;
 544                 snd_pcm_trigger_done(s, substream);
 545         }
 546         spin_unlock(&chip->reg_lock);
 547         return 0;
 548 }
 549
 550 static snd_pcm_uframes_t lola_pcm_pointer(struct snd_pcm_substream *substream)
 551 {
 552         struct lola *chip = snd_pcm_substream_chip(substream);
 553         struct lola_stream *str = lola_get_stream(substream);
 554         unsigned int pos = lola_dsd_read(chip, str->dsd, LPIB);
 555
 556         if (pos >= str->bufsize)
 557                 pos = 0;
 558         return bytes_to_frames(substream->runtime, pos);
 559 }
 560
 561 void lola_pcm_update(struct lola *chip, struct lola_pcm *pcm, unsigned int bits)
 562 {
 563         int i;
 564
 565         for (i = 0; bits && i < pcm->num_streams; i++) {
 566                 if (bits & (1 << i)) {
 567                         struct lola_stream *str = &pcm->streams[i];
 568                         if (str->substream && str->running)
 569                                 snd_pcm_period_elapsed(str->substream);
 570                         bits &= ~(1 << i);
 571                 }
 572         }
 573 }
 574
 575 static const struct snd_pcm_ops lola_pcm_ops = {
 576         .open = lola_pcm_open,
 577         .close = lola_pcm_close,
 578         .hw_params = lola_pcm_hw_params,
 579         .hw_free = lola_pcm_hw_free,
 580         .prepare = lola_pcm_prepare,
 581         .trigger = lola_pcm_trigger,
 582         .pointer = lola_pcm_pointer,
 583 };
 584
 585 int lola_create_pcm(struct lola *chip)
 586 {
 587         struct snd_pcm *pcm;
 588         int i, err;
 589
 590         for (i = 0; i < 2; i++) {
 591                 err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
 592                                           &chip->pci->dev,
 593                                           PAGE_SIZE, &chip->pcm[i].bdl);
 594                 if (err < 0)
 595                         return err;
 596         }
 597
 598         err = snd_pcm_new(chip->card, "Digigram Lola", 0,
 599                           chip->pcm[SNDRV_PCM_STREAM_PLAYBACK].num_streams,
 600                           chip->pcm[SNDRV_PCM_STREAM_CAPTURE].num_streams,
 601                           &pcm);
 602         if (err < 0)
 603                 return err;
 604         strscpy(pcm->name, "Digigram Lola", sizeof(pcm->name));
 605         pcm->private_data = chip;
 606         for (i = 0; i < 2; i++) {
 607                 if (chip->pcm[i].num_streams)
 608                         snd_pcm_set_ops(pcm, i, &lola_pcm_ops);
 609         }
 610         /* buffer pre-allocation */
 611         snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
 612                                        &chip->pci->dev,
 613                                        1024 * 64, 32 * 1024 * 1024);
 614         return 0;
 615 }
 616
 617 void lola_free_pcm(struct lola *chip)
 618 {
 619         snd_dma_free_pages(&chip->pcm[0].bdl);
 620         snd_dma_free_pages(&chip->pcm[1].bdl);
 621 }
 622
 623 /*
 624  */
 625
 626 static int lola_init_stream(struct lola *chip, struct lola_stream *str,
 627                             int idx, int nid, int dir)
 628 {
 629         unsigned int val;
 630         int err;
 631
 632         str->nid = nid;
 633         str->index = idx;
 634         str->dsd = idx;
 635         if (dir == PLAY)
 636                 str->dsd += MAX_STREAM_IN_COUNT;
 637         err = lola_read_param(chip, nid, LOLA_PAR_AUDIO_WIDGET_CAP, &val);
 638         if (err < 0) {
 639                 dev_err(chip->card->dev, "Can't read wcaps for 0x%x\n", nid);
 640                 return err;
 641         }
 642         if (dir == PLAY) {
 643                 /* test TYPE and bits 0..11 (no test bit9 : Digital = 0/1) */
 644                 if ((val & 0x00f00dff) != 0x00000010) {
 645                         dev_err(chip->card->dev,
 646                                 "Invalid wcaps 0x%x for 0x%x\n",
 647                                val, nid);
 648                         return -EINVAL;
 649                 }
 650         } else {
 651                 /* test TYPE and bits 0..11 (no test bit9 : Digital = 0/1)
 652                  * (bug : ignore bit8: Conn list = 0/1)
 653                  */
 654                 if ((val & 0x00f00cff) != 0x00100010) {
 655                         dev_err(chip->card->dev,
 656                                 "Invalid wcaps 0x%x for 0x%x\n",
 657                                val, nid);
 658                         return -EINVAL;
 659                 }
 660                 /* test bit9:DIGITAL and bit12:SRC_PRESENT*/
 661                 if ((val & 0x00001200) == 0x00001200)
 662                         chip->input_src_caps_mask |= (1 << idx);
 663         }
 664
 665         err = lola_read_param(chip, nid, LOLA_PAR_STREAM_FORMATS, &val);
 666         if (err < 0) {
 667                 dev_err(chip->card->dev, "Can't read FORMATS 0x%x\n", nid);
 668                 return err;
 669         }
 670         val &= 3;
 671         if (val == 3)
 672                 str->can_float = true;
 673         if (!(val & 1)) {
 674                 dev_err(chip->card->dev,
 675                         "Invalid formats 0x%x for 0x%x", val, nid);
 676                 return -EINVAL;
 677         }
 678         return 0;
 679 }
 680
 681 int lola_init_pcm(struct lola *chip, int dir, int *nidp)
 682 {
 683         struct lola_pcm *pcm = &chip->pcm[dir];
 684         int i, nid, err;
 685
 686         nid = *nidp;
 687         for (i = 0; i < pcm->num_streams; i++, nid++) {
 688                 err = lola_init_stream(chip, &pcm->streams[i], i, nid, dir);
 689                 if (err < 0)
 690                         return err;
 691         }
 692         *nidp = nid;
 693         return 0;
 694 }