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 } 711