sound/pci/lola/lola_pcm.c

   1 /*
   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>
  25 #include <linux/delay.h>
  26 #include <sound/core.h>
  27 #include <sound/pcm.h>
  28 #include "lola.h"
  29
  30 #define LOLA_MAX_BDL_ENTRIES    8
  31 #define LOLA_MAX_BUF_SIZE       (1024*1024*1024)
  32 #define LOLA_BDL_ENTRY_SIZE     (16 * 16)
  33
  34 static 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
  40 static 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
  47 static unsigned int lola_get_lrc(struct lola *chip)
  48 {
  49         return lola_readl(chip, BAR1, LRC);
  50 }
  51
  52 static 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 */
  64 static 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
  73 static 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
  85 static 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
  96 static void wait_for_srst_clear(struct lola *chip, struct lola_stream *str)
  97 {
  98         unsigned long end_time = jiffies + msecs_to_jiffies(200);
  99         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         }
 106         dev_warn(chip->card->dev, "SRST not clear (stream %d)\n", str->dsd);
 107 }
 108
 109 static int lola_stream_wait_for_fifo(struct lola *chip,
 110                                      struct lola_stream *str,
 111                                      bool ready)
 112 {
 113         unsigned int val = ready ? LOLA_DSD_STS_FIFORDY : 0;
 114         unsigned long end_time = jiffies + msecs_to_jiffies(200);
 115         while (time_before(jiffies, end_time)) {
 116                 unsigned int reg = lola_dsd_read(chip, str->dsd, STS);
 117                 if ((reg & LOLA_DSD_STS_FIFORDY) == val)
 118                         return 0;
 119                 msleep(1);
 120         }
 121         dev_warn(chip->card->dev, "FIFO not ready (stream %d)\n", str->dsd);
 122         return -EIO;
 123 }
 124
 125 /* sync for FIFO ready/empty for all linked streams;
 126  * clear paused flag when FIFO gets ready again
 127  */
 128 static 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         }
 159         dev_warn(chip->card->dev, "FIFO not ready (pending %d)\n", pending - 1);
 160         return -EIO;
 161 }
 162
 163 /* finish pause - prepare for a new resume */
 164 static 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
 182 static void lola_stream_reset(struct lola *chip, struct lola_stream *str)
 183 {
 184         if (str->prepared) {
 185                 if (str->paused)
 186                         lola_sync_pause(chip, str->substream);
 187                 str->prepared = 0;
 188                 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
 200 static 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),
 210         .rates =                SNDRV_PCM_RATE_8000_192000,
 211         .rate_min =             8000,
 212         .rate_max =             192000,
 213         .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,
 219         .periods_max =          LOLA_MAX_BDL_ENTRIES,
 220         .fifo_size =            0,
 221 };
 222
 223 static 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;
 229
 230         mutex_lock(&chip->open_mutex);
 231         if (str->opened) {
 232                 mutex_unlock(&chip->open_mutex);
 233                 return -EBUSY;
 234         }
 235         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;
 240         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++;
 249         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
 250         /* period size = multiple of chip->granularity (8, 16 or 32 frames)*/
 251         snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
 252                                    chip->granularity);
 253         snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
 254                                    chip->granularity);
 255         mutex_unlock(&chip->open_mutex);
 256         return 0;
 257 }
 258
 259 static 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
 272 static 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         }
 282         if (--chip->ref_count_rate == 0) {
 283                 /* release sample rate */
 284                 chip->sample_rate = 0;
 285         }
 286         mutex_unlock(&chip->open_mutex);
 287         return 0;
 288 }
 289
 290 static 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
 302 static 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  */
 318 static 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
 331                 addr = snd_pcm_sgbuf_get_addr(substream, ofs);
 332                 /* 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 */
 336                 chunk = snd_pcm_sgbuf_get_chunk_size(substream, ofs, size);
 337                 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  */
 354 static int lola_setup_periods(struct lola *chip, struct lola_pcm *pcm,
 355                               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 */
 365         bdl = (u32 *)(pcm->bdl.area + LOLA_BDL_ENTRY_SIZE * str->index);
 366         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:
 376         dev_err(chip->card->dev, "Too many BDL entries: buffer=%d, period=%d\n",
 377                    str->bufsize, period_bytes);
 378         return -EINVAL;
 379 }
 380
 381 static 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
 405 static 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) {
 418                 dev_err(chip->card->dev, "Cannot set stream format 0x%x\n",
 419                        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) {
 430                         dev_err(chip->card->dev,
 431                                 "Cannot set stream channel %d\n", i);
 432                         return err;
 433                 }
 434         }
 435         return 0;
 436 }
 437
 438 /*
 439  * set up the SD for streaming
 440  */
 441 static int lola_setup_controller(struct lola *chip, struct lola_pcm *pcm,
 442                                  struct lola_stream *str)
 443 {
 444         dma_addr_t bdl;
 445
 446         if (str->prepared)
 447                 return -EINVAL;
 448
 449         /* set up BDL */
 450         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));
 453         /* program the stream LVI (last valid index) of the BDL */
 454         lola_dsd_write(chip, str->dsd, LVI, str->frags - 1);
 455         lola_stream_clear_pending_irq(chip, str);
 456
 457         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);
 463 }
 464
 465 static 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);
 477         if (str->index + runtime->channels > pcm->num_streams) {
 478                 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
 491         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;
 498
 499         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
 504         err = lola_set_stream_config(chip, str, runtime->channels);
 505         if (err < 0)
 506                 return err;
 507
 508         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;
 515 }
 516
 517 static 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;
 524         bool sync_streams;
 525
 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
 541         /*
 542          * sample correct synchronization is only needed starting several
 543          * streams. On stop or if only one stream do as quick as possible
 544          */
 545         sync_streams = (start && snd_pcm_stream_linked(substream));
 546         tstamp = lola_get_tstamp(chip, !sync_streams);
 547         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;
 557                 str->paused = !start;
 558                 snd_pcm_trigger_done(s, substream);
 559         }
 560         spin_unlock(&chip->reg_lock);
 561         return 0;
 562 }
 563
 564 static 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
 575 void 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
 589 static const 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,
 598         .page = snd_pcm_sgbuf_ops_page,
 599 };
 600
 601 int lola_create_pcm(struct lola *chip)
 602 {
 603         struct snd_pcm *pcm;
 604         int i, err;
 605
 606         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
 614         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 */
 627         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
 628                                               snd_dma_pci_data(chip->pci),
 629                                               1024 * 64, 32 * 1024 * 1024);
 630         return 0;
 631 }
 632
 633 void lola_free_pcm(struct lola *chip)
 634 {
 635         snd_dma_free_pages(&chip->pcm[0].bdl);
 636         snd_dma_free_pages(&chip->pcm[1].bdl);
 637 }
 638
 639 /*
 640  */
 641
 642 static 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) {
 655                 dev_err(chip->card->dev, "Can't read wcaps for 0x%x\n", nid);
 656                 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) {
 661                         dev_err(chip->card->dev,
 662                                 "Invalid wcaps 0x%x for 0x%x\n",
 663                                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) {
 671                         dev_err(chip->card->dev,
 672                                 "Invalid wcaps 0x%x for 0x%x\n",
 673                                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) {
 683                 dev_err(chip->card->dev, "Can't read FORMATS 0x%x\n", nid);
 684                 return err;
 685         }
 686         val &= 3;
 687         if (val == 3)
 688                 str->can_float = true;
 689         if (!(val & 1)) {
 690                 dev_err(chip->card->dev,
 691                         "Invalid formats 0x%x for 0x%x", val, nid);
 692                 return -EINVAL;
 693         }
 694         return 0;
 695 }
 696
 697 int lola_init_pcm(struct lola *chip, int dir, int *nidp)
 698 {
 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 }