[PATCH] Remove i386_ksyms.c, almost.
[linux-2.6.git] / arch / i386 / kernel / reboot.c
1 /*
2  *  linux/arch/i386/kernel/reboot.c
3  */
4
5 #include <linux/config.h>
6 #include <linux/mm.h>
7 #include <linux/module.h>
8 #include <linux/delay.h>
9 #include <linux/init.h>
10 #include <linux/interrupt.h>
11 #include <linux/mc146818rtc.h>
12 #include <linux/efi.h>
13 #include <linux/dmi.h>
14 #include <asm/uaccess.h>
15 #include <asm/apic.h>
16 #include "mach_reboot.h"
17 #include <linux/reboot_fixups.h>
18
19 /*
20  * Power off function, if any
21  */
22 void (*pm_power_off)(void);
23 EXPORT_SYMBOL(pm_power_off);
24
25 static int reboot_mode;
26 static int reboot_thru_bios;
27
28 #ifdef CONFIG_SMP
29 int reboot_smp = 0;
30 static int reboot_cpu = -1;
31 /* shamelessly grabbed from lib/vsprintf.c for readability */
32 #define is_digit(c)     ((c) >= '0' && (c) <= '9')
33 #endif
34 static int __init reboot_setup(char *str)
35 {
36         while(1) {
37                 switch (*str) {
38                 case 'w': /* "warm" reboot (no memory testing etc) */
39                         reboot_mode = 0x1234;
40                         break;
41                 case 'c': /* "cold" reboot (with memory testing etc) */
42                         reboot_mode = 0x0;
43                         break;
44                 case 'b': /* "bios" reboot by jumping through the BIOS */
45                         reboot_thru_bios = 1;
46                         break;
47                 case 'h': /* "hard" reboot by toggling RESET and/or crashing the CPU */
48                         reboot_thru_bios = 0;
49                         break;
50 #ifdef CONFIG_SMP
51                 case 's': /* "smp" reboot by executing reset on BSP or other CPU*/
52                         reboot_smp = 1;
53                         if (is_digit(*(str+1))) {
54                                 reboot_cpu = (int) (*(str+1) - '0');
55                                 if (is_digit(*(str+2))) 
56                                         reboot_cpu = reboot_cpu*10 + (int)(*(str+2) - '0');
57                         }
58                                 /* we will leave sorting out the final value 
59                                 when we are ready to reboot, since we might not
60                                 have set up boot_cpu_id or smp_num_cpu */
61                         break;
62 #endif
63                 }
64                 if((str = strchr(str,',')) != NULL)
65                         str++;
66                 else
67                         break;
68         }
69         return 1;
70 }
71
72 __setup("reboot=", reboot_setup);
73
74 /*
75  * Reboot options and system auto-detection code provided by
76  * Dell Inc. so their systems "just work". :-)
77  */
78
79 /*
80  * Some machines require the "reboot=b"  commandline option, this quirk makes that automatic.
81  */
82 static int __init set_bios_reboot(struct dmi_system_id *d)
83 {
84         if (!reboot_thru_bios) {
85                 reboot_thru_bios = 1;
86                 printk(KERN_INFO "%s series board detected. Selecting BIOS-method for reboots.\n", d->ident);
87         }
88         return 0;
89 }
90
91 /*
92  * Some machines require the "reboot=s"  commandline option, this quirk makes that automatic.
93  */
94 static int __init set_smp_reboot(struct dmi_system_id *d)
95 {
96 #ifdef CONFIG_SMP
97         if (!reboot_smp) {
98                 reboot_smp = 1;
99                 printk(KERN_INFO "%s series board detected. Selecting SMP-method for reboots.\n", d->ident);
100         }
101 #endif
102         return 0;
103 }
104
105 /*
106  * Some machines require the "reboot=b,s"  commandline option, this quirk makes that automatic.
107  */
108 static int __init set_smp_bios_reboot(struct dmi_system_id *d)
109 {
110         set_smp_reboot(d);
111         set_bios_reboot(d);
112         return 0;
113 }
114
115 static struct dmi_system_id __initdata reboot_dmi_table[] = {
116         {       /* Handle problems with rebooting on Dell 1300's */
117                 .callback = set_smp_bios_reboot,
118                 .ident = "Dell PowerEdge 1300",
119                 .matches = {
120                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
121                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1300/"),
122                 },
123         },
124         {       /* Handle problems with rebooting on Dell 300's */
125                 .callback = set_bios_reboot,
126                 .ident = "Dell PowerEdge 300",
127                 .matches = {
128                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
129                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 300/"),
130                 },
131         },
132         {       /* Handle problems with rebooting on Dell 2400's */
133                 .callback = set_bios_reboot,
134                 .ident = "Dell PowerEdge 2400",
135                 .matches = {
136                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
137                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2400"),
138                 },
139         },
140         { }
141 };
142
143 static int __init reboot_init(void)
144 {
145         dmi_check_system(reboot_dmi_table);
146         return 0;
147 }
148
149 core_initcall(reboot_init);
150
151 /* The following code and data reboots the machine by switching to real
152    mode and jumping to the BIOS reset entry point, as if the CPU has
153    really been reset.  The previous version asked the keyboard
154    controller to pulse the CPU reset line, which is more thorough, but
155    doesn't work with at least one type of 486 motherboard.  It is easy
156    to stop this code working; hence the copious comments. */
157
158 static unsigned long long
159 real_mode_gdt_entries [3] =
160 {
161         0x0000000000000000ULL,  /* Null descriptor */
162         0x00009a000000ffffULL,  /* 16-bit real-mode 64k code at 0x00000000 */
163         0x000092000100ffffULL   /* 16-bit real-mode 64k data at 0x00000100 */
164 };
165
166 static struct
167 {
168         unsigned short       size __attribute__ ((packed));
169         unsigned long long * base __attribute__ ((packed));
170 }
171 real_mode_gdt = { sizeof (real_mode_gdt_entries) - 1, real_mode_gdt_entries },
172 real_mode_idt = { 0x3ff, NULL },
173 no_idt = { 0, NULL };
174
175
176 /* This is 16-bit protected mode code to disable paging and the cache,
177    switch to real mode and jump to the BIOS reset code.
178
179    The instruction that switches to real mode by writing to CR0 must be
180    followed immediately by a far jump instruction, which set CS to a
181    valid value for real mode, and flushes the prefetch queue to avoid
182    running instructions that have already been decoded in protected
183    mode.
184
185    Clears all the flags except ET, especially PG (paging), PE
186    (protected-mode enable) and TS (task switch for coprocessor state
187    save).  Flushes the TLB after paging has been disabled.  Sets CD and
188    NW, to disable the cache on a 486, and invalidates the cache.  This
189    is more like the state of a 486 after reset.  I don't know if
190    something else should be done for other chips.
191
192    More could be done here to set up the registers as if a CPU reset had
193    occurred; hopefully real BIOSs don't assume much. */
194
195 static unsigned char real_mode_switch [] =
196 {
197         0x66, 0x0f, 0x20, 0xc0,                 /*    movl  %cr0,%eax        */
198         0x66, 0x83, 0xe0, 0x11,                 /*    andl  $0x00000011,%eax */
199         0x66, 0x0d, 0x00, 0x00, 0x00, 0x60,     /*    orl   $0x60000000,%eax */
200         0x66, 0x0f, 0x22, 0xc0,                 /*    movl  %eax,%cr0        */
201         0x66, 0x0f, 0x22, 0xd8,                 /*    movl  %eax,%cr3        */
202         0x66, 0x0f, 0x20, 0xc3,                 /*    movl  %cr0,%ebx        */
203         0x66, 0x81, 0xe3, 0x00, 0x00, 0x00, 0x60,       /*    andl  $0x60000000,%ebx */
204         0x74, 0x02,                             /*    jz    f                */
205         0x0f, 0x09,                             /*    wbinvd                 */
206         0x24, 0x10,                             /* f: andb  $0x10,al         */
207         0x66, 0x0f, 0x22, 0xc0                  /*    movl  %eax,%cr0        */
208 };
209 static unsigned char jump_to_bios [] =
210 {
211         0xea, 0x00, 0x00, 0xff, 0xff            /*    ljmp  $0xffff,$0x0000  */
212 };
213
214 /*
215  * Switch to real mode and then execute the code
216  * specified by the code and length parameters.
217  * We assume that length will aways be less that 100!
218  */
219 void machine_real_restart(unsigned char *code, int length)
220 {
221         unsigned long flags;
222
223         local_irq_disable();
224
225         /* Write zero to CMOS register number 0x0f, which the BIOS POST
226            routine will recognize as telling it to do a proper reboot.  (Well
227            that's what this book in front of me says -- it may only apply to
228            the Phoenix BIOS though, it's not clear).  At the same time,
229            disable NMIs by setting the top bit in the CMOS address register,
230            as we're about to do peculiar things to the CPU.  I'm not sure if
231            `outb_p' is needed instead of just `outb'.  Use it to be on the
232            safe side.  (Yes, CMOS_WRITE does outb_p's. -  Paul G.)
233          */
234
235         spin_lock_irqsave(&rtc_lock, flags);
236         CMOS_WRITE(0x00, 0x8f);
237         spin_unlock_irqrestore(&rtc_lock, flags);
238
239         /* Remap the kernel at virtual address zero, as well as offset zero
240            from the kernel segment.  This assumes the kernel segment starts at
241            virtual address PAGE_OFFSET. */
242
243         memcpy (swapper_pg_dir, swapper_pg_dir + USER_PGD_PTRS,
244                 sizeof (swapper_pg_dir [0]) * KERNEL_PGD_PTRS);
245
246         /*
247          * Use `swapper_pg_dir' as our page directory.
248          */
249         load_cr3(swapper_pg_dir);
250
251         /* Write 0x1234 to absolute memory location 0x472.  The BIOS reads
252            this on booting to tell it to "Bypass memory test (also warm
253            boot)".  This seems like a fairly standard thing that gets set by
254            REBOOT.COM programs, and the previous reset routine did this
255            too. */
256
257         *((unsigned short *)0x472) = reboot_mode;
258
259         /* For the switch to real mode, copy some code to low memory.  It has
260            to be in the first 64k because it is running in 16-bit mode, and it
261            has to have the same physical and virtual address, because it turns
262            off paging.  Copy it near the end of the first page, out of the way
263            of BIOS variables. */
264
265         memcpy ((void *) (0x1000 - sizeof (real_mode_switch) - 100),
266                 real_mode_switch, sizeof (real_mode_switch));
267         memcpy ((void *) (0x1000 - 100), code, length);
268
269         /* Set up the IDT for real mode. */
270
271         __asm__ __volatile__ ("lidt %0" : : "m" (real_mode_idt));
272
273         /* Set up a GDT from which we can load segment descriptors for real
274            mode.  The GDT is not used in real mode; it is just needed here to
275            prepare the descriptors. */
276
277         __asm__ __volatile__ ("lgdt %0" : : "m" (real_mode_gdt));
278
279         /* Load the data segment registers, and thus the descriptors ready for
280            real mode.  The base address of each segment is 0x100, 16 times the
281            selector value being loaded here.  This is so that the segment
282            registers don't have to be reloaded after switching to real mode:
283            the values are consistent for real mode operation already. */
284
285         __asm__ __volatile__ ("movl $0x0010,%%eax\n"
286                                 "\tmovl %%eax,%%ds\n"
287                                 "\tmovl %%eax,%%es\n"
288                                 "\tmovl %%eax,%%fs\n"
289                                 "\tmovl %%eax,%%gs\n"
290                                 "\tmovl %%eax,%%ss" : : : "eax");
291
292         /* Jump to the 16-bit code that we copied earlier.  It disables paging
293            and the cache, switches to real mode, and jumps to the BIOS reset
294            entry point. */
295
296         __asm__ __volatile__ ("ljmp $0x0008,%0"
297                                 :
298                                 : "i" ((void *) (0x1000 - sizeof (real_mode_switch) - 100)));
299 }
300 #ifdef CONFIG_APM_MODULE
301 EXPORT_SYMBOL(machine_real_restart);
302 #endif
303
304 void machine_restart(char * __unused)
305 {
306 #ifdef CONFIG_SMP
307         int cpuid;
308         
309         cpuid = GET_APIC_ID(apic_read(APIC_ID));
310
311         if (reboot_smp) {
312
313                 /* check to see if reboot_cpu is valid 
314                    if its not, default to the BSP */
315                 if ((reboot_cpu == -1) ||  
316                       (reboot_cpu > (NR_CPUS -1))  || 
317                       !physid_isset(cpuid, phys_cpu_present_map))
318                         reboot_cpu = boot_cpu_physical_apicid;
319
320                 reboot_smp = 0;  /* use this as a flag to only go through this once*/
321                 /* re-run this function on the other CPUs
322                    it will fall though this section since we have 
323                    cleared reboot_smp, and do the reboot if it is the
324                    correct CPU, otherwise it halts. */
325                 if (reboot_cpu != cpuid)
326                         smp_call_function((void *)machine_restart , NULL, 1, 0);
327         }
328
329         /* if reboot_cpu is still -1, then we want a tradional reboot, 
330            and if we are not running on the reboot_cpu,, halt */
331         if ((reboot_cpu != -1) && (cpuid != reboot_cpu)) {
332                 for (;;)
333                 __asm__ __volatile__ ("hlt");
334         }
335         /*
336          * Stop all CPUs and turn off local APICs and the IO-APIC, so
337          * other OSs see a clean IRQ state.
338          */
339         smp_send_stop();
340 #endif /* CONFIG_SMP */
341
342         lapic_shutdown();
343
344 #ifdef CONFIG_X86_IO_APIC
345         disable_IO_APIC();
346 #endif
347
348         if (!reboot_thru_bios) {
349                 if (efi_enabled) {
350                         efi.reset_system(EFI_RESET_COLD, EFI_SUCCESS, 0, NULL);
351                         __asm__ __volatile__("lidt %0": :"m" (no_idt));
352                         __asm__ __volatile__("int3");
353                 }
354                 /* rebooting needs to touch the page at absolute addr 0 */
355                 *((unsigned short *)__va(0x472)) = reboot_mode;
356                 for (;;) {
357                         mach_reboot_fixups(); /* for board specific fixups */
358                         mach_reboot();
359                         /* That didn't work - force a triple fault.. */
360                         __asm__ __volatile__("lidt %0": :"m" (no_idt));
361                         __asm__ __volatile__("int3");
362                 }
363         }
364         if (efi_enabled)
365                 efi.reset_system(EFI_RESET_WARM, EFI_SUCCESS, 0, NULL);
366
367         machine_real_restart(jump_to_bios, sizeof(jump_to_bios));
368 }
369
370 EXPORT_SYMBOL(machine_restart);
371
372 void machine_halt(void)
373 {
374 }
375
376 EXPORT_SYMBOL(machine_halt);
377
378 void machine_power_off(void)
379 {
380         lapic_shutdown();
381
382         if (efi_enabled)
383                 efi.reset_system(EFI_RESET_SHUTDOWN, EFI_SUCCESS, 0, NULL);
384         if (pm_power_off)
385                 pm_power_off();
386 }
387
388 EXPORT_SYMBOL(machine_power_off);
389