Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 1 | /* |
Dave Liu | 03051c3 | 2007-09-18 12:36:11 +0800 | [diff] [blame] | 2 | * Copyright (C) 2004-2007 Freescale Semiconductor, Inc. |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 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 |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 21 | */ |
| 22 | |
| 23 | /* |
| 24 | * CPU specific code for the MPC83xx family. |
| 25 | * |
| 26 | * Derived from the MPC8260 and MPC85xx. |
| 27 | */ |
| 28 | |
| 29 | #include <common.h> |
| 30 | #include <watchdog.h> |
| 31 | #include <command.h> |
| 32 | #include <mpc83xx.h> |
| 33 | #include <asm/processor.h> |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 34 | #if defined(CONFIG_OF_FLAT_TREE) |
| 35 | #include <ft_build.h> |
Jerry Van Baren | 26d02c9 | 2007-07-04 21:27:30 -0400 | [diff] [blame] | 36 | #elif defined(CONFIG_OF_LIBFDT) |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 37 | #include <libfdt.h> |
Kumar Gala | 246d4ae | 2007-11-27 21:59:46 -0600 | [diff] [blame] | 38 | #include <fdt_support.h> |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 39 | #endif |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 40 | |
Wolfgang Denk | d87080b | 2006-03-31 18:32:53 +0200 | [diff] [blame] | 41 | DECLARE_GLOBAL_DATA_PTR; |
| 42 | |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 43 | int checkcpu(void) |
| 44 | { |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 45 | volatile immap_t *immr; |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 46 | ulong clock = gd->cpu_clk; |
| 47 | u32 pvr = get_pvr(); |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 48 | u32 spridr; |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 49 | char buf[32]; |
| 50 | |
Timur Tabi | d239d74 | 2006-11-03 12:00:28 -0600 | [diff] [blame] | 51 | immr = (immap_t *)CFG_IMMR; |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 52 | |
Kim Phillips | 54b2d43 | 2007-04-30 15:26:21 -0500 | [diff] [blame] | 53 | puts("CPU: "); |
Scott Wood | 95e7ef8 | 2007-04-16 14:34:16 -0500 | [diff] [blame] | 54 | |
| 55 | switch (pvr & 0xffff0000) { |
| 56 | case PVR_E300C1: |
| 57 | printf("e300c1, "); |
| 58 | break; |
| 59 | |
| 60 | case PVR_E300C2: |
| 61 | printf("e300c2, "); |
| 62 | break; |
| 63 | |
| 64 | case PVR_E300C3: |
| 65 | printf("e300c3, "); |
| 66 | break; |
| 67 | |
Dave Liu | 03051c3 | 2007-09-18 12:36:11 +0800 | [diff] [blame] | 68 | case PVR_E300C4: |
| 69 | printf("e300c4, "); |
| 70 | break; |
| 71 | |
Scott Wood | 95e7ef8 | 2007-04-16 14:34:16 -0500 | [diff] [blame] | 72 | default: |
| 73 | printf("Unknown core, "); |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 74 | } |
| 75 | |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 76 | spridr = immr->sysconf.spridr; |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 77 | switch(spridr) { |
| 78 | case SPR_8349E_REV10: |
| 79 | case SPR_8349E_REV11: |
Xie Xiaobo | 8d172c0 | 2007-02-14 18:26:44 +0800 | [diff] [blame] | 80 | case SPR_8349E_REV31: |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 81 | puts("MPC8349E, "); |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 82 | break; |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 83 | case SPR_8349_REV10: |
| 84 | case SPR_8349_REV11: |
Xie Xiaobo | 8d172c0 | 2007-02-14 18:26:44 +0800 | [diff] [blame] | 85 | case SPR_8349_REV31: |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 86 | puts("MPC8349, "); |
| 87 | break; |
| 88 | case SPR_8347E_REV10_TBGA: |
| 89 | case SPR_8347E_REV11_TBGA: |
Xie Xiaobo | 8d172c0 | 2007-02-14 18:26:44 +0800 | [diff] [blame] | 90 | case SPR_8347E_REV31_TBGA: |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 91 | case SPR_8347E_REV10_PBGA: |
| 92 | case SPR_8347E_REV11_PBGA: |
Xie Xiaobo | 8d172c0 | 2007-02-14 18:26:44 +0800 | [diff] [blame] | 93 | case SPR_8347E_REV31_PBGA: |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 94 | puts("MPC8347E, "); |
| 95 | break; |
| 96 | case SPR_8347_REV10_TBGA: |
| 97 | case SPR_8347_REV11_TBGA: |
Xie Xiaobo | 8d172c0 | 2007-02-14 18:26:44 +0800 | [diff] [blame] | 98 | case SPR_8347_REV31_TBGA: |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 99 | case SPR_8347_REV10_PBGA: |
| 100 | case SPR_8347_REV11_PBGA: |
Xie Xiaobo | 8d172c0 | 2007-02-14 18:26:44 +0800 | [diff] [blame] | 101 | case SPR_8347_REV31_PBGA: |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 102 | puts("MPC8347, "); |
| 103 | break; |
| 104 | case SPR_8343E_REV10: |
| 105 | case SPR_8343E_REV11: |
Xie Xiaobo | 8d172c0 | 2007-02-14 18:26:44 +0800 | [diff] [blame] | 106 | case SPR_8343E_REV31: |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 107 | puts("MPC8343E, "); |
| 108 | break; |
| 109 | case SPR_8343_REV10: |
| 110 | case SPR_8343_REV11: |
Xie Xiaobo | 8d172c0 | 2007-02-14 18:26:44 +0800 | [diff] [blame] | 111 | case SPR_8343_REV31: |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 112 | puts("MPC8343, "); |
| 113 | break; |
| 114 | case SPR_8360E_REV10: |
| 115 | case SPR_8360E_REV11: |
| 116 | case SPR_8360E_REV12: |
Xie Xiaobo | b110f40 | 2007-02-14 18:27:06 +0800 | [diff] [blame] | 117 | case SPR_8360E_REV20: |
Lee Nipper | 1ded024 | 2007-06-14 20:07:33 -0500 | [diff] [blame] | 118 | case SPR_8360E_REV21: |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 119 | puts("MPC8360E, "); |
| 120 | break; |
| 121 | case SPR_8360_REV10: |
| 122 | case SPR_8360_REV11: |
| 123 | case SPR_8360_REV12: |
Xie Xiaobo | b110f40 | 2007-02-14 18:27:06 +0800 | [diff] [blame] | 124 | case SPR_8360_REV20: |
Lee Nipper | 1ded024 | 2007-06-14 20:07:33 -0500 | [diff] [blame] | 125 | case SPR_8360_REV21: |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 126 | puts("MPC8360, "); |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 127 | break; |
Dave Liu | 24c3aca | 2006-12-07 21:13:15 +0800 | [diff] [blame] | 128 | case SPR_8323E_REV10: |
| 129 | case SPR_8323E_REV11: |
| 130 | puts("MPC8323E, "); |
| 131 | break; |
| 132 | case SPR_8323_REV10: |
| 133 | case SPR_8323_REV11: |
| 134 | puts("MPC8323, "); |
| 135 | break; |
| 136 | case SPR_8321E_REV10: |
| 137 | case SPR_8321E_REV11: |
| 138 | puts("MPC8321E, "); |
| 139 | break; |
| 140 | case SPR_8321_REV10: |
| 141 | case SPR_8321_REV11: |
| 142 | puts("MPC8321, "); |
| 143 | break; |
Scott Wood | a35b0c4 | 2007-04-16 14:34:15 -0500 | [diff] [blame] | 144 | case SPR_8311_REV10: |
| 145 | puts("MPC8311, "); |
| 146 | break; |
| 147 | case SPR_8311E_REV10: |
| 148 | puts("MPC8311E, "); |
| 149 | break; |
| 150 | case SPR_8313_REV10: |
| 151 | puts("MPC8313, "); |
| 152 | break; |
| 153 | case SPR_8313E_REV10: |
| 154 | puts("MPC8313E, "); |
| 155 | break; |
Dave Liu | 555da61 | 2007-09-18 12:36:58 +0800 | [diff] [blame] | 156 | case SPR_8315E_REV10: |
| 157 | puts("MPC8315E, "); |
| 158 | break; |
| 159 | case SPR_8315_REV10: |
| 160 | puts("MPC8315, "); |
| 161 | break; |
| 162 | case SPR_8314E_REV10: |
| 163 | puts("MPC8314E, "); |
| 164 | break; |
| 165 | case SPR_8314_REV10: |
| 166 | puts("MPC8314, "); |
| 167 | break; |
Dave Liu | 03051c3 | 2007-09-18 12:36:11 +0800 | [diff] [blame] | 168 | case SPR_8379E_REV10: |
| 169 | puts("MPC8379E, "); |
| 170 | break; |
| 171 | case SPR_8379_REV10: |
| 172 | puts("MPC8379, "); |
| 173 | break; |
| 174 | case SPR_8378E_REV10: |
| 175 | puts("MPC8378E, "); |
| 176 | break; |
| 177 | case SPR_8378_REV10: |
| 178 | puts("MPC8378, "); |
| 179 | break; |
| 180 | case SPR_8377E_REV10: |
| 181 | puts("MPC8377E, "); |
| 182 | break; |
| 183 | case SPR_8377_REV10: |
| 184 | puts("MPC8377, "); |
| 185 | break; |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 186 | default: |
Lee Nipper | 1ded024 | 2007-06-14 20:07:33 -0500 | [diff] [blame] | 187 | printf("Rev: Unknown revision number:%08x\n" |
| 188 | "Warning: Unsupported cpu revision!\n",spridr); |
Xie Xiaobo | 8d172c0 | 2007-02-14 18:26:44 +0800 | [diff] [blame] | 189 | return 0; |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 190 | } |
Rafal Jaworowski | 6902df5 | 2005-10-17 02:39:53 +0200 | [diff] [blame] | 191 | |
Kumar Gala | 3e78a31 | 2007-01-30 14:08:30 -0600 | [diff] [blame] | 192 | #if defined(CONFIG_MPC834X) |
Xie Xiaobo | 8d172c0 | 2007-02-14 18:26:44 +0800 | [diff] [blame] | 193 | /* Multiple revisons of 834x processors may have the same SPRIDR value. |
| 194 | * So use PVR to identify the revision number. |
| 195 | */ |
Kim Phillips | 54b2d43 | 2007-04-30 15:26:21 -0500 | [diff] [blame] | 196 | printf("Rev: %02x at %s MHz", PVR_MAJ(pvr)<<4 | PVR_MIN(pvr), strmhz(buf, clock)); |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 197 | #else |
Kim Phillips | 54b2d43 | 2007-04-30 15:26:21 -0500 | [diff] [blame] | 198 | printf("Rev: %02x at %s MHz", spridr & 0x0000FFFF, strmhz(buf, clock)); |
Dave Liu | 5f82043 | 2006-11-03 19:33:44 -0600 | [diff] [blame] | 199 | #endif |
Kim Phillips | 54b2d43 | 2007-04-30 15:26:21 -0500 | [diff] [blame] | 200 | printf(", CSB: %4d MHz\n", gd->csb_clk / 1000000); |
| 201 | |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 202 | return 0; |
| 203 | } |
| 204 | |
| 205 | |
Timur Tabi | be5e618 | 2006-11-03 19:15:00 -0600 | [diff] [blame] | 206 | /* |
Timur Tabi | 2ad6b51 | 2006-10-31 18:44:42 -0600 | [diff] [blame] | 207 | * Program a UPM with the code supplied in the table. |
| 208 | * |
| 209 | * The 'dummy' variable is used to increment the MAD. 'dummy' is |
| 210 | * supposed to be a pointer to the memory of the device being |
| 211 | * programmed by the UPM. The data in the MDR is written into |
| 212 | * memory and the MAD is incremented every time there's a read |
| 213 | * from 'dummy'. Unfortunately, the current prototype for this |
| 214 | * function doesn't allow for passing the address of this |
| 215 | * device, and changing the prototype will break a number lots |
| 216 | * of other code, so we need to use a round-about way of finding |
| 217 | * the value for 'dummy'. |
| 218 | * |
| 219 | * The value can be extracted from the base address bits of the |
| 220 | * Base Register (BR) associated with the specific UPM. To find |
| 221 | * that BR, we need to scan all 8 BRs until we find the one that |
| 222 | * has its MSEL bits matching the UPM we want. Once we know the |
| 223 | * right BR, we can extract the base address bits from it. |
| 224 | * |
| 225 | * The MxMR and the BR and OR of the chosen bank should all be |
| 226 | * configured before calling this function. |
| 227 | * |
| 228 | * Parameters: |
| 229 | * upm: 0=UPMA, 1=UPMB, 2=UPMC |
| 230 | * table: Pointer to an array of values to program |
| 231 | * size: Number of elements in the array. Must be 64 or less. |
Timur Tabi | be5e618 | 2006-11-03 19:15:00 -0600 | [diff] [blame] | 232 | */ |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 233 | void upmconfig (uint upm, uint *table, uint size) |
| 234 | { |
Timur Tabi | 2ad6b51 | 2006-10-31 18:44:42 -0600 | [diff] [blame] | 235 | #if defined(CONFIG_MPC834X) |
Timur Tabi | d239d74 | 2006-11-03 12:00:28 -0600 | [diff] [blame] | 236 | volatile immap_t *immap = (immap_t *) CFG_IMMR; |
Timur Tabi | 2ad6b51 | 2006-10-31 18:44:42 -0600 | [diff] [blame] | 237 | volatile lbus83xx_t *lbus = &immap->lbus; |
| 238 | volatile uchar *dummy = NULL; |
| 239 | const u32 msel = (upm + 4) << BR_MSEL_SHIFT; /* What the MSEL field in BRn should be */ |
| 240 | volatile u32 *mxmr = &lbus->mamr + upm; /* Pointer to mamr, mbmr, or mcmr */ |
| 241 | uint i; |
| 242 | |
| 243 | /* Scan all the banks to determine the base address of the device */ |
| 244 | for (i = 0; i < 8; i++) { |
| 245 | if ((lbus->bank[i].br & BR_MSEL) == msel) { |
| 246 | dummy = (uchar *) (lbus->bank[i].br & BR_BA); |
| 247 | break; |
| 248 | } |
| 249 | } |
| 250 | |
| 251 | if (!dummy) { |
| 252 | printf("Error: %s() could not find matching BR\n", __FUNCTION__); |
| 253 | hang(); |
| 254 | } |
| 255 | |
| 256 | /* Set the OP field in the MxMR to "write" and the MAD field to 000000 */ |
| 257 | *mxmr = (*mxmr & 0xCFFFFFC0) | 0x10000000; |
| 258 | |
| 259 | for (i = 0; i < size; i++) { |
| 260 | lbus->mdr = table[i]; |
| 261 | __asm__ __volatile__ ("sync"); |
| 262 | *dummy; /* Write the value to memory and increment MAD */ |
| 263 | __asm__ __volatile__ ("sync"); |
| 264 | } |
| 265 | |
| 266 | /* Set the OP field in the MxMR to "normal" and the MAD field to 000000 */ |
| 267 | *mxmr &= 0xCFFFFFC0; |
| 268 | #else |
| 269 | printf("Error: %s() not defined for this configuration.\n", __FUNCTION__); |
| 270 | hang(); |
| 271 | #endif |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 272 | } |
| 273 | |
| 274 | |
| 275 | int |
| 276 | do_reset (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[]) |
| 277 | { |
Wolfgang Denk | 07a2505 | 2005-08-05 19:49:35 +0200 | [diff] [blame] | 278 | ulong msr; |
| 279 | #ifndef MPC83xx_RESET |
| 280 | ulong addr; |
| 281 | #endif |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 282 | |
Timur Tabi | d239d74 | 2006-11-03 12:00:28 -0600 | [diff] [blame] | 283 | volatile immap_t *immap = (immap_t *) CFG_IMMR; |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 284 | |
| 285 | #ifdef MPC83xx_RESET |
| 286 | /* Interrupts and MMU off */ |
| 287 | __asm__ __volatile__ ("mfmsr %0":"=r" (msr):); |
| 288 | |
| 289 | msr &= ~( MSR_EE | MSR_IR | MSR_DR); |
| 290 | __asm__ __volatile__ ("mtmsr %0"::"r" (msr)); |
| 291 | |
| 292 | /* enable Reset Control Reg */ |
| 293 | immap->reset.rpr = 0x52535445; |
Marian Balakowicz | 6d8ae5a | 2006-03-14 16:12:48 +0100 | [diff] [blame] | 294 | __asm__ __volatile__ ("sync"); |
| 295 | __asm__ __volatile__ ("isync"); |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 296 | |
| 297 | /* confirm Reset Control Reg is enabled */ |
| 298 | while(!((immap->reset.rcer) & RCER_CRE)); |
| 299 | |
| 300 | printf("Resetting the board."); |
| 301 | printf("\n"); |
| 302 | |
| 303 | udelay(200); |
| 304 | |
| 305 | /* perform reset, only one bit */ |
Wolfgang Denk | 07a2505 | 2005-08-05 19:49:35 +0200 | [diff] [blame] | 306 | immap->reset.rcr = RCR_SWHR; |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 307 | |
Wolfgang Denk | 07a2505 | 2005-08-05 19:49:35 +0200 | [diff] [blame] | 308 | #else /* ! MPC83xx_RESET */ |
| 309 | |
| 310 | immap->reset.rmr = RMR_CSRE; /* Checkstop Reset enable */ |
| 311 | |
| 312 | /* Interrupts and MMU off */ |
| 313 | __asm__ __volatile__ ("mfmsr %0":"=r" (msr):); |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 314 | |
| 315 | msr &= ~(MSR_ME | MSR_EE | MSR_IR | MSR_DR); |
| 316 | __asm__ __volatile__ ("mtmsr %0"::"r" (msr)); |
| 317 | |
| 318 | /* |
| 319 | * Trying to execute the next instruction at a non-existing address |
| 320 | * should cause a machine check, resulting in reset |
| 321 | */ |
| 322 | addr = CFG_RESET_ADDRESS; |
| 323 | |
| 324 | printf("resetting the board."); |
| 325 | printf("\n"); |
| 326 | ((void (*)(void)) addr) (); |
Wolfgang Denk | 07a2505 | 2005-08-05 19:49:35 +0200 | [diff] [blame] | 327 | #endif /* MPC83xx_RESET */ |
| 328 | |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 329 | return 1; |
| 330 | } |
| 331 | |
| 332 | |
| 333 | /* |
| 334 | * Get timebase clock frequency (like cpu_clk in Hz) |
| 335 | */ |
| 336 | |
| 337 | unsigned long get_tbclk(void) |
| 338 | { |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 339 | ulong tbclk; |
| 340 | |
| 341 | tbclk = (gd->bus_clk + 3L) / 4L; |
| 342 | |
| 343 | return tbclk; |
| 344 | } |
| 345 | |
| 346 | |
| 347 | #if defined(CONFIG_WATCHDOG) |
| 348 | void watchdog_reset (void) |
| 349 | { |
Timur Tabi | 2ad6b51 | 2006-10-31 18:44:42 -0600 | [diff] [blame] | 350 | int re_enable = disable_interrupts(); |
| 351 | |
| 352 | /* Reset the 83xx watchdog */ |
Timur Tabi | d239d74 | 2006-11-03 12:00:28 -0600 | [diff] [blame] | 353 | volatile immap_t *immr = (immap_t *) CFG_IMMR; |
Timur Tabi | 2ad6b51 | 2006-10-31 18:44:42 -0600 | [diff] [blame] | 354 | immr->wdt.swsrr = 0x556c; |
| 355 | immr->wdt.swsrr = 0xaa39; |
| 356 | |
| 357 | if (re_enable) |
| 358 | enable_interrupts (); |
Eran Liberty | f046ccd | 2005-07-28 10:08:46 -0500 | [diff] [blame] | 359 | } |
Timur Tabi | 2ad6b51 | 2006-10-31 18:44:42 -0600 | [diff] [blame] | 360 | #endif |
Kumar Gala | 62ec641 | 2006-01-11 16:48:10 -0600 | [diff] [blame] | 361 | |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 362 | #if defined(CONFIG_OF_LIBFDT) |
| 363 | |
| 364 | /* |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 365 | * "Setter" functions used to add/modify FDT entries. |
| 366 | */ |
Kim Phillips | f57ac7a | 2007-07-25 19:25:22 -0500 | [diff] [blame] | 367 | static int fdt_set_eth0(void *blob, int nodeoffset, const char *name, bd_t *bd) |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 368 | { |
Kim Phillips | 8f9e0e9 | 2007-08-15 22:30:19 -0500 | [diff] [blame] | 369 | /* Fix it up if it exists, don't create it if it doesn't exist */ |
Kim Phillips | f57ac7a | 2007-07-25 19:25:22 -0500 | [diff] [blame] | 370 | if (fdt_get_property(blob, nodeoffset, name, 0)) { |
| 371 | return fdt_setprop(blob, nodeoffset, name, bd->bi_enetaddr, 6); |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 372 | } |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 373 | return 0; |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 374 | } |
| 375 | #ifdef CONFIG_HAS_ETH1 |
| 376 | /* second onboard ethernet port */ |
Kim Phillips | f57ac7a | 2007-07-25 19:25:22 -0500 | [diff] [blame] | 377 | static int fdt_set_eth1(void *blob, int nodeoffset, const char *name, bd_t *bd) |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 378 | { |
Kim Phillips | 8f9e0e9 | 2007-08-15 22:30:19 -0500 | [diff] [blame] | 379 | /* Fix it up if it exists, don't create it if it doesn't exist */ |
Kim Phillips | f57ac7a | 2007-07-25 19:25:22 -0500 | [diff] [blame] | 380 | if (fdt_get_property(blob, nodeoffset, name, 0)) { |
| 381 | return fdt_setprop(blob, nodeoffset, name, bd->bi_enet1addr, 6); |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 382 | } |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 383 | return 0; |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 384 | } |
| 385 | #endif |
| 386 | #ifdef CONFIG_HAS_ETH2 |
| 387 | /* third onboard ethernet port */ |
Kim Phillips | f57ac7a | 2007-07-25 19:25:22 -0500 | [diff] [blame] | 388 | static int fdt_set_eth2(void *blob, int nodeoffset, const char *name, bd_t *bd) |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 389 | { |
Kim Phillips | 8f9e0e9 | 2007-08-15 22:30:19 -0500 | [diff] [blame] | 390 | /* Fix it up if it exists, don't create it if it doesn't exist */ |
Kim Phillips | f57ac7a | 2007-07-25 19:25:22 -0500 | [diff] [blame] | 391 | if (fdt_get_property(blob, nodeoffset, name, 0)) { |
| 392 | return fdt_setprop(blob, nodeoffset, name, bd->bi_enet2addr, 6); |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 393 | } |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 394 | return 0; |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 395 | } |
| 396 | #endif |
| 397 | #ifdef CONFIG_HAS_ETH3 |
| 398 | /* fourth onboard ethernet port */ |
Kim Phillips | f57ac7a | 2007-07-25 19:25:22 -0500 | [diff] [blame] | 399 | static int fdt_set_eth3(void *blob, int nodeoffset, const char *name, bd_t *bd) |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 400 | { |
Kim Phillips | 8f9e0e9 | 2007-08-15 22:30:19 -0500 | [diff] [blame] | 401 | /* Fix it up if it exists, don't create it if it doesn't exist */ |
Kim Phillips | f57ac7a | 2007-07-25 19:25:22 -0500 | [diff] [blame] | 402 | if (fdt_get_property(blob, nodeoffset, name, 0)) { |
| 403 | return fdt_setprop(blob, nodeoffset, name, bd->bi_enet3addr, 6); |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 404 | } |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 405 | return 0; |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 406 | } |
| 407 | #endif |
| 408 | |
Kim Phillips | f57ac7a | 2007-07-25 19:25:22 -0500 | [diff] [blame] | 409 | static int fdt_set_busfreq(void *blob, int nodeoffset, const char *name, bd_t *bd) |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 410 | { |
| 411 | u32 tmp; |
Kim Phillips | 8f9e0e9 | 2007-08-15 22:30:19 -0500 | [diff] [blame] | 412 | /* Create or update the property */ |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 413 | tmp = cpu_to_be32(bd->bi_busfreq); |
Kim Phillips | f57ac7a | 2007-07-25 19:25:22 -0500 | [diff] [blame] | 414 | return fdt_setprop(blob, nodeoffset, name, &tmp, sizeof(tmp)); |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 415 | } |
| 416 | |
Kim Phillips | f57ac7a | 2007-07-25 19:25:22 -0500 | [diff] [blame] | 417 | static int fdt_set_tbfreq(void *blob, int nodeoffset, const char *name, bd_t *bd) |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 418 | { |
| 419 | u32 tmp; |
Kim Phillips | 8f9e0e9 | 2007-08-15 22:30:19 -0500 | [diff] [blame] | 420 | /* Create or update the property */ |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 421 | tmp = cpu_to_be32(OF_TBCLK); |
Kim Phillips | f57ac7a | 2007-07-25 19:25:22 -0500 | [diff] [blame] | 422 | return fdt_setprop(blob, nodeoffset, name, &tmp, sizeof(tmp)); |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 423 | } |
| 424 | |
| 425 | |
Kim Phillips | 8f9e0e9 | 2007-08-15 22:30:19 -0500 | [diff] [blame] | 426 | static int fdt_set_clockfreq(void *blob, int nodeoffset, const char *name, bd_t *bd) |
| 427 | { |
| 428 | u32 tmp; |
| 429 | /* Create or update the property */ |
| 430 | tmp = cpu_to_be32(gd->core_clk); |
| 431 | return fdt_setprop(blob, nodeoffset, name, &tmp, sizeof(tmp)); |
| 432 | } |
| 433 | |
| 434 | #ifdef CONFIG_QE |
| 435 | static int fdt_set_qe_busfreq(void *blob, int nodeoffset, const char *name, bd_t *bd) |
| 436 | { |
| 437 | u32 tmp; |
| 438 | /* Create or update the property */ |
| 439 | tmp = cpu_to_be32(gd->qe_clk); |
| 440 | return fdt_setprop(blob, nodeoffset, name, &tmp, sizeof(tmp)); |
| 441 | } |
| 442 | |
| 443 | static int fdt_set_qe_brgfreq(void *blob, int nodeoffset, const char *name, bd_t *bd) |
| 444 | { |
| 445 | u32 tmp; |
| 446 | /* Create or update the property */ |
| 447 | tmp = cpu_to_be32(gd->brg_clk); |
| 448 | return fdt_setprop(blob, nodeoffset, name, &tmp, sizeof(tmp)); |
| 449 | } |
| 450 | #endif |
| 451 | |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 452 | /* |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 453 | * Fixups to the fdt. |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 454 | */ |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 455 | static const struct { |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 456 | char *node; |
| 457 | char *prop; |
Kim Phillips | f57ac7a | 2007-07-25 19:25:22 -0500 | [diff] [blame] | 458 | int (*set_fn)(void *blob, int nodeoffset, const char *name, bd_t *bd); |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 459 | } fixup_props[] = { |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 460 | { "/cpus/" OF_CPU, |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 461 | "timebase-frequency", |
| 462 | fdt_set_tbfreq |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 463 | }, |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 464 | { "/cpus/" OF_CPU, |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 465 | "bus-frequency", |
| 466 | fdt_set_busfreq |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 467 | }, |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 468 | { "/cpus/" OF_CPU, |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 469 | "clock-frequency", |
Kim Phillips | 8f9e0e9 | 2007-08-15 22:30:19 -0500 | [diff] [blame] | 470 | fdt_set_clockfreq |
| 471 | }, |
| 472 | { "/" OF_SOC, |
| 473 | "bus-frequency", |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 474 | fdt_set_busfreq |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 475 | }, |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 476 | { "/" OF_SOC "/serial@4500", |
| 477 | "clock-frequency", |
| 478 | fdt_set_busfreq |
| 479 | }, |
| 480 | { "/" OF_SOC "/serial@4600", |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 481 | "clock-frequency", |
| 482 | fdt_set_busfreq |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 483 | }, |
Kim Phillips | 255a3577 | 2007-05-16 16:52:19 -0500 | [diff] [blame] | 484 | #ifdef CONFIG_TSEC1 |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 485 | { "/" OF_SOC "/ethernet@24000", |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 486 | "mac-address", |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 487 | fdt_set_eth0 |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 488 | }, |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 489 | { "/" OF_SOC "/ethernet@24000", |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 490 | "local-mac-address", |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 491 | fdt_set_eth0 |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 492 | }, |
| 493 | #endif |
Kim Phillips | 255a3577 | 2007-05-16 16:52:19 -0500 | [diff] [blame] | 494 | #ifdef CONFIG_TSEC2 |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 495 | { "/" OF_SOC "/ethernet@25000", |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 496 | "mac-address", |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 497 | fdt_set_eth1 |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 498 | }, |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 499 | { "/" OF_SOC "/ethernet@25000", |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 500 | "local-mac-address", |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 501 | fdt_set_eth1 |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 502 | }, |
| 503 | #endif |
Kim Phillips | 8f9e0e9 | 2007-08-15 22:30:19 -0500 | [diff] [blame] | 504 | #ifdef CONFIG_QE |
| 505 | { "/" OF_QE, |
| 506 | "brg-frequency", |
| 507 | fdt_set_qe_brgfreq |
| 508 | }, |
| 509 | { "/" OF_QE, |
| 510 | "bus-frequency", |
| 511 | fdt_set_qe_busfreq |
| 512 | }, |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 513 | #ifdef CONFIG_UEC_ETH1 |
| 514 | #if CFG_UEC1_UCC_NUM == 0 /* UCC1 */ |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 515 | { "/" OF_QE "/ucc@2000", |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 516 | "mac-address", |
| 517 | fdt_set_eth0 |
| 518 | }, |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 519 | { "/" OF_QE "/ucc@2000", |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 520 | "local-mac-address", |
| 521 | fdt_set_eth0 |
| 522 | }, |
Joakim Tjernlund | ccf21c3 | 2007-12-06 16:43:40 +0100 | [diff] [blame] | 523 | #elif CFG_UEC1_UCC_NUM == 1 /* UCC2 */ |
| 524 | { "/" OF_QE "/ucc@3000", |
| 525 | "mac-address", |
| 526 | fdt_set_eth0 |
| 527 | }, |
| 528 | { "/" OF_QE "/ucc@3000", |
| 529 | "local-mac-address", |
| 530 | fdt_set_eth0 |
| 531 | }, |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 532 | #elif CFG_UEC1_UCC_NUM == 2 /* UCC3 */ |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 533 | { "/" OF_QE "/ucc@2200", |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 534 | "mac-address", |
| 535 | fdt_set_eth0 |
| 536 | }, |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 537 | { "/" OF_QE "/ucc@2200", |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 538 | "local-mac-address", |
| 539 | fdt_set_eth0 |
| 540 | }, |
Joakim Tjernlund | ccf21c3 | 2007-12-06 16:43:40 +0100 | [diff] [blame] | 541 | #elif CFG_UEC1_UCC_NUM == 3 /* UCC4 */ |
| 542 | { "/" OF_QE "/ucc@3200", |
| 543 | "mac-address", |
| 544 | fdt_set_eth0 |
| 545 | }, |
| 546 | { "/" OF_QE "/ucc@3200", |
| 547 | "local-mac-address", |
| 548 | fdt_set_eth0 |
| 549 | }, |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 550 | #endif |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 551 | #endif /* CONFIG_UEC_ETH1 */ |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 552 | #ifdef CONFIG_UEC_ETH2 |
Joakim Tjernlund | ccf21c3 | 2007-12-06 16:43:40 +0100 | [diff] [blame] | 553 | #if CFG_UEC2_UCC_NUM == 0 /* UCC1 */ |
| 554 | { "/" OF_QE "/ucc@2000", |
| 555 | "mac-address", |
| 556 | fdt_set_eth1 |
| 557 | }, |
| 558 | { "/" OF_QE "/ucc@2000", |
| 559 | "local-mac-address", |
| 560 | fdt_set_eth1 |
| 561 | }, |
| 562 | #elif CFG_UEC2_UCC_NUM == 1 /* UCC2 */ |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 563 | { "/" OF_QE "/ucc@3000", |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 564 | "mac-address", |
| 565 | fdt_set_eth1 |
| 566 | }, |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 567 | { "/" OF_QE "/ucc@3000", |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 568 | "local-mac-address", |
| 569 | fdt_set_eth1 |
| 570 | }, |
Joakim Tjernlund | ccf21c3 | 2007-12-06 16:43:40 +0100 | [diff] [blame] | 571 | #elif CFG_UEC2_UCC_NUM == 2 /* UCC3 */ |
| 572 | { "/" OF_QE "/ucc@2200", |
| 573 | "mac-address", |
| 574 | fdt_set_eth1 |
| 575 | }, |
| 576 | { "/" OF_QE "/ucc@2200", |
| 577 | "local-mac-address", |
| 578 | fdt_set_eth1 |
| 579 | }, |
Kim Phillips | f4b2ac5 | 2007-08-15 22:30:12 -0500 | [diff] [blame] | 580 | #elif CFG_UEC2_UCC_NUM == 3 /* UCC4 */ |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 581 | { "/" OF_QE "/ucc@3200", |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 582 | "mac-address", |
| 583 | fdt_set_eth1 |
| 584 | }, |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 585 | { "/" OF_QE "/ucc@3200", |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 586 | "local-mac-address", |
| 587 | fdt_set_eth1 |
| 588 | }, |
| 589 | #endif |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 590 | #endif /* CONFIG_UEC_ETH2 */ |
Joakim Tjernlund | ccf21c3 | 2007-12-06 16:43:40 +0100 | [diff] [blame] | 591 | #ifdef CONFIG_UEC_ETH3 |
| 592 | #if CFG_UEC3_UCC_NUM == 0 /* UCC1 */ |
| 593 | { "/" OF_QE "/ucc@2000", |
| 594 | "mac-address", |
| 595 | fdt_set_eth2 |
| 596 | }, |
| 597 | { "/" OF_QE "/ucc@2000", |
| 598 | "local-mac-address", |
| 599 | fdt_set_eth2 |
| 600 | }, |
| 601 | #elif CFG_UEC3_UCC_NUM == 1 /* UCC2 */ |
| 602 | { "/" OF_QE "/ucc@3000", |
| 603 | "mac-address", |
| 604 | fdt_set_eth2 |
| 605 | }, |
| 606 | { "/" OF_QE "/ucc@3000", |
| 607 | "local-mac-address", |
| 608 | fdt_set_eth2 |
| 609 | }, |
| 610 | #elif CFG_UEC3_UCC_NUM == 2 /* UCC3 */ |
| 611 | { "/" OF_QE "/ucc@2200", |
| 612 | "mac-address", |
| 613 | fdt_set_eth2 |
| 614 | }, |
| 615 | { "/" OF_QE "/ucc@2200", |
| 616 | "local-mac-address", |
| 617 | fdt_set_eth2 |
| 618 | }, |
| 619 | #elif CFG_UEC3_UCC_NUM == 3 /* UCC4 */ |
| 620 | { "/" OF_QE "/ucc@3200", |
| 621 | "mac-address", |
| 622 | fdt_set_eth2 |
| 623 | }, |
| 624 | { "/" OF_QE "/ucc@3200", |
| 625 | "local-mac-address", |
| 626 | fdt_set_eth2 |
| 627 | }, |
| 628 | #endif |
| 629 | #endif /* CONFIG_UEC_ETH3 */ |
| 630 | #ifdef CONFIG_UEC_ETH4 |
| 631 | #if CFG_UEC4_UCC_NUM == 0 /* UCC1 */ |
| 632 | { "/" OF_QE "/ucc@2000", |
| 633 | "mac-address", |
| 634 | fdt_set_eth3 |
| 635 | }, |
| 636 | { "/" OF_QE "/ucc@2000", |
| 637 | "local-mac-address", |
| 638 | fdt_set_eth3 |
| 639 | }, |
| 640 | #elif CFG_UEC4_UCC_NUM == 1 /* UCC2 */ |
| 641 | { "/" OF_QE "/ucc@3000", |
| 642 | "mac-address", |
| 643 | fdt_set_eth3 |
| 644 | }, |
| 645 | { "/" OF_QE "/ucc@3000", |
| 646 | "local-mac-address", |
| 647 | fdt_set_eth3 |
| 648 | }, |
| 649 | #elif CFG_UEC4_UCC_NUM == 2 /* UCC3 */ |
| 650 | { "/" OF_QE "/ucc@2200", |
| 651 | "mac-address", |
| 652 | fdt_set_eth3 |
| 653 | }, |
| 654 | { "/" OF_QE "/ucc@2200", |
| 655 | "local-mac-address", |
| 656 | fdt_set_eth3 |
| 657 | }, |
| 658 | #elif CFG_UEC4_UCC_NUM == 3 /* UCC4 */ |
| 659 | { "/" OF_QE "/ucc@3200", |
| 660 | "mac-address", |
| 661 | fdt_set_eth3 |
| 662 | }, |
| 663 | { "/" OF_QE "/ucc@3200", |
| 664 | "local-mac-address", |
| 665 | fdt_set_eth3 |
| 666 | }, |
| 667 | #endif |
| 668 | #endif /* CONFIG_UEC_ETH4 */ |
Kim Phillips | 8f9e0e9 | 2007-08-15 22:30:19 -0500 | [diff] [blame] | 669 | #endif /* CONFIG_QE */ |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 670 | }; |
| 671 | |
| 672 | void |
| 673 | ft_cpu_setup(void *blob, bd_t *bd) |
| 674 | { |
Kim Phillips | 6a16e0d | 2007-08-15 22:30:26 -0500 | [diff] [blame] | 675 | int nodeoffset; |
| 676 | int err; |
| 677 | int j; |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 678 | |
| 679 | for (j = 0; j < (sizeof(fixup_props) / sizeof(fixup_props[0])); j++) { |
Kumar Gala | 8d04f02 | 2007-10-24 11:04:22 -0500 | [diff] [blame] | 680 | nodeoffset = fdt_path_offset(blob, fixup_props[j].node); |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 681 | if (nodeoffset >= 0) { |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 682 | err = fixup_props[j].set_fn(blob, nodeoffset, |
| 683 | fixup_props[j].prop, bd); |
Gerald Van Baren | f35a53f | 2007-04-15 13:54:26 -0400 | [diff] [blame] | 684 | if (err < 0) |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 685 | debug("Problem setting %s = %s: %s\n", |
Kim Phillips | 6a16e0d | 2007-08-15 22:30:26 -0500 | [diff] [blame] | 686 | fixup_props[j].node, fixup_props[j].prop, |
| 687 | fdt_strerror(err)); |
Jerry Van Baren | 8be4044 | 2007-07-04 21:34:24 -0400 | [diff] [blame] | 688 | } else { |
| 689 | debug("Couldn't find %s: %s\n", |
Kim Phillips | 6a16e0d | 2007-08-15 22:30:26 -0500 | [diff] [blame] | 690 | fixup_props[j].node, fdt_strerror(nodeoffset)); |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 691 | } |
| 692 | } |
Kim Phillips | 6a16e0d | 2007-08-15 22:30:26 -0500 | [diff] [blame] | 693 | |
Kumar Gala | 246d4ae | 2007-11-27 21:59:46 -0600 | [diff] [blame] | 694 | fdt_fixup_memory(blob, (u64)bd->bi_memstart, (u64)bd->bi_memsize); |
Gerald Van Baren | 213bf8c | 2007-03-31 12:23:51 -0400 | [diff] [blame] | 695 | } |
Jerry Van Baren | 26d02c9 | 2007-07-04 21:27:30 -0400 | [diff] [blame] | 696 | #elif defined(CONFIG_OF_FLAT_TREE) |
Kumar Gala | 62ec641 | 2006-01-11 16:48:10 -0600 | [diff] [blame] | 697 | void |
| 698 | ft_cpu_setup(void *blob, bd_t *bd) |
| 699 | { |
| 700 | u32 *p; |
| 701 | int len; |
| 702 | ulong clock; |
| 703 | |
| 704 | clock = bd->bi_busfreq; |
| 705 | p = ft_get_prop(blob, "/cpus/" OF_CPU "/bus-frequency", &len); |
| 706 | if (p != NULL) |
| 707 | *p = cpu_to_be32(clock); |
| 708 | |
| 709 | p = ft_get_prop(blob, "/" OF_SOC "/bus-frequency", &len); |
| 710 | if (p != NULL) |
| 711 | *p = cpu_to_be32(clock); |
| 712 | |
| 713 | p = ft_get_prop(blob, "/" OF_SOC "/serial@4500/clock-frequency", &len); |
| 714 | if (p != NULL) |
| 715 | *p = cpu_to_be32(clock); |
| 716 | |
| 717 | p = ft_get_prop(blob, "/" OF_SOC "/serial@4600/clock-frequency", &len); |
| 718 | if (p != NULL) |
| 719 | *p = cpu_to_be32(clock); |
| 720 | |
Kim Phillips | 255a3577 | 2007-05-16 16:52:19 -0500 | [diff] [blame] | 721 | #ifdef CONFIG_TSEC1 |
Timur Tabi | 61f4f91 | 2007-02-13 10:41:42 -0600 | [diff] [blame] | 722 | p = ft_get_prop(blob, "/" OF_SOC "/ethernet@24000/mac-address", &len); |
| 723 | if (p != NULL) |
| 724 | memcpy(p, bd->bi_enetaddr, 6); |
| 725 | |
Kim Phillips | 4804136 | 2006-11-01 00:07:25 -0600 | [diff] [blame] | 726 | p = ft_get_prop(blob, "/" OF_SOC "/ethernet@24000/local-mac-address", &len); |
Kim Phillips | b700474 | 2007-01-30 16:15:21 -0600 | [diff] [blame] | 727 | if (p != NULL) |
Kumar Gala | 62ec641 | 2006-01-11 16:48:10 -0600 | [diff] [blame] | 728 | memcpy(p, bd->bi_enetaddr, 6); |
| 729 | #endif |
| 730 | |
Kim Phillips | 255a3577 | 2007-05-16 16:52:19 -0500 | [diff] [blame] | 731 | #ifdef CONFIG_TSEC2 |
Timur Tabi | 61f4f91 | 2007-02-13 10:41:42 -0600 | [diff] [blame] | 732 | p = ft_get_prop(blob, "/" OF_SOC "/ethernet@25000/mac-address", &len); |
| 733 | if (p != NULL) |
| 734 | memcpy(p, bd->bi_enet1addr, 6); |
| 735 | |
Kim Phillips | 4804136 | 2006-11-01 00:07:25 -0600 | [diff] [blame] | 736 | p = ft_get_prop(blob, "/" OF_SOC "/ethernet@25000/local-mac-address", &len); |
Kim Phillips | b700474 | 2007-01-30 16:15:21 -0600 | [diff] [blame] | 737 | if (p != NULL) |
Kumar Gala | 62ec641 | 2006-01-11 16:48:10 -0600 | [diff] [blame] | 738 | memcpy(p, bd->bi_enet1addr, 6); |
| 739 | #endif |
Kim Phillips | d51b3cf | 2007-02-22 20:06:57 -0600 | [diff] [blame] | 740 | |
| 741 | #ifdef CONFIG_UEC_ETH1 |
| 742 | #if CFG_UEC1_UCC_NUM == 0 /* UCC1 */ |
| 743 | p = ft_get_prop(blob, "/" OF_QE "/ucc@2000/mac-address", &len); |
| 744 | if (p != NULL) |
| 745 | memcpy(p, bd->bi_enetaddr, 6); |
| 746 | |
| 747 | p = ft_get_prop(blob, "/" OF_QE "/ucc@2000/local-mac-address", &len); |
| 748 | if (p != NULL) |
| 749 | memcpy(p, bd->bi_enetaddr, 6); |
| 750 | #elif CFG_UEC1_UCC_NUM == 2 /* UCC3 */ |
| 751 | p = ft_get_prop(blob, "/" OF_QE "/ucc@2200/mac-address", &len); |
| 752 | if (p != NULL) |
| 753 | memcpy(p, bd->bi_enetaddr, 6); |
| 754 | |
| 755 | p = ft_get_prop(blob, "/" OF_QE "/ucc@2200/local-mac-address", &len); |
| 756 | if (p != NULL) |
| 757 | memcpy(p, bd->bi_enetaddr, 6); |
| 758 | #endif |
| 759 | #endif |
| 760 | |
| 761 | #ifdef CONFIG_UEC_ETH2 |
| 762 | #if CFG_UEC2_UCC_NUM == 1 /* UCC2 */ |
| 763 | p = ft_get_prop(blob, "/" OF_QE "/ucc@3000/mac-address", &len); |
| 764 | if (p != NULL) |
| 765 | memcpy(p, bd->bi_enet1addr, 6); |
| 766 | |
| 767 | p = ft_get_prop(blob, "/" OF_QE "/ucc@3000/local-mac-address", &len); |
| 768 | if (p != NULL) |
| 769 | memcpy(p, bd->bi_enet1addr, 6); |
| 770 | #elif CFG_UEC2_UCC_NUM == 3 /* UCC4 */ |
| 771 | p = ft_get_prop(blob, "/" OF_QE "/ucc@3200/mac-address", &len); |
| 772 | if (p != NULL) |
| 773 | memcpy(p, bd->bi_enet1addr, 6); |
| 774 | |
| 775 | p = ft_get_prop(blob, "/" OF_QE "/ucc@3200/local-mac-address", &len); |
| 776 | if (p != NULL) |
| 777 | memcpy(p, bd->bi_enet1addr, 6); |
| 778 | #endif |
| 779 | #endif |
Kumar Gala | 62ec641 | 2006-01-11 16:48:10 -0600 | [diff] [blame] | 780 | } |
| 781 | #endif |
Marian Balakowicz | 61f2515 | 2006-03-14 16:14:48 +0100 | [diff] [blame] | 782 | |
| 783 | #if defined(CONFIG_DDR_ECC) |
| 784 | void dma_init(void) |
| 785 | { |
Timur Tabi | d239d74 | 2006-11-03 12:00:28 -0600 | [diff] [blame] | 786 | volatile immap_t *immap = (immap_t *)CFG_IMMR; |
Dave Liu | f6eda7f | 2006-10-25 14:41:21 -0500 | [diff] [blame] | 787 | volatile dma83xx_t *dma = &immap->dma; |
Marian Balakowicz | 61f2515 | 2006-03-14 16:14:48 +0100 | [diff] [blame] | 788 | volatile u32 status = swab32(dma->dmasr0); |
| 789 | volatile u32 dmamr0 = swab32(dma->dmamr0); |
| 790 | |
| 791 | debug("DMA-init\n"); |
| 792 | |
| 793 | /* initialize DMASARn, DMADAR and DMAABCRn */ |
| 794 | dma->dmadar0 = (u32)0; |
| 795 | dma->dmasar0 = (u32)0; |
| 796 | dma->dmabcr0 = 0; |
| 797 | |
| 798 | __asm__ __volatile__ ("sync"); |
| 799 | __asm__ __volatile__ ("isync"); |
| 800 | |
| 801 | /* clear CS bit */ |
| 802 | dmamr0 &= ~DMA_CHANNEL_START; |
| 803 | dma->dmamr0 = swab32(dmamr0); |
| 804 | __asm__ __volatile__ ("sync"); |
| 805 | __asm__ __volatile__ ("isync"); |
| 806 | |
| 807 | /* while the channel is busy, spin */ |
| 808 | while(status & DMA_CHANNEL_BUSY) { |
| 809 | status = swab32(dma->dmasr0); |
| 810 | } |
| 811 | |
| 812 | debug("DMA-init end\n"); |
| 813 | } |
| 814 | |
| 815 | uint dma_check(void) |
| 816 | { |
Timur Tabi | d239d74 | 2006-11-03 12:00:28 -0600 | [diff] [blame] | 817 | volatile immap_t *immap = (immap_t *)CFG_IMMR; |
Dave Liu | f6eda7f | 2006-10-25 14:41:21 -0500 | [diff] [blame] | 818 | volatile dma83xx_t *dma = &immap->dma; |
Marian Balakowicz | 61f2515 | 2006-03-14 16:14:48 +0100 | [diff] [blame] | 819 | volatile u32 status = swab32(dma->dmasr0); |
| 820 | volatile u32 byte_count = swab32(dma->dmabcr0); |
| 821 | |
| 822 | /* while the channel is busy, spin */ |
| 823 | while (status & DMA_CHANNEL_BUSY) { |
| 824 | status = swab32(dma->dmasr0); |
| 825 | } |
| 826 | |
| 827 | if (status & DMA_CHANNEL_TRANSFER_ERROR) { |
| 828 | printf ("DMA Error: status = %x @ %d\n", status, byte_count); |
| 829 | } |
| 830 | |
| 831 | return status; |
| 832 | } |
| 833 | |
| 834 | int dma_xfer(void *dest, u32 count, void *src) |
| 835 | { |
Timur Tabi | d239d74 | 2006-11-03 12:00:28 -0600 | [diff] [blame] | 836 | volatile immap_t *immap = (immap_t *)CFG_IMMR; |
Dave Liu | f6eda7f | 2006-10-25 14:41:21 -0500 | [diff] [blame] | 837 | volatile dma83xx_t *dma = &immap->dma; |
Marian Balakowicz | 61f2515 | 2006-03-14 16:14:48 +0100 | [diff] [blame] | 838 | volatile u32 dmamr0; |
| 839 | |
| 840 | /* initialize DMASARn, DMADAR and DMAABCRn */ |
| 841 | dma->dmadar0 = swab32((u32)dest); |
| 842 | dma->dmasar0 = swab32((u32)src); |
| 843 | dma->dmabcr0 = swab32(count); |
| 844 | |
| 845 | __asm__ __volatile__ ("sync"); |
| 846 | __asm__ __volatile__ ("isync"); |
| 847 | |
| 848 | /* init direct transfer, clear CS bit */ |
| 849 | dmamr0 = (DMA_CHANNEL_TRANSFER_MODE_DIRECT | |
| 850 | DMA_CHANNEL_SOURCE_ADDRESS_HOLD_8B | |
| 851 | DMA_CHANNEL_SOURCE_ADRESSS_HOLD_EN); |
Wolfgang Denk | cf48eb9 | 2006-04-16 10:51:58 +0200 | [diff] [blame] | 852 | |
Marian Balakowicz | 61f2515 | 2006-03-14 16:14:48 +0100 | [diff] [blame] | 853 | dma->dmamr0 = swab32(dmamr0); |
| 854 | |
| 855 | __asm__ __volatile__ ("sync"); |
| 856 | __asm__ __volatile__ ("isync"); |
| 857 | |
| 858 | /* set CS to start DMA transfer */ |
| 859 | dmamr0 |= DMA_CHANNEL_START; |
| 860 | dma->dmamr0 = swab32(dmamr0); |
| 861 | __asm__ __volatile__ ("sync"); |
| 862 | __asm__ __volatile__ ("isync"); |
| 863 | |
| 864 | return ((int)dma_check()); |
| 865 | } |
| 866 | #endif /*CONFIG_DDR_ECC*/ |