Merge git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc
[linux-2.6] / arch / ppc / platforms / apus_setup.c
1 /*
2  *  Copyright (C) 1998, 1999  Jesper Skov
3  *
4  *  Basically what is needed to replace functionality found in
5  *  arch/m68k allowing Amiga drivers to work under APUS.
6  *  Bits of code and/or ideas from arch/m68k and arch/ppc files.
7  *
8  * TODO:
9  *  This file needs a *really* good cleanup. Restructure and optimize.
10  *  Make sure it can be compiled for non-APUS configs. Begin to move
11  *  Amiga specific stuff into mach/amiga.
12  */
13
14 #include <linux/config.h>
15 #include <linux/kernel.h>
16 #include <linux/sched.h>
17 #include <linux/init.h>
18 #include <linux/initrd.h>
19 #include <linux/seq_file.h>
20
21 /* Needs INITSERIAL call in head.S! */
22 #undef APUS_DEBUG
23
24 #include <asm/bootinfo.h>
25 #include <asm/setup.h>
26 #include <asm/amigahw.h>
27 #include <asm/amigaints.h>
28 #include <asm/amigappc.h>
29 #include <asm/pgtable.h>
30 #include <asm/dma.h>
31 #include <asm/machdep.h>
32 #include <asm/time.h>
33
34 unsigned long m68k_machtype;
35 char debug_device[6] = "";
36
37 extern void amiga_init_IRQ(void);
38
39 extern void apus_setup_pci_ptrs(void);
40
41 void (*mach_sched_init) (void (*handler)(int, void *, struct pt_regs *)) __initdata = NULL;
42 /* machine dependent irq functions */
43 void (*mach_init_IRQ) (void) __initdata = NULL;
44 void (*(*mach_default_handler)[]) (int, void *, struct pt_regs *) = NULL;
45 void (*mach_get_model) (char *model) = NULL;
46 int (*mach_get_hardware_list) (char *buffer) = NULL;
47 int (*mach_get_irq_list) (struct seq_file *, void *) = NULL;
48 void (*mach_process_int) (int, struct pt_regs *) = NULL;
49 /* machine dependent timer functions */
50 unsigned long (*mach_gettimeoffset) (void);
51 void (*mach_gettod) (int*, int*, int*, int*, int*, int*);
52 int (*mach_hwclk) (int, struct hwclk_time*) = NULL;
53 int (*mach_set_clock_mmss) (unsigned long) = NULL;
54 void (*mach_reset)( void );
55 long mach_max_dma_address = 0x00ffffff; /* default set to the lower 16MB */
56 #ifdef CONFIG_HEARTBEAT
57 void (*mach_heartbeat) (int) = NULL;
58 extern void apus_heartbeat (void);
59 #endif
60
61 extern unsigned long amiga_model;
62 extern unsigned decrementer_count;/* count value for 1e6/HZ microseconds */
63 extern unsigned count_period_num; /* 1 decrementer count equals */
64 extern unsigned count_period_den; /* count_period_num / count_period_den us */
65
66 int num_memory = 0;
67 struct mem_info memory[NUM_MEMINFO];/* memory description */
68 /* FIXME: Duplicate memory data to avoid conflicts with m68k shared code. */
69 int m68k_realnum_memory = 0;
70 struct mem_info m68k_memory[NUM_MEMINFO];/* memory description */
71
72 struct mem_info ramdisk;
73
74 extern void config_amiga(void);
75
76 static int __60nsram = 0;
77
78 /* for cpuinfo */
79 static int __bus_speed = 0;
80 static int __speed_test_failed = 0;
81
82 /********************************************** COMPILE PROTECTION */
83 /* Provide some stubs that links to Amiga specific functions.
84  * This allows CONFIG_APUS to be removed from generic PPC files while
85  * preventing link errors for other PPC targets.
86  */
87 unsigned long apus_get_rtc_time(void)
88 {
89 #ifdef CONFIG_APUS
90         extern unsigned long m68k_get_rtc_time(void);
91
92         return m68k_get_rtc_time ();
93 #else
94         return 0;
95 #endif
96 }
97
98 int apus_set_rtc_time(unsigned long nowtime)
99 {
100 #ifdef CONFIG_APUS
101         extern int m68k_set_rtc_time(unsigned long nowtime);
102
103         return m68k_set_rtc_time (nowtime);
104 #else
105         return 0;
106 #endif
107 }
108
109 /*********************************************************** SETUP */
110 /* From arch/m68k/kernel/setup.c. */
111 void __init apus_setup_arch(void)
112 {
113 #ifdef CONFIG_APUS
114         extern char cmd_line[];
115         int i;
116         char *p, *q;
117
118         /* Let m68k-shared code know it should do the Amiga thing. */
119         m68k_machtype = MACH_AMIGA;
120
121         /* Parse the command line for arch-specific options.
122          * For the m68k, this is currently only "debug=xxx" to enable printing
123          * certain kernel messages to some machine-specific device.  */
124         for( p = cmd_line; p && *p; ) {
125             i = 0;
126             if (!strncmp( p, "debug=", 6 )) {
127                     strlcpy( debug_device, p+6, sizeof(debug_device) );
128                     if ((q = strchr( debug_device, ' ' ))) *q = 0;
129                     i = 1;
130             } else if (!strncmp( p, "60nsram", 7 )) {
131                     APUS_WRITE (APUS_REG_WAITSTATE,
132                                 REGWAITSTATE_SETRESET
133                                 |REGWAITSTATE_PPCR
134                                 |REGWAITSTATE_PPCW);
135                     __60nsram = 1;
136                     i = 1;
137             }
138
139             if (i) {
140                 /* option processed, delete it */
141                 if ((q = strchr( p, ' ' )))
142                     strcpy( p, q+1 );
143                 else
144                     *p = 0;
145             } else {
146                 if ((p = strchr( p, ' ' ))) ++p;
147             }
148         }
149
150         config_amiga();
151
152 #if 0 /* Enable for logging - also include logging.o in Makefile rule */
153         {
154 #define LOG_SIZE 4096
155                 void* base;
156
157                 /* Throw away some memory - the P5 firmare stomps on top
158                  * of CHIP memory during bootup.
159                  */
160                 amiga_chip_alloc(0x1000);
161
162                 base = amiga_chip_alloc(LOG_SIZE+sizeof(klog_data_t));
163                 LOG_INIT(base, base+sizeof(klog_data_t), LOG_SIZE);
164         }
165 #endif
166 #endif
167 }
168
169 int
170 apus_show_cpuinfo(struct seq_file *m)
171 {
172         extern int __map_without_bats;
173         extern unsigned long powerup_PCI_present;
174
175         seq_printf(m, "machine\t\t: Amiga\n");
176         seq_printf(m, "bus speed\t: %d%s", __bus_speed,
177                    (__speed_test_failed) ? " [failed]\n" : "\n");
178         seq_printf(m, "using BATs\t: %s\n",
179                    (__map_without_bats) ? "No" : "Yes");
180         seq_printf(m, "ram speed\t: %dns\n", (__60nsram) ? 60 : 70);
181         seq_printf(m, "PCI bridge\t: %s\n",
182                    (powerup_PCI_present) ? "Yes" : "No");
183         return 0;
184 }
185
186 static void get_current_tb(unsigned long long *time)
187 {
188         __asm __volatile ("1:mftbu 4      \n\t"
189                           "  mftb  5      \n\t"
190                           "  mftbu 6      \n\t"
191                           "  cmpw  4,6    \n\t"
192                           "  bne   1b     \n\t"
193                           "  stw   4,0(%0)\n\t"
194                           "  stw   5,4(%0)\n\t"
195                           :
196                           : "r" (time)
197                           : "r4", "r5", "r6");
198 }
199
200
201 void apus_calibrate_decr(void)
202 {
203 #ifdef CONFIG_APUS
204         unsigned long freq;
205
206         /* This algorithm for determining the bus speed was
207            contributed by Ralph Schmidt. */
208         unsigned long long start, stop;
209         int bus_speed;
210         int speed_test_failed = 0;
211
212         {
213                 unsigned long loop = amiga_eclock / 10;
214
215                 get_current_tb (&start);
216                 while (loop--) {
217                         unsigned char tmp;
218
219                         tmp = ciaa.pra;
220                 }
221                 get_current_tb (&stop);
222         }
223
224         bus_speed = (((unsigned long)(stop-start))*10*4) / 1000000;
225         if (AMI_1200 == amiga_model)
226                 bus_speed /= 2;
227
228         if ((bus_speed >= 47) && (bus_speed < 53)) {
229                 bus_speed = 50;
230                 freq = 12500000;
231         } else if ((bus_speed >= 57) && (bus_speed < 63)) {
232                 bus_speed = 60;
233                 freq = 15000000;
234         } else if ((bus_speed >= 63) && (bus_speed < 69)) {
235                 bus_speed = 67;
236                 freq = 16666667;
237         } else {
238                 printk ("APUS: Unable to determine bus speed (%d). "
239                         "Defaulting to 50MHz", bus_speed);
240                 bus_speed = 50;
241                 freq = 12500000;
242                 speed_test_failed = 1;
243         }
244
245         /* Ease diagnostics... */
246         {
247                 extern int __map_without_bats;
248                 extern unsigned long powerup_PCI_present;
249
250                 printk ("APUS: BATs=%d, BUS=%dMHz",
251                         (__map_without_bats) ? 0 : 1,
252                         bus_speed);
253                 if (speed_test_failed)
254                         printk ("[FAILED - please report]");
255
256                 printk (", RAM=%dns, PCI bridge=%d\n",
257                         (__60nsram) ? 60 : 70,
258                         (powerup_PCI_present) ? 1 : 0);
259
260                 /* print a bit more if asked politely... */
261                 if (!(ciaa.pra & 0x40)){
262                         extern unsigned int bat_addrs[4][3];
263                         int b;
264                         for (b = 0; b < 4; ++b) {
265                                 printk ("APUS: BAT%d ", b);
266                                 printk ("%08x-%08x -> %08x\n",
267                                         bat_addrs[b][0],
268                                         bat_addrs[b][1],
269                                         bat_addrs[b][2]);
270                         }
271                 }
272
273         }
274
275         printk("time_init: decrementer frequency = %lu.%.6lu MHz\n",
276                freq/1000000, freq%1000000);
277         tb_ticks_per_jiffy = freq / HZ;
278         tb_to_us = mulhwu_scale_factor(freq, 1000000);
279
280         __bus_speed = bus_speed;
281         __speed_test_failed = speed_test_failed;
282 #endif
283 }
284
285 void arch_gettod(int *year, int *mon, int *day, int *hour,
286                  int *min, int *sec)
287 {
288 #ifdef CONFIG_APUS
289         if (mach_gettod)
290                 mach_gettod(year, mon, day, hour, min, sec);
291         else
292                 *year = *mon = *day = *hour = *min = *sec = 0;
293 #endif
294 }
295
296 /* for "kbd-reset" cmdline param */
297 __init
298 void kbd_reset_setup(char *str, int *ints)
299 {
300 }
301
302 /*********************************************************** MEMORY */
303 #define KMAP_MAX 32
304 unsigned long kmap_chunks[KMAP_MAX*3];
305 int kmap_chunk_count = 0;
306
307 /* From pgtable.h */
308 static __inline__ pte_t *my_find_pte(struct mm_struct *mm,unsigned long va)
309 {
310         pgd_t *dir = 0;
311         pmd_t *pmd = 0;
312         pte_t *pte = 0;
313
314         va &= PAGE_MASK;
315
316         dir = pgd_offset( mm, va );
317         if (dir)
318         {
319                 pmd = pmd_offset(dir, va & PAGE_MASK);
320                 if (pmd && pmd_present(*pmd))
321                 {
322                         pte = pte_offset(pmd, va);
323                 }
324         }
325         return pte;
326 }
327
328
329 /* Again simulating an m68k/mm/kmap.c function. */
330 void kernel_set_cachemode( unsigned long address, unsigned long size,
331                            unsigned int cmode )
332 {
333         unsigned long mask, flags;
334
335         switch (cmode)
336         {
337         case IOMAP_FULL_CACHING:
338                 mask = ~(_PAGE_NO_CACHE | _PAGE_GUARDED);
339                 flags = 0;
340                 break;
341         case IOMAP_NOCACHE_SER:
342                 mask = ~0;
343                 flags = (_PAGE_NO_CACHE | _PAGE_GUARDED);
344                 break;
345         default:
346                 panic ("kernel_set_cachemode() doesn't support mode %d\n",
347                        cmode);
348                 break;
349         }
350
351         size /= PAGE_SIZE;
352         address &= PAGE_MASK;
353         while (size--)
354         {
355                 pte_t *pte;
356
357                 pte = my_find_pte(&init_mm, address);
358                 if ( !pte )
359                 {
360                         printk("pte NULL in kernel_set_cachemode()\n");
361                         return;
362                 }
363
364                 pte_val (*pte) &= mask;
365                 pte_val (*pte) |= flags;
366                 flush_tlb_page(find_vma(&init_mm,address),address);
367
368                 address += PAGE_SIZE;
369         }
370 }
371
372 unsigned long mm_ptov (unsigned long paddr)
373 {
374         unsigned long ret;
375         if (paddr < 16*1024*1024)
376                 ret = ZTWO_VADDR(paddr);
377         else {
378                 int i;
379
380                 for (i = 0; i < kmap_chunk_count;){
381                         unsigned long phys = kmap_chunks[i++];
382                         unsigned long size = kmap_chunks[i++];
383                         unsigned long virt = kmap_chunks[i++];
384                         if (paddr >= phys
385                             && paddr < (phys + size)){
386                                 ret = virt + paddr - phys;
387                                 goto exit;
388                         }
389                 }
390
391                 ret = (unsigned long) __va(paddr);
392         }
393 exit:
394 #ifdef DEBUGPV
395         printk ("PTOV(%lx)=%lx\n", paddr, ret);
396 #endif
397         return ret;
398 }
399
400 int mm_end_of_chunk (unsigned long addr, int len)
401 {
402         if (memory[0].addr + memory[0].size == addr + len)
403                 return 1;
404         return 0;
405 }
406
407 /*********************************************************** CACHE */
408
409 #define L1_CACHE_BYTES 32
410 #define MAX_CACHE_SIZE 8192
411 void cache_push(__u32 addr, int length)
412 {
413         addr = mm_ptov(addr);
414
415         if (MAX_CACHE_SIZE < length)
416                 length = MAX_CACHE_SIZE;
417
418         while(length > 0){
419                 __asm ("dcbf 0,%0\n\t"
420                        : : "r" (addr));
421                 addr += L1_CACHE_BYTES;
422                 length -= L1_CACHE_BYTES;
423         }
424         /* Also flush trailing block */
425         __asm ("dcbf 0,%0\n\t"
426                "sync \n\t"
427                : : "r" (addr));
428 }
429
430 void cache_clear(__u32 addr, int length)
431 {
432         if (MAX_CACHE_SIZE < length)
433                 length = MAX_CACHE_SIZE;
434
435         addr = mm_ptov(addr);
436
437         __asm ("dcbf 0,%0\n\t"
438                "sync \n\t"
439                "icbi 0,%0 \n\t"
440                "isync \n\t"
441                : : "r" (addr));
442
443         addr += L1_CACHE_BYTES;
444         length -= L1_CACHE_BYTES;
445
446         while(length > 0){
447                 __asm ("dcbf 0,%0\n\t"
448                        "sync \n\t"
449                        "icbi 0,%0 \n\t"
450                        "isync \n\t"
451                        : : "r" (addr));
452                 addr += L1_CACHE_BYTES;
453                 length -= L1_CACHE_BYTES;
454         }
455
456         __asm ("dcbf 0,%0\n\t"
457                "sync \n\t"
458                "icbi 0,%0 \n\t"
459                "isync \n\t"
460                : : "r" (addr));
461 }
462
463 /****************************************************** from setup.c */
464 void
465 apus_restart(char *cmd)
466 {
467         local_irq_disable();
468
469         APUS_WRITE(APUS_REG_LOCK,
470                    REGLOCK_BLACKMAGICK1|REGLOCK_BLACKMAGICK2);
471         APUS_WRITE(APUS_REG_LOCK,
472                    REGLOCK_BLACKMAGICK1|REGLOCK_BLACKMAGICK3);
473         APUS_WRITE(APUS_REG_LOCK,
474                    REGLOCK_BLACKMAGICK2|REGLOCK_BLACKMAGICK3);
475         APUS_WRITE(APUS_REG_SHADOW, REGSHADOW_SELFRESET);
476         APUS_WRITE(APUS_REG_RESET, REGRESET_AMIGARESET);
477         for(;;);
478 }
479
480 void
481 apus_power_off(void)
482 {
483         for (;;);
484 }
485
486 void
487 apus_halt(void)
488 {
489    apus_restart(NULL);
490 }
491
492 /****************************************************** IRQ stuff */
493
494 static unsigned char last_ipl[8];
495
496 int apus_get_irq(struct pt_regs* regs)
497 {
498         unsigned char ipl_emu, mask;
499         unsigned int level;
500
501         APUS_READ(APUS_IPL_EMU, ipl_emu);
502         level = (ipl_emu >> 3) & IPLEMU_IPLMASK;
503         mask = IPLEMU_SETRESET|IPLEMU_DISABLEINT|level;
504         level ^= 7;
505
506         /* Save previous IPL value */
507         if (last_ipl[level])
508                 return -2;
509         last_ipl[level] = ipl_emu;
510
511         /* Set to current IPL value */
512         APUS_WRITE(APUS_IPL_EMU, mask);
513         APUS_WRITE(APUS_IPL_EMU, IPLEMU_DISABLEINT|level);
514
515
516 #ifdef __INTERRUPT_DEBUG
517         printk("<%d:%d>", level, ~ipl_emu & IPLEMU_IPLMASK);
518 #endif
519         return level + IRQ_AMIGA_AUTO;
520 }
521
522 void apus_end_irq(unsigned int irq)
523 {
524         unsigned char ipl_emu;
525         unsigned int level = irq - IRQ_AMIGA_AUTO;
526 #ifdef __INTERRUPT_DEBUG
527         printk("{%d}", ~last_ipl[level] & IPLEMU_IPLMASK);
528 #endif
529         /* Restore IPL to the previous value */
530         ipl_emu = last_ipl[level] & IPLEMU_IPLMASK;
531         APUS_WRITE(APUS_IPL_EMU, IPLEMU_SETRESET|IPLEMU_DISABLEINT|ipl_emu);
532         last_ipl[level] = 0;
533         ipl_emu ^= 7;
534         APUS_WRITE(APUS_IPL_EMU, IPLEMU_DISABLEINT|ipl_emu);
535 }
536
537 /****************************************************** debugging */
538
539 /* some serial hardware definitions */
540 #define SDR_OVRUN   (1<<15)
541 #define SDR_RBF     (1<<14)
542 #define SDR_TBE     (1<<13)
543 #define SDR_TSRE    (1<<12)
544
545 #define AC_SETCLR   (1<<15)
546 #define AC_UARTBRK  (1<<11)
547
548 #define SER_DTR     (1<<7)
549 #define SER_RTS     (1<<6)
550 #define SER_DCD     (1<<5)
551 #define SER_CTS     (1<<4)
552 #define SER_DSR     (1<<3)
553
554 static __inline__ void ser_RTSon(void)
555 {
556     ciab.pra &= ~SER_RTS; /* active low */
557 }
558
559 int __debug_ser_out( unsigned char c )
560 {
561         amiga_custom.serdat = c | 0x100;
562         mb();
563         while (!(amiga_custom.serdatr & 0x2000))
564                 barrier();
565         return 1;
566 }
567
568 unsigned char __debug_ser_in( void )
569 {
570         unsigned char c;
571
572         /* XXX: is that ok?? derived from amiga_ser.c... */
573         while( !(amiga_custom.intreqr & IF_RBF) )
574                 barrier();
575         c = amiga_custom.serdatr;
576         /* clear the interrupt, so that another character can be read */
577         amiga_custom.intreq = IF_RBF;
578         return c;
579 }
580
581 int __debug_serinit( void )
582 {
583         unsigned long flags;
584
585         local_irq_save(flags);
586
587         /* turn off Rx and Tx interrupts */
588         amiga_custom.intena = IF_RBF | IF_TBE;
589
590         /* clear any pending interrupt */
591         amiga_custom.intreq = IF_RBF | IF_TBE;
592
593         local_irq_restore(flags);
594
595         /*
596          * set the appropriate directions for the modem control flags,
597          * and clear RTS and DTR
598          */
599         ciab.ddra |= (SER_DTR | SER_RTS);   /* outputs */
600         ciab.ddra &= ~(SER_DCD | SER_CTS | SER_DSR);  /* inputs */
601
602 #ifdef CONFIG_KGDB
603         /* turn Rx interrupts on for GDB */
604         amiga_custom.intena = IF_SETCLR | IF_RBF;
605         ser_RTSon();
606 #endif
607
608         return 0;
609 }
610
611 void __debug_print_hex(unsigned long x)
612 {
613         int i;
614         char hexchars[] = "0123456789ABCDEF";
615
616         for (i = 0; i < 8; i++) {
617                 __debug_ser_out(hexchars[(x >> 28) & 15]);
618                 x <<= 4;
619         }
620         __debug_ser_out('\n');
621         __debug_ser_out('\r');
622 }
623
624 void __debug_print_string(char* s)
625 {
626         unsigned char c;
627         while((c = *s++))
628                 __debug_ser_out(c);
629         __debug_ser_out('\n');
630         __debug_ser_out('\r');
631 }
632
633 static void apus_progress(char *s, unsigned short value)
634 {
635         __debug_print_string(s);
636 }
637
638 /****************************************************** init */
639
640 /* The number of spurious interrupts */
641 volatile unsigned int num_spurious;
642
643 extern struct irqaction amiga_sys_irqaction[AUTO_IRQS];
644
645
646 extern void amiga_enable_irq(unsigned int irq);
647 extern void amiga_disable_irq(unsigned int irq);
648
649 struct hw_interrupt_type amiga_sys_irqctrl = {
650         .typename = "Amiga IPL",
651         .end = apus_end_irq,
652 };
653
654 struct hw_interrupt_type amiga_irqctrl = {
655         .typename = "Amiga    ",
656         .enable = amiga_enable_irq,
657         .disable = amiga_disable_irq,
658 };
659
660 #define HARDWARE_MAPPED_SIZE (512*1024)
661 unsigned long __init apus_find_end_of_memory(void)
662 {
663         int shadow = 0;
664         unsigned long total;
665
666         /* The memory size reported by ADOS excludes the 512KB
667            reserved for PPC exception registers and possibly 512KB
668            containing a shadow of the ADOS ROM. */
669         {
670                 unsigned long size = memory[0].size;
671
672                 /* If 2MB aligned, size was probably user
673                    specified. We can't tell anything about shadowing
674                    in this case so skip shadow assignment. */
675                 if (0 != (size & 0x1fffff)){
676                         /* Align to 512KB to ensure correct handling
677                            of both memfile and system specified
678                            sizes. */
679                         size = ((size+0x0007ffff) & 0xfff80000);
680                         /* If memory is 1MB aligned, assume
681                            shadowing. */
682                         shadow = !(size & 0x80000);
683                 }
684
685                 /* Add the chunk that ADOS does not see. by aligning
686                    the size to the nearest 2MB limit upwards.  */
687                 memory[0].size = ((size+0x001fffff) & 0xffe00000);
688         }
689
690         ppc_memstart = memory[0].addr;
691         ppc_memoffset = PAGE_OFFSET - PPC_MEMSTART;
692         total = memory[0].size;
693
694         /* Remove the memory chunks that are controlled by special
695            Phase5 hardware. */
696
697         /* Remove the upper 512KB if it contains a shadow of
698            the ADOS ROM. FIXME: It might be possible to
699            disable this shadow HW. Check the booter
700            (ppc_boot.c) */
701         if (shadow)
702                 total -= HARDWARE_MAPPED_SIZE;
703
704         /* Remove the upper 512KB where the PPC exception
705            vectors are mapped. */
706         total -= HARDWARE_MAPPED_SIZE;
707
708         /* Linux/APUS only handles one block of memory -- the one on
709            the PowerUP board. Other system memory is horrible slow in
710            comparison. The user can use other memory for swapping
711            using the z2ram device. */
712         return total;
713 }
714
715 static void __init
716 apus_map_io(void)
717 {
718         /* Map PPC exception vectors. */
719         io_block_mapping(0xfff00000, 0xfff00000, 0x00020000, _PAGE_KERNEL);
720         /* Map chip and ZorroII memory */
721         io_block_mapping(zTwoBase,   0x00000000, 0x01000000, _PAGE_IO);
722 }
723
724 __init
725 void apus_init_IRQ(void)
726 {
727         struct irqaction *action;
728         int i;
729
730 #ifdef CONFIG_PCI
731         apus_setup_pci_ptrs();
732 #endif
733
734         for ( i = 0 ; i < AMI_IRQS; i++ ) {
735                 irq_desc[i].status = IRQ_LEVEL;
736                 if (i < IRQ_AMIGA_AUTO) {
737                         irq_desc[i].handler = &amiga_irqctrl;
738                 } else {
739                         irq_desc[i].handler = &amiga_sys_irqctrl;
740                         action = &amiga_sys_irqaction[i-IRQ_AMIGA_AUTO];
741                         if (action->name)
742                                 setup_irq(i, action);
743                 }
744         }
745
746         amiga_init_IRQ();
747
748 }
749
750 __init
751 void platform_init(unsigned long r3, unsigned long r4, unsigned long r5,
752                    unsigned long r6, unsigned long r7)
753 {
754         extern int parse_bootinfo(const struct bi_record *);
755         extern char _end[];
756
757         /* Parse bootinfo. The bootinfo is located right after
758            the kernel bss */
759         parse_bootinfo((const struct bi_record *)&_end);
760 #ifdef CONFIG_BLK_DEV_INITRD
761         /* Take care of initrd if we have one. Use data from
762            bootinfo to avoid the need to initialize PPC
763            registers when kernel is booted via a PPC reset. */
764         if ( ramdisk.addr ) {
765                 initrd_start = (unsigned long) __va(ramdisk.addr);
766                 initrd_end = (unsigned long)
767                         __va(ramdisk.size + ramdisk.addr);
768         }
769 #endif /* CONFIG_BLK_DEV_INITRD */
770
771         ISA_DMA_THRESHOLD = 0x00ffffff;
772
773         ppc_md.setup_arch     = apus_setup_arch;
774         ppc_md.show_cpuinfo   = apus_show_cpuinfo;
775         ppc_md.init_IRQ       = apus_init_IRQ;
776         ppc_md.get_irq        = apus_get_irq;
777
778 #ifdef CONFIG_HEARTBEAT
779         ppc_md.heartbeat      = apus_heartbeat;
780         ppc_md.heartbeat_count = 1;
781 #endif
782 #ifdef APUS_DEBUG
783         __debug_serinit();
784         ppc_md.progress       = apus_progress;
785 #endif
786         ppc_md.init           = NULL;
787
788         ppc_md.restart        = apus_restart;
789         ppc_md.power_off      = apus_power_off;
790         ppc_md.halt           = apus_halt;
791
792         ppc_md.time_init      = NULL;
793         ppc_md.set_rtc_time   = apus_set_rtc_time;
794         ppc_md.get_rtc_time   = apus_get_rtc_time;
795         ppc_md.calibrate_decr = apus_calibrate_decr;
796
797         ppc_md.find_end_of_memory = apus_find_end_of_memory;
798         ppc_md.setup_io_mappings = apus_map_io;
799 }