Merge git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-rc-fixes-2.6
[linux-2.6] / arch / ppc / platforms / prep_setup.c
1 /*
2  *  Copyright (C) 1995  Linus Torvalds
3  *  Adapted from 'alpha' version by Gary Thomas
4  *  Modified by Cort Dougan (cort@cs.nmt.edu)
5  *
6  * Support for PReP (Motorola MTX/MVME)
7  * by Troy Benjegerdes (hozer@drgw.net)
8  */
9
10 /*
11  * bootup setup stuff..
12  */
13
14 #include <linux/delay.h>
15 #include <linux/module.h>
16 #include <linux/errno.h>
17 #include <linux/sched.h>
18 #include <linux/kernel.h>
19 #include <linux/mm.h>
20 #include <linux/stddef.h>
21 #include <linux/unistd.h>
22 #include <linux/ptrace.h>
23 #include <linux/slab.h>
24 #include <linux/user.h>
25 #include <linux/a.out.h>
26 #include <linux/screen_info.h>
27 #include <linux/major.h>
28 #include <linux/interrupt.h>
29 #include <linux/reboot.h>
30 #include <linux/init.h>
31 #include <linux/initrd.h>
32 #include <linux/ioport.h>
33 #include <linux/console.h>
34 #include <linux/timex.h>
35 #include <linux/pci.h>
36 #include <linux/ide.h>
37 #include <linux/seq_file.h>
38 #include <linux/root_dev.h>
39
40 #include <asm/sections.h>
41 #include <asm/mmu.h>
42 #include <asm/processor.h>
43 #include <asm/residual.h>
44 #include <asm/io.h>
45 #include <asm/pgtable.h>
46 #include <asm/cache.h>
47 #include <asm/dma.h>
48 #include <asm/machdep.h>
49 #include <asm/mc146818rtc.h>
50 #include <asm/mk48t59.h>
51 #include <asm/prep_nvram.h>
52 #include <asm/raven.h>
53 #include <asm/vga.h>
54 #include <asm/time.h>
55 #include <asm/mpc10x.h>
56 #include <asm/i8259.h>
57 #include <asm/open_pic.h>
58 #include <asm/pci-bridge.h>
59 #include <asm/todc.h>
60
61 /* prep registers for L2 */
62 #define CACHECRBA       0x80000823      /* Cache configuration register address */
63 #define L2CACHE_MASK    0x03    /* Mask for 2 L2 Cache bits */
64 #define L2CACHE_512KB   0x00    /* 512KB */
65 #define L2CACHE_256KB   0x01    /* 256KB */
66 #define L2CACHE_1MB     0x02    /* 1MB */
67 #define L2CACHE_NONE    0x03    /* NONE */
68 #define L2CACHE_PARITY  0x08    /* Mask for L2 Cache Parity Protected bit */
69
70 TODC_ALLOC();
71
72 extern unsigned char prep_nvram_read_val(int addr);
73 extern void prep_nvram_write_val(int addr,
74                                  unsigned char val);
75 extern unsigned char rs_nvram_read_val(int addr);
76 extern void rs_nvram_write_val(int addr,
77                                  unsigned char val);
78 extern void ibm_prep_init(void);
79
80 extern void prep_find_bridges(void);
81
82 int _prep_type;
83
84 extern void prep_residual_setup_pci(char *irq_edge_mask_lo, char *irq_edge_mask_hi);
85 extern void prep_sandalfoot_setup_pci(char *irq_edge_mask_lo, char *irq_edge_mask_hi);
86 extern void prep_thinkpad_setup_pci(char *irq_edge_mask_lo, char *irq_edge_mask_hi);
87 extern void prep_carolina_setup_pci(char *irq_edge_mask_lo, char *irq_edge_mask_hi);
88 extern void prep_tiger1_setup_pci(char *irq_edge_mask_lo, char *irq_edge_mask_hi);
89
90
91 #define cached_21       (((char *)(ppc_cached_irq_mask))[3])
92 #define cached_A1       (((char *)(ppc_cached_irq_mask))[2])
93
94 extern PTE *Hash, *Hash_end;
95 extern unsigned long Hash_size, Hash_mask;
96 extern int probingmem;
97 extern unsigned long loops_per_jiffy;
98
99 /* useful ISA ports */
100 #define PREP_SYSCTL     0x81c
101 /* present in the IBM reference design; possibly identical in Mot boxes: */
102 #define PREP_IBM_SIMM_ID        0x803   /* SIMM size: 32 or 8 MiB */
103 #define PREP_IBM_SIMM_PRESENCE  0x804
104 #define PREP_IBM_EQUIPMENT      0x80c
105 #define PREP_IBM_L2INFO 0x80d
106 #define PREP_IBM_PM1    0x82a   /* power management register 1 */
107 #define PREP_IBM_PLANAR 0x852   /* planar ID - identifies the motherboard */
108 #define PREP_IBM_DISP   0x8c0   /* 4-digit LED display */
109
110 /* Equipment Present Register masks: */
111 #define PREP_IBM_EQUIPMENT_RESERVED     0x80
112 #define PREP_IBM_EQUIPMENT_SCSIFUSE     0x40
113 #define PREP_IBM_EQUIPMENT_L2_COPYBACK  0x08
114 #define PREP_IBM_EQUIPMENT_L2_256       0x04
115 #define PREP_IBM_EQUIPMENT_CPU  0x02
116 #define PREP_IBM_EQUIPMENT_L2   0x01
117
118 /* planar ID values: */
119 /* Sandalfoot/Sandalbow (6015/7020) */
120 #define PREP_IBM_SANDALFOOT     0xfc
121 /* Woodfield, Thinkpad 850/860 (6042/7249) */
122 #define PREP_IBM_THINKPAD       0xff /* planar ID unimplemented */
123 /* PowerSeries 830/850 (6050/6070) */
124 #define PREP_IBM_CAROLINA_IDE_0 0xf0
125 #define PREP_IBM_CAROLINA_IDE_1 0xf1
126 #define PREP_IBM_CAROLINA_IDE_2 0xf2
127 #define PREP_IBM_CAROLINA_IDE_3 0xf3
128 /* 7248-43P */
129 #define PREP_IBM_CAROLINA_SCSI_0        0xf4
130 #define PREP_IBM_CAROLINA_SCSI_1        0xf5
131 #define PREP_IBM_CAROLINA_SCSI_2        0xf6
132 #define PREP_IBM_CAROLINA_SCSI_3        0xf7 /* missing from Carolina Tech Spec */
133 /* Tiger1 (7043-140) */
134 #define PREP_IBM_TIGER1_133             0xd1
135 #define PREP_IBM_TIGER1_166             0xd2
136 #define PREP_IBM_TIGER1_180             0xd3
137 #define PREP_IBM_TIGER1_xxx             0xd4 /* unknown, but probably exists */
138 #define PREP_IBM_TIGER1_333             0xd5 /* missing from Tiger Tech Spec */
139
140 /* setup_ibm_pci:
141  *      set Motherboard_map_name, Motherboard_map, Motherboard_routes.
142  *      return 8259 edge/level masks.
143  */
144 void (*setup_ibm_pci)(char *irq_lo, char *irq_hi);
145
146 extern char *Motherboard_map_name; /* for use in *_cpuinfo */
147
148 /*
149  * As found in the PReP reference implementation.
150  * Used by Thinkpad, Sandalfoot (6015/7020), and all Motorola PReP.
151  */
152 static void __init
153 prep_gen_enable_l2(void)
154 {
155         outb(inb(PREP_SYSCTL) | 0x3, PREP_SYSCTL);
156 }
157
158 /* Used by Carolina and Tiger1 */
159 static void __init
160 prep_carolina_enable_l2(void)
161 {
162         outb(inb(PREP_SYSCTL) | 0xc0, PREP_SYSCTL);
163 }
164
165 /* cpuinfo code common to all IBM PReP */
166 static void
167 prep_ibm_cpuinfo(struct seq_file *m)
168 {
169         unsigned int equip_reg = inb(PREP_IBM_EQUIPMENT);
170
171         seq_printf(m, "machine\t\t: PReP %s\n", Motherboard_map_name);
172
173         seq_printf(m, "upgrade cpu\t: ");
174         if (equip_reg & PREP_IBM_EQUIPMENT_CPU) {
175                 seq_printf(m, "not ");
176         }
177         seq_printf(m, "present\n");
178
179         /* print info about the SCSI fuse */
180         seq_printf(m, "scsi fuse\t: ");
181         if (equip_reg & PREP_IBM_EQUIPMENT_SCSIFUSE)
182                 seq_printf(m, "ok");
183         else
184                 seq_printf(m, "bad");
185         seq_printf(m, "\n");
186
187         /* print info about SIMMs */
188         if (have_residual_data) {
189                 int i;
190                 seq_printf(m, "simms\t\t: ");
191                 for (i = 0; (res->ActualNumMemories) && (i < MAX_MEMS); i++) {
192                         if (res->Memories[i].SIMMSize != 0)
193                                 seq_printf(m, "%d:%ldMiB ", i,
194                                         (res->Memories[i].SIMMSize > 1024) ?
195                                         res->Memories[i].SIMMSize>>20 :
196                                         res->Memories[i].SIMMSize);
197                 }
198                 seq_printf(m, "\n");
199         }
200 }
201
202 static int
203 prep_gen_cpuinfo(struct seq_file *m)
204 {
205         prep_ibm_cpuinfo(m);
206         return 0;
207 }
208
209 static int
210 prep_sandalfoot_cpuinfo(struct seq_file *m)
211 {
212         unsigned int equip_reg = inb(PREP_IBM_EQUIPMENT);
213
214         prep_ibm_cpuinfo(m);
215
216         /* report amount and type of L2 cache present */
217         seq_printf(m, "L2 cache\t: ");
218         if (equip_reg & PREP_IBM_EQUIPMENT_L2) {
219                 seq_printf(m, "not present");
220         } else {
221                 if (equip_reg & PREP_IBM_EQUIPMENT_L2_256)
222                         seq_printf(m, "256KiB");
223                 else
224                         seq_printf(m, "unknown size");
225
226                 if (equip_reg & PREP_IBM_EQUIPMENT_L2_COPYBACK)
227                         seq_printf(m, ", copy-back");
228                 else
229                         seq_printf(m, ", write-through");
230         }
231         seq_printf(m, "\n");
232
233         return 0;
234 }
235
236 static int
237 prep_thinkpad_cpuinfo(struct seq_file *m)
238 {
239         unsigned int equip_reg = inb(PREP_IBM_EQUIPMENT);
240         char *cpubus_speed, *pci_speed;
241
242         prep_ibm_cpuinfo(m);
243
244         /* report amount and type of L2 cache present */
245         seq_printf(m, "l2 cache\t: ");
246         if ((equip_reg & 0x1) == 0) {
247                 switch ((equip_reg & 0xc) >> 2) {
248                         case 0x0:
249                                 seq_printf(m, "128KiB look-aside 2-way write-through\n");
250                                 break;
251                         case 0x1:
252                                 seq_printf(m, "512KiB look-aside direct-mapped write-back\n");
253                                 break;
254                         case 0x2:
255                                 seq_printf(m, "256KiB look-aside 2-way write-through\n");
256                                 break;
257                         case 0x3:
258                                 seq_printf(m, "256KiB look-aside direct-mapped write-back\n");
259                                 break;
260                 }
261         } else {
262                 seq_printf(m, "not present\n");
263         }
264
265         /* report bus speeds because we can */
266         if ((equip_reg & 0x80) == 0) {
267                 switch ((equip_reg & 0x30) >> 4) {
268                         case 0x1:
269                                 cpubus_speed = "50";
270                                 pci_speed = "25";
271                                 break;
272                         case 0x3:
273                                 cpubus_speed = "66";
274                                 pci_speed = "33";
275                                 break;
276                         default:
277                                 cpubus_speed = "unknown";
278                                 pci_speed = "unknown";
279                                 break;
280                 }
281         } else {
282                 switch ((equip_reg & 0x30) >> 4) {
283                         case 0x1:
284                                 cpubus_speed = "25";
285                                 pci_speed = "25";
286                                 break;
287                         case 0x2:
288                                 cpubus_speed = "60";
289                                 pci_speed = "30";
290                                 break;
291                         case 0x3:
292                                 cpubus_speed = "33";
293                                 pci_speed = "33";
294                                 break;
295                         default:
296                                 cpubus_speed = "unknown";
297                                 pci_speed = "unknown";
298                                 break;
299                 }
300         }
301         seq_printf(m, "60x bus\t\t: %sMHz\n", cpubus_speed);
302         seq_printf(m, "pci bus\t\t: %sMHz\n", pci_speed);
303
304         return 0;
305 }
306
307 static int
308 prep_carolina_cpuinfo(struct seq_file *m)
309 {
310         unsigned int equip_reg = inb(PREP_IBM_EQUIPMENT);
311
312         prep_ibm_cpuinfo(m);
313
314         /* report amount and type of L2 cache present */
315         seq_printf(m, "l2 cache\t: ");
316         if ((equip_reg & 0x1) == 0) {
317                 unsigned int l2_reg = inb(PREP_IBM_L2INFO);
318
319                 /* L2 size */
320                 if ((l2_reg & 0x60) == 0)
321                         seq_printf(m, "256KiB");
322                 else if ((l2_reg & 0x60) == 0x20)
323                         seq_printf(m, "512KiB");
324                 else
325                         seq_printf(m, "unknown size");
326
327                 /* L2 type */
328                 if ((l2_reg & 0x3) == 0)
329                         seq_printf(m, ", async");
330                 else if ((l2_reg & 0x3) == 1)
331                         seq_printf(m, ", sync");
332                 else
333                         seq_printf(m, ", unknown type");
334
335                 seq_printf(m, "\n");
336         } else {
337                 seq_printf(m, "not present\n");
338         }
339
340         return 0;
341 }
342
343 static int
344 prep_tiger1_cpuinfo(struct seq_file *m)
345 {
346         unsigned int l2_reg = inb(PREP_IBM_L2INFO);
347
348         prep_ibm_cpuinfo(m);
349
350         /* report amount and type of L2 cache present */
351         seq_printf(m, "l2 cache\t: ");
352         if ((l2_reg & 0xf) == 0xf) {
353                 seq_printf(m, "not present\n");
354         } else {
355                 if (l2_reg & 0x8)
356                         seq_printf(m, "async, ");
357                 else
358                         seq_printf(m, "sync burst, ");
359         
360                 if (l2_reg & 0x4)
361                         seq_printf(m, "parity, ");
362                 else
363                         seq_printf(m, "no parity, ");
364         
365                 switch (l2_reg & 0x3) {
366                         case 0x0:
367                                 seq_printf(m, "256KiB\n");
368                                 break;
369                         case 0x1:
370                                 seq_printf(m, "512KiB\n");
371                                 break;
372                         case 0x2:
373                                 seq_printf(m, "1MiB\n");
374                                 break;
375                         default:
376                                 seq_printf(m, "unknown size\n");
377                                 break;
378                 }
379         }
380
381         return 0;
382 }
383
384
385 /* Used by all Motorola PReP */
386 static int
387 prep_mot_cpuinfo(struct seq_file *m)
388 {
389         unsigned int cachew = *((unsigned char *)CACHECRBA);
390
391         seq_printf(m, "machine\t\t: PReP %s\n", Motherboard_map_name);
392
393         /* report amount and type of L2 cache present */
394         seq_printf(m, "l2 cache\t: ");
395         switch (cachew & L2CACHE_MASK) {
396                 case L2CACHE_512KB:
397                         seq_printf(m, "512KiB");
398                         break;
399                 case L2CACHE_256KB:
400                         seq_printf(m, "256KiB");
401                         break;
402                 case L2CACHE_1MB:
403                         seq_printf(m, "1MiB");
404                         break;
405                 case L2CACHE_NONE:
406                         seq_printf(m, "none\n");
407                         goto no_l2;
408                         break;
409                 default:
410                         seq_printf(m, "%x\n", cachew);
411         }
412
413         seq_printf(m, ", parity %s",
414                         (cachew & L2CACHE_PARITY)? "enabled" : "disabled");
415
416         seq_printf(m, " SRAM:");
417
418         switch ( ((cachew & 0xf0) >> 4) & ~(0x3) ) {
419                 case 1: seq_printf(m, "synchronous, parity, flow-through\n");
420                                 break;
421                 case 2: seq_printf(m, "asynchronous, no parity\n");
422                                 break;
423                 case 3: seq_printf(m, "asynchronous, parity\n");
424                                 break;
425                 default:seq_printf(m, "synchronous, pipelined, no parity\n");
426                                 break;
427         }
428
429 no_l2:
430         /* print info about SIMMs */
431         if (have_residual_data) {
432                 int i;
433                 seq_printf(m, "simms\t\t: ");
434                 for (i = 0; (res->ActualNumMemories) && (i < MAX_MEMS); i++) {
435                         if (res->Memories[i].SIMMSize != 0)
436                                 seq_printf(m, "%d:%ldM ", i,
437                                         (res->Memories[i].SIMMSize > 1024) ?
438                                         res->Memories[i].SIMMSize>>20 :
439                                         res->Memories[i].SIMMSize);
440                 }
441                 seq_printf(m, "\n");
442         }
443
444         return 0;
445 }
446
447 static void
448 prep_restart(char *cmd)
449 {
450 #define PREP_SP92       0x92    /* Special Port 92 */
451         local_irq_disable(); /* no interrupts */
452
453         /* set exception prefix high - to the prom */
454         _nmask_and_or_msr(0, MSR_IP);
455
456         /* make sure bit 0 (reset) is a 0 */
457         outb( inb(PREP_SP92) & ~1L , PREP_SP92);
458         /* signal a reset to system control port A - soft reset */
459         outb( inb(PREP_SP92) | 1 , PREP_SP92);
460
461         while ( 1 ) ;
462         /* not reached */
463 #undef PREP_SP92
464 }
465
466 static void
467 prep_halt(void)
468 {
469         local_irq_disable(); /* no interrupts */
470
471         /* set exception prefix high - to the prom */
472         _nmask_and_or_msr(0, MSR_IP);
473
474         while ( 1 ) ;
475         /* not reached */
476 }
477
478 /* Carrera is the power manager in the Thinkpads. Unfortunately not much is
479  * known about it, so we can't power down.
480  */
481 static void
482 prep_carrera_poweroff(void)
483 {
484         prep_halt();
485 }
486
487 /*
488  * On most IBM PReP's, power management is handled by a Signetics 87c750
489  * behind the Utah component on the ISA bus. To access the 750 you must write
490  * a series of nibbles to port 0x82a (decoded by the Utah). This is described
491  * somewhat in the IBM Carolina Technical Specification.
492  * -Hollis
493  */
494 static void
495 utah_sig87c750_setbit(unsigned int bytenum, unsigned int bitnum, int value)
496 {
497         /*
498          * byte1: 0 0 0 1 0  d  a5 a4
499          * byte2: 0 0 0 1 a3 a2 a1 a0
500          *
501          * d = the bit's value, enabled or disabled
502          * (a5 a4 a3) = the byte number, minus 20
503          * (a2 a1 a0) = the bit number
504          *
505          * example: set the 5th bit of byte 21 (21.5)
506          *     a5 a4 a3 = 001 (byte 1)
507          *     a2 a1 a0 = 101 (bit 5)
508          *
509          *     byte1 = 0001 0100 (0x14)
510          *     byte2 = 0001 1101 (0x1d)
511          */
512         unsigned char byte1=0x10, byte2=0x10;
513
514         /* the 750's '20.0' is accessed as '0.0' through Utah (which adds 20) */
515         bytenum -= 20;
516
517         byte1 |= (!!value) << 2;                /* set d */
518         byte1 |= (bytenum >> 1) & 0x3;  /* set a5, a4 */
519
520         byte2 |= (bytenum & 0x1) << 3;  /* set a3 */
521         byte2 |= bitnum & 0x7;                  /* set a2, a1, a0 */
522
523         outb(byte1, PREP_IBM_PM1);      /* first nibble */
524         mb();
525         udelay(100);                            /* important: let controller recover */
526
527         outb(byte2, PREP_IBM_PM1);      /* second nibble */
528         mb();
529         udelay(100);                            /* important: let controller recover */
530 }
531
532 static void
533 prep_sig750_poweroff(void)
534 {
535         /* tweak the power manager found in most IBM PRePs (except Thinkpads) */
536
537         local_irq_disable();
538         /* set exception prefix high - to the prom */
539         _nmask_and_or_msr(0, MSR_IP);
540
541         utah_sig87c750_setbit(21, 5, 1); /* set bit 21.5, "PMEXEC_OFF" */
542
543         while (1) ;
544         /* not reached */
545 }
546
547 static int
548 prep_show_percpuinfo(struct seq_file *m, int i)
549 {
550         /* PREP's without residual data will give incorrect values here */
551         seq_printf(m, "clock\t\t: ");
552         if (have_residual_data)
553                 seq_printf(m, "%ldMHz\n",
554                            (res->VitalProductData.ProcessorHz > 1024) ?
555                            res->VitalProductData.ProcessorHz / 1000000 :
556                            res->VitalProductData.ProcessorHz);
557         else
558                 seq_printf(m, "???\n");
559
560         return 0;
561 }
562
563 /*
564  * Fill out screen_info according to the residual data. This allows us to use
565  * at least vesafb.
566  */
567 static void __init
568 prep_init_vesa(void)
569 {
570 #if     (defined(CONFIG_FB_VGA16) || defined(CONFIG_FB_VGA16_MODULE) || \
571          defined(CONFIG_FB_VESA))
572         PPC_DEVICE *vgadev = NULL;
573
574         if (have_residual_data)
575                 vgadev = residual_find_device(~0, NULL, DisplayController,
576                                                         SVGAController, -1, 0);
577
578         if (vgadev != NULL) {
579                 PnP_TAG_PACKET *pkt;
580
581                 pkt = PnP_find_large_vendor_packet(
582                                 (unsigned char *)&res->DevicePnPHeap[vgadev->AllocatedOffset],
583                                 0x04, 0); /* 0x04 = Display Tag */
584                 if (pkt != NULL) {
585                         unsigned char *ptr = (unsigned char *)pkt;
586
587                         if (ptr[4]) {
588                                 /* graphics mode */
589                                 screen_info.orig_video_isVGA = VIDEO_TYPE_VLFB;
590
591                                 screen_info.lfb_depth = ptr[4] * 8;
592
593                                 screen_info.lfb_width = swab16(*(short *)(ptr+6));
594                                 screen_info.lfb_height = swab16(*(short *)(ptr+8));
595                                 screen_info.lfb_linelength = swab16(*(short *)(ptr+10));
596
597                                 screen_info.lfb_base = swab32(*(long *)(ptr+12));
598                                 screen_info.lfb_size = swab32(*(long *)(ptr+20)) / 65536;
599                         }
600                 }
601         }
602 #endif
603 }
604
605 /*
606  * Set DBAT 2 to access 0x80000000 so early progress messages will work
607  */
608 static __inline__ void
609 prep_set_bat(void)
610 {
611         /* wait for all outstanding memory access to complete */
612         mb();
613
614         /* setup DBATs */
615         mtspr(SPRN_DBAT2U, 0x80001ffe);
616         mtspr(SPRN_DBAT2L, 0x8000002a);
617
618         /* wait for updates */
619         mb();
620 }
621
622 /*
623  * IBM 3-digit status LED
624  */
625 static unsigned int ibm_statusled_base;
626
627 static void
628 ibm_statusled_progress(char *s, unsigned short hex);
629
630 static int
631 ibm_statusled_panic(struct notifier_block *dummy1, unsigned long dummy2,
632                     void * dummy3)
633 {
634         ibm_statusled_progress(NULL, 0x505); /* SOS */
635         return NOTIFY_DONE;
636 }
637
638 static struct notifier_block ibm_statusled_block = {
639         ibm_statusled_panic,
640         NULL,
641         INT_MAX /* try to do it first */
642 };
643
644 static void
645 ibm_statusled_progress(char *s, unsigned short hex)
646 {
647         static int notifier_installed;
648         /*
649          * Progress uses 4 digits and we have only 3.  So, we map 0xffff to
650          * 0xfff for display switch off.  Out of range values are mapped to
651          * 0xeff, as I'm told 0xf00 and above are reserved for hardware codes.
652          * Install the panic notifier when the display is first switched off.
653          */
654         if (hex == 0xffff) {
655                 hex = 0xfff;
656                 if (!notifier_installed) {
657                         ++notifier_installed;
658                         atomic_notifier_chain_register(&panic_notifier_list,
659                                                 &ibm_statusled_block);
660                 }
661         }
662         else
663                 if (hex > 0xfff)
664                         hex = 0xeff;
665
666         mb();
667         outw(hex, ibm_statusled_base);
668 }
669
670 static void __init
671 ibm_statusled_init(void)
672 {
673         /*
674          * The IBM 3-digit LED display is specified in the residual data
675          * as an operator panel device, type "System Status LED".  Find
676          * that device and determine its address.  We validate all the
677          * other parameters on the off-chance another, similar device
678          * exists.
679          */
680         if (have_residual_data) {
681                 PPC_DEVICE *led;
682                 PnP_TAG_PACKET *pkt;
683
684                 led = residual_find_device(~0, NULL, SystemPeripheral,
685                                            OperatorPanel, SystemStatusLED, 0);
686                 if (!led)
687                         return;
688
689                 pkt = PnP_find_packet((unsigned char *)
690                        &res->DevicePnPHeap[led->AllocatedOffset], S8_Packet, 0);
691                 if (!pkt)
692                         return;
693
694                 if (pkt->S8_Pack.IOInfo != ISAAddr16bit)
695                         return;
696                 if (*(unsigned short *)pkt->S8_Pack.RangeMin !=
697                     *(unsigned short *)pkt->S8_Pack.RangeMax)
698                         return;
699                 if (pkt->S8_Pack.IOAlign != 2)
700                         return;
701                 if (pkt->S8_Pack.IONum != 2)
702                         return;
703
704                 ibm_statusled_base = ld_le16((unsigned short *)
705                                              (pkt->S8_Pack.RangeMin));
706                 ppc_md.progress = ibm_statusled_progress;
707         }
708 }
709
710 static void __init
711 prep_setup_arch(void)
712 {
713         unsigned char reg;
714         int is_ide=0;
715
716         /* init to some ~sane value until calibrate_delay() runs */
717         loops_per_jiffy = 50000000;
718
719         /* Lookup PCI host bridges */
720         prep_find_bridges();
721
722         /* Set up floppy in PS/2 mode */
723         outb(0x09, SIO_CONFIG_RA);
724         reg = inb(SIO_CONFIG_RD);
725         reg = (reg & 0x3F) | 0x40;
726         outb(reg, SIO_CONFIG_RD);
727         outb(reg, SIO_CONFIG_RD);       /* Have to write twice to change! */
728
729         switch ( _prep_type )
730         {
731         case _PREP_IBM:
732                 reg = inb(PREP_IBM_PLANAR);
733                 printk(KERN_INFO "IBM planar ID: %02x", reg);
734                 switch (reg) {
735                         case PREP_IBM_SANDALFOOT:
736                                 prep_gen_enable_l2();
737                                 setup_ibm_pci = prep_sandalfoot_setup_pci;
738                                 ppc_md.power_off = prep_sig750_poweroff;
739                                 ppc_md.show_cpuinfo = prep_sandalfoot_cpuinfo;
740                                 break;
741                         case PREP_IBM_THINKPAD:
742                                 prep_gen_enable_l2();
743                                 setup_ibm_pci = prep_thinkpad_setup_pci;
744                                 ppc_md.power_off = prep_carrera_poweroff;
745                                 ppc_md.show_cpuinfo = prep_thinkpad_cpuinfo;
746                                 break;
747                         default:
748                                 if (have_residual_data) {
749                                         prep_gen_enable_l2();
750                                         setup_ibm_pci = prep_residual_setup_pci;
751                                         ppc_md.power_off = prep_halt;
752                                         ppc_md.show_cpuinfo = prep_gen_cpuinfo;
753                                         break;
754                                 }
755                                 else
756                                         printk(" - unknown! Assuming Carolina");
757                                         /* fall through */
758                         case PREP_IBM_CAROLINA_IDE_0:
759                         case PREP_IBM_CAROLINA_IDE_1:
760                         case PREP_IBM_CAROLINA_IDE_2:
761                         case PREP_IBM_CAROLINA_IDE_3:
762                                 is_ide = 1;
763                         case PREP_IBM_CAROLINA_SCSI_0:
764                         case PREP_IBM_CAROLINA_SCSI_1:
765                         case PREP_IBM_CAROLINA_SCSI_2:
766                         case PREP_IBM_CAROLINA_SCSI_3:
767                                 prep_carolina_enable_l2();
768                                 setup_ibm_pci = prep_carolina_setup_pci;
769                                 ppc_md.power_off = prep_sig750_poweroff;
770                                 ppc_md.show_cpuinfo = prep_carolina_cpuinfo;
771                                 break;
772                         case PREP_IBM_TIGER1_133:
773                         case PREP_IBM_TIGER1_166:
774                         case PREP_IBM_TIGER1_180:
775                         case PREP_IBM_TIGER1_xxx:
776                         case PREP_IBM_TIGER1_333:
777                                 prep_carolina_enable_l2();
778                                 setup_ibm_pci = prep_tiger1_setup_pci;
779                                 ppc_md.power_off = prep_sig750_poweroff;
780                                 ppc_md.show_cpuinfo = prep_tiger1_cpuinfo;
781                                 break;
782                 }
783                 printk("\n");
784
785                 /* default root device */
786                 if (is_ide)
787                         ROOT_DEV = MKDEV(IDE0_MAJOR, 3);
788                 else
789                         ROOT_DEV = MKDEV(SCSI_DISK0_MAJOR, 3);
790
791                 break;
792         case _PREP_Motorola:
793                 prep_gen_enable_l2();
794                 ppc_md.power_off = prep_halt;
795                 ppc_md.show_cpuinfo = prep_mot_cpuinfo;
796
797 #ifdef CONFIG_BLK_DEV_INITRD
798                 if (initrd_start)
799                         ROOT_DEV = Root_RAM0;
800                 else
801 #endif
802 #ifdef CONFIG_ROOT_NFS
803                         ROOT_DEV = Root_NFS;
804 #else
805                         ROOT_DEV = Root_SDA2;
806 #endif
807                 break;
808         }
809
810         /* Read in NVRAM data */
811         init_prep_nvram();
812
813         /* if no bootargs, look in NVRAM */
814         if ( cmd_line[0] == '\0' ) {
815                 char *bootargs;
816                  bootargs = prep_nvram_get_var("bootargs");
817                  if (bootargs != NULL) {
818                          strcpy(cmd_line, bootargs);
819                          /* again.. */
820                          strcpy(boot_command_line, cmd_line);
821                 }
822         }
823
824         prep_init_vesa();
825
826         switch (_prep_type) {
827         case _PREP_Motorola:
828                 raven_init();
829                 break;
830         case _PREP_IBM:
831                 ibm_prep_init();
832                 break;
833         }
834
835 #ifdef CONFIG_VGA_CONSOLE
836         /* vgacon.c needs to know where we mapped IO memory in io_block_mapping() */
837         vgacon_remap_base = 0xf0000000;
838         conswitchp = &vga_con;
839 #endif
840 }
841
842 /*
843  * First, see if we can get this information from the residual data.
844  * This is important on some IBM PReP systems.  If we cannot, we let the
845  * TODC code handle doing this.
846  */
847 static void __init
848 prep_calibrate_decr(void)
849 {
850         if (have_residual_data) {
851                 unsigned long freq, divisor = 4;
852
853                 if ( res->VitalProductData.ProcessorBusHz ) {
854                         freq = res->VitalProductData.ProcessorBusHz;
855                         printk("time_init: decrementer frequency = %lu.%.6lu MHz\n",
856                                         (freq/divisor)/1000000,
857                                         (freq/divisor)%1000000);
858                         tb_to_us = mulhwu_scale_factor(freq/divisor, 1000000);
859                         tb_ticks_per_jiffy = freq / HZ / divisor;
860                 }
861         }
862         else
863                 todc_calibrate_decr();
864 }
865
866 static void __init
867 prep_init_IRQ(void)
868 {
869         unsigned int pci_viddid, pci_did;
870
871         if (OpenPIC_Addr != NULL) {
872                 openpic_init(NUM_8259_INTERRUPTS);
873                 /* We have a cascade on OpenPIC IRQ 0, Linux IRQ 16 */
874                 openpic_hookup_cascade(NUM_8259_INTERRUPTS, "82c59 cascade",
875                                        i8259_irq);
876         }
877
878         if (have_residual_data) {
879                 i8259_init(residual_isapic_addr(), 0);
880                 return;
881         }
882
883         /* If we have a Raven PCI bridge or a Hawk PCI bridge / Memory
884          * controller, we poll (as they have a different int-ack address). */
885         early_read_config_dword(NULL, 0, 0, PCI_VENDOR_ID, &pci_viddid);
886         pci_did = (pci_viddid & 0xffff0000) >> 16;
887         if (((pci_viddid & 0xffff) == PCI_VENDOR_ID_MOTOROLA)
888                         && ((pci_did == PCI_DEVICE_ID_MOTOROLA_RAVEN)
889                                 || (pci_did == PCI_DEVICE_ID_MOTOROLA_HAWK)))
890                 i8259_init(0, 0);
891         else
892                 /* PCI interrupt ack address given in section 6.1.8 of the
893                  * PReP specification. */
894                 i8259_init(MPC10X_MAPA_PCI_INTACK_ADDR, 0);
895 }
896
897 #if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE)
898 /*
899  * IDE stuff.
900  */
901 static int
902 prep_ide_default_irq(unsigned long base)
903 {
904         switch (base) {
905                 case 0x1f0: return 13;
906                 case 0x170: return 13;
907                 case 0x1e8: return 11;
908                 case 0x168: return 10;
909                 case 0xfff0: return 14;         /* MCP(N)750 ide0 */
910                 case 0xffe0: return 15;         /* MCP(N)750 ide1 */
911                 default: return 0;
912         }
913 }
914
915 static unsigned long
916 prep_ide_default_io_base(int index)
917 {
918         switch (index) {
919                 case 0: return 0x1f0;
920                 case 1: return 0x170;
921                 case 2: return 0x1e8;
922                 case 3: return 0x168;
923                 default:
924                         return 0;
925         }
926 }
927 #endif
928
929 #ifdef CONFIG_SMP
930 /* PReP (MTX) support */
931 static int __init
932 smp_prep_probe(void)
933 {
934         extern int mot_multi;
935
936         if (mot_multi) {
937                 openpic_request_IPIs();
938                 smp_hw_index[1] = 1;
939                 return 2;
940         }
941
942         return 1;
943 }
944
945 static void __init
946 smp_prep_kick_cpu(int nr)
947 {
948         *(unsigned long *)KERNELBASE = nr;
949         asm volatile("dcbf 0,%0"::"r"(KERNELBASE):"memory");
950         printk("CPU1 released, waiting\n");
951 }
952
953 static void __init
954 smp_prep_setup_cpu(int cpu_nr)
955 {
956         if (OpenPIC_Addr)
957                 do_openpic_setup_cpu();
958 }
959
960 static struct smp_ops_t prep_smp_ops = {
961         smp_openpic_message_pass,
962         smp_prep_probe,
963         smp_prep_kick_cpu,
964         smp_prep_setup_cpu,
965         .give_timebase = smp_generic_give_timebase,
966         .take_timebase = smp_generic_take_timebase,
967 };
968 #endif /* CONFIG_SMP */
969
970 /*
971  * Setup the bat mappings we're going to load that cover
972  * the io areas.  RAM was mapped by mapin_ram().
973  * -- Cort
974  */
975 static void __init
976 prep_map_io(void)
977 {
978         io_block_mapping(0x80000000, PREP_ISA_IO_BASE, 0x10000000, _PAGE_IO);
979         io_block_mapping(0xf0000000, PREP_ISA_MEM_BASE, 0x08000000, _PAGE_IO);
980 }
981
982 static int __init
983 prep_request_io(void)
984 {
985 #ifdef CONFIG_NVRAM
986         request_region(PREP_NVRAM_AS0, 0x8, "nvram");
987 #endif
988         request_region(0x00,0x20,"dma1");
989         request_region(0x40,0x20,"timer");
990         request_region(0x80,0x10,"dma page reg");
991         request_region(0xc0,0x20,"dma2");
992
993         return 0;
994 }
995
996 device_initcall(prep_request_io);
997
998 void __init
999 prep_init(unsigned long r3, unsigned long r4, unsigned long r5,
1000                 unsigned long r6, unsigned long r7)
1001 {
1002 #ifdef CONFIG_PREP_RESIDUAL
1003         /* make a copy of residual data */
1004         if ( r3 ) {
1005                 memcpy((void *)res,(void *)(r3+KERNELBASE),
1006                          sizeof(RESIDUAL));
1007         }
1008 #endif
1009
1010         isa_io_base = PREP_ISA_IO_BASE;
1011         isa_mem_base = PREP_ISA_MEM_BASE;
1012         pci_dram_offset = PREP_PCI_DRAM_OFFSET;
1013         ISA_DMA_THRESHOLD = 0x00ffffff;
1014         DMA_MODE_READ = 0x44;
1015         DMA_MODE_WRITE = 0x48;
1016         ppc_do_canonicalize_irqs = 1;
1017
1018         /* figure out what kind of prep workstation we are */
1019         if (have_residual_data) {
1020                 if ( !strncmp(res->VitalProductData.PrintableModel,"IBM",3) )
1021                         _prep_type = _PREP_IBM;
1022                 else
1023                         _prep_type = _PREP_Motorola;
1024         }
1025         else {
1026                 /* assume motorola if no residual (netboot?) */
1027                 _prep_type = _PREP_Motorola;
1028         }
1029
1030 #ifdef CONFIG_PREP_RESIDUAL
1031         /* Switch off all residual data processing if the user requests it */
1032         if (strstr(cmd_line, "noresidual") != NULL)
1033                         res = NULL;
1034 #endif
1035
1036         /* Initialise progress early to get maximum benefit */
1037         prep_set_bat();
1038         ibm_statusled_init();
1039
1040         ppc_md.setup_arch     = prep_setup_arch;
1041         ppc_md.show_percpuinfo = prep_show_percpuinfo;
1042         ppc_md.show_cpuinfo   = NULL; /* set in prep_setup_arch() */
1043         ppc_md.init_IRQ       = prep_init_IRQ;
1044         /* this gets changed later on if we have an OpenPIC -- Cort */
1045         ppc_md.get_irq        = i8259_irq;
1046
1047         ppc_md.phys_mem_access_prot = pci_phys_mem_access_prot;
1048
1049         ppc_md.restart        = prep_restart;
1050         ppc_md.power_off      = NULL; /* set in prep_setup_arch() */
1051         ppc_md.halt           = prep_halt;
1052
1053         ppc_md.nvram_read_val = prep_nvram_read_val;
1054         ppc_md.nvram_write_val = prep_nvram_write_val;
1055
1056         ppc_md.time_init      = todc_time_init;
1057         if (_prep_type == _PREP_IBM) {
1058                 ppc_md.rtc_read_val = todc_mc146818_read_val;
1059                 ppc_md.rtc_write_val = todc_mc146818_write_val;
1060                 TODC_INIT(TODC_TYPE_MC146818, RTC_PORT(0), NULL, RTC_PORT(1),
1061                                 8);
1062         } else {
1063                 TODC_INIT(TODC_TYPE_MK48T59, PREP_NVRAM_AS0, PREP_NVRAM_AS1,
1064                                 PREP_NVRAM_DATA, 8);
1065         }
1066
1067         ppc_md.calibrate_decr = prep_calibrate_decr;
1068         ppc_md.set_rtc_time   = todc_set_rtc_time;
1069         ppc_md.get_rtc_time   = todc_get_rtc_time;
1070
1071         ppc_md.setup_io_mappings = prep_map_io;
1072
1073 #if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE)
1074         ppc_ide_md.default_irq = prep_ide_default_irq;
1075         ppc_ide_md.default_io_base = prep_ide_default_io_base;
1076 #endif
1077
1078 #ifdef CONFIG_SMP
1079         smp_ops                  = &prep_smp_ops;
1080 #endif /* CONFIG_SMP */
1081 }