Merge branch 'linux-2.6' into for-linus
[linux-2.6.git] / arch / powerpc / sysdev / qe_lib / qe.c
1 /*
2  * Copyright (C) 2006 Freescale Semicondutor, Inc. All rights reserved.
3  *
4  * Authors:     Shlomi Gridish <gridish@freescale.com>
5  *              Li Yang <leoli@freescale.com>
6  * Based on cpm2_common.c from Dan Malek (dmalek@jlc.net)
7  *
8  * Description:
9  * General Purpose functions for the global management of the
10  * QUICC Engine (QE).
11  *
12  * This program is free software; you can redistribute  it and/or modify it
13  * under  the terms of  the GNU General  Public License as published by the
14  * Free Software Foundation;  either version 2 of the  License, or (at your
15  * option) any later version.
16  */
17 #include <linux/errno.h>
18 #include <linux/sched.h>
19 #include <linux/kernel.h>
20 #include <linux/param.h>
21 #include <linux/string.h>
22 #include <linux/mm.h>
23 #include <linux/interrupt.h>
24 #include <linux/bootmem.h>
25 #include <linux/module.h>
26 #include <linux/delay.h>
27 #include <linux/ioport.h>
28 #include <asm/irq.h>
29 #include <asm/page.h>
30 #include <asm/pgtable.h>
31 #include <asm/immap_qe.h>
32 #include <asm/qe.h>
33 #include <asm/prom.h>
34 #include <asm/rheap.h>
35
36 static void qe_snums_init(void);
37 static void qe_muram_init(void);
38 static int qe_sdma_init(void);
39
40 static DEFINE_SPINLOCK(qe_lock);
41
42 /* QE snum state */
43 enum qe_snum_state {
44         QE_SNUM_STATE_USED,
45         QE_SNUM_STATE_FREE
46 };
47
48 /* QE snum */
49 struct qe_snum {
50         u8 num;
51         enum qe_snum_state state;
52 };
53
54 /* We allocate this here because it is used almost exclusively for
55  * the communication processor devices.
56  */
57 struct qe_immap *qe_immr = NULL;
58 EXPORT_SYMBOL(qe_immr);
59
60 static struct qe_snum snums[QE_NUM_OF_SNUM];    /* Dynamically allocated SNUMs */
61
62 static phys_addr_t qebase = -1;
63
64 phys_addr_t get_qe_base(void)
65 {
66         struct device_node *qe;
67
68         if (qebase != -1)
69                 return qebase;
70
71         qe = of_find_node_by_type(NULL, "qe");
72         if (qe) {
73                 unsigned int size;
74                 const void *prop = get_property(qe, "reg", &size);
75                 qebase = of_translate_address(qe, prop);
76                 of_node_put(qe);
77         };
78
79         return qebase;
80 }
81
82 EXPORT_SYMBOL(get_qe_base);
83
84 void qe_reset(void)
85 {
86         if (qe_immr == NULL)
87                 qe_immr = ioremap(get_qe_base(), QE_IMMAP_SIZE);
88
89         qe_snums_init();
90
91         qe_issue_cmd(QE_RESET, QE_CR_SUBBLOCK_INVALID,
92                      QE_CR_PROTOCOL_UNSPECIFIED, 0);
93
94         /* Reclaim the MURAM memory for our use. */
95         qe_muram_init();
96
97         if (qe_sdma_init())
98                 panic("sdma init failed!");
99 }
100
101 int qe_issue_cmd(u32 cmd, u32 device, u8 mcn_protocol, u32 cmd_input)
102 {
103         unsigned long flags;
104         u8 mcn_shift = 0, dev_shift = 0;
105
106         spin_lock_irqsave(&qe_lock, flags);
107         if (cmd == QE_RESET) {
108                 out_be32(&qe_immr->cp.cecr, (u32) (cmd | QE_CR_FLG));
109         } else {
110                 if (cmd == QE_ASSIGN_PAGE) {
111                         /* Here device is the SNUM, not sub-block */
112                         dev_shift = QE_CR_SNUM_SHIFT;
113                 } else if (cmd == QE_ASSIGN_RISC) {
114                         /* Here device is the SNUM, and mcnProtocol is
115                          * e_QeCmdRiscAssignment value */
116                         dev_shift = QE_CR_SNUM_SHIFT;
117                         mcn_shift = QE_CR_MCN_RISC_ASSIGN_SHIFT;
118                 } else {
119                         if (device == QE_CR_SUBBLOCK_USB)
120                                 mcn_shift = QE_CR_MCN_USB_SHIFT;
121                         else
122                                 mcn_shift = QE_CR_MCN_NORMAL_SHIFT;
123                 }
124
125                 out_be32(&qe_immr->cp.cecdr, cmd_input);
126                 out_be32(&qe_immr->cp.cecr,
127                          (cmd | QE_CR_FLG | ((u32) device << dev_shift) | (u32)
128                           mcn_protocol << mcn_shift));
129         }
130
131         /* wait for the QE_CR_FLG to clear */
132         while(in_be32(&qe_immr->cp.cecr) & QE_CR_FLG)
133                 cpu_relax();
134         spin_unlock_irqrestore(&qe_lock, flags);
135
136         return 0;
137 }
138 EXPORT_SYMBOL(qe_issue_cmd);
139
140 /* Set a baud rate generator. This needs lots of work. There are
141  * 16 BRGs, which can be connected to the QE channels or output
142  * as clocks. The BRGs are in two different block of internal
143  * memory mapped space.
144  * The baud rate clock is the system clock divided by something.
145  * It was set up long ago during the initial boot phase and is
146  * is given to us.
147  * Baud rate clocks are zero-based in the driver code (as that maps
148  * to port numbers). Documentation uses 1-based numbering.
149  */
150 static unsigned int brg_clk = 0;
151
152 unsigned int get_brg_clk(void)
153 {
154         struct device_node *qe;
155         if (brg_clk)
156                 return brg_clk;
157
158         qe = of_find_node_by_type(NULL, "qe");
159         if (qe) {
160                 unsigned int size;
161                 const u32 *prop = get_property(qe, "brg-frequency", &size);
162                 brg_clk = *prop;
163                 of_node_put(qe);
164         };
165         return brg_clk;
166 }
167
168 /* This function is used by UARTS, or anything else that uses a 16x
169  * oversampled clock.
170  */
171 void qe_setbrg(u32 brg, u32 rate)
172 {
173         volatile u32 *bp;
174         u32 divisor, tempval;
175         int div16 = 0;
176
177         bp = &qe_immr->brg.brgc[brg];
178
179         divisor = (get_brg_clk() / rate);
180         if (divisor > QE_BRGC_DIVISOR_MAX + 1) {
181                 div16 = 1;
182                 divisor /= 16;
183         }
184
185         tempval = ((divisor - 1) << QE_BRGC_DIVISOR_SHIFT) | QE_BRGC_ENABLE;
186         if (div16)
187                 tempval |= QE_BRGC_DIV16;
188
189         out_be32(bp, tempval);
190 }
191
192 /* Initialize SNUMs (thread serial numbers) according to
193  * QE Module Control chapter, SNUM table
194  */
195 static void qe_snums_init(void)
196 {
197         int i;
198         static const u8 snum_init[] = {
199                 0x04, 0x05, 0x0C, 0x0D, 0x14, 0x15, 0x1C, 0x1D,
200                 0x24, 0x25, 0x2C, 0x2D, 0x34, 0x35, 0x88, 0x89,
201                 0x98, 0x99, 0xA8, 0xA9, 0xB8, 0xB9, 0xC8, 0xC9,
202                 0xD8, 0xD9, 0xE8, 0xE9,
203         };
204
205         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
206                 snums[i].num = snum_init[i];
207                 snums[i].state = QE_SNUM_STATE_FREE;
208         }
209 }
210
211 int qe_get_snum(void)
212 {
213         unsigned long flags;
214         int snum = -EBUSY;
215         int i;
216
217         spin_lock_irqsave(&qe_lock, flags);
218         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
219                 if (snums[i].state == QE_SNUM_STATE_FREE) {
220                         snums[i].state = QE_SNUM_STATE_USED;
221                         snum = snums[i].num;
222                         break;
223                 }
224         }
225         spin_unlock_irqrestore(&qe_lock, flags);
226
227         return snum;
228 }
229 EXPORT_SYMBOL(qe_get_snum);
230
231 void qe_put_snum(u8 snum)
232 {
233         int i;
234
235         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
236                 if (snums[i].num == snum) {
237                         snums[i].state = QE_SNUM_STATE_FREE;
238                         break;
239                 }
240         }
241 }
242 EXPORT_SYMBOL(qe_put_snum);
243
244 static int qe_sdma_init(void)
245 {
246         struct sdma *sdma = &qe_immr->sdma;
247         u32 sdma_buf_offset;
248
249         if (!sdma)
250                 return -ENODEV;
251
252         /* allocate 2 internal temporary buffers (512 bytes size each) for
253          * the SDMA */
254         sdma_buf_offset = qe_muram_alloc(512 * 2, 64);
255         if (IS_MURAM_ERR(sdma_buf_offset))
256                 return -ENOMEM;
257
258         out_be32(&sdma->sdebcr, sdma_buf_offset & QE_SDEBCR_BA_MASK);
259         out_be32(&sdma->sdmr, (QE_SDMR_GLB_1_MSK | (0x1 >>
260                                         QE_SDMR_CEN_SHIFT)));
261
262         return 0;
263 }
264
265 /*
266  * muram_alloc / muram_free bits.
267  */
268 static DEFINE_SPINLOCK(qe_muram_lock);
269
270 /* 16 blocks should be enough to satisfy all requests
271  * until the memory subsystem goes up... */
272 static rh_block_t qe_boot_muram_rh_block[16];
273 static rh_info_t qe_muram_info;
274
275 static void qe_muram_init(void)
276 {
277         struct device_node *np;
278         u32 address;
279         u64 size;
280         unsigned int flags;
281
282         /* initialize the info header */
283         rh_init(&qe_muram_info, 1,
284                 sizeof(qe_boot_muram_rh_block) /
285                 sizeof(qe_boot_muram_rh_block[0]), qe_boot_muram_rh_block);
286
287         /* Attach the usable muram area */
288         /* XXX: This is a subset of the available muram. It
289          * varies with the processor and the microcode patches activated.
290          */
291         if ((np = of_find_node_by_name(NULL, "data-only")) != NULL) {
292                 address = *of_get_address(np, 0, &size, &flags);
293                 of_node_put(np);
294                 rh_attach_region(&qe_muram_info,
295                         (void *)address, (int)size);
296         }
297 }
298
299 /* This function returns an index into the MURAM area.
300  */
301 u32 qe_muram_alloc(u32 size, u32 align)
302 {
303         void *start;
304         unsigned long flags;
305
306         spin_lock_irqsave(&qe_muram_lock, flags);
307         start = rh_alloc_align(&qe_muram_info, size, align, "QE");
308         spin_unlock_irqrestore(&qe_muram_lock, flags);
309
310         return (u32) start;
311 }
312 EXPORT_SYMBOL(qe_muram_alloc);
313
314 int qe_muram_free(u32 offset)
315 {
316         int ret;
317         unsigned long flags;
318
319         spin_lock_irqsave(&qe_muram_lock, flags);
320         ret = rh_free(&qe_muram_info, (void *)offset);
321         spin_unlock_irqrestore(&qe_muram_lock, flags);
322
323         return ret;
324 }
325 EXPORT_SYMBOL(qe_muram_free);
326
327 /* not sure if this is ever needed */
328 u32 qe_muram_alloc_fixed(u32 offset, u32 size)
329 {
330         void *start;
331         unsigned long flags;
332
333         spin_lock_irqsave(&qe_muram_lock, flags);
334         start = rh_alloc_fixed(&qe_muram_info, (void *)offset, size, "commproc");
335         spin_unlock_irqrestore(&qe_muram_lock, flags);
336
337         return (u32) start;
338 }
339 EXPORT_SYMBOL(qe_muram_alloc_fixed);
340
341 void qe_muram_dump(void)
342 {
343         rh_dump(&qe_muram_info);
344 }
345 EXPORT_SYMBOL(qe_muram_dump);
346
347 void *qe_muram_addr(u32 offset)
348 {
349         return (void *)&qe_immr->muram[offset];
350 }
351 EXPORT_SYMBOL(qe_muram_addr);