drivers/usb/musb/cppi41.c

   1 /*
   2  * CPPI 4.1 support
   3  *
   4  * Copyright (C) 2008-2009 MontaVista Software, Inc. <source@mvista.com>
   5  *
   6  * Based on the PAL CPPI 4.1 implementation
   7  * Copyright (C) 1998-2006 Texas Instruments Incorporated
   8  *
   9  * This file contains the main implementation for CPPI 4.1 common peripherals,
  10  * including the DMA Controllers and the Queue Managers.
  11  *
  12  * This program is free software; you can distribute it and/or modify it
  13  * under the terms of the GNU General Public License (Version 2) as
  14  * published by the Free Software Foundation.
  15  *
  16  * This program is distributed in the hope it will be useful, but WITHOUT
  17  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19  * for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License along
  22  * with this program; if not, write to the Free Software Foundation, Inc.,
  23  * 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
  24  *
  25  */
  26
  27 #include <linux/io.h>
  28 #include <linux/init.h>
  29 #include <linux/slab.h>
  30 #include <linux/module.h>
  31 #include <linux/dma-mapping.h>
  32
  33 #include "cppi41.h"
  34
  35 #undef  CPPI41_DEBUG
  36
  37 #ifdef  CPPI41_DEBUG
  38 #define DBG(format, args...) printk(format, ##args)
  39 #else
  40 #define DBG(format, args...)
  41 #endif
  42
  43 static struct {
  44         void *virt_addr;
  45         dma_addr_t phys_addr;
  46 } linking_ram[CPPI41_NUM_QUEUE_MGR];
  47
  48 static u32 *allocated_queues[CPPI41_NUM_QUEUE_MGR];
  49
  50 /* First 32 packet descriptors are reserved for unallocated memory regions. */
  51 static u32 next_desc_index[CPPI41_NUM_QUEUE_MGR] = { 1 << 5 };
  52 static u8  next_mem_rgn[CPPI41_NUM_QUEUE_MGR];
  53
  54 static struct {
  55         size_t rgn_size;
  56         void *virt_addr;
  57         dma_addr_t phys_addr;
  58         struct cppi41_queue_obj queue_obj;
  59         u8 mem_rgn;
  60 } dma_teardown[CPPI41_NUM_DMA_BLOCK];
  61
  62 /******************** CPPI 4.1 Functions (External Interface) *****************/
  63
  64 int __init cppi41_queue_mgr_init(u8 q_mgr, dma_addr_t rgn0_base, u16 rgn0_size)
  65 {
  66         void __iomem *q_mgr_regs;
  67         void *ptr;
  68
  69         if (q_mgr >= cppi41_num_queue_mgr)
  70                 return -EINVAL;
  71
  72         q_mgr_regs = cppi41_queue_mgr[q_mgr].q_mgr_rgn_base;
  73
  74         __raw_writel(rgn0_base, q_mgr_regs + QMGR_LINKING_RAM_RGN0_BASE_REG);
  75         DBG("Linking RAM region 0 base @ %p, value: %x\n",
  76             q_mgr_regs + QMGR_LINKING_RAM_RGN0_BASE_REG,
  77             __raw_readl(q_mgr_regs + QMGR_LINKING_RAM_RGN0_BASE_REG));
  78
  79         __raw_writel(rgn0_size, q_mgr_regs + QMGR_LINKING_RAM_RGN0_SIZE_REG);
  80         DBG("Linking RAM region 0 size @ %p, value: %x\n",
  81             q_mgr_regs + QMGR_LINKING_RAM_RGN0_SIZE_REG,
  82             __raw_readl(q_mgr_regs + QMGR_LINKING_RAM_RGN0_SIZE_REG));
  83
  84         ptr = dma_alloc_coherent(NULL, 0x10000 - rgn0_size * 4,
  85                                  &linking_ram[q_mgr].phys_addr,
  86                                  GFP_KERNEL | GFP_DMA);
  87         if (ptr == NULL) {
  88                 printk(KERN_ERR "ERROR: %s: Unable to allocate "
  89                        "linking RAM.\n", __func__);
  90                 return -ENOMEM;
  91         }
  92         linking_ram[q_mgr].virt_addr = ptr;
  93
  94         __raw_writel(linking_ram[q_mgr].phys_addr,
  95                      q_mgr_regs + QMGR_LINKING_RAM_RGN1_BASE_REG);
  96         DBG("Linking RAM region 1 base @ %p, value: %x\n",
  97             q_mgr_regs + QMGR_LINKING_RAM_RGN1_BASE_REG,
  98             __raw_readl(q_mgr_regs + QMGR_LINKING_RAM_RGN1_BASE_REG));
  99
 100         ptr = kzalloc(BITS_TO_LONGS(cppi41_queue_mgr[q_mgr].num_queue),
 101                       GFP_KERNEL);
 102         if (ptr == NULL) {
 103                 printk(KERN_ERR "ERROR: %s: Unable to allocate queue bitmap.\n",
 104                        __func__);
 105                 dma_free_coherent(NULL, 0x10000 - rgn0_size * 4,
 106                                   linking_ram[q_mgr].virt_addr,
 107                                   linking_ram[q_mgr].phys_addr);
 108                 return -ENOMEM;
 109         }
 110         allocated_queues[q_mgr] = ptr;
 111
 112         return 0;
 113 }
 114
 115 int __init cppi41_dma_block_init(u8 dma_num, u8 q_mgr, u8 num_order,
 116                                  u8 *sched_tbl, u8 tbl_size)
 117 {
 118         const struct cppi41_dma_block *dma_block;
 119         struct cppi41_teardown_desc *curr_td;
 120         dma_addr_t td_addr;
 121         unsigned num_desc, num_reg;
 122         void *ptr;
 123         int error, i, j, k;
 124         u16 q_num;
 125         u32 val;
 126
 127         if (dma_num >= cppi41_num_dma_block ||
 128             q_mgr >= cppi41_num_queue_mgr ||
 129             !tbl_size || sched_tbl == NULL)
 130                 return -EINVAL;
 131
 132         error = cppi41_queue_alloc(CPPI41_FREE_DESC_QUEUE |
 133                                    CPPI41_UNASSIGNED_QUEUE, q_mgr, &q_num);
 134         if (error) {
 135                 printk(KERN_ERR "ERROR: %s: Unable to allocate teardown "
 136                        "descriptor queue.\n", __func__);
 137                 return error;
 138         }
 139         DBG("Teardown descriptor queue %d in queue manager 0 "
 140             "allocated\n", q_num);
 141
 142         /*
 143          * Tell the hardware about the Teardown descriptor
 144          * queue manager and queue number.
 145          */
 146         dma_block = &cppi41_dma_block[dma_num];
 147         __raw_writel((q_mgr << DMA_TD_DESC_QMGR_SHIFT) |
 148                      (q_num << DMA_TD_DESC_QNUM_SHIFT),
 149                      dma_block->global_ctrl_base +
 150                      DMA_TEARDOWN_FREE_DESC_CTRL_REG);
 151         DBG("Teardown free descriptor control @ %p, value: %x\n",
 152             dma_block->global_ctrl_base + DMA_TEARDOWN_FREE_DESC_CTRL_REG,
 153             __raw_readl(dma_block->global_ctrl_base +
 154                         DMA_TEARDOWN_FREE_DESC_CTRL_REG));
 155
 156         num_desc = 1 << num_order;
 157         dma_teardown[dma_num].rgn_size = num_desc *
 158                                          sizeof(struct cppi41_teardown_desc);
 159
 160         /* Pre-allocate teardown descriptors. */
 161         ptr = dma_alloc_coherent(NULL, dma_teardown[dma_num].rgn_size,
 162                                  &dma_teardown[dma_num].phys_addr,
 163                                  GFP_KERNEL | GFP_DMA);
 164         if (ptr == NULL) {
 165                 printk(KERN_ERR "ERROR: %s: Unable to allocate teardown "
 166                        "descriptors.\n", __func__);
 167                 error = -ENOMEM;
 168                 goto free_queue;
 169         }
 170         dma_teardown[dma_num].virt_addr = ptr;
 171
 172         error = cppi41_mem_rgn_alloc(q_mgr, dma_teardown[dma_num].phys_addr, 5,
 173                                      num_order, &dma_teardown[dma_num].mem_rgn);
 174         if (error) {
 175                 printk(KERN_ERR "ERROR: %s: Unable to allocate queue manager "
 176                        "memory region for teardown descriptors.\n", __func__);
 177                 goto free_mem;
 178         }
 179
 180         error = cppi41_queue_init(&dma_teardown[dma_num].queue_obj, 0, q_num);
 181         if (error) {
 182                 printk(KERN_ERR "ERROR: %s: Unable to initialize teardown "
 183                        "free descriptor queue.\n", __func__);
 184                 goto free_rgn;
 185         }
 186
 187         /*
 188          * Push all teardown descriptors to the free teardown queue
 189          * for the CPPI 4.1 system.
 190          */
 191         curr_td = dma_teardown[dma_num].virt_addr;
 192         td_addr = dma_teardown[dma_num].phys_addr;
 193
 194         for (i = 0; i < num_desc; i++) {
 195                 cppi41_queue_push(&dma_teardown[dma_num].queue_obj, td_addr,
 196                                   sizeof(*curr_td), 0);
 197                 td_addr += sizeof(*curr_td);
 198         }
 199
 200         /* Initialize the DMA scheduler. */
 201         num_reg = (tbl_size + 3) / 4;
 202         for (k = i = 0; i < num_reg; i++) {
 203                 for (val = j = 0; j < 4; j++, k++) {
 204                         val >>= 8;
 205                         if (k < tbl_size)
 206                                 val |= sched_tbl[k] << 24;
 207                 }
 208
 209                 __raw_writel(val, dma_block->sched_table_base +
 210                              DMA_SCHED_TABLE_WORD_REG(i));
 211                 DBG("DMA scheduler table @ %p, value written: %x\n",
 212                     dma_block->sched_table_base + DMA_SCHED_TABLE_WORD_REG(i),
 213                     val);
 214         }
 215
 216         __raw_writel((tbl_size - 1) << DMA_SCHED_LAST_ENTRY_SHIFT |
 217                      DMA_SCHED_ENABLE_MASK,
 218                      dma_block->sched_ctrl_base + DMA_SCHED_CTRL_REG);
 219         DBG("DMA scheduler control @ %p, value: %x\n",
 220             dma_block->sched_ctrl_base + DMA_SCHED_CTRL_REG,
 221             __raw_readl(dma_block->sched_ctrl_base + DMA_SCHED_CTRL_REG));
 222
 223         return 0;
 224
 225 free_rgn:
 226         cppi41_mem_rgn_free(q_mgr, dma_teardown[dma_num].mem_rgn);
 227 free_mem:
 228         dma_free_coherent(NULL, dma_teardown[dma_num].rgn_size,
 229                           dma_teardown[dma_num].virt_addr,
 230                           dma_teardown[dma_num].phys_addr);
 231 free_queue:
 232         cppi41_queue_free(q_mgr, q_num);
 233         return error;
 234 }
 235
 236 /*
 237  * cppi41_mem_rgn_alloc - allocate a memory region within the queue manager
 238  */
 239 int cppi41_mem_rgn_alloc(u8 q_mgr, dma_addr_t rgn_addr, u8 size_order,
 240                          u8 num_order, u8 *mem_rgn)
 241 {
 242         void __iomem *desc_mem_regs;
 243         u32 num_desc = 1 << num_order, index, ctrl;
 244         int rgn;
 245
 246         DBG("%s called with rgn_addr = %08x, size_order = %d, num_order = %d\n",
 247             __func__, rgn_addr, size_order, num_order);
 248
 249         if (q_mgr >= cppi41_num_queue_mgr ||
 250             size_order < 5 || size_order > 13 ||
 251             num_order  < 5 || num_order  > 12 ||
 252             (rgn_addr & ((1 << size_order) - 1)))
 253                 return -EINVAL;
 254
 255         rgn = next_mem_rgn[q_mgr];
 256         index = next_desc_index[q_mgr];
 257         if (rgn >= CPPI41_MAX_MEM_RGN || index + num_desc > 0x4000)
 258                 return -ENOSPC;
 259
 260         next_mem_rgn[q_mgr] = rgn + 1;
 261         next_desc_index[q_mgr] = index + num_desc;
 262
 263         desc_mem_regs = cppi41_queue_mgr[q_mgr].desc_mem_rgn_base;
 264
 265         /* Write the base register */
 266         __raw_writel(rgn_addr, desc_mem_regs + QMGR_MEM_RGN_BASE_REG(rgn));
 267         DBG("Descriptor region base @ %p, value: %x\n",
 268             desc_mem_regs + QMGR_MEM_RGN_BASE_REG(rgn),
 269             __raw_readl(desc_mem_regs + QMGR_MEM_RGN_BASE_REG(rgn)));
 270
 271         /* Write the control register */
 272         ctrl = ((index << QMGR_MEM_RGN_INDEX_SHIFT) &
 273                 QMGR_MEM_RGN_INDEX_MASK) |
 274                (((size_order - 5) << QMGR_MEM_RGN_DESC_SIZE_SHIFT) &
 275                 QMGR_MEM_RGN_DESC_SIZE_MASK) |
 276                (((num_order - 5) << QMGR_MEM_RGN_SIZE_SHIFT) &
 277                 QMGR_MEM_RGN_SIZE_MASK);
 278         __raw_writel(ctrl, desc_mem_regs + QMGR_MEM_RGN_CTRL_REG(rgn));
 279         DBG("Descriptor region control @ %p, value: %x\n",
 280             desc_mem_regs + QMGR_MEM_RGN_CTRL_REG(rgn),
 281             __raw_readl(desc_mem_regs + QMGR_MEM_RGN_CTRL_REG(rgn)));
 282
 283         *mem_rgn = rgn;
 284         return 0;
 285 }
 286 EXPORT_SYMBOL(cppi41_mem_rgn_alloc);
 287
 288 /*
 289  * cppi41_mem_rgn_free - free the memory region within the queue manager
 290  */
 291 int cppi41_mem_rgn_free(u8 q_mgr, u8 mem_rgn)
 292 {
 293         void __iomem *desc_mem_regs;
 294
 295         DBG("%s called.\n", __func__);
 296
 297         if (q_mgr >= cppi41_num_queue_mgr || mem_rgn >= next_mem_rgn[q_mgr])
 298                 return -EINVAL;
 299
 300         desc_mem_regs = cppi41_queue_mgr[q_mgr].desc_mem_rgn_base;
 301
 302         if (__raw_readl(desc_mem_regs + QMGR_MEM_RGN_BASE_REG(mem_rgn)) == 0)
 303                 return -ENOENT;
 304
 305         __raw_writel(0, desc_mem_regs + QMGR_MEM_RGN_BASE_REG(mem_rgn));
 306         __raw_writel(0, desc_mem_regs + QMGR_MEM_RGN_CTRL_REG(mem_rgn));
 307
 308         return 0;
 309 }
 310 EXPORT_SYMBOL(cppi41_mem_rgn_free);
 311
 312 /*
 313  * cppi41_tx_ch_init - initialize a CPPI 4.1 Tx channel object
 314  *
 315  * Verify the channel info (range checking, etc.) and store the channel
 316  * information within the object structure.
 317  */
 318 int cppi41_tx_ch_init(struct cppi41_dma_ch_obj *tx_ch_obj,
 319                       u8 dma_num, u8 ch_num)
 320 {
 321         if (dma_num >= cppi41_num_dma_block ||
 322             ch_num  >= cppi41_dma_block[dma_num].num_tx_ch)
 323                 return -EINVAL;
 324
 325         /* Populate the channel object structure */
 326         tx_ch_obj->base_addr  = cppi41_dma_block[dma_num].ch_ctrl_stat_base +
 327                                 DMA_CH_TX_GLOBAL_CFG_REG(ch_num);
 328         tx_ch_obj->global_cfg = __raw_readl(tx_ch_obj->base_addr);
 329         return 0;
 330 }
 331 EXPORT_SYMBOL(cppi41_tx_ch_init);
 332
 333 /*
 334  * cppi41_rx_ch_init - initialize a CPPI 4.1 Rx channel object
 335  *
 336  * Verify the channel info (range checking, etc.) and store the channel
 337  * information within the object structure.
 338  */
 339 int cppi41_rx_ch_init(struct cppi41_dma_ch_obj *rx_ch_obj,
 340                       u8 dma_num, u8 ch_num)
 341 {
 342         if (dma_num >= cppi41_num_dma_block ||
 343             ch_num  >= cppi41_dma_block[dma_num].num_rx_ch)
 344                 return -EINVAL;
 345
 346         /* Populate the channel object structure */
 347         rx_ch_obj->base_addr  = cppi41_dma_block[dma_num].ch_ctrl_stat_base +
 348                                 DMA_CH_RX_GLOBAL_CFG_REG(ch_num);
 349         rx_ch_obj->global_cfg = __raw_readl(rx_ch_obj->base_addr);
 350         return 0;
 351 }
 352 EXPORT_SYMBOL(cppi41_rx_ch_init);
 353
 354 /*
 355  * We have to cache the last written Rx/Tx channel global configration register
 356  * value due to its bits other than enable/teardown being write-only. Yet there
 357  * is a caveat related to caching the enable bit: this bit may be automatically
 358  * cleared as a result of teardown, so we can't trust its cached value!
 359  * When modifying the write only register fields, we're making use of the fact
 360  * that they read back as zeros, and not clearing them explicitly...
 361  */
 362
 363 /*
 364  * cppi41_dma_ch_default_queue - set CPPI 4.1 channel default completion queue
 365  */
 366 void cppi41_dma_ch_default_queue(struct cppi41_dma_ch_obj *dma_ch_obj,
 367                                  u8 q_mgr, u16 q_num)
 368 {
 369         u32 val = dma_ch_obj->global_cfg;
 370
 371         /* Clear the fields to be modified. */
 372         val &= ~(DMA_CH_TX_DEFAULT_QMGR_MASK | DMA_CH_TX_DEFAULT_QNUM_MASK |
 373                  DMA_CH_TX_ENABLE_MASK);
 374
 375         /* Set the default completion queue. */
 376         val |= ((q_mgr << DMA_CH_TX_DEFAULT_QMGR_SHIFT) &
 377                 DMA_CH_TX_DEFAULT_QMGR_MASK) |
 378                ((q_num << DMA_CH_TX_DEFAULT_QNUM_SHIFT) &
 379                 DMA_CH_TX_DEFAULT_QNUM_MASK);
 380
 381         /* Get the current state of the enable bit. */
 382         dma_ch_obj->global_cfg = val |= __raw_readl(dma_ch_obj->base_addr);
 383         __raw_writel(val, dma_ch_obj->base_addr);
 384         DBG("Channel global configuration @ %p, value written: %x, "
 385             "value read: %x\n", dma_ch_obj->base_addr, val,
 386             __raw_readl(dma_ch_obj->base_addr));
 387
 388 }
 389 EXPORT_SYMBOL(cppi41_dma_ch_default_queue);
 390
 391 /*
 392  * cppi41_rx_ch_configure - configure CPPI 4.1 Rx channel
 393  */
 394 void cppi41_rx_ch_configure(struct cppi41_dma_ch_obj *rx_ch_obj,
 395                             struct cppi41_rx_ch_cfg  *cfg)
 396 {
 397         void __iomem *base = rx_ch_obj->base_addr;
 398         u32 val = __raw_readl(rx_ch_obj->base_addr);
 399
 400         val |= ((cfg->sop_offset << DMA_CH_RX_SOP_OFFSET_SHIFT) &
 401                 DMA_CH_RX_SOP_OFFSET_MASK) |
 402                ((cfg->default_desc_type << DMA_CH_RX_DEFAULT_DESC_TYPE_SHIFT) &
 403                 DMA_CH_RX_DEFAULT_DESC_TYPE_MASK) |
 404                ((cfg->retry_starved << DMA_CH_RX_ERROR_HANDLING_SHIFT) &
 405                 DMA_CH_RX_ERROR_HANDLING_MASK) |
 406                ((cfg->rx_queue.q_mgr << DMA_CH_RX_DEFAULT_RQ_QMGR_SHIFT) &
 407                 DMA_CH_RX_DEFAULT_RQ_QMGR_MASK) |
 408                ((cfg->rx_queue.q_num << DMA_CH_RX_DEFAULT_RQ_QNUM_SHIFT) &
 409                 DMA_CH_RX_DEFAULT_RQ_QNUM_MASK);
 410
 411         rx_ch_obj->global_cfg = val;
 412         __raw_writel(val, base);
 413         DBG("Rx channel global configuration @ %p, value written: %x, "
 414             "value read: %x\n", base, val, __raw_readl(base));
 415
 416         base -= DMA_CH_RX_GLOBAL_CFG_REG(0);
 417
 418         /*
 419          * Set up the packet configuration register
 420          * based on the descriptor type...
 421          */
 422         switch (cfg->default_desc_type) {
 423         case DMA_CH_RX_DEFAULT_DESC_EMBED:
 424                 val = ((cfg->cfg.embed_pkt.fd_queue.q_mgr <<
 425                         DMA_CH_RX_EMBED_FDQ_QMGR_SHIFT) &
 426                        DMA_CH_RX_EMBED_FDQ_QMGR_MASK) |
 427                       ((cfg->cfg.embed_pkt.fd_queue.q_num <<
 428                         DMA_CH_RX_EMBED_FDQ_QNUM_SHIFT) &
 429                        DMA_CH_RX_EMBED_FDQ_QNUM_MASK) |
 430                       ((cfg->cfg.embed_pkt.num_buf_slot <<
 431                         DMA_CH_RX_EMBED_NUM_SLOT_SHIFT) &
 432                        DMA_CH_RX_EMBED_NUM_SLOT_MASK) |
 433                       ((cfg->cfg.embed_pkt.sop_slot_num <<
 434                         DMA_CH_RX_EMBED_SOP_SLOT_SHIFT) &
 435                        DMA_CH_RX_EMBED_SOP_SLOT_MASK);
 436
 437                 __raw_writel(val, base + DMA_CH_RX_EMBED_PKT_CFG_REG_B(0));
 438                 DBG("Rx channel embedded packet configuration B @ %p, "
 439                     "value written: %x\n",
 440                     base + DMA_CH_RX_EMBED_PKT_CFG_REG_B(0), val);
 441
 442                 val = ((cfg->cfg.embed_pkt.free_buf_pool[0].b_pool <<
 443                         DMA_CH_RX_EMBED_FBP_PNUM_SHIFT(0)) &
 444                        DMA_CH_RX_EMBED_FBP_PNUM_MASK(0)) |
 445                       ((cfg->cfg.embed_pkt.free_buf_pool[0].b_mgr <<
 446                         DMA_CH_RX_EMBED_FBP_BMGR_SHIFT(0)) &
 447                        DMA_CH_RX_EMBED_FBP_BMGR_MASK(0)) |
 448                       ((cfg->cfg.embed_pkt.free_buf_pool[1].b_pool <<
 449                         DMA_CH_RX_EMBED_FBP_PNUM_SHIFT(1)) &
 450                        DMA_CH_RX_EMBED_FBP_PNUM_MASK(1)) |
 451                       ((cfg->cfg.embed_pkt.free_buf_pool[1].b_mgr <<
 452                         DMA_CH_RX_EMBED_FBP_BMGR_SHIFT(1)) &
 453                        DMA_CH_RX_EMBED_FBP_BMGR_MASK(1)) |
 454                       ((cfg->cfg.embed_pkt.free_buf_pool[2].b_pool <<
 455                         DMA_CH_RX_EMBED_FBP_PNUM_SHIFT(2)) &
 456                        DMA_CH_RX_EMBED_FBP_PNUM_MASK(2)) |
 457                       ((cfg->cfg.embed_pkt.free_buf_pool[2].b_mgr <<
 458                         DMA_CH_RX_EMBED_FBP_BMGR_SHIFT(2)) &
 459                        DMA_CH_RX_EMBED_FBP_BMGR_MASK(2)) |
 460                       ((cfg->cfg.embed_pkt.free_buf_pool[3].b_pool <<
 461                         DMA_CH_RX_EMBED_FBP_PNUM_SHIFT(3)) &
 462                        DMA_CH_RX_EMBED_FBP_PNUM_MASK(3)) |
 463                       ((cfg->cfg.embed_pkt.free_buf_pool[3].b_mgr <<
 464                         DMA_CH_RX_EMBED_FBP_BMGR_SHIFT(3)) &
 465                        DMA_CH_RX_EMBED_FBP_BMGR_MASK(3));
 466
 467                 __raw_writel(val, base + DMA_CH_RX_EMBED_PKT_CFG_REG_A(0));
 468                 DBG("Rx channel embedded packet configuration A @ %p, "
 469                     "value written: %x\n",
 470                     base + DMA_CH_RX_EMBED_PKT_CFG_REG_A(0), val);
 471                 break;
 472         case DMA_CH_RX_DEFAULT_DESC_HOST:
 473                 val = ((cfg->cfg.host_pkt.fdb_queue[0].q_num <<
 474                         DMA_CH_RX_HOST_FDQ_QNUM_SHIFT(0)) &
 475                        DMA_CH_RX_HOST_FDQ_QNUM_MASK(0)) |
 476                       ((cfg->cfg.host_pkt.fdb_queue[0].q_mgr <<
 477                         DMA_CH_RX_HOST_FDQ_QMGR_SHIFT(0)) &
 478                        DMA_CH_RX_HOST_FDQ_QMGR_MASK(0)) |
 479                       ((cfg->cfg.host_pkt.fdb_queue[1].q_num <<
 480                         DMA_CH_RX_HOST_FDQ_QNUM_SHIFT(1)) &
 481                        DMA_CH_RX_HOST_FDQ_QNUM_MASK(1)) |
 482                       ((cfg->cfg.host_pkt.fdb_queue[1].q_mgr <<
 483                         DMA_CH_RX_HOST_FDQ_QMGR_SHIFT(1)) &
 484                        DMA_CH_RX_HOST_FDQ_QMGR_MASK(1));
 485
 486                 __raw_writel(val, base + DMA_CH_RX_HOST_PKT_CFG_REG_A(0));
 487                 DBG("Rx channel host packet configuration A @ %p, "
 488                     "value written: %x\n",
 489                     base + DMA_CH_RX_HOST_PKT_CFG_REG_A(0), val);
 490
 491                 val = ((cfg->cfg.host_pkt.fdb_queue[2].q_num <<
 492                         DMA_CH_RX_HOST_FDQ_QNUM_SHIFT(2)) &
 493                        DMA_CH_RX_HOST_FDQ_QNUM_MASK(2)) |
 494                       ((cfg->cfg.host_pkt.fdb_queue[2].q_mgr <<
 495                         DMA_CH_RX_HOST_FDQ_QMGR_SHIFT(2)) &
 496                        DMA_CH_RX_HOST_FDQ_QMGR_MASK(2)) |
 497                       ((cfg->cfg.host_pkt.fdb_queue[3].q_num <<
 498                        DMA_CH_RX_HOST_FDQ_QNUM_SHIFT(3)) &
 499                        DMA_CH_RX_HOST_FDQ_QNUM_MASK(3)) |
 500                       ((cfg->cfg.host_pkt.fdb_queue[3].q_mgr <<
 501                         DMA_CH_RX_HOST_FDQ_QMGR_SHIFT(3)) &
 502                        DMA_CH_RX_HOST_FDQ_QMGR_MASK(3));
 503
 504                 __raw_writel(val, base + DMA_CH_RX_HOST_PKT_CFG_REG_B(0));
 505                 DBG("Rx channel host packet configuration B @ %p, "
 506                     "value written: %x\n",
 507                     base + DMA_CH_RX_HOST_PKT_CFG_REG_B(0), val);
 508                 break;
 509         case DMA_CH_RX_DEFAULT_DESC_MONO:
 510                 val = ((cfg->cfg.mono_pkt.fd_queue.q_num <<
 511                         DMA_CH_RX_MONO_FDQ_QNUM_SHIFT) &
 512                        DMA_CH_RX_MONO_FDQ_QNUM_MASK) |
 513                       ((cfg->cfg.mono_pkt.fd_queue.q_mgr <<
 514                         DMA_CH_RX_MONO_FDQ_QMGR_SHIFT) &
 515                        DMA_CH_RX_MONO_FDQ_QMGR_MASK) |
 516                       ((cfg->cfg.mono_pkt.sop_offset <<
 517                         DMA_CH_RX_MONO_SOP_OFFSET_SHIFT) &
 518                        DMA_CH_RX_MONO_SOP_OFFSET_MASK);
 519
 520                 __raw_writel(val, base + DMA_CH_RX_MONO_PKT_CFG_REG(0));
 521                 DBG("Rx channel monolithic packet configuration @ %p, "
 522                     "value written: %x\n",
 523                     base + DMA_CH_RX_MONO_PKT_CFG_REG(0), val);
 524                 break;
 525         }
 526 }
 527 EXPORT_SYMBOL(cppi41_rx_ch_configure);
 528
 529 /*
 530  * cppi41_dma_ch_teardown - teardown a given Tx/Rx channel
 531  */
 532 void cppi41_dma_ch_teardown(struct cppi41_dma_ch_obj *dma_ch_obj)
 533 {
 534         u32 val = __raw_readl(dma_ch_obj->base_addr);
 535
 536         /* Initiate channel teardown. */
 537         val |= dma_ch_obj->global_cfg & ~DMA_CH_TX_ENABLE_MASK;
 538         dma_ch_obj->global_cfg = val |= DMA_CH_TX_TEARDOWN_MASK;
 539         __raw_writel(val, dma_ch_obj->base_addr);
 540         DBG("Tear down channel @ %p, value written: %x, value read: %x\n",
 541             dma_ch_obj->base_addr, val, __raw_readl(dma_ch_obj->base_addr));
 542 }
 543 EXPORT_SYMBOL(cppi41_dma_ch_teardown);
 544
 545 /*
 546  * cppi41_dma_ch_enable - enable Tx/Rx DMA channel in hardware
 547  *
 548  * Makes the channel ready for data transmission/reception.
 549  */
 550 void cppi41_dma_ch_enable(struct cppi41_dma_ch_obj *dma_ch_obj)
 551 {
 552         u32 val = dma_ch_obj->global_cfg | DMA_CH_TX_ENABLE_MASK;
 553
 554         /* Teardown bit remains set after completion, so clear it now... */
 555         dma_ch_obj->global_cfg = val &= ~DMA_CH_TX_TEARDOWN_MASK;
 556         __raw_writel(val, dma_ch_obj->base_addr);
 557         DBG("Enable channel @ %p, value written: %x, value read: %x\n",
 558             dma_ch_obj->base_addr, val, __raw_readl(dma_ch_obj->base_addr));
 559 }
 560 EXPORT_SYMBOL(cppi41_dma_ch_enable);
 561
 562 /*
 563  * cppi41_dma_ch_disable - disable Tx/Rx DMA channel in hardware
 564  */
 565 void cppi41_dma_ch_disable(struct cppi41_dma_ch_obj *dma_ch_obj)
 566 {
 567         dma_ch_obj->global_cfg &= ~DMA_CH_TX_ENABLE_MASK;
 568         __raw_writel(dma_ch_obj->global_cfg, dma_ch_obj->base_addr);
 569         DBG("Disable channel @ %p, value written: %x, value read: %x\n",
 570             dma_ch_obj->base_addr, dma_ch_obj->global_cfg,
 571             __raw_readl(dma_ch_obj->base_addr));
 572 }
 573 EXPORT_SYMBOL(cppi41_dma_ch_disable);
 574
 575 /**
 576  * alloc_queue - allocate a queue in the given range
 577  * @allocated:  pointer to the bitmap of the allocated queues
 578  * @excluded:   pointer to the bitmap of the queues excluded from allocation
 579  *              (optional)
 580  * @start:      starting queue number
 581  * @count:      number of queues available
 582  *
 583  * Returns queue number on success, -ENOSPC otherwise.
 584  */
 585 static int alloc_queue(u32 *allocated, const u32 *excluded, unsigned start,
 586                        unsigned count)
 587 {
 588         u32 bit, mask = 0;
 589         int index = -1;
 590
 591         /*
 592          * We're starting the loop as if we've just wrapped around 32 bits
 593          * in order to save on preloading the bitmasks.
 594          */
 595         for (bit = 0; count--; start++, bit <<= 1) {
 596                 /* Have we just wrapped around 32 bits? */
 597                 if (!bit) {
 598                         /* Start over with the next bitmask word */
 599                         bit = 1;
 600                         index++;
 601                         /* Have we just entered the loop? */
 602                         if (!index) {
 603                                 /* Calculate the starting values */
 604                                 bit <<= start & 0x1f;
 605                                 index = start >> 5;
 606                         }
 607                         /*
 608                          * Load the next word of the allocated bitmask OR'ing
 609                          * it with the excluded bitmask if it's been passed.
 610                          */
 611                         mask = allocated[index];
 612                         if (excluded != NULL)
 613                                 mask |= excluded[index];
 614                 }
 615                 /*
 616                  * If the bit in the combined bitmask is zero,
 617                  * we've just found a free queue.
 618                  */
 619                 if (!(mask & bit)) {
 620                         allocated[index] |= bit;
 621                         return start;
 622                 }
 623         }
 624         return -ENOSPC;
 625 }
 626
 627 /*
 628  * cppi41_queue_alloc - allocate a queue of a given type in the queue manager
 629  */
 630 int cppi41_queue_alloc(u8 type, u8 q_mgr, u16 *q_num)
 631 {
 632         int res = -ENOSPC;
 633
 634         if (q_mgr >= cppi41_num_queue_mgr)
 635                 return -EINVAL;
 636
 637         /* Mask out the unsupported queue types */
 638         type &= cppi41_queue_mgr[q_mgr].queue_types;
 639         /* First see if a free descriptor queue was requested... */
 640         if (type & CPPI41_FREE_DESC_QUEUE)
 641                 res = alloc_queue(allocated_queues[q_mgr], NULL,
 642                                   cppi41_queue_mgr[q_mgr].base_fdq_num,  16);
 643
 644         /* Then see if a free descriptor/buffer queue was requested... */
 645         if (res < 0 && (type & CPPI41_FREE_DESC_BUF_QUEUE))
 646                 res = alloc_queue(allocated_queues[q_mgr], NULL,
 647                                   cppi41_queue_mgr[q_mgr].base_fdbq_num, 16);
 648
 649         /* Last see if an unassigned queue was requested... */
 650         if (res < 0 && (type & CPPI41_UNASSIGNED_QUEUE))
 651                 res = alloc_queue(allocated_queues[q_mgr],
 652                                   cppi41_queue_mgr[q_mgr].assigned, 0,
 653                                   cppi41_queue_mgr[q_mgr].num_queue);
 654
 655         /* See if any queue was allocated... */
 656         if (res < 0)
 657                 return res;
 658
 659         /* Return the queue allocated */
 660         *q_num = res;
 661         return 0;
 662 }
 663 EXPORT_SYMBOL(cppi41_queue_alloc);
 664
 665 /*
 666  * cppi41_queue_free - free the given queue in the queue manager
 667  */
 668 int cppi41_queue_free(u8 q_mgr, u16 q_num)
 669 {
 670         int index = q_num >> 5, bit = 1 << (q_num & 0x1f);
 671
 672         if (q_mgr >= cppi41_num_queue_mgr ||
 673             q_num >= cppi41_queue_mgr[q_mgr].num_queue ||
 674             !(allocated_queues[q_mgr][index] & bit))
 675                 return -EINVAL;
 676
 677         allocated_queues[q_mgr][index] &= ~bit;
 678         return 0;
 679 }
 680 EXPORT_SYMBOL(cppi41_queue_free);
 681
 682 /*
 683  * cppi41_queue_init - initialize a CPPI 4.1 queue object
 684  */
 685 int cppi41_queue_init(struct cppi41_queue_obj *queue_obj, u8 q_mgr, u16 q_num)
 686 {
 687         if (q_mgr >= cppi41_num_queue_mgr ||
 688             q_num >= cppi41_queue_mgr[q_mgr].num_queue)
 689                 return -EINVAL;
 690
 691         queue_obj->base_addr = cppi41_queue_mgr[q_mgr].q_mgmt_rgn_base +
 692                                QMGR_QUEUE_STATUS_REG_A(q_num);
 693
 694         return 0;
 695 }
 696 EXPORT_SYMBOL(cppi41_queue_init);
 697
 698 /*
 699  * cppi41_queue_push - push a descriptor into the given queue
 700  */
 701 void cppi41_queue_push(const struct cppi41_queue_obj *queue_obj, u32 desc_addr,
 702                        u32 desc_size, u32 pkt_size)
 703 {
 704         u32 val;
 705
 706         /*
 707          * Write to the tail of the queue.
 708          * TODO: Can't think of a reason why a queue to head may be required.
 709          * If it is, the API may have to be extended.
 710          */
 711 #if 0
 712         /*
 713          * Also, can't understand why packet size is required to queue up a
 714          * descriptor. The spec says packet size *must* be written prior to
 715          * the packet write operation.
 716          */
 717         if (pkt_size)
 718                 val = (pkt_size << QMGR_QUEUE_PKT_SIZE_SHIFT) &
 719                       QMGR_QUEUE_PKT_SIZE_MASK;
 720         __raw_writel(val, queue_obj->base_addr + QMGR_QUEUE_REG_C(0));
 721 #endif
 722
 723         val = (((desc_size - 24) >> (2 - QMGR_QUEUE_DESC_SIZE_SHIFT)) &
 724                QMGR_QUEUE_DESC_SIZE_MASK) |
 725               (desc_addr & QMGR_QUEUE_DESC_PTR_MASK);
 726
 727         DBG("Pushing value %x to queue @ %p\n", val, queue_obj->base_addr);
 728
 729         __raw_writel(val, queue_obj->base_addr + QMGR_QUEUE_REG_D(0));
 730 }
 731 EXPORT_SYMBOL(cppi41_queue_push);
 732
 733 /*
 734  * cppi41_queue_pop - pop a descriptor from a given queue
 735  */
 736 unsigned long cppi41_queue_pop(const struct cppi41_queue_obj *queue_obj)
 737 {
 738         u32 val = __raw_readl(queue_obj->base_addr + QMGR_QUEUE_REG_D(0));
 739
 740         DBG("Popping value %x from queue @ %p\n", val, queue_obj->base_addr);
 741
 742         return val & QMGR_QUEUE_DESC_PTR_MASK;
 743 }
 744 EXPORT_SYMBOL(cppi41_queue_pop);
 745
 746 /*
 747  * cppi41_get_teardown_info - extract information from a teardown descriptor
 748  */
 749 int cppi41_get_teardown_info(unsigned long addr, u32 *info)
 750 {
 751         struct cppi41_teardown_desc *desc;
 752         int dma_num;
 753
 754         for (dma_num = 0; dma_num < cppi41_num_dma_block; dma_num++)
 755                 if (addr >= dma_teardown[dma_num].phys_addr &&
 756                     addr <  dma_teardown[dma_num].phys_addr +
 757                             dma_teardown[dma_num].rgn_size)
 758                         break;
 759
 760         if (dma_num == cppi41_num_dma_block)
 761                 return -EINVAL;
 762
 763         desc = addr - dma_teardown[dma_num].phys_addr +
 764                dma_teardown[dma_num].virt_addr;
 765
 766         if ((desc->teardown_info & CPPI41_DESC_TYPE_MASK) !=
 767             (CPPI41_DESC_TYPE_TEARDOWN << CPPI41_DESC_TYPE_SHIFT))
 768                 return -EINVAL;
 769
 770         *info = desc->teardown_info;
 771 #if 1
 772         /* Hardware is not giving the current DMA number as of now. :-/ */
 773         *info |= (dma_num << CPPI41_TEARDOWN_DMA_NUM_SHIFT) &
 774                  CPPI41_TEARDOWN_DMA_NUM_MASK;
 775 #else
 776         dma_num = (desc->teardown_info & CPPI41_TEARDOWN_DMA_NUM_MASK) >>
 777                  CPPI41_TEARDOWN_DMA_NUM_SHIFT;
 778 #endif
 779
 780         cppi41_queue_push(&dma_teardown[dma_num].queue_obj, addr,
 781                           sizeof(struct cppi41_teardown_desc), 0);
 782
 783         return 0;
 784 }
 785 EXPORT_SYMBOL(cppi41_get_teardown_info);
 786
 787 MODULE_DESCRIPTION("TI CPPI 4.1 support");
 788 MODULE_AUTHOR("MontaVista Software");
 789 MODULE_LICENSE("GPL");