arch/powerpc/cpu/mpc85xx/liodn.c

   1 /*
   2  * Copyright 2008-2011 Freescale Semiconductor, Inc.
   3  *
   4  * See file CREDITS for list of people who contributed to this
   5  * project.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 of
  10  * the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  20  * MA 02111-1307 USA
  21  */
  22
  23 #include <common.h>
  24 #include <libfdt.h>
  25 #include <fdt_support.h>
  26
  27 #include <asm/immap_85xx.h>
  28 #include <asm/io.h>
  29 #include <asm/processor.h>
  30 #include <asm/fsl_portals.h>
  31 #include <asm/fsl_liodn.h>
  32
  33 int get_dpaa_liodn(enum fsl_dpaa_dev dpaa_dev, u32 *liodns, int liodn_offset)
  34 {
  35         liodns[0] = liodn_bases[dpaa_dev].id[0] + liodn_offset;
  36
  37         if (liodn_bases[dpaa_dev].num_ids == 2)
  38                 liodns[1] = liodn_bases[dpaa_dev].id[1] + liodn_offset;
  39
  40         return liodn_bases[dpaa_dev].num_ids;
  41 }
  42
  43 #ifdef CONFIG_SYS_SRIO
  44 static void set_srio_liodn(struct srio_liodn_id_table *tbl, int size)
  45 {
  46         int i;
  47
  48         for (i = 0; i < size; i++) {
  49                 unsigned long reg_off = tbl[i].reg_offset[0];
  50                 out_be32((u32 *)reg_off, tbl[i].id[0]);
  51
  52                 if (tbl[i].num_ids == 2) {
  53                         reg_off = tbl[i].reg_offset[1];
  54                         out_be32((u32 *)reg_off, tbl[i].id[1]);
  55                 }
  56         }
  57 }
  58 #endif
  59
  60 static void set_liodn(struct liodn_id_table *tbl, int size)
  61 {
  62         int i;
  63
  64         for (i = 0; i < size; i++) {
  65                 u32 liodn;
  66                 if (tbl[i].num_ids == 2) {
  67                         liodn = (tbl[i].id[0] << 16) | tbl[i].id[1];
  68                 } else {
  69                         liodn = tbl[i].id[0];
  70                 }
  71
  72                 out_be32((volatile u32 *)(tbl[i].reg_offset), liodn);
  73         }
  74 }
  75
  76 static void setup_sec_liodn_base(void)
  77 {
  78         ccsr_sec_t *sec = (void *)CONFIG_SYS_FSL_SEC_ADDR;
  79         u32 base;
  80
  81         if (!IS_E_PROCESSOR(get_svr()))
  82                 return;
  83
  84         /* QILCR[QSLOM] */
  85         out_be32(&sec->qilcr_ms, 0x3ff<<16);
  86
  87         base = (liodn_bases[FSL_HW_PORTAL_SEC].id[0] << 16) |
  88                 liodn_bases[FSL_HW_PORTAL_SEC].id[1];
  89
  90         out_be32(&sec->qilcr_ls, base);
  91 }
  92
  93 #ifdef CONFIG_SYS_DPAA_FMAN
  94 static void setup_fman_liodn_base(enum fsl_dpaa_dev dev,
  95                                   struct liodn_id_table *tbl, int size)
  96 {
  97         int i;
  98         ccsr_fman_t *fm;
  99         u32 base;
 100
 101         switch(dev) {
 102         case FSL_HW_PORTAL_FMAN1:
 103                 fm = (void *)CONFIG_SYS_FSL_FM1_ADDR;
 104                 break;
 105
 106 #if (CONFIG_SYS_NUM_FMAN == 2)
 107         case FSL_HW_PORTAL_FMAN2:
 108                 fm = (void *)CONFIG_SYS_FSL_FM2_ADDR;
 109                 break;
 110 #endif
 111         default:
 112                 printf("Error: Invalid device type to %s\n", __FUNCTION__);
 113                 return ;
 114         }
 115
 116         base = (liodn_bases[dev].id[0] << 16) | liodn_bases[dev].id[0];
 117
 118         /* setup all bases the same */
 119         for (i = 0; i < 32; i++) {
 120                 out_be32(&fm->fm_dma.fmdmplr[i], base);
 121         }
 122
 123         /* update tbl to ... */
 124         for (i = 0; i < size; i++)
 125                 tbl[i].id[0] += liodn_bases[dev].id[0];
 126 }
 127 #endif
 128
 129 static void setup_pme_liodn_base(void)
 130 {
 131 #ifdef CONFIG_SYS_DPAA_PME
 132         ccsr_pme_t *pme = (void *)CONFIG_SYS_FSL_CORENET_PME_ADDR;
 133         u32 base = (liodn_bases[FSL_HW_PORTAL_PME].id[0] << 16) |
 134                         liodn_bases[FSL_HW_PORTAL_PME].id[1];
 135
 136         out_be32(&pme->liodnbr, base);
 137 #endif
 138 }
 139
 140 #ifdef CONFIG_SYS_FSL_RAID_ENGINE
 141 static void setup_raide_liodn_base(void)
 142 {
 143         struct ccsr_raide *raide = (void *)CONFIG_SYS_FSL_RAID_ENGINE_ADDR;
 144
 145         /* setup raid engine liodn base for data/desc ; both set to 47 */
 146         u32 base = (liodn_bases[FSL_HW_PORTAL_RAID_ENGINE].id[0] << 16) |
 147                         liodn_bases[FSL_HW_PORTAL_RAID_ENGINE].id[0];
 148
 149         out_be32(&raide->liodnbr, base);
 150 }
 151 #endif
 152
 153 #ifdef CONFIG_SYS_DPAA_RMAN
 154 static void set_rman_liodn(struct liodn_id_table *tbl, int size)
 155 {
 156         int i;
 157         struct ccsr_rman *rman = (void *)CONFIG_SYS_FSL_CORENET_RMAN_ADDR;
 158
 159         for (i = 0; i < size; i++) {
 160                 /* write the RMan block number */
 161                 out_be32(&rman->mmitar, i);
 162                 /* write the liodn offset corresponding to the block */
 163                 out_be32((u32 *)(tbl[i].reg_offset), tbl[i].id[0]);
 164         }
 165 }
 166
 167 static void setup_rman_liodn_base(struct liodn_id_table *tbl, int size)
 168 {
 169         int i;
 170         struct ccsr_rman *rman = (void *)CONFIG_SYS_FSL_CORENET_RMAN_ADDR;
 171         u32 base = liodn_bases[FSL_HW_PORTAL_RMAN].id[0];
 172
 173         out_be32(&rman->mmliodnbr, base);
 174
 175         /* update liodn offset */
 176         for (i = 0; i < size; i++)
 177                 tbl[i].id[0] += base;
 178 }
 179 #endif
 180
 181 void set_liodns(void)
 182 {
 183         /* setup general liodn offsets */
 184         set_liodn(liodn_tbl, liodn_tbl_sz);
 185
 186 #ifdef CONFIG_SYS_SRIO
 187         /* setup SRIO port liodns */
 188         set_srio_liodn(srio_liodn_tbl, srio_liodn_tbl_sz);
 189 #endif
 190
 191         /* setup SEC block liodn bases & offsets if we have one */
 192         if (IS_E_PROCESSOR(get_svr())) {
 193                 set_liodn(sec_liodn_tbl, sec_liodn_tbl_sz);
 194                 setup_sec_liodn_base();
 195         }
 196
 197         /* setup FMAN block(s) liodn bases & offsets if we have one */
 198 #ifdef CONFIG_SYS_DPAA_FMAN
 199         set_liodn(fman1_liodn_tbl, fman1_liodn_tbl_sz);
 200         setup_fman_liodn_base(FSL_HW_PORTAL_FMAN1, fman1_liodn_tbl,
 201                                 fman1_liodn_tbl_sz);
 202
 203 #if (CONFIG_SYS_NUM_FMAN == 2)
 204         set_liodn(fman2_liodn_tbl, fman2_liodn_tbl_sz);
 205         setup_fman_liodn_base(FSL_HW_PORTAL_FMAN2, fman2_liodn_tbl,
 206                                 fman2_liodn_tbl_sz);
 207 #endif
 208 #endif
 209         /* setup PME liodn base */
 210         setup_pme_liodn_base();
 211
 212 #ifdef CONFIG_SYS_FSL_RAID_ENGINE
 213         /* raid engine ccr addr code for liodn */
 214         set_liodn(raide_liodn_tbl, raide_liodn_tbl_sz);
 215         setup_raide_liodn_base();
 216 #endif
 217
 218 #ifdef CONFIG_SYS_DPAA_RMAN
 219         /* setup RMan liodn offsets */
 220         set_rman_liodn(rman_liodn_tbl, rman_liodn_tbl_sz);
 221         /* setup RMan liodn base */
 222         setup_rman_liodn_base(rman_liodn_tbl, rman_liodn_tbl_sz);
 223 #endif
 224 }
 225
 226 #ifdef CONFIG_SYS_SRIO
 227 static void fdt_fixup_srio_liodn(void *blob, struct srio_liodn_id_table *tbl)
 228 {
 229         int i, srio_off;
 230
 231         /* search for srio node, if doesn't exist just return - nothing todo */
 232         srio_off = fdt_node_offset_by_compatible(blob, -1, "fsl,srio");
 233         if (srio_off < 0)
 234                 return ;
 235
 236         for (i = 0; i < srio_liodn_tbl_sz; i++) {
 237                 int off, portid = tbl[i].portid;
 238
 239                 off = fdt_node_offset_by_prop_value(blob, srio_off,
 240                          "cell-index", &portid, 4);
 241                 if (off >= 0) {
 242                         off = fdt_setprop(blob, off, "fsl,liodn",
 243                                 &tbl[i].id[0],
 244                                 sizeof(u32) * tbl[i].num_ids);
 245                         if (off > 0)
 246                                 printf("WARNING unable to set fsl,liodn for "
 247                                         "fsl,srio port %d: %s\n",
 248                                         portid, fdt_strerror(off));
 249                 } else {
 250                         debug("WARNING: couldn't set fsl,liodn for srio: %s.\n",
 251                                 fdt_strerror(off));
 252                 }
 253         }
 254 }
 255 #endif
 256
 257 static void fdt_fixup_liodn_tbl(void *blob, struct liodn_id_table *tbl, int sz)
 258 {
 259         int i;
 260
 261         for (i = 0; i < sz; i++) {
 262                 int off;
 263
 264                 if (tbl[i].compat == NULL)
 265                         continue;
 266
 267                 off = fdt_node_offset_by_compat_reg(blob,
 268                                 tbl[i].compat, tbl[i].compat_offset);
 269                 if (off >= 0) {
 270                         off = fdt_setprop(blob, off, "fsl,liodn",
 271                                 &tbl[i].id[0],
 272                                 sizeof(u32) * tbl[i].num_ids);
 273                         if (off > 0)
 274                                 printf("WARNING unable to set fsl,liodn for "
 275                                         "%s: %s\n",
 276                                         tbl[i].compat, fdt_strerror(off));
 277                 } else {
 278                         debug("WARNING: could not set fsl,liodn for %s: %s.\n",
 279                                         tbl[i].compat, fdt_strerror(off));
 280                 }
 281         }
 282 }
 283
 284 void fdt_fixup_liodn(void *blob)
 285 {
 286 #ifdef CONFIG_SYS_SRIO
 287         fdt_fixup_srio_liodn(blob, srio_liodn_tbl);
 288 #endif
 289
 290         fdt_fixup_liodn_tbl(blob, liodn_tbl, liodn_tbl_sz);
 291 #ifdef CONFIG_SYS_DPAA_FMAN
 292         fdt_fixup_liodn_tbl(blob, fman1_liodn_tbl, fman1_liodn_tbl_sz);
 293 #if (CONFIG_SYS_NUM_FMAN == 2)
 294         fdt_fixup_liodn_tbl(blob, fman2_liodn_tbl, fman2_liodn_tbl_sz);
 295 #endif
 296 #endif
 297         fdt_fixup_liodn_tbl(blob, sec_liodn_tbl, sec_liodn_tbl_sz);
 298
 299 #ifdef CONFIG_SYS_FSL_RAID_ENGINE
 300         fdt_fixup_liodn_tbl(blob, raide_liodn_tbl, raide_liodn_tbl_sz);
 301 #endif
 302
 303 #ifdef CONFIG_SYS_DPAA_RMAN
 304         fdt_fixup_liodn_tbl(blob, rman_liodn_tbl, rman_liodn_tbl_sz);
 305 #endif
 306 }