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 snd_pcm_lib_malloc_pages(substream,
 286                                         params_buffer_bytes(hw_params));
 287 }
 288
 289 static int lola_pcm_hw_free(struct snd_pcm_substream *substream)
 290 {
 291         struct lola *chip = snd_pcm_substream_chip(substream);
 292         struct lola_pcm *pcm = lola_get_pcm(substream);
 293         struct lola_stream *str = lola_get_stream(substream);
 294
 295         mutex_lock(&chip->open_mutex);
 296         lola_stream_reset(chip, str);
 297         lola_cleanup_slave_streams(pcm, str);
 298         mutex_unlock(&chip->open_mutex);
 299         return snd_pcm_lib_free_pages(substream);
 300 }
 301
 302 /*
 303  * set up a BDL entry
 304  */
 305 static int setup_bdle(struct snd_pcm_substream *substream,
 306                       struct lola_stream *str, __le32 **bdlp,
 307                       int ofs, int size)
 308 {
 309         __le32 *bdl = *bdlp;
 310
 311         while (size > 0) {
 312                 dma_addr_t addr;
 313                 int chunk;
 314
 315                 if (str->frags >= LOLA_MAX_BDL_ENTRIES)
 316                         return -EINVAL;
 317
 318                 addr = snd_pcm_sgbuf_get_addr(substream, ofs);
 319                 /* program the address field of the BDL entry */
 320                 bdl[0] = cpu_to_le32((u32)addr);
 321                 bdl[1] = cpu_to_le32(upper_32_bits(addr));
 322                 /* program the size field of the BDL entry */
 323                 chunk = snd_pcm_sgbuf_get_chunk_size(substream, ofs, size);
 324                 bdl[2] = cpu_to_le32(chunk);
 325                 /* program the IOC to enable interrupt
 326                  * only when the whole fragment is processed
 327                  */
 328                 size -= chunk;
 329                 bdl[3] = size ? 0 : cpu_to_le32(0x01);
 330                 bdl += 4;
 331                 str->frags++;
 332                 ofs += chunk;
 333         }
 334         *bdlp = bdl;
 335         return ofs;
 336 }
 337
 338 /*
 339  * set up BDL entries
 340  */
 341 static int lola_setup_periods(struct lola *chip, struct lola_pcm *pcm,
 342                               struct snd_pcm_substream *substream,
 343                               struct lola_stream *str)
 344 {
 345         __le32 *bdl;
 346         int i, ofs, periods, period_bytes;
 347
 348         period_bytes = str->period_bytes;
 349         periods = str->bufsize / period_bytes;
 350
 351         /* program the initial BDL entries */
 352         bdl = (__le32 *)(pcm->bdl.area + LOLA_BDL_ENTRY_SIZE * str->index);
 353         ofs = 0;
 354         str->frags = 0;
 355         for (i = 0; i < periods; i++) {
 356                 ofs = setup_bdle(substream, str, &bdl, ofs, period_bytes);
 357                 if (ofs < 0)
 358                         goto error;
 359         }
 360         return 0;
 361
 362  error:
 363         dev_err(chip->card->dev, "Too many BDL entries: buffer=%d, period=%d\n",
 364                    str->bufsize, period_bytes);
 365         return -EINVAL;
 366 }
 367
 368 static unsigned int lola_get_format_verb(struct snd_pcm_substream *substream)
 369 {
 370         unsigned int verb;
 371
 372         switch (substream->runtime->format) {
 373         case SNDRV_PCM_FORMAT_S16_LE:
 374                 verb = 0x00000000;
 375                 break;
 376         case SNDRV_PCM_FORMAT_S24_LE:
 377                 verb = 0x00000200;
 378                 break;
 379         case SNDRV_PCM_FORMAT_S32_LE:
 380                 verb = 0x00000300;
 381                 break;
 382         case SNDRV_PCM_FORMAT_FLOAT_LE:
 383                 verb = 0x00001300;
 384                 break;
 385         default:
 386                 return 0;
 387         }
 388         verb |= substream->runtime->channels;
 389         return verb;
 390 }
 391
 392 static int lola_set_stream_config(struct lola *chip,
 393                                   struct lola_stream *str,
 394                                   int channels)
 395 {
 396         int i, err;
 397         unsigned int verb, val;
 398
 399         /* set format info for all channels
 400          * (with only one command for the first channel)
 401          */
 402         err = lola_codec_read(chip, str->nid, LOLA_VERB_SET_STREAM_FORMAT,
 403                               str->format_verb, 0, &val, NULL);
 404         if (err < 0) {
 405                 dev_err(chip->card->dev, "Cannot set stream format 0x%x\n",
 406                        str->format_verb);
 407                 return err;
 408         }
 409
 410         /* update stream - channel config */
 411         for (i = 0; i < channels; i++) {
 412                 verb = (str->index << 6) | i;
 413                 err = lola_codec_read(chip, str[i].nid,
 414                                       LOLA_VERB_SET_CHANNEL_STREAMID, 0, verb,
 415                                       &val, NULL);
 416                 if (err < 0) {
 417                         dev_err(chip->card->dev,
 418                                 "Cannot set stream channel %d\n", i);
 419                         return err;
 420                 }
 421         }
 422         return 0;
 423 }
 424
 425 /*
 426  * set up the SD for streaming
 427  */
 428 static int lola_setup_controller(struct lola *chip, struct lola_pcm *pcm,
 429                                  struct lola_stream *str)
 430 {
 431         dma_addr_t bdl;
 432
 433         if (str->prepared)
 434                 return -EINVAL;
 435
 436         /* set up BDL */
 437         bdl = pcm->bdl.addr + LOLA_BDL_ENTRY_SIZE * str->index;
 438         lola_dsd_write(chip, str->dsd, BDPL, (u32)bdl);
 439         lola_dsd_write(chip, str->dsd, BDPU, upper_32_bits(bdl));
 440         /* program the stream LVI (last valid index) of the BDL */
 441         lola_dsd_write(chip, str->dsd, LVI, str->frags - 1);
 442         lola_stream_clear_pending_irq(chip, str);
 443
 444         lola_dsd_write(chip, str->dsd, CTL,
 445                        LOLA_DSD_CTL_IOCE | LOLA_DSD_CTL_DEIE | LOLA_DSD_CTL_SRUN);
 446
 447         str->prepared = 1;
 448
 449         return lola_stream_wait_for_fifo(chip, str, true);
 450 }
 451
 452 static int lola_pcm_prepare(struct snd_pcm_substream *substream)
 453 {
 454         struct lola *chip = snd_pcm_substream_chip(substream);
 455         struct lola_pcm *pcm = lola_get_pcm(substream);
 456         struct lola_stream *str = lola_get_stream(substream);
 457         struct snd_pcm_runtime *runtime = substream->runtime;
 458         unsigned int bufsize, period_bytes, format_verb;
 459         int i, err;
 460
 461         mutex_lock(&chip->open_mutex);
 462         lola_stream_reset(chip, str);
 463         lola_cleanup_slave_streams(pcm, str);
 464         if (str->index + runtime->channels > pcm->num_streams) {
 465                 mutex_unlock(&chip->open_mutex);
 466                 return -EINVAL;
 467         }
 468         for (i = 1; i < runtime->channels; i++) {
 469                 str[i].master = str;
 470                 str[i].opened = 1;
 471         }
 472         mutex_unlock(&chip->open_mutex);
 473
 474         bufsize = snd_pcm_lib_buffer_bytes(substream);
 475         period_bytes = snd_pcm_lib_period_bytes(substream);
 476         format_verb = lola_get_format_verb(substream);
 477
 478         str->bufsize = bufsize;
 479         str->period_bytes = period_bytes;
 480         str->format_verb = format_verb;
 481
 482         err = lola_setup_periods(chip, pcm, substream, str);
 483         if (err < 0)
 484                 return err;
 485
 486         err = lola_set_sample_rate(chip, runtime->rate);
 487         if (err < 0)
 488                 return err;
 489         chip->sample_rate = runtime->rate;      /* sample rate gets locked */
 490
 491         err = lola_set_stream_config(chip, str, runtime->channels);
 492         if (err < 0)
 493                 return err;
 494
 495         err = lola_setup_controller(chip, pcm, str);
 496         if (err < 0) {
 497                 lola_stream_reset(chip, str);
 498                 return err;
 499         }
 500
 501         return 0;
 502 }
 503
 504 static int lola_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 505 {
 506         struct lola *chip = snd_pcm_substream_chip(substream);
 507         struct lola_stream *str;
 508         struct snd_pcm_substream *s;
 509         unsigned int start;
 510         unsigned int tstamp;
 511         bool sync_streams;
 512
 513         switch (cmd) {
 514         case SNDRV_PCM_TRIGGER_START:
 515         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 516         case SNDRV_PCM_TRIGGER_RESUME:
 517                 start = 1;
 518                 break;
 519         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 520         case SNDRV_PCM_TRIGGER_SUSPEND:
 521         case SNDRV_PCM_TRIGGER_STOP:
 522                 start = 0;
 523                 break;
 524         default:
 525                 return -EINVAL;
 526         }
 527
 528         /*
 529          * sample correct synchronization is only needed starting several
 530          * streams. On stop or if only one stream do as quick as possible
 531          */
 532         sync_streams = (start && snd_pcm_stream_linked(substream));
 533         tstamp = lola_get_tstamp(chip, !sync_streams);
 534         spin_lock(&chip->reg_lock);
 535         snd_pcm_group_for_each_entry(s, substream) {
 536                 if (s->pcm->card != substream->pcm->card)
 537                         continue;
 538                 str = lola_get_stream(s);
 539                 if (start)
 540                         lola_stream_start(chip, str, tstamp);
 541                 else
 542                         lola_stream_stop(chip, str, tstamp);
 543                 str->running = start;
 544                 str->paused = !start;
 545                 snd_pcm_trigger_done(s, substream);
 546         }
 547         spin_unlock(&chip->reg_lock);
 548         return 0;
 549 }
 550
 551 static snd_pcm_uframes_t lola_pcm_pointer(struct snd_pcm_substream *substream)
 552 {
 553         struct lola *chip = snd_pcm_substream_chip(substream);
 554         struct lola_stream *str = lola_get_stream(substream);
 555         unsigned int pos = lola_dsd_read(chip, str->dsd, LPIB);
 556
 557         if (pos >= str->bufsize)
 558                 pos = 0;
 559         return bytes_to_frames(substream->runtime, pos);
 560 }
 561
 562 void lola_pcm_update(struct lola *chip, struct lola_pcm *pcm, unsigned int bits)
 563 {
 564         int i;
 565
 566         for (i = 0; bits && i < pcm->num_streams; i++) {
 567                 if (bits & (1 << i)) {
 568                         struct lola_stream *str = &pcm->streams[i];
 569                         if (str->substream && str->running)
 570                                 snd_pcm_period_elapsed(str->substream);
 571                         bits &= ~(1 << i);
 572                 }
 573         }
 574 }
 575
 576 static const struct snd_pcm_ops lola_pcm_ops = {
 577         .open = lola_pcm_open,
 578         .close = lola_pcm_close,
 579         .ioctl = snd_pcm_lib_ioctl,
 580         .hw_params = lola_pcm_hw_params,
 581         .hw_free = lola_pcm_hw_free,
 582         .prepare = lola_pcm_prepare,
 583         .trigger = lola_pcm_trigger,
 584         .pointer = lola_pcm_pointer,
 585         .page = snd_pcm_sgbuf_ops_page,
 586 };
 587
 588 int lola_create_pcm(struct lola *chip)
 589 {
 590         struct snd_pcm *pcm;
 591         int i, err;
 592
 593         for (i = 0; i < 2; i++) {
 594                 err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
 595                                           snd_dma_pci_data(chip->pci),
 596                                           PAGE_SIZE, &chip->pcm[i].bdl);
 597                 if (err < 0)
 598                         return err;
 599         }
 600
 601         err = snd_pcm_new(chip->card, "Digigram Lola", 0,
 602                           chip->pcm[SNDRV_PCM_STREAM_PLAYBACK].num_streams,
 603                           chip->pcm[SNDRV_PCM_STREAM_CAPTURE].num_streams,
 604                           &pcm);
 605         if (err < 0)
 606                 return err;
 607         strlcpy(pcm->name, "Digigram Lola", sizeof(pcm->name));
 608         pcm->private_data = chip;
 609         for (i = 0; i < 2; i++) {
 610                 if (chip->pcm[i].num_streams)
 611                         snd_pcm_set_ops(pcm, i, &lola_pcm_ops);
 612         }
 613         /* buffer pre-allocation */
 614         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
 615                                               snd_dma_pci_data(chip->pci),
 616                                               1024 * 64, 32 * 1024 * 1024);
 617         return 0;
 618 }
 619
 620 void lola_free_pcm(struct lola *chip)
 621 {
 622         snd_dma_free_pages(&chip->pcm[0].bdl);
 623         snd_dma_free_pages(&chip->pcm[1].bdl);
 624 }
 625
 626 /*
 627  */
 628
 629 static int lola_init_stream(struct lola *chip, struct lola_stream *str,
 630                             int idx, int nid, int dir)
 631 {
 632         unsigned int val;
 633         int err;
 634
 635         str->nid = nid;
 636         str->index = idx;
 637         str->dsd = idx;
 638         if (dir == PLAY)
 639                 str->dsd += MAX_STREAM_IN_COUNT;
 640         err = lola_read_param(chip, nid, LOLA_PAR_AUDIO_WIDGET_CAP, &val);
 641         if (err < 0) {
 642                 dev_err(chip->card->dev, "Can't read wcaps for 0x%x\n", nid);
 643                 return err;
 644         }
 645         if (dir == PLAY) {
 646                 /* test TYPE and bits 0..11 (no test bit9 : Digital = 0/1) */
 647                 if ((val & 0x00f00dff) != 0x00000010) {
 648                         dev_err(chip->card->dev,
 649                                 "Invalid wcaps 0x%x for 0x%x\n",
 650                                val, nid);
 651                         return -EINVAL;
 652                 }
 653         } else {
 654                 /* test TYPE and bits 0..11 (no test bit9 : Digital = 0/1)
 655                  * (bug : ignore bit8: Conn list = 0/1)
 656                  */
 657                 if ((val & 0x00f00cff) != 0x00100010) {
 658                         dev_err(chip->card->dev,
 659                                 "Invalid wcaps 0x%x for 0x%x\n",
 660                                val, nid);
 661                         return -EINVAL;
 662                 }
 663                 /* test bit9:DIGITAL and bit12:SRC_PRESENT*/
 664                 if ((val & 0x00001200) == 0x00001200)
 665                         chip->input_src_caps_mask |= (1 << idx);
 666         }
 667
 668         err = lola_read_param(chip, nid, LOLA_PAR_STREAM_FORMATS, &val);
 669         if (err < 0) {
 670                 dev_err(chip->card->dev, "Can't read FORMATS 0x%x\n", nid);
 671                 return err;
 672         }
 673         val &= 3;
 674         if (val == 3)
 675                 str->can_float = true;
 676         if (!(val & 1)) {
 677                 dev_err(chip->card->dev,
 678                         "Invalid formats 0x%x for 0x%x", val, nid);
 679                 return -EINVAL;
 680         }
 681         return 0;
 682 }
 683
 684 int lola_init_pcm(struct lola *chip, int dir, int *nidp)
 685 {
 686         struct lola_pcm *pcm = &chip->pcm[dir];
 687         int i, nid, err;
 688
 689         nid = *nidp;
 690         for (i = 0; i < pcm->num_streams; i++, nid++) {
 691                 err = lola_init_stream(chip, &pcm->streams[i], i, nid, dir);
 692                 if (err < 0)
 693                         return err;
 694         }
 695         *nidp = nid;
 696         return 0;
 697 }