[POWERPC] qe: add function qe_clock_source()
[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 = of_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 BRG clock is the QE clock divided by 2.
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 = of_get_property(qe, "brg-frequency", &size);
162                 brg_clk = *prop;
163                 of_node_put(qe);
164         };
165         return brg_clk;
166 }
167
168 /* Program the BRG to the given sampling rate and multiplier
169  *
170  * @brg: the BRG, QE_BRG1 - QE_BRG16
171  * @rate: the desired sampling rate
172  * @multiplier: corresponds to the value programmed in GUMR_L[RDCR] or
173  * GUMR_L[TDCR].  E.g., if this BRG is the RX clock, and GUMR_L[RDCR]=01,
174  * then 'multiplier' should be 8.
175  */
176 int qe_setbrg(enum qe_clock brg, unsigned int rate, unsigned int multiplier)
177 {
178         u32 divisor, tempval;
179         u32 div16 = 0;
180
181         if ((brg < QE_BRG1) || (brg > QE_BRG16))
182                 return -EINVAL;
183
184         divisor = get_brg_clk() / (rate * multiplier);
185
186         if (divisor > QE_BRGC_DIVISOR_MAX + 1) {
187                 div16 = QE_BRGC_DIV16;
188                 divisor /= 16;
189         }
190
191         /* Errata QE_General4, which affects some MPC832x and MPC836x SOCs, says
192            that the BRG divisor must be even if you're not using divide-by-16
193            mode. */
194         if (!div16 && (divisor & 1))
195                 divisor++;
196
197         tempval = ((divisor - 1) << QE_BRGC_DIVISOR_SHIFT) |
198                 QE_BRGC_ENABLE | div16;
199
200         out_be32(&qe_immr->brg.brgc[brg - QE_BRG1], tempval);
201
202         return 0;
203 }
204 EXPORT_SYMBOL(qe_setbrg);
205
206 /* Convert a string to a QE clock source enum
207  *
208  * This function takes a string, typically from a property in the device
209  * tree, and returns the corresponding "enum qe_clock" value.
210 */
211 enum qe_clock qe_clock_source(const char *source)
212 {
213         unsigned int i;
214
215         if (strcasecmp(source, "none") == 0)
216                 return QE_CLK_NONE;
217
218         if (strncasecmp(source, "brg", 3) == 0) {
219                 i = simple_strtoul(source + 3, NULL, 10);
220                 if ((i >= 1) && (i <= 16))
221                         return (QE_BRG1 - 1) + i;
222                 else
223                         return QE_CLK_DUMMY;
224         }
225
226         if (strncasecmp(source, "clk", 3) == 0) {
227                 i = simple_strtoul(source + 3, NULL, 10);
228                 if ((i >= 1) && (i <= 24))
229                         return (QE_CLK1 - 1) + i;
230                 else
231                         return QE_CLK_DUMMY;
232         }
233
234         return QE_CLK_DUMMY;
235 }
236 EXPORT_SYMBOL(qe_clock_source);
237
238 /* Initialize SNUMs (thread serial numbers) according to
239  * QE Module Control chapter, SNUM table
240  */
241 static void qe_snums_init(void)
242 {
243         int i;
244         static const u8 snum_init[] = {
245                 0x04, 0x05, 0x0C, 0x0D, 0x14, 0x15, 0x1C, 0x1D,
246                 0x24, 0x25, 0x2C, 0x2D, 0x34, 0x35, 0x88, 0x89,
247                 0x98, 0x99, 0xA8, 0xA9, 0xB8, 0xB9, 0xC8, 0xC9,
248                 0xD8, 0xD9, 0xE8, 0xE9,
249         };
250
251         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
252                 snums[i].num = snum_init[i];
253                 snums[i].state = QE_SNUM_STATE_FREE;
254         }
255 }
256
257 int qe_get_snum(void)
258 {
259         unsigned long flags;
260         int snum = -EBUSY;
261         int i;
262
263         spin_lock_irqsave(&qe_lock, flags);
264         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
265                 if (snums[i].state == QE_SNUM_STATE_FREE) {
266                         snums[i].state = QE_SNUM_STATE_USED;
267                         snum = snums[i].num;
268                         break;
269                 }
270         }
271         spin_unlock_irqrestore(&qe_lock, flags);
272
273         return snum;
274 }
275 EXPORT_SYMBOL(qe_get_snum);
276
277 void qe_put_snum(u8 snum)
278 {
279         int i;
280
281         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
282                 if (snums[i].num == snum) {
283                         snums[i].state = QE_SNUM_STATE_FREE;
284                         break;
285                 }
286         }
287 }
288 EXPORT_SYMBOL(qe_put_snum);
289
290 static int qe_sdma_init(void)
291 {
292         struct sdma *sdma = &qe_immr->sdma;
293         unsigned long sdma_buf_offset;
294
295         if (!sdma)
296                 return -ENODEV;
297
298         /* allocate 2 internal temporary buffers (512 bytes size each) for
299          * the SDMA */
300         sdma_buf_offset = qe_muram_alloc(512 * 2, 4096);
301         if (IS_ERR_VALUE(sdma_buf_offset))
302                 return -ENOMEM;
303
304         out_be32(&sdma->sdebcr, (u32) sdma_buf_offset & QE_SDEBCR_BA_MASK);
305         out_be32(&sdma->sdmr, (QE_SDMR_GLB_1_MSK |
306                                         (0x1 << QE_SDMR_CEN_SHIFT)));
307
308         return 0;
309 }
310
311 /*
312  * muram_alloc / muram_free bits.
313  */
314 static DEFINE_SPINLOCK(qe_muram_lock);
315
316 /* 16 blocks should be enough to satisfy all requests
317  * until the memory subsystem goes up... */
318 static rh_block_t qe_boot_muram_rh_block[16];
319 static rh_info_t qe_muram_info;
320
321 static void qe_muram_init(void)
322 {
323         struct device_node *np;
324         u32 address;
325         u64 size;
326         unsigned int flags;
327
328         /* initialize the info header */
329         rh_init(&qe_muram_info, 1,
330                 sizeof(qe_boot_muram_rh_block) /
331                 sizeof(qe_boot_muram_rh_block[0]), qe_boot_muram_rh_block);
332
333         /* Attach the usable muram area */
334         /* XXX: This is a subset of the available muram. It
335          * varies with the processor and the microcode patches activated.
336          */
337         if ((np = of_find_node_by_name(NULL, "data-only")) != NULL) {
338                 address = *of_get_address(np, 0, &size, &flags);
339                 of_node_put(np);
340                 rh_attach_region(&qe_muram_info, address, (int) size);
341         }
342 }
343
344 /* This function returns an index into the MURAM area.
345  */
346 unsigned long qe_muram_alloc(int size, int align)
347 {
348         unsigned long start;
349         unsigned long flags;
350
351         spin_lock_irqsave(&qe_muram_lock, flags);
352         start = rh_alloc_align(&qe_muram_info, size, align, "QE");
353         spin_unlock_irqrestore(&qe_muram_lock, flags);
354
355         return start;
356 }
357 EXPORT_SYMBOL(qe_muram_alloc);
358
359 int qe_muram_free(unsigned long offset)
360 {
361         int ret;
362         unsigned long flags;
363
364         spin_lock_irqsave(&qe_muram_lock, flags);
365         ret = rh_free(&qe_muram_info, offset);
366         spin_unlock_irqrestore(&qe_muram_lock, flags);
367
368         return ret;
369 }
370 EXPORT_SYMBOL(qe_muram_free);
371
372 /* not sure if this is ever needed */
373 unsigned long qe_muram_alloc_fixed(unsigned long offset, int size)
374 {
375         unsigned long start;
376         unsigned long flags;
377
378         spin_lock_irqsave(&qe_muram_lock, flags);
379         start = rh_alloc_fixed(&qe_muram_info, offset, size, "commproc");
380         spin_unlock_irqrestore(&qe_muram_lock, flags);
381
382         return start;
383 }
384 EXPORT_SYMBOL(qe_muram_alloc_fixed);
385
386 void qe_muram_dump(void)
387 {
388         rh_dump(&qe_muram_info);
389 }
390 EXPORT_SYMBOL(qe_muram_dump);
391
392 void *qe_muram_addr(unsigned long offset)
393 {
394         return (void *)&qe_immr->muram[offset];
395 }
396 EXPORT_SYMBOL(qe_muram_addr);