arch/arm/mach-davinci/dma.c

   1 /*
   2  * EDMA3 support for DaVinci
   3  *
   4  * Copyright (C) 2006-2009 Texas Instruments.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20 #include <linux/kernel.h>
  21 #include <linux/init.h>
  22 #include <linux/module.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/io.h>
  26
  27 #include <mach/edma.h>
  28
  29 /* Offsets matching "struct edmacc_param" */
  30 #define PARM_OPT                0x00
  31 #define PARM_SRC                0x04
  32 #define PARM_A_B_CNT            0x08
  33 #define PARM_DST                0x0c
  34 #define PARM_SRC_DST_BIDX       0x10
  35 #define PARM_LINK_BCNTRLD       0x14
  36 #define PARM_SRC_DST_CIDX       0x18
  37 #define PARM_CCNT               0x1c
  38
  39 #define PARM_SIZE               0x20
  40
  41 /* Offsets for EDMA CC global channel registers and their shadows */
  42 #define SH_ER           0x00    /* 64 bits */
  43 #define SH_ECR          0x08    /* 64 bits */
  44 #define SH_ESR          0x10    /* 64 bits */
  45 #define SH_CER          0x18    /* 64 bits */
  46 #define SH_EER          0x20    /* 64 bits */
  47 #define SH_EECR         0x28    /* 64 bits */
  48 #define SH_EESR         0x30    /* 64 bits */
  49 #define SH_SER          0x38    /* 64 bits */
  50 #define SH_SECR         0x40    /* 64 bits */
  51 #define SH_IER          0x50    /* 64 bits */
  52 #define SH_IECR         0x58    /* 64 bits */
  53 #define SH_IESR         0x60    /* 64 bits */
  54 #define SH_IPR          0x68    /* 64 bits */
  55 #define SH_ICR          0x70    /* 64 bits */
  56 #define SH_IEVAL        0x78
  57 #define SH_QER          0x80
  58 #define SH_QEER         0x84
  59 #define SH_QEECR        0x88
  60 #define SH_QEESR        0x8c
  61 #define SH_QSER         0x90
  62 #define SH_QSECR        0x94
  63 #define SH_SIZE         0x200
  64
  65 /* Offsets for EDMA CC global registers */
  66 #define EDMA_REV        0x0000
  67 #define EDMA_CCCFG      0x0004
  68 #define EDMA_QCHMAP     0x0200  /* 8 registers */
  69 #define EDMA_DMAQNUM    0x0240  /* 8 registers (4 on OMAP-L1xx) */
  70 #define EDMA_QDMAQNUM   0x0260
  71 #define EDMA_QUETCMAP   0x0280
  72 #define EDMA_QUEPRI     0x0284
  73 #define EDMA_EMR        0x0300  /* 64 bits */
  74 #define EDMA_EMCR       0x0308  /* 64 bits */
  75 #define EDMA_QEMR       0x0310
  76 #define EDMA_QEMCR      0x0314
  77 #define EDMA_CCERR      0x0318
  78 #define EDMA_CCERRCLR   0x031c
  79 #define EDMA_EEVAL      0x0320
  80 #define EDMA_DRAE       0x0340  /* 4 x 64 bits*/
  81 #define EDMA_QRAE       0x0380  /* 4 registers */
  82 #define EDMA_QUEEVTENTRY        0x0400  /* 2 x 16 registers */
  83 #define EDMA_QSTAT      0x0600  /* 2 registers */
  84 #define EDMA_QWMTHRA    0x0620
  85 #define EDMA_QWMTHRB    0x0624
  86 #define EDMA_CCSTAT     0x0640
  87
  88 #define EDMA_M          0x1000  /* global channel registers */
  89 #define EDMA_ECR        0x1008
  90 #define EDMA_ECRH       0x100C
  91 #define EDMA_SHADOW0    0x2000  /* 4 regions shadowing global channels */
  92 #define EDMA_PARM       0x4000  /* 128 param entries */
  93
  94 #define PARM_OFFSET(param_no)   (EDMA_PARM + ((param_no) << 5))
  95
  96 #define EDMA_DCHMAP     0x0100  /* 64 registers */
  97 #define CHMAP_EXIST     BIT(24)
  98
  99 #define EDMA_MAX_DMACH           64
 100 #define EDMA_MAX_PARAMENTRY     512
 101 #define EDMA_MAX_CC               2
 102
 103
 104 /*****************************************************************************/
 105
 106 static void __iomem *edmacc_regs_base[EDMA_MAX_CC];
 107
 108 static inline unsigned int edma_read(unsigned ctlr, int offset)
 109 {
 110         return (unsigned int)__raw_readl(edmacc_regs_base[ctlr] + offset);
 111 }
 112
 113 static inline void edma_write(unsigned ctlr, int offset, int val)
 114 {
 115         __raw_writel(val, edmacc_regs_base[ctlr] + offset);
 116 }
 117 static inline void edma_modify(unsigned ctlr, int offset, unsigned and,
 118                 unsigned or)
 119 {
 120         unsigned val = edma_read(ctlr, offset);
 121         val &= and;
 122         val |= or;
 123         edma_write(ctlr, offset, val);
 124 }
 125 static inline void edma_and(unsigned ctlr, int offset, unsigned and)
 126 {
 127         unsigned val = edma_read(ctlr, offset);
 128         val &= and;
 129         edma_write(ctlr, offset, val);
 130 }
 131 static inline void edma_or(unsigned ctlr, int offset, unsigned or)
 132 {
 133         unsigned val = edma_read(ctlr, offset);
 134         val |= or;
 135         edma_write(ctlr, offset, val);
 136 }
 137 static inline unsigned int edma_read_array(unsigned ctlr, int offset, int i)
 138 {
 139         return edma_read(ctlr, offset + (i << 2));
 140 }
 141 static inline void edma_write_array(unsigned ctlr, int offset, int i,
 142                 unsigned val)
 143 {
 144         edma_write(ctlr, offset + (i << 2), val);
 145 }
 146 static inline void edma_modify_array(unsigned ctlr, int offset, int i,
 147                 unsigned and, unsigned or)
 148 {
 149         edma_modify(ctlr, offset + (i << 2), and, or);
 150 }
 151 static inline void edma_or_array(unsigned ctlr, int offset, int i, unsigned or)
 152 {
 153         edma_or(ctlr, offset + (i << 2), or);
 154 }
 155 static inline void edma_or_array2(unsigned ctlr, int offset, int i, int j,
 156                 unsigned or)
 157 {
 158         edma_or(ctlr, offset + ((i*2 + j) << 2), or);
 159 }
 160 static inline void edma_write_array2(unsigned ctlr, int offset, int i, int j,
 161                 unsigned val)
 162 {
 163         edma_write(ctlr, offset + ((i*2 + j) << 2), val);
 164 }
 165 static inline unsigned int edma_shadow0_read(unsigned ctlr, int offset)
 166 {
 167         return edma_read(ctlr, EDMA_SHADOW0 + offset);
 168 }
 169 static inline unsigned int edma_shadow0_read_array(unsigned ctlr, int offset,
 170                 int i)
 171 {
 172         return edma_read(ctlr, EDMA_SHADOW0 + offset + (i << 2));
 173 }
 174 static inline void edma_shadow0_write(unsigned ctlr, int offset, unsigned val)
 175 {
 176         edma_write(ctlr, EDMA_SHADOW0 + offset, val);
 177 }
 178 static inline void edma_shadow0_write_array(unsigned ctlr, int offset, int i,
 179                 unsigned val)
 180 {
 181         edma_write(ctlr, EDMA_SHADOW0 + offset + (i << 2), val);
 182 }
 183 static inline unsigned int edma_parm_read(unsigned ctlr, int offset,
 184                 int param_no)
 185 {
 186         return edma_read(ctlr, EDMA_PARM + offset + (param_no << 5));
 187 }
 188 static inline void edma_parm_write(unsigned ctlr, int offset, int param_no,
 189                 unsigned val)
 190 {
 191         edma_write(ctlr, EDMA_PARM + offset + (param_no << 5), val);
 192 }
 193 static inline void edma_parm_modify(unsigned ctlr, int offset, int param_no,
 194                 unsigned and, unsigned or)
 195 {
 196         edma_modify(ctlr, EDMA_PARM + offset + (param_no << 5), and, or);
 197 }
 198 static inline void edma_parm_and(unsigned ctlr, int offset, int param_no,
 199                 unsigned and)
 200 {
 201         edma_and(ctlr, EDMA_PARM + offset + (param_no << 5), and);
 202 }
 203 static inline void edma_parm_or(unsigned ctlr, int offset, int param_no,
 204                 unsigned or)
 205 {
 206         edma_or(ctlr, EDMA_PARM + offset + (param_no << 5), or);
 207 }
 208
 209 /*****************************************************************************/
 210
 211 /* actual number of DMA channels and slots on this silicon */
 212 struct edma {
 213         /* how many dma resources of each type */
 214         unsigned        num_channels;
 215         unsigned        num_region;
 216         unsigned        num_slots;
 217         unsigned        num_tc;
 218         unsigned        num_cc;
 219         enum dma_event_q        default_queue;
 220
 221         /* list of channels with no even trigger; terminated by "-1" */
 222         const s8        *noevent;
 223
 224         /* The edma_inuse bit for each PaRAM slot is clear unless the
 225          * channel is in use ... by ARM or DSP, for QDMA, or whatever.
 226          */
 227         DECLARE_BITMAP(edma_inuse, EDMA_MAX_PARAMENTRY);
 228
 229         /* The edma_unused bit for each channel is clear unless
 230          * it is not being used on this platform. It uses a bit
 231          * of SOC-specific initialization code.
 232          */
 233         DECLARE_BITMAP(edma_unused, EDMA_MAX_DMACH);
 234
 235         unsigned        irq_res_start;
 236         unsigned        irq_res_end;
 237
 238         struct dma_interrupt_data {
 239                 void (*callback)(unsigned channel, unsigned short ch_status,
 240                                 void *data);
 241                 void *data;
 242         } intr_data[EDMA_MAX_DMACH];
 243 };
 244
 245 static struct edma *edma_info[EDMA_MAX_CC];
 246 static int arch_num_cc;
 247
 248 /* dummy param set used to (re)initialize parameter RAM slots */
 249 static const struct edmacc_param dummy_paramset = {
 250         .link_bcntrld = 0xffff,
 251         .ccnt = 1,
 252 };
 253
 254 /*****************************************************************************/
 255
 256 static void map_dmach_queue(unsigned ctlr, unsigned ch_no,
 257                 enum dma_event_q queue_no)
 258 {
 259         int bit = (ch_no & 0x7) * 4;
 260
 261         /* default to low priority queue */
 262         if (queue_no == EVENTQ_DEFAULT)
 263                 queue_no = edma_info[ctlr]->default_queue;
 264
 265         queue_no &= 7;
 266         edma_modify_array(ctlr, EDMA_DMAQNUM, (ch_no >> 3),
 267                         ~(0x7 << bit), queue_no << bit);
 268 }
 269
 270 static void __init map_queue_tc(unsigned ctlr, int queue_no, int tc_no)
 271 {
 272         int bit = queue_no * 4;
 273         edma_modify(ctlr, EDMA_QUETCMAP, ~(0x7 << bit), ((tc_no & 0x7) << bit));
 274 }
 275
 276 static void __init assign_priority_to_queue(unsigned ctlr, int queue_no,
 277                 int priority)
 278 {
 279         int bit = queue_no * 4;
 280         edma_modify(ctlr, EDMA_QUEPRI, ~(0x7 << bit),
 281                         ((priority & 0x7) << bit));
 282 }
 283
 284 /**
 285  * map_dmach_param - Maps channel number to param entry number
 286  *
 287  * This maps the dma channel number to param entry numberter. In
 288  * other words using the DMA channel mapping registers a param entry
 289  * can be mapped to any channel
 290  *
 291  * Callers are responsible for ensuring the channel mapping logic is
 292  * included in that particular EDMA variant (Eg : dm646x)
 293  *
 294  */
 295 static void __init map_dmach_param(unsigned ctlr)
 296 {
 297         int i;
 298         for (i = 0; i < EDMA_MAX_DMACH; i++)
 299                 edma_write_array(ctlr, EDMA_DCHMAP , i , (i << 5));
 300 }
 301
 302 static inline void
 303 setup_dma_interrupt(unsigned lch,
 304         void (*callback)(unsigned channel, u16 ch_status, void *data),
 305         void *data)
 306 {
 307         unsigned ctlr;
 308
 309         ctlr = EDMA_CTLR(lch);
 310         lch = EDMA_CHAN_SLOT(lch);
 311
 312         if (!callback) {
 313                 edma_shadow0_write_array(ctlr, SH_IECR, lch >> 5,
 314                                 (1 << (lch & 0x1f)));
 315         }
 316
 317         edma_info[ctlr]->intr_data[lch].callback = callback;
 318         edma_info[ctlr]->intr_data[lch].data = data;
 319
 320         if (callback) {
 321                 edma_shadow0_write_array(ctlr, SH_ICR, lch >> 5,
 322                                 (1 << (lch & 0x1f)));
 323                 edma_shadow0_write_array(ctlr, SH_IESR, lch >> 5,
 324                                 (1 << (lch & 0x1f)));
 325         }
 326 }
 327
 328 static int irq2ctlr(int irq)
 329 {
 330         if (irq >= edma_info[0]->irq_res_start &&
 331                 irq <= edma_info[0]->irq_res_end)
 332                 return 0;
 333         else if (irq >= edma_info[1]->irq_res_start &&
 334                 irq <= edma_info[1]->irq_res_end)
 335                 return 1;
 336
 337         return -1;
 338 }
 339
 340 /******************************************************************************
 341  *
 342  * DMA interrupt handler
 343  *
 344  *****************************************************************************/
 345 static irqreturn_t dma_irq_handler(int irq, void *data)
 346 {
 347         int i;
 348         unsigned ctlr;
 349         unsigned int cnt = 0;
 350
 351         ctlr = irq2ctlr(irq);
 352
 353         dev_dbg(data, "dma_irq_handler\n");
 354
 355         if ((edma_shadow0_read_array(ctlr, SH_IPR, 0) == 0)
 356             && (edma_shadow0_read_array(ctlr, SH_IPR, 1) == 0))
 357                 return IRQ_NONE;
 358
 359         while (1) {
 360                 int j;
 361                 if (edma_shadow0_read_array(ctlr, SH_IPR, 0))
 362                         j = 0;
 363                 else if (edma_shadow0_read_array(ctlr, SH_IPR, 1))
 364                         j = 1;
 365                 else
 366                         break;
 367                 dev_dbg(data, "IPR%d %08x\n", j,
 368                                 edma_shadow0_read_array(ctlr, SH_IPR, j));
 369                 for (i = 0; i < 32; i++) {
 370                         int k = (j << 5) + i;
 371                         if (edma_shadow0_read_array(ctlr, SH_IPR, j) &
 372                                                         (1 << i)) {
 373                                 /* Clear the corresponding IPR bits */
 374                                 edma_shadow0_write_array(ctlr, SH_ICR, j,
 375                                                         (1 << i));
 376                                 if (edma_info[ctlr]->intr_data[k].callback) {
 377                                         edma_info[ctlr]->intr_data[k].callback(
 378                                                 k, DMA_COMPLETE,
 379                                                 edma_info[ctlr]->intr_data[k].
 380                                                 data);
 381                                 }
 382                         }
 383                 }
 384                 cnt++;
 385                 if (cnt > 10)
 386                         break;
 387         }
 388         edma_shadow0_write(ctlr, SH_IEVAL, 1);
 389         return IRQ_HANDLED;
 390 }
 391
 392 /******************************************************************************
 393  *
 394  * DMA error interrupt handler
 395  *
 396  *****************************************************************************/
 397 static irqreturn_t dma_ccerr_handler(int irq, void *data)
 398 {
 399         int i;
 400         unsigned ctlr;
 401         unsigned int cnt = 0;
 402
 403         ctlr = irq2ctlr(irq);
 404
 405         dev_dbg(data, "dma_ccerr_handler\n");
 406
 407         if ((edma_read_array(ctlr, EDMA_EMR, 0) == 0) &&
 408             (edma_read_array(ctlr, EDMA_EMR, 1) == 0) &&
 409             (edma_read(ctlr, EDMA_QEMR) == 0) &&
 410             (edma_read(ctlr, EDMA_CCERR) == 0))
 411                 return IRQ_NONE;
 412
 413         while (1) {
 414                 int j = -1;
 415                 if (edma_read_array(ctlr, EDMA_EMR, 0))
 416                         j = 0;
 417                 else if (edma_read_array(ctlr, EDMA_EMR, 1))
 418                         j = 1;
 419                 if (j >= 0) {
 420                         dev_dbg(data, "EMR%d %08x\n", j,
 421                                         edma_read_array(ctlr, EDMA_EMR, j));
 422                         for (i = 0; i < 32; i++) {
 423                                 int k = (j << 5) + i;
 424                                 if (edma_read_array(ctlr, EDMA_EMR, j) &
 425                                                         (1 << i)) {
 426                                         /* Clear the corresponding EMR bits */
 427                                         edma_write_array(ctlr, EDMA_EMCR, j,
 428                                                         1 << i);
 429                                         /* Clear any SER */
 430                                         edma_shadow0_write_array(ctlr, SH_SECR,
 431                                                                 j, (1 << i));
 432                                         if (edma_info[ctlr]->intr_data[k].
 433                                                                 callback) {
 434                                                 edma_info[ctlr]->intr_data[k].
 435                                                 callback(k,
 436                                                 DMA_CC_ERROR,
 437                                                 edma_info[ctlr]->intr_data
 438                                                 [k].data);
 439                                         }
 440                                 }
 441                         }
 442                 } else if (edma_read(ctlr, EDMA_QEMR)) {
 443                         dev_dbg(data, "QEMR %02x\n",
 444                                 edma_read(ctlr, EDMA_QEMR));
 445                         for (i = 0; i < 8; i++) {
 446                                 if (edma_read(ctlr, EDMA_QEMR) & (1 << i)) {
 447                                         /* Clear the corresponding IPR bits */
 448                                         edma_write(ctlr, EDMA_QEMCR, 1 << i);
 449                                         edma_shadow0_write(ctlr, SH_QSECR,
 450                                                                 (1 << i));
 451
 452                                         /* NOTE:  not reported!! */
 453                                 }
 454                         }
 455                 } else if (edma_read(ctlr, EDMA_CCERR)) {
 456                         dev_dbg(data, "CCERR %08x\n",
 457                                 edma_read(ctlr, EDMA_CCERR));
 458                         /* FIXME:  CCERR.BIT(16) ignored!  much better
 459                          * to just write CCERRCLR with CCERR value...
 460                          */
 461                         for (i = 0; i < 8; i++) {
 462                                 if (edma_read(ctlr, EDMA_CCERR) & (1 << i)) {
 463                                         /* Clear the corresponding IPR bits */
 464                                         edma_write(ctlr, EDMA_CCERRCLR, 1 << i);
 465
 466                                         /* NOTE:  not reported!! */
 467                                 }
 468                         }
 469                 }
 470                 if ((edma_read_array(ctlr, EDMA_EMR, 0) == 0)
 471                     && (edma_read_array(ctlr, EDMA_EMR, 1) == 0)
 472                     && (edma_read(ctlr, EDMA_QEMR) == 0)
 473                     && (edma_read(ctlr, EDMA_CCERR) == 0)) {
 474                         break;
 475                 }
 476                 cnt++;
 477                 if (cnt > 10)
 478                         break;
 479         }
 480         edma_write(ctlr, EDMA_EEVAL, 1);
 481         return IRQ_HANDLED;
 482 }
 483
 484 /******************************************************************************
 485  *
 486  * Transfer controller error interrupt handlers
 487  *
 488  *****************************************************************************/
 489
 490 #define tc_errs_handled false   /* disabled as long as they're NOPs */
 491
 492 static irqreturn_t dma_tc0err_handler(int irq, void *data)
 493 {
 494         dev_dbg(data, "dma_tc0err_handler\n");
 495         return IRQ_HANDLED;
 496 }
 497
 498 static irqreturn_t dma_tc1err_handler(int irq, void *data)
 499 {
 500         dev_dbg(data, "dma_tc1err_handler\n");
 501         return IRQ_HANDLED;
 502 }
 503
 504 static int reserve_contiguous_slots(int ctlr, unsigned int id,
 505                                      unsigned int num_slots,
 506                                      unsigned int start_slot)
 507 {
 508         int i, j;
 509         unsigned int count = num_slots;
 510         int stop_slot = start_slot;
 511         DECLARE_BITMAP(tmp_inuse, EDMA_MAX_PARAMENTRY);
 512
 513         for (i = start_slot; i < edma_info[ctlr]->num_slots; ++i) {
 514                 j = EDMA_CHAN_SLOT(i);
 515                 if (!test_and_set_bit(j, edma_info[ctlr]->edma_inuse)) {
 516                         /* Record our current beginning slot */
 517                         if (count == num_slots)
 518                                 stop_slot = i;
 519
 520                         count--;
 521                         set_bit(j, tmp_inuse);
 522
 523                         if (count == 0)
 524                                 break;
 525                 } else {
 526                         clear_bit(j, tmp_inuse);
 527
 528                         if (id == EDMA_CONT_PARAMS_FIXED_EXACT) {
 529                                 stop_slot = i;
 530                                 break;
 531                         } else
 532                                 count = num_slots;
 533                 }
 534         }
 535
 536         /*
 537          * We have to clear any bits that we set
 538          * if we run out parameter RAM slots, i.e we do find a set
 539          * of contiguous parameter RAM slots but do not find the exact number
 540          * requested as we may reach the total number of parameter RAM slots
 541          */
 542         if (i == edma_info[ctlr]->num_slots)
 543                 stop_slot = i;
 544
 545         for (j = start_slot; j < stop_slot; j++)
 546                 if (test_bit(j, tmp_inuse))
 547                         clear_bit(j, edma_info[ctlr]->edma_inuse);
 548
 549         if (count)
 550                 return -EBUSY;
 551
 552         for (j = i - num_slots + 1; j <= i; ++j)
 553                 memcpy_toio(edmacc_regs_base[ctlr] + PARM_OFFSET(j),
 554                         &dummy_paramset, PARM_SIZE);
 555
 556         return EDMA_CTLR_CHAN(ctlr, i - num_slots + 1);
 557 }
 558
 559 static int prepare_unused_channel_list(struct device *dev, void *data)
 560 {
 561         struct platform_device *pdev = to_platform_device(dev);
 562         int i, ctlr;
 563
 564         for (i = 0; i < pdev->num_resources; i++) {
 565                 if ((pdev->resource[i].flags & IORESOURCE_DMA) &&
 566                                 (int)pdev->resource[i].start >= 0) {
 567                         ctlr = EDMA_CTLR(pdev->resource[i].start);
 568                         clear_bit(EDMA_CHAN_SLOT(pdev->resource[i].start),
 569                                         edma_info[ctlr]->edma_unused);
 570                 }
 571         }
 572
 573         return 0;
 574 }
 575
 576 /*-----------------------------------------------------------------------*/
 577
 578 static bool unused_chan_list_done;
 579
 580 /* Resource alloc/free:  dma channels, parameter RAM slots */
 581
 582 /**
 583  * edma_alloc_channel - allocate DMA channel and paired parameter RAM
 584  * @channel: specific channel to allocate; negative for "any unmapped channel"
 585  * @callback: optional; to be issued on DMA completion or errors
 586  * @data: passed to callback
 587  * @eventq_no: an EVENTQ_* constant, used to choose which Transfer
 588  *      Controller (TC) executes requests using this channel.  Use
 589  *      EVENTQ_DEFAULT unless you really need a high priority queue.
 590  *
 591  * This allocates a DMA channel and its associated parameter RAM slot.
 592  * The parameter RAM is initialized to hold a dummy transfer.
 593  *
 594  * Normal use is to pass a specific channel number as @channel, to make
 595  * use of hardware events mapped to that channel.  When the channel will
 596  * be used only for software triggering or event chaining, channels not
 597  * mapped to hardware events (or mapped to unused events) are preferable.
 598  *
 599  * DMA transfers start from a channel using edma_start(), or by
 600  * chaining.  When the transfer described in that channel's parameter RAM
 601  * slot completes, that slot's data may be reloaded through a link.
 602  *
 603  * DMA errors are only reported to the @callback associated with the
 604  * channel driving that transfer, but transfer completion callbacks can
 605  * be sent to another channel under control of the TCC field in
 606  * the option word of the transfer's parameter RAM set.  Drivers must not
 607  * use DMA transfer completion callbacks for channels they did not allocate.
 608  * (The same applies to TCC codes used in transfer chaining.)
 609  *
 610  * Returns the number of the channel, else negative errno.
 611  */
 612 int edma_alloc_channel(int channel,
 613                 void (*callback)(unsigned channel, u16 ch_status, void *data),
 614                 void *data,
 615                 enum dma_event_q eventq_no)
 616 {
 617         unsigned i, done = 0, ctlr = 0;
 618         int ret = 0;
 619
 620         if (!unused_chan_list_done) {
 621                 /*
 622                  * Scan all the platform devices to find out the EDMA channels
 623                  * used and clear them in the unused list, making the rest
 624                  * available for ARM usage.
 625                  */
 626                 ret = bus_for_each_dev(&platform_bus_type, NULL, NULL,
 627                                 prepare_unused_channel_list);
 628                 if (ret < 0)
 629                         return ret;
 630
 631                 unused_chan_list_done = true;
 632         }
 633
 634         if (channel >= 0) {
 635                 ctlr = EDMA_CTLR(channel);
 636                 channel = EDMA_CHAN_SLOT(channel);
 637         }
 638
 639         if (channel < 0) {
 640                 for (i = 0; i < arch_num_cc; i++) {
 641                         channel = 0;
 642                         for (;;) {
 643                                 channel = find_next_bit(edma_info[i]->
 644                                                 edma_unused,
 645                                                 edma_info[i]->num_channels,
 646                                                 channel);
 647                                 if (channel == edma_info[i]->num_channels)
 648                                         break;
 649                                 if (!test_and_set_bit(channel,
 650                                                 edma_info[i]->edma_inuse)) {
 651                                         done = 1;
 652                                         ctlr = i;
 653                                         break;
 654                                 }
 655                                 channel++;
 656                         }
 657                         if (done)
 658                                 break;
 659                 }
 660                 if (!done)
 661                         return -ENOMEM;
 662         } else if (channel >= edma_info[ctlr]->num_channels) {
 663                 return -EINVAL;
 664         } else if (test_and_set_bit(channel, edma_info[ctlr]->edma_inuse)) {
 665                 return -EBUSY;
 666         }
 667
 668         /* ensure access through shadow region 0 */
 669         edma_or_array2(ctlr, EDMA_DRAE, 0, channel >> 5, 1 << (channel & 0x1f));
 670
 671         /* ensure no events are pending */
 672         edma_stop(EDMA_CTLR_CHAN(ctlr, channel));
 673         memcpy_toio(edmacc_regs_base[ctlr] + PARM_OFFSET(channel),
 674                         &dummy_paramset, PARM_SIZE);
 675
 676         if (callback)
 677                 setup_dma_interrupt(EDMA_CTLR_CHAN(ctlr, channel),
 678                                         callback, data);
 679
 680         map_dmach_queue(ctlr, channel, eventq_no);
 681
 682         return EDMA_CTLR_CHAN(ctlr, channel);
 683 }
 684 EXPORT_SYMBOL(edma_alloc_channel);
 685
 686
 687 /**
 688  * edma_free_channel - deallocate DMA channel
 689  * @channel: dma channel returned from edma_alloc_channel()
 690  *
 691  * This deallocates the DMA channel and associated parameter RAM slot
 692  * allocated by edma_alloc_channel().
 693  *
 694  * Callers are responsible for ensuring the channel is inactive, and
 695  * will not be reactivated by linking, chaining, or software calls to
 696  * edma_start().
 697  */
 698 void edma_free_channel(unsigned channel)
 699 {
 700         unsigned ctlr;
 701
 702         ctlr = EDMA_CTLR(channel);
 703         channel = EDMA_CHAN_SLOT(channel);
 704
 705         if (channel >= edma_info[ctlr]->num_channels)
 706                 return;
 707
 708         setup_dma_interrupt(channel, NULL, NULL);
 709         /* REVISIT should probably take out of shadow region 0 */
 710
 711         memcpy_toio(edmacc_regs_base[ctlr] + PARM_OFFSET(channel),
 712                         &dummy_paramset, PARM_SIZE);
 713         clear_bit(channel, edma_info[ctlr]->edma_inuse);
 714 }
 715 EXPORT_SYMBOL(edma_free_channel);
 716
 717 /**
 718  * edma_alloc_slot - allocate DMA parameter RAM
 719  * @slot: specific slot to allocate; negative for "any unused slot"
 720  *
 721  * This allocates a parameter RAM slot, initializing it to hold a
 722  * dummy transfer.  Slots allocated using this routine have not been
 723  * mapped to a hardware DMA channel, and will normally be used by
 724  * linking to them from a slot associated with a DMA channel.
 725  *
 726  * Normal use is to pass EDMA_SLOT_ANY as the @slot, but specific
 727  * slots may be allocated on behalf of DSP firmware.
 728  *
 729  * Returns the number of the slot, else negative errno.
 730  */
 731 int edma_alloc_slot(unsigned ctlr, int slot)
 732 {
 733         if (slot >= 0)
 734                 slot = EDMA_CHAN_SLOT(slot);
 735
 736         if (slot < 0) {
 737                 slot = edma_info[ctlr]->num_channels;
 738                 for (;;) {
 739                         slot = find_next_zero_bit(edma_info[ctlr]->edma_inuse,
 740                                         edma_info[ctlr]->num_slots, slot);
 741                         if (slot == edma_info[ctlr]->num_slots)
 742                                 return -ENOMEM;
 743                         if (!test_and_set_bit(slot,
 744                                                 edma_info[ctlr]->edma_inuse))
 745                                 break;
 746                 }
 747         } else if (slot < edma_info[ctlr]->num_channels ||
 748                         slot >= edma_info[ctlr]->num_slots) {
 749                 return -EINVAL;
 750         } else if (test_and_set_bit(slot, edma_info[ctlr]->edma_inuse)) {
 751                 return -EBUSY;
 752         }
 753
 754         memcpy_toio(edmacc_regs_base[ctlr] + PARM_OFFSET(slot),
 755                         &dummy_paramset, PARM_SIZE);
 756
 757         return EDMA_CTLR_CHAN(ctlr, slot);
 758 }
 759 EXPORT_SYMBOL(edma_alloc_slot);
 760
 761 /**
 762  * edma_free_slot - deallocate DMA parameter RAM
 763  * @slot: parameter RAM slot returned from edma_alloc_slot()
 764  *
 765  * This deallocates the parameter RAM slot allocated by edma_alloc_slot().
 766  * Callers are responsible for ensuring the slot is inactive, and will
 767  * not be activated.
 768  */
 769 void edma_free_slot(unsigned slot)
 770 {
 771         unsigned ctlr;
 772
 773         ctlr = EDMA_CTLR(slot);
 774         slot = EDMA_CHAN_SLOT(slot);
 775
 776         if (slot < edma_info[ctlr]->num_channels ||
 777                 slot >= edma_info[ctlr]->num_slots)
 778                 return;
 779
 780         memcpy_toio(edmacc_regs_base[ctlr] + PARM_OFFSET(slot),
 781                         &dummy_paramset, PARM_SIZE);
 782         clear_bit(slot, edma_info[ctlr]->edma_inuse);
 783 }
 784 EXPORT_SYMBOL(edma_free_slot);
 785
 786
 787 /**
 788  * edma_alloc_cont_slots- alloc contiguous parameter RAM slots
 789  * The API will return the starting point of a set of
 790  * contiguous parameter RAM slots that have been requested
 791  *
 792  * @id: can only be EDMA_CONT_PARAMS_ANY or EDMA_CONT_PARAMS_FIXED_EXACT
 793  * or EDMA_CONT_PARAMS_FIXED_NOT_EXACT
 794  * @count: number of contiguous Paramter RAM slots
 795  * @slot  - the start value of Parameter RAM slot that should be passed if id
 796  * is EDMA_CONT_PARAMS_FIXED_EXACT or EDMA_CONT_PARAMS_FIXED_NOT_EXACT
 797  *
 798  * If id is EDMA_CONT_PARAMS_ANY then the API starts looking for a set of
 799  * contiguous Parameter RAM slots from parameter RAM 64 in the case of
 800  * DaVinci SOCs and 32 in the case of DA8xx SOCs.
 801  *
 802  * If id is EDMA_CONT_PARAMS_FIXED_EXACT then the API starts looking for a
 803  * set of contiguous parameter RAM slots from the "slot" that is passed as an
 804  * argument to the API.
 805  *
 806  * If id is EDMA_CONT_PARAMS_FIXED_NOT_EXACT then the API initially tries
 807  * starts looking for a set of contiguous parameter RAMs from the "slot"
 808  * that is passed as an argument to the API. On failure the API will try to
 809  * find a set of contiguous Parameter RAM slots from the remaining Parameter
 810  * RAM slots
 811  */
 812 int edma_alloc_cont_slots(unsigned ctlr, unsigned int id, int slot, int count)
 813 {
 814         /*
 815          * The start slot requested should be greater than
 816          * the number of channels and lesser than the total number
 817          * of slots
 818          */
 819         if ((id != EDMA_CONT_PARAMS_ANY) &&
 820                 (slot < edma_info[ctlr]->num_channels ||
 821                 slot >= edma_info[ctlr]->num_slots))
 822                 return -EINVAL;
 823
 824         /*
 825          * The number of parameter RAM slots requested cannot be less than 1
 826          * and cannot be more than the number of slots minus the number of
 827          * channels
 828          */
 829         if (count < 1 || count >
 830                 (edma_info[ctlr]->num_slots - edma_info[ctlr]->num_channels))
 831                 return -EINVAL;
 832
 833         switch (id) {
 834         case EDMA_CONT_PARAMS_ANY:
 835                 return reserve_contiguous_slots(ctlr, id, count,
 836                                                  edma_info[ctlr]->num_channels);
 837         case EDMA_CONT_PARAMS_FIXED_EXACT:
 838         case EDMA_CONT_PARAMS_FIXED_NOT_EXACT:
 839                 return reserve_contiguous_slots(ctlr, id, count, slot);
 840         default:
 841                 return -EINVAL;
 842         }
 843
 844 }
 845 EXPORT_SYMBOL(edma_alloc_cont_slots);
 846
 847 /**
 848  * edma_free_cont_slots - deallocate DMA parameter RAM slots
 849  * @slot: first parameter RAM of a set of parameter RAM slots to be freed
 850  * @count: the number of contiguous parameter RAM slots to be freed
 851  *
 852  * This deallocates the parameter RAM slots allocated by
 853  * edma_alloc_cont_slots.
 854  * Callers/applications need to keep track of sets of contiguous
 855  * parameter RAM slots that have been allocated using the edma_alloc_cont_slots
 856  * API.
 857  * Callers are responsible for ensuring the slots are inactive, and will
 858  * not be activated.
 859  */
 860 int edma_free_cont_slots(unsigned slot, int count)
 861 {
 862         unsigned ctlr, slot_to_free;
 863         int i;
 864
 865         ctlr = EDMA_CTLR(slot);
 866         slot = EDMA_CHAN_SLOT(slot);
 867
 868         if (slot < edma_info[ctlr]->num_channels ||
 869                 slot >= edma_info[ctlr]->num_slots ||
 870                 count < 1)
 871                 return -EINVAL;
 872
 873         for (i = slot; i < slot + count; ++i) {
 874                 ctlr = EDMA_CTLR(i);
 875                 slot_to_free = EDMA_CHAN_SLOT(i);
 876
 877                 memcpy_toio(edmacc_regs_base[ctlr] + PARM_OFFSET(slot_to_free),
 878                         &dummy_paramset, PARM_SIZE);
 879                 clear_bit(slot_to_free, edma_info[ctlr]->edma_inuse);
 880         }
 881
 882         return 0;
 883 }
 884 EXPORT_SYMBOL(edma_free_cont_slots);
 885
 886 /*-----------------------------------------------------------------------*/
 887
 888 /* Parameter RAM operations (i) -- read/write partial slots */
 889
 890 /**
 891  * edma_set_src - set initial DMA source address in parameter RAM slot
 892  * @slot: parameter RAM slot being configured
 893  * @src_port: physical address of source (memory, controller FIFO, etc)
 894  * @addressMode: INCR, except in very rare cases
 895  * @fifoWidth: ignored unless @addressMode is FIFO, else specifies the
 896  *      width to use when addressing the fifo (e.g. W8BIT, W32BIT)
 897  *
 898  * Note that the source address is modified during the DMA transfer
 899  * according to edma_set_src_index().
 900  */
 901 void edma_set_src(unsigned slot, dma_addr_t src_port,
 902                                 enum address_mode mode, enum fifo_width width)
 903 {
 904         unsigned ctlr;
 905
 906         ctlr = EDMA_CTLR(slot);
 907         slot = EDMA_CHAN_SLOT(slot);
 908
 909         if (slot < edma_info[ctlr]->num_slots) {
 910                 unsigned int i = edma_parm_read(ctlr, PARM_OPT, slot);
 911
 912                 if (mode) {
 913                         /* set SAM and program FWID */
 914                         i = (i & ~(EDMA_FWID)) | (SAM | ((width & 0x7) << 8));
 915                 } else {
 916                         /* clear SAM */
 917                         i &= ~SAM;
 918                 }
 919                 edma_parm_write(ctlr, PARM_OPT, slot, i);
 920
 921                 /* set the source port address
 922                    in source register of param structure */
 923                 edma_parm_write(ctlr, PARM_SRC, slot, src_port);
 924         }
 925 }
 926 EXPORT_SYMBOL(edma_set_src);
 927
 928 /**
 929  * edma_set_dest - set initial DMA destination address in parameter RAM slot
 930  * @slot: parameter RAM slot being configured
 931  * @dest_port: physical address of destination (memory, controller FIFO, etc)
 932  * @addressMode: INCR, except in very rare cases
 933  * @fifoWidth: ignored unless @addressMode is FIFO, else specifies the
 934  *      width to use when addressing the fifo (e.g. W8BIT, W32BIT)
 935  *
 936  * Note that the destination address is modified during the DMA transfer
 937  * according to edma_set_dest_index().
 938  */
 939 void edma_set_dest(unsigned slot, dma_addr_t dest_port,
 940                                  enum address_mode mode, enum fifo_width width)
 941 {
 942         unsigned ctlr;
 943
 944         ctlr = EDMA_CTLR(slot);
 945         slot = EDMA_CHAN_SLOT(slot);
 946
 947         if (slot < edma_info[ctlr]->num_slots) {
 948                 unsigned int i = edma_parm_read(ctlr, PARM_OPT, slot);
 949
 950                 if (mode) {
 951                         /* set DAM and program FWID */
 952                         i = (i & ~(EDMA_FWID)) | (DAM | ((width & 0x7) << 8));
 953                 } else {
 954                         /* clear DAM */
 955                         i &= ~DAM;
 956                 }
 957                 edma_parm_write(ctlr, PARM_OPT, slot, i);
 958                 /* set the destination port address
 959                    in dest register of param structure */
 960                 edma_parm_write(ctlr, PARM_DST, slot, dest_port);
 961         }
 962 }
 963 EXPORT_SYMBOL(edma_set_dest);
 964
 965 /**
 966  * edma_get_position - returns the current transfer points
 967  * @slot: parameter RAM slot being examined
 968  * @src: pointer to source port position
 969  * @dst: pointer to destination port position
 970  *
 971  * Returns current source and destination addresses for a particular
 972  * parameter RAM slot.  Its channel should not be active when this is called.
 973  */
 974 void edma_get_position(unsigned slot, dma_addr_t *src, dma_addr_t *dst)
 975 {
 976         struct edmacc_param temp;
 977         unsigned ctlr;
 978
 979         ctlr = EDMA_CTLR(slot);
 980         slot = EDMA_CHAN_SLOT(slot);
 981
 982         edma_read_slot(EDMA_CTLR_CHAN(ctlr, slot), &temp);
 983         if (src != NULL)
 984                 *src = temp.src;
 985         if (dst != NULL)
 986                 *dst = temp.dst;
 987 }
 988 EXPORT_SYMBOL(edma_get_position);
 989
 990 /**
 991  * edma_set_src_index - configure DMA source address indexing
 992  * @slot: parameter RAM slot being configured
 993  * @src_bidx: byte offset between source arrays in a frame
 994  * @src_cidx: byte offset between source frames in a block
 995  *
 996  * Offsets are specified to support either contiguous or discontiguous
 997  * memory transfers, or repeated access to a hardware register, as needed.
 998  * When accessing hardware registers, both offsets are normally zero.
 999  */
1000 void edma_set_src_index(unsigned slot, s16 src_bidx, s16 src_cidx)
1001 {
1002         unsigned ctlr;
1003
1004         ctlr = EDMA_CTLR(slot);
1005         slot = EDMA_CHAN_SLOT(slot);
1006
1007         if (slot < edma_info[ctlr]->num_slots) {
1008                 edma_parm_modify(ctlr, PARM_SRC_DST_BIDX, slot,
1009                                 0xffff0000, src_bidx);
1010                 edma_parm_modify(ctlr, PARM_SRC_DST_CIDX, slot,
1011                                 0xffff0000, src_cidx);
1012         }
1013 }
1014 EXPORT_SYMBOL(edma_set_src_index);
1015
1016 /**
1017  * edma_set_dest_index - configure DMA destination address indexing
1018  * @slot: parameter RAM slot being configured
1019  * @dest_bidx: byte offset between destination arrays in a frame
1020  * @dest_cidx: byte offset between destination frames in a block
1021  *
1022  * Offsets are specified to support either contiguous or discontiguous
1023  * memory transfers, or repeated access to a hardware register, as needed.
1024  * When accessing hardware registers, both offsets are normally zero.
1025  */
1026 void edma_set_dest_index(unsigned slot, s16 dest_bidx, s16 dest_cidx)
1027 {
1028         unsigned ctlr;
1029
1030         ctlr = EDMA_CTLR(slot);
1031         slot = EDMA_CHAN_SLOT(slot);
1032
1033         if (slot < edma_info[ctlr]->num_slots) {
1034                 edma_parm_modify(ctlr, PARM_SRC_DST_BIDX, slot,
1035                                 0x0000ffff, dest_bidx << 16);
1036                 edma_parm_modify(ctlr, PARM_SRC_DST_CIDX, slot,
1037                                 0x0000ffff, dest_cidx << 16);
1038         }
1039 }
1040 EXPORT_SYMBOL(edma_set_dest_index);
1041
1042 /**
1043  * edma_set_transfer_params - configure DMA transfer parameters
1044  * @slot: parameter RAM slot being configured
1045  * @acnt: how many bytes per array (at least one)
1046  * @bcnt: how many arrays per frame (at least one)
1047  * @ccnt: how many frames per block (at least one)
1048  * @bcnt_rld: used only for A-Synchronized transfers; this specifies
1049  *      the value to reload into bcnt when it decrements to zero
1050  * @sync_mode: ASYNC or ABSYNC
1051  *
1052  * See the EDMA3 documentation to understand how to configure and link
1053  * transfers using the fields in PaRAM slots.  If you are not doing it
1054  * all at once with edma_write_slot(), you will use this routine
1055  * plus two calls each for source and destination, setting the initial
1056  * address and saying how to index that address.
1057  *
1058  * An example of an A-Synchronized transfer is a serial link using a
1059  * single word shift register.  In that case, @acnt would be equal to
1060  * that word size; the serial controller issues a DMA synchronization
1061  * event to transfer each word, and memory access by the DMA transfer
1062  * controller will be word-at-a-time.
1063  *
1064  * An example of an AB-Synchronized transfer is a device using a FIFO.
1065  * In that case, @acnt equals the FIFO width and @bcnt equals its depth.
1066  * The controller with the FIFO issues DMA synchronization events when
1067  * the FIFO threshold is reached, and the DMA transfer controller will
1068  * transfer one frame to (or from) the FIFO.  It will probably use
1069  * efficient burst modes to access memory.
1070  */
1071 void edma_set_transfer_params(unsigned slot,
1072                 u16 acnt, u16 bcnt, u16 ccnt,
1073                 u16 bcnt_rld, enum sync_dimension sync_mode)
1074 {
1075         unsigned ctlr;
1076
1077         ctlr = EDMA_CTLR(slot);
1078         slot = EDMA_CHAN_SLOT(slot);
1079
1080         if (slot < edma_info[ctlr]->num_slots) {
1081                 edma_parm_modify(ctlr, PARM_LINK_BCNTRLD, slot,
1082                                 0x0000ffff, bcnt_rld << 16);
1083                 if (sync_mode == ASYNC)
1084                         edma_parm_and(ctlr, PARM_OPT, slot, ~SYNCDIM);
1085                 else
1086                         edma_parm_or(ctlr, PARM_OPT, slot, SYNCDIM);
1087                 /* Set the acount, bcount, ccount registers */
1088                 edma_parm_write(ctlr, PARM_A_B_CNT, slot, (bcnt << 16) | acnt);
1089                 edma_parm_write(ctlr, PARM_CCNT, slot, ccnt);
1090         }
1091 }
1092 EXPORT_SYMBOL(edma_set_transfer_params);
1093
1094 /**
1095  * edma_link - link one parameter RAM slot to another
1096  * @from: parameter RAM slot originating the link
1097  * @to: parameter RAM slot which is the link target
1098  *
1099  * The originating slot should not be part of any active DMA transfer.
1100  */
1101 void edma_link(unsigned from, unsigned to)
1102 {
1103         unsigned ctlr_from, ctlr_to;
1104
1105         ctlr_from = EDMA_CTLR(from);
1106         from = EDMA_CHAN_SLOT(from);
1107         ctlr_to = EDMA_CTLR(to);
1108         to = EDMA_CHAN_SLOT(to);
1109
1110         if (from >= edma_info[ctlr_from]->num_slots)
1111                 return;
1112         if (to >= edma_info[ctlr_to]->num_slots)
1113                 return;
1114         edma_parm_modify(ctlr_from, PARM_LINK_BCNTRLD, from, 0xffff0000,
1115                                 PARM_OFFSET(to));
1116 }
1117 EXPORT_SYMBOL(edma_link);
1118
1119 /**
1120  * edma_unlink - cut link from one parameter RAM slot
1121  * @from: parameter RAM slot originating the link
1122  *
1123  * The originating slot should not be part of any active DMA transfer.
1124  * Its link is set to 0xffff.
1125  */
1126 void edma_unlink(unsigned from)
1127 {
1128         unsigned ctlr;
1129
1130         ctlr = EDMA_CTLR(from);
1131         from = EDMA_CHAN_SLOT(from);
1132
1133         if (from >= edma_info[ctlr]->num_slots)
1134                 return;
1135         edma_parm_or(ctlr, PARM_LINK_BCNTRLD, from, 0xffff);
1136 }
1137 EXPORT_SYMBOL(edma_unlink);
1138
1139 /*-----------------------------------------------------------------------*/
1140
1141 /* Parameter RAM operations (ii) -- read/write whole parameter sets */
1142
1143 /**
1144  * edma_write_slot - write parameter RAM data for slot
1145  * @slot: number of parameter RAM slot being modified
1146  * @param: data to be written into parameter RAM slot
1147  *
1148  * Use this to assign all parameters of a transfer at once.  This
1149  * allows more efficient setup of transfers than issuing multiple
1150  * calls to set up those parameters in small pieces, and provides
1151  * complete control over all transfer options.
1152  */
1153 void edma_write_slot(unsigned slot, const struct edmacc_param *param)
1154 {
1155         unsigned ctlr;
1156
1157         ctlr = EDMA_CTLR(slot);
1158         slot = EDMA_CHAN_SLOT(slot);
1159
1160         if (slot >= edma_info[ctlr]->num_slots)
1161                 return;
1162         memcpy_toio(edmacc_regs_base[ctlr] + PARM_OFFSET(slot), param,
1163                         PARM_SIZE);
1164 }
1165 EXPORT_SYMBOL(edma_write_slot);
1166
1167 /**
1168  * edma_read_slot - read parameter RAM data from slot
1169  * @slot: number of parameter RAM slot being copied
1170  * @param: where to store copy of parameter RAM data
1171  *
1172  * Use this to read data from a parameter RAM slot, perhaps to
1173  * save them as a template for later reuse.
1174  */
1175 void edma_read_slot(unsigned slot, struct edmacc_param *param)
1176 {
1177         unsigned ctlr;
1178
1179         ctlr = EDMA_CTLR(slot);
1180         slot = EDMA_CHAN_SLOT(slot);
1181
1182         if (slot >= edma_info[ctlr]->num_slots)
1183                 return;
1184         memcpy_fromio(param, edmacc_regs_base[ctlr] + PARM_OFFSET(slot),
1185                         PARM_SIZE);
1186 }
1187 EXPORT_SYMBOL(edma_read_slot);
1188
1189 /*-----------------------------------------------------------------------*/
1190
1191 /* Various EDMA channel control operations */
1192
1193 /**
1194  * edma_pause - pause dma on a channel
1195  * @channel: on which edma_start() has been called
1196  *
1197  * This temporarily disables EDMA hardware events on the specified channel,
1198  * preventing them from triggering new transfers on its behalf
1199  */
1200 void edma_pause(unsigned channel)
1201 {
1202         unsigned ctlr;
1203
1204         ctlr = EDMA_CTLR(channel);
1205         channel = EDMA_CHAN_SLOT(channel);
1206
1207         if (channel < edma_info[ctlr]->num_channels) {
1208                 unsigned int mask = (1 << (channel & 0x1f));
1209
1210                 edma_shadow0_write_array(ctlr, SH_EECR, channel >> 5, mask);
1211         }
1212 }
1213 EXPORT_SYMBOL(edma_pause);
1214
1215 /**
1216  * edma_resume - resumes dma on a paused channel
1217  * @channel: on which edma_pause() has been called
1218  *
1219  * This re-enables EDMA hardware events on the specified channel.
1220  */
1221 void edma_resume(unsigned channel)
1222 {
1223         unsigned ctlr;
1224
1225         ctlr = EDMA_CTLR(channel);
1226         channel = EDMA_CHAN_SLOT(channel);
1227
1228         if (channel < edma_info[ctlr]->num_channels) {
1229                 unsigned int mask = (1 << (channel & 0x1f));
1230
1231                 edma_shadow0_write_array(ctlr, SH_EESR, channel >> 5, mask);
1232         }
1233 }
1234 EXPORT_SYMBOL(edma_resume);
1235
1236 /**
1237  * edma_start - start dma on a channel
1238  * @channel: channel being activated
1239  *
1240  * Channels with event associations will be triggered by their hardware
1241  * events, and channels without such associations will be triggered by
1242  * software.  (At this writing there is no interface for using software
1243  * triggers except with channels that don't support hardware triggers.)
1244  *
1245  * Returns zero on success, else negative errno.
1246  */
1247 int edma_start(unsigned channel)
1248 {
1249         unsigned ctlr;
1250
1251         ctlr = EDMA_CTLR(channel);
1252         channel = EDMA_CHAN_SLOT(channel);
1253
1254         if (channel < edma_info[ctlr]->num_channels) {
1255                 int j = channel >> 5;
1256                 unsigned int mask = (1 << (channel & 0x1f));
1257
1258                 /* EDMA channels without event association */
1259                 if (test_bit(channel, edma_info[ctlr]->edma_unused)) {
1260                         pr_debug("EDMA: ESR%d %08x\n", j,
1261                                 edma_shadow0_read_array(ctlr, SH_ESR, j));
1262                         edma_shadow0_write_array(ctlr, SH_ESR, j, mask);
1263                         return 0;
1264                 }
1265
1266                 /* EDMA channel with event association */
1267                 pr_debug("EDMA: ER%d %08x\n", j,
1268                         edma_shadow0_read_array(ctlr, SH_ER, j));
1269                 /* Clear any pending error */
1270                 edma_write_array(ctlr, EDMA_EMCR, j, mask);
1271                 /* Clear any SER */
1272                 edma_shadow0_write_array(ctlr, SH_SECR, j, mask);
1273                 edma_shadow0_write_array(ctlr, SH_EESR, j, mask);
1274                 pr_debug("EDMA: EER%d %08x\n", j,
1275                         edma_shadow0_read_array(ctlr, SH_EER, j));
1276                 return 0;
1277         }
1278
1279         return -EINVAL;
1280 }
1281 EXPORT_SYMBOL(edma_start);
1282
1283 /**
1284  * edma_stop - stops dma on the channel passed
1285  * @channel: channel being deactivated
1286  *
1287  * When @lch is a channel, any active transfer is paused and
1288  * all pending hardware events are cleared.  The current transfer
1289  * may not be resumed, and the channel's Parameter RAM should be
1290  * reinitialized before being reused.
1291  */
1292 void edma_stop(unsigned channel)
1293 {
1294         unsigned ctlr;
1295
1296         ctlr = EDMA_CTLR(channel);
1297         channel = EDMA_CHAN_SLOT(channel);
1298
1299         if (channel < edma_info[ctlr]->num_channels) {
1300                 int j = channel >> 5;
1301                 unsigned int mask = (1 << (channel & 0x1f));
1302
1303                 edma_shadow0_write_array(ctlr, SH_EECR, j, mask);
1304                 edma_shadow0_write_array(ctlr, SH_ECR, j, mask);
1305                 edma_shadow0_write_array(ctlr, SH_SECR, j, mask);
1306                 edma_write_array(ctlr, EDMA_EMCR, j, mask);
1307
1308                 pr_debug("EDMA: EER%d %08x\n", j,
1309                                 edma_shadow0_read_array(ctlr, SH_EER, j));
1310
1311                 /* REVISIT:  consider guarding against inappropriate event
1312                  * chaining by overwriting with dummy_paramset.
1313                  */
1314         }
1315 }
1316 EXPORT_SYMBOL(edma_stop);
1317
1318 /******************************************************************************
1319  *
1320  * It cleans ParamEntry qand bring back EDMA to initial state if media has
1321  * been removed before EDMA has finished.It is usedful for removable media.
1322  * Arguments:
1323  *      ch_no     - channel no
1324  *
1325  * Return: zero on success, or corresponding error no on failure
1326  *
1327  * FIXME this should not be needed ... edma_stop() should suffice.
1328  *
1329  *****************************************************************************/
1330
1331 void edma_clean_channel(unsigned channel)
1332 {
1333         unsigned ctlr;
1334
1335         ctlr = EDMA_CTLR(channel);
1336         channel = EDMA_CHAN_SLOT(channel);
1337
1338         if (channel < edma_info[ctlr]->num_channels) {
1339                 int j = (channel >> 5);
1340                 unsigned int mask = 1 << (channel & 0x1f);
1341
1342                 pr_debug("EDMA: EMR%d %08x\n", j,
1343                                 edma_read_array(ctlr, EDMA_EMR, j));
1344                 edma_shadow0_write_array(ctlr, SH_ECR, j, mask);
1345                 /* Clear the corresponding EMR bits */
1346                 edma_write_array(ctlr, EDMA_EMCR, j, mask);
1347                 /* Clear any SER */
1348                 edma_shadow0_write_array(ctlr, SH_SECR, j, mask);
1349                 edma_write(ctlr, EDMA_CCERRCLR, (1 << 16) | 0x3);
1350         }
1351 }
1352 EXPORT_SYMBOL(edma_clean_channel);
1353
1354 /*
1355  * edma_clear_event - clear an outstanding event on the DMA channel
1356  * Arguments:
1357  *      channel - channel number
1358  */
1359 void edma_clear_event(unsigned channel)
1360 {
1361         unsigned ctlr;
1362
1363         ctlr = EDMA_CTLR(channel);
1364         channel = EDMA_CHAN_SLOT(channel);
1365
1366         if (channel >= edma_info[ctlr]->num_channels)
1367                 return;
1368         if (channel < 32)
1369                 edma_write(ctlr, EDMA_ECR, 1 << channel);
1370         else
1371                 edma_write(ctlr, EDMA_ECRH, 1 << (channel - 32));
1372 }
1373 EXPORT_SYMBOL(edma_clear_event);
1374
1375 /*-----------------------------------------------------------------------*/
1376
1377 static int __init edma_probe(struct platform_device *pdev)
1378 {
1379         struct edma_soc_info    *info = pdev->dev.platform_data;
1380         const s8                (*queue_priority_mapping)[2];
1381         const s8                (*queue_tc_mapping)[2];
1382         int                     i, j, found = 0;
1383         int                     status = -1;
1384         int                     irq[EDMA_MAX_CC] = {0, 0};
1385         int                     err_irq[EDMA_MAX_CC] = {0, 0};
1386         struct resource         *r[EDMA_MAX_CC] = {NULL};
1387         resource_size_t         len[EDMA_MAX_CC];
1388         char                    res_name[10];
1389         char                    irq_name[10];
1390
1391         if (!info)
1392                 return -ENODEV;
1393
1394         for (j = 0; j < EDMA_MAX_CC; j++) {
1395                 sprintf(res_name, "edma_cc%d", j);
1396                 r[j] = platform_get_resource_byname(pdev, IORESOURCE_MEM,
1397                                                 res_name);
1398                 if (!r[j]) {
1399                         if (found)
1400                                 break;
1401                         else
1402                                 return -ENODEV;
1403                 } else
1404                         found = 1;
1405
1406                 len[j] = resource_size(r[j]);
1407
1408                 r[j] = request_mem_region(r[j]->start, len[j],
1409                         dev_name(&pdev->dev));
1410                 if (!r[j]) {
1411                         status = -EBUSY;
1412                         goto fail1;
1413                 }
1414
1415                 edmacc_regs_base[j] = ioremap(r[j]->start, len[j]);
1416                 if (!edmacc_regs_base[j]) {
1417                         status = -EBUSY;
1418                         goto fail1;
1419                 }
1420
1421                 edma_info[j] = kmalloc(sizeof(struct edma), GFP_KERNEL);
1422                 if (!edma_info[j]) {
1423                         status = -ENOMEM;
1424                         goto fail1;
1425                 }
1426                 memset(edma_info[j], 0, sizeof(struct edma));
1427
1428                 edma_info[j]->num_channels = min_t(unsigned, info[j].n_channel,
1429                                                         EDMA_MAX_DMACH);
1430                 edma_info[j]->num_slots = min_t(unsigned, info[j].n_slot,
1431                                                         EDMA_MAX_PARAMENTRY);
1432                 edma_info[j]->num_cc = min_t(unsigned, info[j].n_cc,
1433                                                         EDMA_MAX_CC);
1434
1435                 edma_info[j]->default_queue = info[j].default_queue;
1436                 if (!edma_info[j]->default_queue)
1437                         edma_info[j]->default_queue = EVENTQ_1;
1438
1439                 dev_dbg(&pdev->dev, "DMA REG BASE ADDR=%p\n",
1440                         edmacc_regs_base[j]);
1441
1442                 for (i = 0; i < edma_info[j]->num_slots; i++)
1443                         memcpy_toio(edmacc_regs_base[j] + PARM_OFFSET(i),
1444                                         &dummy_paramset, PARM_SIZE);
1445
1446                 /* Mark all channels as unused */
1447                 memset(edma_info[j]->edma_unused, 0xff,
1448                         sizeof(edma_info[j]->edma_unused));
1449
1450                 sprintf(irq_name, "edma%d", j);
1451                 irq[j] = platform_get_irq_byname(pdev, irq_name);
1452                 edma_info[j]->irq_res_start = irq[j];
1453                 status = request_irq(irq[j], dma_irq_handler, 0, "edma",
1454                                         &pdev->dev);
1455                 if (status < 0) {
1456                         dev_dbg(&pdev->dev, "request_irq %d failed --> %d\n",
1457                                 irq[j], status);
1458                         goto fail;
1459                 }
1460
1461                 sprintf(irq_name, "edma%d_err", j);
1462                 err_irq[j] = platform_get_irq_byname(pdev, irq_name);
1463                 edma_info[j]->irq_res_end = err_irq[j];
1464                 status = request_irq(err_irq[j], dma_ccerr_handler, 0,
1465                                         "edma_error", &pdev->dev);
1466                 if (status < 0) {
1467                         dev_dbg(&pdev->dev, "request_irq %d failed --> %d\n",
1468                                 err_irq[j], status);
1469                         goto fail;
1470                 }
1471
1472                 /* Everything lives on transfer controller 1 until otherwise
1473                  * specified. This way, long transfers on the low priority queue
1474                  * started by the codec engine will not cause audio defects.
1475                  */
1476                 for (i = 0; i < edma_info[j]->num_channels; i++)
1477                         map_dmach_queue(j, i, EVENTQ_1);
1478
1479                 queue_tc_mapping = info[j].queue_tc_mapping;
1480                 queue_priority_mapping = info[j].queue_priority_mapping;
1481
1482                 /* Event queue to TC mapping */
1483                 for (i = 0; queue_tc_mapping[i][0] != -1; i++)
1484                         map_queue_tc(j, queue_tc_mapping[i][0],
1485                                         queue_tc_mapping[i][1]);
1486
1487                 /* Event queue priority mapping */
1488                 for (i = 0; queue_priority_mapping[i][0] != -1; i++)
1489                         assign_priority_to_queue(j,
1490                                                 queue_priority_mapping[i][0],
1491                                                 queue_priority_mapping[i][1]);
1492
1493                 /* Map the channel to param entry if channel mapping logic
1494                  * exist
1495                  */
1496                 if (edma_read(j, EDMA_CCCFG) & CHMAP_EXIST)
1497                         map_dmach_param(j);
1498
1499                 for (i = 0; i < info[j].n_region; i++) {
1500                         edma_write_array2(j, EDMA_DRAE, i, 0, 0x0);
1501                         edma_write_array2(j, EDMA_DRAE, i, 1, 0x0);
1502                         edma_write_array(j, EDMA_QRAE, i, 0x0);
1503                 }
1504                 arch_num_cc++;
1505         }
1506
1507         if (tc_errs_handled) {
1508                 status = request_irq(IRQ_TCERRINT0, dma_tc0err_handler, 0,
1509                                         "edma_tc0", &pdev->dev);
1510                 if (status < 0) {
1511                         dev_dbg(&pdev->dev, "request_irq %d failed --> %d\n",
1512                                 IRQ_TCERRINT0, status);
1513                         return status;
1514                 }
1515                 status = request_irq(IRQ_TCERRINT, dma_tc1err_handler, 0,
1516                                         "edma_tc1", &pdev->dev);
1517                 if (status < 0) {
1518                         dev_dbg(&pdev->dev, "request_irq %d --> %d\n",
1519                                 IRQ_TCERRINT, status);
1520                         return status;
1521                 }
1522         }
1523
1524         return 0;
1525
1526 fail:
1527         for (i = 0; i < EDMA_MAX_CC; i++) {
1528                 if (err_irq[i])
1529                         free_irq(err_irq[i], &pdev->dev);
1530                 if (irq[i])
1531                         free_irq(irq[i], &pdev->dev);
1532         }
1533 fail1:
1534         for (i = 0; i < EDMA_MAX_CC; i++) {
1535                 if (r[i])
1536                         release_mem_region(r[i]->start, len[i]);
1537                 if (edmacc_regs_base[i])
1538                         iounmap(edmacc_regs_base[i]);
1539                 kfree(edma_info[i]);
1540         }
1541         return status;
1542 }
1543
1544
1545 static struct platform_driver edma_driver = {
1546         .driver.name    = "edma",
1547 };
1548
1549 static int __init edma_init(void)
1550 {
1551         return platform_driver_probe(&edma_driver, edma_probe);
1552 }
1553 arch_initcall(edma_init);
1554