sys/arm/freescale/imx/imx6_ssi.c

   1 /*-
   2  * Copyright (c) 2015 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  * i.MX6 Synchronous Serial Interface (SSI)
  29  *
  30  * Chapter 61, i.MX 6Dual/6Quad Applications Processor Reference Manual,
  31  * Rev. 1, 04/2013
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/bus.h>
  40 #include <sys/kernel.h>
  41 #include <sys/module.h>
  42 #include <sys/malloc.h>
  43 #include <sys/rman.h>
  44 #include <sys/timeet.h>
  45 #include <sys/timetc.h>
  46
  47 #include <dev/sound/pcm/sound.h>
  48 #include <dev/sound/chip.h>
  49 #include <mixer_if.h>
  50
  51 #include <dev/ofw/openfirm.h>
  52 #include <dev/ofw/ofw_bus.h>
  53 #include <dev/ofw/ofw_bus_subr.h>
  54
  55 #include <machine/bus.h>
  56 #include <machine/cpu.h>
  57 #include <machine/intr.h>
  58
  59 #include <arm/freescale/imx/imx6_sdma.h>
  60 #include <arm/freescale/imx/imx6_anatopvar.h>
  61 #include <arm/freescale/imx/imx_ccmvar.h>
  62
  63 #define READ4(_sc, _reg)        \
  64         bus_space_read_4(_sc->bst, _sc->bsh, _reg)
  65 #define WRITE4(_sc, _reg, _val) \
  66         bus_space_write_4(_sc->bst, _sc->bsh, _reg, _val)
  67
  68 #define SSI_NCHANNELS   1
  69 #define DMAS_TOTAL      8
  70
  71 /* i.MX6 SSI registers */
  72
  73 #define SSI_STX0        0x00 /* Transmit Data Register n */
  74 #define SSI_STX1        0x04 /* Transmit Data Register n */
  75 #define SSI_SRX0        0x08 /* Receive Data Register n */
  76 #define SSI_SRX1        0x0C /* Receive Data Register n */
  77 #define SSI_SCR         0x10 /* Control Register */
  78 #define  SCR_I2S_MODE_S 5    /* I2S Mode Select. */
  79 #define  SCR_I2S_MODE_M 0x3
  80 #define  SCR_SYN        (1 << 4)
  81 #define  SCR_NET        (1 << 3)  /* Network mode */
  82 #define  SCR_RE         (1 << 2)  /* Receive Enable. */
  83 #define  SCR_TE         (1 << 1)  /* Transmit Enable. */
  84 #define  SCR_SSIEN      (1 << 0)  /* SSI Enable */
  85 #define SSI_SISR        0x14      /* Interrupt Status Register */
  86 #define SSI_SIER        0x18      /* Interrupt Enable Register */
  87 #define  SIER_RDMAE     (1 << 22) /* Receive DMA Enable. */
  88 #define  SIER_RIE       (1 << 21) /* Receive Interrupt Enable. */
  89 #define  SIER_TDMAE     (1 << 20) /* Transmit DMA Enable. */
  90 #define  SIER_TIE       (1 << 19) /* Transmit Interrupt Enable. */
  91 #define  SIER_TDE0IE    (1 << 12) /* Transmit Data Register Empty 0. */
  92 #define  SIER_TUE0IE    (1 << 8)  /* Transmitter Underrun Error 0. */
  93 #define  SIER_TFE0IE    (1 << 0)  /* Transmit FIFO Empty 0 IE. */
  94 #define SSI_STCR        0x1C      /* Transmit Configuration Register */
  95 #define  STCR_TXBIT0    (1 << 9)  /* Transmit Bit 0 shift MSB/LSB */
  96 #define  STCR_TFEN1     (1 << 8)  /* Transmit FIFO Enable 1. */
  97 #define  STCR_TFEN0     (1 << 7)  /* Transmit FIFO Enable 0. */
  98 #define  STCR_TFDIR     (1 << 6)  /* Transmit Frame Direction. */
  99 #define  STCR_TXDIR     (1 << 5)  /* Transmit Clock Direction. */
 100 #define  STCR_TSHFD     (1 << 4)  /* Transmit Shift Direction. */
 101 #define  STCR_TSCKP     (1 << 3)  /* Transmit Clock Polarity. */
 102 #define  STCR_TFSI      (1 << 2)  /* Transmit Frame Sync Invert. */
 103 #define  STCR_TFSL      (1 << 1)  /* Transmit Frame Sync Length. */
 104 #define  STCR_TEFS      (1 << 0)  /* Transmit Early Frame Sync. */
 105 #define SSI_SRCR        0x20      /* Receive Configuration Register */
 106 #define SSI_STCCR       0x24      /* Transmit Clock Control Register */
 107 #define  STCCR_DIV2     (1 << 18) /* Divide By 2. */
 108 #define  STCCR_PSR      (1 << 17) /* Divide clock by 8. */
 109 #define  WL3_WL0_S      13
 110 #define  WL3_WL0_M      0xf
 111 #define  DC4_DC0_S      8
 112 #define  DC4_DC0_M      0x1f
 113 #define  PM7_PM0_S      0
 114 #define  PM7_PM0_M      0xff
 115 #define SSI_SRCCR       0x28    /* Receive Clock Control Register */
 116 #define SSI_SFCSR       0x2C    /* FIFO Control/Status Register */
 117 #define  SFCSR_RFWM1_S  20      /* Receive FIFO Empty WaterMark 1 */
 118 #define  SFCSR_RFWM1_M  0xf
 119 #define  SFCSR_TFWM1_S  16      /* Transmit FIFO Empty WaterMark 1 */
 120 #define  SFCSR_TFWM1_M  0xf
 121 #define  SFCSR_RFWM0_S  4       /* Receive FIFO Empty WaterMark 0 */
 122 #define  SFCSR_RFWM0_M  0xf
 123 #define  SFCSR_TFWM0_S  0       /* Transmit FIFO Empty WaterMark 0 */
 124 #define  SFCSR_TFWM0_M  0xf
 125 #define SSI_SACNT       0x38    /* AC97 Control Register */
 126 #define SSI_SACADD      0x3C    /* AC97 Command Address Register */
 127 #define SSI_SACDAT      0x40    /* AC97 Command Data Register */
 128 #define SSI_SATAG       0x44    /* AC97 Tag Register */
 129 #define SSI_STMSK       0x48    /* Transmit Time Slot Mask Register */
 130 #define SSI_SRMSK       0x4C    /* Receive Time Slot Mask Register */
 131 #define SSI_SACCST      0x50    /* AC97 Channel Status Register */
 132 #define SSI_SACCEN      0x54    /* AC97 Channel Enable Register */
 133 #define SSI_SACCDIS     0x58    /* AC97 Channel Disable Register */
 134
 135 static MALLOC_DEFINE(M_SSI, "ssi", "ssi audio");
 136
 137 uint32_t ssi_dma_intr(void *arg, int chn);
 138
 139 struct ssi_rate {
 140         uint32_t speed;
 141         uint32_t mfi; /* PLL4 Multiplication Factor Integer */
 142         uint32_t mfn; /* PLL4 Multiplication Factor Numerator */
 143         uint32_t mfd; /* PLL4 Multiplication Factor Denominator */
 144         /* More dividers to configure can be added here */
 145 };
 146
 147 static struct ssi_rate rate_map[] = {
 148         { 192000, 49, 152, 1000 }, /* PLL4 49.152 Mhz */
 149         /* TODO: add more frequences */
 150         { 0, 0 },
 151 };
 152
 153 /*
 154  *  i.MX6 example bit clock formula
 155  *
 156  *  BCLK = 2 channels * 192000 hz * 24 bit = 9216000 hz =
 157  *     (24000000 * (49 + 152/1000.0) / 4 / 4 / 2 / 2 / 2 / 1 / 1)
 158  *             ^     ^     ^      ^    ^   ^   ^   ^   ^   ^   ^
 159  *             |     |     |      |    |   |   |   |   |   |   |
 160  *  Fref ------/     |     |      |    |   |   |   |   |   |   |
 161  *  PLL4 div select -/     |      |    |   |   |   |   |   |   |
 162  *  PLL4 num --------------/      |    |   |   |   |   |   |   |
 163  *  PLL4 denom -------------------/    |   |   |   |   |   |   |
 164  *  PLL4 post div ---------------------/   |   |   |   |   |   |
 165  *  CCM ssi pre div (CCM_CS1CDR) ----------/   |   |   |   |   |
 166  *  CCM ssi post div (CCM_CS1CDR) -------------/   |   |   |   |
 167  *  SSI PM7_PM0_S ---------------------------------/   |   |   |
 168  *  SSI Fixed divider ---------------------------------/   |   |
 169  *  SSI DIV2 ----------------------------------------------/   |
 170  *  SSI PSR (prescaler /1 or /8) ------------------------------/
 171  *
 172  *  MCLK (Master clock) depends on DAC, usually BCLK * 4
 173  */
 174
 175 struct sc_info {
 176         struct resource         *res[2];
 177         bus_space_tag_t         bst;
 178         bus_space_handle_t      bsh;
 179         device_t                dev;
 180         struct mtx              *lock;
 181         void                    *ih;
 182         int                     pos;
 183         int                     dma_size;
 184         bus_dma_tag_t           dma_tag;
 185         bus_dmamap_t            dma_map;
 186         bus_addr_t              buf_base_phys;
 187         uint32_t                *buf_base;
 188         struct sdma_conf        *conf;
 189         struct ssi_rate         *sr;
 190         struct sdma_softc       *sdma_sc;
 191         uint32_t                sdma_ev_rx;
 192         uint32_t                sdma_ev_tx;
 193         int                     sdma_channel;
 194 };
 195
 196 /* Channel registers */
 197 struct sc_chinfo {
 198         struct snd_dbuf         *buffer;
 199         struct pcm_channel      *channel;
 200         struct sc_pcminfo       *parent;
 201
 202         /* Channel information */
 203         uint32_t        dir;
 204         uint32_t        format;
 205
 206         /* Flags */
 207         uint32_t        run;
 208 };
 209
 210 /* PCM device private data */
 211 struct sc_pcminfo {
 212         device_t                dev;
 213         uint32_t                (*ih)(struct sc_pcminfo *scp);
 214         uint32_t                chnum;
 215         struct sc_chinfo        chan[SSI_NCHANNELS];
 216         struct sc_info          *sc;
 217 };
 218
 219 static struct resource_spec ssi_spec[] = {
 220         { SYS_RES_MEMORY,       0,      RF_ACTIVE },
 221         { SYS_RES_IRQ,          0,      RF_ACTIVE },
 222         { -1, 0 }
 223 };
 224
 225 static int setup_dma(struct sc_pcminfo *scp);
 226 static void setup_ssi(struct sc_info *);
 227 static void ssi_configure_clock(struct sc_info *);
 228
 229 /*
 230  * Mixer interface.
 231  */
 232
 233 static int
 234 ssimixer_init(struct snd_mixer *m)
 235 {
 236         struct sc_pcminfo *scp;
 237         struct sc_info *sc;
 238         int mask;
 239
 240         scp = mix_getdevinfo(m);
 241         sc = scp->sc;
 242
 243         if (sc == NULL)
 244                 return -1;
 245
 246         mask = SOUND_MASK_PCM;
 247         mask |= SOUND_MASK_VOLUME;
 248
 249         snd_mtxlock(sc->lock);
 250         pcm_setflags(scp->dev, pcm_getflags(scp->dev) | SD_F_SOFTPCMVOL);
 251         mix_setdevs(m, mask);
 252         snd_mtxunlock(sc->lock);
 253
 254         return (0);
 255 }
 256
 257 static int
 258 ssimixer_set(struct snd_mixer *m, unsigned dev,
 259     unsigned left, unsigned right)
 260 {
 261         struct sc_pcminfo *scp;
 262
 263         scp = mix_getdevinfo(m);
 264
 265         /* Here we can configure hardware volume on our DAC */
 266
 267 #if 1
 268         device_printf(scp->dev, "ssimixer_set() %d %d\n",
 269             left, right);
 270 #endif
 271
 272         return (0);
 273 }
 274
 275 static kobj_method_t ssimixer_methods[] = {
 276         KOBJMETHOD(mixer_init,      ssimixer_init),
 277         KOBJMETHOD(mixer_set,       ssimixer_set),
 278         KOBJMETHOD_END
 279 };
 280 MIXER_DECLARE(ssimixer);
 281
 282
 283 /*
 284  * Channel interface.
 285  */
 286
 287 static void *
 288 ssichan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 289     struct pcm_channel *c, int dir)
 290 {
 291         struct sc_pcminfo *scp;
 292         struct sc_chinfo *ch;
 293         struct sc_info *sc;
 294
 295         scp = (struct sc_pcminfo *)devinfo;
 296         sc = scp->sc;
 297
 298         snd_mtxlock(sc->lock);
 299         ch = &scp->chan[0];
 300         ch->dir = dir;
 301         ch->run = 0;
 302         ch->buffer = b;
 303         ch->channel = c;
 304         ch->parent = scp;
 305         snd_mtxunlock(sc->lock);
 306
 307         if (sndbuf_setup(ch->buffer, sc->buf_base, sc->dma_size) != 0) {
 308                 device_printf(scp->dev, "Can't setup sndbuf.\n");
 309                 return NULL;
 310         }
 311
 312         return ch;
 313 }
 314
 315 static int
 316 ssichan_free(kobj_t obj, void *data)
 317 {
 318         struct sc_chinfo *ch = data;
 319         struct sc_pcminfo *scp = ch->parent;
 320         struct sc_info *sc = scp->sc;
 321
 322 #if 0
 323         device_printf(scp->dev, "ssichan_free()\n");
 324 #endif
 325
 326         snd_mtxlock(sc->lock);
 327         /* TODO: free channel buffer */
 328         snd_mtxunlock(sc->lock);
 329
 330         return (0);
 331 }
 332
 333 static int
 334 ssichan_setformat(kobj_t obj, void *data, uint32_t format)
 335 {
 336         struct sc_chinfo *ch = data;
 337
 338         ch->format = format;
 339
 340         return (0);
 341 }
 342
 343 static uint32_t
 344 ssichan_setspeed(kobj_t obj, void *data, uint32_t speed)
 345 {
 346         struct sc_pcminfo *scp;
 347         struct sc_chinfo *ch;
 348         struct ssi_rate *sr;
 349         struct sc_info *sc;
 350         int threshold;
 351         int i;
 352
 353         ch = data;
 354         scp = ch->parent;
 355         sc = scp->sc;
 356
 357         sr = NULL;
 358
 359         /* First look for equal frequency. */
 360         for (i = 0; rate_map[i].speed != 0; i++) {
 361                 if (rate_map[i].speed == speed)
 362                         sr = &rate_map[i];
 363         }
 364
 365         /* If no match, just find nearest. */
 366         if (sr == NULL) {
 367                 for (i = 0; rate_map[i].speed != 0; i++) {
 368                         sr = &rate_map[i];
 369                         threshold = sr->speed + ((rate_map[i + 1].speed != 0) ?
 370                             ((rate_map[i + 1].speed - sr->speed) >> 1) : 0);
 371                         if (speed < threshold)
 372                                 break;
 373                 }
 374         }
 375
 376         sc->sr = sr;
 377
 378         ssi_configure_clock(sc);
 379
 380         return (sr->speed);
 381 }
 382
 383 static void
 384 ssi_configure_clock(struct sc_info *sc)
 385 {
 386         struct ssi_rate *sr;
 387
 388         sr = sc->sr;
 389
 390         pll4_configure_output(sr->mfi, sr->mfn, sr->mfd);
 391
 392         /* Configure other dividers here, if any */
 393 }
 394
 395 static uint32_t
 396 ssichan_setblocksize(kobj_t obj, void *data, uint32_t blocksize)
 397 {
 398         struct sc_chinfo *ch = data;
 399         struct sc_pcminfo *scp = ch->parent;
 400         struct sc_info *sc = scp->sc;
 401
 402         sndbuf_resize(ch->buffer, sc->dma_size / blocksize, blocksize);
 403
 404         setup_dma(scp);
 405
 406         return (sndbuf_getblksz(ch->buffer));
 407 }
 408
 409 uint32_t
 410 ssi_dma_intr(void *arg, int chn)
 411 {
 412         struct sc_pcminfo *scp;
 413         struct sdma_conf *conf;
 414         struct sc_chinfo *ch;
 415         struct sc_info *sc;
 416         int bufsize;
 417
 418         scp = arg;
 419         ch = &scp->chan[0];
 420         sc = scp->sc;
 421         conf = sc->conf;
 422
 423         bufsize = sndbuf_getsize(ch->buffer);
 424
 425         sc->pos += conf->period;
 426         if (sc->pos >= bufsize)
 427                 sc->pos -= bufsize;
 428
 429         if (ch->run)
 430                 chn_intr(ch->channel);
 431
 432         return (0);
 433 }
 434
 435 static int
 436 find_sdma_controller(struct sc_info *sc)
 437 {
 438         struct sdma_softc *sdma_sc;
 439         phandle_t node, sdma_node;
 440         device_t sdma_dev;
 441         pcell_t dts_value[DMAS_TOTAL];
 442         int len;
 443
 444         if ((node = ofw_bus_get_node(sc->dev)) == -1)
 445                 return (ENXIO);
 446
 447         if ((len = OF_getproplen(node, "dmas")) <= 0)
 448                 return (ENXIO);
 449
 450         if (len != sizeof(dts_value)) {
 451                 device_printf(sc->dev,
 452                     "\"dmas\" property length is invalid: %d (expected %d)",
 453                     len, sizeof(dts_value));
 454                 return (ENXIO);
 455         }
 456
 457         OF_getencprop(node, "dmas", dts_value, sizeof(dts_value));
 458
 459         sc->sdma_ev_rx = dts_value[1];
 460         sc->sdma_ev_tx = dts_value[5];
 461
 462         sdma_node = OF_node_from_xref(dts_value[0]);
 463
 464         sdma_sc = NULL;
 465
 466         sdma_dev = devclass_get_device(devclass_find("sdma"), 0);
 467         if (sdma_dev)
 468                 sdma_sc = device_get_softc(sdma_dev);
 469
 470         if (sdma_sc == NULL) {
 471                 device_printf(sc->dev, "No sDMA found. Can't operate\n");
 472                 return (ENXIO);
 473         }
 474
 475         sc->sdma_sc = sdma_sc;
 476
 477         return (0);
 478 };
 479
 480 static int
 481 setup_dma(struct sc_pcminfo *scp)
 482 {
 483         struct sdma_conf *conf;
 484         struct sc_chinfo *ch;
 485         struct sc_info *sc;
 486         int fmt;
 487
 488         ch = &scp->chan[0];
 489         sc = scp->sc;
 490         conf = sc->conf;
 491
 492         conf->ih = ssi_dma_intr;
 493         conf->ih_user = scp;
 494         conf->saddr = sc->buf_base_phys;
 495         conf->daddr = rman_get_start(sc->res[0]) + SSI_STX0;
 496         conf->event = sc->sdma_ev_tx; /* SDMA TX event */
 497         conf->period = sndbuf_getblksz(ch->buffer);
 498         conf->num_bd = sndbuf_getblkcnt(ch->buffer);
 499
 500         /*
 501          * Word Length
 502          * Can be 32, 24, 16 or 8 for sDMA.
 503          *
 504          * SSI supports 24 at max.
 505          */
 506
 507         fmt = sndbuf_getfmt(ch->buffer);
 508
 509         if (fmt & AFMT_16BIT) {
 510                 conf->word_length = 16;
 511                 conf->command = CMD_2BYTES;
 512         } else if (fmt & AFMT_24BIT) {
 513                 conf->word_length = 24;
 514                 conf->command = CMD_3BYTES;
 515         } else {
 516                 device_printf(sc->dev, "Unknown format\n");
 517                 return (-1);
 518         }
 519
 520         return (0);
 521 }
 522
 523 static int
 524 ssi_start(struct sc_pcminfo *scp)
 525 {
 526         struct sc_info *sc;
 527         int reg;
 528
 529         sc = scp->sc;
 530
 531         if (sdma_configure(sc->sdma_channel, sc->conf) != 0) {
 532                 device_printf(sc->dev, "Can't configure sDMA\n");
 533                 return (-1);
 534         }
 535
 536         /* Enable DMA interrupt */
 537         reg = (SIER_TDMAE);
 538         WRITE4(sc, SSI_SIER, reg);
 539
 540         sdma_start(sc->sdma_channel);
 541
 542         return (0);
 543 }
 544
 545 static int
 546 ssi_stop(struct sc_pcminfo *scp)
 547 {
 548         struct sc_info *sc;
 549         int reg;
 550
 551         sc = scp->sc;
 552
 553         reg = READ4(sc, SSI_SIER);
 554         reg &= ~(SIER_TDMAE);
 555         WRITE4(sc, SSI_SIER, reg);
 556
 557         sdma_stop(sc->sdma_channel);
 558
 559         bzero(sc->buf_base, sc->dma_size);
 560
 561         return (0);
 562 }
 563
 564 static int
 565 ssichan_trigger(kobj_t obj, void *data, int go)
 566 {
 567         struct sc_pcminfo *scp;
 568         struct sc_chinfo *ch;
 569         struct sc_info *sc;
 570
 571         ch = data;
 572         scp = ch->parent;
 573         sc = scp->sc;
 574
 575         snd_mtxlock(sc->lock);
 576
 577         switch (go) {
 578         case PCMTRIG_START:
 579 #if 0
 580                 device_printf(scp->dev, "trigger start\n");
 581 #endif
 582                 ch->run = 1;
 583
 584                 ssi_start(scp);
 585
 586                 break;
 587
 588         case PCMTRIG_STOP:
 589         case PCMTRIG_ABORT:
 590 #if 0
 591                 device_printf(scp->dev, "trigger stop or abort\n");
 592 #endif
 593                 ch->run = 0;
 594
 595                 ssi_stop(scp);
 596
 597                 break;
 598         }
 599
 600         snd_mtxunlock(sc->lock);
 601
 602         return (0);
 603 }
 604
 605 static uint32_t
 606 ssichan_getptr(kobj_t obj, void *data)
 607 {
 608         struct sc_pcminfo *scp;
 609         struct sc_chinfo *ch;
 610         struct sc_info *sc;
 611
 612         ch = data;
 613         scp = ch->parent;
 614         sc = scp->sc;
 615
 616         return (sc->pos);
 617 }
 618
 619 static uint32_t ssi_pfmt[] = {
 620         SND_FORMAT(AFMT_S24_LE, 2, 0),
 621         0
 622 };
 623
 624 static struct pcmchan_caps ssi_pcaps = {44100, 192000, ssi_pfmt, 0};
 625
 626 static struct pcmchan_caps *
 627 ssichan_getcaps(kobj_t obj, void *data)
 628 {
 629
 630         return (&ssi_pcaps);
 631 }
 632
 633 static kobj_method_t ssichan_methods[] = {
 634         KOBJMETHOD(channel_init,         ssichan_init),
 635         KOBJMETHOD(channel_free,         ssichan_free),
 636         KOBJMETHOD(channel_setformat,    ssichan_setformat),
 637         KOBJMETHOD(channel_setspeed,     ssichan_setspeed),
 638         KOBJMETHOD(channel_setblocksize, ssichan_setblocksize),
 639         KOBJMETHOD(channel_trigger,      ssichan_trigger),
 640         KOBJMETHOD(channel_getptr,       ssichan_getptr),
 641         KOBJMETHOD(channel_getcaps,      ssichan_getcaps),
 642         KOBJMETHOD_END
 643 };
 644 CHANNEL_DECLARE(ssichan);
 645
 646 static int
 647 ssi_probe(device_t dev)
 648 {
 649
 650         if (!ofw_bus_status_okay(dev))
 651                 return (ENXIO);
 652
 653         if (!ofw_bus_is_compatible(dev, "fsl,imx6q-ssi"))
 654                 return (ENXIO);
 655
 656         device_set_desc(dev, "i.MX6 Synchronous Serial Interface (SSI)");
 657         return (BUS_PROBE_DEFAULT);
 658 }
 659
 660 static void
 661 ssi_intr(void *arg)
 662 {
 663         struct sc_pcminfo *scp;
 664         struct sc_chinfo *ch;
 665         struct sc_info *sc;
 666
 667         scp = arg;
 668         sc = scp->sc;
 669         ch = &scp->chan[0];
 670
 671         /* We don't use SSI interrupt */
 672 #if 0
 673         device_printf(sc->dev, "SSI Intr 0x%08x\n",
 674             READ4(sc, SSI_SISR));
 675 #endif
 676 }
 677
 678 static void
 679 setup_ssi(struct sc_info *sc)
 680 {
 681         int reg;
 682
 683         reg = READ4(sc, SSI_STCCR);
 684         reg &= ~(WL3_WL0_M << WL3_WL0_S);
 685         reg |= (0xb << WL3_WL0_S); /* 24 bit */
 686         reg &= ~(DC4_DC0_M << DC4_DC0_S);
 687         reg |= (1 << DC4_DC0_S); /* 2 words per frame */
 688         reg &= ~(STCCR_DIV2); /* Divide by 1 */
 689         reg &= ~(STCCR_PSR); /* Divide by 1 */
 690         reg &= ~(PM7_PM0_M << PM7_PM0_S);
 691         reg |= (1 << PM7_PM0_S); /* Divide by 2 */
 692         WRITE4(sc, SSI_STCCR, reg);
 693
 694         reg = READ4(sc, SSI_SFCSR);
 695         reg &= ~(SFCSR_TFWM0_M << SFCSR_TFWM0_S);
 696         reg |= (8 << SFCSR_TFWM0_S); /* empty slots */
 697         WRITE4(sc, SSI_SFCSR, reg);
 698
 699         reg = READ4(sc, SSI_STCR);
 700         reg |= (STCR_TFEN0);
 701         reg &= ~(STCR_TFEN1);
 702         reg &= ~(STCR_TSHFD); /* MSB */
 703         reg |= (STCR_TXBIT0);
 704         reg |= (STCR_TXDIR | STCR_TFDIR);
 705         reg |= (STCR_TSCKP); /* falling edge */
 706         reg |= (STCR_TFSI);
 707         reg &= ~(STCR_TFSI); /* active high frame sync */
 708         reg &= ~(STCR_TFSL);
 709         reg |= STCR_TEFS;
 710         WRITE4(sc, SSI_STCR, reg);
 711
 712         reg = READ4(sc, SSI_SCR);
 713         reg &= ~(SCR_I2S_MODE_M << SCR_I2S_MODE_S); /* Not master */
 714         reg |= (SCR_SSIEN | SCR_TE);
 715         reg |= (SCR_NET);
 716         reg |= (SCR_SYN);
 717         WRITE4(sc, SSI_SCR, reg);
 718 }
 719
 720 static void
 721 ssi_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int err)
 722 {
 723         bus_addr_t *addr;
 724
 725         if (err)
 726                 return;
 727
 728         addr = (bus_addr_t*)arg;
 729         *addr = segs[0].ds_addr;
 730 }
 731
 732 static int
 733 ssi_attach(device_t dev)
 734 {
 735         char status[SND_STATUSLEN];
 736         struct sc_pcminfo *scp;
 737         struct sc_info *sc;
 738         int err;
 739
 740         sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
 741         sc->dev = dev;
 742         sc->sr = &rate_map[0];
 743         sc->pos = 0;
 744         sc->conf = malloc(sizeof(struct sdma_conf), M_DEVBUF, M_WAITOK | M_ZERO);
 745
 746         sc->lock = snd_mtxcreate(device_get_nameunit(dev), "ssi softc");
 747         if (sc->lock == NULL) {
 748                 device_printf(dev, "Can't create mtx\n");
 749                 return (ENXIO);
 750         }
 751
 752         if (bus_alloc_resources(dev, ssi_spec, sc->res)) {
 753                 device_printf(dev, "could not allocate resources\n");
 754                 return (ENXIO);
 755         }
 756
 757         /* Memory interface */
 758         sc->bst = rman_get_bustag(sc->res[0]);
 759         sc->bsh = rman_get_bushandle(sc->res[0]);
 760
 761         /* SDMA */
 762         if (find_sdma_controller(sc)) {
 763                 device_printf(dev, "could not find active SDMA\n");
 764                 return (ENXIO);
 765         }
 766
 767         /* Setup PCM */
 768         scp = malloc(sizeof(struct sc_pcminfo), M_DEVBUF, M_NOWAIT | M_ZERO);
 769         scp->sc = sc;
 770         scp->dev = dev;
 771
 772         /*
 773          * Maximum possible DMA buffer.
 774          * Will be used partially to match 24 bit word.
 775          */
 776         sc->dma_size = 131072;
 777
 778         /*
 779          * Must use dma_size boundary as modulo feature required.
 780          * Modulo feature allows setup circular buffer.
 781          */
 782
 783         err = bus_dma_tag_create(
 784             bus_get_dma_tag(sc->dev),
 785             4, sc->dma_size,            /* alignment, boundary */
 786             BUS_SPACE_MAXADDR_32BIT,    /* lowaddr */
 787             BUS_SPACE_MAXADDR,          /* highaddr */
 788             NULL, NULL,                 /* filter, filterarg */
 789             sc->dma_size, 1,            /* maxsize, nsegments */
 790             sc->dma_size, 0,            /* maxsegsize, flags */
 791             NULL, NULL,                 /* lockfunc, lockarg */
 792             &sc->dma_tag);
 793
 794         err = bus_dmamem_alloc(sc->dma_tag, (void **)&sc->buf_base,
 795             BUS_DMA_NOWAIT | BUS_DMA_COHERENT, &sc->dma_map);
 796         if (err) {
 797                 device_printf(dev, "cannot allocate framebuffer\n");
 798                 return (ENXIO);
 799         }
 800
 801         err = bus_dmamap_load(sc->dma_tag, sc->dma_map, sc->buf_base,
 802             sc->dma_size, ssi_dmamap_cb, &sc->buf_base_phys, BUS_DMA_NOWAIT);
 803         if (err) {
 804                 device_printf(dev, "cannot load DMA map\n");
 805                 return (ENXIO);
 806         }
 807
 808         bzero(sc->buf_base, sc->dma_size);
 809
 810         /* Setup interrupt handler */
 811         err = bus_setup_intr(dev, sc->res[1], INTR_MPSAFE | INTR_TYPE_AV,
 812             NULL, ssi_intr, scp, &sc->ih);
 813         if (err) {
 814                 device_printf(dev, "Unable to alloc interrupt resource.\n");
 815                 return (ENXIO);
 816         }
 817
 818         pcm_setflags(dev, pcm_getflags(dev) | SD_F_MPSAFE);
 819
 820         err = pcm_register(dev, scp, 1, 0);
 821         if (err) {
 822                 device_printf(dev, "Can't register pcm.\n");
 823                 return (ENXIO);
 824         }
 825
 826         scp->chnum = 0;
 827         pcm_addchan(dev, PCMDIR_PLAY, &ssichan_class, scp);
 828         scp->chnum++;
 829
 830         snprintf(status, SND_STATUSLEN, "at simplebus");
 831         pcm_setstatus(dev, status);
 832
 833         mixer_init(dev, &ssimixer_class, scp);
 834         setup_ssi(sc);
 835
 836         imx_ccm_ssi_configure(dev);
 837
 838         sc->sdma_channel = sdma_alloc();
 839         if (sc->sdma_channel < 0) {
 840                 device_printf(sc->dev, "Can't get sDMA channel\n");
 841                 return (1);
 842         }
 843
 844         return (0);
 845 }
 846
 847 static device_method_t ssi_pcm_methods[] = {
 848         DEVMETHOD(device_probe,         ssi_probe),
 849         DEVMETHOD(device_attach,        ssi_attach),
 850         { 0, 0 }
 851 };
 852
 853 static driver_t ssi_pcm_driver = {
 854         "pcm",
 855         ssi_pcm_methods,
 856         PCM_SOFTC_SIZE,
 857 };
 858
 859 DRIVER_MODULE(ssi, simplebus, ssi_pcm_driver, pcm_devclass, 0, 0);
 860 MODULE_DEPEND(ssi, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
 861 MODULE_DEPEND(ssi, sdma, 0, 0, 0);
 862 MODULE_VERSION(ssi, 1);