Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/cooloney...
[linux-2.6] / arch / x86 / mach-voyager / voyager_basic.c
1 /* Copyright (C) 1999,2001 
2  *
3  * Author: J.E.J.Bottomley@HansenPartnership.com
4  *
5  * This file contains all the voyager specific routines for getting
6  * initialisation of the architecture to function.  For additional
7  * features see:
8  *
9  *      voyager_cat.c - Voyager CAT bus interface
10  *      voyager_smp.c - Voyager SMP hal (emulates linux smp.c)
11  */
12
13 #include <linux/module.h>
14 #include <linux/types.h>
15 #include <linux/sched.h>
16 #include <linux/ptrace.h>
17 #include <linux/ioport.h>
18 #include <linux/interrupt.h>
19 #include <linux/init.h>
20 #include <linux/delay.h>
21 #include <linux/reboot.h>
22 #include <linux/sysrq.h>
23 #include <linux/smp.h>
24 #include <linux/nodemask.h>
25 #include <asm/io.h>
26 #include <asm/voyager.h>
27 #include <asm/vic.h>
28 #include <linux/pm.h>
29 #include <asm/tlbflush.h>
30 #include <asm/arch_hooks.h>
31 #include <asm/i8253.h>
32
33 /*
34  * Power off function, if any
35  */
36 void (*pm_power_off) (void);
37 EXPORT_SYMBOL(pm_power_off);
38
39 int voyager_level = 0;
40
41 struct voyager_SUS *voyager_SUS = NULL;
42
43 #ifdef CONFIG_SMP
44 static void voyager_dump(int dummy1, struct tty_struct *dummy3)
45 {
46         /* get here via a sysrq */
47         voyager_smp_dump();
48 }
49
50 static struct sysrq_key_op sysrq_voyager_dump_op = {
51         .handler = voyager_dump,
52         .help_msg = "Voyager",
53         .action_msg = "Dump Voyager Status",
54 };
55 #endif
56
57 void voyager_detect(struct voyager_bios_info *bios)
58 {
59         if (bios->len != 0xff) {
60                 int class = (bios->class_1 << 8)
61                     | (bios->class_2 & 0xff);
62
63                 printk("Voyager System detected.\n"
64                        "        Class %x, Revision %d.%d\n",
65                        class, bios->major, bios->minor);
66                 if (class == VOYAGER_LEVEL4)
67                         voyager_level = 4;
68                 else if (class < VOYAGER_LEVEL5_AND_ABOVE)
69                         voyager_level = 3;
70                 else
71                         voyager_level = 5;
72                 printk("        Architecture Level %d\n", voyager_level);
73                 if (voyager_level < 4)
74                         printk
75                             ("\n**WARNING**: Voyager HAL only supports Levels 4 and 5 Architectures at the moment\n\n");
76                 /* install the power off handler */
77                 pm_power_off = voyager_power_off;
78 #ifdef CONFIG_SMP
79                 register_sysrq_key('v', &sysrq_voyager_dump_op);
80 #endif
81         } else {
82                 printk("\n\n**WARNING**: No Voyager Subsystem Found\n");
83         }
84 }
85
86 void voyager_system_interrupt(int cpl, void *dev_id)
87 {
88         printk("Voyager: detected system interrupt\n");
89 }
90
91 /* Routine to read information from the extended CMOS area */
92 __u8 voyager_extended_cmos_read(__u16 addr)
93 {
94         outb(addr & 0xff, 0x74);
95         outb((addr >> 8) & 0xff, 0x75);
96         return inb(0x76);
97 }
98
99 /* internal definitions for the SUS Click Map of memory */
100
101 #define CLICK_ENTRIES   16
102 #define CLICK_SIZE      4096    /* click to byte conversion for Length */
103
104 typedef struct ClickMap {
105         struct Entry {
106                 __u32 Address;
107                 __u32 Length;
108         } Entry[CLICK_ENTRIES];
109 } ClickMap_t;
110
111 /* This routine is pretty much an awful hack to read the bios clickmap by
112  * mapping it into page 0.  There are usually three regions in the map:
113  *      Base Memory
114  *      Extended Memory
115  *      zero length marker for end of map
116  *
117  * Returns are 0 for failure and 1 for success on extracting region.
118  */
119 int __init voyager_memory_detect(int region, __u32 * start, __u32 * length)
120 {
121         int i;
122         int retval = 0;
123         __u8 cmos[4];
124         ClickMap_t *map;
125         unsigned long map_addr;
126         unsigned long old;
127
128         if (region >= CLICK_ENTRIES) {
129                 printk("Voyager: Illegal ClickMap region %d\n", region);
130                 return 0;
131         }
132
133         for (i = 0; i < sizeof(cmos); i++)
134                 cmos[i] =
135                     voyager_extended_cmos_read(VOYAGER_MEMORY_CLICKMAP + i);
136
137         map_addr = *(unsigned long *)cmos;
138
139         /* steal page 0 for this */
140         old = pg0[0];
141         pg0[0] = ((map_addr & PAGE_MASK) | _PAGE_RW | _PAGE_PRESENT);
142         local_flush_tlb();
143         /* now clear everything out but page 0 */
144         map = (ClickMap_t *) (map_addr & (~PAGE_MASK));
145
146         /* zero length is the end of the clickmap */
147         if (map->Entry[region].Length != 0) {
148                 *length = map->Entry[region].Length * CLICK_SIZE;
149                 *start = map->Entry[region].Address;
150                 retval = 1;
151         }
152
153         /* replace the mapping */
154         pg0[0] = old;
155         local_flush_tlb();
156         return retval;
157 }
158
159 /* voyager specific handling code for timer interrupts.  Used to hand
160  * off the timer tick to the SMP code, since the VIC doesn't have an
161  * internal timer (The QIC does, but that's another story). */
162 void voyager_timer_interrupt(void)
163 {
164         if ((jiffies & 0x3ff) == 0) {
165
166                 /* There seems to be something flaky in either
167                  * hardware or software that is resetting the timer 0
168                  * count to something much higher than it should be
169                  * This seems to occur in the boot sequence, just
170                  * before root is mounted.  Therefore, every 10
171                  * seconds or so, we sanity check the timer zero count
172                  * and kick it back to where it should be.
173                  *
174                  * FIXME: This is the most awful hack yet seen.  I
175                  * should work out exactly what is interfering with
176                  * the timer count settings early in the boot sequence
177                  * and swiftly introduce it to something sharp and
178                  * pointy.  */
179                 __u16 val;
180
181                 spin_lock(&i8253_lock);
182
183                 outb_p(0x00, 0x43);
184                 val = inb_p(0x40);
185                 val |= inb(0x40) << 8;
186                 spin_unlock(&i8253_lock);
187
188                 if (val > LATCH) {
189                         printk
190                             ("\nVOYAGER: countdown timer value too high (%d), resetting\n\n",
191                              val);
192                         spin_lock(&i8253_lock);
193                         outb(0x34, 0x43);
194                         outb_p(LATCH & 0xff, 0x40);     /* LSB */
195                         outb(LATCH >> 8, 0x40); /* MSB */
196                         spin_unlock(&i8253_lock);
197                 }
198         }
199 #ifdef CONFIG_SMP
200         smp_vic_timer_interrupt();
201 #endif
202 }
203
204 void voyager_power_off(void)
205 {
206         printk("VOYAGER Power Off\n");
207
208         if (voyager_level == 5) {
209                 voyager_cat_power_off();
210         } else if (voyager_level == 4) {
211                 /* This doesn't apparently work on most L4 machines,
212                  * but the specs say to do this to get automatic power
213                  * off.  Unfortunately, if it doesn't power off the
214                  * machine, it ends up doing a cold restart, which
215                  * isn't really intended, so comment out the code */
216 #if 0
217                 int port;
218
219                 /* enable the voyager Configuration Space */
220                 outb((inb(VOYAGER_MC_SETUP) & 0xf0) | 0x8, VOYAGER_MC_SETUP);
221                 /* the port for the power off flag is an offset from the
222                    floating base */
223                 port = (inb(VOYAGER_SSPB_RELOCATION_PORT) << 8) + 0x21;
224                 /* set the power off flag */
225                 outb(inb(port) | 0x1, port);
226 #endif
227         }
228         /* and wait for it to happen */
229         local_irq_disable();
230         for (;;)
231                 halt();
232 }
233
234 /* copied from process.c */
235 static inline void kb_wait(void)
236 {
237         int i;
238
239         for (i = 0; i < 0x10000; i++)
240                 if ((inb_p(0x64) & 0x02) == 0)
241                         break;
242 }
243
244 void machine_shutdown(void)
245 {
246         /* Architecture specific shutdown needed before a kexec */
247 }
248
249 void machine_restart(char *cmd)
250 {
251         printk("Voyager Warm Restart\n");
252         kb_wait();
253
254         if (voyager_level == 5) {
255                 /* write magic values to the RTC to inform system that
256                  * shutdown is beginning */
257                 outb(0x8f, 0x70);
258                 outb(0x5, 0x71);
259
260                 udelay(50);
261                 outb(0xfe, 0x64);       /* pull reset low */
262         } else if (voyager_level == 4) {
263                 __u16 catbase = inb(VOYAGER_SSPB_RELOCATION_PORT) << 8;
264                 __u8 basebd = inb(VOYAGER_MC_SETUP);
265
266                 outb(basebd | 0x08, VOYAGER_MC_SETUP);
267                 outb(0x02, catbase + 0x21);
268         }
269         local_irq_disable();
270         for (;;)
271                 halt();
272 }
273
274 void machine_emergency_restart(void)
275 {
276         /*for now, just hook this to a warm restart */
277         machine_restart(NULL);
278 }
279
280 void mca_nmi_hook(void)
281 {
282         __u8 dumpval __maybe_unused = inb(0xf823);
283         __u8 swnmi __maybe_unused = inb(0xf813);
284
285         /* FIXME: assume dump switch pressed */
286         /* check to see if the dump switch was pressed */
287         VDEBUG(("VOYAGER: dumpval = 0x%x, swnmi = 0x%x\n", dumpval, swnmi));
288         /* clear swnmi */
289         outb(0xff, 0xf813);
290         /* tell SUS to ignore dump */
291         if (voyager_level == 5 && voyager_SUS != NULL) {
292                 if (voyager_SUS->SUS_mbox == VOYAGER_DUMP_BUTTON_NMI) {
293                         voyager_SUS->kernel_mbox = VOYAGER_NO_COMMAND;
294                         voyager_SUS->kernel_flags |= VOYAGER_OS_IN_PROGRESS;
295                         udelay(1000);
296                         voyager_SUS->kernel_mbox = VOYAGER_IGNORE_DUMP;
297                         voyager_SUS->kernel_flags &= ~VOYAGER_OS_IN_PROGRESS;
298                 }
299         }
300         printk(KERN_ERR
301                "VOYAGER: Dump switch pressed, printing CPU%d tracebacks\n",
302                smp_processor_id());
303         show_stack(NULL, NULL);
304         show_state();
305 }
306
307 void machine_halt(void)
308 {
309         /* treat a halt like a power off */
310         machine_power_off();
311 }
312
313 void machine_power_off(void)
314 {
315         if (pm_power_off)
316                 pm_power_off();
317 }