Merge branch 'linux-next' of git://git.infradead.org/~dedekind/ubi-2.6
[linux-2.6] / arch / powerpc / sysdev / bestcomm / gen_bd.c
1 /*
2  * Driver for MPC52xx processor BestComm General Buffer Descriptor
3  *
4  * Copyright (C) 2007 Sylvain Munaut <tnt@246tNt.com>
5  * Copyright (C) 2006 AppSpec Computer Technologies Corp.
6  *                    Jeff Gibbons <jeff.gibbons@appspec.com>
7  *
8  * This program is free software; you can redistribute  it and/or modify it
9  * under the terms of the GNU General Public License version 2 as published
10  * by the Free Software Foundation.
11  *
12  */
13
14 #include <linux/version.h>
15 #include <linux/module.h>
16 #include <linux/kernel.h>
17 #include <linux/string.h>
18 #include <linux/types.h>
19 #include <asm/errno.h>
20 #include <asm/io.h>
21
22 #include <asm/mpc52xx.h>
23 #include <asm/mpc52xx_psc.h>
24
25 #include "bestcomm.h"
26 #include "bestcomm_priv.h"
27 #include "gen_bd.h"
28
29
30 /* ======================================================================== */
31 /* Task image/var/inc                                                       */
32 /* ======================================================================== */
33
34 /* gen_bd tasks images */
35 extern u32 bcom_gen_bd_rx_task[];
36 extern u32 bcom_gen_bd_tx_task[];
37
38 /* rx task vars that need to be set before enabling the task */
39 struct bcom_gen_bd_rx_var {
40         u32 enable;             /* (u16*) address of task's control register */
41         u32 fifo;               /* (u32*) address of gen_bd's fifo */
42         u32 bd_base;            /* (struct bcom_bd*) beginning of ring buffer */
43         u32 bd_last;            /* (struct bcom_bd*) end of ring buffer */
44         u32 bd_start;           /* (struct bcom_bd*) current bd */
45         u32 buffer_size;        /* size of receive buffer */
46 };
47
48 /* rx task incs that need to be set before enabling the task */
49 struct bcom_gen_bd_rx_inc {
50         u16 pad0;
51         s16 incr_bytes;
52         u16 pad1;
53         s16 incr_dst;
54 };
55
56 /* tx task vars that need to be set before enabling the task */
57 struct bcom_gen_bd_tx_var {
58         u32 fifo;               /* (u32*) address of gen_bd's fifo */
59         u32 enable;             /* (u16*) address of task's control register */
60         u32 bd_base;            /* (struct bcom_bd*) beginning of ring buffer */
61         u32 bd_last;            /* (struct bcom_bd*) end of ring buffer */
62         u32 bd_start;           /* (struct bcom_bd*) current bd */
63         u32 buffer_size;        /* set by uCode for each packet */
64 };
65
66 /* tx task incs that need to be set before enabling the task */
67 struct bcom_gen_bd_tx_inc {
68         u16 pad0;
69         s16 incr_bytes;
70         u16 pad1;
71         s16 incr_src;
72         u16 pad2;
73         s16 incr_src_ma;
74 };
75
76 /* private structure */
77 struct bcom_gen_bd_priv {
78         phys_addr_t     fifo;
79         int             initiator;
80         int             ipr;
81         int             maxbufsize;
82 };
83
84
85 /* ======================================================================== */
86 /* Task support code                                                        */
87 /* ======================================================================== */
88
89 struct bcom_task *
90 bcom_gen_bd_rx_init(int queue_len, phys_addr_t fifo,
91                         int initiator, int ipr, int maxbufsize)
92 {
93         struct bcom_task *tsk;
94         struct bcom_gen_bd_priv *priv;
95
96         tsk = bcom_task_alloc(queue_len, sizeof(struct bcom_gen_bd),
97                         sizeof(struct bcom_gen_bd_priv));
98         if (!tsk)
99                 return NULL;
100
101         tsk->flags = BCOM_FLAGS_NONE;
102
103         priv = tsk->priv;
104         priv->fifo      = fifo;
105         priv->initiator = initiator;
106         priv->ipr       = ipr;
107         priv->maxbufsize = maxbufsize;
108
109         if (bcom_gen_bd_rx_reset(tsk)) {
110                 bcom_task_free(tsk);
111                 return NULL;
112         }
113
114         return tsk;
115 }
116 EXPORT_SYMBOL_GPL(bcom_gen_bd_rx_init);
117
118 int
119 bcom_gen_bd_rx_reset(struct bcom_task *tsk)
120 {
121         struct bcom_gen_bd_priv *priv = tsk->priv;
122         struct bcom_gen_bd_rx_var *var;
123         struct bcom_gen_bd_rx_inc *inc;
124
125         /* Shutdown the task */
126         bcom_disable_task(tsk->tasknum);
127
128         /* Reset the microcode */
129         var = (struct bcom_gen_bd_rx_var *) bcom_task_var(tsk->tasknum);
130         inc = (struct bcom_gen_bd_rx_inc *) bcom_task_inc(tsk->tasknum);
131
132         if (bcom_load_image(tsk->tasknum, bcom_gen_bd_rx_task))
133                 return -1;
134
135         var->enable     = bcom_eng->regs_base +
136                                 offsetof(struct mpc52xx_sdma, tcr[tsk->tasknum]);
137         var->fifo       = (u32) priv->fifo;
138         var->bd_base    = tsk->bd_pa;
139         var->bd_last    = tsk->bd_pa + ((tsk->num_bd-1) * tsk->bd_size);
140         var->bd_start   = tsk->bd_pa;
141         var->buffer_size = priv->maxbufsize;
142
143         inc->incr_bytes = -(s16)sizeof(u32);
144         inc->incr_dst   = sizeof(u32);
145
146         /* Reset the BDs */
147         tsk->index = 0;
148         tsk->outdex = 0;
149
150         memset(tsk->bd, 0x00, tsk->num_bd * tsk->bd_size);
151
152         /* Configure some stuff */
153         bcom_set_task_pragma(tsk->tasknum, BCOM_GEN_RX_BD_PRAGMA);
154         bcom_set_task_auto_start(tsk->tasknum, tsk->tasknum);
155
156         out_8(&bcom_eng->regs->ipr[priv->initiator], priv->ipr);
157         bcom_set_initiator(tsk->tasknum, priv->initiator);
158
159         out_be32(&bcom_eng->regs->IntPend, 1<<tsk->tasknum);    /* Clear ints */
160
161         return 0;
162 }
163 EXPORT_SYMBOL_GPL(bcom_gen_bd_rx_reset);
164
165 void
166 bcom_gen_bd_rx_release(struct bcom_task *tsk)
167 {
168         /* Nothing special for the GenBD tasks */
169         bcom_task_free(tsk);
170 }
171 EXPORT_SYMBOL_GPL(bcom_gen_bd_rx_release);
172
173
174 extern struct bcom_task *
175 bcom_gen_bd_tx_init(int queue_len, phys_addr_t fifo,
176                         int initiator, int ipr)
177 {
178         struct bcom_task *tsk;
179         struct bcom_gen_bd_priv *priv;
180
181         tsk = bcom_task_alloc(queue_len, sizeof(struct bcom_gen_bd),
182                         sizeof(struct bcom_gen_bd_priv));
183         if (!tsk)
184                 return NULL;
185
186         tsk->flags = BCOM_FLAGS_NONE;
187
188         priv = tsk->priv;
189         priv->fifo      = fifo;
190         priv->initiator = initiator;
191         priv->ipr       = ipr;
192
193         if (bcom_gen_bd_tx_reset(tsk)) {
194                 bcom_task_free(tsk);
195                 return NULL;
196         }
197
198         return tsk;
199 }
200 EXPORT_SYMBOL_GPL(bcom_gen_bd_tx_init);
201
202 int
203 bcom_gen_bd_tx_reset(struct bcom_task *tsk)
204 {
205         struct bcom_gen_bd_priv *priv = tsk->priv;
206         struct bcom_gen_bd_tx_var *var;
207         struct bcom_gen_bd_tx_inc *inc;
208
209         /* Shutdown the task */
210         bcom_disable_task(tsk->tasknum);
211
212         /* Reset the microcode */
213         var = (struct bcom_gen_bd_tx_var *) bcom_task_var(tsk->tasknum);
214         inc = (struct bcom_gen_bd_tx_inc *) bcom_task_inc(tsk->tasknum);
215
216         if (bcom_load_image(tsk->tasknum, bcom_gen_bd_tx_task))
217                 return -1;
218
219         var->enable     = bcom_eng->regs_base +
220                                 offsetof(struct mpc52xx_sdma, tcr[tsk->tasknum]);
221         var->fifo       = (u32) priv->fifo;
222         var->bd_base    = tsk->bd_pa;
223         var->bd_last    = tsk->bd_pa + ((tsk->num_bd-1) * tsk->bd_size);
224         var->bd_start   = tsk->bd_pa;
225
226         inc->incr_bytes = -(s16)sizeof(u32);
227         inc->incr_src   = sizeof(u32);
228         inc->incr_src_ma = sizeof(u8);
229
230         /* Reset the BDs */
231         tsk->index = 0;
232         tsk->outdex = 0;
233
234         memset(tsk->bd, 0x00, tsk->num_bd * tsk->bd_size);
235
236         /* Configure some stuff */
237         bcom_set_task_pragma(tsk->tasknum, BCOM_GEN_TX_BD_PRAGMA);
238         bcom_set_task_auto_start(tsk->tasknum, tsk->tasknum);
239
240         out_8(&bcom_eng->regs->ipr[priv->initiator], priv->ipr);
241         bcom_set_initiator(tsk->tasknum, priv->initiator);
242
243         out_be32(&bcom_eng->regs->IntPend, 1<<tsk->tasknum);    /* Clear ints */
244
245         return 0;
246 }
247 EXPORT_SYMBOL_GPL(bcom_gen_bd_tx_reset);
248
249 void
250 bcom_gen_bd_tx_release(struct bcom_task *tsk)
251 {
252         /* Nothing special for the GenBD tasks */
253         bcom_task_free(tsk);
254 }
255 EXPORT_SYMBOL_GPL(bcom_gen_bd_tx_release);
256
257 /* ---------------------------------------------------------------------
258  * PSC support code
259  */
260
261 /**
262  * bcom_psc_parameters - Bestcomm initialization value table for PSC devices
263  *
264  * This structure is only used internally.  It is a lookup table for PSC
265  * specific parameters to bestcomm tasks.
266  */
267 static struct bcom_psc_params {
268         int rx_initiator;
269         int rx_ipr;
270         int tx_initiator;
271         int tx_ipr;
272 } bcom_psc_params[] = {
273         [0] = {
274                 .rx_initiator = BCOM_INITIATOR_PSC1_RX,
275                 .rx_ipr = BCOM_IPR_PSC1_RX,
276                 .tx_initiator = BCOM_INITIATOR_PSC1_TX,
277                 .tx_ipr = BCOM_IPR_PSC1_TX,
278         },
279         [1] = {
280                 .rx_initiator = BCOM_INITIATOR_PSC2_RX,
281                 .rx_ipr = BCOM_IPR_PSC2_RX,
282                 .tx_initiator = BCOM_INITIATOR_PSC2_TX,
283                 .tx_ipr = BCOM_IPR_PSC2_TX,
284         },
285         [2] = {
286                 .rx_initiator = BCOM_INITIATOR_PSC3_RX,
287                 .rx_ipr = BCOM_IPR_PSC3_RX,
288                 .tx_initiator = BCOM_INITIATOR_PSC3_TX,
289                 .tx_ipr = BCOM_IPR_PSC3_TX,
290         },
291         [3] = {
292                 .rx_initiator = BCOM_INITIATOR_PSC4_RX,
293                 .rx_ipr = BCOM_IPR_PSC4_RX,
294                 .tx_initiator = BCOM_INITIATOR_PSC4_TX,
295                 .tx_ipr = BCOM_IPR_PSC4_TX,
296         },
297         [4] = {
298                 .rx_initiator = BCOM_INITIATOR_PSC5_RX,
299                 .rx_ipr = BCOM_IPR_PSC5_RX,
300                 .tx_initiator = BCOM_INITIATOR_PSC5_TX,
301                 .tx_ipr = BCOM_IPR_PSC5_TX,
302         },
303         [5] = {
304                 .rx_initiator = BCOM_INITIATOR_PSC6_RX,
305                 .rx_ipr = BCOM_IPR_PSC6_RX,
306                 .tx_initiator = BCOM_INITIATOR_PSC6_TX,
307                 .tx_ipr = BCOM_IPR_PSC6_TX,
308         },
309 };
310
311 /**
312  * bcom_psc_gen_bd_rx_init - Allocate a receive bcom_task for a PSC port
313  * @psc_num:    Number of the PSC to allocate a task for
314  * @queue_len:  number of buffer descriptors to allocate for the task
315  * @fifo:       physical address of FIFO register
316  * @maxbufsize: Maximum receive data size in bytes.
317  *
318  * Allocate a bestcomm task structure for receiving data from a PSC.
319  */
320 struct bcom_task * bcom_psc_gen_bd_rx_init(unsigned psc_num, int queue_len,
321                                            phys_addr_t fifo, int maxbufsize)
322 {
323         if (psc_num >= MPC52xx_PSC_MAXNUM)
324                 return NULL;
325
326         return bcom_gen_bd_rx_init(queue_len, fifo,
327                                    bcom_psc_params[psc_num].rx_initiator,
328                                    bcom_psc_params[psc_num].rx_ipr,
329                                    maxbufsize);
330 }
331 EXPORT_SYMBOL_GPL(bcom_psc_gen_bd_rx_init);
332
333 /**
334  * bcom_psc_gen_bd_tx_init - Allocate a transmit bcom_task for a PSC port
335  * @psc_num:    Number of the PSC to allocate a task for
336  * @queue_len:  number of buffer descriptors to allocate for the task
337  * @fifo:       physical address of FIFO register
338  *
339  * Allocate a bestcomm task structure for transmitting data to a PSC.
340  */
341 struct bcom_task *
342 bcom_psc_gen_bd_tx_init(unsigned psc_num, int queue_len, phys_addr_t fifo)
343 {
344         struct psc;
345         return bcom_gen_bd_tx_init(queue_len, fifo,
346                                    bcom_psc_params[psc_num].tx_initiator,
347                                    bcom_psc_params[psc_num].tx_ipr);
348 }
349 EXPORT_SYMBOL_GPL(bcom_psc_gen_bd_tx_init);
350
351
352 MODULE_DESCRIPTION("BestComm General Buffer Descriptor tasks driver");
353 MODULE_AUTHOR("Jeff Gibbons <jeff.gibbons@appspec.com>");
354 MODULE_LICENSE("GPL v2");
355