[PATCH] Removing SYMBOL_NAME part 4
[opensuse:kernel.git] / arch / m68k / kernel / head.S
1 /* -*- mode: asm -*-
2 **
3 ** head.S -- This file contains the initial boot code for the
4 **           Linux/68k kernel.
5 **
6 ** Copyright 1993 by Hamish Macdonald
7 **
8 ** 68040 fixes by Michael Rausch
9 ** 68060 fixes by Roman Hodek
10 ** MMU cleanup by Randy Thelen
11 ** Final MMU cleanup by Roman Zippel
12 **
13 ** Atari support by Andreas Schwab, using ideas of Robert de Vries
14 ** and Bjoern Brauel
15 ** VME Support by Richard Hirst
16 **
17 ** 94/11/14 Andreas Schwab: put kernel at PAGESIZE
18 ** 94/11/18 Andreas Schwab: remove identity mapping of STRAM for Atari
19 ** ++ Bjoern & Roman: ATARI-68040 support for the Medusa
20 ** 95/11/18 Richard Hirst: Added MVME166 support
21 ** 96/04/26 Guenther Kelleter: fixed identity mapping for Falcon with
22 **                            Magnum- and FX-alternate ram
23 ** 98/04/25 Phil Blundell: added HP300 support
24 ** 1998/08/30 David Kilzer: Added support for fbcon_font_desc structures
25 **            for linux-2.1.115
26 ** 9/02/11  Richard Zidlicky: added Q40 support (initial vesion 99/01/01) 
27 **
28 ** This file is subject to the terms and conditions of the GNU General Public
29 ** License. See the file README.legal in the main directory of this archive
30 ** for more details.
31 **
32 */
33
34 /*
35  * Linux startup code.
36  *
37  * At this point, the boot loader has:
38  * Disabled interrupts
39  * Disabled caches
40  * Put us in supervisor state.
41  *
42  * The kernel setup code takes the following steps:
43  * .  Raise interrupt level
44  * .  Set up initial kernel memory mapping.
45  *    .  This sets up a mapping of the 4M of memory the kernel is located in.
46  *    .  It also does a mapping of any initial machine specific areas.
47  * .  Enable the MMU
48  * .  Enable cache memories
49  * .  Jump to kernel startup
50  *
51  * Much of the file restructuring was to accomplish:
52  * 1) Remove register dependency through-out the file.
53  * 2) Increase use of subroutines to perform functions
54  * 3) Increase readability of the code
55  *
56  * Of course, readability is a subjective issue, so it will never be
57  * argued that that goal was accomplished.  It was merely a goal.
58  * A key way to help make code more readable is to give good
59  * documentation.  So, the first thing you will find is exaustive
60  * write-ups on the structure of the file, and the features of the
61  * functional subroutines.
62  *
63  * General Structure:
64  * ------------------
65  *      Without a doubt the single largest chunk of head.S is spent
66  * mapping the kernel and I/O physical space into the logical range
67  * for the kernel.
68  *      There are new subroutines and data structures to make MMU
69  * support cleaner and easier to understand.
70  *      First, you will find a routine call "mmu_map" which maps
71  * a logical to a physical region for some length given a cache
72  * type on behalf of the caller.  This routine makes writing the
73  * actual per-machine specific code very simple.
74  *      A central part of the code, but not a subroutine in itself,
75  * is the mmu_init code which is broken down into mapping the kernel
76  * (the same for all machines) and mapping machine-specific I/O
77  * regions.
78  *      Also, there will be a description of engaging the MMU and
79  * caches.
80  *      You will notice that there is a chunk of code which
81  * can emit the entire MMU mapping of the machine.  This is present
82  * only in debug modes and can be very helpful.
83  *      Further, there is a new console driver in head.S that is
84  * also only engaged in debug mode.  Currently, it's only supported
85  * on the Macintosh class of machines.  However, it is hoped that
86  * others will plug-in support for specific machines.
87  *
88  * ######################################################################
89  *
90  * mmu_map
91  * -------
92  *      mmu_map was written for two key reasons.  First, it was clear
93  * that it was very difficult to read the previous code for mapping
94  * regions of memory.  Second, the Macintosh required such extensive
95  * memory allocations that it didn't make sense to propogate the
96  * existing code any further.
97  *      mmu_map requires some parameters:
98  *
99  *      mmu_map (logical, physical, length, cache_type)
100  *
101  *      While this essentially describes the function in the abstract, you'll
102  * find more indepth description of other parameters at the implementation site.
103  * 
104  * mmu_get_root_table_entry
105  * ------------------------
106  * mmu_get_ptr_table_entry
107  * -----------------------
108  * mmu_get_page_table_entry
109  * ------------------------
110  * 
111  *      These routines are used by other mmu routines to get a pointer into
112  * a table, if necessary a new table is allocated. These routines are working
113  * basically like pmd_alloc() and pte_alloc() in <asm/pgtable.h>. The root
114  * table needs of course only to be allocated once in mmu_get_root_table_entry,
115  * so that here also some mmu specific initialization is done. The second page
116  * at the start of the kernel (the first page is unmapped later) is used for
117  * the kernel_pg_dir. It must be at a position known at link time (as it's used
118  * to initialize the init task struct) and since it needs special cache
119  * settings, it's the easiest to use this page, the rest of the page is used
120  * for further pointer tables.
121  * mmu_get_page_table_entry allocates always a whole page for page tables, this
122  * means 1024 pages and so 4MB of memory can be mapped. It doesn't make sense
123  * to manage page tables in smaller pieces as nearly all mappings have that
124  * size.
125  *
126  * ######################################################################
127  *
128  *
129  * ######################################################################
130  *
131  * mmu_engage
132  * ----------
133  *      Thanks to a small helping routine enabling the mmu got quiet simple
134  * and there is only one way left. mmu_engage makes a complete a new mapping
135  * that only includes the absolute necessary to be able to jump to the final
136  * postion and to restore the original mapping.
137  * As this code doesn't need a transparent translation register anymore this
138  * means all registers are free to be used by machines that needs them for
139  * other purposes.
140  *
141  * ######################################################################
142  *
143  * mmu_print
144  * ---------
145  *      This algorithm will print out the page tables of the system as
146  * appropriate for an 030 or an 040.  This is useful for debugging purposes
147  * and as such is enclosed in #ifdef MMU_PRINT/#endif clauses.
148  *
149  * ######################################################################
150  *
151  * console_init
152  * ------------
153  *      The console is also able to be turned off.  The console in head.S
154  * is specifically for debugging and can be very useful.  It is surrounded by
155  * #ifdef CONSOLE/#endif clauses so it doesn't have to ship in known-good
156  * kernels.  It's basic algorithm is to determine the size of the screen
157  * (in height/width and bit depth) and then use that information for
158  * displaying an 8x8 font or an 8x16 (widthxheight).  I prefer the 8x8 for
159  * debugging so I can see more good data.  But it was trivial to add support
160  * for both fonts, so I included it.
161  *      Also, the algorithm for plotting pixels is abstracted so that in
162  * theory other platforms could add support for different kinds of frame
163  * buffers.  This could be very useful.
164  *
165  * console_put_penguin
166  * -------------------
167  *      An important part of any Linux bring up is the penguin and there's
168  * nothing like getting the Penguin on the screen!  This algorithm will work
169  * on any machine for which there is a console_plot_pixel.
170  *
171  * console_scroll
172  * --------------
173  *      My hope is that the scroll algorithm does the right thing on the
174  * various platforms, but it wouldn't be hard to add the test conditions
175  * and new code if it doesn't.
176  *
177  * console_putc
178  * -------------
179  *
180  * ######################################################################
181  *
182  *      Register usage has greatly simplified within head.S. Every subroutine
183  * saves and restores all registers that it modifies (except it returns a
184  * value in there of course). So the only register that needs to be initialized
185  * is the stack pointer.
186  * All other init code and data is now placed in the init section, so it will
187  * be automatically freed at the end of the kernel initialization.
188  *
189  * ######################################################################
190  *
191  * options
192  * -------
193  *      There are many options availble in a build of this file.  I've
194  * taken the time to describe them here to save you the time of searching
195  * for them and trying to understand what they mean.
196  *
197  * CONFIG_xxx:  These are the obvious machine configuration defines created
198  * during configuration.  These are defined in include/linux/autoconf.h.
199  *
200  * CONSOLE:     There is support for head.S console in this file.  This
201  * console can talk to a Mac frame buffer, but could easily be extrapolated
202  * to extend it to support other platforms.
203  *
204  * TEST_MMU:    This is a test harness for running on any given machine but
205  * getting an MMU dump for another class of machine.  The classes of machines
206  * that can be tested are any of the makes (Atari, Amiga, Mac, VME, etc.)
207  * and any of the models (030, 040, 060, etc.).
208  *
209  *      NOTE:   TEST_MMU is NOT permanent!  It is scheduled to be removed
210  *              When head.S boots on Atari, Amiga, Macintosh, and VME
211  *              machines.  At that point the underlying logic will be
212  *              believed to be solid enough to be trusted, and TEST_MMU
213  *              can be dropped.  Do note that that will clean up the
214  *              head.S code significantly as large blocks of #if/#else
215  *              clauses can be removed.
216  *
217  * MMU_NOCACHE_KERNEL:  On the Macintosh platform there was an inquiry into
218  * determing why devices don't appear to work.  A test case was to remove
219  * the cacheability of the kernel bits.
220  *
221  * MMU_PRINT:   There is a routine built into head.S that can display the
222  * MMU data structures.  It outputs its result through the serial_putc
223  * interface.  So where ever that winds up driving data, that's where the
224  * mmu struct will appear.  On the Macintosh that's typically the console.
225  *
226  * SERIAL_DEBUG:        There are a series of putc() macro statements
227  * scattered through out the code to give progress of status to the
228  * person sitting at the console.  This constant determines whether those
229  * are used.
230  *
231  * DEBUG:       This is the standard DEBUG flag that can be set for building
232  *              the kernel.  It has the effect adding additional tests into
233  *              the code.
234  *
235  * FONT_6x11:
236  * FONT_8x8:
237  * FONT_8x16:
238  *              In theory these could be determined at run time or handed
239  *              over by the booter.  But, let's be real, it's a fine hard
240  *              coded value.  (But, you will notice the code is run-time
241  *              flexible!)  A pointer to the font's struct fbcon_font_desc
242  *              is kept locally in Lconsole_font.  It is used to determine
243  *              font size information dynamically.
244  *
245  * Atari constants:
246  * USE_PRINTER: Use the printer port for serial debug.
247  * USE_SCC_B:   Use the SCC port A (Serial2) for serial debug.
248  * USE_SCC_A:   Use the SCC port B (Modem2) for serial debug.
249  * USE_MFP:     Use the ST-MFP port (Modem1) for serial debug.
250  *
251  * Macintosh constants:
252  * MAC_SERIAL_DEBUG:    Turns on serial debug output for the Macintosh.
253  * MAC_USE_SCC_A:       Use the SCC port A (modem) for serial debug.
254  * MAC_USE_SCC_B:       Use the SCC port B (printer) for serial debug (default).
255  */
256
257 #include <linux/config.h>
258 #include <linux/linkage.h>
259 #include <linux/init.h>
260 #include <asm/bootinfo.h>
261 #include <asm/setup.h>
262 #include <asm/entry.h>
263 #include <asm/pgtable.h>
264 #include <asm/page.h>
265 #include "m68k_defs.h"
266
267 #ifdef CONFIG_MAC
268
269 #include <asm/machw.h>
270
271 /*
272  * Macintosh console support
273  */
274
275 #define CONSOLE
276
277 /*
278  * Macintosh serial debug support; outputs boot info to the printer
279  *   and/or modem serial ports
280  */
281 #undef MAC_SERIAL_DEBUG
282
283 /*
284  * Macintosh serial debug port selection; define one or both;
285  *   requires MAC_SERIAL_DEBUG to be defined
286  */
287 #define MAC_USE_SCC_A           /* Macintosh modem serial port */
288 #define MAC_USE_SCC_B           /* Macintosh printer serial port */
289
290 #endif  /* CONFIG_MAC */
291
292 #undef MMU_PRINT
293 #undef MMU_NOCACHE_KERNEL
294 #define SERIAL_DEBUG
295 #undef DEBUG
296
297 /*
298  * For the head.S console, there are three supported fonts, 6x11, 8x16 and 8x8.
299  * The 8x8 font is harder to read but fits more on the screen.
300  */
301 #define FONT_8x8        /* default */
302 /* #define FONT_8x16 */ /* 2nd choice */
303 /* #define FONT_6x11 */ /* 3rd choice */
304
305 .globl kernel_pg_dir
306 .globl availmem
307 .globl m68k_pgtable_cachemode
308 .globl m68k_supervisor_cachemode
309 #ifdef CONFIG_MVME16x
310 .globl mvme_bdid
311 #endif
312 #ifdef CONFIG_Q40
313 .globl q40_mem_cptr     
314 #endif          
315
316 CPUTYPE_040     = 1     /* indicates an 040 */
317 CPUTYPE_060     = 2     /* indicates an 060 */
318 CPUTYPE_0460    = 3     /* if either above are set, this is set */
319 CPUTYPE_020     = 4     /* indicates an 020 */
320
321 /* Translation control register */
322 TC_ENABLE = 0x8000
323 TC_PAGE8K = 0x4000
324 TC_PAGE4K = 0x0000
325
326 /* Transparent translation registers */
327 TTR_ENABLE      = 0x8000        /* enable transparent translation */
328 TTR_ANYMODE     = 0x4000        /* user and kernel mode access */
329 TTR_KERNELMODE  = 0x2000        /* only kernel mode access */
330 TTR_USERMODE    = 0x0000        /* only user mode access */
331 TTR_CI          = 0x0400        /* inhibit cache */
332 TTR_RW          = 0x0200        /* read/write mode */
333 TTR_RWM         = 0x0100        /* read/write mask */
334 TTR_FCB2        = 0x0040        /* function code base bit 2 */
335 TTR_FCB1        = 0x0020        /* function code base bit 1 */
336 TTR_FCB0        = 0x0010        /* function code base bit 0 */
337 TTR_FCM2        = 0x0004        /* function code mask bit 2 */
338 TTR_FCM1        = 0x0002        /* function code mask bit 1 */
339 TTR_FCM0        = 0x0001        /* function code mask bit 0 */
340
341 /* Cache Control registers */
342 CC6_ENABLE_D    = 0x80000000    /* enable data cache (680[46]0) */
343 CC6_FREEZE_D    = 0x40000000    /* freeze data cache (68060) */
344 CC6_ENABLE_SB   = 0x20000000    /* enable store buffer (68060) */
345 CC6_PUSH_DPI    = 0x10000000    /* disable CPUSH invalidation (68060) */
346 CC6_HALF_D      = 0x08000000    /* half-cache mode for data cache (68060) */
347 CC6_ENABLE_B    = 0x00800000    /* enable branch cache (68060) */
348 CC6_CLRA_B      = 0x00400000    /* clear all entries in branch cache (68060) */
349 CC6_CLRU_B      = 0x00200000    /* clear user entries in branch cache (68060) */
350 CC6_ENABLE_I    = 0x00008000    /* enable instruction cache (680[46]0) */
351 CC6_FREEZE_I    = 0x00004000    /* freeze instruction cache (68060) */
352 CC6_HALF_I      = 0x00002000    /* half-cache mode for instruction cache (68060) */
353 CC3_ALLOC_WRITE = 0x00002000    /* write allocate mode(68030) */
354 CC3_ENABLE_DB   = 0x00001000    /* enable data burst (68030) */
355 CC3_CLR_D       = 0x00000800    /* clear data cache (68030) */
356 CC3_CLRE_D      = 0x00000400    /* clear entry in data cache (68030) */
357 CC3_FREEZE_D    = 0x00000200    /* freeze data cache (68030) */
358 CC3_ENABLE_D    = 0x00000100    /* enable data cache (68030) */
359 CC3_ENABLE_IB   = 0x00000010    /* enable instruction burst (68030) */
360 CC3_CLR_I       = 0x00000008    /* clear instruction cache (68030) */
361 CC3_CLRE_I      = 0x00000004    /* clear entry in instruction cache (68030) */
362 CC3_FREEZE_I    = 0x00000002    /* freeze instruction cache (68030) */
363 CC3_ENABLE_I    = 0x00000001    /* enable instruction cache (68030) */
364
365 /* Miscellaneous definitions */
366 PAGESIZE        = 4096
367 PAGESHIFT       = 12
368
369 ROOT_TABLE_SIZE = 128
370 PTR_TABLE_SIZE  = 128
371 PAGE_TABLE_SIZE = 64
372 ROOT_INDEX_SHIFT = 25
373 PTR_INDEX_SHIFT  = 18
374 PAGE_INDEX_SHIFT = 12
375
376 #ifdef DEBUG
377 /* When debugging use readable names for labels */
378 #ifdef __STDC__
379 #define L(name) .head.S.##name
380 #else
381 #define L(name) .head.S./**/name
382 #endif
383 #else
384 #ifdef __STDC__
385 #define L(name) .L##name
386 #else
387 #define L(name) .L/**/name
388 #endif
389 #endif
390
391 /* The __INITDATA stuff is a no-op when ftrace or kgdb are turned on */
392 #ifndef __INITDATA
393 #define __INITDATA      .data
394 #define __FINIT         .previous
395 #endif
396
397 /* Several macros to make the writing of subroutines easier:
398  * - func_start marks the beginning of the routine which setups the frame
399  *   register and saves the registers, it also defines another macro
400  *   to automatically restore the registers again.
401  * - func_return marks the end of the routine and simply calls the prepared
402  *   macro to restore registers and jump back to the caller.
403  * - func_define generates another macro to automatically put arguments
404  *   onto the stack call the subroutine and cleanup the stack again.
405  */
406
407 /* Within subroutines these macros can be used to access the arguments
408  * on the stack. With STACK some allocated memory on the stack can be
409  * accessed and ARG0 points to the return address (used by mmu_engage).
410  */
411 #define STACK   %a6@(stackstart)
412 #define ARG0    %a6@(4)
413 #define ARG1    %a6@(8)
414 #define ARG2    %a6@(12)
415 #define ARG3    %a6@(16)
416 #define ARG4    %a6@(20)
417
418 .macro  func_start      name,saveregs,stack=0
419 L(\name):
420         linkw   %a6,#-\stack
421         moveml  \saveregs,%sp@-
422 .set    stackstart,-\stack      
423
424 .macro  func_return_\name
425         moveml  %sp@+,\saveregs
426         unlk    %a6
427         rts
428 .endm
429 .endm
430
431 .macro  func_return     name
432         func_return_\name
433 .endm
434
435 .macro  func_call       name
436         jbsr    L(\name)
437 .endm
438
439 .macro  move_stack      nr,arg1,arg2,arg3,arg4
440 .if     \nr
441         move_stack      "(\nr-1)",\arg2,\arg3,\arg4
442         movel   \arg1,%sp@-
443 .endif
444 .endm
445
446 .macro  func_define     name,nr=0
447 .macro  \name   arg1,arg2,arg3,arg4
448         move_stack      \nr,\arg1,\arg2,\arg3,\arg4
449         func_call       \name
450 .if     \nr
451         lea     %sp@(\nr*4),%sp
452 .endif
453 .endm
454 .endm
455
456 func_define     mmu_map,4
457 func_define     mmu_map_tt,4
458 func_define     mmu_fixup_page_mmu_cache,1
459 func_define     mmu_temp_map,2
460 func_define     mmu_engage
461 func_define     mmu_get_root_table_entry,1
462 func_define     mmu_get_ptr_table_entry,2
463 func_define     mmu_get_page_table_entry,2
464 func_define     mmu_print
465 func_define     get_new_page
466 #ifdef CONFIG_HP300
467 func_define     set_leds
468 #endif
469
470 .macro  mmu_map_eq      arg1,arg2,arg3
471         mmu_map \arg1,\arg1,\arg2,\arg3
472 .endm
473
474 .macro  get_bi_record   record
475         pea     \record
476         func_call       get_bi_record
477         addql   #4,%sp
478 .endm
479
480 func_define     serial_putc,1
481 func_define     console_putc,1
482
483 .macro  putc    ch
484 #if defined(CONSOLE) || defined(SERIAL_DEBUG)
485         pea     \ch
486 #endif
487 #ifdef CONSOLE
488         func_call       console_putc
489 #endif
490 #ifdef SERIAL_DEBUG
491         func_call       serial_putc
492 #endif
493 #if defined(CONSOLE) || defined(SERIAL_DEBUG)
494         addql   #4,%sp
495 #endif
496 .endm
497
498 .macro  dputc   ch
499 #ifdef DEBUG
500         putc    \ch
501 #endif
502 .endm
503
504 func_define     putn,1
505
506 .macro  dputn   nr
507 #ifdef DEBUG
508         putn    \nr
509 #endif
510 .endm
511
512 .macro  puts            string
513 #if defined(CONSOLE) || defined(SERIAL_DEBUG)
514         __INITDATA
515 .Lstr\@:
516         .string "\string"
517         __FINIT
518         pea     %pc@(.Lstr\@)
519         func_call       puts
520         addql   #4,%sp
521 #endif
522 .endm
523
524 .macro  dputs   string
525 #ifdef DEBUG
526         puts    "\string"
527 #endif
528 .endm
529
530 #define is_not_amiga(lab) cmpl &MACH_AMIGA,%pc@(m68k_machtype); jne lab
531 #define is_not_atari(lab) cmpl &MACH_ATARI,%pc@(m68k_machtype); jne lab
532 #define is_not_mac(lab) cmpl &MACH_MAC,%pc@(m68k_machtype); jne lab
533 #define is_not_mvme147(lab) cmpl &MACH_MVME147,%pc@(m68k_machtype); jne lab
534 #define is_not_mvme16x(lab) cmpl &MACH_MVME16x,%pc@(m68k_machtype); jne lab
535 #define is_not_bvme6000(lab) cmpl &MACH_BVME6000,%pc@(m68k_machtype); jne lab
536 #define is_mvme147(lab) cmpl &MACH_MVME147,%pc@(m68k_machtype); jeq lab
537 #define is_mvme16x(lab) cmpl &MACH_MVME16x,%pc@(m68k_machtype); jeq lab
538 #define is_bvme6000(lab) cmpl &MACH_BVME6000,%pc@(m68k_machtype); jeq lab
539 #define is_not_hp300(lab) cmpl &MACH_HP300,%pc@(m68k_machtype); jne lab
540 #define is_not_apollo(lab) cmpl &MACH_APOLLO,%pc@(m68k_machtype); jne lab
541 #define is_not_q40(lab) cmpl &MACH_Q40,%pc@(m68k_machtype); jne lab
542 #define is_not_sun3x(lab) cmpl &MACH_SUN3X,%pc@(m68k_machtype); jne lab
543
544 #define hasnt_leds(lab) cmpl &MACH_HP300,%pc@(m68k_machtype); \
545                         jeq 42f; \
546                         cmpl &MACH_APOLLO,%pc@(m68k_machtype); \
547                         jne lab ;\
548                 42:\
549
550 #define is_040_or_060(lab)      btst &CPUTYPE_0460,%pc@(L(cputype)+3); jne lab
551 #define is_not_040_or_060(lab)  btst &CPUTYPE_0460,%pc@(L(cputype)+3); jeq lab
552 #define is_040(lab)             btst &CPUTYPE_040,%pc@(L(cputype)+3); jne lab
553 #define is_060(lab)             btst &CPUTYPE_060,%pc@(L(cputype)+3); jne lab
554 #define is_not_060(lab)         btst &CPUTYPE_060,%pc@(L(cputype)+3); jeq lab
555 #define is_020(lab)             btst &CPUTYPE_020,%pc@(L(cputype)+3); jne lab
556 #define is_not_020(lab)         btst &CPUTYPE_020,%pc@(L(cputype)+3); jeq lab
557
558 /* On the HP300 we use the on-board LEDs for debug output before
559    the console is running.  Writing a 1 bit turns the corresponding LED
560    _off_ - on the 340 bit 7 is towards the back panel of the machine.  */
561 .macro  leds    mask
562 #if defined(CONFIG_HP300) || defined(CONFIG_APOLLO)
563         hasnt_leds(.Lled\@)
564         pea     \mask
565         func_call       set_leds
566         addql   #4,%sp
567 .Lled\@:
568 #endif
569 .endm
570
571 .text
572 ENTRY(_stext)
573 /*
574  * Version numbers of the bootinfo interface
575  * The area from _stext to _start will later be used as kernel pointer table
576  */
577         bras    1f      /* Jump over bootinfo version numbers */
578
579         .long   BOOTINFOV_MAGIC
580         .long   MACH_AMIGA, AMIGA_BOOTI_VERSION
581         .long   MACH_ATARI, ATARI_BOOTI_VERSION
582         .long   MACH_MVME147, MVME147_BOOTI_VERSION
583         .long   MACH_MVME16x, MVME16x_BOOTI_VERSION
584         .long   MACH_BVME6000, BVME6000_BOOTI_VERSION
585         .long   MACH_MAC, MAC_BOOTI_VERSION
586         .long   MACH_Q40, Q40_BOOTI_VERSION     
587         .long   0
588 1:      jra     __start
589
590 .equ    kernel_pg_dir,_stext
591
592 .equ    .,_stext+PAGESIZE
593
594 ENTRY(_start)
595         jra     __start
596 __INIT
597 ENTRY(__start)
598
599 /*
600  * Setup initial stack pointer
601  */
602         lea     %pc@(_stext),%sp
603
604 /*
605  * Record the CPU and machine type.
606  */
607
608         get_bi_record   BI_MACHTYPE
609         lea     %pc@(m68k_machtype),%a1
610         movel   %a0@,%a1@
611
612         get_bi_record   BI_FPUTYPE
613         lea     %pc@(m68k_fputype),%a1
614         movel   %a0@,%a1@
615
616         get_bi_record   BI_MMUTYPE
617         lea     %pc@(m68k_mmutype),%a1
618         movel   %a0@,%a1@
619
620         get_bi_record   BI_CPUTYPE
621         lea     %pc@(m68k_cputype),%a1
622         movel   %a0@,%a1@
623
624 #ifdef CONFIG_MAC
625 /*
626  * For Macintosh, we need to determine the display parameters early (at least
627  * while debugging it).
628  */
629
630         is_not_mac(L(test_notmac))
631
632         get_bi_record   BI_MAC_VADDR
633         lea     %pc@(L(mac_videobase)),%a1
634         movel   %a0@,%a1@
635
636         get_bi_record   BI_MAC_VDEPTH
637         lea     %pc@(L(mac_videodepth)),%a1
638         movel   %a0@,%a1@
639
640         get_bi_record   BI_MAC_VDIM
641         lea     %pc@(L(mac_dimensions)),%a1
642         movel   %a0@,%a1@
643
644         get_bi_record   BI_MAC_VROW
645         lea     %pc@(L(mac_rowbytes)),%a1
646         movel   %a0@,%a1@
647
648 #ifdef MAC_SERIAL_DEBUG
649         get_bi_record   BI_MAC_SCCBASE
650         lea     %pc@(L(mac_sccbase)),%a1
651         movel   %a0@,%a1@
652 #endif /* MAC_SERIAL_DEBUG */
653
654 #if 0
655         /*
656          * Clear the screen
657          */
658         lea     %pc@(L(mac_videobase)),%a0
659         movel   %a0@,%a1
660         lea     %pc@(L(mac_dimensions)),%a0
661         movel   %a0@,%d1
662         swap    %d1             /* #rows is high bytes */
663         andl    #0xFFFF,%d1     /* rows */
664         subl    #10,%d1
665         lea     %pc@(L(mac_rowbytes)),%a0
666 loopy2:
667         movel   %a0@,%d0
668         subql   #1,%d0
669 loopx2:
670         moveb   #0x55, %a1@+
671         dbra    %d0,loopx2
672         dbra    %d1,loopy2
673 #endif
674
675 L(test_notmac):
676 #endif /* CONFIG_MAC */
677
678
679 /*
680  * There are ultimately two pieces of information we want for all kinds of
681  * processors CpuType and CacheBits.  The CPUTYPE was passed in from booter
682  * and is converted here from a booter type definition to a separate bit
683  * number which allows for the standard is_0x0 macro tests.
684  */
685         movel   %pc@(m68k_cputype),%d0
686         /*
687          * Assume it's an 030
688          */
689         clrl    %d1
690
691         /*
692          * Test the BootInfo cputype for 060
693          */
694         btst    #CPUB_68060,%d0
695         jeq     1f
696         bset    #CPUTYPE_060,%d1
697         bset    #CPUTYPE_0460,%d1
698         jra     3f
699 1:
700         /*
701          * Test the BootInfo cputype for 040
702          */
703         btst    #CPUB_68040,%d0
704         jeq     2f
705         bset    #CPUTYPE_040,%d1
706         bset    #CPUTYPE_0460,%d1
707         jra     3f
708 2:
709         /*
710          * Test the BootInfo cputype for 020
711          */
712         btst    #CPUB_68020,%d0
713         jeq     3f
714         bset    #CPUTYPE_020,%d1
715         jra     3f
716 3:
717         /*
718          * Record the cpu type
719          */
720         lea     %pc@(L(cputype)),%a0
721         movel   %d1,%a0@
722
723         /*
724          * NOTE:
725          *
726          * Now the macros are valid:
727          *      is_040_or_060
728          *      is_not_040_or_060
729          *      is_040
730          *      is_060
731          *      is_not_060
732          */
733
734         /*
735          * Determine the cache mode for pages holding MMU tables
736          * and for supervisor mode, unused for '020 and '030
737          */
738         clrl    %d0
739         clrl    %d1
740
741         is_not_040_or_060(L(save_cachetype))
742
743         /*
744          * '040 or '060
745          * d1 := cacheable write-through
746          * NOTE: The 68040 manual strongly recommends non-cached for MMU tables,
747          * but we have been using write-through since at least 2.0.29 so I
748          * guess it is OK.
749          */
750 #ifdef CONFIG_060_WRITETHROUGH
751         /*
752          * If this is a 68060 board using drivers with cache coherency
753          * problems, then supervisor memory accesses need to be write-through
754          * also; otherwise, we want copyback.
755          */
756
757         is_not_060(1f)
758         movel   #_PAGE_CACHE040W,%d0
759         jra     L(save_cachetype)
760 #endif /* CONFIG_060_WRITETHROUGH */
761 1:
762         movew   #_PAGE_CACHE040,%d0
763
764         movel   #_PAGE_CACHE040W,%d1
765
766 L(save_cachetype):
767         /* Save cache mode for supervisor mode and page tables
768          */
769         lea     %pc@(m68k_supervisor_cachemode),%a0
770         movel   %d0,%a0@
771         lea     %pc@(m68k_pgtable_cachemode),%a0
772         movel   %d1,%a0@
773
774 /*
775  * raise interrupt level
776  */
777         movew   #0x2700,%sr
778
779 /*
780    If running on an Atari, determine the I/O base of the
781    serial port and test if we are running on a Medusa or Hades.
782    This test is necessary here, because on the Hades the serial
783    port is only accessible in the high I/O memory area.
784
785    The test whether it is a Medusa is done by writing to the byte at
786    phys. 0x0. This should result in a bus error on all other machines.
787
788    ...should, but doesn't. The Afterburner040 for the Falcon has the
789    same behaviour (0x0..0x7 are no ROM shadow). So we have to do
790    another test to distinguish Medusa and AB040. This is a
791    read attempt for 0x00ff82fe phys. that should bus error on a Falcon
792    (+AB040), but is in the range where the Medusa always asserts DTACK.
793
794    The test for the Hades is done by reading address 0xb0000000. This
795    should give a bus error on the Medusa.
796  */
797
798 #ifdef CONFIG_ATARI
799         is_not_atari(L(notypetest))
800
801         /* get special machine type (Medusa/Hades/AB40) */
802         moveq   #0,%d3 /* default if tag doesn't exist */
803         get_bi_record   BI_ATARI_MCH_TYPE
804         tstl    %d0
805         jbmi    1f
806         movel   %a0@,%d3
807         lea     %pc@(atari_mch_type),%a0
808         movel   %d3,%a0@
809 1:
810         /* On the Hades, the iobase must be set up before opening the
811          * serial port. There are no I/O regs at 0x00ffxxxx at all. */
812         moveq   #0,%d0
813         cmpl    #ATARI_MACH_HADES,%d3
814         jbne    1f
815         movel   #0xff000000,%d0         /* Hades I/O base addr: 0xff000000 */
816 1:      lea     %pc@(L(iobase)),%a0
817         movel   %d0,%a0@
818
819 L(notypetest):
820 #endif
821
822 #ifdef CONFIG_VME
823         is_mvme147(L(getvmetype))
824         is_bvme6000(L(getvmetype))
825         is_not_mvme16x(L(gvtdone))
826
827         /* See if the loader has specified the BI_VME_TYPE tag.  Recent
828          * versions of VMELILO and TFTPLILO do this.  We have to do this
829          * early so we know how to handle console output.  If the tag
830          * doesn't exist then we use the Bug for output on MVME16x.
831          */
832 L(getvmetype):
833         get_bi_record   BI_VME_TYPE
834         tstl    %d0
835         jbmi    1f
836         movel   %a0@,%d3
837         lea     %pc@(vme_brdtype),%a0
838         movel   %d3,%a0@
839 1:
840 #ifdef CONFIG_MVME16x
841         is_not_mvme16x(L(gvtdone))
842
843         /* Need to get the BRD_ID info to differentiate between 162, 167,
844          * etc.  This is available as a BI_VME_BRDINFO tag with later
845          * versions of VMELILO and TFTPLILO, otherwise we call the Bug.
846          */
847         get_bi_record   BI_VME_BRDINFO
848         tstl    %d0
849         jpl     1f
850
851         /* Get pointer to board ID data from Bug */
852         movel   %d2,%sp@-
853         trap    #15
854         .word   0x70            /* trap 0x70 - .BRD_ID */
855         movel   %sp@+,%a0
856 1:
857         lea     %pc@(mvme_bdid),%a1
858         /* Structure is 32 bytes long */
859         movel   %a0@+,%a1@+
860         movel   %a0@+,%a1@+
861         movel   %a0@+,%a1@+
862         movel   %a0@+,%a1@+
863         movel   %a0@+,%a1@+
864         movel   %a0@+,%a1@+
865         movel   %a0@+,%a1@+
866         movel   %a0@+,%a1@+
867 #endif
868
869 L(gvtdone):
870
871 #endif
872
873 /*
874  * Initialize serial port
875  */
876         jbsr    L(serial_init)
877
878 /*
879  * Initialize console
880  */
881 #ifdef CONFIG_MAC
882         is_not_mac(L(nocon))
883 #ifdef CONSOLE
884         jbsr    L(console_init)
885 #ifdef CONSOLE_PENGUIN
886         jbsr    L(console_put_penguin)
887 #endif  /* CONSOLE_PENGUIN */
888         jbsr    L(console_put_stats)
889 #endif  /* CONSOLE */
890 L(nocon):
891 #endif  /* CONFIG_MAC */
892
893
894         putc    '\n'
895         putc    'A'
896         dputn   %pc@(L(cputype))
897         dputn   %pc@(m68k_supervisor_cachemode)
898         dputn   %pc@(m68k_pgtable_cachemode)
899         dputc   '\n'
900
901 /*
902  * Save physical start address of kernel
903  */
904         lea     %pc@(L(phys_kernel_start)),%a0
905         lea     %pc@(_stext),%a1
906         subl    #_stext,%a1
907         addl    #PAGE_OFFSET,%a1
908         movel   %a1,%a0@
909
910         putc    'B'
911
912         leds    0x4
913
914 /*
915  *      mmu_init
916  *
917  *      This block of code does what's necessary to map in the various kinds
918  *      of machines for execution of Linux.
919  *      First map the first 4 MB of kernel code & data
920  */
921
922         mmu_map #PAGE_OFFSET,%pc@(L(phys_kernel_start)),#4*1024*1024,\
923                 %pc@(m68k_supervisor_cachemode)
924
925         putc    'C'
926
927 #ifdef CONFIG_AMIGA
928
929 L(mmu_init_amiga):
930
931         is_not_amiga(L(mmu_init_not_amiga))
932 /*
933  * mmu_init_amiga
934  */
935
936         putc    'D'
937
938         is_not_040_or_060(1f)
939
940         /*
941          * 040: Map the 16Meg range physical 0x0 upto logical 0x8000.0000
942          */
943         mmu_map         #0x80000000,#0,#0x01000000,#_PAGE_NOCACHE_S
944         /*
945          * Map the Zorro III I/O space with transparent translation
946          * for frame buffer memory etc.
947          */
948         mmu_map_tt      #1,#0x40000000,#0x20000000,#_PAGE_NOCACHE_S
949
950         jbra    L(mmu_init_done)
951
952 1:
953         /*
954          * 030: Map the 32Meg range physical 0x0 upto logical 0x8000.0000
955          */
956         mmu_map         #0x80000000,#0,#0x02000000,#_PAGE_NOCACHE030
957         mmu_map_tt      #1,#0x40000000,#0x20000000,#_PAGE_NOCACHE030
958
959         jbra    L(mmu_init_done)
960
961 L(mmu_init_not_amiga):
962 #endif
963
964 #ifdef CONFIG_ATARI
965
966 L(mmu_init_atari):
967
968         is_not_atari(L(mmu_init_not_atari))
969
970         putc    'E'
971
972 /* On the Atari, we map the I/O region (phys. 0x00ffxxxx) by mapping
973    the last 16 MB of virtual address space to the first 16 MB (i.e.
974    0xffxxxxxx -> 0x00xxxxxx). For this, an additional pointer table is
975    needed. I/O ranges are marked non-cachable.
976
977    For the Medusa it is better to map the I/O region transparently
978    (i.e. 0xffxxxxxx -> 0xffxxxxxx), because some I/O registers are
979    accessible only in the high area.
980
981    On the Hades all I/O registers are only accessible in the high
982    area.
983 */
984
985         /* I/O base addr for non-Medusa, non-Hades: 0x00000000 */
986         moveq   #0,%d0
987         movel   %pc@(atari_mch_type),%d3
988         cmpl    #ATARI_MACH_MEDUSA,%d3
989         jbeq    2f
990         cmpl    #ATARI_MACH_HADES,%d3
991         jbne    1f
992 2:      movel   #0xff000000,%d0 /* Medusa/Hades base addr: 0xff000000 */
993 1:      movel   %d0,%d3
994
995         is_040_or_060(L(spata68040))
996
997         /* Map everything non-cacheable, though not all parts really
998          * need to disable caches (crucial only for 0xff8000..0xffffff
999          * (standard I/O) and 0xf00000..0xf3ffff (IDE)). The remainder
1000          * isn't really used, except for sometimes peeking into the
1001          * ROMs (mirror at phys. 0x0), so caching isn't necessary for
1002          * this. */
1003         mmu_map #0xff000000,%d3,#0x01000000,#_PAGE_NOCACHE030
1004
1005         jbra    L(mmu_init_done)
1006
1007 L(spata68040):
1008
1009         mmu_map #0xff000000,%d3,#0x01000000,#_PAGE_NOCACHE_S
1010
1011         jbra    L(mmu_init_done)
1012
1013 L(mmu_init_not_atari):
1014 #endif
1015
1016 #ifdef CONFIG_Q40
1017         is_not_q40(L(notq40))
1018         /*
1019          * add transparent mapping for 0xff00 0000 - 0xffff ffff
1020          * non-cached serialized etc..
1021          * this includes master chip, DAC, RTC and ISA ports
1022          * 0xfe000000-0xfeffffff is for screen and ROM
1023          */
1024
1025         putc    'Q'
1026
1027         mmu_map_tt      #0,#0xfe000000,#0x01000000,#_PAGE_CACHE040W
1028         mmu_map_tt      #1,#0xff000000,#0x01000000,#_PAGE_NOCACHE_S
1029         
1030         jbra    L(mmu_init_done)
1031         
1032 L(notq40):              
1033 #endif  
1034         
1035 #ifdef CONFIG_HP300
1036         is_not_hp300(L(nothp300))
1037
1038 /* On the HP300, we map the ROM, INTIO and DIO regions (phys. 0x00xxxxxx)
1039    by mapping 32MB from 0xf0xxxxxx -> 0x00xxxxxx) using an 030 early
1040    termination page descriptor.  The ROM mapping is needed because the LEDs
1041    are mapped there too.  */
1042
1043         mmu_map #0xf0000000,#0,#0x02000000,#_PAGE_NOCACHE030
1044
1045 L(nothp300):
1046
1047 #endif
1048
1049 #ifdef CONFIG_MVME147
1050
1051        is_not_mvme147(L(not147))
1052
1053        /*
1054         * On MVME147 we have already created kernel page tables for
1055         * 4MB of RAM at address 0, so now need to do a transparent
1056         * mapping of the top of memory space.  Make it 0.5GByte for now,
1057         * so we can access on-board i/o areas.
1058         */
1059
1060        mmu_map_tt      #1,#0xe0000000,#0x20000000,#_PAGE_NOCACHE030
1061
1062        jbra    L(mmu_init_done)
1063
1064 L(not147):
1065 #endif /* CONFIG_MVME147 */
1066
1067 #ifdef CONFIG_MVME16x
1068
1069         is_not_mvme16x(L(not16x))
1070
1071         /*
1072          * On MVME16x we have already created kernel page tables for
1073          * 4MB of RAM at address 0, so now need to do a transparent
1074          * mapping of the top of memory space.  Make it 0.5GByte for now.
1075          * Supervisor only access, so transparent mapping doesn't
1076          * clash with User code virtual address space.
1077          * this covers IO devices, PROM and SRAM.  The PROM and SRAM
1078          * mapping is needed to allow 167Bug to run.
1079          * IO is in the range 0xfff00000 to 0xfffeffff.
1080          * PROM is 0xff800000->0xffbfffff and SRAM is
1081          * 0xffe00000->0xffe1ffff.
1082          */
1083
1084         mmu_map_tt      #1,#0xe0000000,#0x20000000,#_PAGE_NOCACHE_S
1085
1086         jbra    L(mmu_init_done)
1087
1088 L(not16x):
1089 #endif  /* CONFIG_MVME162 | CONFIG_MVME167 */
1090
1091 #ifdef CONFIG_BVME6000
1092
1093         is_not_bvme6000(L(not6000))
1094
1095         /*
1096          * On BVME6000 we have already created kernel page tables for
1097          * 4MB of RAM at address 0, so now need to do a transparent
1098          * mapping of the top of memory space.  Make it 0.5GByte for now,
1099          * so we can access on-board i/o areas.
1100          * Supervisor only access, so transparent mapping doesn't
1101          * clash with User code virtual address space.
1102          */
1103
1104         mmu_map_tt      #1,#0xe0000000,#0x20000000,#_PAGE_NOCACHE_S
1105
1106         jbra    L(mmu_init_done)
1107
1108 L(not6000):
1109 #endif /* CONFIG_BVME6000 */
1110
1111 /*
1112  * mmu_init_mac
1113  *
1114  * The Macintosh mappings are less clear.
1115  *
1116  * Even as of this writing, it is unclear how the
1117  * Macintosh mappings will be done.  However, as
1118  * the first author of this code I'm proposing the
1119  * following model:
1120  *
1121  * Map the kernel (that's already done),
1122  * Map the I/O (on most machines that's the
1123  * 0x5000.0000 ... 0x5200.0000 range,
1124  * Map the video frame buffer using as few pages
1125  * as absolutely (this requirement mostly stems from
1126  * the fact that when the frame buffer is at
1127  * 0x0000.0000 then we know there is valid RAM just
1128  * above the screen that we don't want to waste!).
1129  *
1130  * By the way, if the frame buffer is at 0x0000.0000
1131  * then the Macintosh is known as an RBV based Mac.
1132  *
1133  * By the way 2, the code currently maps in a bunch of
1134  * regions.  But I'd like to cut that out.  (And move most
1135  * of the mappings up into the kernel proper ... or only
1136  * map what's necessary.)
1137  */
1138
1139 #ifdef CONFIG_MAC
1140
1141 L(mmu_init_mac):
1142
1143         is_not_mac(L(mmu_init_not_mac))
1144
1145         putc    'F'
1146
1147         lea     %pc@(L(mac_videobase)),%a0
1148         lea     %pc@(L(console_video_virtual)),%a1
1149         movel   %a0@,%a1@
1150
1151         is_not_040_or_060(1f)
1152
1153         moveq   #_PAGE_NOCACHE_S,%d3
1154         jbra    2f
1155 1:
1156         moveq   #_PAGE_NOCACHE030,%d3
1157 2:
1158         /*
1159          * Mac Note: screen address of logical 0xF000.0000 -> <screen physical>
1160          *           we simply map the 4MB that contains the videomem
1161          */
1162
1163         movel   #VIDEOMEMMASK,%d0
1164         andl    L(mac_videobase),%d0
1165
1166         mmu_map         #VIDEOMEMBASE,%d0,#VIDEOMEMSIZE,%d3
1167         mmu_map_eq      #0x40800000,#0x02000000,%d3     /* rom ? */
1168         mmu_map_eq      #0x50000000,#0x02000000,%d3
1169         mmu_map_eq      #0x60000000,#0x00400000,%d3
1170         mmu_map_eq      #0x9c000000,#0x00400000,%d3
1171         mmu_map_tt      #1,#0xf8000000,#0x08000000,%d3
1172
1173         jbra    L(mmu_init_done)
1174
1175 L(mmu_init_not_mac):
1176 #endif
1177
1178 #ifdef CONFIG_SUN3X
1179         is_not_sun3x(L(notsun3x))
1180
1181         /* oh, the pain..  We're gonna want the prom code after
1182          * starting the MMU, so we copy the mappings, translating
1183          * from 8k -> 4k pages as we go.
1184          */
1185
1186         /* copy maps from 0xfee00000 to 0xff000000 */
1187         movel   #0xfee00000, %d0
1188         moveq   #ROOT_INDEX_SHIFT, %d1
1189         lsrl    %d1,%d0
1190         mmu_get_root_table_entry        %d0
1191
1192         movel   #0xfee00000, %d0
1193         moveq   #PTR_INDEX_SHIFT, %d1
1194         lsrl    %d1,%d0
1195         andl    #PTR_TABLE_SIZE-1, %d0
1196         mmu_get_ptr_table_entry         %a0,%d0
1197
1198         movel   #0xfee00000, %d0
1199         moveq   #PAGE_INDEX_SHIFT, %d1
1200         lsrl    %d1,%d0
1201         andl    #PAGE_TABLE_SIZE-1, %d0
1202         mmu_get_page_table_entry        %a0,%d0
1203
1204         /* this is where the prom page table lives */   
1205         movel   0xfefe00d4, %a1
1206         movel   %a1@, %a1
1207
1208         movel   #((0x200000 >> 13)-1), %d1
1209
1210 1:
1211         movel   %a1@+, %d3
1212         movel   %d3,%a0@+
1213         addl    #0x1000,%d3
1214         movel   %d3,%a0@+
1215         
1216         dbra    %d1,1b  
1217                 
1218         /* setup tt1 for I/O */
1219         mmu_map_tt      #1,#0x40000000,#0x40000000,#_PAGE_NOCACHE_S 
1220         jbra    L(mmu_init_done)
1221
1222 L(notsun3x):
1223 #endif
1224
1225 #ifdef CONFIG_APOLLO
1226         is_not_apollo(L(notapollo))
1227
1228         putc    'P'
1229         mmu_map         #0x80000000,#0,#0x02000000,#_PAGE_NOCACHE030
1230         
1231 L(notapollo):   
1232         jbra    L(mmu_init_done)
1233 #endif
1234
1235 L(mmu_init_done):
1236
1237         putc    'G'
1238         leds    0x8
1239
1240 /*
1241  * mmu_fixup
1242  *
1243  * On the 040 class machines, all pages that are used for the
1244  * mmu have to be fixed up. According to Motorola, pages holding mmu
1245  * tables should be non-cacheable on a '040 and write-through on a
1246  * '060. But analysis of the reasons for this, and practical
1247  * experience, showed that write-through also works on a '040.
1248  *
1249  * Allocated memory so far goes from kernel_end to memory_start that
1250  * is used for all kind of tables, for that the cache attributes
1251  * are now fixed.
1252  */
1253 L(mmu_fixup):
1254
1255         is_not_040_or_060(L(mmu_fixup_done))
1256
1257 #ifdef MMU_NOCACHE_KERNEL
1258         jbra    L(mmu_fixup_done)
1259 #endif
1260
1261         /* first fix the page at the start of the kernel, that
1262          * contains also kernel_pg_dir.
1263          */
1264         movel   %pc@(L(phys_kernel_start)),%d0
1265         subl    #PAGE_OFFSET,%d0
1266         lea     %pc@(_stext),%a0
1267         subl    %d0,%a0
1268         mmu_fixup_page_mmu_cache        %a0
1269
1270         movel   %pc@(L(kernel_end)),%a0
1271         subl    %d0,%a0
1272         movel   %pc@(L(memory_start)),%a1
1273         subl    %d0,%a1
1274         bra     2f
1275 1:
1276         mmu_fixup_page_mmu_cache        %a0
1277         addw    #PAGESIZE,%a0
1278 2:
1279         cmpl    %a0,%a1
1280         jgt     1b
1281
1282 L(mmu_fixup_done):
1283
1284 #ifdef MMU_PRINT
1285         mmu_print
1286 #endif
1287
1288 /*
1289  * mmu_engage
1290  *
1291  * This chunk of code performs the gruesome task of engaging the MMU.
1292  * The reason its gruesome is because when the MMU becomes engaged it
1293  * maps logical addresses to physical addresses.  The Program Counter
1294  * register is then passed through the MMU before the next instruction
1295  * is fetched (the instruction following the engage MMU instruction).
1296  * This may mean one of two things:
1297  * 1. The Program Counter falls within the logical address space of
1298  *    the kernel of which there are two sub-possibilities:
1299  *    A. The PC maps to the correct instruction (logical PC == physical
1300  *       code location), or
1301  *    B. The PC does not map through and the processor will read some
1302  *       data (or instruction) which is not the logically next instr.
1303  *    As you can imagine, A is good and B is bad.
1304  * Alternatively,
1305  * 2. The Program Counter does not map through the MMU.  The processor
1306  *    will take a Bus Error.
1307  * Clearly, 2 is bad.
1308  * It doesn't take a wiz kid to figure you want 1.A.
1309  * This code creates that possibility.
1310  * There are two possible 1.A. states (we now ignore the other above states):
1311  * A. The kernel is located at physical memory addressed the same as
1312  *    the logical memory for the kernel, i.e., 0x01000.
1313  * B. The kernel is located some where else.  e.g., 0x0400.0000
1314  *
1315  *    Under some conditions the Macintosh can look like A or B.
1316  * [A friend and I once noted that Apple hardware engineers should be
1317  * wacked twice each day: once when they show up at work (as in, Whack!,
1318  * "This is for the screwy hardware we know you're going to design today."),
1319  * and also at the end of the day (as in, Whack! "I don't know what
1320  * you designed today, but I'm sure it wasn't good."). -- rst]
1321  *
1322  * This code works on the following premise:
1323  * If the kernel start (%d5) is within the first 16 Meg of RAM,
1324  * then create a mapping for the kernel at logical 0x8000.0000 to
1325  * the physical location of the pc.  And, create a transparent
1326  * translation register for the first 16 Meg.  Then, after the MMU
1327  * is engaged, the PC can be moved up into the 0x8000.0000 range
1328  * and then the transparent translation can be turned off and then
1329  * the PC can jump to the correct logical location and it will be
1330  * home (finally).  This is essentially the code that the Amiga used
1331  * to use.  Now, it's generalized for all processors.  Which means
1332  * that a fresh (but temporary) mapping has to be created.  The mapping
1333  * is made in page 0 (an as of yet unused location -- except for the
1334  * stack!).  This temporary mapping will only require 1 pointer table
1335  * and a single page table (it can map 256K).
1336  *
1337  * OK, alternatively, imagine that the Program Counter is not within
1338  * the first 16 Meg.  Then, just use Transparent Translation registers
1339  * to do the right thing.
1340  *
1341  * Last, if _start is already at 0x01000, then there's nothing special
1342  * to do (in other words, in a degenerate case of the first case above,
1343  * do nothing).
1344  *
1345  * Let's do it.
1346  *
1347  *
1348  */
1349
1350         putc    'H'
1351
1352         mmu_engage
1353
1354 /*
1355  * After this point no new memory is allocated and
1356  * the start of available memory is stored in availmem.
1357  * (The bootmem allocator requires now the physicall address.)
1358  */
1359
1360         movel   L(memory_start),availmem
1361
1362 #ifdef CONFIG_AMIGA
1363         is_not_amiga(1f)
1364         /* fixup the Amiga custom register location before printing */
1365         clrl    L(custom)
1366 1:
1367 #endif
1368
1369 #ifdef CONFIG_ATARI
1370         is_not_atari(1f)
1371         /* fixup the Atari iobase register location before printing */
1372         movel   #0xff000000,L(iobase)
1373 1:
1374 #endif
1375
1376 #ifdef CONFIG_MAC
1377         is_not_mac(1f)
1378         movel   #~VIDEOMEMMASK,%d0
1379         andl    L(mac_videobase),%d0
1380         addl    #VIDEOMEMBASE,%d0
1381         movel   %d0,L(mac_videobase)
1382 1:
1383 #endif
1384
1385 #ifdef CONFIG_HP300
1386         is_not_hp300(1f)
1387         /*
1388          * Fix up the custom register to point to the new location of the LEDs.
1389          */
1390         movel   #0xf0000000,L(custom)
1391
1392         /*
1393          * Energise the FPU and caches.
1394          */
1395         movel   #0x60,0xf05f400c
1396 1:
1397 #endif
1398
1399 #ifdef CONFIG_SUN3X
1400         is_not_sun3x(1f)
1401
1402         /* enable copro */
1403         oriw    #0x4000,0x61000000 
1404 1:
1405 #endif
1406
1407 #ifdef CONFIG_APOLLO
1408         is_not_apollo(1f)
1409
1410         /*
1411          * Fix up the iobase before printing
1412          */
1413         movel   #0x80000000,L(iobase)
1414 1:
1415 #endif
1416         
1417         putc    'I'
1418         leds    0x10
1419
1420 /*
1421  * Enable caches
1422  */
1423
1424         is_not_040_or_060(L(cache_not_680460))
1425
1426 L(cache680460):
1427         .chip   68040
1428         nop
1429         cpusha  %bc
1430         nop
1431
1432         is_060(L(cache68060))
1433
1434         movel   #CC6_ENABLE_D+CC6_ENABLE_I,%d0
1435         /* MMU stuff works in copyback mode now, so enable the cache */
1436         movec   %d0,%cacr
1437         jra     L(cache_done)
1438
1439 L(cache68060):
1440         movel   #CC6_ENABLE_D+CC6_ENABLE_I+CC6_ENABLE_SB+CC6_PUSH_DPI+CC6_ENABLE_B+CC6_CLRA_B,%d0
1441         /* MMU stuff works in copyback mode now, so enable the cache */
1442         movec   %d0,%cacr
1443         /* enable superscalar dispatch in PCR */
1444         moveq   #1,%d0
1445         .chip   68060
1446         movec   %d0,%pcr
1447
1448         jbra    L(cache_done)
1449 L(cache_not_680460):
1450 L(cache68030):
1451         .chip   68030
1452         movel   #CC3_ENABLE_DB+CC3_CLR_D+CC3_ENABLE_D+CC3_ENABLE_IB+CC3_CLR_I+CC3_ENABLE_I,%d0
1453         movec   %d0,%cacr
1454
1455         jra     L(cache_done)
1456         .chip   68k
1457 L(cache_done):
1458
1459         putc    'J'
1460
1461 /*
1462  * Setup initial stack pointer
1463  */
1464         lea     init_task_union,%curptr
1465         lea     0x2000(%curptr),%sp
1466
1467         putc    'K'
1468
1469         subl    %a6,%a6         /* clear a6 for gdb */
1470
1471 /*
1472  * The new 64bit printf support requires an early exception initialization.
1473  */
1474         jbsr    base_trap_init
1475
1476 /* jump to the kernel start */
1477
1478         putc    '\n'
1479         leds    0x55
1480
1481         jbsr    start_kernel
1482
1483 /*
1484  * Find a tag record in the bootinfo structure
1485  * The bootinfo structure is located right after the kernel bss
1486  * Returns: d0: size (-1 if not found)
1487  *          a0: data pointer (end-of-records if not found)
1488  */
1489 func_start      get_bi_record,%d1
1490
1491         movel   ARG1,%d0
1492         lea     %pc@(_end),%a0
1493 1:      tstw    %a0@(BIR_TAG)
1494         jeq     3f
1495         cmpw    %a0@(BIR_TAG),%d0
1496         jeq     2f
1497         addw    %a0@(BIR_SIZE),%a0
1498         jra     1b
1499 2:      moveq   #0,%d0
1500         movew   %a0@(BIR_SIZE),%d0
1501         lea     %a0@(BIR_DATA),%a0
1502         jra     4f
1503 3:      moveq   #-1,%d0
1504         lea     %a0@(BIR_SIZE),%a0
1505 4:
1506 func_return     get_bi_record
1507
1508
1509 /*
1510  *      MMU Initialization Begins Here
1511  *
1512  *      The structure of the MMU tables on the 68k machines
1513  *      is thus:
1514  *      Root Table
1515  *              Logical addresses are translated through
1516  *      a hierarchical translation mechanism where the high-order
1517  *      seven bits of the logical address (LA) are used as an
1518  *      index into the "root table."  Each entry in the root
1519  *      table has a bit which specifies if it's a valid pointer to a
1520  *      pointer table.  Each entry defines a 32KMeg range of memory.
1521  *      If an entry is invalid then that logical range of 32M is
1522  *      invalid and references to that range of memory (when the MMU
1523  *      is enabled) will fault.  If the entry is valid, then it does
1524  *      one of two things.  On 040/060 class machines, it points to
1525  *      a pointer table which then describes more finely the memory
1526  *      within that 32M range.  On 020/030 class machines, a technique
1527  *      called "early terminating descriptors" are used.  This technique
1528  *      allows an entire 32Meg to be described by a single entry in the
1529  *      root table.  Thus, this entry in the root table, contains the
1530  *      physical address of the memory or I/O at the logical address
1531  *      which the entry represents and it also contains the necessary
1532  *      cache bits for this region.
1533  *
1534  *      Pointer Tables
1535  *              Per the Root Table, there will be one or more
1536  *      pointer tables.  Each pointer table defines a 32M range.
1537  *      Not all of the 32M range need be defined.  Again, the next
1538  *      seven bits of the logical address are used an index into
1539  *      the pointer table to point to page tables (if the pointer
1540  *      is valid).  There will undoubtedly be more than one
1541  *      pointer table for the kernel because each pointer table
1542  *      defines a range of only 32M.  Valid pointer table entries
1543  *      point to page tables, or are early terminating entries
1544  *      themselves.
1545  *
1546  *      Page Tables
1547  *              Per the Pointer Tables, each page table entry points
1548  *      to the physical page in memory that supports the logical
1549  *      address that translates to the particular index.
1550  *
1551  *      In short, the Logical Address gets translated as follows:
1552  *              bits 31..26 - index into the Root Table
1553  *              bits 25..18 - index into the Pointer Table
1554  *              bits 17..12 - index into the Page Table
1555  *              bits 11..0  - offset into a particular 4K page
1556  *
1557  *      The algorithms which follows do one thing: they abstract
1558  *      the MMU hardware.  For example, there are three kinds of
1559  *      cache settings that are relevant.  Either, memory is
1560  *      being mapped in which case it is either Kernel Code (or
1561  *      the RamDisk) or it is MMU data.  On the 030, the MMU data
1562  *      option also describes the kernel.  Or, I/O is being mapped
1563  *      in which case it has its own kind of cache bits.  There
1564  *      are constants which abstract these notions from the code that
1565  *      actually makes the call to map some range of memory.
1566  *
1567  *
1568  *
1569  */
1570
1571 #ifdef MMU_PRINT
1572 /*
1573  *      mmu_print
1574  *
1575  *      This algorithm will print out the current MMU mappings.
1576  *
1577  *      Input:
1578  *              %a5 points to the root table.  Everything else is calculated
1579  *                      from this.
1580  */
1581
1582 #define mmu_next_valid          0
1583 #define mmu_start_logical       4
1584 #define mmu_next_logical        8
1585 #define mmu_start_physical      12
1586 #define mmu_next_physical       16
1587
1588 #define MMU_PRINT_INVALID               -1
1589 #define MMU_PRINT_VALID                 1
1590 #define MMU_PRINT_UNINITED              0
1591
1592 #define putZc(z,n)              jbne 1f; putc z; jbra 2f; 1: putc n; 2:
1593
1594 func_start      mmu_print,%a0-%a6/%d0-%d7
1595
1596         movel   %pc@(L(kernel_pgdir_ptr)),%a5
1597         lea     %pc@(L(mmu_print_data)),%a0
1598         movel   #MMU_PRINT_UNINITED,%a0@(mmu_next_valid)
1599
1600         is_not_040_or_060(mmu_030_print)
1601
1602 mmu_040_print:
1603         puts    "\nMMU040\n"
1604         puts    "rp:"
1605         putn    %a5
1606         putc    '\n'
1607 #if 0
1608         /*
1609          * The following #if/#endif block is a tight algorithm for dumping the 040
1610          * MMU Map in gory detail.  It really isn't that practical unless the
1611          * MMU Map algorithm appears to go awry and you need to debug it at the
1612          * entry per entry level.
1613          */
1614         movel   #ROOT_TABLE_SIZE,%d5
1615 #if 0
1616         movel   %a5@+,%d7               | Burn an entry to skip the kernel mappings,
1617         subql   #1,%d5                  | they (might) work
1618 #endif
1619 1:      tstl    %d5
1620         jbeq    mmu_print_done
1621         subq    #1,%d5
1622         movel   %a5@+,%d7
1623         btst    #1,%d7
1624         jbeq    1b
1625
1626 2:      putn    %d7
1627         andil   #0xFFFFFE00,%d7
1628         movel   %d7,%a4
1629         movel   #PTR_TABLE_SIZE,%d4
1630         putc    ' '
1631 3:      tstl    %d4
1632         jbeq    11f
1633         subq    #1,%d4
1634         movel   %a4@+,%d7
1635         btst    #1,%d7
1636         jbeq    3b
1637
1638 4:      putn    %d7
1639         andil   #0xFFFFFF00,%d7
1640         movel   %d7,%a3
1641         movel   #PAGE_TABLE_SIZE,%d3
1642 5:      movel   #8,%d2
1643 6:      tstl    %d3
1644         jbeq    31f
1645         subq    #1,%d3
1646         movel   %a3@+,%d6
1647         btst    #0,%d6
1648         jbeq    6b
1649 7:      tstl    %d2
1650         jbeq    8f
1651         subq    #1,%d2
1652         putc    ' '
1653         jbra    91f
1654 8:      putc    '\n'
1655         movel   #8+1+8+1+1,%d2
1656 9:      putc    ' '
1657         dbra    %d2,9b
1658         movel   #7,%d2
1659 91:     putn    %d6
1660         jbra    6b
1661
1662 31:     putc    '\n'
1663         movel   #8+1,%d2
1664 32:     putc    ' '
1665         dbra    %d2,32b
1666         jbra    3b
1667
1668 11:     putc    '\n'
1669         jbra    1b
1670 #endif /* MMU 040 Dumping code that's gory and detailed */
1671
1672         lea     %pc@(kernel_pg_dir),%a5
1673         movel   %a5,%a0                 /* a0 has the address of the root table ptr */
1674         movel   #0x00000000,%a4         /* logical address */
1675         moveql  #0,%d0
1676 40:
1677         /* Increment the logical address and preserve in d5 */
1678         movel   %a4,%d5
1679         addil   #PAGESIZE<<13,%d5
1680         movel   %a0@+,%d6
1681         btst    #1,%d6
1682         jbne    41f
1683         jbsr    mmu_print_tuple_invalidate
1684         jbra    48f
1685 41:
1686         movel   #0,%d1
1687         andil   #0xfffffe00,%d6
1688         movel   %d6,%a1
1689 42:
1690         movel   %a4,%d5
1691         addil   #PAGESIZE<<6,%d5
1692         movel   %a1@+,%d6
1693         btst    #1,%d6
1694         jbne    43f
1695         jbsr    mmu_print_tuple_invalidate
1696         jbra    47f
1697 43:
1698         movel   #0,%d2
1699         andil   #0xffffff00,%d6
1700         movel   %d6,%a2
1701 44:
1702         movel   %a4,%d5
1703         addil   #PAGESIZE,%d5
1704         movel   %a2@+,%d6
1705         btst    #0,%d6
1706         jbne    45f
1707         jbsr    mmu_print_tuple_invalidate
1708         jbra    46f
1709 45:
1710         moveml  %d0-%d1,%sp@-
1711         movel   %a4,%d0
1712         movel   %d6,%d1
1713         andil   #0xfffff4e0,%d1
1714         lea     %pc@(mmu_040_print_flags),%a6
1715         jbsr    mmu_print_tuple
1716         moveml  %sp@+,%d0-%d1
1717 46:
1718         movel   %d5,%a4
1719         addq    #1,%d2
1720         cmpib   #64,%d2
1721         jbne    44b
1722 47:
1723         movel   %d5,%a4
1724         addq    #1,%d1
1725         cmpib   #128,%d1
1726         jbne    42b
1727 48:
1728         movel   %d5,%a4                 /* move to the next logical address */
1729         addq    #1,%d0
1730         cmpib   #128,%d0
1731         jbne    40b
1732
1733         .chip   68040
1734         movec   %dtt1,%d0
1735         movel   %d0,%d1
1736         andiw   #0x8000,%d1             /* is it valid ? */
1737         jbeq    1f                      /* No, bail out */
1738
1739         movel   %d0,%d1
1740         andil   #0xff000000,%d1         /* Get the address */
1741         putn    %d1
1742         puts    "=="
1743         putn    %d1
1744
1745         movel   %d0,%d6
1746         jbsr    mmu_040_print_flags_tt
1747 1:
1748         movec   %dtt0,%d0
1749         movel   %d0,%d1
1750         andiw   #0x8000,%d1             /* is it valid ? */
1751         jbeq    1f                      /* No, bail out */
1752
1753         movel   %d0,%d1
1754         andil   #0xff000000,%d1         /* Get the address */
1755         putn    %d1
1756         puts    "=="
1757         putn    %d1
1758
1759         movel   %d0,%d6
1760         jbsr    mmu_040_print_flags_tt
1761 1:
1762         .chip   68k
1763
1764         jbra    mmu_print_done
1765
1766 mmu_040_print_flags:
1767         btstl   #10,%d6
1768         putZc(' ','G')  /* global bit */
1769         btstl   #7,%d6
1770         putZc(' ','S')  /* supervisor bit */
1771 mmu_040_print_flags_tt:
1772         btstl   #6,%d6
1773         jbne    3f
1774         putc    'C'
1775         btstl   #5,%d6
1776         putZc('w','c')  /* write through or copy-back */
1777         jbra    4f
1778 3:
1779         putc    'N'
1780         btstl   #5,%d6
1781         putZc('s',' ')  /* serialized non-cacheable, or non-cacheable */
1782 4:
1783         rts
1784
1785 mmu_030_print_flags:
1786         btstl   #6,%d6
1787         putZc('C','I')  /* write through or copy-back */
1788         rts
1789
1790 mmu_030_print:
1791         puts    "\nMMU030\n"
1792         puts    "\nrp:"
1793         putn    %a5
1794         putc    '\n'
1795         movel   %a5,%d0
1796         andil   #0xfffffff0,%d0
1797         movel   %d0,%a0
1798         movel   #0x00000000,%a4         /* logical address */
1799         movel   #0,%d0
1800 30:
1801         movel   %a4,%d5
1802         addil   #PAGESIZE<<13,%d5
1803         movel   %a0@+,%d6
1804         btst    #1,%d6                  /* is it a ptr? */
1805         jbne    31f                     /* yes */
1806         btst    #0,%d6                  /* is it early terminating? */
1807         jbeq    1f                      /* no */
1808         jbsr    mmu_030_print_helper
1809         jbra    38f
1810 1:
1811         jbsr    mmu_print_tuple_invalidate
1812         jbra    38f
1813 31:
1814         movel   #0,%d1
1815         andil   #0xfffffff0,%d6
1816         movel   %d6,%a1
1817 32:
1818         movel   %a4,%d5
1819         addil   #PAGESIZE<<6,%d5
1820         movel   %a1@+,%d6
1821         btst    #1,%d6
1822         jbne    33f
1823         btst    #0,%d6
1824         jbeq    1f                      /* no */
1825         jbsr    mmu_030_print_helper
1826         jbra    37f
1827 1:
1828         jbsr    mmu_print_tuple_invalidate
1829         jbra    37f
1830 33:
1831         movel   #0,%d2
1832         andil   #0xfffffff0,%d6
1833         movel   %d6,%a2
1834 34:
1835         movel   %a4,%d5
1836         addil   #PAGESIZE,%d5
1837         movel   %a2@+,%d6
1838         btst    #0,%d6
1839         jbne    35f
1840         jbsr    mmu_print_tuple_invalidate
1841         jbra    36f
1842 35:
1843         jbsr    mmu_030_print_helper
1844 36:
1845         movel   %d5,%a4
1846         addq    #1,%d2
1847         cmpib   #64,%d2
1848         jbne    34b
1849 37:
1850         movel   %d5,%a4
1851         addq    #1,%d1
1852         cmpib   #128,%d1
1853         jbne    32b
1854 38:
1855         movel   %d5,%a4                 /* move to the next logical address */
1856         addq    #1,%d0
1857         cmpib   #128,%d0
1858         jbne    30b
1859
1860 mmu_print_done:
1861         puts    "\n\n"
1862
1863 func_return     mmu_print
1864
1865
1866 mmu_030_print_helper:
1867         moveml  %d0-%d1,%sp@-
1868         movel   %a4,%d0
1869         movel   %d6,%d1
1870         lea     %pc@(mmu_030_print_flags),%a6
1871         jbsr    mmu_print_tuple
1872         moveml  %sp@+,%d0-%d1
1873         rts
1874
1875 mmu_print_tuple_invalidate:
1876         moveml  %a0/%d7,%sp@-
1877
1878         lea     %pc@(L(mmu_print_data)),%a0
1879         tstl    %a0@(mmu_next_valid)
1880         jbmi    mmu_print_tuple_invalidate_exit
1881
1882         movel   #MMU_PRINT_INVALID,%a0@(mmu_next_valid)
1883
1884         putn    %a4
1885
1886         puts    "##\n"
1887
1888 mmu_print_tuple_invalidate_exit:
1889         moveml  %sp@+,%a0/%d7
1890         rts
1891
1892
1893 mmu_print_tuple:
1894         moveml  %d0-%d7/%a0,%sp@-
1895
1896         lea     %pc@(L(mmu_print_data)),%a0
1897
1898         tstl    %a0@(mmu_next_valid)
1899         jble    mmu_print_tuple_print
1900
1901         cmpl    %a0@(mmu_next_physical),%d1
1902         jbeq    mmu_print_tuple_increment
1903
1904 mmu_print_tuple_print:
1905         putn    %d0
1906         puts    "->"
1907         putn    %d1
1908
1909         movel   %d1,%d6
1910         jbsr    %a6@
1911
1912 mmu_print_tuple_record:
1913         movel   #MMU_PRINT_VALID,%a0@(mmu_next_valid)
1914
1915         movel   %d1,%a0@(mmu_next_physical)
1916
1917 mmu_print_tuple_increment:
1918         movel   %d5,%d7
1919         subl    %a4,%d7
1920         addl    %d7,%a0@(mmu_next_physical)
1921
1922 mmu_print_tuple_exit:
1923         moveml  %sp@+,%d0-%d7/%a0
1924         rts
1925
1926 mmu_print_machine_cpu_types:
1927         puts    "machine: "
1928
1929         is_not_amiga(1f)
1930         puts    "amiga"
1931         jbra    9f
1932 1:
1933         is_not_atari(2f)
1934         puts    "atari"
1935         jbra    9f
1936 2:
1937         is_not_mac(3f)
1938         puts    "macintosh"
1939         jbra    9f
1940 3:      puts    "unknown"
1941 9:      putc    '\n'
1942
1943         puts    "cputype: 0"
1944         is_not_060(1f)
1945         putc    '6'
1946         jbra    9f
1947 1:
1948         is_not_040_or_060(2f)
1949         putc    '4'
1950         jbra    9f
1951 2:      putc    '3'
1952 9:      putc    '0'
1953         putc    '\n'
1954
1955         rts
1956 #endif /* MMU_PRINT */
1957
1958 /*
1959  * mmu_map_tt
1960  *
1961  * This is a specific function which works on all 680x0 machines.
1962  * On 030, 040 & 060 it will attempt to use Transparent Translation
1963  * registers (tt1).
1964  * On 020 it will call the standard mmu_map which will use early
1965  * terminating descriptors.
1966  */
1967 func_start      mmu_map_tt,%d0/%d1/%a0,4
1968
1969         dputs   "mmu_map_tt:"
1970         dputn   ARG1
1971         dputn   ARG2
1972         dputn   ARG3
1973         dputn   ARG4
1974         dputc   '\n'
1975
1976         is_020(L(do_map))
1977
1978         /* Extract the highest bit set
1979          */
1980         bfffo   ARG3{#0,#32},%d1
1981         cmpw    #8,%d1
1982         jcc     L(do_map)
1983
1984         /* And get the mask
1985          */
1986         moveq   #-1,%d0
1987         lsrl    %d1,%d0
1988         lsrl    #1,%d0
1989
1990         /* Mask the address
1991          */
1992         movel   %d0,%d1
1993         notl    %d1
1994         andl    ARG2,%d1
1995
1996         /* Generate the upper 16bit of the tt register
1997          */
1998         lsrl    #8,%d0
1999         orl     %d0,%d1
2000         clrw    %d1
2001
2002         is_040_or_060(L(mmu_map_tt_040))
2003
2004         /* set 030 specific bits (read/write access for supervisor mode
2005          * (highest function code set, lower two bits masked))
2006          */
2007         orw     #TTR_ENABLE+TTR_RWM+TTR_FCB2+TTR_FCM1+TTR_FCM0,%d1
2008         movel   ARG4,%d0
2009         btst    #6,%d0
2010         jeq     1f
2011         orw     #TTR_CI,%d1
2012
2013 1:      lea     STACK,%a0
2014         dputn   %d1
2015         movel   %d1,%a0@
2016         .chip   68030
2017         tstl    ARG1
2018         jne     1f
2019         pmove   %a0@,%tt0
2020         jra     2f
2021 1:      pmove   %a0@,%tt1
2022 2:      .chip   68k
2023         jra     L(mmu_map_tt_done)
2024
2025         /* set 040 specific bits
2026          */
2027 L(mmu_map_tt_040):
2028         orw     #TTR_ENABLE+TTR_KERNELMODE,%d1
2029         orl     ARG4,%d1
2030         dputn   %d1
2031
2032         .chip   68040
2033         tstl    ARG1
2034         jne     1f
2035         movec   %d1,%itt0
2036         movec   %d1,%dtt0
2037         jra     2f
2038 1:      movec   %d1,%itt1
2039         movec   %d1,%dtt1
2040 2:      .chip   68k
2041
2042         jra     L(mmu_map_tt_done)
2043
2044 L(do_map):
2045         mmu_map_eq      ARG2,ARG3,ARG4
2046
2047 L(mmu_map_tt_done):
2048
2049 func_return     mmu_map_tt
2050
2051 /*
2052  *      mmu_map
2053  *
2054  *      This routine will map a range of memory using a pointer
2055  *      table and allocating the pages on the fly from the kernel.
2056  *      The pointer table does not have to be already linked into
2057  *      the root table, this routine will do that if necessary.
2058  *
2059  *      NOTE
2060  *      This routine will assert failure and use the serial_putc
2061  *      routines in the case of a run-time error.  For example,
2062  *      if the address is already mapped.
2063  *
2064  *      NOTE-2
2065  *      This routine will use early terminating descriptors
2066  *      where possible for the 68020+68851 and 68030 type
2067  *      processors.
2068  */
2069 func_start      mmu_map,%d0-%d4/%a0-%a4
2070
2071         dputs   "\nmmu_map:"
2072         dputn   ARG1
2073         dputn   ARG2
2074         dputn   ARG3
2075         dputn   ARG4
2076         dputc   '\n'
2077
2078         /* Get logical address and round it down to 256KB
2079          */
2080         movel   ARG1,%d0
2081         andl    #-(PAGESIZE*PAGE_TABLE_SIZE),%d0
2082         movel   %d0,%a3
2083
2084         /* Get the end address
2085          */
2086         movel   ARG1,%a4
2087         addl    ARG3,%a4
2088         subql   #1,%a4
2089
2090         /* Get physical address and round it down to 256KB
2091          */
2092         movel   ARG2,%d0
2093         andl    #-(PAGESIZE*PAGE_TABLE_SIZE),%d0
2094         movel   %d0,%a2
2095
2096         /* Add page attributes to the physical address
2097          */
2098         movel   ARG4,%d0
2099         orw     #_PAGE_PRESENT+_PAGE_ACCESSED+_PAGE_DIRTY,%d0
2100         addw    %d0,%a2
2101
2102         dputn   %a2
2103         dputn   %a3
2104         dputn   %a4
2105
2106         is_not_040_or_060(L(mmu_map_030))
2107
2108         addw    #_PAGE_GLOBAL040,%a2
2109 /*
2110  *      MMU 040 & 060 Support
2111  *
2112  *      The MMU usage for the 040 and 060 is different enough from
2113  *      the 030 and 68851 that there is separate code.  This comment
2114  *      block describes the data structures and algorithms built by
2115  *      this code.
2116  *
2117  *      The 040 does not support early terminating descriptors, as
2118  *      the 030 does.  Therefore, a third level of table is needed
2119  *      for the 040, and that would be the page table.  In Linux,
2120  *      page tables are allocated directly from the memory above the
2121  *      kernel.
2122  *
2123  */
2124
2125 L(mmu_map_040):
2126         /* Calculate the offset into the root table
2127          */
2128         movel   %a3,%d0
2129         moveq   #ROOT_INDEX_SHIFT,%d1
2130         lsrl    %d1,%d0
2131         mmu_get_root_table_entry        %d0
2132
2133         /* Calculate the offset into the pointer table
2134          */
2135         movel   %a3,%d0
2136         moveq   #PTR_INDEX_SHIFT,%d1
2137         lsrl    %d1,%d0
2138         andl    #PTR_TABLE_SIZE-1,%d0
2139         mmu_get_ptr_table_entry         %a0,%d0
2140
2141         /* Calculate the offset into the page table
2142          */
2143         movel   %a3,%d0
2144         moveq   #PAGE_INDEX_SHIFT,%d1
2145         lsrl    %d1,%d0
2146         andl    #PAGE_TABLE_SIZE-1,%d0
2147         mmu_get_page_table_entry        %a0,%d0
2148
2149         /* The page table entry must not no be busy
2150          */
2151         tstl    %a0@
2152         jne     L(mmu_map_error)
2153
2154         /* Do the mapping and advance the pointers
2155          */
2156         movel   %a2,%a0@
2157 2:
2158         addw    #PAGESIZE,%a2
2159         addw    #PAGESIZE,%a3
2160
2161         /* Ready with mapping?
2162          */
2163         lea     %a3@(-1),%a0
2164         cmpl    %a0,%a4
2165         jhi     L(mmu_map_040)
2166         jra     L(mmu_map_done)
2167
2168 L(mmu_map_030):
2169         /* Calculate the offset into the root table
2170          */
2171         movel   %a3,%d0
2172         moveq   #ROOT_INDEX_SHIFT,%d1
2173         lsrl    %d1,%d0
2174         mmu_get_root_table_entry        %d0
2175
2176         /* Check if logical address 32MB aligned,
2177          * so we can try to map it once
2178          */
2179         movel   %a3,%d0
2180         andl    #(PTR_TABLE_SIZE*PAGE_TABLE_SIZE*PAGESIZE-1)&(-ROOT_TABLE_SIZE),%d0
2181         jne     1f
2182
2183         /* Is there enough to map for 32MB at once
2184          */
2185         lea     %a3@(PTR_TABLE_SIZE*PAGE_TABLE_SIZE*PAGESIZE-1),%a1
2186         cmpl    %a1,%a4
2187         jcs     1f
2188
2189         addql   #1,%a1
2190
2191         /* The root table entry must not no be busy
2192          */
2193         tstl    %a0@
2194         jne     L(mmu_map_error)
2195
2196         /* Do the mapping and advance the pointers
2197          */
2198         dputs   "early term1"
2199         dputn   %a2
2200         dputn   %a3
2201         dputn   %a1
2202         dputc   '\n'
2203         movel   %a2,%a0@
2204
2205         movel   %a1,%a3
2206         lea     %a2@(PTR_TABLE_SIZE*PAGE_TABLE_SIZE*PAGESIZE),%a2
2207         jra     L(mmu_mapnext_030)
2208 1:
2209         /* Calculate the offset into the pointer table
2210          */
2211         movel   %a3,%d0
2212         moveq   #PTR_INDEX_SHIFT,%d1
2213         lsrl    %d1,%d0
2214         andl    #PTR_TABLE_SIZE-1,%d0
2215         mmu_get_ptr_table_entry         %a0,%d0
2216
2217         /* The pointer table entry must not no be busy
2218          */
2219         tstl    %a0@
2220         jne     L(mmu_map_error)
2221
2222         /* Do the mapping and advance the pointers
2223          */
2224         dputs   "early term2"
2225         dputn   %a2
2226         dputn   %a3
2227         dputc   '\n'
2228         movel   %a2,%a0@
2229
2230         addl    #PAGE_TABLE_SIZE*PAGESIZE,%a2
2231         addl    #PAGE_TABLE_SIZE*PAGESIZE,%a3
2232
2233 L(mmu_mapnext_030):
2234         /* Ready with mapping?
2235          */
2236         lea     %a3@(-1),%a0
2237         cmpl    %a0,%a4
2238         jhi     L(mmu_map_030)
2239         jra     L(mmu_map_done)
2240
2241 L(mmu_map_error):
2242
2243         dputs   "mmu_map error:"
2244         dputn   %a2
2245         dputn   %a3
2246         dputc   '\n'
2247
2248 L(mmu_map_done):
2249
2250 func_return     mmu_map
2251
2252 /*
2253  *      mmu_fixup
2254  *
2255  *      On the 040 class machines, all pages that are used for the
2256  *      mmu have to be fixed up.
2257  */
2258
2259 func_start      mmu_fixup_page_mmu_cache,%d0/%a0
2260
2261         dputs   "mmu_fixup_page_mmu_cache"
2262         dputn   ARG1
2263
2264         /* Calculate the offset into the root table
2265          */
2266         movel   ARG1,%d0
2267         moveq   #ROOT_INDEX_SHIFT,%d1
2268         lsrl    %d1,%d0
2269         mmu_get_root_table_entry        %d0
2270
2271         /* Calculate the offset into the pointer table
2272          */
2273         movel   ARG1,%d0
2274         moveq   #PTR_INDEX_SHIFT,%d1
2275         lsrl    %d1,%d0
2276         andl    #PTR_TABLE_SIZE-1,%d0
2277         mmu_get_ptr_table_entry         %a0,%d0
2278
2279         /* Calculate the offset into the page table
2280          */
2281         movel   ARG1,%d0
2282         moveq   #PAGE_INDEX_SHIFT,%d1
2283         lsrl    %d1,%d0
2284         andl    #PAGE_TABLE_SIZE-1,%d0
2285         mmu_get_page_table_entry        %a0,%d0
2286
2287         movel   %a0@,%d0
2288         andil   #_CACHEMASK040,%d0
2289         orl     %pc@(m68k_pgtable_cachemode),%d0
2290         movel   %d0,%a0@
2291
2292         dputc   '\n'
2293
2294 func_return     mmu_fixup_page_mmu_cache
2295
2296 /*
2297  *      mmu_temp_map
2298  *
2299  *      create a temporary mapping to enable the mmu,
2300  *      this we don't need any transparation translation tricks.
2301  */
2302
2303 func_start      mmu_temp_map,%d0/%d1/%a0/%a1
2304
2305         dputs   "mmu_temp_map"
2306         dputn   ARG1
2307         dputn   ARG2
2308         dputc   '\n'
2309
2310         lea     %pc@(L(temp_mmap_mem)),%a1
2311
2312         /* Calculate the offset in the root table
2313          */
2314         movel   ARG2,%d0
2315         moveq   #ROOT_INDEX_SHIFT,%d1
2316         lsrl    %d1,%d0
2317         mmu_get_root_table_entry        %d0
2318
2319         /* Check if the table is temporary allocated, so we have to reuse it
2320          */
2321         movel   %a0@,%d0
2322         cmpl    %pc@(L(memory_start)),%d0
2323         jcc     1f
2324
2325         /* Temporary allocate a ptr table and insert it into the root table
2326          */
2327         movel   %a1@,%d0
2328         addl    #PTR_TABLE_SIZE*4,%a1@
2329         orw     #_PAGE_TABLE+_PAGE_ACCESSED,%d0
2330         movel   %d0,%a0@
2331         dputs   " (new)"
2332 1:
2333         dputn   %d0
2334         /* Mask the root table entry for the ptr table
2335          */
2336         andw    #-ROOT_TABLE_SIZE,%d0
2337         movel   %d0,%a0
2338
2339         /* Calculate the offset into the pointer table
2340          */
2341         movel   ARG2,%d0
2342         moveq   #PTR_INDEX_SHIFT,%d1
2343         lsrl    %d1,%d0
2344         andl    #PTR_TABLE_SIZE-1,%d0
2345         lea     %a0@(%d0*4),%a0
2346         dputn   %a0
2347
2348         /* Check if a temporary page table is already allocated
2349          */
2350         movel   %a0@,%d0
2351         jne     1f
2352
2353         /* Temporary allocate a page table and insert it into the ptr table
2354          */
2355         movel   %a1@,%d0
2356         /* The 512 should be PAGE_TABLE_SIZE*4, but that violates the
2357            alignment restriction for pointer tables on the '0[46]0.  */
2358         addl    #512,%a1@
2359         orw     #_PAGE_TABLE+_PAGE_ACCESSED,%d0
2360         movel   %d0,%a0@
2361         dputs   " (new)"
2362 1:
2363         dputn   %d0
2364         /* Mask the ptr table entry for the page table
2365          */
2366         andw    #-PTR_TABLE_SIZE,%d0
2367         movel   %d0,%a0
2368
2369         /* Calculate the offset into the page table
2370          */
2371         movel   ARG2,%d0
2372         moveq   #PAGE_INDEX_SHIFT,%d1
2373         lsrl    %d1,%d0
2374         andl    #PAGE_TABLE_SIZE-1,%d0
2375         lea     %a0@(%d0*4),%a0
2376         dputn   %a0
2377
2378         /* Insert the address into the page table
2379          */
2380         movel   ARG1,%d0
2381         andw    #-PAGESIZE,%d0
2382         orw     #_PAGE_PRESENT+_PAGE_ACCESSED+_PAGE_DIRTY,%d0
2383         movel   %d0,%a0@
2384         dputn   %d0
2385
2386         dputc   '\n'
2387
2388 func_return     mmu_temp_map
2389
2390 func_start      mmu_engage,%d0-%d2/%a0-%a3
2391
2392         moveq   #ROOT_TABLE_SIZE-1,%d0
2393         /* Temporarily use a different root table.  */
2394         lea     %pc@(L(kernel_pgdir_ptr)),%a0
2395         movel   %a0@,%a2
2396         movel   %pc@(L(memory_start)),%a1
2397         movel   %a1,%a0@
2398         movel   %a2,%a0
2399 1:
2400         movel   %a0@+,%a1@+
2401         dbra    %d0,1b
2402
2403         lea     %pc@(L(temp_mmap_mem)),%a0
2404         movel   %a1,%a0@
2405
2406         movew   #PAGESIZE-1,%d0
2407 1:
2408         clrl    %a1@+
2409         dbra    %d0,1b
2410
2411         lea     %pc@(1b),%a0
2412         movel   #1b,%a1
2413         /* Skip temp mappings if phys == virt */
2414         cmpl    %a0,%a1
2415         jeq     1f
2416
2417         mmu_temp_map    %a0,%a0
2418         mmu_temp_map    %a0,%a1
2419
2420         addw    #PAGESIZE,%a0
2421         addw    #PAGESIZE,%a1
2422         mmu_temp_map    %a0,%a0
2423         mmu_temp_map    %a0,%a1
2424 1:
2425         movel   %pc@(L(memory_start)),%a3
2426         movel   %pc@(L(phys_kernel_start)),%d2
2427
2428         is_not_040_or_060(L(mmu_engage_030))
2429
2430 L(mmu_engage_040):
2431         .chip   68040
2432         nop
2433         cinva   %bc
2434         nop
2435         pflusha
2436         nop
2437         movec   %a3,%srp
2438         movel   #TC_ENABLE+TC_PAGE4K,%d0
2439         movec   %d0,%tc         /* enable the MMU */
2440         jmp     1f:l
2441 1:      nop
2442         movec   %a2,%srp
2443         nop
2444         cinva   %bc
2445         nop
2446         pflusha
2447         .chip   68k
2448         jra     L(mmu_engage_cleanup)
2449
2450 L(mmu_engage_030_temp):
2451         .space  12
2452 L(mmu_engage_030):
2453         .chip   68030
2454         lea     %pc@(L(mmu_engage_030_temp)),%a0
2455         movel   #0x80000002,%a0@
2456         movel   %a3,%a0@(4)
2457         movel   #0x0808,%d0
2458         movec   %d0,%cacr
2459         pmove   %a0@,%srp
2460         pflusha
2461         /*
2462          * enable,super root enable,4096 byte pages,7 bit root index,
2463          * 7 bit pointer index, 6 bit page table index.
2464          */
2465         movel   #0x82c07760,%a0@(8)
2466         pmove   %a0@(8),%tc     /* enable the MMU */
2467         jmp     1f:l
2468 1:      movel   %a2,%a0@(4)
2469         movel   #0x0808,%d0
2470         movec   %d0,%cacr
2471         pmove   %a0@,%srp
2472         pflusha
2473         .chip   68k
2474
2475 L(mmu_engage_cleanup):
2476         subl    #PAGE_OFFSET,%d2
2477         subl    %d2,%a2
2478         movel   %a2,L(kernel_pgdir_ptr)
2479         subl    %d2,%fp
2480         subl    %d2,%sp
2481         subl    %d2,ARG0
2482
2483 func_return     mmu_engage
2484
2485 func_start      mmu_get_root_table_entry,%d0/%a1
2486
2487 #if 0
2488         dputs   "mmu_get_root_table_entry:"
2489         dputn   ARG1
2490         dputs   " ="
2491 #endif
2492
2493         movel   %pc@(L(kernel_pgdir_ptr)),%a0
2494         tstl    %a0
2495         jne     2f
2496
2497         dputs   "\nmmu_init:"
2498
2499         /* Find the start of free memory, get_bi_record does this for us,
2500          * as the bootinfo structure is located directly behind the kernel
2501          * and and we simply search for the last entry.
2502          */
2503         get_bi_record   BI_LAST
2504         addw    #PAGESIZE-1,%a0
2505         movel   %a0,%d0
2506         andw    #-PAGESIZE,%d0
2507
2508         dputn   %d0
2509
2510         lea     %pc@(L(memory_start)),%a0
2511         movel   %d0,%a0@
2512         lea     %pc@(L(kernel_end)),%a0
2513         movel   %d0,%a0@
2514
2515         /* we have to return the first page at _stext since the init code
2516          * in mm/init.c simply expects kernel_pg_dir there, the rest of
2517          * page is used for further ptr tables in get_ptr_table.
2518          */
2519         lea     %pc@(_stext),%a0
2520         lea     %pc@(L(mmu_cached_pointer_tables)),%a1
2521         movel   %a0,%a1@
2522         addl    #ROOT_TABLE_SIZE*4,%a1@
2523
2524         lea     %pc@(L(mmu_num_pointer_tables)),%a1
2525         addql   #1,%a1@
2526
2527         /* clear the page
2528          */
2529         movel   %a0,%a1
2530         movew   #PAGESIZE/4-1,%d0
2531 1:
2532         clrl    %a1@+
2533         dbra    %d0,1b
2534
2535         lea     %pc@(L(kernel_pgdir_ptr)),%a1
2536         movel   %a0,%a1@
2537
2538         dputn   %a0
2539         dputc   '\n'
2540 2:
2541         movel   ARG1,%d0
2542         lea     %a0@(%d0*4),%a0
2543
2544 #if 0
2545         dputn   %a0
2546         dputc   '\n'
2547 #endif
2548
2549 func_return     mmu_get_root_table_entry
2550
2551
2552
2553 func_start      mmu_get_ptr_table_entry,%d0/%a1
2554
2555 #if 0
2556         dputs   "mmu_get_ptr_table_entry:"
2557         dputn   ARG1
2558         dputn   ARG2
2559         dputs   " ="
2560 #endif
2561
2562         movel   ARG1,%a0
2563         movel   %a0@,%d0
2564         jne     2f
2565
2566         /* Keep track of the number of pointer tables we use
2567          */
2568         dputs   "\nmmu_get_new_ptr_table:"
2569         lea     %pc@(L(mmu_num_pointer_tables)),%a0
2570         movel   %a0@,%d0
2571         addql   #1,%a0@
2572
2573         /* See if there is a free pointer table in our cache of pointer tables
2574          */
2575         lea     %pc@(L(mmu_cached_pointer_tables)),%a1
2576         andw    #7,%d0
2577         jne     1f
2578
2579         /* Get a new pointer table page from above the kernel memory
2580          */
2581         get_new_page
2582         movel   %a0,%a1@
2583 1:
2584         /* There is an unused pointer table in our cache... use it
2585          */
2586         movel   %a1@,%d0
2587         addl    #PTR_TABLE_SIZE*4,%a1@
2588
2589         dputn   %d0
2590         dputc   '\n'
2591
2592         /* Insert the new pointer table into the root table
2593          */
2594         movel   ARG1,%a0
2595         orw     #_PAGE_TABLE+_PAGE_ACCESSED,%d0
2596         movel   %d0,%a0@
2597 2:
2598         /* Extract the pointer table entry
2599          */
2600         andw    #-PTR_TABLE_SIZE,%d0
2601         movel   %d0,%a0
2602         movel   ARG2,%d0
2603         lea     %a0@(%d0*4),%a0
2604
2605 #if 0
2606         dputn   %a0
2607         dputc   '\n'
2608 #endif
2609
2610 func_return     mmu_get_ptr_table_entry
2611
2612
2613 func_start      mmu_get_page_table_entry,%d0/%a1
2614
2615 #if 0
2616         dputs   "mmu_get_page_table_entry:"
2617         dputn   ARG1
2618         dputn   ARG2
2619         dputs   " ="
2620 #endif
2621
2622         movel   ARG1,%a0
2623         movel   %a0@,%d0
2624         jne     2f
2625
2626         /* If the page table entry doesn't exist, we allocate a complete new
2627          * page and use it as one continues big page table which can cover
2628          * 4MB of memory, nearly almost all mappings have that alignment.
2629          */
2630         get_new_page
2631         addw    #_PAGE_TABLE+_PAGE_ACCESSED,%a0
2632
2633         /* align pointer table entry for a page of page tables
2634          */
2635         movel   ARG1,%d0
2636         andw    #-(PAGESIZE/PAGE_TABLE_SIZE),%d0
2637         movel   %d0,%a1
2638
2639         /* Insert the page tables into the pointer entries
2640          */
2641         moveq   #PAGESIZE/PAGE_TABLE_SIZE/4-1,%d0
2642 1:
2643         movel   %a0,%a1@+
2644         lea     %a0@(PAGE_TABLE_SIZE*4),%a0
2645         dbra    %d0,1b
2646
2647         /* Now we can get the initialized pointer table entry
2648          */
2649         movel   ARG1,%a0
2650         movel   %a0@,%d0
2651 2:
2652         /* Extract the page table entry
2653          */
2654         andw    #-PAGE_TABLE_SIZE,%d0
2655         movel   %d0,%a0
2656         movel   ARG2,%d0
2657         lea     %a0@(%d0*4),%a0
2658
2659 #if 0
2660         dputn   %a0
2661         dputc   '\n'
2662 #endif
2663
2664 func_return     mmu_get_page_table_entry
2665
2666 /*
2667  *      get_new_page
2668  *
2669  *      Return a new page from the memory start and clear it.
2670  */
2671 func_start      get_new_page,%d0/%a1
2672
2673         dputs   "\nget_new_page:"
2674
2675         /* allocate the page and adjust memory_start
2676          */
2677         lea     %pc@(L(memory_start)),%a0
2678         movel   %a0@,%a1
2679         addl    #PAGESIZE,%a0@
2680
2681         /* clear the new page
2682          */
2683         movel   %a1,%a0
2684         movew   #PAGESIZE/4-1,%d0
2685 1:
2686         clrl    %a1@+
2687         dbra    %d0,1b
2688
2689         dputn   %a0
2690         dputc   '\n'
2691
2692 func_return     get_new_page
2693
2694
2695
2696 /*
2697  * Debug output support
2698  * Atarians have a choice between the parallel port, the serial port
2699  * from the MFP or a serial port of the SCC
2700  */
2701
2702 #ifdef CONFIG_MAC
2703
2704 L(scc_initable_mac):
2705         .byte   9,12            /* Reset */
2706         .byte   4,0x44          /* x16, 1 stopbit, no parity */
2707         .byte   3,0xc0          /* receiver: 8 bpc */
2708         .byte   5,0xe2          /* transmitter: 8 bpc, assert dtr/rts */
2709         .byte   9,0             /* no interrupts */
2710         .byte   10,0            /* NRZ */
2711         .byte   11,0x50         /* use baud rate generator */
2712         .byte   12,10,13,0      /* 9600 baud */
2713         .byte   14,1            /* Baud rate generator enable */
2714         .byte   3,0xc1          /* enable receiver */
2715         .byte   5,0xea          /* enable transmitter */
2716         .byte   -1
2717         .even
2718 #endif
2719
2720 #ifdef CONFIG_ATARI
2721 /* #define USE_PRINTER */
2722 /* #define USE_SCC_B */
2723 /* #define USE_SCC_A */
2724 #define USE_MFP
2725
2726 #if defined(USE_SCC_A) || defined(USE_SCC_B)
2727 #define USE_SCC
2728 /* Initialisation table for SCC */
2729 L(scc_initable):
2730         .byte   9,12            /* Reset */
2731         .byte   4,0x44          /* x16, 1 stopbit, no parity */
2732         .byte   3,0xc0          /* receiver: 8 bpc */
2733         .byte   5,0xe2          /* transmitter: 8 bpc, assert dtr/rts */
2734         .byte   9,0             /* no interrupts */
2735         .byte   10,0            /* NRZ */
2736         .byte   11,0x50         /* use baud rate generator */
2737         .byte   12,24,13,0      /* 9600 baud */
2738         .byte   14,2,14,3       /* use master clock for BRG, enable */
2739         .byte   3,0xc1          /* enable receiver */
2740         .byte   5,0xea          /* enable transmitter */
2741         .byte   -1
2742         .even
2743 #endif
2744
2745 #ifdef USE_PRINTER
2746
2747 LPSG_SELECT     = 0xff8800
2748 LPSG_READ       = 0xff8800
2749 LPSG_WRITE      = 0xff8802
2750 LPSG_IO_A       = 14
2751 LPSG_IO_B       = 15
2752 LPSG_CONTROL    = 7
2753 LSTMFP_GPIP     = 0xfffa01
2754 LSTMFP_DDR      = 0xfffa05
2755 LSTMFP_IERB     = 0xfffa09
2756
2757 #elif defined(USE_SCC_B)
2758
2759 LSCC_CTRL       = 0xff8c85
2760 LSCC_DATA       = 0xff8c87
2761
2762 #elif defined(USE_SCC_A)
2763
2764 LSCC_CTRL       = 0xff8c81
2765 LSCC_DATA       = 0xff8c83
2766
2767 /* Initialisation table for SCC */
2768 L(scc_initable):
2769         .byte   9,12            /* Reset */
2770         .byte   4,0x44          /* x16, 1 stopbit, no parity */
2771         .byte   3,0xc0          /* receiver: 8 bpc */
2772         .byte   5,0xe2          /* transmitter: 8 bpc, assert dtr/rts */
2773         .byte   9,0             /* no interrupts */
2774         .byte   10,0            /* NRZ */
2775         .byte   11,0x50         /* use baud rate generator */
2776         .byte   12,24,13,0      /* 9600 baud */
2777         .byte   14,2,14,3       /* use master clock for BRG, enable */
2778         .byte   3,0xc1          /* enable receiver */
2779         .byte   5,0xea          /* enable transmitter */
2780         .byte   -1
2781         .even
2782
2783 #elif defined(USE_MFP)
2784
2785 LMFP_UCR     = 0xfffa29
2786 LMFP_TDCDR   = 0xfffa1d
2787 LMFP_TDDR    = 0xfffa25
2788 LMFP_TSR     = 0xfffa2d
2789 LMFP_UDR     = 0xfffa2f
2790
2791 #endif
2792 #endif  /* CONFIG_ATARI */
2793
2794 /*
2795  * Serial port output support.
2796  */
2797
2798 /*
2799  * Initialize serial port hardware for 9600/8/1
2800  */
2801 func_start      serial_init,%d0/%d1/%a0/%a1
2802         /*
2803          *      Some of the register usage that follows
2804          *      CONFIG_AMIGA
2805          *              a0 = pointer to boot info record
2806          *              d0 = boot info offset
2807          *      CONFIG_ATARI
2808          *              a0 = address of SCC
2809          *              a1 = Liobase address/address of scc_initable
2810          *              d0 = init data for serial port
2811          *      CONFIG_MAC
2812          *              a0 = address of SCC
2813          *              a1 = address of scc_initable_mac
2814          *              d0 = init data for serial port
2815          */
2816
2817 #ifdef CONFIG_AMIGA
2818 #define SERIAL_DTR      7
2819 #define SERIAL_CNTRL    CIABBASE+C_PRA
2820
2821         is_not_amiga(1f)
2822         lea     %pc@(L(custom)),%a0
2823         movel   #-ZTWOBASE,%a0@
2824         bclr    #SERIAL_DTR,SERIAL_CNTRL-ZTWOBASE
2825         get_bi_record   BI_AMIGA_SERPER
2826         movew   %a0@,CUSTOMBASE+C_SERPER-ZTWOBASE
2827 |       movew   #61,CUSTOMBASE+C_SERPER-ZTWOBASE
2828 1:
2829 #endif
2830 #ifdef CONFIG_ATARI
2831         is_not_atari(4f)
2832         movel   %pc@(L(iobase)),%a1
2833 #if defined(USE_PRINTER)
2834         bclr    #0,%a1@(LSTMFP_IERB)
2835         bclr    #0,%a1@(LSTMFP_DDR)
2836         moveb   #LPSG_CONTROL,%a1@(LPSG_SELECT)
2837         moveb   #0xff,%a1@(LPSG_WRITE)
2838         moveb   #LPSG_IO_B,%a1@(LPSG_SELECT)
2839         clrb    %a1@(LPSG_WRITE)
2840         moveb   #LPSG_IO_A,%a1@(LPSG_SELECT)
2841         moveb   %a1@(LPSG_READ),%d0
2842         bset    #5,%d0
2843         moveb   %d0,%a1@(LPSG_WRITE)
2844 #elif defined(USE_SCC)
2845         lea     %a1@(LSCC_CTRL),%a0
2846         lea     %pc@(L(scc_initable)),%a1
2847 2:      moveb   %a1@+,%d0
2848         jmi     3f
2849         moveb   %d0,%a0@
2850         moveb   %a1@+,%a0@
2851         jra     2b
2852 3:      clrb    %a0@
2853 #elif defined(USE_MFP)
2854         bclr    #1,%a1@(LMFP_TSR)
2855         moveb   #0x88,%a1@(LMFP_UCR)
2856         andb    #0x70,%a1@(LMFP_TDCDR)
2857         moveb   #2,%a1@(LMFP_TDDR)
2858         orb     #1,%a1@(LMFP_TDCDR)
2859         bset    #1,%a1@(LMFP_TSR)
2860 #endif
2861         jra     L(serial_init_done)
2862 4:
2863 #endif
2864 #ifdef CONFIG_MAC
2865         is_not_mac(L(serial_init_not_mac))
2866 #ifdef MAC_SERIAL_DEBUG
2867 #if !defined(MAC_USE_SCC_A) && !defined(MAC_USE_SCC_B)
2868 #define MAC_USE_SCC_B
2869 #endif
2870 #define mac_scc_cha_b_ctrl_offset       0x0
2871 #define mac_scc_cha_a_ctrl_offset       0x2
2872 #define mac_scc_cha_b_data_offset       0x4
2873 #define mac_scc_cha_a_data_offset       0x6
2874
2875 #ifdef MAC_USE_SCC_A
2876         /* Initialize channel A */
2877         movel   %pc@(L(mac_sccbase)),%a0
2878         lea     %pc@(L(scc_initable_mac)),%a1
2879 5:      moveb   %a1@+,%d0
2880         jmi     6f
2881         moveb   %d0,%a0@(mac_scc_cha_a_ctrl_offset)
2882         moveb   %a1@+,%a0@(mac_scc_cha_a_ctrl_offset)
2883         jra     5b
2884 6:
2885 #endif  /* MAC_USE_SCC_A */
2886
2887 #ifdef MAC_USE_SCC_B
2888         /* Initialize channel B */
2889 #ifndef MAC_USE_SCC_A   /* Load mac_sccbase only if needed */
2890         movel   %pc@(L(mac_sccbase)),%a0
2891 #endif  /* MAC_USE_SCC_A */
2892         lea     %pc@(L(scc_initable_mac)),%a1
2893 7:      moveb   %a1@+,%d0
2894         jmi     8f
2895         moveb   %d0,%a0@(mac_scc_cha_b_ctrl_offset)
2896         moveb   %a1@+,%a0@(mac_scc_cha_b_ctrl_offset)
2897         jra     7b
2898 8:
2899 #endif  /* MAC_USE_SCC_B */
2900 #endif  /* MAC_SERIAL_DEBUG */
2901
2902         jra     L(serial_init_done)
2903 L(serial_init_not_mac):
2904 #endif  /* CONFIG_MAC */
2905
2906 #ifdef CONFIG_Q40
2907         is_not_q40(2f)
2908 /* debug output goes into SRAM, so we don't do it unless requested
2909    - check for '%LX$' signature in SRAM   */
2910         lea     %pc@(q40_mem_cptr),%a1
2911         move.l  #0xff020010,%a1@  /* must be inited - also used by debug=mem */
2912         move.l  #0xff020000,%a1   
2913         cmp.b   #'%',%a1@
2914         bne     2f      /*nodbg*/
2915         addq.w  #4,%a1
2916         cmp.b   #'L',%a1@
2917         bne     2f      /*nodbg*/
2918         addq.w  #4,%a1
2919         cmp.b   #'X',%a1@
2920         bne     2f      /*nodbg*/
2921         addq.w  #4,%a1
2922         cmp.b   #'$',%a1@
2923         bne     2f      /*nodbg*/
2924         /* signature OK */
2925         lea     %pc@(L(q40_do_debug)),%a1
2926         tas     %a1@
2927 /*nodbg: q40_do_debug is 0 by default*/ 
2928 2:              
2929 #endif  
2930         
2931 #ifdef CONFIG_APOLLO
2932 /* We count on the PROM initializing SIO1 */
2933 #endif
2934
2935 L(serial_init_done):
2936 func_return     serial_init
2937
2938 /*
2939  * Output character on serial port.
2940  */
2941 func_start      serial_putc,%d0/%d1/%a0/%a1
2942
2943         movel   ARG1,%d0
2944         cmpib   #'\n',%d0
2945         jbne    1f
2946
2947         /* A little safe recursion is good for the soul */
2948         serial_putc     #'\r'
2949 1:
2950
2951 #ifdef CONFIG_AMIGA
2952         is_not_amiga(2f)
2953         andw    #0x00ff,%d0
2954         oriw    #0x0100,%d0
2955         movel   %pc@(L(custom)),%a0
2956         movew   %d0,%a0@(CUSTOMBASE+C_SERDAT)
2957 1:      movew   %a0@(CUSTOMBASE+C_SERDATR),%d0
2958         andw    #0x2000,%d0
2959         jeq     1b
2960         jra     L(serial_putc_done)