1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * i2sbus driver -- pcm routines 4 * 5 * Copyright 2006 Johannes Berg <johannes@sipsolutions.net> 6 */ 7 8 #include <linux/io.h> 9 #include <linux/delay.h> 10 #include <linux/slab.h> 11 #include <sound/core.h> 12 #include <asm/macio.h> 13 #include <linux/pci.h> 14 #include <linux/module.h> 15 #include "../soundbus.h" 16 #include "i2sbus.h" 17 18 static inline void get_pcm_info(struct i2sbus_dev *i2sdev, int in, 19 struct pcm_info **pi, struct pcm_info **other) 20 { 21 if (in) { 22 if (pi) 23 *pi = &i2sdev->in; 24 if (other) 25 *other = &i2sdev->out; 26 } else { 27 if (pi) 28 *pi = &i2sdev->out; 29 if (other) 30 *other = &i2sdev->in; 31 } 32 } 33 34 static int clock_and_divisors(int mclk, int sclk, int rate, int *out) 35 { 36 /* sclk must be derived from mclk! */ 37 if (mclk % sclk) 38 return -1; 39 /* derive sclk register value */ 40 if (i2s_sf_sclkdiv(mclk / sclk, out)) 41 return -1; 42 43 if (I2S_CLOCK_SPEED_18MHz % (rate * mclk) == 0) { 44 if (!i2s_sf_mclkdiv(I2S_CLOCK_SPEED_18MHz / (rate * mclk), out)) { 45 *out |= I2S_SF_CLOCK_SOURCE_18MHz; 46 return 0; 47 } 48 } 49 if (I2S_CLOCK_SPEED_45MHz % (rate * mclk) == 0) { 50 if (!i2s_sf_mclkdiv(I2S_CLOCK_SPEED_45MHz / (rate * mclk), out)) { 51 *out |= I2S_SF_CLOCK_SOURCE_45MHz; 52 return 0; 53 } 54 } 55 if (I2S_CLOCK_SPEED_49MHz % (rate * mclk) == 0) { 56 if (!i2s_sf_mclkdiv(I2S_CLOCK_SPEED_49MHz / (rate * mclk), out)) { 57 *out |= I2S_SF_CLOCK_SOURCE_49MHz; 58 return 0; 59 } 60 } 61 return -1; 62 } 63 64 #define CHECK_RATE(rate) \ 65 do { if (rates & SNDRV_PCM_RATE_ ##rate) { \ 66 int dummy; \ 67 if (clock_and_divisors(sysclock_factor, \ 68 bus_factor, rate, &dummy)) \ 69 rates &= ~SNDRV_PCM_RATE_ ##rate; \ 70 } } while (0) 71 72 static int i2sbus_pcm_open(struct i2sbus_dev *i2sdev, int in) 73 { 74 struct pcm_info *pi, *other; 75 struct soundbus_dev *sdev; 76 int masks_inited = 0, err; 77 struct codec_info_item *cii, *rev; 78 struct snd_pcm_hardware *hw; 79 u64 formats = 0; 80 unsigned int rates = 0; 81 struct transfer_info v; 82 int bus_factor = 0, sysclock_factor = 0; 83 int found_this; 84 85 guard(mutex)(&i2sdev->lock); 86 87 get_pcm_info(i2sdev, in, &pi, &other); 88 89 hw = &pi->substream->runtime->hw; 90 sdev = &i2sdev->sound; 91 92 if (pi->active) { 93 /* alsa messed up */ 94 return -EBUSY; 95 } 96 97 /* we now need to assign the hw */ 98 list_for_each_entry(cii, &sdev->codec_list, list) { 99 struct transfer_info *ti = cii->codec->transfers; 100 bus_factor = cii->codec->bus_factor; 101 sysclock_factor = cii->codec->sysclock_factor; 102 while (ti->formats && ti->rates) { 103 v = *ti; 104 if (ti->transfer_in == in 105 && cii->codec->usable(cii, ti, &v)) { 106 if (masks_inited) { 107 formats &= v.formats; 108 rates &= v.rates; 109 } else { 110 formats = v.formats; 111 rates = v.rates; 112 masks_inited = 1; 113 } 114 } 115 ti++; 116 } 117 } 118 if (!masks_inited || !bus_factor || !sysclock_factor) 119 return -ENODEV; 120 /* bus dependent stuff */ 121 hw->info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | 122 SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_RESUME | 123 SNDRV_PCM_INFO_JOINT_DUPLEX; 124 125 CHECK_RATE(5512); 126 CHECK_RATE(8000); 127 CHECK_RATE(11025); 128 CHECK_RATE(16000); 129 CHECK_RATE(22050); 130 CHECK_RATE(32000); 131 CHECK_RATE(44100); 132 CHECK_RATE(48000); 133 CHECK_RATE(64000); 134 CHECK_RATE(88200); 135 CHECK_RATE(96000); 136 CHECK_RATE(176400); 137 CHECK_RATE(192000); 138 hw->rates = rates; 139 140 /* well. the codec might want 24 bits only, and we'll 141 * ever only transfer 24 bits, but they are top-aligned! 142 * So for alsa, we claim that we're doing full 32 bit 143 * while in reality we'll ignore the lower 8 bits of 144 * that when doing playback (they're transferred as 0 145 * as far as I know, no codecs we have are 32-bit capable 146 * so I can't really test) and when doing recording we'll 147 * always have those lower 8 bits recorded as 0 */ 148 if (formats & SNDRV_PCM_FMTBIT_S24_BE) 149 formats |= SNDRV_PCM_FMTBIT_S32_BE; 150 if (formats & SNDRV_PCM_FMTBIT_U24_BE) 151 formats |= SNDRV_PCM_FMTBIT_U32_BE; 152 /* now mask off what we can support. I suppose we could 153 * also support S24_3LE and some similar formats, but I 154 * doubt there's a codec that would be able to use that, 155 * so we don't support it here. */ 156 hw->formats = formats & (SNDRV_PCM_FMTBIT_S16_BE | 157 SNDRV_PCM_FMTBIT_U16_BE | 158 SNDRV_PCM_FMTBIT_S32_BE | 159 SNDRV_PCM_FMTBIT_U32_BE); 160 161 /* we need to set the highest and lowest rate possible. 162 * These are the highest and lowest rates alsa can 163 * support properly in its bitfield. 164 * Below, we'll use that to restrict to the rate 165 * currently in use (if any). */ 166 hw->rate_min = 5512; 167 hw->rate_max = 192000; 168 /* if the other stream is active, then we can only 169 * support what it is currently using. 170 * FIXME: I lied. This comment is wrong. We can support 171 * anything that works with the same serial format, ie. 172 * when recording 24 bit sound we can well play 16 bit 173 * sound at the same time iff using the same transfer mode. 174 */ 175 if (other->active) { 176 /* FIXME: is this guaranteed by the alsa api? */ 177 hw->formats &= pcm_format_to_bits(i2sdev->format); 178 /* see above, restrict rates to the one we already have */ 179 hw->rate_min = i2sdev->rate; 180 hw->rate_max = i2sdev->rate; 181 } 182 183 hw->channels_min = 2; 184 hw->channels_max = 2; 185 /* these are somewhat arbitrary */ 186 hw->buffer_bytes_max = 131072; 187 hw->period_bytes_min = 256; 188 hw->period_bytes_max = 16384; 189 hw->periods_min = 3; 190 hw->periods_max = MAX_DBDMA_COMMANDS; 191 err = snd_pcm_hw_constraint_integer(pi->substream->runtime, 192 SNDRV_PCM_HW_PARAM_PERIODS); 193 if (err < 0) 194 return err; 195 list_for_each_entry(cii, &sdev->codec_list, list) { 196 if (cii->codec->open) { 197 err = cii->codec->open(cii, pi->substream); 198 if (err) { 199 /* unwind */ 200 found_this = 0; 201 list_for_each_entry_reverse(rev, 202 &sdev->codec_list, list) { 203 if (found_this && rev->codec->close) { 204 rev->codec->close(rev, 205 pi->substream); 206 } 207 if (rev == cii) 208 found_this = 1; 209 } 210 return err; 211 } 212 } 213 } 214 215 return 0; 216 } 217 218 #undef CHECK_RATE 219 220 static int i2sbus_pcm_close(struct i2sbus_dev *i2sdev, int in) 221 { 222 struct codec_info_item *cii; 223 struct pcm_info *pi; 224 int err = 0, tmp; 225 226 guard(mutex)(&i2sdev->lock); 227 228 get_pcm_info(i2sdev, in, &pi, NULL); 229 230 list_for_each_entry(cii, &i2sdev->sound.codec_list, list) { 231 if (cii->codec->close) { 232 tmp = cii->codec->close(cii, pi->substream); 233 if (tmp) 234 err = tmp; 235 } 236 } 237 238 pi->substream = NULL; 239 pi->active = 0; 240 return err; 241 } 242 243 static void i2sbus_wait_for_stop(struct i2sbus_dev *i2sdev, 244 struct pcm_info *pi) 245 { 246 unsigned long flags; 247 DECLARE_COMPLETION_ONSTACK(done); 248 unsigned long time_left; 249 250 spin_lock_irqsave(&i2sdev->low_lock, flags); 251 if (pi->dbdma_ring.stopping) { 252 pi->stop_completion = &done; 253 spin_unlock_irqrestore(&i2sdev->low_lock, flags); 254 time_left = wait_for_completion_timeout(&done, HZ); 255 spin_lock_irqsave(&i2sdev->low_lock, flags); 256 pi->stop_completion = NULL; 257 if (time_left == 0) { 258 /* timeout expired, stop dbdma forcefully */ 259 printk(KERN_ERR "i2sbus_wait_for_stop: timed out\n"); 260 /* make sure RUN, PAUSE and S0 bits are cleared */ 261 out_le32(&pi->dbdma->control, (RUN | PAUSE | 1) << 16); 262 pi->dbdma_ring.stopping = 0; 263 time_left = 10; 264 while (in_le32(&pi->dbdma->status) & ACTIVE) { 265 if (--time_left <= 0) 266 break; 267 udelay(1); 268 } 269 } 270 } 271 spin_unlock_irqrestore(&i2sdev->low_lock, flags); 272 } 273 274 #ifdef CONFIG_PM 275 void i2sbus_wait_for_stop_both(struct i2sbus_dev *i2sdev) 276 { 277 struct pcm_info *pi; 278 279 get_pcm_info(i2sdev, 0, &pi, NULL); 280 i2sbus_wait_for_stop(i2sdev, pi); 281 get_pcm_info(i2sdev, 1, &pi, NULL); 282 i2sbus_wait_for_stop(i2sdev, pi); 283 } 284 #endif 285 286 static inline int i2sbus_hw_free(struct snd_pcm_substream *substream, int in) 287 { 288 struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); 289 struct pcm_info *pi; 290 291 get_pcm_info(i2sdev, in, &pi, NULL); 292 if (pi->dbdma_ring.stopping) 293 i2sbus_wait_for_stop(i2sdev, pi); 294 return 0; 295 } 296 297 static int i2sbus_playback_hw_free(struct snd_pcm_substream *substream) 298 { 299 return i2sbus_hw_free(substream, 0); 300 } 301 302 static int i2sbus_record_hw_free(struct snd_pcm_substream *substream) 303 { 304 return i2sbus_hw_free(substream, 1); 305 } 306 307 static int i2sbus_pcm_prepare(struct i2sbus_dev *i2sdev, int in) 308 { 309 /* whee. Hard work now. The user has selected a bitrate 310 * and bit format, so now we have to program our 311 * I2S controller appropriately. */ 312 struct snd_pcm_runtime *runtime; 313 struct dbdma_cmd *command; 314 int i, periodsize, nperiods; 315 dma_addr_t offset; 316 struct bus_info bi; 317 struct codec_info_item *cii; 318 int sfr = 0; /* serial format register */ 319 int dws = 0; /* data word sizes reg */ 320 int input_16bit; 321 struct pcm_info *pi, *other; 322 int cnt; 323 unsigned int cmd, stopaddr; 324 325 guard(mutex)(&i2sdev->lock); 326 327 get_pcm_info(i2sdev, in, &pi, &other); 328 329 if (pi->dbdma_ring.running) 330 return -EBUSY; 331 if (pi->dbdma_ring.stopping) 332 i2sbus_wait_for_stop(i2sdev, pi); 333 334 if (!pi->substream || !pi->substream->runtime) 335 return -EINVAL; 336 337 runtime = pi->substream->runtime; 338 pi->active = 1; 339 if (other->active && 340 ((i2sdev->format != runtime->format) 341 || (i2sdev->rate != runtime->rate))) 342 return -EINVAL; 343 344 i2sdev->format = runtime->format; 345 i2sdev->rate = runtime->rate; 346 347 periodsize = snd_pcm_lib_period_bytes(pi->substream); 348 nperiods = pi->substream->runtime->periods; 349 pi->current_period = 0; 350 351 /* generate dbdma command ring first */ 352 command = pi->dbdma_ring.cmds; 353 memset(command, 0, (nperiods + 2) * sizeof(struct dbdma_cmd)); 354 355 /* commands to DMA to/from the ring */ 356 /* 357 * For input, we need to do a graceful stop; if we abort 358 * the DMA, we end up with leftover bytes that corrupt 359 * the next recording. To do this we set the S0 status 360 * bit and wait for the DMA controller to stop. Each 361 * command has a branch condition to 362 * make it branch to a stop command if S0 is set. 363 * On input we also need to wait for the S7 bit to be 364 * set before turning off the DMA controller. 365 * In fact we do the graceful stop for output as well. 366 */ 367 offset = runtime->dma_addr; 368 cmd = (in? INPUT_MORE: OUTPUT_MORE) | BR_IFSET | INTR_ALWAYS; 369 stopaddr = pi->dbdma_ring.bus_cmd_start + 370 (nperiods + 1) * sizeof(struct dbdma_cmd); 371 for (i = 0; i < nperiods; i++, command++, offset += periodsize) { 372 command->command = cpu_to_le16(cmd); 373 command->cmd_dep = cpu_to_le32(stopaddr); 374 command->phy_addr = cpu_to_le32(offset); 375 command->req_count = cpu_to_le16(periodsize); 376 } 377 378 /* branch back to beginning of ring */ 379 command->command = cpu_to_le16(DBDMA_NOP | BR_ALWAYS); 380 command->cmd_dep = cpu_to_le32(pi->dbdma_ring.bus_cmd_start); 381 command++; 382 383 /* set stop command */ 384 command->command = cpu_to_le16(DBDMA_STOP); 385 386 /* ok, let's set the serial format and stuff */ 387 switch (runtime->format) { 388 /* 16 bit formats */ 389 case SNDRV_PCM_FORMAT_S16_BE: 390 case SNDRV_PCM_FORMAT_U16_BE: 391 /* FIXME: if we add different bus factors we need to 392 * do more here!! */ 393 bi.bus_factor = 0; 394 list_for_each_entry(cii, &i2sdev->sound.codec_list, list) { 395 bi.bus_factor = cii->codec->bus_factor; 396 break; 397 } 398 if (!bi.bus_factor) 399 return -ENODEV; 400 input_16bit = 1; 401 break; 402 case SNDRV_PCM_FORMAT_S32_BE: 403 case SNDRV_PCM_FORMAT_U32_BE: 404 /* force 64x bus speed, otherwise the data cannot be 405 * transferred quickly enough! */ 406 bi.bus_factor = 64; 407 input_16bit = 0; 408 break; 409 default: 410 return -EINVAL; 411 } 412 /* we assume all sysclocks are the same! */ 413 list_for_each_entry(cii, &i2sdev->sound.codec_list, list) { 414 bi.sysclock_factor = cii->codec->sysclock_factor; 415 break; 416 } 417 418 if (clock_and_divisors(bi.sysclock_factor, 419 bi.bus_factor, 420 runtime->rate, 421 &sfr) < 0) 422 return -EINVAL; 423 switch (bi.bus_factor) { 424 case 32: 425 sfr |= I2S_SF_SERIAL_FORMAT_I2S_32X; 426 break; 427 case 64: 428 sfr |= I2S_SF_SERIAL_FORMAT_I2S_64X; 429 break; 430 } 431 /* FIXME: THIS ASSUMES MASTER ALL THE TIME */ 432 sfr |= I2S_SF_SCLK_MASTER; 433 434 list_for_each_entry(cii, &i2sdev->sound.codec_list, list) { 435 int err = 0; 436 if (cii->codec->prepare) 437 err = cii->codec->prepare(cii, &bi, pi->substream); 438 if (err) 439 return err; 440 } 441 /* codecs are fine with it, so set our clocks */ 442 if (input_16bit) 443 dws = (2 << I2S_DWS_NUM_CHANNELS_IN_SHIFT) | 444 (2 << I2S_DWS_NUM_CHANNELS_OUT_SHIFT) | 445 I2S_DWS_DATA_IN_16BIT | I2S_DWS_DATA_OUT_16BIT; 446 else 447 dws = (2 << I2S_DWS_NUM_CHANNELS_IN_SHIFT) | 448 (2 << I2S_DWS_NUM_CHANNELS_OUT_SHIFT) | 449 I2S_DWS_DATA_IN_24BIT | I2S_DWS_DATA_OUT_24BIT; 450 451 /* early exit if already programmed correctly */ 452 /* not locking these is fine since we touch them only in this function */ 453 if (in_le32(&i2sdev->intfregs->serial_format) == sfr 454 && in_le32(&i2sdev->intfregs->data_word_sizes) == dws) 455 return 0; 456 457 /* let's notify the codecs about clocks going away. 458 * For now we only do mastering on the i2s cell... */ 459 list_for_each_entry(cii, &i2sdev->sound.codec_list, list) 460 if (cii->codec->switch_clock) 461 cii->codec->switch_clock(cii, CLOCK_SWITCH_PREPARE_SLAVE); 462 463 i2sbus_control_enable(i2sdev->control, i2sdev); 464 i2sbus_control_cell(i2sdev->control, i2sdev, 1); 465 466 out_le32(&i2sdev->intfregs->intr_ctl, I2S_PENDING_CLOCKS_STOPPED); 467 468 i2sbus_control_clock(i2sdev->control, i2sdev, 0); 469 470 msleep(1); 471 472 /* wait for clock stopped. This can apparently take a while... */ 473 cnt = 100; 474 while (cnt-- && 475 !(in_le32(&i2sdev->intfregs->intr_ctl) & I2S_PENDING_CLOCKS_STOPPED)) { 476 msleep(5); 477 } 478 out_le32(&i2sdev->intfregs->intr_ctl, I2S_PENDING_CLOCKS_STOPPED); 479 480 /* not locking these is fine since we touch them only in this function */ 481 out_le32(&i2sdev->intfregs->serial_format, sfr); 482 out_le32(&i2sdev->intfregs->data_word_sizes, dws); 483 484 i2sbus_control_enable(i2sdev->control, i2sdev); 485 i2sbus_control_cell(i2sdev->control, i2sdev, 1); 486 i2sbus_control_clock(i2sdev->control, i2sdev, 1); 487 msleep(1); 488 489 list_for_each_entry(cii, &i2sdev->sound.codec_list, list) 490 if (cii->codec->switch_clock) 491 cii->codec->switch_clock(cii, CLOCK_SWITCH_SLAVE); 492 493 return 0; 494 } 495 496 #ifdef CONFIG_PM 497 void i2sbus_pcm_prepare_both(struct i2sbus_dev *i2sdev) 498 { 499 i2sbus_pcm_prepare(i2sdev, 0); 500 i2sbus_pcm_prepare(i2sdev, 1); 501 } 502 #endif 503 504 static int i2sbus_pcm_trigger(struct i2sbus_dev *i2sdev, int in, int cmd) 505 { 506 struct codec_info_item *cii; 507 struct pcm_info *pi; 508 509 guard(spinlock_irqsave)(&i2sdev->low_lock); 510 511 get_pcm_info(i2sdev, in, &pi, NULL); 512 513 switch (cmd) { 514 case SNDRV_PCM_TRIGGER_START: 515 case SNDRV_PCM_TRIGGER_RESUME: 516 if (pi->dbdma_ring.running) 517 return -EALREADY; 518 list_for_each_entry(cii, &i2sdev->sound.codec_list, list) 519 if (cii->codec->start) 520 cii->codec->start(cii, pi->substream); 521 pi->dbdma_ring.running = 1; 522 523 if (pi->dbdma_ring.stopping) { 524 /* Clear the S0 bit, then see if we stopped yet */ 525 out_le32(&pi->dbdma->control, 1 << 16); 526 if (in_le32(&pi->dbdma->status) & ACTIVE) { 527 /* possible race here? */ 528 udelay(10); 529 if (in_le32(&pi->dbdma->status) & ACTIVE) { 530 pi->dbdma_ring.stopping = 0; 531 return 0; /* keep running */ 532 } 533 } 534 } 535 536 /* make sure RUN, PAUSE and S0 bits are cleared */ 537 out_le32(&pi->dbdma->control, (RUN | PAUSE | 1) << 16); 538 539 /* set branch condition select register */ 540 out_le32(&pi->dbdma->br_sel, (1 << 16) | 1); 541 542 /* write dma command buffer address to the dbdma chip */ 543 out_le32(&pi->dbdma->cmdptr, pi->dbdma_ring.bus_cmd_start); 544 545 /* initialize the frame count and current period */ 546 pi->current_period = 0; 547 pi->frame_count = in_le32(&i2sdev->intfregs->frame_count); 548 549 /* set the DMA controller running */ 550 out_le32(&pi->dbdma->control, (RUN << 16) | RUN); 551 552 /* off you go! */ 553 break; 554 555 case SNDRV_PCM_TRIGGER_STOP: 556 case SNDRV_PCM_TRIGGER_SUSPEND: 557 if (!pi->dbdma_ring.running) 558 return -EALREADY; 559 pi->dbdma_ring.running = 0; 560 561 /* Set the S0 bit to make the DMA branch to the stop cmd */ 562 out_le32(&pi->dbdma->control, (1 << 16) | 1); 563 pi->dbdma_ring.stopping = 1; 564 565 list_for_each_entry(cii, &i2sdev->sound.codec_list, list) 566 if (cii->codec->stop) 567 cii->codec->stop(cii, pi->substream); 568 break; 569 default: 570 return -EINVAL; 571 } 572 573 return 0; 574 } 575 576 static snd_pcm_uframes_t i2sbus_pcm_pointer(struct i2sbus_dev *i2sdev, int in) 577 { 578 struct pcm_info *pi; 579 u32 fc; 580 581 get_pcm_info(i2sdev, in, &pi, NULL); 582 583 fc = in_le32(&i2sdev->intfregs->frame_count); 584 fc = fc - pi->frame_count; 585 586 if (fc >= pi->substream->runtime->buffer_size) 587 fc %= pi->substream->runtime->buffer_size; 588 return fc; 589 } 590 591 static inline void handle_interrupt(struct i2sbus_dev *i2sdev, int in) 592 { 593 struct pcm_info *pi; 594 u32 fc, nframes; 595 u32 status; 596 int timeout, i; 597 int dma_stopped = 0; 598 struct snd_pcm_runtime *runtime; 599 600 scoped_guard(spinlock, &i2sdev->low_lock) { 601 get_pcm_info(i2sdev, in, &pi, NULL); 602 if (!pi->dbdma_ring.running && !pi->dbdma_ring.stopping) 603 return; 604 605 i = pi->current_period; 606 runtime = pi->substream->runtime; 607 while (pi->dbdma_ring.cmds[i].xfer_status) { 608 if (le16_to_cpu(pi->dbdma_ring.cmds[i].xfer_status) & BT) 609 /* 610 * BT is the branch taken bit. If it took a branch 611 * it is because we set the S0 bit to make it 612 * branch to the stop command. 613 */ 614 dma_stopped = 1; 615 pi->dbdma_ring.cmds[i].xfer_status = 0; 616 617 if (++i >= runtime->periods) { 618 i = 0; 619 pi->frame_count += runtime->buffer_size; 620 } 621 pi->current_period = i; 622 623 /* 624 * Check the frame count. The DMA tends to get a bit 625 * ahead of the frame counter, which confuses the core. 626 */ 627 fc = in_le32(&i2sdev->intfregs->frame_count); 628 nframes = i * runtime->period_size; 629 if (fc < pi->frame_count + nframes) 630 pi->frame_count = fc - nframes; 631 } 632 633 if (dma_stopped) { 634 timeout = 1000; 635 for (;;) { 636 status = in_le32(&pi->dbdma->status); 637 if (!(status & ACTIVE) && (!in || (status & 0x80))) 638 break; 639 if (--timeout <= 0) { 640 printk(KERN_ERR 641 "i2sbus: timed out waiting for DMA to stop!\n"); 642 break; 643 } 644 udelay(1); 645 } 646 647 /* Turn off DMA controller, clear S0 bit */ 648 out_le32(&pi->dbdma->control, (RUN | PAUSE | 1) << 16); 649 650 pi->dbdma_ring.stopping = 0; 651 if (pi->stop_completion) 652 complete(pi->stop_completion); 653 } 654 655 if (!pi->dbdma_ring.running) 656 return; 657 } 658 659 /* may call _trigger again, hence needs to be unlocked */ 660 snd_pcm_period_elapsed(pi->substream); 661 } 662 663 irqreturn_t i2sbus_tx_intr(int irq, void *devid) 664 { 665 handle_interrupt((struct i2sbus_dev *)devid, 0); 666 return IRQ_HANDLED; 667 } 668 669 irqreturn_t i2sbus_rx_intr(int irq, void *devid) 670 { 671 handle_interrupt((struct i2sbus_dev *)devid, 1); 672 return IRQ_HANDLED; 673 } 674 675 static int i2sbus_playback_open(struct snd_pcm_substream *substream) 676 { 677 struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); 678 679 if (!i2sdev) 680 return -EINVAL; 681 i2sdev->out.substream = substream; 682 return i2sbus_pcm_open(i2sdev, 0); 683 } 684 685 static int i2sbus_playback_close(struct snd_pcm_substream *substream) 686 { 687 struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); 688 int err; 689 690 if (!i2sdev) 691 return -EINVAL; 692 if (i2sdev->out.substream != substream) 693 return -EINVAL; 694 err = i2sbus_pcm_close(i2sdev, 0); 695 if (!err) 696 i2sdev->out.substream = NULL; 697 return err; 698 } 699 700 static int i2sbus_playback_prepare(struct snd_pcm_substream *substream) 701 { 702 struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); 703 704 if (!i2sdev) 705 return -EINVAL; 706 if (i2sdev->out.substream != substream) 707 return -EINVAL; 708 return i2sbus_pcm_prepare(i2sdev, 0); 709 } 710 711 static int i2sbus_playback_trigger(struct snd_pcm_substream *substream, int cmd) 712 { 713 struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); 714 715 if (!i2sdev) 716 return -EINVAL; 717 if (i2sdev->out.substream != substream) 718 return -EINVAL; 719 return i2sbus_pcm_trigger(i2sdev, 0, cmd); 720 } 721 722 static snd_pcm_uframes_t i2sbus_playback_pointer(struct snd_pcm_substream 723 *substream) 724 { 725 struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); 726 727 if (!i2sdev) 728 return -EINVAL; 729 if (i2sdev->out.substream != substream) 730 return 0; 731 return i2sbus_pcm_pointer(i2sdev, 0); 732 } 733 734 static const struct snd_pcm_ops i2sbus_playback_ops = { 735 .open = i2sbus_playback_open, 736 .close = i2sbus_playback_close, 737 .hw_free = i2sbus_playback_hw_free, 738 .prepare = i2sbus_playback_prepare, 739 .trigger = i2sbus_playback_trigger, 740 .pointer = i2sbus_playback_pointer, 741 }; 742 743 static int i2sbus_record_open(struct snd_pcm_substream *substream) 744 { 745 struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); 746 747 if (!i2sdev) 748 return -EINVAL; 749 i2sdev->in.substream = substream; 750 return i2sbus_pcm_open(i2sdev, 1); 751 } 752 753 static int i2sbus_record_close(struct snd_pcm_substream *substream) 754 { 755 struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); 756 int err; 757 758 if (!i2sdev) 759 return -EINVAL; 760 if (i2sdev->in.substream != substream) 761 return -EINVAL; 762 err = i2sbus_pcm_close(i2sdev, 1); 763 if (!err) 764 i2sdev->in.substream = NULL; 765 return err; 766 } 767 768 static int i2sbus_record_prepare(struct snd_pcm_substream *substream) 769 { 770 struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); 771 772 if (!i2sdev) 773 return -EINVAL; 774 if (i2sdev->in.substream != substream) 775 return -EINVAL; 776 return i2sbus_pcm_prepare(i2sdev, 1); 777 } 778 779 static int i2sbus_record_trigger(struct snd_pcm_substream *substream, int cmd) 780 { 781 struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); 782 783 if (!i2sdev) 784 return -EINVAL; 785 if (i2sdev->in.substream != substream) 786 return -EINVAL; 787 return i2sbus_pcm_trigger(i2sdev, 1, cmd); 788 } 789 790 static snd_pcm_uframes_t i2sbus_record_pointer(struct snd_pcm_substream 791 *substream) 792 { 793 struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); 794 795 if (!i2sdev) 796 return -EINVAL; 797 if (i2sdev->in.substream != substream) 798 return 0; 799 return i2sbus_pcm_pointer(i2sdev, 1); 800 } 801 802 static const struct snd_pcm_ops i2sbus_record_ops = { 803 .open = i2sbus_record_open, 804 .close = i2sbus_record_close, 805 .hw_free = i2sbus_record_hw_free, 806 .prepare = i2sbus_record_prepare, 807 .trigger = i2sbus_record_trigger, 808 .pointer = i2sbus_record_pointer, 809 }; 810 811 static void i2sbus_private_free(struct snd_pcm *pcm) 812 { 813 struct i2sbus_dev *i2sdev = snd_pcm_chip(pcm); 814 struct codec_info_item *p, *tmp; 815 816 i2sdev->sound.pcm = NULL; 817 i2sdev->out.created = 0; 818 i2sdev->in.created = 0; 819 list_for_each_entry_safe(p, tmp, &i2sdev->sound.codec_list, list) { 820 printk(KERN_ERR "i2sbus: a codec didn't unregister!\n"); 821 list_del(&p->list); 822 module_put(p->codec->owner); 823 kfree(p); 824 } 825 soundbus_dev_put(&i2sdev->sound); 826 module_put(THIS_MODULE); 827 } 828 829 int 830 i2sbus_attach_codec(struct soundbus_dev *dev, struct snd_card *card, 831 struct codec_info *ci, void *data) 832 { 833 int err, in = 0, out = 0; 834 struct transfer_info *tmp; 835 struct i2sbus_dev *i2sdev = soundbus_dev_to_i2sbus_dev(dev); 836 struct codec_info_item *cii; 837 838 if (!dev->pcmname || dev->pcmid == -1) { 839 printk(KERN_ERR "i2sbus: pcm name and id must be set!\n"); 840 return -EINVAL; 841 } 842 843 list_for_each_entry(cii, &dev->codec_list, list) { 844 if (cii->codec_data == data) 845 return -EALREADY; 846 } 847 848 if (!ci->transfers || !ci->transfers->formats 849 || !ci->transfers->rates || !ci->usable) 850 return -EINVAL; 851 852 /* we currently code the i2s transfer on the clock, and support only 853 * 32 and 64 */ 854 if (ci->bus_factor != 32 && ci->bus_factor != 64) 855 return -EINVAL; 856 857 /* If you want to fix this, you need to keep track of what transport infos 858 * are to be used, which codecs they belong to, and then fix all the 859 * sysclock/busclock stuff above to depend on which is usable */ 860 list_for_each_entry(cii, &dev->codec_list, list) { 861 if (cii->codec->sysclock_factor != ci->sysclock_factor) { 862 printk(KERN_DEBUG 863 "cannot yet handle multiple different sysclocks!\n"); 864 return -EINVAL; 865 } 866 if (cii->codec->bus_factor != ci->bus_factor) { 867 printk(KERN_DEBUG 868 "cannot yet handle multiple different bus clocks!\n"); 869 return -EINVAL; 870 } 871 } 872 873 tmp = ci->transfers; 874 while (tmp->formats && tmp->rates) { 875 if (tmp->transfer_in) 876 in = 1; 877 else 878 out = 1; 879 tmp++; 880 } 881 882 cii = kzalloc(sizeof(struct codec_info_item), GFP_KERNEL); 883 if (!cii) 884 return -ENOMEM; 885 886 /* use the private data to point to the codec info */ 887 cii->sdev = soundbus_dev_get(dev); 888 cii->codec = ci; 889 cii->codec_data = data; 890 891 if (!cii->sdev) { 892 printk(KERN_DEBUG 893 "i2sbus: failed to get soundbus dev reference\n"); 894 err = -ENODEV; 895 goto out_free_cii; 896 } 897 898 if (!try_module_get(THIS_MODULE)) { 899 printk(KERN_DEBUG "i2sbus: failed to get module reference!\n"); 900 err = -EBUSY; 901 goto out_put_sdev; 902 } 903 904 if (!try_module_get(ci->owner)) { 905 printk(KERN_DEBUG 906 "i2sbus: failed to get module reference to codec owner!\n"); 907 err = -EBUSY; 908 goto out_put_this_module; 909 } 910 911 if (!dev->pcm) { 912 err = snd_pcm_new(card, dev->pcmname, dev->pcmid, 0, 0, 913 &dev->pcm); 914 if (err) { 915 printk(KERN_DEBUG "i2sbus: failed to create pcm\n"); 916 goto out_put_ci_module; 917 } 918 } 919 920 /* ALSA yet again sucks. 921 * If it is ever fixed, remove this line. See below. */ 922 out = in = 1; 923 924 if (!i2sdev->out.created && out) { 925 if (dev->pcm->card != card) { 926 /* eh? */ 927 printk(KERN_ERR 928 "Can't attach same bus to different cards!\n"); 929 err = -EINVAL; 930 goto out_put_ci_module; 931 } 932 err = snd_pcm_new_stream(dev->pcm, SNDRV_PCM_STREAM_PLAYBACK, 1); 933 if (err) 934 goto out_put_ci_module; 935 snd_pcm_set_ops(dev->pcm, SNDRV_PCM_STREAM_PLAYBACK, 936 &i2sbus_playback_ops); 937 dev->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].dev->parent = 938 &dev->ofdev.dev; 939 i2sdev->out.created = 1; 940 } 941 942 if (!i2sdev->in.created && in) { 943 if (dev->pcm->card != card) { 944 printk(KERN_ERR 945 "Can't attach same bus to different cards!\n"); 946 err = -EINVAL; 947 goto out_put_ci_module; 948 } 949 err = snd_pcm_new_stream(dev->pcm, SNDRV_PCM_STREAM_CAPTURE, 1); 950 if (err) 951 goto out_put_ci_module; 952 snd_pcm_set_ops(dev->pcm, SNDRV_PCM_STREAM_CAPTURE, 953 &i2sbus_record_ops); 954 dev->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].dev->parent = 955 &dev->ofdev.dev; 956 i2sdev->in.created = 1; 957 } 958 959 /* so we have to register the pcm after adding any substream 960 * to it because alsa doesn't create the devices for the 961 * substreams when we add them later. 962 * Therefore, force in and out on both busses (above) and 963 * register the pcm now instead of just after creating it. 964 */ 965 err = snd_device_register(card, dev->pcm); 966 if (err) { 967 printk(KERN_ERR "i2sbus: error registering new pcm\n"); 968 goto out_put_ci_module; 969 } 970 /* no errors any more, so let's add this to our list */ 971 list_add(&cii->list, &dev->codec_list); 972 973 dev->pcm->private_data = i2sdev; 974 dev->pcm->private_free = i2sbus_private_free; 975 976 /* well, we really should support scatter/gather DMA */ 977 snd_pcm_set_managed_buffer_all( 978 dev->pcm, SNDRV_DMA_TYPE_DEV, 979 &macio_get_pci_dev(i2sdev->macio)->dev, 980 64 * 1024, 64 * 1024); 981 982 return 0; 983 out_put_ci_module: 984 module_put(ci->owner); 985 out_put_this_module: 986 module_put(THIS_MODULE); 987 out_put_sdev: 988 soundbus_dev_put(dev); 989 out_free_cii: 990 kfree(cii); 991 return err; 992 } 993 994 void i2sbus_detach_codec(struct soundbus_dev *dev, void *data) 995 { 996 struct codec_info_item *cii = NULL, *i; 997 998 list_for_each_entry(i, &dev->codec_list, list) { 999 if (i->codec_data == data) { 1000 cii = i; 1001 break; 1002 } 1003 } 1004 if (cii) { 1005 list_del(&cii->list); 1006 module_put(cii->codec->owner); 1007 kfree(cii); 1008 } 1009 /* no more codecs, but still a pcm? */ 1010 if (list_empty(&dev->codec_list) && dev->pcm) { 1011 /* the actual cleanup is done by the callback above! */ 1012 snd_device_free(dev->pcm->card, dev->pcm); 1013 } 1014 } 1015