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