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