498f858c249c999518c409aafa9b0c8714ffa569
[sitara-epos/sitara-epos-kernel.git] / 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  */
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>
33 #include "cppi41.h"
35 #undef  CPPI41_DEBUG
37 #ifdef  CPPI41_DEBUG
38 #define DBG(format, args...) printk(format, ##args)
39 #else
40 #define DBG(format, args...)
41 #endif
43 static struct {
44         void *virt_addr;
45         dma_addr_t phys_addr;
46 } linking_ram[CPPI41_NUM_QUEUE_MGR];
48 static u32 *allocated_queues[CPPI41_NUM_QUEUE_MGR];
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];
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];
62 /******************** CPPI 4.1 Functions (External Interface) *****************/
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;
69         if (q_mgr >= cppi41_num_queue_mgr)
70                 return -EINVAL;
72         q_mgr_regs = cppi41_queue_mgr[q_mgr].q_mgr_rgn_base;
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));
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));
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;
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));
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;
112         return 0;
115 int __init cppi41_dma_block_init(u8 dma_num, u8 q_mgr, u8 num_order,
116                                  u8 *sched_tbl, u8 tbl_size)
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;
127         if (dma_num >= cppi41_num_dma_block ||
128             q_mgr >= cppi41_num_queue_mgr ||
129             !tbl_size || sched_tbl == NULL)
130                 return -EINVAL;
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);
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));
156         num_desc = 1 << num_order;
157         dma_teardown[dma_num].rgn_size = num_desc *
158                                          sizeof(struct cppi41_teardown_desc);
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;
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         }
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         }
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;
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         }
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                 }
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         }
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));
223         return 0;
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;
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)
242         void __iomem *desc_mem_regs;
243         u32 num_desc = 1 << num_order, index, ctrl;
244         int rgn;
246         DBG("%s called with rgn_addr = %08x, size_order = %d, num_order = %d\n",
247             __func__, rgn_addr, size_order, num_order);
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;
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;
260         next_mem_rgn[q_mgr] = rgn + 1;
261         next_desc_index[q_mgr] = index + num_desc;
263         desc_mem_regs = cppi41_queue_mgr[q_mgr].desc_mem_rgn_base;
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)));
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)));
283         *mem_rgn = rgn;
284         return 0;
286 EXPORT_SYMBOL(cppi41_mem_rgn_alloc);
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)
293         void __iomem *desc_mem_regs;
295         DBG("%s called.\n", __func__);
297         if (q_mgr >= cppi41_num_queue_mgr || mem_rgn >= next_mem_rgn[q_mgr])
298                 return -EINVAL;
300         desc_mem_regs = cppi41_queue_mgr[q_mgr].desc_mem_rgn_base;
302         if (__raw_readl(desc_mem_regs + QMGR_MEM_RGN_BASE_REG(mem_rgn)) == 0)
303                 return -ENOENT;
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));
308         return 0;
310 EXPORT_SYMBOL(cppi41_mem_rgn_free);
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)
321         if (dma_num >= cppi41_num_dma_block ||
322             ch_num  >= cppi41_dma_block[dma_num].num_tx_ch)
323                 return -EINVAL;
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;
331 EXPORT_SYMBOL(cppi41_tx_ch_init);
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)
342         if (dma_num >= cppi41_num_dma_block ||
343             ch_num  >= cppi41_dma_block[dma_num].num_rx_ch)
344                 return -EINVAL;
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;
352 EXPORT_SYMBOL(cppi41_rx_ch_init);
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  */
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)
369         u32 val = dma_ch_obj->global_cfg;
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);
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);
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));
389 EXPORT_SYMBOL(cppi41_dma_ch_default_queue);
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)
397         void __iomem *base = rx_ch_obj->base_addr;
398         u32 val = __raw_readl(rx_ch_obj->base_addr);
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);
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));
416         base -= DMA_CH_RX_GLOBAL_CFG_REG(0);
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);
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);
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));
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));
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);
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));
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);
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         }
527 EXPORT_SYMBOL(cppi41_rx_ch_configure);
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)
534         u32 val = __raw_readl(dma_ch_obj->base_addr);
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));
543 EXPORT_SYMBOL(cppi41_dma_ch_teardown);
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)
552         u32 val = dma_ch_obj->global_cfg | DMA_CH_TX_ENABLE_MASK;
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));
560 EXPORT_SYMBOL(cppi41_dma_ch_enable);
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)
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));
573 EXPORT_SYMBOL(cppi41_dma_ch_disable);
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)
588         u32 bit, mask = 0;
589         int index = -1;
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;
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)
632         int res = -ENOSPC;
634         if (q_mgr >= cppi41_num_queue_mgr)
635                 return -EINVAL;
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);
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);
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);
655         /* See if any queue was allocated... */
656         if (res < 0)
657                 return res;
659         /* Return the queue allocated */
660         *q_num = res;
661         return 0;
663 EXPORT_SYMBOL(cppi41_queue_alloc);
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)
670         int index = q_num >> 5, bit = 1 << (q_num & 0x1f);
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;
677         allocated_queues[q_mgr][index] &= ~bit;
678         return 0;
680 EXPORT_SYMBOL(cppi41_queue_free);
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)
687         if (q_mgr >= cppi41_num_queue_mgr ||
688             q_num >= cppi41_queue_mgr[q_mgr].num_queue)
689                 return -EINVAL;
691         queue_obj->base_addr = cppi41_queue_mgr[q_mgr].q_mgmt_rgn_base +
692                                QMGR_QUEUE_STATUS_REG_A(q_num);
694         return 0;
696 EXPORT_SYMBOL(cppi41_queue_init);
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)
704         u32 val;
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
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);
727         DBG("Pushing value %x to queue @ %p\n", val, queue_obj->base_addr);
729         __raw_writel(val, queue_obj->base_addr + QMGR_QUEUE_REG_D(0));
731 EXPORT_SYMBOL(cppi41_queue_push);
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)
738         u32 val = __raw_readl(queue_obj->base_addr + QMGR_QUEUE_REG_D(0));
740         DBG("Popping value %x from queue @ %p\n", val, queue_obj->base_addr);
742         return val & QMGR_QUEUE_DESC_PTR_MASK;
744 EXPORT_SYMBOL(cppi41_queue_pop);
746 /*
747  * cppi41_get_teardown_info - extract information from a teardown descriptor
748  */
749 int cppi41_get_teardown_info(unsigned long addr, u32 *info)
751         struct cppi41_teardown_desc *desc;
752         int dma_num;
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;
760         if (dma_num == cppi41_num_dma_block)
761                 return -EINVAL;
763         desc = addr - dma_teardown[dma_num].phys_addr +
764                dma_teardown[dma_num].virt_addr;
766         if ((desc->teardown_info & CPPI41_DESC_TYPE_MASK) !=
767             (CPPI41_DESC_TYPE_TEARDOWN << CPPI41_DESC_TYPE_SHIFT))
768                 return -EINVAL;
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
780         cppi41_queue_push(&dma_teardown[dma_num].queue_obj, addr,
781                           sizeof(struct cppi41_teardown_desc), 0);
783         return 0;
785 EXPORT_SYMBOL(cppi41_get_teardown_info);
787 MODULE_DESCRIPTION("TI CPPI 4.1 support");
788 MODULE_AUTHOR("MontaVista Software");
789 MODULE_LICENSE("GPL");