arch/mips/powertv/powertv_setup.c

   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
  29 #include <linux/cpu.h>
  30 #include <asm/bootinfo.h>
  31 #include <asm/irq.h>
  32 #include <asm/mips-boards/generic.h>
  33 #include <asm/mips-boards/prom.h>
  34 #include <asm/dma.h>
  35 #include <linux/time.h>
  36 #include <asm/traps.h>
  37 #include <asm/asm-offsets.h>
  38 #include "reset.h"
  39
  40 #define VAL(n)          STR(n)
  41
  42 /*
  43  * Macros for loading addresses and storing registers:
  44  * PTR_LA       Load the address into a register
  45  * LONG_S       Store the full width of the given register.
  46  * LONG_L       Load the full width of the given register
  47  * PTR_ADDIU    Add a constant value to a register used as a pointer
  48  * REG_SIZE     Number of 8-bit bytes in a full width register
  49  */
  50 #ifdef CONFIG_64BIT
  51 #warning TODO: 64-bit code needs to be verified
  52 #define PTR_LA          "dla    "
  53 #define LONG_S          "sd     "
  54 #define LONG_L          "ld     "
  55 #define PTR_ADDIU       "daddiu "
  56 #define REG_SIZE        "8"             /* In bytes */
  57 #endif
  58
  59 #ifdef CONFIG_32BIT
  60 #define PTR_LA          "la     "
  61 #define LONG_S          "sw     "
  62 #define LONG_L          "lw     "
  63 #define PTR_ADDIU       "addiu  "
  64 #define REG_SIZE        "4"             /* In bytes */
  65 #endif
  66
  67 static struct pt_regs die_regs;
  68 static bool have_die_regs;
  69
  70 static void register_panic_notifier(void);
  71 static int panic_handler(struct notifier_block *notifier_block,
  72         unsigned long event, void *cause_string);
  73
  74 const char *get_system_type(void)
  75 {
  76         return "PowerTV";
  77 }
  78
  79 void __init plat_mem_setup(void)
  80 {
  81         panic_on_oops = 1;
  82         register_panic_notifier();
  83
  84 #if 0
  85         mips_pcibios_init();
  86 #endif
  87         mips_reboot_setup();
  88 }
  89
  90 /*
  91  * Install a panic notifier for platform-specific diagnostics
  92  */
  93 static void register_panic_notifier()
  94 {
  95         static struct notifier_block panic_notifier = {
  96                 .notifier_call = panic_handler,
  97                 .next = NULL,
  98                 .priority       = INT_MAX
  99         };
 100         atomic_notifier_chain_register(&panic_notifier_list, &panic_notifier);
 101 }
 102
 103 static int panic_handler(struct notifier_block *notifier_block,
 104         unsigned long event, void *cause_string)
 105 {
 106         struct pt_regs  my_regs;
 107
 108         /* Save all of the registers */
 109         {
 110                 unsigned long   at, v0, v1; /* Must be on the stack */
 111
 112                 /* Start by saving $at and v0 on the stack. We use $at
 113                  * ourselves, but it looks like the compiler may use v0 or v1
 114                  * to load the address of the pt_regs structure. We'll come
 115                  * back later to store the registers in the pt_regs
 116                  * structure. */
 117                 __asm__ __volatile__ (
 118                         ".set   noat\n"
 119                         LONG_S          "$at, %[at]\n"
 120                         LONG_S          "$2, %[v0]\n"
 121                         LONG_S          "$3, %[v1]\n"
 122                 :
 123                         [at] "=m" (at),
 124                         [v0] "=m" (v0),
 125                         [v1] "=m" (v1)
 126                 :
 127                 :       "at"
 128                 );
 129
 130                 __asm__ __volatile__ (
 131                         ".set   noat\n"
 132                         "move           $at, %[pt_regs]\n"
 133
 134                         /* Argument registers */
 135                         LONG_S          "$4, " VAL(PT_R4) "($at)\n"
 136                         LONG_S          "$5, " VAL(PT_R5) "($at)\n"
 137                         LONG_S          "$6, " VAL(PT_R6) "($at)\n"
 138                         LONG_S          "$7, " VAL(PT_R7) "($at)\n"
 139
 140                         /* Temporary regs */
 141                         LONG_S          "$8, " VAL(PT_R8) "($at)\n"
 142                         LONG_S          "$9, " VAL(PT_R9) "($at)\n"
 143                         LONG_S          "$10, " VAL(PT_R10) "($at)\n"
 144                         LONG_S          "$11, " VAL(PT_R11) "($at)\n"
 145                         LONG_S          "$12, " VAL(PT_R12) "($at)\n"
 146                         LONG_S          "$13, " VAL(PT_R13) "($at)\n"
 147                         LONG_S          "$14, " VAL(PT_R14) "($at)\n"
 148                         LONG_S          "$15, " VAL(PT_R15) "($at)\n"
 149
 150                         /* "Saved" registers */
 151                         LONG_S          "$16, " VAL(PT_R16) "($at)\n"
 152                         LONG_S          "$17, " VAL(PT_R17) "($at)\n"
 153                         LONG_S          "$18, " VAL(PT_R18) "($at)\n"
 154                         LONG_S          "$19, " VAL(PT_R19) "($at)\n"
 155                         LONG_S          "$20, " VAL(PT_R20) "($at)\n"
 156                         LONG_S          "$21, " VAL(PT_R21) "($at)\n"
 157                         LONG_S          "$22, " VAL(PT_R22) "($at)\n"
 158                         LONG_S          "$23, " VAL(PT_R23) "($at)\n"
 159
 160                         /* Add'l temp regs */
 161                         LONG_S          "$24, " VAL(PT_R24) "($at)\n"
 162                         LONG_S          "$25, " VAL(PT_R25) "($at)\n"
 163
 164                         /* Kernel temp regs */
 165                         LONG_S          "$26, " VAL(PT_R26) "($at)\n"
 166                         LONG_S          "$27, " VAL(PT_R27) "($at)\n"
 167
 168                         /* Global pointer, stack pointer, frame pointer and
 169                          * return address */
 170                         LONG_S          "$gp, " VAL(PT_R28) "($at)\n"
 171                         LONG_S          "$sp, " VAL(PT_R29) "($at)\n"
 172                         LONG_S          "$fp, " VAL(PT_R30) "($at)\n"
 173                         LONG_S          "$ra, " VAL(PT_R31) "($at)\n"
 174
 175                         /* Now we can get the $at and v0 registers back and
 176                          * store them */
 177                         LONG_L          "$8, %[at]\n"
 178                         LONG_S          "$8, " VAL(PT_R1) "($at)\n"
 179                         LONG_L          "$8, %[v0]\n"
 180                         LONG_S          "$8, " VAL(PT_R2) "($at)\n"
 181                         LONG_L          "$8, %[v1]\n"
 182                         LONG_S          "$8, " VAL(PT_R3) "($at)\n"
 183                 :
 184                 :
 185                         [at] "m" (at),
 186                         [v0] "m" (v0),
 187                         [v1] "m" (v1),
 188                         [pt_regs] "r" (&my_regs)
 189                 :       "at", "t0"
 190                 );
 191
 192                 /* Set the current EPC value to be the current location in this
 193                  * function */
 194                 __asm__ __volatile__ (
 195                         ".set   noat\n"
 196                 "1:\n"
 197                         PTR_LA          "$at, 1b\n"
 198                         LONG_S          "$at, %[cp0_epc]\n"
 199                 :
 200                         [cp0_epc] "=m" (my_regs.cp0_epc)
 201                 :
 202                 :       "at"
 203                 );
 204
 205                 my_regs.cp0_cause = read_c0_cause();
 206                 my_regs.cp0_status = read_c0_status();
 207         }
 208
 209 #ifdef CONFIG_DIAGNOSTICS
 210         failure_report((char *) cause_string,
 211                 have_die_regs ? &die_regs : &my_regs);
 212         have_die_regs = false;
 213 #else
 214         pr_crit("I'm feeling a bit sleepy. hmmmmm... perhaps a nap would... "
 215                 "zzzz... \n");
 216 #endif
 217
 218         return NOTIFY_DONE;
 219 }
 220
 221 /**
 222  * Platform-specific handling of oops
 223  * @str:        Pointer to the oops string
 224  * @regs:       Pointer to the oops registers
 225  * All we do here is to save the registers for subsequent printing through
 226  * the panic notifier.
 227  */
 228 void platform_die(const char *str, const struct pt_regs *regs)
 229 {
 230         /* If we already have saved registers, don't overwrite them as they
 231          * they apply to the initial fault */
 232
 233         if (!have_die_regs) {
 234                 have_die_regs = true;
 235                 die_regs = *regs;
 236         }
 237 }
 238
 239 /* Information about the RF MAC address, if one was supplied on the
 240  * command line. */
 241 static bool have_rfmac;
 242 static u8 rfmac[ETH_ALEN];
 243
 244 static int rfmac_param(char *p)
 245 {
 246         u8      *q;
 247         bool    is_high_nibble;
 248         int     c;
 249
 250         /* Skip a leading "0x", if present */
 251         if (*p == '0' && *(p+1) == 'x')
 252                 p += 2;
 253
 254         q = rfmac;
 255         is_high_nibble = true;
 256
 257         for (c = (unsigned char) *p++;
 258                 isxdigit(c) && q - rfmac < ETH_ALEN;
 259                 c = (unsigned char) *p++) {
 260                 int     nibble;
 261
 262                 nibble = (isdigit(c) ? (c - '0') :
 263                         (isupper(c) ? c - 'A' + 10 : c - 'a' + 10));
 264
 265                 if (is_high_nibble)
 266                         *q = nibble << 4;
 267                 else
 268                         *q++ |= nibble;
 269
 270                 is_high_nibble = !is_high_nibble;
 271         }
 272
 273         /* If we parsed all the way to the end of the parameter value and
 274          * parsed all ETH_ALEN bytes, we have a usable RF MAC address */
 275         have_rfmac = (c == '\0' && q - rfmac == ETH_ALEN);
 276
 277         return 0;
 278 }
 279
 280 early_param("rfmac", rfmac_param);
 281
 282 /*
 283  * Generate an Ethernet MAC address that has a good chance of being unique.
 284  * @addr:       Pointer to six-byte array containing the Ethernet address
 285  * Generates an Ethernet MAC address that is highly likely to be unique for
 286  * this particular system on a network with other systems of the same type.
 287  *
 288  * The problem we are solving is that, when random_ether_addr() is used to
 289  * generate MAC addresses at startup, there isn't much entropy for the random
 290  * number generator to use and the addresses it produces are fairly likely to
 291  * be the same as those of other identical systems on the same local network.
 292  * This is true even for relatively small numbers of systems (for the reason
 293  * why, see the Wikipedia entry for "Birthday problem" at:
 294  *      http://en.wikipedia.org/wiki/Birthday_problem
 295  *
 296  * The good news is that we already have a MAC address known to be unique, the
 297  * RF MAC address. The bad news is that this address is already in use on the
 298  * RF interface. Worse, the obvious trick, taking the RF MAC address and
 299  * turning on the locally managed bit, has already been used for other devices.
 300  * Still, this does give us something to work with.
 301  *
 302  * The approach we take is:
 303  * 1.   If we can't get the RF MAC Address, just call random_ether_addr.
 304  * 2.   Use the 24-bit NIC-specific bits of the RF MAC address as the last 24
 305  *      bits of the new address. This is very likely to be unique, except for
 306  *      the current box.
 307  * 3.   To avoid using addresses already on the current box, we set the top
 308  *      six bits of the address with a value different from any currently
 309  *      registered Scientific Atlanta organizationally unique identifyer
 310  *      (OUI). This avoids duplication with any addresses on the system that
 311  *      were generated from valid Scientific Atlanta-registered address by
 312  *      simply flipping the locally managed bit.
 313  * 4.   We aren't generating a multicast address, so we leave the multicast
 314  *      bit off. Since we aren't using a registered address, we have to set
 315  *      the locally managed bit.
 316  * 5.   We then randomly generate the remaining 16-bits. This does two
 317  *      things:
 318  *      a.      It allows us to call this function for more than one device
 319  *              in this system
 320  *      b.      It ensures that things will probably still work even if
 321  *              some device on the device network has a locally managed
 322  *              address that matches the top six bits from step 2.
 323  */
 324 void platform_random_ether_addr(u8 addr[ETH_ALEN])
 325 {
 326         const int num_random_bytes = 2;
 327         const unsigned char non_sciatl_oui_bits = 0xc0u;
 328         const unsigned char mac_addr_locally_managed = (1 << 1);
 329
 330         if (!have_rfmac) {
 331                 pr_warning("rfmac not available on command line; "
 332                         "generating random MAC address\n");
 333                 random_ether_addr(addr);
 334         }
 335
 336         else {
 337                 int     i;
 338
 339                 /* Set the first byte to something that won't match a Scientific
 340                  * Atlanta OUI, is locally managed, and isn't a multicast
 341                  * address */
 342                 addr[0] = non_sciatl_oui_bits | mac_addr_locally_managed;
 343
 344                 /* Get some bytes of random address information */
 345                 get_random_bytes(&addr[1], num_random_bytes);
 346
 347                 /* Copy over the NIC-specific bits of the RF MAC address */
 348                 for (i = 1 + num_random_bytes; i < ETH_ALEN; i++)
 349                         addr[i] = rfmac[i];
 350         }
 351 }