arch/arm/mach-ep93xx/dma-m2p.c

   1 /*
   2  * arch/arm/mach-ep93xx/dma-m2p.c
   3  * M2P DMA handling for Cirrus EP93xx chips.
   4  *
   5  * Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
   6  * Copyright (C) 2006 Applied Data Systems
   7  *
   8  * Copyright (C) 2009 Ryan Mallon <ryan@bluewatersys.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or (at
  13  * your option) any later version.
  14  */
  15
  16 /*
  17  * On the EP93xx chip the following peripherals my be allocated to the 10
  18  * Memory to Internal Peripheral (M2P) channels (5 transmit + 5 receive).
  19  *
  20  *      I2S     contains 3 Tx and 3 Rx DMA Channels
  21  *      AAC     contains 3 Tx and 3 Rx DMA Channels
  22  *      UART1   contains 1 Tx and 1 Rx DMA Channels
  23  *      UART2   contains 1 Tx and 1 Rx DMA Channels
  24  *      UART3   contains 1 Tx and 1 Rx DMA Channels
  25  *      IrDA    contains 1 Tx and 1 Rx DMA Channels
  26  *
  27  * SSP and IDE use the Memory to Memory (M2M) channels and are not covered
  28  * with this implementation.
  29  */
  30
  31 #define pr_fmt(fmt) "ep93xx " KBUILD_MODNAME ": " fmt
  32
  33 #include <linux/kernel.h>
  34 #include <linux/clk.h>
  35 #include <linux/err.h>
  36 #include <linux/interrupt.h>
  37 #include <linux/module.h>
  38 #include <linux/io.h>
  39
  40 #include <mach/dma.h>
  41 #include <mach/hardware.h>
  42
  43 #define M2P_CONTROL                     0x00
  44 #define  M2P_CONTROL_STALL_IRQ_EN       (1 << 0)
  45 #define  M2P_CONTROL_NFB_IRQ_EN         (1 << 1)
  46 #define  M2P_CONTROL_ERROR_IRQ_EN       (1 << 3)
  47 #define  M2P_CONTROL_ENABLE             (1 << 4)
  48 #define M2P_INTERRUPT                   0x04
  49 #define  M2P_INTERRUPT_STALL            (1 << 0)
  50 #define  M2P_INTERRUPT_NFB              (1 << 1)
  51 #define  M2P_INTERRUPT_ERROR            (1 << 3)
  52 #define M2P_PPALLOC                     0x08
  53 #define M2P_STATUS                      0x0c
  54 #define M2P_REMAIN                      0x14
  55 #define M2P_MAXCNT0                     0x20
  56 #define M2P_BASE0                       0x24
  57 #define M2P_MAXCNT1                     0x30
  58 #define M2P_BASE1                       0x34
  59
  60 #define STATE_IDLE      0       /* Channel is inactive.  */
  61 #define STATE_STALL     1       /* Channel is active, no buffers pending.  */
  62 #define STATE_ON        2       /* Channel is active, one buffer pending.  */
  63 #define STATE_NEXT      3       /* Channel is active, two buffers pending.  */
  64
  65 struct m2p_channel {
  66         char                            *name;
  67         void __iomem                    *base;
  68         int                             irq;
  69
  70         struct clk                      *clk;
  71         spinlock_t                      lock;
  72
  73         void                            *client;
  74         unsigned                        next_slot:1;
  75         struct ep93xx_dma_buffer        *buffer_xfer;
  76         struct ep93xx_dma_buffer        *buffer_next;
  77         struct list_head                buffers_pending;
  78 };
  79
  80 static struct m2p_channel m2p_rx[] = {
  81         {"m2p1", EP93XX_DMA_BASE + 0x0040, IRQ_EP93XX_DMAM2P1},
  82         {"m2p3", EP93XX_DMA_BASE + 0x00c0, IRQ_EP93XX_DMAM2P3},
  83         {"m2p5", EP93XX_DMA_BASE + 0x0200, IRQ_EP93XX_DMAM2P5},
  84         {"m2p7", EP93XX_DMA_BASE + 0x0280, IRQ_EP93XX_DMAM2P7},
  85         {"m2p9", EP93XX_DMA_BASE + 0x0300, IRQ_EP93XX_DMAM2P9},
  86         {NULL},
  87 };
  88
  89 static struct m2p_channel m2p_tx[] = {
  90         {"m2p0", EP93XX_DMA_BASE + 0x0000, IRQ_EP93XX_DMAM2P0},
  91         {"m2p2", EP93XX_DMA_BASE + 0x0080, IRQ_EP93XX_DMAM2P2},
  92         {"m2p4", EP93XX_DMA_BASE + 0x0240, IRQ_EP93XX_DMAM2P4},
  93         {"m2p6", EP93XX_DMA_BASE + 0x02c0, IRQ_EP93XX_DMAM2P6},
  94         {"m2p8", EP93XX_DMA_BASE + 0x0340, IRQ_EP93XX_DMAM2P8},
  95         {NULL},
  96 };
  97
  98 static void feed_buf(struct m2p_channel *ch, struct ep93xx_dma_buffer *buf)
  99 {
 100         if (ch->next_slot == 0) {
 101                 writel(buf->size, ch->base + M2P_MAXCNT0);
 102                 writel(buf->bus_addr, ch->base + M2P_BASE0);
 103         } else {
 104                 writel(buf->size, ch->base + M2P_MAXCNT1);
 105                 writel(buf->bus_addr, ch->base + M2P_BASE1);
 106         }
 107         ch->next_slot ^= 1;
 108 }
 109
 110 static void choose_buffer_xfer(struct m2p_channel *ch)
 111 {
 112         struct ep93xx_dma_buffer *buf;
 113
 114         ch->buffer_xfer = NULL;
 115         if (!list_empty(&ch->buffers_pending)) {
 116                 buf = list_entry(ch->buffers_pending.next,
 117                                  struct ep93xx_dma_buffer, list);
 118                 list_del(&buf->list);
 119                 feed_buf(ch, buf);
 120                 ch->buffer_xfer = buf;
 121         }
 122 }
 123
 124 static void choose_buffer_next(struct m2p_channel *ch)
 125 {
 126         struct ep93xx_dma_buffer *buf;
 127
 128         ch->buffer_next = NULL;
 129         if (!list_empty(&ch->buffers_pending)) {
 130                 buf = list_entry(ch->buffers_pending.next,
 131                                  struct ep93xx_dma_buffer, list);
 132                 list_del(&buf->list);
 133                 feed_buf(ch, buf);
 134                 ch->buffer_next = buf;
 135         }
 136 }
 137
 138 static inline void m2p_set_control(struct m2p_channel *ch, u32 v)
 139 {
 140         /*
 141          * The control register must be read immediately after being written so
 142          * that the internal state machine is correctly updated. See the ep93xx
 143          * users' guide for details.
 144          */
 145         writel(v, ch->base + M2P_CONTROL);
 146         readl(ch->base + M2P_CONTROL);
 147 }
 148
 149 static inline int m2p_channel_state(struct m2p_channel *ch)
 150 {
 151         return (readl(ch->base + M2P_STATUS) >> 4) & 0x3;
 152 }
 153
 154 static irqreturn_t m2p_irq(int irq, void *dev_id)
 155 {
 156         struct m2p_channel *ch = dev_id;
 157         struct ep93xx_dma_m2p_client *cl;
 158         u32 irq_status, v;
 159         int error = 0;
 160
 161         cl = ch->client;
 162
 163         spin_lock(&ch->lock);
 164         irq_status = readl(ch->base + M2P_INTERRUPT);
 165
 166         if (irq_status & M2P_INTERRUPT_ERROR) {
 167                 writel(M2P_INTERRUPT_ERROR, ch->base + M2P_INTERRUPT);
 168                 error = 1;
 169         }
 170
 171         if ((irq_status & (M2P_INTERRUPT_STALL | M2P_INTERRUPT_NFB)) == 0) {
 172                 spin_unlock(&ch->lock);
 173                 return IRQ_NONE;
 174         }
 175
 176         switch (m2p_channel_state(ch)) {
 177         case STATE_IDLE:
 178                 pr_crit("dma interrupt without a dma buffer\n");
 179                 BUG();
 180                 break;
 181
 182         case STATE_STALL:
 183                 cl->buffer_finished(cl->cookie, ch->buffer_xfer, 0, error);
 184                 if (ch->buffer_next != NULL) {
 185                         cl->buffer_finished(cl->cookie, ch->buffer_next,
 186                                             0, error);
 187                 }
 188                 choose_buffer_xfer(ch);
 189                 choose_buffer_next(ch);
 190                 if (ch->buffer_xfer != NULL)
 191                         cl->buffer_started(cl->cookie, ch->buffer_xfer);
 192                 break;
 193
 194         case STATE_ON:
 195                 cl->buffer_finished(cl->cookie, ch->buffer_xfer, 0, error);
 196                 ch->buffer_xfer = ch->buffer_next;
 197                 choose_buffer_next(ch);
 198                 cl->buffer_started(cl->cookie, ch->buffer_xfer);
 199                 break;
 200
 201         case STATE_NEXT:
 202                 pr_crit("dma interrupt while next\n");
 203                 BUG();
 204                 break;
 205         }
 206
 207         v = readl(ch->base + M2P_CONTROL) & ~(M2P_CONTROL_STALL_IRQ_EN |
 208                                               M2P_CONTROL_NFB_IRQ_EN);
 209         if (ch->buffer_xfer != NULL)
 210                 v |= M2P_CONTROL_STALL_IRQ_EN;
 211         if (ch->buffer_next != NULL)
 212                 v |= M2P_CONTROL_NFB_IRQ_EN;
 213         m2p_set_control(ch, v);
 214
 215         spin_unlock(&ch->lock);
 216         return IRQ_HANDLED;
 217 }
 218
 219 static struct m2p_channel *find_free_channel(struct ep93xx_dma_m2p_client *cl)
 220 {
 221         struct m2p_channel *ch;
 222         int i;
 223
 224         if (cl->flags & EP93XX_DMA_M2P_RX)
 225                 ch = m2p_rx;
 226         else
 227                 ch = m2p_tx;
 228
 229         for (i = 0; ch[i].base; i++) {
 230                 struct ep93xx_dma_m2p_client *client;
 231
 232                 client = ch[i].client;
 233                 if (client != NULL) {
 234                         int port;
 235
 236                         port = cl->flags & EP93XX_DMA_M2P_PORT_MASK;
 237                         if (port == (client->flags &
 238                                      EP93XX_DMA_M2P_PORT_MASK)) {
 239                                 pr_warning("DMA channel already used by %s\n",
 240                                            cl->name ? : "unknown client");
 241                                 return ERR_PTR(-EBUSY);
 242                         }
 243                 }
 244         }
 245
 246         for (i = 0; ch[i].base; i++) {
 247                 if (ch[i].client == NULL)
 248                         return ch + i;
 249         }
 250
 251         pr_warning("No free DMA channel for %s\n",
 252                    cl->name ? : "unknown client");
 253         return ERR_PTR(-ENODEV);
 254 }
 255
 256 static void channel_enable(struct m2p_channel *ch)
 257 {
 258         struct ep93xx_dma_m2p_client *cl = ch->client;
 259         u32 v;
 260
 261         clk_enable(ch->clk);
 262
 263         v = cl->flags & EP93XX_DMA_M2P_PORT_MASK;
 264         writel(v, ch->base + M2P_PPALLOC);
 265
 266         v = cl->flags & EP93XX_DMA_M2P_ERROR_MASK;
 267         v |= M2P_CONTROL_ENABLE | M2P_CONTROL_ERROR_IRQ_EN;
 268         m2p_set_control(ch, v);
 269 }
 270
 271 static void channel_disable(struct m2p_channel *ch)
 272 {
 273         u32 v;
 274
 275         v = readl(ch->base + M2P_CONTROL);
 276         v &= ~(M2P_CONTROL_STALL_IRQ_EN | M2P_CONTROL_NFB_IRQ_EN);
 277         m2p_set_control(ch, v);
 278
 279         while (m2p_channel_state(ch) >= STATE_ON)
 280                 cpu_relax();
 281
 282         m2p_set_control(ch, 0x0);
 283
 284         while (m2p_channel_state(ch) == STATE_STALL)
 285                 cpu_relax();
 286
 287         clk_disable(ch->clk);
 288 }
 289
 290 int ep93xx_dma_m2p_client_register(struct ep93xx_dma_m2p_client *cl)
 291 {
 292         struct m2p_channel *ch;
 293         int err;
 294
 295         ch = find_free_channel(cl);
 296         if (IS_ERR(ch))
 297                 return PTR_ERR(ch);
 298
 299         err = request_irq(ch->irq, m2p_irq, 0, cl->name ? : "dma-m2p", ch);
 300         if (err)
 301                 return err;
 302
 303         ch->client = cl;
 304         ch->next_slot = 0;
 305         ch->buffer_xfer = NULL;
 306         ch->buffer_next = NULL;
 307         INIT_LIST_HEAD(&ch->buffers_pending);
 308
 309         cl->channel = ch;
 310
 311         channel_enable(ch);
 312
 313         return 0;
 314 }
 315 EXPORT_SYMBOL_GPL(ep93xx_dma_m2p_client_register);
 316
 317 void ep93xx_dma_m2p_client_unregister(struct ep93xx_dma_m2p_client *cl)
 318 {
 319         struct m2p_channel *ch = cl->channel;
 320
 321         channel_disable(ch);
 322         free_irq(ch->irq, ch);
 323         ch->client = NULL;
 324 }
 325 EXPORT_SYMBOL_GPL(ep93xx_dma_m2p_client_unregister);
 326
 327 void ep93xx_dma_m2p_submit(struct ep93xx_dma_m2p_client *cl,
 328                            struct ep93xx_dma_buffer *buf)
 329 {
 330         struct m2p_channel *ch = cl->channel;
 331         unsigned long flags;
 332         u32 v;
 333
 334         spin_lock_irqsave(&ch->lock, flags);
 335         v = readl(ch->base + M2P_CONTROL);
 336         if (ch->buffer_xfer == NULL) {
 337                 ch->buffer_xfer = buf;
 338                 feed_buf(ch, buf);
 339                 cl->buffer_started(cl->cookie, buf);
 340
 341                 v |= M2P_CONTROL_STALL_IRQ_EN;
 342                 m2p_set_control(ch, v);
 343
 344         } else if (ch->buffer_next == NULL) {
 345                 ch->buffer_next = buf;
 346                 feed_buf(ch, buf);
 347
 348                 v |= M2P_CONTROL_NFB_IRQ_EN;
 349                 m2p_set_control(ch, v);
 350         } else {
 351                 list_add_tail(&buf->list, &ch->buffers_pending);
 352         }
 353         spin_unlock_irqrestore(&ch->lock, flags);
 354 }
 355 EXPORT_SYMBOL_GPL(ep93xx_dma_m2p_submit);
 356
 357 void ep93xx_dma_m2p_submit_recursive(struct ep93xx_dma_m2p_client *cl,
 358                                      struct ep93xx_dma_buffer *buf)
 359 {
 360         struct m2p_channel *ch = cl->channel;
 361
 362         list_add_tail(&buf->list, &ch->buffers_pending);
 363 }
 364 EXPORT_SYMBOL_GPL(ep93xx_dma_m2p_submit_recursive);
 365
 366 void ep93xx_dma_m2p_flush(struct ep93xx_dma_m2p_client *cl)
 367 {
 368         struct m2p_channel *ch = cl->channel;
 369
 370         channel_disable(ch);
 371         ch->next_slot = 0;
 372         ch->buffer_xfer = NULL;
 373         ch->buffer_next = NULL;
 374         INIT_LIST_HEAD(&ch->buffers_pending);
 375         channel_enable(ch);
 376 }
 377 EXPORT_SYMBOL_GPL(ep93xx_dma_m2p_flush);
 378
 379 static int init_channel(struct m2p_channel *ch)
 380 {
 381         ch->clk = clk_get(NULL, ch->name);
 382         if (IS_ERR(ch->clk))
 383                 return PTR_ERR(ch->clk);
 384
 385         spin_lock_init(&ch->lock);
 386         ch->client = NULL;
 387
 388         return 0;
 389 }
 390
 391 static int __init ep93xx_dma_m2p_init(void)
 392 {
 393         int i;
 394         int ret;
 395
 396         for (i = 0; m2p_rx[i].base; i++) {
 397                 ret = init_channel(m2p_rx + i);
 398                 if (ret)
 399                         return ret;
 400         }
 401
 402         for (i = 0; m2p_tx[i].base; i++) {
 403                 ret = init_channel(m2p_tx + i);
 404                 if (ret)
 405                         return ret;
 406         }
 407
 408         pr_info("M2P DMA subsystem initialized\n");
 409         return 0;
 410 }
 411 arch_initcall(ep93xx_dma_m2p_init);