sound/aoa/soundbus/i2sbus/pcm.c

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