1/* 2 * Carsten Langgaard, carstenl@mips.com 3 * Copyright (C) 2000 MIPS Technologies, Inc. All rights reserved. 4 * Portions copyright (C) 2009 Cisco Systems, Inc. 5 * 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. 9 * 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 13 * for more details. 14 * 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. 18 */ 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> 30 31#include <asm/bootinfo.h> 32#include <asm/irq.h> 33#include <asm/mips-boards/generic.h> 34#include <asm/mips-boards/prom.h> 35#include <asm/dma.h> 36#include <asm/asm.h> 37#include <asm/traps.h> 38#include <asm/asm-offsets.h> 39#include "reset.h" 40 41#define VAL(n) STR(n) 42 43/* 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 49 */ 50#define LONG_L_ VAL(LONG_L) " " 51#define LONG_S_ VAL(LONG_S) " " 52#define PTR_LA_ VAL(PTR_LA) " " 53 54#ifdef CONFIG_64BIT 55#warning TODO: 64-bit code needs to be verified 56#define REG_SIZE "8" /* In bytes */ 57#endif 58 59#ifdef CONFIG_32BIT 60#define REG_SIZE "4" /* In bytes */ 61#endif 62 63static void register_panic_notifier(void); 64static int panic_handler(struct notifier_block *notifier_block, 65 unsigned long event, void *cause_string); 66 67const char *get_system_type(void) 68{ 69 return "PowerTV"; 70} 71 72void __init plat_mem_setup(void) 73{ 74 panic_on_oops = 1; 75 register_panic_notifier(); 76 77 mips_reboot_setup(); 78} 79 80/* 81 * Install a panic notifier for platform-specific diagnostics 82 */ 83static void register_panic_notifier() 84{ 85 static struct notifier_block panic_notifier = { 86 .notifier_call = panic_handler, 87 .next = NULL, 88 .priority = INT_MAX 89 }; 90 atomic_notifier_chain_register(&panic_notifier_list, &panic_notifier); 91} 92 93static int panic_handler(struct notifier_block *notifier_block, 94 unsigned long event, void *cause_string) 95{ 96 struct pt_regs my_regs; 97 98 /* Save all of the registers */ 99 { 100 unsigned long at, v0, v1; /* Must be on the stack */ 101 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 106 * structure. */ 107 __asm__ __volatile__ ( 108 ".set noat\n" 109 LONG_S_ "$at, %[at]\n" 110 LONG_S_ "$2, %[v0]\n" 111 LONG_S_ "$3, %[v1]\n" 112 : 113 [at] "=m" (at), 114 [v0] "=m" (v0), 115 [v1] "=m" (v1) 116 : 117 : "at" 118 ); 119 120 __asm__ __volatile__ ( 121 ".set noat\n" 122 "move $at, %[pt_regs]\n" 123 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" 129 130 /* Temporary regs */ 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" 139 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" 149 150 /* Add'l temp regs */ 151 LONG_S_ "$24, " VAL(PT_R24) "($at)\n" 152 LONG_S_ "$25, " VAL(PT_R25) "($at)\n" 153 154 /* Kernel temp regs */ 155 LONG_S_ "$26, " VAL(PT_R26) "($at)\n" 156 LONG_S_ "$27, " VAL(PT_R27) "($at)\n" 157 158 /* Global pointer, stack pointer, frame pointer and 159 * return address */ 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" 164 165 /* Now we can get the $at and v0 registers back and 166 * store them */ 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" 173 : 174 : 175 [at] "m" (at), 176 [v0] "m" (v0), 177 [v1] "m" (v1), 178 [pt_regs] "r" (&my_regs) 179 : "at", "t0" 180 ); 181 182 /* Set the current EPC value to be the current location in this 183 * function */ 184 __asm__ __volatile__ ( 185 ".set noat\n" 186 "1:\n" 187 PTR_LA_ "$at, 1b\n" 188 LONG_S_ "$at, %[cp0_epc]\n" 189 : 190 [cp0_epc] "=m" (my_regs.cp0_epc) 191 : 192 : "at" 193 ); 194 195 my_regs.cp0_cause = read_c0_cause(); 196 my_regs.cp0_status = read_c0_status(); 197 } 198 199 pr_crit("I'm feeling a bit sleepy. hmmmmm... perhaps a nap would... " 200 "zzzz... \n"); 201 202 return NOTIFY_DONE; 203} 204 205/* Information about the RF MAC address, if one was supplied on the 206 * command line. */ 207static bool have_rfmac; 208static u8 rfmac[ETH_ALEN]; 209 210static int rfmac_param(char *p) 211{ 212 u8 *q; 213 bool is_high_nibble; 214 int c; 215 216 /* Skip a leading "0x", if present */ 217 if (*p == '0' && *(p+1) == 'x') 218 p += 2; 219 220 q = rfmac; 221 is_high_nibble = true; 222 223 for (c = (unsigned char) *p++; 224 isxdigit(c) && q - rfmac < ETH_ALEN; 225 c = (unsigned char) *p++) { 226 int nibble; 227 228 nibble = (isdigit(c) ? (c - '0') : 229 (isupper(c) ? c - 'A' + 10 : c - 'a' + 10)); 230 231 if (is_high_nibble) 232 *q = nibble << 4; 233 else 234 *q++ |= nibble; 235 236 is_high_nibble = !is_high_nibble; 237 } 238 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); 242 243 return 0; 244} 245 246early_param("rfmac", rfmac_param); 247 248/* 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. 253 * 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 261 * 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. 267 * 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 272 * the current box. 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 283 * things: 284 * a. It allows us to call this function for more than one device 285 * in this system 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. 289 */ 290void platform_random_ether_addr(u8 addr[ETH_ALEN]) 291{ 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); 295 296 if (!have_rfmac) { 297 pr_warning("rfmac not available on command line; " 298 "generating random MAC address\n"); 299 random_ether_addr(addr); 300 } 301 302 else { 303 int i; 304 305 /* Set the first byte to something that won't match a Scientific 306 * Atlanta OUI, is locally managed, and isn't a multicast 307 * address */ 308 addr[0] = non_sciatl_oui_bits | mac_addr_locally_managed; 309 310 /* Get some bytes of random address information */ 311 get_random_bytes(&addr[1], num_random_bytes); 312 313 /* Copy over the NIC-specific bits of the RF MAC address */ 314 for (i = 1 + num_random_bytes; i < ETH_ALEN; i++) 315 addr[i] = rfmac[i]; 316 } 317} 318