powerpc: Fix a bunch of sparse warnings in the qe_lib
[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 <linux/crc32.h>
29 #include <asm/irq.h>
30 #include <asm/page.h>
31 #include <asm/pgtable.h>
32 #include <asm/immap_qe.h>
33 #include <asm/qe.h>
34 #include <asm/prom.h>
35 #include <asm/rheap.h>
36
37 static void qe_snums_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 __iomem *qe_immr;
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         int size;
68         const u32 *prop;
69
70         if (qebase != -1)
71                 return qebase;
72
73         qe = of_find_compatible_node(NULL, NULL, "fsl,qe");
74         if (!qe) {
75                 qe = of_find_node_by_type(NULL, "qe");
76                 if (!qe)
77                         return qebase;
78         }
79
80         prop = of_get_property(qe, "reg", &size);
81         if (prop && size >= sizeof(*prop))
82                 qebase = of_translate_address(qe, prop);
83         of_node_put(qe);
84
85         return qebase;
86 }
87
88 EXPORT_SYMBOL(get_qe_base);
89
90 void __init qe_reset(void)
91 {
92         if (qe_immr == NULL)
93                 qe_immr = ioremap(get_qe_base(), QE_IMMAP_SIZE);
94
95         qe_snums_init();
96
97         qe_issue_cmd(QE_RESET, QE_CR_SUBBLOCK_INVALID,
98                      QE_CR_PROTOCOL_UNSPECIFIED, 0);
99
100         /* Reclaim the MURAM memory for our use. */
101         qe_muram_init();
102
103         if (qe_sdma_init())
104                 panic("sdma init failed!");
105 }
106
107 int qe_issue_cmd(u32 cmd, u32 device, u8 mcn_protocol, u32 cmd_input)
108 {
109         unsigned long flags;
110         u8 mcn_shift = 0, dev_shift = 0;
111
112         spin_lock_irqsave(&qe_lock, flags);
113         if (cmd == QE_RESET) {
114                 out_be32(&qe_immr->cp.cecr, (u32) (cmd | QE_CR_FLG));
115         } else {
116                 if (cmd == QE_ASSIGN_PAGE) {
117                         /* Here device is the SNUM, not sub-block */
118                         dev_shift = QE_CR_SNUM_SHIFT;
119                 } else if (cmd == QE_ASSIGN_RISC) {
120                         /* Here device is the SNUM, and mcnProtocol is
121                          * e_QeCmdRiscAssignment value */
122                         dev_shift = QE_CR_SNUM_SHIFT;
123                         mcn_shift = QE_CR_MCN_RISC_ASSIGN_SHIFT;
124                 } else {
125                         if (device == QE_CR_SUBBLOCK_USB)
126                                 mcn_shift = QE_CR_MCN_USB_SHIFT;
127                         else
128                                 mcn_shift = QE_CR_MCN_NORMAL_SHIFT;
129                 }
130
131                 out_be32(&qe_immr->cp.cecdr, cmd_input);
132                 out_be32(&qe_immr->cp.cecr,
133                          (cmd | QE_CR_FLG | ((u32) device << dev_shift) | (u32)
134                           mcn_protocol << mcn_shift));
135         }
136
137         /* wait for the QE_CR_FLG to clear */
138         while(in_be32(&qe_immr->cp.cecr) & QE_CR_FLG)
139                 cpu_relax();
140         spin_unlock_irqrestore(&qe_lock, flags);
141
142         return 0;
143 }
144 EXPORT_SYMBOL(qe_issue_cmd);
145
146 /* Set a baud rate generator. This needs lots of work. There are
147  * 16 BRGs, which can be connected to the QE channels or output
148  * as clocks. The BRGs are in two different block of internal
149  * memory mapped space.
150  * The BRG clock is the QE clock divided by 2.
151  * It was set up long ago during the initial boot phase and is
152  * is given to us.
153  * Baud rate clocks are zero-based in the driver code (as that maps
154  * to port numbers). Documentation uses 1-based numbering.
155  */
156 static unsigned int brg_clk = 0;
157
158 unsigned int qe_get_brg_clk(void)
159 {
160         struct device_node *qe;
161         int size;
162         const u32 *prop;
163
164         if (brg_clk)
165                 return brg_clk;
166
167         qe = of_find_compatible_node(NULL, NULL, "fsl,qe");
168         if (!qe) {
169                 qe = of_find_node_by_type(NULL, "qe");
170                 if (!qe)
171                         return brg_clk;
172         }
173
174         prop = of_get_property(qe, "brg-frequency", &size);
175         if (prop && size == sizeof(*prop))
176                 brg_clk = *prop;
177
178         of_node_put(qe);
179
180         return brg_clk;
181 }
182 EXPORT_SYMBOL(qe_get_brg_clk);
183
184 /* Program the BRG to the given sampling rate and multiplier
185  *
186  * @brg: the BRG, QE_BRG1 - QE_BRG16
187  * @rate: the desired sampling rate
188  * @multiplier: corresponds to the value programmed in GUMR_L[RDCR] or
189  * GUMR_L[TDCR].  E.g., if this BRG is the RX clock, and GUMR_L[RDCR]=01,
190  * then 'multiplier' should be 8.
191  */
192 int qe_setbrg(enum qe_clock brg, unsigned int rate, unsigned int multiplier)
193 {
194         u32 divisor, tempval;
195         u32 div16 = 0;
196
197         if ((brg < QE_BRG1) || (brg > QE_BRG16))
198                 return -EINVAL;
199
200         divisor = qe_get_brg_clk() / (rate * multiplier);
201
202         if (divisor > QE_BRGC_DIVISOR_MAX + 1) {
203                 div16 = QE_BRGC_DIV16;
204                 divisor /= 16;
205         }
206
207         /* Errata QE_General4, which affects some MPC832x and MPC836x SOCs, says
208            that the BRG divisor must be even if you're not using divide-by-16
209            mode. */
210         if (!div16 && (divisor & 1))
211                 divisor++;
212
213         tempval = ((divisor - 1) << QE_BRGC_DIVISOR_SHIFT) |
214                 QE_BRGC_ENABLE | div16;
215
216         out_be32(&qe_immr->brg.brgc[brg - QE_BRG1], tempval);
217
218         return 0;
219 }
220 EXPORT_SYMBOL(qe_setbrg);
221
222 /* Convert a string to a QE clock source enum
223  *
224  * This function takes a string, typically from a property in the device
225  * tree, and returns the corresponding "enum qe_clock" value.
226 */
227 enum qe_clock qe_clock_source(const char *source)
228 {
229         unsigned int i;
230
231         if (strcasecmp(source, "none") == 0)
232                 return QE_CLK_NONE;
233
234         if (strncasecmp(source, "brg", 3) == 0) {
235                 i = simple_strtoul(source + 3, NULL, 10);
236                 if ((i >= 1) && (i <= 16))
237                         return (QE_BRG1 - 1) + i;
238                 else
239                         return QE_CLK_DUMMY;
240         }
241
242         if (strncasecmp(source, "clk", 3) == 0) {
243                 i = simple_strtoul(source + 3, NULL, 10);
244                 if ((i >= 1) && (i <= 24))
245                         return (QE_CLK1 - 1) + i;
246                 else
247                         return QE_CLK_DUMMY;
248         }
249
250         return QE_CLK_DUMMY;
251 }
252 EXPORT_SYMBOL(qe_clock_source);
253
254 /* Initialize SNUMs (thread serial numbers) according to
255  * QE Module Control chapter, SNUM table
256  */
257 static void qe_snums_init(void)
258 {
259         int i;
260         static const u8 snum_init[] = {
261                 0x04, 0x05, 0x0C, 0x0D, 0x14, 0x15, 0x1C, 0x1D,
262                 0x24, 0x25, 0x2C, 0x2D, 0x34, 0x35, 0x88, 0x89,
263                 0x98, 0x99, 0xA8, 0xA9, 0xB8, 0xB9, 0xC8, 0xC9,
264                 0xD8, 0xD9, 0xE8, 0xE9,
265         };
266
267         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
268                 snums[i].num = snum_init[i];
269                 snums[i].state = QE_SNUM_STATE_FREE;
270         }
271 }
272
273 int qe_get_snum(void)
274 {
275         unsigned long flags;
276         int snum = -EBUSY;
277         int i;
278
279         spin_lock_irqsave(&qe_lock, flags);
280         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
281                 if (snums[i].state == QE_SNUM_STATE_FREE) {
282                         snums[i].state = QE_SNUM_STATE_USED;
283                         snum = snums[i].num;
284                         break;
285                 }
286         }
287         spin_unlock_irqrestore(&qe_lock, flags);
288
289         return snum;
290 }
291 EXPORT_SYMBOL(qe_get_snum);
292
293 void qe_put_snum(u8 snum)
294 {
295         int i;
296
297         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
298                 if (snums[i].num == snum) {
299                         snums[i].state = QE_SNUM_STATE_FREE;
300                         break;
301                 }
302         }
303 }
304 EXPORT_SYMBOL(qe_put_snum);
305
306 static int qe_sdma_init(void)
307 {
308         struct sdma __iomem *sdma = &qe_immr->sdma;
309         unsigned long sdma_buf_offset;
310
311         if (!sdma)
312                 return -ENODEV;
313
314         /* allocate 2 internal temporary buffers (512 bytes size each) for
315          * the SDMA */
316         sdma_buf_offset = qe_muram_alloc(512 * 2, 4096);
317         if (IS_ERR_VALUE(sdma_buf_offset))
318                 return -ENOMEM;
319
320         out_be32(&sdma->sdebcr, (u32) sdma_buf_offset & QE_SDEBCR_BA_MASK);
321         out_be32(&sdma->sdmr, (QE_SDMR_GLB_1_MSK |
322                                         (0x1 << QE_SDMR_CEN_SHIFT)));
323
324         return 0;
325 }
326
327 /* The maximum number of RISCs we support */
328 #define MAX_QE_RISC     2
329
330 /* Firmware information stored here for qe_get_firmware_info() */
331 static struct qe_firmware_info qe_firmware_info;
332
333 /*
334  * Set to 1 if QE firmware has been uploaded, and therefore
335  * qe_firmware_info contains valid data.
336  */
337 static int qe_firmware_uploaded;
338
339 /*
340  * Upload a QE microcode
341  *
342  * This function is a worker function for qe_upload_firmware().  It does
343  * the actual uploading of the microcode.
344  */
345 static void qe_upload_microcode(const void *base,
346         const struct qe_microcode *ucode)
347 {
348         const __be32 *code = base + be32_to_cpu(ucode->code_offset);
349         unsigned int i;
350
351         if (ucode->major || ucode->minor || ucode->revision)
352                 printk(KERN_INFO "qe-firmware: "
353                         "uploading microcode '%s' version %u.%u.%u\n",
354                         ucode->id, ucode->major, ucode->minor, ucode->revision);
355         else
356                 printk(KERN_INFO "qe-firmware: "
357                         "uploading microcode '%s'\n", ucode->id);
358
359         /* Use auto-increment */
360         out_be32(&qe_immr->iram.iadd, be32_to_cpu(ucode->iram_offset) |
361                 QE_IRAM_IADD_AIE | QE_IRAM_IADD_BADDR);
362
363         for (i = 0; i < be32_to_cpu(ucode->count); i++)
364                 out_be32(&qe_immr->iram.idata, be32_to_cpu(code[i]));
365 }
366
367 /*
368  * Upload a microcode to the I-RAM at a specific address.
369  *
370  * See Documentation/powerpc/qe-firmware.txt for information on QE microcode
371  * uploading.
372  *
373  * Currently, only version 1 is supported, so the 'version' field must be
374  * set to 1.
375  *
376  * The SOC model and revision are not validated, they are only displayed for
377  * informational purposes.
378  *
379  * 'calc_size' is the calculated size, in bytes, of the firmware structure and
380  * all of the microcode structures, minus the CRC.
381  *
382  * 'length' is the size that the structure says it is, including the CRC.
383  */
384 int qe_upload_firmware(const struct qe_firmware *firmware)
385 {
386         unsigned int i;
387         unsigned int j;
388         u32 crc;
389         size_t calc_size = sizeof(struct qe_firmware);
390         size_t length;
391         const struct qe_header *hdr;
392
393         if (!firmware) {
394                 printk(KERN_ERR "qe-firmware: invalid pointer\n");
395                 return -EINVAL;
396         }
397
398         hdr = &firmware->header;
399         length = be32_to_cpu(hdr->length);
400
401         /* Check the magic */
402         if ((hdr->magic[0] != 'Q') || (hdr->magic[1] != 'E') ||
403             (hdr->magic[2] != 'F')) {
404                 printk(KERN_ERR "qe-firmware: not a microcode\n");
405                 return -EPERM;
406         }
407
408         /* Check the version */
409         if (hdr->version != 1) {
410                 printk(KERN_ERR "qe-firmware: unsupported version\n");
411                 return -EPERM;
412         }
413
414         /* Validate some of the fields */
415         if ((firmware->count < 1) || (firmware->count > MAX_QE_RISC)) {
416                 printk(KERN_ERR "qe-firmware: invalid data\n");
417                 return -EINVAL;
418         }
419
420         /* Validate the length and check if there's a CRC */
421         calc_size += (firmware->count - 1) * sizeof(struct qe_microcode);
422
423         for (i = 0; i < firmware->count; i++)
424                 /*
425                  * For situations where the second RISC uses the same microcode
426                  * as the first, the 'code_offset' and 'count' fields will be
427                  * zero, so it's okay to add those.
428                  */
429                 calc_size += sizeof(__be32) *
430                         be32_to_cpu(firmware->microcode[i].count);
431
432         /* Validate the length */
433         if (length != calc_size + sizeof(__be32)) {
434                 printk(KERN_ERR "qe-firmware: invalid length\n");
435                 return -EPERM;
436         }
437
438         /* Validate the CRC */
439         crc = be32_to_cpu(*(__be32 *)((void *)firmware + calc_size));
440         if (crc != crc32(0, firmware, calc_size)) {
441                 printk(KERN_ERR "qe-firmware: firmware CRC is invalid\n");
442                 return -EIO;
443         }
444
445         /*
446          * If the microcode calls for it, split the I-RAM.
447          */
448         if (!firmware->split)
449                 setbits16(&qe_immr->cp.cercr, QE_CP_CERCR_CIR);
450
451         if (firmware->soc.model)
452                 printk(KERN_INFO
453                         "qe-firmware: firmware '%s' for %u V%u.%u\n",
454                         firmware->id, be16_to_cpu(firmware->soc.model),
455                         firmware->soc.major, firmware->soc.minor);
456         else
457                 printk(KERN_INFO "qe-firmware: firmware '%s'\n",
458                         firmware->id);
459
460         /*
461          * The QE only supports one microcode per RISC, so clear out all the
462          * saved microcode information and put in the new.
463          */
464         memset(&qe_firmware_info, 0, sizeof(qe_firmware_info));
465         strcpy(qe_firmware_info.id, firmware->id);
466         qe_firmware_info.extended_modes = firmware->extended_modes;
467         memcpy(qe_firmware_info.vtraps, firmware->vtraps,
468                 sizeof(firmware->vtraps));
469
470         /* Loop through each microcode. */
471         for (i = 0; i < firmware->count; i++) {
472                 const struct qe_microcode *ucode = &firmware->microcode[i];
473
474                 /* Upload a microcode if it's present */
475                 if (ucode->code_offset)
476                         qe_upload_microcode(firmware, ucode);
477
478                 /* Program the traps for this processor */
479                 for (j = 0; j < 16; j++) {
480                         u32 trap = be32_to_cpu(ucode->traps[j]);
481
482                         if (trap)
483                                 out_be32(&qe_immr->rsp[i].tibcr[j], trap);
484                 }
485
486                 /* Enable traps */
487                 out_be32(&qe_immr->rsp[i].eccr, be32_to_cpu(ucode->eccr));
488         }
489
490         qe_firmware_uploaded = 1;
491
492         return 0;
493 }
494 EXPORT_SYMBOL(qe_upload_firmware);
495
496 /*
497  * Get info on the currently-loaded firmware
498  *
499  * This function also checks the device tree to see if the boot loader has
500  * uploaded a firmware already.
501  */
502 struct qe_firmware_info *qe_get_firmware_info(void)
503 {
504         static int initialized;
505         struct property *prop;
506         struct device_node *qe;
507         struct device_node *fw = NULL;
508         const char *sprop;
509         unsigned int i;
510
511         /*
512          * If we haven't checked yet, and a driver hasn't uploaded a firmware
513          * yet, then check the device tree for information.
514          */
515         if (qe_firmware_uploaded)
516                 return &qe_firmware_info;
517
518         if (initialized)
519                 return NULL;
520
521         initialized = 1;
522
523         /*
524          * Newer device trees have an "fsl,qe" compatible property for the QE
525          * node, but we still need to support older device trees.
526         */
527         qe = of_find_compatible_node(NULL, NULL, "fsl,qe");
528         if (!qe) {
529                 qe = of_find_node_by_type(NULL, "qe");
530                 if (!qe)
531                         return NULL;
532         }
533
534         /* Find the 'firmware' child node */
535         for_each_child_of_node(qe, fw) {
536                 if (strcmp(fw->name, "firmware") == 0)
537                         break;
538         }
539
540         of_node_put(qe);
541
542         /* Did we find the 'firmware' node? */
543         if (!fw)
544                 return NULL;
545
546         qe_firmware_uploaded = 1;
547
548         /* Copy the data into qe_firmware_info*/
549         sprop = of_get_property(fw, "id", NULL);
550         if (sprop)
551                 strncpy(qe_firmware_info.id, sprop,
552                         sizeof(qe_firmware_info.id) - 1);
553
554         prop = of_find_property(fw, "extended-modes", NULL);
555         if (prop && (prop->length == sizeof(u64))) {
556                 const u64 *iprop = prop->value;
557
558                 qe_firmware_info.extended_modes = *iprop;
559         }
560
561         prop = of_find_property(fw, "virtual-traps", NULL);
562         if (prop && (prop->length == 32)) {
563                 const u32 *iprop = prop->value;
564
565                 for (i = 0; i < ARRAY_SIZE(qe_firmware_info.vtraps); i++)
566                         qe_firmware_info.vtraps[i] = iprop[i];
567         }
568
569         of_node_put(fw);
570
571         return &qe_firmware_info;
572 }
573 EXPORT_SYMBOL(qe_get_firmware_info);
574