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.brgc1;
 178         bp += brg;
 179
 180         divisor = (get_brg_clk() / rate);
 181         if (divisor > QE_BRGC_DIVISOR_MAX + 1) {
 182                 div16 = 1;
 183                 divisor /= 16;
 184         }
 185
 186         tempval = ((divisor - 1) << QE_BRGC_DIVISOR_SHIFT) | QE_BRGC_ENABLE;
 187         if (div16)
 188                 tempval |= QE_BRGC_DIV16;
 189
 190         out_be32(bp, tempval);
 191 }
 192
 193 /* Initialize SNUMs (thread serial numbers) according to
 194  * QE Module Control chapter, SNUM table
 195  */
 196 static void qe_snums_init(void)
 197 {
 198         int i;
 199         static const u8 snum_init[] = {
 200                 0x04, 0x05, 0x0C, 0x0D, 0x14, 0x15, 0x1C, 0x1D,
 201                 0x24, 0x25, 0x2C, 0x2D, 0x34, 0x35, 0x88, 0x89,
 202                 0x98, 0x99, 0xA8, 0xA9, 0xB8, 0xB9, 0xC8, 0xC9,
 203                 0xD8, 0xD9, 0xE8, 0xE9,
 204         };
 205
 206         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
 207                 snums[i].num = snum_init[i];
 208                 snums[i].state = QE_SNUM_STATE_FREE;
 209         }
 210 }
 211
 212 int qe_get_snum(void)
 213 {
 214         unsigned long flags;
 215         int snum = -EBUSY;
 216         int i;
 217
 218         spin_lock_irqsave(&qe_lock, flags);
 219         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
 220                 if (snums[i].state == QE_SNUM_STATE_FREE) {
 221                         snums[i].state = QE_SNUM_STATE_USED;
 222                         snum = snums[i].num;
 223                         break;
 224                 }
 225         }
 226         spin_unlock_irqrestore(&qe_lock, flags);
 227
 228         return snum;
 229 }
 230 EXPORT_SYMBOL(qe_get_snum);
 231
 232 void qe_put_snum(u8 snum)
 233 {
 234         int i;
 235
 236         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
 237                 if (snums[i].num == snum) {
 238                         snums[i].state = QE_SNUM_STATE_FREE;
 239                         break;
 240                 }
 241         }
 242 }
 243 EXPORT_SYMBOL(qe_put_snum);
 244
 245 static int qe_sdma_init(void)
 246 {
 247         struct sdma *sdma = &qe_immr->sdma;
 248         u32 sdma_buf_offset;
 249
 250         if (!sdma)
 251                 return -ENODEV;
 252
 253         /* allocate 2 internal temporary buffers (512 bytes size each) for
 254          * the SDMA */
 255         sdma_buf_offset = qe_muram_alloc(512 * 2, 64);
 256         if (IS_MURAM_ERR(sdma_buf_offset))
 257                 return -ENOMEM;
 258
 259         out_be32(&sdma->sdebcr, sdma_buf_offset & QE_SDEBCR_BA_MASK);
 260         out_be32(&sdma->sdmr, (QE_SDMR_GLB_1_MSK | (0x1 >>
 261                                         QE_SDMR_CEN_SHIFT)));
 262
 263         return 0;
 264 }
 265
 266 /*
 267  * muram_alloc / muram_free bits.
 268  */
 269 static DEFINE_SPINLOCK(qe_muram_lock);
 270
 271 /* 16 blocks should be enough to satisfy all requests
 272  * until the memory subsystem goes up... */
 273 static rh_block_t qe_boot_muram_rh_block[16];
 274 static rh_info_t qe_muram_info;
 275
 276 static void qe_muram_init(void)
 277 {
 278         struct device_node *np;
 279         u32 address;
 280         u64 size;
 281         unsigned int flags;
 282
 283         /* initialize the info header */
 284         rh_init(&qe_muram_info, 1,
 285                 sizeof(qe_boot_muram_rh_block) /
 286                 sizeof(qe_boot_muram_rh_block[0]), qe_boot_muram_rh_block);
 287
 288         /* Attach the usable muram area */
 289         /* XXX: This is a subset of the available muram. It
 290          * varies with the processor and the microcode patches activated.
 291          */
 292         if ((np = of_find_node_by_name(NULL, "data-only")) != NULL) {
 293                 address = *of_get_address(np, 0, &size, &flags);
 294                 of_node_put(np);
 295                 rh_attach_region(&qe_muram_info,
 296                         (void *)address, (int)size);
 297         }
 298 }
 299
 300 /* This function returns an index into the MURAM area.
 301  */
 302 u32 qe_muram_alloc(u32 size, u32 align)
 303 {
 304         void *start;
 305         unsigned long flags;
 306
 307         spin_lock_irqsave(&qe_muram_lock, flags);
 308         start = rh_alloc_align(&qe_muram_info, size, align, "QE");
 309         spin_unlock_irqrestore(&qe_muram_lock, flags);
 310
 311         return (u32) start;
 312 }
 313 EXPORT_SYMBOL(qe_muram_alloc);
 314
 315 int qe_muram_free(u32 offset)
 316 {
 317         int ret;
 318         unsigned long flags;
 319
 320         spin_lock_irqsave(&qe_muram_lock, flags);
 321         ret = rh_free(&qe_muram_info, (void *)offset);
 322         spin_unlock_irqrestore(&qe_muram_lock, flags);
 323
 324         return ret;
 325 }
 326 EXPORT_SYMBOL(qe_muram_free);
 327
 328 /* not sure if this is ever needed */
 329 u32 qe_muram_alloc_fixed(u32 offset, u32 size)
 330 {
 331         void *start;
 332         unsigned long flags;
 333
 334         spin_lock_irqsave(&qe_muram_lock, flags);
 335         start = rh_alloc_fixed(&qe_muram_info, (void *)offset, size, "commproc");
 336         spin_unlock_irqrestore(&qe_muram_lock, flags);
 337
 338         return (u32) start;
 339 }
 340 EXPORT_SYMBOL(qe_muram_alloc_fixed);
 341
 342 void qe_muram_dump(void)
 343 {
 344         rh_dump(&qe_muram_info);
 345 }
 346 EXPORT_SYMBOL(qe_muram_dump);
 347
 348 void *qe_muram_addr(u32 offset)
 349 {
 350         return (void *)&qe_immr->muram[offset];
 351 }
 352 EXPORT_SYMBOL(qe_muram_addr);