sys/arm/freescale/vybrid/vf_sai.c

   1 /*-
   2  * Copyright (c) 2014 Ruslan Bukin <br@bsdpad.com>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 /*
  28  * Vybrid Family Synchronous Audio Interface (SAI)
  29  * Chapter 51, Vybrid Reference Manual, Rev. 5, 07/2013
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/bus.h>
  38 #include <sys/kernel.h>
  39 #include <sys/module.h>
  40 #include <sys/malloc.h>
  41 #include <sys/rman.h>
  42 #include <sys/timeet.h>
  43 #include <sys/timetc.h>
  44 #include <sys/watchdog.h>
  45
  46 #include <dev/sound/pcm/sound.h>
  47 #include <dev/sound/chip.h>
  48 #include <mixer_if.h>
  49
  50 #include <dev/ofw/openfirm.h>
  51 #include <dev/ofw/ofw_bus.h>
  52 #include <dev/ofw/ofw_bus_subr.h>
  53
  54 #include <machine/bus.h>
  55 #include <machine/cpu.h>
  56 #include <machine/intr.h>
  57
  58 #include <arm/freescale/vybrid/vf_common.h>
  59 #include <arm/freescale/vybrid/vf_dmamux.h>
  60 #include <arm/freescale/vybrid/vf_edma.h>
  61
  62 #define I2S_TCSR        0x00    /* SAI Transmit Control */
  63 #define I2S_TCR1        0x04    /* SAI Transmit Configuration 1 */
  64 #define I2S_TCR2        0x08    /* SAI Transmit Configuration 2 */
  65 #define I2S_TCR3        0x0C    /* SAI Transmit Configuration 3 */
  66 #define I2S_TCR4        0x10    /* SAI Transmit Configuration 4 */
  67 #define I2S_TCR5        0x14    /* SAI Transmit Configuration 5 */
  68 #define I2S_TDR0        0x20    /* SAI Transmit Data */
  69 #define I2S_TFR0        0x40    /* SAI Transmit FIFO */
  70 #define I2S_TMR         0x60    /* SAI Transmit Mask */
  71 #define I2S_RCSR        0x80    /* SAI Receive Control */
  72 #define I2S_RCR1        0x84    /* SAI Receive Configuration 1 */
  73 #define I2S_RCR2        0x88    /* SAI Receive Configuration 2 */
  74 #define I2S_RCR3        0x8C    /* SAI Receive Configuration 3 */
  75 #define I2S_RCR4        0x90    /* SAI Receive Configuration 4 */
  76 #define I2S_RCR5        0x94    /* SAI Receive Configuration 5 */
  77 #define I2S_RDR0        0xA0    /* SAI Receive Data */
  78 #define I2S_RFR0        0xC0    /* SAI Receive FIFO */
  79 #define I2S_RMR         0xE0    /* SAI Receive Mask */
  80
  81 #define TCR1_TFW_M      0x1f            /* Transmit FIFO Watermark Mask */
  82 #define TCR1_TFW_S      0               /* Transmit FIFO Watermark Shift */
  83 #define TCR2_MSEL_M     0x3             /* MCLK Select Mask*/
  84 #define TCR2_MSEL_S     26              /* MCLK Select Shift*/
  85 #define TCR2_BCP        (1 << 25)       /* Bit Clock Polarity */
  86 #define TCR2_BCD        (1 << 24)       /* Bit Clock Direction */
  87 #define TCR3_TCE        (1 << 16)       /* Transmit Channel Enable */
  88 #define TCR4_FRSZ_M     0x1f            /* Frame size Mask */
  89 #define TCR4_FRSZ_S     16              /* Frame size Shift */
  90 #define TCR4_SYWD_M     0x1f            /* Sync Width Mask */
  91 #define TCR4_SYWD_S     8               /* Sync Width Shift */
  92 #define TCR4_MF         (1 << 4)        /* MSB First */
  93 #define TCR4_FSE        (1 << 3)        /* Frame Sync Early */
  94 #define TCR4_FSP        (1 << 1)        /* Frame Sync Polarity Low */
  95 #define TCR4_FSD        (1 << 0)        /* Frame Sync Direction Master */
  96 #define TCR5_FBT_M      0x1f            /* First Bit Shifted */
  97 #define TCR5_FBT_S      8               /* First Bit Shifted */
  98 #define TCR5_W0W_M      0x1f            /* Word 0 Width */
  99 #define TCR5_W0W_S      16              /* Word 0 Width */
 100 #define TCR5_WNW_M      0x1f            /* Word N Width */
 101 #define TCR5_WNW_S      24              /* Word N Width */
 102 #define TCSR_TE         (1 << 31)       /* Transmitter Enable */
 103 #define TCSR_BCE        (1 << 28)       /* Bit Clock Enable */
 104 #define TCSR_FRDE       (1 << 0)        /* FIFO Request DMA Enable */
 105
 106 #define SAI_NCHANNELS   1
 107
 108 static MALLOC_DEFINE(M_SAI, "sai", "sai audio");
 109
 110 struct sai_rate {
 111         uint32_t speed;
 112         uint32_t div; /* Bit Clock Divide. Division value is (div + 1) * 2. */
 113         uint32_t mfi; /* PLL4 Multiplication Factor Integer */
 114         uint32_t mfn; /* PLL4 Multiplication Factor Numerator */
 115         uint32_t mfd; /* PLL4 Multiplication Factor Denominator */
 116 };
 117
 118 /*
 119  * Bit clock divider formula
 120  * (div + 1) * 2 = MCLK/(nch * LRCLK * bits/1000000),
 121  * where:
 122  *   MCLK - master clock
 123  *   nch - number of channels
 124  *   LRCLK - left right clock
 125  * e.g. (div + 1) * 2 = 16.9344/(2 * 44100 * 24/1000000)
 126  *
 127  * Example for 96khz, 24bit, 18.432 Mhz mclk (192fs)
 128  * { 96000, 1, 18, 40176000, 93000000 },
 129  */
 130
 131 static struct sai_rate rate_map[] = {
 132         { 44100, 7, 33, 80798400, 93000000 }, /* 33.8688 Mhz */
 133         { 96000, 3, 36, 80352000, 93000000 }, /* 36.864 Mhz */
 134         { 192000, 1, 36, 80352000, 93000000 }, /* 36.864 Mhz */
 135         { 0, 0 },
 136 };
 137
 138 struct sc_info {
 139         struct resource         *res[2];
 140         bus_space_tag_t         bst;
 141         bus_space_handle_t      bsh;
 142         device_t                dev;
 143         struct mtx              *lock;
 144         uint32_t                speed;
 145         uint32_t                period;
 146         void                    *ih;
 147         int                     pos;
 148         int                     dma_size;
 149         bus_dma_tag_t           dma_tag;
 150         bus_dmamap_t            dma_map;
 151         bus_addr_t              buf_base_phys;
 152         uint32_t                *buf_base;
 153         struct tcd_conf         *tcd;
 154         struct sai_rate         *sr;
 155         struct edma_softc       *edma_sc;
 156         int                     edma_chnum;
 157 };
 158
 159 /* Channel registers */
 160 struct sc_chinfo {
 161         struct snd_dbuf         *buffer;
 162         struct pcm_channel      *channel;
 163         struct sc_pcminfo       *parent;
 164
 165         /* Channel information */
 166         uint32_t        dir;
 167         uint32_t        format;
 168
 169         /* Flags */
 170         uint32_t        run;
 171 };
 172
 173 /* PCM device private data */
 174 struct sc_pcminfo {
 175         device_t                dev;
 176         uint32_t                (*ih) (struct sc_pcminfo *scp);
 177         uint32_t                chnum;
 178         struct sc_chinfo        chan[SAI_NCHANNELS];
 179         struct sc_info          *sc;
 180 };
 181
 182 static struct resource_spec sai_spec[] = {
 183         { SYS_RES_MEMORY,       0,      RF_ACTIVE },
 184         { SYS_RES_IRQ,          0,      RF_ACTIVE },
 185         { -1, 0 }
 186 };
 187
 188 static int setup_dma(struct sc_pcminfo *scp);
 189 static void setup_sai(struct sc_info *);
 190 static void sai_configure_clock(struct sc_info *);
 191
 192 /*
 193  * Mixer interface.
 194  */
 195
 196 static int
 197 saimixer_init(struct snd_mixer *m)
 198 {
 199         struct sc_pcminfo *scp;
 200         struct sc_info *sc;
 201         int mask;
 202
 203         scp = mix_getdevinfo(m);
 204         sc = scp->sc;
 205
 206         if (sc == NULL)
 207                 return -1;
 208
 209         mask = SOUND_MASK_PCM;
 210
 211         snd_mtxlock(sc->lock);
 212         pcm_setflags(scp->dev, pcm_getflags(scp->dev) | SD_F_SOFTPCMVOL);
 213         mix_setdevs(m, mask);
 214         snd_mtxunlock(sc->lock);
 215
 216         return (0);
 217 }
 218
 219 static int
 220 saimixer_set(struct snd_mixer *m, unsigned dev,
 221     unsigned left, unsigned right)
 222 {
 223         struct sc_pcminfo *scp;
 224
 225         scp = mix_getdevinfo(m);
 226
 227 #if 0
 228         device_printf(scp->dev, "saimixer_set() %d %d\n",
 229             left, right);
 230 #endif
 231
 232         return (0);
 233 }
 234
 235 static kobj_method_t saimixer_methods[] = {
 236         KOBJMETHOD(mixer_init,      saimixer_init),
 237         KOBJMETHOD(mixer_set,       saimixer_set),
 238         KOBJMETHOD_END
 239 };
 240 MIXER_DECLARE(saimixer);
 241
 242 /*
 243  * Channel interface.
 244  */
 245
 246 static void *
 247 saichan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 248     struct pcm_channel *c, int dir)
 249 {
 250         struct sc_pcminfo *scp;
 251         struct sc_chinfo *ch;
 252         struct sc_info *sc;
 253
 254         scp = (struct sc_pcminfo *)devinfo;
 255         sc = scp->sc;
 256
 257         snd_mtxlock(sc->lock);
 258         ch = &scp->chan[0];
 259         ch->dir = dir;
 260         ch->run = 0;
 261         ch->buffer = b;
 262         ch->channel = c;
 263         ch->parent = scp;
 264         snd_mtxunlock(sc->lock);
 265
 266         if (sndbuf_setup(ch->buffer, sc->buf_base, sc->dma_size) != 0) {
 267                 device_printf(scp->dev, "Can't setup sndbuf.\n");
 268                 return NULL;
 269         }
 270
 271         return ch;
 272 }
 273
 274 static int
 275 saichan_free(kobj_t obj, void *data)
 276 {
 277         struct sc_chinfo *ch = data;
 278         struct sc_pcminfo *scp = ch->parent;
 279         struct sc_info *sc = scp->sc;
 280
 281 #if 0
 282         device_printf(scp->dev, "saichan_free()\n");
 283 #endif
 284
 285         snd_mtxlock(sc->lock);
 286         /* TODO: free channel buffer */
 287         snd_mtxunlock(sc->lock);
 288
 289         return (0);
 290 }
 291
 292 static int
 293 saichan_setformat(kobj_t obj, void *data, uint32_t format)
 294 {
 295         struct sc_chinfo *ch = data;
 296
 297         ch->format = format;
 298
 299         return (0);
 300 }
 301
 302 static uint32_t
 303 saichan_setspeed(kobj_t obj, void *data, uint32_t speed)
 304 {
 305         struct sc_pcminfo *scp;
 306         struct sc_chinfo *ch;
 307         struct sai_rate *sr;
 308         struct sc_info *sc;
 309         int threshold;
 310         int i;
 311
 312         ch = data;
 313         scp = ch->parent;
 314         sc = scp->sc;
 315
 316         sr = NULL;
 317
 318         /* First look for equal frequency. */
 319         for (i = 0; rate_map[i].speed != 0; i++) {
 320                 if (rate_map[i].speed == speed)
 321                         sr = &rate_map[i];
 322         }
 323
 324         /* If no match, just find nearest. */
 325         if (sr == NULL) {
 326                 for (i = 0; rate_map[i].speed != 0; i++) {
 327                         sr = &rate_map[i];
 328                         threshold = sr->speed + ((rate_map[i + 1].speed != 0) ?
 329                             ((rate_map[i + 1].speed - sr->speed) >> 1) : 0);
 330                         if (speed < threshold)
 331                                 break;
 332                 }
 333         }
 334
 335         sc->sr = sr;
 336
 337         sai_configure_clock(sc);
 338
 339         return (sr->speed);
 340 }
 341
 342 static void
 343 sai_configure_clock(struct sc_info *sc)
 344 {
 345         struct sai_rate *sr;
 346         int reg;
 347
 348         sr = sc->sr;
 349
 350         /*
 351          * Manual says that TCR/RCR registers must not be
 352          * altered when TCSR[TE] is set.
 353          * We ignore it since we have problem sometimes
 354          * after re-enabling transmitter (DMA goes stall).
 355          */
 356
 357         reg = READ4(sc, I2S_TCR2);
 358         reg &= ~(0xff << 0);
 359         reg |= (sr->div << 0);
 360         WRITE4(sc, I2S_TCR2, reg);
 361
 362         pll4_configure_output(sr->mfi, sr->mfn, sr->mfd);
 363 }
 364
 365 static uint32_t
 366 saichan_setblocksize(kobj_t obj, void *data, uint32_t blocksize)
 367 {
 368         struct sc_chinfo *ch = data;
 369         struct sc_pcminfo *scp = ch->parent;
 370         struct sc_info *sc = scp->sc;
 371
 372         sndbuf_resize(ch->buffer, sc->dma_size / blocksize, blocksize);
 373
 374         sc->period = sndbuf_getblksz(ch->buffer);
 375         return (sc->period);
 376 }
 377
 378 uint32_t sai_dma_intr(void *arg, int chn);
 379 uint32_t
 380 sai_dma_intr(void *arg, int chn)
 381 {
 382         struct sc_pcminfo *scp;
 383         struct sc_chinfo *ch;
 384         struct sc_info *sc;
 385         struct tcd_conf *tcd;
 386
 387         scp = arg;
 388         ch = &scp->chan[0];
 389
 390         sc = scp->sc;
 391         tcd = sc->tcd;
 392
 393         sc->pos += (tcd->nbytes * tcd->nmajor);
 394         if (sc->pos >= sc->dma_size)
 395                 sc->pos -= sc->dma_size;
 396
 397         if (ch->run)
 398                 chn_intr(ch->channel);
 399
 400         return (0);
 401 }
 402
 403 static int
 404 find_edma_controller(struct sc_info *sc)
 405 {
 406         struct edma_softc *edma_sc;
 407         phandle_t node, edma_node;
 408         int edma_src_transmit;
 409         int edma_mux_group;
 410         int edma_device_id;
 411         device_t edma_dev;
 412         int dts_value;
 413         int len;
 414         int i;
 415
 416         if ((node = ofw_bus_get_node(sc->dev)) == -1)
 417                 return (ENXIO);
 418
 419         if ((len = OF_getproplen(node, "edma-controller")) <= 0)
 420                 return (ENXIO);
 421         if ((len = OF_getproplen(node, "edma-src-transmit")) <= 0)
 422                 return (ENXIO);
 423         if ((len = OF_getproplen(node, "edma-mux-group")) <= 0)
 424                 return (ENXIO);
 425
 426         OF_getencprop(node, "edma-src-transmit", &dts_value, len);
 427         edma_src_transmit = dts_value;
 428         OF_getencprop(node, "edma-mux-group", &dts_value, len);
 429         edma_mux_group = dts_value;
 430         OF_getencprop(node, "edma-controller", &dts_value, len);
 431         edma_node = OF_node_from_xref(dts_value);
 432
 433         if ((len = OF_getproplen(edma_node, "device-id")) <= 0) {
 434                 return (ENXIO);
 435         }
 436
 437         OF_getencprop(edma_node, "device-id", &dts_value, len);
 438         edma_device_id = dts_value;
 439
 440         edma_sc = NULL;
 441
 442         for (i = 0; i < EDMA_NUM_DEVICES; i++) {
 443                 edma_dev = devclass_get_device(devclass_find("edma"), i);
 444                 if (edma_dev) {
 445                         edma_sc = device_get_softc(edma_dev);
 446                         if (edma_sc->device_id == edma_device_id) {
 447                                 /* found */
 448                                 break;
 449                         }
 450
 451                         edma_sc = NULL;
 452                 }
 453         }
 454
 455         if (edma_sc == NULL) {
 456                 device_printf(sc->dev, "no eDMA. can't operate\n");
 457                 return (ENXIO);
 458         }
 459
 460         sc->edma_sc = edma_sc;
 461
 462         sc->edma_chnum = edma_sc->channel_configure(edma_sc, edma_mux_group,
 463             edma_src_transmit);
 464         if (sc->edma_chnum < 0) {
 465                 /* cant setup eDMA */
 466                 return (ENXIO);
 467         }
 468
 469         return (0);
 470 };
 471
 472 static int
 473 setup_dma(struct sc_pcminfo *scp)
 474 {
 475         struct tcd_conf *tcd;
 476         struct sc_info *sc;
 477
 478         sc = scp->sc;
 479
 480         tcd = malloc(sizeof(struct tcd_conf), M_DEVBUF, M_WAITOK | M_ZERO);
 481         tcd->channel = sc->edma_chnum;
 482         tcd->ih = sai_dma_intr;
 483         tcd->ih_user = scp;
 484         tcd->saddr = sc->buf_base_phys;
 485         tcd->daddr = rman_get_start(sc->res[0]) + I2S_TDR0;
 486
 487         /*
 488          * Bytes to transfer per each minor loop.
 489          * Hardware FIFO buffer size is 32x32bits.
 490          */
 491         tcd->nbytes = 64;
 492
 493         tcd->nmajor = 512;
 494         tcd->smod = 17; /* dma_size range */
 495         tcd->dmod = 0;
 496         tcd->esg = 0;
 497         tcd->soff = 0x4;
 498         tcd->doff = 0;
 499         tcd->ssize = 0x2;
 500         tcd->dsize = 0x2;
 501         tcd->slast = 0;
 502         tcd->dlast_sga = 0;
 503
 504         sc->tcd = tcd;
 505
 506         sc->edma_sc->dma_setup(sc->edma_sc, sc->tcd);
 507
 508         return (0);
 509 }
 510
 511 static int
 512 saichan_trigger(kobj_t obj, void *data, int go)
 513 {
 514         struct sc_chinfo *ch = data;
 515         struct sc_pcminfo *scp = ch->parent;
 516         struct sc_info *sc = scp->sc;
 517
 518         snd_mtxlock(sc->lock);
 519
 520         switch (go) {
 521         case PCMTRIG_START:
 522 #if 0
 523                 device_printf(scp->dev, "trigger start\n");
 524 #endif
 525                 ch->run = 1;
 526                 break;
 527
 528         case PCMTRIG_STOP:
 529         case PCMTRIG_ABORT:
 530 #if 0
 531                 device_printf(scp->dev, "trigger stop or abort\n");
 532 #endif
 533                 ch->run = 0;
 534                 break;
 535         }
 536
 537         snd_mtxunlock(sc->lock);
 538
 539         return (0);
 540 }
 541
 542 static uint32_t
 543 saichan_getptr(kobj_t obj, void *data)
 544 {
 545         struct sc_pcminfo *scp;
 546         struct sc_chinfo *ch;
 547         struct sc_info *sc;
 548
 549         ch = data;
 550         scp = ch->parent;
 551         sc = scp->sc;
 552
 553         return (sc->pos);
 554 }
 555
 556 static uint32_t sai_pfmt[] = {
 557         /*
 558          * eDMA doesn't allow 24-bit coping,
 559          * so we use 32.
 560          */
 561         SND_FORMAT(AFMT_S32_LE, 2, 0),
 562         0
 563 };
 564
 565 static struct pcmchan_caps sai_pcaps = {44100, 192000, sai_pfmt, 0};
 566
 567 static struct pcmchan_caps *
 568 saichan_getcaps(kobj_t obj, void *data)
 569 {
 570
 571         return (&sai_pcaps);
 572 }
 573
 574 static kobj_method_t saichan_methods[] = {
 575         KOBJMETHOD(channel_init,         saichan_init),
 576         KOBJMETHOD(channel_free,         saichan_free),
 577         KOBJMETHOD(channel_setformat,    saichan_setformat),
 578         KOBJMETHOD(channel_setspeed,     saichan_setspeed),
 579         KOBJMETHOD(channel_setblocksize, saichan_setblocksize),
 580         KOBJMETHOD(channel_trigger,      saichan_trigger),
 581         KOBJMETHOD(channel_getptr,       saichan_getptr),
 582         KOBJMETHOD(channel_getcaps,      saichan_getcaps),
 583         KOBJMETHOD_END
 584 };
 585 CHANNEL_DECLARE(saichan);
 586
 587 static int
 588 sai_probe(device_t dev)
 589 {
 590
 591         if (!ofw_bus_status_okay(dev))
 592                 return (ENXIO);
 593
 594         if (!ofw_bus_is_compatible(dev, "fsl,mvf600-sai"))
 595                 return (ENXIO);
 596
 597         device_set_desc(dev, "Vybrid Family Synchronous Audio Interface");
 598         return (BUS_PROBE_DEFAULT);
 599 }
 600
 601 static void
 602 sai_intr(void *arg)
 603 {
 604         struct sc_pcminfo *scp;
 605         struct sc_info *sc;
 606
 607         scp = arg;
 608         sc = scp->sc;
 609
 610         device_printf(sc->dev, "Error I2S_TCSR == 0x%08x\n",
 611             READ4(sc, I2S_TCSR));
 612 }
 613
 614 static void
 615 setup_sai(struct sc_info *sc)
 616 {
 617         int reg;
 618
 619         /*
 620          * TCR/RCR registers must not be altered when TCSR[TE] is set.
 621          */
 622
 623         reg = READ4(sc, I2S_TCSR);
 624         reg &= ~(TCSR_BCE | TCSR_TE | TCSR_FRDE);
 625         WRITE4(sc, I2S_TCSR, reg);
 626
 627         reg = READ4(sc, I2S_TCR3);
 628         reg &= ~(TCR3_TCE);
 629         WRITE4(sc, I2S_TCR3, reg);
 630
 631         reg = (64 << TCR1_TFW_S);
 632         WRITE4(sc, I2S_TCR1, reg);
 633
 634         reg = READ4(sc, I2S_TCR2);
 635         reg &= ~(TCR2_MSEL_M << TCR2_MSEL_S);
 636         reg |= (1 << TCR2_MSEL_S);
 637         reg |= (TCR2_BCP | TCR2_BCD);
 638         WRITE4(sc, I2S_TCR2, reg);
 639
 640         sai_configure_clock(sc);
 641
 642         reg = READ4(sc, I2S_TCR3);
 643         reg |= (TCR3_TCE);
 644         WRITE4(sc, I2S_TCR3, reg);
 645
 646         /* Configure to 32-bit I2S mode */
 647         reg = READ4(sc, I2S_TCR4);
 648         reg &= ~(TCR4_FRSZ_M << TCR4_FRSZ_S);
 649         reg |= (1 << TCR4_FRSZ_S); /* 2 words per frame */
 650         reg &= ~(TCR4_SYWD_M << TCR4_SYWD_S);
 651         reg |= (23 << TCR4_SYWD_S);
 652         reg |= (TCR4_MF | TCR4_FSE | TCR4_FSP | TCR4_FSD);
 653         WRITE4(sc, I2S_TCR4, reg);
 654
 655         reg = READ4(sc, I2S_TCR5);
 656         reg &= ~(TCR5_W0W_M << TCR5_W0W_S);
 657         reg |= (23 << TCR5_W0W_S);
 658         reg &= ~(TCR5_WNW_M << TCR5_WNW_S);
 659         reg |= (23 << TCR5_WNW_S);
 660         reg &= ~(TCR5_FBT_M << TCR5_FBT_S);
 661         reg |= (31 << TCR5_FBT_S);
 662         WRITE4(sc, I2S_TCR5, reg);
 663
 664         /* Enable transmitter */
 665         reg = READ4(sc, I2S_TCSR);
 666         reg |= (TCSR_BCE | TCSR_TE | TCSR_FRDE);
 667         reg |= (1 << 10); /* FEIE */
 668         WRITE4(sc, I2S_TCSR, reg);
 669 }
 670
 671
 672 static void
 673 sai_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int err)
 674 {
 675         bus_addr_t *addr;
 676
 677         if (err)
 678                 return;
 679
 680         addr = (bus_addr_t*)arg;
 681         *addr = segs[0].ds_addr;
 682 }
 683
 684 static int
 685 sai_attach(device_t dev)
 686 {
 687         char status[SND_STATUSLEN];
 688         struct sc_pcminfo *scp;
 689         struct sc_info *sc;
 690         int err;
 691
 692         sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
 693         sc->dev = dev;
 694         sc->sr = &rate_map[0];
 695         sc->pos = 0;
 696
 697         sc->lock = snd_mtxcreate(device_get_nameunit(dev), "sai softc");
 698         if (sc->lock == NULL) {
 699                 device_printf(dev, "Cant create mtx\n");
 700                 return (ENXIO);
 701         }
 702
 703         if (bus_alloc_resources(dev, sai_spec, sc->res)) {
 704                 device_printf(dev, "could not allocate resources\n");
 705                 return (ENXIO);
 706         }
 707
 708         /* Memory interface */
 709         sc->bst = rman_get_bustag(sc->res[0]);
 710         sc->bsh = rman_get_bushandle(sc->res[0]);
 711
 712         /* eDMA */
 713         if (find_edma_controller(sc)) {
 714                 device_printf(dev, "could not find active eDMA\n");
 715                 return (ENXIO);
 716         }
 717
 718         /* Setup PCM */
 719         scp = malloc(sizeof(struct sc_pcminfo), M_DEVBUF, M_NOWAIT | M_ZERO);
 720         scp->sc = sc;
 721         scp->dev = dev;
 722
 723         /* DMA */
 724         sc->dma_size = 131072;
 725
 726         /*
 727          * Must use dma_size boundary as modulo feature required.
 728          * Modulo feature allows setup circular buffer.
 729          */
 730
 731         err = bus_dma_tag_create(
 732             bus_get_dma_tag(sc->dev),
 733             4, sc->dma_size,            /* alignment, boundary */
 734             BUS_SPACE_MAXADDR_32BIT,    /* lowaddr */
 735             BUS_SPACE_MAXADDR,          /* highaddr */
 736             NULL, NULL,                 /* filter, filterarg */
 737             sc->dma_size, 1,            /* maxsize, nsegments */
 738             sc->dma_size, 0,            /* maxsegsize, flags */
 739             NULL, NULL,                 /* lockfunc, lockarg */
 740             &sc->dma_tag);
 741
 742         err = bus_dmamem_alloc(sc->dma_tag, (void **)&sc->buf_base,
 743             BUS_DMA_NOWAIT | BUS_DMA_COHERENT, &sc->dma_map);
 744         if (err) {
 745                 device_printf(dev, "cannot allocate framebuffer\n");
 746                 return (ENXIO);
 747         }
 748
 749         err = bus_dmamap_load(sc->dma_tag, sc->dma_map, sc->buf_base,
 750             sc->dma_size, sai_dmamap_cb, &sc->buf_base_phys, BUS_DMA_NOWAIT);
 751         if (err) {
 752                 device_printf(dev, "cannot load DMA map\n");
 753                 return (ENXIO);
 754         }
 755
 756         bzero(sc->buf_base, sc->dma_size);
 757
 758         /* Setup interrupt handler */
 759         err = bus_setup_intr(dev, sc->res[1], INTR_MPSAFE | INTR_TYPE_AV,
 760             NULL, sai_intr, scp, &sc->ih);
 761         if (err) {
 762                 device_printf(dev, "Unable to alloc interrupt resource.\n");
 763                 return (ENXIO);
 764         }
 765
 766         pcm_setflags(dev, pcm_getflags(dev) | SD_F_MPSAFE);
 767
 768         err = pcm_register(dev, scp, 1, 0);
 769         if (err) {
 770                 device_printf(dev, "Can't register pcm.\n");
 771                 return (ENXIO);
 772         }
 773
 774         scp->chnum = 0;
 775         pcm_addchan(dev, PCMDIR_PLAY, &saichan_class, scp);
 776         scp->chnum++;
 777
 778         snprintf(status, SND_STATUSLEN, "at simplebus");
 779         pcm_setstatus(dev, status);
 780
 781         mixer_init(dev, &saimixer_class, scp);
 782
 783         setup_dma(scp);
 784         setup_sai(sc);
 785
 786         return (0);
 787 }
 788
 789 static device_method_t sai_pcm_methods[] = {
 790         DEVMETHOD(device_probe,         sai_probe),
 791         DEVMETHOD(device_attach,        sai_attach),
 792         { 0, 0 }
 793 };
 794
 795 static driver_t sai_pcm_driver = {
 796         "pcm",
 797         sai_pcm_methods,
 798         PCM_SOFTC_SIZE,
 799 };
 800
 801 DRIVER_MODULE(sai, simplebus, sai_pcm_driver, pcm_devclass, 0, 0);
 802 MODULE_DEPEND(sai, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
 803 MODULE_VERSION(sai, 1);