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         printk(KERN_WARNING SFX "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         printk(KERN_WARNING SFX "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         printk(KERN_WARNING SFX "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         snd_printk(KERN_ERR SFX "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                 printk(KERN_ERR SFX "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                         printk(KERN_ERR SFX "Cannot set stream channel %d\n", i);
 431                         return err;
 432                 }
 433         }
 434         return 0;
 435 }
 436
 437 /*
 438  * set up the SD for streaming
 439  */
 440 static int lola_setup_controller(struct lola *chip, struct lola_pcm *pcm,
 441                                  struct lola_stream *str)
 442 {
 443         dma_addr_t bdl;
 444
 445         if (str->prepared)
 446                 return -EINVAL;
 447
 448         /* set up BDL */
 449         bdl = pcm->bdl.addr + LOLA_BDL_ENTRY_SIZE * str->index;
 450         lola_dsd_write(chip, str->dsd, BDPL, (u32)bdl);
 451         lola_dsd_write(chip, str->dsd, BDPU, upper_32_bits(bdl));
 452         /* program the stream LVI (last valid index) of the BDL */
 453         lola_dsd_write(chip, str->dsd, LVI, str->frags - 1);
 454         lola_stream_clear_pending_irq(chip, str);
 455
 456         lola_dsd_write(chip, str->dsd, CTL,
 457                        LOLA_DSD_CTL_IOCE | LOLA_DSD_CTL_DEIE | LOLA_DSD_CTL_SRUN);
 458
 459         str->prepared = 1;
 460
 461         return lola_stream_wait_for_fifo(chip, str, true);
 462 }
 463
 464 static int lola_pcm_prepare(struct snd_pcm_substream *substream)
 465 {
 466         struct lola *chip = snd_pcm_substream_chip(substream);
 467         struct lola_pcm *pcm = lola_get_pcm(substream);
 468         struct lola_stream *str = lola_get_stream(substream);
 469         struct snd_pcm_runtime *runtime = substream->runtime;
 470         unsigned int bufsize, period_bytes, format_verb;
 471         int i, err;
 472
 473         mutex_lock(&chip->open_mutex);
 474         lola_stream_reset(chip, str);
 475         lola_cleanup_slave_streams(pcm, str);
 476         if (str->index + runtime->channels > pcm->num_streams) {
 477                 mutex_unlock(&chip->open_mutex);
 478                 return -EINVAL;
 479         }
 480         for (i = 1; i < runtime->channels; i++) {
 481                 str[i].master = str;
 482                 str[i].opened = 1;
 483         }
 484         mutex_unlock(&chip->open_mutex);
 485
 486         bufsize = snd_pcm_lib_buffer_bytes(substream);
 487         period_bytes = snd_pcm_lib_period_bytes(substream);
 488         format_verb = lola_get_format_verb(substream);
 489
 490         str->bufsize = bufsize;
 491         str->period_bytes = period_bytes;
 492         str->format_verb = format_verb;
 493
 494         err = lola_setup_periods(chip, pcm, substream, str);
 495         if (err < 0)
 496                 return err;
 497
 498         err = lola_set_sample_rate(chip, runtime->rate);
 499         if (err < 0)
 500                 return err;
 501         chip->sample_rate = runtime->rate;      /* sample rate gets locked */
 502
 503         err = lola_set_stream_config(chip, str, runtime->channels);
 504         if (err < 0)
 505                 return err;
 506
 507         err = lola_setup_controller(chip, pcm, str);
 508         if (err < 0) {
 509                 lola_stream_reset(chip, str);
 510                 return err;
 511         }
 512
 513         return 0;
 514 }
 515
 516 static int lola_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 517 {
 518         struct lola *chip = snd_pcm_substream_chip(substream);
 519         struct lola_stream *str;
 520         struct snd_pcm_substream *s;
 521         unsigned int start;
 522         unsigned int tstamp;
 523         bool sync_streams;
 524
 525         switch (cmd) {
 526         case SNDRV_PCM_TRIGGER_START:
 527         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 528         case SNDRV_PCM_TRIGGER_RESUME:
 529                 start = 1;
 530                 break;
 531         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 532         case SNDRV_PCM_TRIGGER_SUSPEND:
 533         case SNDRV_PCM_TRIGGER_STOP:
 534                 start = 0;
 535                 break;
 536         default:
 537                 return -EINVAL;
 538         }
 539
 540         /*
 541          * sample correct synchronization is only needed starting several
 542          * streams. On stop or if only one stream do as quick as possible
 543          */
 544         sync_streams = (start && snd_pcm_stream_linked(substream));
 545         tstamp = lola_get_tstamp(chip, !sync_streams);
 546         spin_lock(&chip->reg_lock);
 547         snd_pcm_group_for_each_entry(s, substream) {
 548                 if (s->pcm->card != substream->pcm->card)
 549                         continue;
 550                 str = lola_get_stream(s);
 551                 if (start)
 552                         lola_stream_start(chip, str, tstamp);
 553                 else
 554                         lola_stream_stop(chip, str, tstamp);
 555                 str->running = start;
 556                 str->paused = !start;
 557                 snd_pcm_trigger_done(s, substream);
 558         }
 559         spin_unlock(&chip->reg_lock);
 560         return 0;
 561 }
 562
 563 static snd_pcm_uframes_t lola_pcm_pointer(struct snd_pcm_substream *substream)
 564 {
 565         struct lola *chip = snd_pcm_substream_chip(substream);
 566         struct lola_stream *str = lola_get_stream(substream);
 567         unsigned int pos = lola_dsd_read(chip, str->dsd, LPIB);
 568
 569         if (pos >= str->bufsize)
 570                 pos = 0;
 571         return bytes_to_frames(substream->runtime, pos);
 572 }
 573
 574 void lola_pcm_update(struct lola *chip, struct lola_pcm *pcm, unsigned int bits)
 575 {
 576         int i;
 577
 578         for (i = 0; bits && i < pcm->num_streams; i++) {
 579                 if (bits & (1 << i)) {
 580                         struct lola_stream *str = &pcm->streams[i];
 581                         if (str->substream && str->running)
 582                                 snd_pcm_period_elapsed(str->substream);
 583                         bits &= ~(1 << i);
 584                 }
 585         }
 586 }
 587
 588 static struct snd_pcm_ops lola_pcm_ops = {
 589         .open = lola_pcm_open,
 590         .close = lola_pcm_close,
 591         .ioctl = snd_pcm_lib_ioctl,
 592         .hw_params = lola_pcm_hw_params,
 593         .hw_free = lola_pcm_hw_free,
 594         .prepare = lola_pcm_prepare,
 595         .trigger = lola_pcm_trigger,
 596         .pointer = lola_pcm_pointer,
 597         .page = snd_pcm_sgbuf_ops_page,
 598 };
 599
 600 int __devinit lola_create_pcm(struct lola *chip)
 601 {
 602         struct snd_pcm *pcm;
 603         int i, err;
 604
 605         for (i = 0; i < 2; i++) {
 606                 err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
 607                                           snd_dma_pci_data(chip->pci),
 608                                           PAGE_SIZE, &chip->pcm[i].bdl);
 609                 if (err < 0)
 610                         return err;
 611         }
 612
 613         err = snd_pcm_new(chip->card, "Digigram Lola", 0,
 614                           chip->pcm[SNDRV_PCM_STREAM_PLAYBACK].num_streams,
 615                           chip->pcm[SNDRV_PCM_STREAM_CAPTURE].num_streams,
 616                           &pcm);
 617         if (err < 0)
 618                 return err;
 619         strlcpy(pcm->name, "Digigram Lola", sizeof(pcm->name));
 620         pcm->private_data = chip;
 621         for (i = 0; i < 2; i++) {
 622                 if (chip->pcm[i].num_streams)
 623                         snd_pcm_set_ops(pcm, i, &lola_pcm_ops);
 624         }
 625         /* buffer pre-allocation */
 626         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
 627                                               snd_dma_pci_data(chip->pci),
 628                                               1024 * 64, 32 * 1024 * 1024);
 629         return 0;
 630 }
 631
 632 void lola_free_pcm(struct lola *chip)
 633 {
 634         snd_dma_free_pages(&chip->pcm[0].bdl);
 635         snd_dma_free_pages(&chip->pcm[1].bdl);
 636 }
 637
 638 /*
 639  */
 640
 641 static int lola_init_stream(struct lola *chip, struct lola_stream *str,
 642                             int idx, int nid, int dir)
 643 {
 644         unsigned int val;
 645         int err;
 646
 647         str->nid = nid;
 648         str->index = idx;
 649         str->dsd = idx;
 650         if (dir == PLAY)
 651                 str->dsd += MAX_STREAM_IN_COUNT;
 652         err = lola_read_param(chip, nid, LOLA_PAR_AUDIO_WIDGET_CAP, &val);
 653         if (err < 0) {
 654                 printk(KERN_ERR SFX "Can't read wcaps for 0x%x\n", nid);
 655                 return err;
 656         }
 657         if (dir == PLAY) {
 658                 /* test TYPE and bits 0..11 (no test bit9 : Digital = 0/1) */
 659                 if ((val & 0x00f00dff) != 0x00000010) {
 660                         printk(KERN_ERR SFX "Invalid wcaps 0x%x for 0x%x\n",
 661                                val, nid);
 662                         return -EINVAL;
 663                 }
 664         } else {
 665                 /* test TYPE and bits 0..11 (no test bit9 : Digital = 0/1)
 666                  * (bug : ignore bit8: Conn list = 0/1)
 667                  */
 668                 if ((val & 0x00f00cff) != 0x00100010) {
 669                         printk(KERN_ERR SFX "Invalid wcaps 0x%x for 0x%x\n",
 670                                val, nid);
 671                         return -EINVAL;
 672                 }
 673                 /* test bit9:DIGITAL and bit12:SRC_PRESENT*/
 674                 if ((val & 0x00001200) == 0x00001200)
 675                         chip->input_src_caps_mask |= (1 << idx);
 676         }
 677
 678         err = lola_read_param(chip, nid, LOLA_PAR_STREAM_FORMATS, &val);
 679         if (err < 0) {
 680                 printk(KERN_ERR SFX "Can't read FORMATS 0x%x\n", nid);
 681                 return err;
 682         }
 683         val &= 3;
 684         if (val == 3)
 685                 str->can_float = true;
 686         if (!(val & 1)) {
 687                 printk(KERN_ERR SFX "Invalid formats 0x%x for 0x%x", val, nid);
 688                 return -EINVAL;
 689         }
 690         return 0;
 691 }
 692
 693 int __devinit lola_init_pcm(struct lola *chip, int dir, int *nidp)
 694 {
 695         struct lola_pcm *pcm = &chip->pcm[dir];
 696         int i, nid, err;
 697
 698         nid = *nidp;
 699         for (i = 0; i < pcm->num_streams; i++, nid++) {
 700                 err = lola_init_stream(chip, &pcm->streams[i], i, nid, dir);
 701                 if (err < 0)
 702                         return err;
 703         }
 704         *nidp = nid;
 705         return 0;
 706 }