2 * Carsten Langgaard, carstenl@mips.com
3 * Copyright (C) 2000 MIPS Technologies, Inc. All rights reserved.
4 * Portions copyright (C) 2009 Cisco Systems, Inc.
6 * This program is free software; you can distribute it and/or modify it
7 * under the terms of the GNU General Public License (Version 2) as
8 * published by the Free Software Foundation.
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
19 #include <linux/init.h>
20 #include <linux/sched.h>
21 #include <linux/ioport.h>
22 #include <linux/pci.h>
23 #include <linux/screen_info.h>
24 #include <linux/notifier.h>
25 #include <linux/etherdevice.h>
26 #include <linux/if_ether.h>
27 #include <linux/ctype.h>
28 #include <linux/cpu.h>
29 #include <linux/time.h>
31 #include <asm/bootinfo.h>
33 #include <asm/mips-boards/generic.h>
34 #include <asm/mips-boards/prom.h>
37 #include <asm/traps.h>
38 #include <asm/asm-offsets.h>
44 * Macros for loading addresses and storing registers:
45 * LONG_L_ Stringified version of LONG_L for use in asm() statement
46 * LONG_S_ Stringified version of LONG_S for use in asm() statement
47 * PTR_LA_ Stringified version of PTR_LA for use in asm() statement
48 * REG_SIZE Number of 8-bit bytes in a full width register
50 #define LONG_L_ VAL(LONG_L) " "
51 #define LONG_S_ VAL(LONG_S) " "
52 #define PTR_LA_ VAL(PTR_LA) " "
55 #warning TODO: 64-bit code needs to be verified
56 #define REG_SIZE "8" /* In bytes */
60 #define REG_SIZE "4" /* In bytes */
63 static void register_panic_notifier(void);
64 static int panic_handler(struct notifier_block
*notifier_block
,
65 unsigned long event
, void *cause_string
);
67 const char *get_system_type(void)
72 void __init
plat_mem_setup(void)
75 register_panic_notifier();
81 * Install a panic notifier for platform-specific diagnostics
83 static void register_panic_notifier()
85 static struct notifier_block panic_notifier
= {
86 .notifier_call
= panic_handler
,
90 atomic_notifier_chain_register(&panic_notifier_list
, &panic_notifier
);
93 static int panic_handler(struct notifier_block
*notifier_block
,
94 unsigned long event
, void *cause_string
)
96 struct pt_regs my_regs
;
98 /* Save all of the registers */
100 unsigned long at
, v0
, v1
; /* Must be on the stack */
102 /* Start by saving $at and v0 on the stack. We use $at
103 * ourselves, but it looks like the compiler may use v0 or v1
104 * to load the address of the pt_regs structure. We'll come
105 * back later to store the registers in the pt_regs
107 __asm__
__volatile__ (
109 LONG_S_
"$at, %[at]\n"
110 LONG_S_
"$2, %[v0]\n"
111 LONG_S_
"$3, %[v1]\n"
120 __asm__
__volatile__ (
122 "move $at, %[pt_regs]\n"
124 /* Argument registers */
125 LONG_S_
"$4, " VAL(PT_R4
) "($at)\n"
126 LONG_S_
"$5, " VAL(PT_R5
) "($at)\n"
127 LONG_S_
"$6, " VAL(PT_R6
) "($at)\n"
128 LONG_S_
"$7, " VAL(PT_R7
) "($at)\n"
131 LONG_S_
"$8, " VAL(PT_R8
) "($at)\n"
132 LONG_S_
"$9, " VAL(PT_R9
) "($at)\n"
133 LONG_S_
"$10, " VAL(PT_R10
) "($at)\n"
134 LONG_S_
"$11, " VAL(PT_R11
) "($at)\n"
135 LONG_S_
"$12, " VAL(PT_R12
) "($at)\n"
136 LONG_S_
"$13, " VAL(PT_R13
) "($at)\n"
137 LONG_S_
"$14, " VAL(PT_R14
) "($at)\n"
138 LONG_S_
"$15, " VAL(PT_R15
) "($at)\n"
140 /* "Saved" registers */
141 LONG_S_
"$16, " VAL(PT_R16
) "($at)\n"
142 LONG_S_
"$17, " VAL(PT_R17
) "($at)\n"
143 LONG_S_
"$18, " VAL(PT_R18
) "($at)\n"
144 LONG_S_
"$19, " VAL(PT_R19
) "($at)\n"
145 LONG_S_
"$20, " VAL(PT_R20
) "($at)\n"
146 LONG_S_
"$21, " VAL(PT_R21
) "($at)\n"
147 LONG_S_
"$22, " VAL(PT_R22
) "($at)\n"
148 LONG_S_
"$23, " VAL(PT_R23
) "($at)\n"
150 /* Add'l temp regs */
151 LONG_S_
"$24, " VAL(PT_R24
) "($at)\n"
152 LONG_S_
"$25, " VAL(PT_R25
) "($at)\n"
154 /* Kernel temp regs */
155 LONG_S_
"$26, " VAL(PT_R26
) "($at)\n"
156 LONG_S_
"$27, " VAL(PT_R27
) "($at)\n"
158 /* Global pointer, stack pointer, frame pointer and
160 LONG_S_
"$gp, " VAL(PT_R28
) "($at)\n"
161 LONG_S_
"$sp, " VAL(PT_R29
) "($at)\n"
162 LONG_S_
"$fp, " VAL(PT_R30
) "($at)\n"
163 LONG_S_
"$ra, " VAL(PT_R31
) "($at)\n"
165 /* Now we can get the $at and v0 registers back and
167 LONG_L_
"$8, %[at]\n"
168 LONG_S_
"$8, " VAL(PT_R1
) "($at)\n"
169 LONG_L_
"$8, %[v0]\n"
170 LONG_S_
"$8, " VAL(PT_R2
) "($at)\n"
171 LONG_L_
"$8, %[v1]\n"
172 LONG_S_
"$8, " VAL(PT_R3
) "($at)\n"
178 [pt_regs
] "r" (&my_regs
)
182 /* Set the current EPC value to be the current location in this
184 __asm__
__volatile__ (
188 LONG_S_
"$at, %[cp0_epc]\n"
190 [cp0_epc
] "=m" (my_regs
.cp0_epc
)
195 my_regs
.cp0_cause
= read_c0_cause();
196 my_regs
.cp0_status
= read_c0_status();
199 pr_crit("I'm feeling a bit sleepy. hmmmmm... perhaps a nap would... "
205 /* Information about the RF MAC address, if one was supplied on the
207 static bool have_rfmac
;
208 static u8 rfmac
[ETH_ALEN
];
210 static int rfmac_param(char *p
)
216 /* Skip a leading "0x", if present */
217 if (*p
== '0' && *(p
+1) == 'x')
221 is_high_nibble
= true;
223 for (c
= (unsigned char) *p
++;
224 isxdigit(c
) && q
- rfmac
< ETH_ALEN
;
225 c
= (unsigned char) *p
++) {
228 nibble
= (isdigit(c
) ? (c
- '0') :
229 (isupper(c
) ? c
- 'A' + 10 : c
- 'a' + 10));
236 is_high_nibble
= !is_high_nibble
;
239 /* If we parsed all the way to the end of the parameter value and
240 * parsed all ETH_ALEN bytes, we have a usable RF MAC address */
241 have_rfmac
= (c
== '\0' && q
- rfmac
== ETH_ALEN
);
246 early_param("rfmac", rfmac_param
);
249 * Generate an Ethernet MAC address that has a good chance of being unique.
250 * @addr: Pointer to six-byte array containing the Ethernet address
251 * Generates an Ethernet MAC address that is highly likely to be unique for
252 * this particular system on a network with other systems of the same type.
254 * The problem we are solving is that, when random_ether_addr() is used to
255 * generate MAC addresses at startup, there isn't much entropy for the random
256 * number generator to use and the addresses it produces are fairly likely to
257 * be the same as those of other identical systems on the same local network.
258 * This is true even for relatively small numbers of systems (for the reason
259 * why, see the Wikipedia entry for "Birthday problem" at:
260 * http://en.wikipedia.org/wiki/Birthday_problem
262 * The good news is that we already have a MAC address known to be unique, the
263 * RF MAC address. The bad news is that this address is already in use on the
264 * RF interface. Worse, the obvious trick, taking the RF MAC address and
265 * turning on the locally managed bit, has already been used for other devices.
266 * Still, this does give us something to work with.
268 * The approach we take is:
269 * 1. If we can't get the RF MAC Address, just call random_ether_addr.
270 * 2. Use the 24-bit NIC-specific bits of the RF MAC address as the last 24
271 * bits of the new address. This is very likely to be unique, except for
273 * 3. To avoid using addresses already on the current box, we set the top
274 * six bits of the address with a value different from any currently
275 * registered Scientific Atlanta organizationally unique identifyer
276 * (OUI). This avoids duplication with any addresses on the system that
277 * were generated from valid Scientific Atlanta-registered address by
278 * simply flipping the locally managed bit.
279 * 4. We aren't generating a multicast address, so we leave the multicast
280 * bit off. Since we aren't using a registered address, we have to set
281 * the locally managed bit.
282 * 5. We then randomly generate the remaining 16-bits. This does two
284 * a. It allows us to call this function for more than one device
286 * b. It ensures that things will probably still work even if
287 * some device on the device network has a locally managed
288 * address that matches the top six bits from step 2.
290 void platform_random_ether_addr(u8 addr
[ETH_ALEN
])
292 const int num_random_bytes
= 2;
293 const unsigned char non_sciatl_oui_bits
= 0xc0u
;
294 const unsigned char mac_addr_locally_managed
= (1 << 1);
297 pr_warning("rfmac not available on command line; "
298 "generating random MAC address\n");
299 random_ether_addr(addr
);
305 /* Set the first byte to something that won't match a Scientific
306 * Atlanta OUI, is locally managed, and isn't a multicast
308 addr
[0] = non_sciatl_oui_bits
| mac_addr_locally_managed
;
310 /* Get some bytes of random address information */
311 get_random_bytes(&addr
[1], num_random_bytes
);
313 /* Copy over the NIC-specific bits of the RF MAC address */
314 for (i
= 1 + num_random_bytes
; i
< ETH_ALEN
; i
++)