git.oblomov.eu Git - linux-2.6/blob - arch/arm/mach-s3c2410/dma.c

   1 /* linux/arch/arm/mach-bast/dma.c
   2  *
   3  * (c) 2003-2005 Simtec Electronics
   4  *      Ben Dooks <ben@simtec.co.uk>
   5  *
   6  * S3C2410 DMA core
   7  *
   8  * http://www.simtec.co.uk/products/EB2410ITX/
   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 version 2 as
  12  * published by the Free Software Foundation.
  13  *
  14  * Changelog:
  15  *  27-Feb-2005 BJD  Added kmem cache for dma descriptors
  16  *  18-Nov-2004 BJD  Removed error for loading onto stopped channel
  17  *  10-Nov-2004 BJD  Ensure all external symbols exported for modules
  18  *  10-Nov-2004 BJD  Use sys_device and sysdev_class for power management
  19  *  08-Aug-2004 BJD  Apply rmk's suggestions
  20  *  21-Jul-2004 BJD  Ported to linux 2.6
  21  *  12-Jul-2004 BJD  Finished re-write and change of API
  22  *  06-Jul-2004 BJD  Rewrote dma code to try and cope with various problems
  23  *  23-May-2003 BJD  Created file
  24  *  19-Aug-2003 BJD  Cleanup, header fix, added URL
  25  *
  26  * This file is based on the Sangwook Lee/Samsung patches, re-written due
  27  * to various ommisions from the code (such as flexible dma configuration)
  28  * for use with the BAST system board.
  29  *
  30  * The re-write is pretty much complete, and should be good enough for any
  31  * possible DMA function
  32  */
  33
  34 #include <linux/config.h>
  35
  36 #ifdef CONFIG_S3C2410_DMA_DEBUG
  37 #define DEBUG
  38 #endif
  39
  40 #include <linux/module.h>
  41 #include <linux/init.h>
  42 #include <linux/sched.h>
  43 #include <linux/spinlock.h>
  44 #include <linux/interrupt.h>
  45 #include <linux/sysdev.h>
  46 #include <linux/slab.h>
  47 #include <linux/errno.h>
  48 #include <linux/delay.h>
  49
  50 #include <asm/system.h>
  51 #include <asm/irq.h>
  52 #include <asm/hardware.h>
  53 #include <asm/io.h>
  54 #include <asm/dma.h>
  55
  56 #include <asm/mach/dma.h>
  57 #include <asm/arch/map.h>
  58
  59 /* io map for dma */
  60 static void __iomem *dma_base;
  61 static kmem_cache_t *dma_kmem;
  62
  63 /* dma channel state information */
  64 s3c2410_dma_chan_t s3c2410_chans[S3C2410_DMA_CHANNELS];
  65
  66 /* debugging functions */
  67
  68 #define BUF_MAGIC (0xcafebabe)
  69
  70 #define dmawarn(fmt...) printk(KERN_DEBUG fmt)
  71
  72 #define dma_regaddr(chan, reg) ((chan)->regs + (reg))
  73
  74 #if 1
  75 #define dma_wrreg(chan, reg, val) writel((val), (chan)->regs + (reg))
  76 #else
  77 static inline void
  78 dma_wrreg(s3c2410_dma_chan_t *chan, int reg, unsigned long val)
  79 {
  80         pr_debug("writing %08x to register %08x\n",(unsigned int)val,reg);
  81         writel(val, dma_regaddr(chan, reg));
  82 }
  83
  84 #endif
  85
  86 #define dma_rdreg(chan, reg) readl((chan)->regs + (reg))
  87
  88 /* captured register state for debug */
  89
  90 struct s3c2410_dma_regstate {
  91         unsigned long         dcsrc;
  92         unsigned long         disrc;
  93         unsigned long         dstat;
  94         unsigned long         dcon;
  95         unsigned long         dmsktrig;
  96 };
  97
  98 #ifdef CONFIG_S3C2410_DMA_DEBUG
  99
 100 /* dmadbg_showregs
 101  *
 102  * simple debug routine to print the current state of the dma registers
 103 */
 104
 105 static void
 106 dmadbg_capture(s3c2410_dma_chan_t *chan, struct s3c2410_dma_regstate *regs)
 107 {
 108         regs->dcsrc    = dma_rdreg(chan, S3C2410_DMA_DCSRC);
 109         regs->disrc    = dma_rdreg(chan, S3C2410_DMA_DISRC);
 110         regs->dstat    = dma_rdreg(chan, S3C2410_DMA_DSTAT);
 111         regs->dcon     = dma_rdreg(chan, S3C2410_DMA_DCON);
 112         regs->dmsktrig = dma_rdreg(chan, S3C2410_DMA_DMASKTRIG);
 113 }
 114
 115 static void
 116 dmadbg_showregs(const char *fname, int line, s3c2410_dma_chan_t *chan,
 117                  struct s3c2410_dma_regstate *regs)
 118 {
 119         printk(KERN_DEBUG "dma%d: %s:%d: DCSRC=%08lx, DISRC=%08lx, DSTAT=%08lx DMT=%02lx, DCON=%08lx\n",
 120                chan->number, fname, line,
 121                regs->dcsrc, regs->disrc, regs->dstat, regs->dmsktrig,
 122                regs->dcon);
 123 }
 124
 125 static void
 126 dmadbg_showchan(const char *fname, int line, s3c2410_dma_chan_t *chan)
 127 {
 128         struct s3c2410_dma_regstate state;
 129
 130         dmadbg_capture(chan, &state);
 131
 132         printk(KERN_DEBUG "dma%d: %s:%d: ls=%d, cur=%p, %p %p\n",
 133                chan->number, fname, line, chan->load_state,
 134                chan->curr, chan->next, chan->end);
 135
 136         dmadbg_showregs(fname, line, chan, &state);
 137 }
 138
 139 #define dbg_showregs(chan) dmadbg_showregs(__FUNCTION__, __LINE__, (chan))
 140 #define dbg_showchan(chan) dmadbg_showchan(__FUNCTION__, __LINE__, (chan))
 141 #else
 142 #define dbg_showregs(chan) do { } while(0)
 143 #define dbg_showchan(chan) do { } while(0)
 144 #endif /* CONFIG_S3C2410_DMA_DEBUG */
 145
 146 #define check_channel(chan) \
 147   do { if ((chan) >= S3C2410_DMA_CHANNELS) { \
 148     printk(KERN_ERR "%s: invalid channel %d\n", __FUNCTION__, (chan)); \
 149     return -EINVAL; \
 150   } } while(0)
 151
 152
 153 /* s3c2410_dma_stats_timeout
 154  *
 155  * Update DMA stats from timeout info
 156 */
 157
 158 static void
 159 s3c2410_dma_stats_timeout(s3c2410_dma_stats_t *stats, int val)
 160 {
 161         if (stats == NULL)
 162                 return;
 163
 164         if (val > stats->timeout_longest)
 165                 stats->timeout_longest = val;
 166         if (val < stats->timeout_shortest)
 167                 stats->timeout_shortest = val;
 168
 169         stats->timeout_avg += val;
 170 }
 171
 172 /* s3c2410_dma_waitforload
 173  *
 174  * wait for the DMA engine to load a buffer, and update the state accordingly
 175 */
 176
 177 static int
 178 s3c2410_dma_waitforload(s3c2410_dma_chan_t *chan, int line)
 179 {
 180         int timeout = chan->load_timeout;
 181         int took;
 182
 183         if (chan->load_state != S3C2410_DMALOAD_1LOADED) {
 184                 printk(KERN_ERR "dma%d: s3c2410_dma_waitforload() called in loadstate %d from line %d\n", chan->number, chan->load_state, line);
 185                 return 0;
 186         }
 187
 188         if (chan->stats != NULL)
 189                 chan->stats->loads++;
 190
 191         while (--timeout > 0) {
 192                 if ((dma_rdreg(chan, S3C2410_DMA_DSTAT) << (32-20)) != 0) {
 193                         took = chan->load_timeout - timeout;
 194
 195                         s3c2410_dma_stats_timeout(chan->stats, took);
 196
 197                         switch (chan->load_state) {
 198                         case S3C2410_DMALOAD_1LOADED:
 199                                 chan->load_state = S3C2410_DMALOAD_1RUNNING;
 200                                 break;
 201
 202                         default:
 203                                 printk(KERN_ERR "dma%d: unknown load_state in s3c2410_dma_waitforload() %d\n", chan->number, chan->load_state);
 204                         }
 205
 206                         return 1;
 207                 }
 208         }
 209
 210         if (chan->stats != NULL) {
 211                 chan->stats->timeout_failed++;
 212         }
 213
 214         return 0;
 215 }
 216
 217
 218
 219 /* s3c2410_dma_loadbuffer
 220  *
 221  * load a buffer, and update the channel state
 222 */
 223
 224 static inline int
 225 s3c2410_dma_loadbuffer(s3c2410_dma_chan_t *chan,
 226                        s3c2410_dma_buf_t *buf)
 227 {
 228         unsigned long reload;
 229
 230         pr_debug("s3c2410_chan_loadbuffer: loading buff %p (0x%08lx,0x%06x)\n",
 231                  buf, (unsigned long)buf->data, buf->size);
 232
 233         if (buf == NULL) {
 234                 dmawarn("buffer is NULL\n");
 235                 return -EINVAL;
 236         }
 237
 238         /* check the state of the channel before we do anything */
 239
 240         if (chan->load_state == S3C2410_DMALOAD_1LOADED) {
 241                 dmawarn("load_state is S3C2410_DMALOAD_1LOADED\n");
 242         }
 243
 244         if (chan->load_state == S3C2410_DMALOAD_1LOADED_1RUNNING) {
 245                 dmawarn("state is S3C2410_DMALOAD_1LOADED_1RUNNING\n");
 246         }
 247
 248         /* it would seem sensible if we are the last buffer to not bother
 249          * with the auto-reload bit, so that the DMA engine will not try
 250          * and load another transfer after this one has finished...
 251          */
 252         if (chan->load_state == S3C2410_DMALOAD_NONE) {
 253                 pr_debug("load_state is none, checking for noreload (next=%p)\n",
 254                          buf->next);
 255                 reload = (buf->next == NULL) ? S3C2410_DCON_NORELOAD : 0;
 256         } else {
 257                 pr_debug("load_state is %d => autoreload\n", chan->load_state);
 258                 reload = S3C2410_DCON_AUTORELOAD;
 259         }
 260
 261         writel(buf->data, chan->addr_reg);
 262
 263         dma_wrreg(chan, S3C2410_DMA_DCON,
 264                   chan->dcon | reload | (buf->size/chan->xfer_unit));
 265
 266         chan->next = buf->next;
 267
 268         /* update the state of the channel */
 269
 270         switch (chan->load_state) {
 271         case S3C2410_DMALOAD_NONE:
 272                 chan->load_state = S3C2410_DMALOAD_1LOADED;
 273                 break;
 274
 275         case S3C2410_DMALOAD_1RUNNING:
 276                 chan->load_state = S3C2410_DMALOAD_1LOADED_1RUNNING;
 277                 break;
 278
 279         default:
 280                 dmawarn("dmaload: unknown state %d in loadbuffer\n",
 281                         chan->load_state);
 282                 break;
 283         }
 284
 285         return 0;
 286 }
 287
 288 /* s3c2410_dma_call_op
 289  *
 290  * small routine to call the op routine with the given op if it has been
 291  * registered
 292 */
 293
 294 static void
 295 s3c2410_dma_call_op(s3c2410_dma_chan_t *chan, s3c2410_chan_op_t op)
 296 {
 297         if (chan->op_fn != NULL) {
 298                 (chan->op_fn)(chan, op);
 299         }
 300 }
 301
 302 /* s3c2410_dma_buffdone
 303  *
 304  * small wrapper to check if callback routine needs to be called, and
 305  * if so, call it
 306 */
 307
 308 static inline void
 309 s3c2410_dma_buffdone(s3c2410_dma_chan_t *chan, s3c2410_dma_buf_t *buf,
 310                      s3c2410_dma_buffresult_t result)
 311 {
 312         pr_debug("callback_fn=%p, buf=%p, id=%p, size=%d, result=%d\n",
 313                  chan->callback_fn, buf, buf->id, buf->size, result);
 314
 315         if (chan->callback_fn != NULL) {
 316                 (chan->callback_fn)(chan, buf->id, buf->size, result);
 317         }
 318 }
 319
 320 /* s3c2410_dma_start
 321  *
 322  * start a dma channel going
 323 */
 324
 325 static int s3c2410_dma_start(s3c2410_dma_chan_t *chan)
 326 {
 327         unsigned long tmp;
 328         unsigned long flags;
 329
 330         pr_debug("s3c2410_start_dma: channel=%d\n", chan->number);
 331
 332         local_irq_save(flags);
 333
 334         if (chan->state == S3C2410_DMA_RUNNING) {
 335                 pr_debug("s3c2410_start_dma: already running (%d)\n", chan->state);
 336                 local_irq_restore(flags);
 337                 return 0;
 338         }
 339
 340         chan->state = S3C2410_DMA_RUNNING;
 341
 342         /* check wether there is anything to load, and if not, see
 343          * if we can find anything to load
 344          */
 345
 346         if (chan->load_state == S3C2410_DMALOAD_NONE) {
 347                 if (chan->next == NULL) {
 348                         printk(KERN_ERR "dma%d: channel has nothing loaded\n",
 349                                chan->number);
 350                         chan->state = S3C2410_DMA_IDLE;
 351                         local_irq_restore(flags);
 352                         return -EINVAL;
 353                 }
 354
 355                 s3c2410_dma_loadbuffer(chan, chan->next);
 356         }
 357
 358         dbg_showchan(chan);
 359
 360         /* enable the channel */
 361
 362         if (!chan->irq_enabled) {
 363                 enable_irq(chan->irq);
 364                 chan->irq_enabled = 1;
 365         }
 366
 367         /* start the channel going */
 368
 369         tmp = dma_rdreg(chan, S3C2410_DMA_DMASKTRIG);
 370         tmp &= ~S3C2410_DMASKTRIG_STOP;
 371         tmp |= S3C2410_DMASKTRIG_ON;
 372         dma_wrreg(chan, S3C2410_DMA_DMASKTRIG, tmp);
 373
 374         pr_debug("wrote %08lx to DMASKTRIG\n", tmp);
 375
 376 #if 0
 377         /* the dma buffer loads should take care of clearing the AUTO
 378          * reloading feature */
 379         tmp = dma_rdreg(chan, S3C2410_DMA_DCON);
 380         tmp &= ~S3C2410_DCON_NORELOAD;
 381         dma_wrreg(chan, S3C2410_DMA_DCON, tmp);
 382 #endif
 383
 384         s3c2410_dma_call_op(chan, S3C2410_DMAOP_START);
 385
 386         dbg_showchan(chan);
 387
 388         local_irq_restore(flags);
 389         return 0;
 390 }
 391
 392 /* s3c2410_dma_canload
 393  *
 394  * work out if we can queue another buffer into the DMA engine
 395 */
 396
 397 static int
 398 s3c2410_dma_canload(s3c2410_dma_chan_t *chan)
 399 {
 400         if (chan->load_state == S3C2410_DMALOAD_NONE ||
 401             chan->load_state == S3C2410_DMALOAD_1RUNNING)
 402                 return 1;
 403
 404         return 0;
 405 }
 406
 407
 408 /* s3c2410_dma_enqueue
 409  *
 410  * queue an given buffer for dma transfer.
 411  *
 412  * id         the device driver's id information for this buffer
 413  * data       the physical address of the buffer data
 414  * size       the size of the buffer in bytes
 415  *
 416  * If the channel is not running, then the flag S3C2410_DMAF_AUTOSTART
 417  * is checked, and if set, the channel is started. If this flag isn't set,
 418  * then an error will be returned.
 419  *
 420  * It is possible to queue more than one DMA buffer onto a channel at
 421  * once, and the code will deal with the re-loading of the next buffer
 422  * when necessary.
 423 */
 424
 425 int s3c2410_dma_enqueue(unsigned int channel, void *id,
 426                         dma_addr_t data, int size)
 427 {
 428         s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
 429         s3c2410_dma_buf_t *buf;
 430         unsigned long flags;
 431
 432         check_channel(channel);
 433
 434         pr_debug("%s: id=%p, data=%08x, size=%d\n",
 435                  __FUNCTION__, id, (unsigned int)data, size);
 436
 437         buf = kmem_cache_alloc(dma_kmem, GFP_ATOMIC);
 438         if (buf == NULL) {
 439                 pr_debug("%s: out of memory (%ld alloc)\n",
 440                          __FUNCTION__, sizeof(*buf));
 441                 return -ENOMEM;
 442         }
 443
 444         pr_debug("%s: new buffer %p\n", __FUNCTION__, buf);
 445
 446         //dbg_showchan(chan);
 447
 448         buf->next  = NULL;
 449         buf->data  = buf->ptr = data;
 450         buf->size  = size;
 451         buf->id    = id;
 452         buf->magic = BUF_MAGIC;
 453
 454         local_irq_save(flags);
 455
 456         if (chan->curr == NULL) {
 457                 /* we've got nothing loaded... */
 458                 pr_debug("%s: buffer %p queued onto empty channel\n",
 459                          __FUNCTION__, buf);
 460
 461                 chan->curr = buf;
 462                 chan->end  = buf;
 463                 chan->next = NULL;
 464         } else {
 465                 pr_debug("dma%d: %s: buffer %p queued onto non-empty channel\n",
 466                          chan->number, __FUNCTION__, buf);
 467
 468                 if (chan->end == NULL)
 469                         pr_debug("dma%d: %s: %p not empty, and chan->end==NULL?\n",
 470                                  chan->number, __FUNCTION__, chan);
 471
 472                 chan->end->next = buf;
 473                 chan->end = buf;
 474         }
 475
 476         /* if necessary, update the next buffer field */
 477         if (chan->next == NULL)
 478                 chan->next = buf;
 479
 480         /* check to see if we can load a buffer */
 481         if (chan->state == S3C2410_DMA_RUNNING) {
 482                 if (chan->load_state == S3C2410_DMALOAD_1LOADED && 1) {
 483                         if (s3c2410_dma_waitforload(chan, __LINE__) == 0) {
 484                                 printk(KERN_ERR "dma%d: loadbuffer:"
 485                                        "timeout loading buffer\n",
 486                                        chan->number);
 487                                 dbg_showchan(chan);
 488                                 local_irq_restore(flags);
 489                                 return -EINVAL;
 490                         }
 491                 }
 492
 493                 while (s3c2410_dma_canload(chan) && chan->next != NULL) {
 494                         s3c2410_dma_loadbuffer(chan, chan->next);
 495                 }
 496         } else if (chan->state == S3C2410_DMA_IDLE) {
 497                 if (chan->flags & S3C2410_DMAF_AUTOSTART) {
 498                         s3c2410_dma_ctrl(chan->number, S3C2410_DMAOP_START);
 499                 }
 500         }
 501
 502         local_irq_restore(flags);
 503         return 0;
 504 }
 505
 506 EXPORT_SYMBOL(s3c2410_dma_enqueue);
 507
 508 static inline void
 509 s3c2410_dma_freebuf(s3c2410_dma_buf_t *buf)
 510 {
 511         int magicok = (buf->magic == BUF_MAGIC);
 512
 513         buf->magic = -1;
 514
 515         if (magicok) {
 516                 kmem_cache_free(dma_kmem, buf);
 517         } else {
 518                 printk("s3c2410_dma_freebuf: buff %p with bad magic\n", buf);
 519         }
 520 }
 521
 522 /* s3c2410_dma_lastxfer
 523  *
 524  * called when the system is out of buffers, to ensure that the channel
 525  * is prepared for shutdown.
 526 */
 527
 528 static inline void
 529 s3c2410_dma_lastxfer(s3c2410_dma_chan_t *chan)
 530 {
 531         pr_debug("dma%d: s3c2410_dma_lastxfer: load_state %d\n",
 532                  chan->number, chan->load_state);
 533
 534         switch (chan->load_state) {
 535         case S3C2410_DMALOAD_NONE:
 536                 break;
 537
 538         case S3C2410_DMALOAD_1LOADED:
 539                 if (s3c2410_dma_waitforload(chan, __LINE__) == 0) {
 540                                 /* flag error? */
 541                         printk(KERN_ERR "dma%d: timeout waiting for load\n",
 542                                chan->number);
 543                         return;
 544                 }
 545                 break;
 546
 547         default:
 548                 pr_debug("dma%d: lastxfer: unhandled load_state %d with no next",
 549                          chan->number, chan->load_state);
 550                 return;
 551
 552         }
 553
 554         /* hopefully this'll shut the damned thing up after the transfer... */
 555         dma_wrreg(chan, S3C2410_DMA_DCON, chan->dcon | S3C2410_DCON_NORELOAD);
 556 }
 557
 558
 559 #define dmadbg2(x...)
 560
 561 static irqreturn_t
 562 s3c2410_dma_irq(int irq, void *devpw, struct pt_regs *regs)
 563 {
 564         s3c2410_dma_chan_t *chan = (s3c2410_dma_chan_t *)devpw;
 565         s3c2410_dma_buf_t  *buf;
 566
 567         buf = chan->curr;
 568
 569         dbg_showchan(chan);
 570
 571         /* modify the channel state */
 572
 573         switch (chan->load_state) {
 574         case S3C2410_DMALOAD_1RUNNING:
 575                 /* TODO - if we are running only one buffer, we probably
 576                  * want to reload here, and then worry about the buffer
 577                  * callback */
 578
 579                 chan->load_state = S3C2410_DMALOAD_NONE;
 580                 break;
 581
 582         case S3C2410_DMALOAD_1LOADED:
 583                 /* iirc, we should go back to NONE loaded here, we
 584                  * had a buffer, and it was never verified as being
 585                  * loaded.
 586                  */
 587
 588                 chan->load_state = S3C2410_DMALOAD_NONE;
 589                 break;
 590
 591         case S3C2410_DMALOAD_1LOADED_1RUNNING:
 592                 /* we'll worry about checking to see if another buffer is
 593                  * ready after we've called back the owner. This should
 594                  * ensure we do not wait around too long for the DMA
 595                  * engine to start the next transfer
 596                  */
 597
 598                 chan->load_state = S3C2410_DMALOAD_1LOADED;
 599                 break;
 600
 601         case S3C2410_DMALOAD_NONE:
 602                 printk(KERN_ERR "dma%d: IRQ with no loaded buffer?\n",
 603                        chan->number);
 604                 break;
 605
 606         default:
 607                 printk(KERN_ERR "dma%d: IRQ in invalid load_state %d\n",
 608                        chan->number, chan->load_state);
 609                 break;
 610         }
 611
 612         if (buf != NULL) {
 613                 /* update the chain to make sure that if we load any more
 614                  * buffers when we call the callback function, things should
 615                  * work properly */
 616
 617                 chan->curr = buf->next;
 618                 buf->next  = NULL;
 619
 620                 if (buf->magic != BUF_MAGIC) {
 621                         printk(KERN_ERR "dma%d: %s: buf %p incorrect magic\n",
 622                                chan->number, __FUNCTION__, buf);
 623                         return IRQ_HANDLED;
 624                 }
 625
 626                 s3c2410_dma_buffdone(chan, buf, S3C2410_RES_OK);
 627
 628                 /* free resouces */
 629                 s3c2410_dma_freebuf(buf);
 630         } else {
 631         }
 632
 633         if (chan->next != NULL) {
 634                 unsigned long flags;
 635
 636                 switch (chan->load_state) {
 637                 case S3C2410_DMALOAD_1RUNNING:
 638                         /* don't need to do anything for this state */
 639                         break;
 640
 641                 case S3C2410_DMALOAD_NONE:
 642                         /* can load buffer immediately */
 643                         break;
 644
 645                 case S3C2410_DMALOAD_1LOADED:
 646                         if (s3c2410_dma_waitforload(chan, __LINE__) == 0) {
 647                                 /* flag error? */
 648                                 printk(KERN_ERR "dma%d: timeout waiting for load\n",
 649                                        chan->number);
 650                                 return IRQ_HANDLED;
 651                         }
 652
 653                         break;
 654
 655                 case S3C2410_DMALOAD_1LOADED_1RUNNING:
 656                         goto no_load;
 657
 658                 default:
 659                         printk(KERN_ERR "dma%d: unknown load_state in irq, %d\n",
 660                                chan->number, chan->load_state);
 661                         return IRQ_HANDLED;
 662                 }
 663
 664                 local_irq_save(flags);
 665                 s3c2410_dma_loadbuffer(chan, chan->next);
 666                 local_irq_restore(flags);
 667         } else {
 668                 s3c2410_dma_lastxfer(chan);
 669
 670                 /* see if we can stop this channel.. */
 671                 if (chan->load_state == S3C2410_DMALOAD_NONE) {
 672                         pr_debug("dma%d: end of transfer, stopping channel (%ld)\n",
 673                                  chan->number, jiffies);
 674                         s3c2410_dma_ctrl(chan->number, S3C2410_DMAOP_STOP);
 675                 }
 676         }
 677
 678  no_load:
 679         return IRQ_HANDLED;
 680 }
 681
 682
 683
 684 /* s3c2410_request_dma
 685  *
 686  * get control of an dma channel
 687 */
 688
 689 int s3c2410_dma_request(unsigned int channel, s3c2410_dma_client_t *client,
 690                         void *dev)
 691 {
 692         s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
 693         unsigned long flags;
 694         int err;
 695
 696         pr_debug("dma%d: s3c2410_request_dma: client=%s, dev=%p\n",
 697                  channel, client->name, dev);
 698
 699         check_channel(channel);
 700
 701         local_irq_save(flags);
 702
 703         dbg_showchan(chan);
 704
 705         if (chan->in_use) {
 706                 if (client != chan->client) {
 707                         printk(KERN_ERR "dma%d: already in use\n", channel);
 708                         local_irq_restore(flags);
 709                         return -EBUSY;
 710                 } else {
 711                         printk(KERN_ERR "dma%d: client already has channel\n", channel);
 712                 }
 713         }
 714
 715         chan->client = client;
 716         chan->in_use = 1;
 717
 718         if (!chan->irq_claimed) {
 719                 pr_debug("dma%d: %s : requesting irq %d\n",
 720                          channel, __FUNCTION__, chan->irq);
 721
 722                 err = request_irq(chan->irq, s3c2410_dma_irq, SA_INTERRUPT,
 723                                   client->name, (void *)chan);
 724
 725                 if (err) {
 726                         chan->in_use = 0;
 727                         local_irq_restore(flags);
 728
 729                         printk(KERN_ERR "%s: cannot get IRQ %d for DMA %d\n",
 730                                client->name, chan->irq, chan->number);
 731                         return err;
 732                 }
 733
 734                 chan->irq_claimed = 1;
 735                 chan->irq_enabled = 1;
 736         }
 737
 738         local_irq_restore(flags);
 739
 740         /* need to setup */
 741
 742         pr_debug("%s: channel initialised, %p\n", __FUNCTION__, chan);
 743
 744         return 0;
 745 }
 746
 747 EXPORT_SYMBOL(s3c2410_dma_request);
 748
 749 /* s3c2410_dma_free
 750  *
 751  * release the given channel back to the system, will stop and flush
 752  * any outstanding transfers, and ensure the channel is ready for the
 753  * next claimant.
 754  *
 755  * Note, although a warning is currently printed if the freeing client
 756  * info is not the same as the registrant's client info, the free is still
 757  * allowed to go through.
 758 */
 759
 760 int s3c2410_dma_free(dmach_t channel, s3c2410_dma_client_t *client)
 761 {
 762         s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
 763         unsigned long flags;
 764
 765         check_channel(channel);
 766
 767         local_irq_save(flags);
 768
 769
 770         if (chan->client != client) {
 771                 printk(KERN_WARNING "dma%d: possible free from different client (channel %p, passed %p)\n",
 772                        channel, chan->client, client);
 773         }
 774
 775         /* sort out stopping and freeing the channel */
 776
 777         if (chan->state != S3C2410_DMA_IDLE) {
 778                 pr_debug("%s: need to stop dma channel %p\n",
 779                        __FUNCTION__, chan);
 780
 781                 /* possibly flush the channel */
 782                 s3c2410_dma_ctrl(channel, S3C2410_DMAOP_STOP);
 783         }
 784
 785         chan->client = NULL;
 786         chan->in_use = 0;
 787
 788         if (chan->irq_claimed)
 789                 free_irq(chan->irq, (void *)chan);
 790         chan->irq_claimed = 0;
 791
 792         local_irq_restore(flags);
 793
 794         return 0;
 795 }
 796
 797 EXPORT_SYMBOL(s3c2410_dma_free);
 798
 799 static int s3c2410_dma_dostop(s3c2410_dma_chan_t *chan)
 800 {
 801         unsigned long tmp;
 802         unsigned long flags;
 803
 804         pr_debug("%s:\n", __FUNCTION__);
 805
 806         dbg_showchan(chan);
 807
 808         local_irq_save(flags);
 809
 810         s3c2410_dma_call_op(chan,  S3C2410_DMAOP_STOP);
 811
 812         tmp = dma_rdreg(chan, S3C2410_DMA_DMASKTRIG);
 813         tmp |= S3C2410_DMASKTRIG_STOP;
 814         dma_wrreg(chan, S3C2410_DMA_DMASKTRIG, tmp);
 815
 816 #if 0
 817         /* should also clear interrupts, according to WinCE BSP */
 818         tmp = dma_rdreg(chan, S3C2410_DMA_DCON);
 819         tmp |= S3C2410_DCON_NORELOAD;
 820         dma_wrreg(chan, S3C2410_DMA_DCON, tmp);
 821 #endif
 822
 823         chan->state      = S3C2410_DMA_IDLE;
 824         chan->load_state = S3C2410_DMALOAD_NONE;
 825
 826         local_irq_restore(flags);
 827
 828         return 0;
 829 }
 830
 831 /* s3c2410_dma_flush
 832  *
 833  * stop the channel, and remove all current and pending transfers
 834 */
 835
 836 static int s3c2410_dma_flush(s3c2410_dma_chan_t *chan)
 837 {
 838         s3c2410_dma_buf_t *buf, *next;
 839         unsigned long flags;
 840
 841         pr_debug("%s:\n", __FUNCTION__);
 842
 843         local_irq_save(flags);
 844
 845         if (chan->state != S3C2410_DMA_IDLE) {
 846                 pr_debug("%s: stopping channel...\n", __FUNCTION__ );
 847                 s3c2410_dma_ctrl(chan->number, S3C2410_DMAOP_STOP);
 848         }
 849
 850         buf = chan->curr;
 851         if (buf == NULL)
 852                 buf = chan->next;
 853
 854         chan->curr = chan->next = chan->end = NULL;
 855
 856         if (buf != NULL) {
 857                 for ( ; buf != NULL; buf = next) {
 858                         next = buf->next;
 859
 860                         pr_debug("%s: free buffer %p, next %p\n",
 861                                __FUNCTION__, buf, buf->next);
 862
 863                         s3c2410_dma_buffdone(chan, buf, S3C2410_RES_ABORT);
 864                         s3c2410_dma_freebuf(buf);
 865                 }
 866         }
 867
 868         local_irq_restore(flags);
 869
 870         return 0;
 871 }
 872
 873
 874 int
 875 s3c2410_dma_ctrl(dmach_t channel, s3c2410_chan_op_t op)
 876 {
 877         s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
 878
 879         check_channel(channel);
 880
 881         switch (op) {
 882         case S3C2410_DMAOP_START:
 883                 return s3c2410_dma_start(chan);
 884
 885         case S3C2410_DMAOP_STOP:
 886                 return s3c2410_dma_dostop(chan);
 887
 888         case S3C2410_DMAOP_PAUSE:
 889                 return -ENOENT;
 890
 891         case S3C2410_DMAOP_RESUME:
 892                 return -ENOENT;
 893
 894         case S3C2410_DMAOP_FLUSH:
 895                 return s3c2410_dma_flush(chan);
 896
 897         case S3C2410_DMAOP_TIMEOUT:
 898                 return 0;
 899
 900         }
 901
 902         return -ENOENT;      /* unknown, don't bother */
 903 }
 904
 905 EXPORT_SYMBOL(s3c2410_dma_ctrl);
 906
 907 /* DMA configuration for each channel
 908  *
 909  * DISRCC -> source of the DMA (AHB,APB)
 910  * DISRC  -> source address of the DMA
 911  * DIDSTC -> destination of the DMA (AHB,APD)
 912  * DIDST  -> destination address of the DMA
 913 */
 914
 915 /* s3c2410_dma_config
 916  *
 917  * xfersize:     size of unit in bytes (1,2,4)
 918  * dcon:         base value of the DCONx register
 919 */
 920
 921 int s3c2410_dma_config(dmach_t channel,
 922                        int xferunit,
 923                        int dcon)
 924 {
 925         s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
 926
 927         pr_debug("%s: chan=%d, xfer_unit=%d, dcon=%08x\n",
 928                  __FUNCTION__, channel, xferunit, dcon);
 929
 930         check_channel(channel);
 931
 932         switch (xferunit) {
 933         case 1:
 934                 dcon |= S3C2410_DCON_BYTE;
 935                 break;
 936
 937         case 2:
 938                 dcon |= S3C2410_DCON_HALFWORD;
 939                 break;
 940
 941         case 4:
 942                 dcon |= S3C2410_DCON_WORD;
 943                 break;
 944
 945         default:
 946                 pr_debug("%s: bad transfer size %d\n", __FUNCTION__, xferunit);
 947                 return -EINVAL;
 948         }
 949
 950         dcon |= S3C2410_DCON_HWTRIG;
 951         dcon |= S3C2410_DCON_INTREQ;
 952
 953         pr_debug("%s: dcon now %08x\n", __FUNCTION__, dcon);
 954
 955         chan->dcon = dcon;
 956         chan->xfer_unit = xferunit;
 957
 958         return 0;
 959 }
 960
 961 EXPORT_SYMBOL(s3c2410_dma_config);
 962
 963 int s3c2410_dma_setflags(dmach_t channel, unsigned int flags)
 964 {
 965         s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
 966
 967         check_channel(channel);
 968
 969         pr_debug("%s: chan=%p, flags=%08x\n", __FUNCTION__, chan, flags);
 970
 971         chan->flags = flags;
 972
 973         return 0;
 974 }
 975
 976 EXPORT_SYMBOL(s3c2410_dma_setflags);
 977
 978
 979 /* do we need to protect the settings of the fields from
 980  * irq?
 981 */
 982
 983 int s3c2410_dma_set_opfn(dmach_t channel, s3c2410_dma_opfn_t rtn)
 984 {
 985         s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
 986
 987         check_channel(channel);
 988
 989         pr_debug("%s: chan=%p, op rtn=%p\n", __FUNCTION__, chan, rtn);
 990
 991         chan->op_fn = rtn;
 992
 993         return 0;
 994 }
 995
 996 EXPORT_SYMBOL(s3c2410_dma_set_opfn);
 997
 998 int s3c2410_dma_set_buffdone_fn(dmach_t channel, s3c2410_dma_cbfn_t rtn)
 999 {
1000         s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
1001
1002         check_channel(channel);
1003
1004         pr_debug("%s: chan=%p, callback rtn=%p\n", __FUNCTION__, chan, rtn);
1005
1006         chan->callback_fn = rtn;
1007
1008         return 0;
1009 }
1010
1011 EXPORT_SYMBOL(s3c2410_dma_set_buffdone_fn);
1012
1013 /* s3c2410_dma_devconfig
1014  *
1015  * configure the dma source/destination hardware type and address
1016  *
1017  * source:    S3C2410_DMASRC_HW: source is hardware
1018  *            S3C2410_DMASRC_MEM: source is memory
1019  *
1020  * hwcfg:     the value for xxxSTCn register,
1021  *            bit 0: 0=increment pointer, 1=leave pointer
1022  *            bit 1: 0=soucre is AHB, 1=soucre is APB
1023  *
1024  * devaddr:   physical address of the source
1025 */
1026
1027 int s3c2410_dma_devconfig(int channel,
1028                           s3c2410_dmasrc_t source,
1029                           int hwcfg,
1030                           unsigned long devaddr)
1031 {
1032         s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
1033
1034         check_channel(channel);
1035
1036         pr_debug("%s: source=%d, hwcfg=%08x, devaddr=%08lx\n",
1037                  __FUNCTION__, (int)source, hwcfg, devaddr);
1038
1039         chan->source = source;
1040         chan->dev_addr = devaddr;
1041
1042         switch (source) {
1043         case S3C2410_DMASRC_HW:
1044                 /* source is hardware */
1045                 pr_debug("%s: hw source, devaddr=%08lx, hwcfg=%d\n",
1046                          __FUNCTION__, devaddr, hwcfg);
1047                 dma_wrreg(chan, S3C2410_DMA_DISRCC, hwcfg & 3);
1048                 dma_wrreg(chan, S3C2410_DMA_DISRC,  devaddr);
1049                 dma_wrreg(chan, S3C2410_DMA_DIDSTC, (0<<1) | (0<<0));
1050
1051                 chan->addr_reg = dma_regaddr(chan, S3C2410_DMA_DIDST);
1052                 return 0;
1053
1054         case S3C2410_DMASRC_MEM:
1055                 /* source is memory */
1056                 pr_debug( "%s: mem source, devaddr=%08lx, hwcfg=%d\n",
1057                           __FUNCTION__, devaddr, hwcfg);
1058                 dma_wrreg(chan, S3C2410_DMA_DISRCC, (0<<1) | (0<<0));
1059                 dma_wrreg(chan, S3C2410_DMA_DIDST,  devaddr);
1060                 dma_wrreg(chan, S3C2410_DMA_DIDSTC, hwcfg & 3);
1061
1062                 chan->addr_reg = dma_regaddr(chan, S3C2410_DMA_DISRC);
1063                 return 0;
1064         }
1065
1066         printk(KERN_ERR "dma%d: invalid source type (%d)\n", channel, source);
1067         return -EINVAL;
1068 }
1069
1070 EXPORT_SYMBOL(s3c2410_dma_devconfig);
1071
1072 /* s3c2410_dma_getposition
1073  *
1074  * returns the current transfer points for the dma source and destination
1075 */
1076
1077 int s3c2410_dma_getposition(dmach_t channel, dma_addr_t *src, dma_addr_t *dst)
1078 {
1079         s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
1080
1081         check_channel(channel);
1082
1083         if (src != NULL)
1084                 *src = dma_rdreg(chan, S3C2410_DMA_DCSRC);
1085
1086         if (dst != NULL)
1087                 *dst = dma_rdreg(chan, S3C2410_DMA_DCDST);
1088
1089         return 0;
1090 }
1091
1092 EXPORT_SYMBOL(s3c2410_dma_getposition);
1093
1094
1095 /* system device class */
1096
1097 #ifdef CONFIG_PM
1098
1099 static int s3c2410_dma_suspend(struct sys_device *dev, pm_message_t state)
1100 {
1101         s3c2410_dma_chan_t *cp = container_of(dev, s3c2410_dma_chan_t, dev);
1102
1103         printk(KERN_DEBUG "suspending dma channel %d\n", cp->number);
1104
1105         if (dma_rdreg(cp, S3C2410_DMA_DMASKTRIG) & S3C2410_DMASKTRIG_ON) {
1106                 /* the dma channel is still working, which is probably
1107                  * a bad thing to do over suspend/resume. We stop the
1108                  * channel and assume that the client is either going to
1109                  * retry after resume, or that it is broken.
1110                  */
1111
1112                 printk(KERN_INFO "dma: stopping channel %d due to suspend\n",
1113                        cp->number);
1114
1115                 s3c2410_dma_dostop(cp);
1116         }
1117
1118         return 0;
1119 }
1120
1121 static int s3c2410_dma_resume(struct sys_device *dev)
1122 {
1123         return 0;
1124 }
1125
1126 #else
1127 #define s3c2410_dma_suspend NULL
1128 #define s3c2410_dma_resume  NULL
1129 #endif /* CONFIG_PM */
1130
1131 static struct sysdev_class dma_sysclass = {
1132         set_kset_name("s3c24xx-dma"),
1133         .suspend        = s3c2410_dma_suspend,
1134         .resume         = s3c2410_dma_resume,
1135 };
1136
1137 /* kmem cache implementation */
1138
1139 static void s3c2410_dma_cache_ctor(void *p, kmem_cache_t *c, unsigned long f)
1140 {
1141         memset(p, 0, sizeof(s3c2410_dma_buf_t));
1142 }
1143
1144
1145 /* initialisation code */
1146
1147 static int __init s3c2410_init_dma(void)
1148 {
1149         s3c2410_dma_chan_t *cp;
1150         int channel;
1151         int ret;
1152
1153         printk("S3C2410 DMA Driver, (c) 2003-2004 Simtec Electronics\n");
1154
1155         dma_base = ioremap(S3C24XX_PA_DMA, 0x200);
1156         if (dma_base == NULL) {
1157                 printk(KERN_ERR "dma failed to remap register block\n");
1158                 return -ENOMEM;
1159         }
1160
1161         ret = sysdev_class_register(&dma_sysclass);
1162         if (ret != 0) {
1163                 printk(KERN_ERR "dma sysclass registration failed\n");
1164                 goto err;
1165         }
1166
1167         dma_kmem = kmem_cache_create("dma_desc", sizeof(s3c2410_dma_buf_t), 0,
1168                                      SLAB_HWCACHE_ALIGN,
1169                                      s3c2410_dma_cache_ctor, NULL);
1170
1171         if (dma_kmem == NULL) {
1172                 printk(KERN_ERR "dma failed to make kmem cache\n");
1173                 ret = -ENOMEM;
1174                 goto err;
1175         }
1176
1177         for (channel = 0; channel < S3C2410_DMA_CHANNELS; channel++) {
1178                 cp = &s3c2410_chans[channel];
1179
1180                 memset(cp, 0, sizeof(s3c2410_dma_chan_t));
1181
1182                 /* dma channel irqs are in order.. */
1183                 cp->number = channel;
1184                 cp->irq    = channel + IRQ_DMA0;
1185                 cp->regs   = dma_base + (channel*0x40);
1186
1187                 /* point current stats somewhere */
1188                 cp->stats  = &cp->stats_store;
1189                 cp->stats_store.timeout_shortest = LONG_MAX;
1190
1191                 /* basic channel configuration */
1192
1193                 cp->load_timeout = 1<<18;
1194
1195                 /* register system device */
1196
1197                 cp->dev.cls = &dma_sysclass;
1198                 cp->dev.id  = channel;
1199                 ret = sysdev_register(&cp->dev);
1200
1201                 printk("DMA channel %d at %p, irq %d\n",
1202                        cp->number, cp->regs, cp->irq);
1203         }
1204
1205         return 0;
1206
1207  err:
1208         kmem_cache_destroy(dma_kmem);
1209         iounmap(dma_base);
1210         dma_base = NULL;
1211         return ret;
1212 }
1213
1214 __initcall(s3c2410_init_dma);