]> git.ipfire.org Git - ipfire-2.x.git/blame - src/patches/suse-2.6.27.39/patches.suse/suse-ppc32-mol.patch
projects / ipfire-2.x.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported linux-2.6.27.39 suse/xen patches.
[ipfire-2.x.git] / src / patches / suse-2.6.27.39 / patches.suse / suse-ppc32-mol.patch
CommitLineData
2cb7cef9
BS		 1From: olh@suse.de
2Subject: vanilla sources from www.maconlinux.org
3Patch-mainline: never
4
5to avoid the km_ mess
6
7Never modify this patch! Create new patches for build fixes.
8
9---
10 drivers/macintosh/mol/_dev.c | 376 ++++++++++
11 drivers/macintosh/mol/_fault.c | 159 ++++
12 drivers/macintosh/mol/_hostirq.c | 116 +++
13 drivers/macintosh/mol/_kuname.c | 48 +
14 drivers/macintosh/mol/_misc.c | 147 +++
15 drivers/macintosh/mol/_mmu.c | 41 +
16 drivers/macintosh/mol/actions.c | 548 ++++++++++++++
17 drivers/macintosh/mol/asm-files/603.S | 218 +++++
18 drivers/macintosh/mol/asm-files/dec.S | 228 ++++++
19 drivers/macintosh/mol/asm-files/emuaccel.S | 188 +++++
20 drivers/macintosh/mol/asm-files/emulation.S | 714 +++++++++++++++++++
21 drivers/macintosh/mol/asm-files/entry.S | 433 +++++++++++
22 drivers/macintosh/mol/asm-files/iopage.S | 89 ++
23 drivers/macintosh/mol/asm-files/linux.S | 129 +++
24 drivers/macintosh/mol/asm-files/ptintercept.S | 303 ++++++++
25 drivers/macintosh/mol/asm-files/splitmode.S | 428 +++++++++++
26 drivers/macintosh/mol/asm-files/traps.S | 501 +++++++++++++
27 drivers/macintosh/mol/asm-files/vsid.S | 123 +++
28 drivers/macintosh/mol/asm_offsets.c | 161 ++++
29 drivers/macintosh/mol/context.c | 99 ++
30 drivers/macintosh/mol/emu.c | 228 ++++++
31 drivers/macintosh/mol/fault.c | 601 ++++++++++++++++
32 drivers/macintosh/mol/hash.c | 126 +++
33 drivers/macintosh/mol/include/actions.h | 177 ++++
34 drivers/macintosh/mol/include/alloc.h | 70 +
35 drivers/macintosh/mol/include/archinclude.h | 77 ++
36 drivers/macintosh/mol/include/asm.m4 | 141 +++
37 drivers/macintosh/mol/include/asm_offsets.inc | 136 +++
38 drivers/macintosh/mol/include/asmdbg.h | 184 ++++
39 drivers/macintosh/mol/include/asmdefs.h | 397 ++++++++++
40 drivers/macintosh/mol/include/asmfuncs.h | 80 ++
41 drivers/macintosh/mol/include/atomic.h | 26
42 drivers/macintosh/mol/include/config.h | 90 ++
43 drivers/macintosh/mol/include/constants.h | 36
44 drivers/macintosh/mol/include/context.h | 62 +
45 drivers/macintosh/mol/include/dbg.h | 31
46 drivers/macintosh/mol/include/debugger.h | 96 ++
47 drivers/macintosh/mol/include/emu.h | 29
48 drivers/macintosh/mol/include/emuaccel_sh.h | 41 +
49 drivers/macintosh/mol/include/extralib.h | 70 +
50 drivers/macintosh/mol/include/hash.h | 36
51 drivers/macintosh/mol/include/kernel_vars.h | 225 ++++++
52 drivers/macintosh/mol/include/locks.h | 39 +
53 drivers/macintosh/mol/include/mac_registers.h | 168 ++++
54 drivers/macintosh/mol/include/map.h | 43 +
55 drivers/macintosh/mol/include/misc.h | 105 ++
56 drivers/macintosh/mol/include/mmu.h | 102 ++
57 drivers/macintosh/mol/include/mmu_contexts.h | 55 +
58 drivers/macintosh/mol/include/mmu_mappings.h | 48 +
59 drivers/macintosh/mol/include/mmutypes.h | 76 ++
60 drivers/macintosh/mol/include/mol-ioctl.h | 121 +++
61 drivers/macintosh/mol/include/mol_config.h | 76 ++
62 drivers/macintosh/mol/include/molasm.h | 138 +++
63 drivers/macintosh/mol/include/molversion.h | 6
64 drivers/macintosh/mol/include/mtable.h | 71 +
65 drivers/macintosh/mol/include/osi.h | 170 ++++
66 drivers/macintosh/mol/include/osi_calls.h | 475 ++++++++++++
67 drivers/macintosh/mol/include/performance.h | 71 +
68 drivers/macintosh/mol/include/platform.h | 73 +
69 drivers/macintosh/mol/include/processor.h | 409 +++++++++++
70 drivers/macintosh/mol/include/prom.h | 46 +
71 drivers/macintosh/mol/include/rvec.h | 147 +++
72 drivers/macintosh/mol/include/skiplist.h | 87 ++
73 drivers/macintosh/mol/include/tlbie.h | 102 ++
74 drivers/macintosh/mol/include/uaccess.h | 36
75 drivers/macintosh/mol/include/vector.h | 189 +++++
76 drivers/macintosh/mol/include/version.h | 11
77 drivers/macintosh/mol/include/weaksym.h | 39 +
78 drivers/macintosh/mol/init.c | 191 +++++
79 drivers/macintosh/mol/misc.c | 255 ++++++
80 drivers/macintosh/mol/mmu.c | 251 ++++++
81 drivers/macintosh/mol/mmu_fb.c | 186 +++++
82 drivers/macintosh/mol/mmu_io.c | 470 ++++++++++++
83 drivers/macintosh/mol/mmu_tracker.c | 128 +++
84 drivers/macintosh/mol/mtable.c | 960 ++++++++++++++++++++++++++
85 drivers/macintosh/mol/ptaccess.c | 153 ++++
86 drivers/macintosh/mol/sheep.c | 701 ++++++++++++++++++
87 drivers/macintosh/mol/skiplist.c | 222 ++++++
88 78 files changed, 14428 insertions(+)
89
90--- /dev/null
91+++ b/drivers/macintosh/mol/_dev.c
92@@ -0,0 +1,376 @@
93+/*
94+ * Creation Date: <2003/08/20 17:31:44 samuel>
95+ * Time-stamp: <2004/02/14 14:43:13 samuel>
96+ *
97+ * <dev.c>
98+ *
99+ * misc device
100+ *
101+ * Copyright (C) 2003, 2004 Samuel Rydh (samuel@ibrium.se)
102+ *
103+ * This program is free software; you can redistribute it and/or
104+ * modify it under the terms of the GNU General Public License
105+ * version 2
106+ *
107+ */
108+
109+#include "archinclude.h"
110+#include <linux/module.h>
111+#include <linux/miscdevice.h>
112+#include <linux/spinlock.h>
113+#include <linux/init.h>
114+#include <linux/interrupt.h>
115+#include <linux/irq.h>
116+#include <linux/bitops.h>
117+#include <asm/prom.h>
118+#include <asm/machdep.h>
119+#include <asm/atomic.h>
120+#include "kernel_vars.h"
121+#include "mol-ioctl.h"
122+#include "version.h"
123+#include "mmu.h"
124+#include "misc.h"
125+#include "mtable.h"
126+#include "atomic.h"
127+
128+MODULE_AUTHOR("Samuel Rydh <samuel@ibrium.se>");
129+MODULE_DESCRIPTION("Mac-on-Linux kernel module");
130+MODULE_LICENSE("GPL");
131+
132+static DECLARE_MUTEX( initmutex );
133+static int opencnt;
134+
135+
136+/************************************************************************/
137+/* misc */
138+/************************************************************************/
139+
140+#ifdef CONFIG_SMP
141+#define HAS_SMP 1
142+
143+static void
144+dummy_ipi( void *dummy )
145+{
146+ /* we don't need to _do_ anything, the exception itself is sufficient */
147+}
148+static inline void
149+send_ipi( void )
150+{
151+ smp_call_function( dummy_ipi, NULL, 1, 0 );
152+}
153+#else /* CONFIG_SMP */
154+
155+#define HAS_SMP 0
156+#define send_ipi() do {} while(0)
157+
158+#endif /* CONFIG_SMP */
159+
160+
161+static int
162+find_physical_rom( int *base, int *size )
163+{
164+#ifndef CONFIG_AMIGAONE
165+ struct device_node *dn;
166+ int len, *p;
167+ int by_type = 0;
168+
169+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)
170+ if( !(dn=find_devices("boot-rom")) && !(dn=find_type_devices("rom")) )
171+ return 0;
172+#else
173+ if (! (dn = of_find_node_by_name(NULL, "boot-rom"))) {
174+ by_type = 1;
175+ if (! (dn = of_find_node_by_type(NULL, "rom")))
176+ return 0;
177+ }
178+#endif /* < Linux 2.6.21 */
179+ do {
180+ if( !(p=(int*)get_property(dn, "reg", &len)) || len != sizeof(int[2]) ) {
181+ of_node_put(dn);
182+ return 0;
183+ }
184+ if( (unsigned int)(0xfff00100 - p[0]) < (unsigned int)p[1] ) {
185+ *base = p[0];
186+ *size = p[1];
187+ of_node_put(dn);
188+ return 1;
189+ }
190+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)
191+ dn = dn->next;
192+#else
193+ dn = by_type ? of_find_node_by_type(dn, "rom") :
194+ of_find_node_by_name(dn, "boot-rom");
195+#endif /* < Linux 2.6.21 */
196+ } while( dn );
197+#endif /* CONFIG_AMIGA_ONE */
198+ return 0;
199+}
200+
201+static int
202+get_info( mol_kmod_info_t *user_retinfo, int size )
203+{
204+ mol_kmod_info_t info;
205+
206+ memset( &info, 0, sizeof(info) );
207+ asm volatile("mfpvr %0" : "=r" (info.pvr) : );
208+ info.version = MOL_VERSION;
209+ find_physical_rom( &info.rombase, &info.romsize );
210+ info.tb_freq = HZ * tb_ticks_per_jiffy;
211+ info.smp_kernel = HAS_SMP;
212+
213+ if( (uint)size > sizeof(info) )
214+ size = sizeof(info);
215+
216+ if( copy_to_user(user_retinfo, &info, size) )
217+ return -EFAULT;
218+ return 0;
219+}
220+
221+
222+void
223+prevent_mod_unload( void )
224+{
225+#ifndef LINUX_26
226+ MOD_INC_USE_COUNT;
227+#else
228+ __module_get( THIS_MODULE );
229+#endif
230+}
231+
232+int
233+get_irqs( kernel_vars_t *kv, irq_bitfield_t *irq_info_p )
234+{
235+ irq_bitfield_t irq_mask;
236+ int i;
237+
238+ /* copy the interrupt mask from userspace */
239+ if (copy_from_user(&irq_mask, irq_info_p, sizeof(irq_mask)))
240+ return -EFAULT;
241+
242+ /* see which of the mapped interrupts need to be enabled */
243+ for (i = 0; i < NR_HOST_IRQS; i++) {
244+ if (check_bit_mol(i, (char *) kv->mregs.mapped_irqs.irqs)
245+ && check_bit_mol(i, (char *) irq_mask.irqs)
246+ && check_bit_mol(i, (char *) kv->mregs.active_irqs.irqs)) {
247+ if (test_and_clear_bit(i, kv->mregs.active_irqs.irqs))
248+ atomic_dec_mol((mol_atomic_t *) &(kv->mregs.hostirq_active_cnt));
249+ enable_irq(i);
250+ }
251+ }
252+
253+ /* if one of the enabled interrupts was pending, it should have fired
254+ * now, updating active_irqs */
255+ if (copy_to_user(irq_info_p, &(kv->mregs.active_irqs), sizeof(kv->mregs.active_irqs)))
256+ return -EFAULT;
257+
258+ return 0;
259+}
260+
261+/************************************************************************/
262+/* ioctl */
263+/************************************************************************/
264+
265+static int
266+debugger_op( kernel_vars_t *kv, dbg_op_params_t *upb )
267+{
268+ dbg_op_params_t pb;
269+ int ret;
270+
271+ if( copy_from_user(&pb, upb, sizeof(pb)) )
272+ return -EFAULT;
273+
274+ switch( pb.operation ) {
275+ case DBG_OP_GET_PHYS_PAGE:
276+ ret = dbg_get_linux_page( pb.ea, &pb.ret.page );
277+ break;
278+ default:
279+ ret = do_debugger_op( kv, &pb );
280+ break;
281+ }
282+
283+ if( copy_to_user(upb, &pb, sizeof(pb)) )
284+ return -EFAULT;
285+ return ret;
286+}
287+
288+static int
289+arch_handle_ioctl( kernel_vars_t *kv, int cmd, int p1, int p2, int p3 )
290+{
291+ char *rompage;
292+ int ret = -EFAULT;
293+
294+ switch( cmd ) {
295+ case MOL_IOCTL_GET_IRQS:
296+ return get_irqs( kv, (irq_bitfield_t *) p1 );
297+
298+ case MOL_IOCTL_GET_DIRTY_FBLINES: /* short *retbuf, int size -- npairs */
299+ if( compat_verify_area(VERIFY_WRITE, (short*)p1, p2) )
300+ break;
301+ ret = get_dirty_fb_lines( kv, (short*)p1, p2 );
302+ break;
303+
304+ case MOL_IOCTL_DEBUGGER_OP:
305+ ret = debugger_op( kv, (dbg_op_params_t*)p1 );
306+ break;
307+
308+ case MOL_IOCTL_GRAB_IRQ:
309+ ret = grab_host_irq(kv, p1);
310+ break;
311+
312+ case MOL_IOCTL_RELEASE_IRQ:
313+ ret = release_host_irq(kv, p1);
314+ break;
315+
316+ case MOL_IOCTL_COPY_LAST_ROMPAGE: /* p1 = dest */
317+ ret = -ENODEV;
318+ if( (rompage=ioremap(0xfffff000, 0x1000)) ) {
319+ ret = copy_to_user( (char*)p1, rompage, 0x1000 );
320+ iounmap( rompage );
321+ }
322+ break;
323+
324+ case MOL_IOCTL_SET_RAM: /* void ( char *lvbase, size_t size ) */
325+ if( compat_verify_area(VERIFY_WRITE, (char*)p1, p2) )
326+ break;
327+ ret = 0;
328+ kv->mmu.userspace_ram_base = p1;
329+ kv->mmu.ram_size = p2;
330+ mtable_tune_alloc_limit( kv, p2/(1024 * 1024) );
331+ break;
332+
333+ case MOL_IOCTL_GET_MREGS_PHYS:
334+ ret = virt_to_phys( &kv->mregs );
335+ break;
336+
337+ default:
338+ ret = handle_ioctl( kv, cmd, p1, p2, p3 );
339+ break;
340+ }
341+ return ret;
342+}
343+
344+
345+/************************************************************************/
346+/* device interface */
347+/************************************************************************/
348+
349+static int
350+mol_open( struct inode *inode, struct file *file )
351+{
352+ int ret=0;
353+
354+ if( !(file->f_mode & FMODE_READ) )
355+ return -EPERM;
356+
357+ down( &initmutex );
358+ if( !opencnt++ ) {
359+ if( common_init() ) {
360+ ret = -ENOMEM;
361+ opencnt = 0;
362+ }
363+ }
364+ up( &initmutex );
365+
366+ file->private_data = NULL;
367+ return ret;
368+}
369+
370+static int
371+mol_release( struct inode *inode, struct file *file )
372+{
373+ kernel_vars_t *kv = (kernel_vars_t*)file->private_data;
374+
375+ down( &initmutex );
376+ if( kv )
377+ destroy_session( kv->session_index );
378+
379+ if( !--opencnt )
380+ common_cleanup();
381+ up( &initmutex );
382+ return 0;
383+}
384+
385+static int
386+mol_ioctl( struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg )
387+{
388+ mol_ioctl_pb_t pb;
389+ kernel_vars_t *kv;
390+ int ret;
391+ uint session;
392+
393+ /* fast path */
394+ if( cmd == MOL_IOCTL_SMP_SEND_IPI ) {
395+ send_ipi();
396+ return 0;
397+ }
398+
399+ if( copy_from_user(&pb, (void*)arg, sizeof(pb)) )
400+ return -EFAULT;
401+
402+ switch( cmd ) {
403+ case MOL_IOCTL_GET_INFO:
404+ return get_info( (mol_kmod_info_t*)pb.arg1, pb.arg2 );
405+
406+ case MOL_IOCTL_CREATE_SESSION:
407+ if( !(file->f_mode & FMODE_WRITE) || !capable(CAP_SYS_ADMIN) )
408+ return -EPERM;
409+ ret = -EINVAL;
410+ down( &initmutex );
411+ if( (uint)pb.arg1 < MAX_NUM_SESSIONS && !file->private_data ) {
412+ if( !(ret=initialize_session(pb.arg1)) ) {
413+ kv = g_sesstab->kvars[pb.arg1];
414+ init_MUTEX( &kv->ioctl_sem );
415+ file->private_data = kv;
416+ }
417+ }
418+ up( &initmutex );
419+ return ret;
420+
421+ case MOL_IOCTL_DBG_COPY_KVARS:
422+ session = pb.arg1;
423+ ret = -EINVAL;
424+ down( &initmutex );
425+ if( session < MAX_NUM_SESSIONS && (kv=g_sesstab->kvars[session]) )
426+ ret = copy_to_user( (char*)pb.arg2, kv, sizeof(*kv) );
427+ up( &initmutex );
428+ return ret;
429+ }
430+
431+ if( !(kv=(kernel_vars_t*)file->private_data) )
432+ return -EINVAL;
433+
434+ down( &kv->ioctl_sem );
435+ ret = arch_handle_ioctl( kv, cmd, pb.arg1, pb.arg2, pb.arg3 );
436+ up( &kv->ioctl_sem );
437+
438+ return ret;
439+}
440+
441+static struct file_operations mol_device_fops = {
442+ .owner = THIS_MODULE,
443+ .open = mol_open,
444+ .release = mol_release,
445+ .ioctl = mol_ioctl,
446+// .poll = mol_poll,
447+// .mmap: = mol_mmap,
448+};
449+
450+static struct miscdevice mol_device = {
451+ MISC_DYNAMIC_MINOR, "mol", &mol_device_fops
452+};
453+
454+static int __init
455+dev_register( void )
456+{
457+ printk("MOL %s kernel module loaded\n", MOL_RELEASE );
458+ return misc_register( &mol_device );
459+}
460+
461+static void __exit
462+dev_unregister( void )
463+{
464+ misc_deregister( &mol_device );
465+}
466+
467+module_init( dev_register );
468+module_exit( dev_unregister );
469--- /dev/null
470+++ b/drivers/macintosh/mol/_fault.c
471@@ -0,0 +1,159 @@
472+/*
473+ * Creation Date: <2002/06/08 21:01:54 samuel>
474+ * Time-stamp: <2004/02/19 11:54:33 samuel>
475+ *
476+ * <fault.c>
477+ *
478+ * Linux part
479+ *
480+ * Copyright (C) 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
481+ *
482+ * This program is free software; you can redistribute it and/or
483+ * modify it under the terms of the GNU General Public License
484+ * as published by the Free Software Foundation
485+ *
486+ */
487+
488+#include "archinclude.h"
489+#include "alloc.h"
490+#include "kernel_vars.h"
491+#include "mmu.h"
492+#include "mmu_contexts.h"
493+#include "asmfuncs.h"
494+#include "emu.h"
495+#include "misc.h"
496+#include "rvec.h"
497+#include "performance.h"
498+#include "mol-ioctl.h"
499+#include "mtable.h"
500+
501+#ifdef CONFIG_HIGHPTE
502+#error "MOL is currently incompatible with CONFIG_HIGHPTE"
503+#endif
504+
505+static inline ulong
506+fix_pte( ulong *p, ulong set, ulong flags )
507+{
508+ unsigned long ret, tmp;
509+
510+ __asm__ __volatile__("\n"
511+ "1: lwarx %0,0,%3 \n"
512+ " andc. %1,%5,%0 \n"
513+ " addi %1,0,0 \n"
514+ " bne- 2f \n"
515+ " or %1,%0,%4 \n"
516+ " stwcx. %1,0,%3 \n"
517+ " bne- 1b \n"
518+ "2: \n"
519+ : "=&r" (tmp), "=&r" (ret), "=m" (*p)
520+ : "r" (p), "r" (set), "r" (flags), "m" (*p)
521+ : "cc" );
522+ return ret;
523+}
524+
525+/*
526+ * Get physical page corresponding to linux virtual address. Invokes linux page
527+ * fault handler if the page is missing. This function never fails since we
528+ * know there is a valid mapping...
529+ */
530+#define PAGE_BITS_WRITE (_PAGE_ACCESSED | _PAGE_DIRTY | _PAGE_HASHPTE )
531+#define PAGE_BITS_READ (_PAGE_ACCESSED | _PAGE_HASHPTE )
532+
533+ulong
534+get_phys_page( kernel_vars_t *kv, ulong va, int request_rw )
535+{
536+ char *lvptr = (char*)va;
537+ ulong lpte, uptr, *ptr;
538+ ulong flags;
539+ struct mm_struct *mm;
540+ struct vm_area_struct *vma;
541+
542+ /* pte bits that must be set */
543+ flags = request_rw ? (_PAGE_USER | _PAGE_RW | _PAGE_PRESENT)
544+ : (_PAGE_USER | _PAGE_PRESENT);
545+
546+ uptr = ((ulong*)current->thread.pgdir)[va>>22]; /* top 10 bits */
547+ ptr = (ulong*)(uptr & ~0xfff);
548+ if( !ptr )
549+ goto no_page;
550+#ifdef LINUX_26
551+ ptr = phys_to_virt( (int)ptr );
552+#endif
553+ ptr = ptr + ((va>>12) & 0x3ff); /* next 10 bits */
554+
555+ /* this allows us to keep track of this page until we have
556+ * added a full mtable entry for it. The reservation is lost if
557+ * a TLB invalidation occurs.
558+ */
559+ make_lvptr_reservation( kv, lvptr );
560+
561+ /* we atomically set _PAGE_HASHPTE after checking PAGE_PRESENT and PAGE_RW.
562+ * We are then guaranteed to be notified about a TLB invalidation through the
563+ * flush_hash_page hook.
564+ */
565+ lpte = fix_pte( ptr, (request_rw? PAGE_BITS_WRITE : PAGE_BITS_READ), flags );
566+
567+ /* permissions violation */
568+ if( !lpte )
569+ goto no_page;
570+
571+ return lpte & ~0xfff;
572+
573+no_page:
574+ BUMP( page_missing );
575+
576+ /* no mac page found... */
577+ mm = current->mm;
578+ down_read( &mm->mmap_sem );
579+
580+ if( !(vma=find_vma(mm,va)) || vma->vm_start > va )
581+ goto bad_area;
582+ if( !(vma->vm_flags & (request_rw ? VM_WRITE : (VM_READ | VM_EXEC))) )
583+ goto bad_area;
584+
585+ handle_mm_fault( mm, vma, va, request_rw );
586+
587+ up_read( &mm->mmap_sem );
588+ return get_phys_page(kv, va, request_rw);
589+
590+bad_area:
591+ up_read( &mm->mmap_sem );
592+ printk("get_phys_page: BAD AREA, lvptr = %08lx\n", va );
593+ force_sig(SIGSEGV, current);
594+ return 0;
595+}
596+
597+
598+/************************************************************************/
599+/* Debugger functions */
600+/************************************************************************/
601+
602+int
603+dbg_get_linux_page( ulong va, dbg_page_info_t *r )
604+{
605+ ulong val, uptr, *ptr;
606+
607+ uptr = ((ulong*)current->thread.pgdir)[va>>22]; /* top 10 bits */
608+ ptr = (ulong*)(uptr & ~0xfff);
609+ if( !ptr )
610+ return 1;
611+#ifdef LINUX_26
612+ ptr = phys_to_virt( (int)ptr );
613+#endif
614+ val = ptr[ (va>>12)&0x3ff ]; /* next 10 bits */
615+
616+ r->phys = val & ~0xfff;
617+ r->mflags =
618+ DBG_TRANSL_PAGE_FLAG( val, _PAGE_PRESENT )
619+ | DBG_TRANSL_PAGE_FLAG( val, _PAGE_USER )
620+ | DBG_TRANSL_PAGE_FLAG( val, _PAGE_GUARDED )
621+ | DBG_TRANSL_PAGE_FLAG( val, _PAGE_COHERENT )
622+ | DBG_TRANSL_PAGE_FLAG( val, _PAGE_NO_CACHE )
623+ | DBG_TRANSL_PAGE_FLAG( val, _PAGE_WRITETHRU )
624+ | DBG_TRANSL_PAGE_FLAG( val, _PAGE_DIRTY )
625+ | DBG_TRANSL_PAGE_FLAG( val, _PAGE_ACCESSED )
626+ | DBG_TRANSL_PAGE_FLAG( val, _PAGE_RW )
627+ | DBG_TRANSL_PAGE_FLAG( val, _PAGE_HASHPTE )
628+ | DBG_TRANSL_PAGE_FLAG( val, _PAGE_EXEC );
629+ return 0;
630+}
631--- /dev/null
632+++ b/drivers/macintosh/mol/_hostirq.c
633@@ -0,0 +1,116 @@
634+/*
635+ * <hostirq.c>
636+ *
637+ * host IRQ handling (for pciproxied devices)
638+ *
639+ * Copyright (C) 2005 Mattias Nissler <mattias.nissler@gmx.de>
640+ *
641+ * This program is free software; you can redistribute it and/or
642+ * modify it under the terms of the GNU General Public License
643+ * version 2
644+ *
645+ */
646+#include <linux/version.h>
647+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)
648+#include <linux/threads.h>
649+#include <linux/spinlock.h>
650+#endif
651+#include <linux/interrupt.h>
652+#include <linux/irq.h>
653+#include <linux/sched.h>
654+#include <linux/bitops.h>
655+#include <asm/atomic.h>
656+
657+#include "archinclude.h"
658+#include "kernel_vars.h"
659+#include "misc.h"
660+#include "atomic.h"
661+
662+irqreturn_t
663+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19)
664+hostirq_handler(int irq, void *pkv)
665+#else
666+hostirq_handler(int irq, void *pkv, struct pt_regs *regs)
667+#endif
668+{
669+ siginfo_t si;
670+ kernel_vars_t *kv = (kernel_vars_t *) pkv;
671+
672+ /* disable the irq */
673+ disable_irq_nosync(irq);
674+ /* have the interrupt handled */
675+ if (!test_and_set_bit(irq, kv->mregs.active_irqs.irqs))
676+ atomic_inc_mol((mol_atomic_t *) &(kv->mregs.hostirq_active_cnt));
677+ kv->mregs.hostirq_update = 1;
678+ kv->mregs.interrupt = 1;
679+ /* signal the main thread (it might be DOZEing) */
680+ if (kv->main_thread != NULL) {
681+ memset(&si, 0, sizeof(si));
682+ si.si_signo = SIGHUP;
683+ si.si_code = irq;
684+ send_sig_info(SIGHUP, &si, kv->main_thread);
685+ }
686+
687+ return IRQ_HANDLED;
688+}
689+
690+static char *molirqdescstring = "MOL irq mapping";
691+
692+int
693+grab_host_irq(kernel_vars_t *kv, int irq)
694+{
695+ int ret;
696+
697+ /* sanity check */
698+ if (irq < 0 || irq >= NR_HOST_IRQS
699+ || check_bit_mol(irq, (char *) kv->mregs.mapped_irqs.irqs))
700+ return 0;
701+
702+ /* request the irq */
703+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 21)
704+ ret = request_irq(irq, hostirq_handler, IRQF_DISABLED | IRQF_SHARED, molirqdescstring, kv);
705+#else
706+ ret = request_irq(irq, hostirq_handler, SA_INTERRUPT | SA_SHIRQ, molirqdescstring, kv);
707+#endif
708+ if (!ret) {
709+// printk(KERN_INFO "mapped irq line %d\n", irq);
710+ set_bit_mol(irq, (char *) kv->mregs.mapped_irqs.irqs);
711+ }
712+
713+ return ret;
714+}
715+
716+int
717+release_host_irq(kernel_vars_t *kv, int irq)
718+{
719+ /* sanity check */
720+ if (irq < 0 || irq >= NR_HOST_IRQS
721+ || !check_bit_mol(irq, (char *) kv->mregs.mapped_irqs.irqs))
722+ return 0;
723+
724+ clear_bit_mol(irq, (char *) kv->mregs.mapped_irqs.irqs);
725+ disable_irq(irq);
726+ free_irq(irq, kv);
727+
728+ return 1;
729+}
730+
731+void
732+init_host_irqs(kernel_vars_t *kv)
733+{
734+ memset(&(kv->mregs.mapped_irqs), 0, sizeof(kv->mregs.mapped_irqs));
735+ kv->main_thread = current;
736+ kv->mregs.hostirq_update = 0;
737+}
738+
739+void
740+cleanup_host_irqs(kernel_vars_t *kv)
741+{
742+ int n;
743+
744+ for (n = 0; n < NR_HOST_IRQS; n++) {
745+ if (check_bit_mol(n, (char *) kv->mregs.mapped_irqs.irqs))
746+ release_host_irq(kv, n);
747+ }
748+}
749+
750--- /dev/null
751+++ b/drivers/macintosh/mol/_kuname.c
752@@ -0,0 +1,48 @@
753+/*
754+ * Creation Date: <2001/08/15 01:11:01 samuel>
755+ * Time-stamp: <2003/10/24 10:22:00 samuel>
756+ *
757+ * <kuname.c>
758+ *
759+ * Extract from the kernel source
760+ *
761+ * Copyright (C) 2001, 2002, 2003 Samuel Rydh (samuel@ibrium.se)
762+ *
763+ * This program is free software; you can redistribute it and/or
764+ * modify it under the terms of the GNU General Public License
765+ * as published by the Free Software Foundation
766+ *
767+ */
768+
769+#include <linux/version.h>
770+
771+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
772+#include <linux/utsrelease.h>
773+#endif
774+
775+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
776+#include <linux/config.h>
777+#else
778+#include <linux/autoconf.h>
779+#endif
780+
781+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
782+
783+#ifdef CONFIG_SMP
784+#define SMP_STRING "-smp"
785+#else
786+#define SMP_STRING ""
787+#endif
788+
789+#ifndef CONFIG_ALTIVEC
790+#define ALTIVEC_STRING "-noav"
791+#else
792+#define ALTIVEC_STRING ""
793+#endif
794+
795+#else
796+#define SMP_STRING ""
797+#define ALTIVEC_STRING ""
798+#endif
799+
800+char *cross_compiling_magic = "-MAGIC-" UTS_RELEASE SMP_STRING ALTIVEC_STRING ;
801--- /dev/null
802+++ b/drivers/macintosh/mol/_misc.c
803@@ -0,0 +1,147 @@
804+/*
805+ * Creation Date: <97/05/26 02:10:43 samuel>
806+ * Time-stamp: <2004/03/13 14:14:20 samuel>
807+ *
808+ * <misc.c>
809+ *
810+ * Kernel interface
811+ *
812+ * Copyright (C) 1997-2004 Samuel Rydh (samuel@ibrium.se)
813+ *
814+ * This program is free software; you can redistribute it and/or
815+ * modify it under the terms of the GNU General Public License
816+ * as published by the Free Software Foundation
817+ *
818+ */
819+
820+#include "archinclude.h"
821+#include <linux/vmalloc.h>
822+#include <linux/sched.h>
823+#include <asm/uaccess.h>
824+#include <asm/prom.h>
825+#include "kernel_vars.h"
826+#include "misc.h"
827+#include "performance.h"
828+#include "map.h"
829+
830+#define MMU kv->mmu
831+
832+kernel_vars_t *
833+alloc_kvar_pages( void )
834+{
835+ kernel_vars_t *kv;
836+ int i, order;
837+ char *ptr;
838+
839+ for( i=1, order=0; i<NUM_KVARS_PAGES; i=i<<1, order++ )
840+ ;
841+ if( !(kv=(kernel_vars_t*)__get_free_pages(GFP_KERNEL, order)) )
842+ return NULL;
843+
844+ /* To be able to export the kernel variables to user space, we
845+ * must set the PG_reserved bit. This is due to a check
846+ * in remap_pte_range() in kernel/memory.c (is this bug or a feature?).
847+ */
848+ for( ptr=(char*)kv, i=0; i<NUM_KVARS_PAGES; i++, ptr+=0x1000 )
849+ SetPageReserved( virt_to_page(ptr) );
850+
851+ return kv;
852+}
853+
854+void
855+free_kvar_pages( kernel_vars_t *kv )
856+{
857+ char *ptr = (char*)kv;
858+ int i, order;
859+
860+ for( i=0; i<NUM_KVARS_PAGES; i++, ptr+=0x1000 )
861+ ClearPageReserved( virt_to_page(ptr) );
862+
863+ for( i=1, order=0; i<NUM_KVARS_PAGES; i=i<<1, order++ )
864+ ;
865+ free_pages( (ulong)kv, order );
866+}
867+
868+
869+/************************************************************************/
870+/* hash access */
871+/************************************************************************/
872+
873+ulong *
874+map_emulated_hash( kernel_vars_t *kv, ulong mbase, ulong size )
875+{
876+ return (ulong*)(MMU.userspace_ram_base + mbase);
877+}
878+
879+void
880+unmap_emulated_hash( kernel_vars_t *kv )
881+{
882+ /* nothing */
883+}
884+
885+/************************************************************************/
886+/* kernel lowmem asm <-> kernel C-code switching */
887+/************************************************************************/
888+
889+typedef int (*kernelfunc_t)( kernel_vars_t *, ulong, ulong, ulong );
890+typedef void (*trampoline_t)( struct pt_regs *regs );
891+static trampoline_t old_trampoline;
892+
893+static void
894+mol_trampoline_vector( struct pt_regs *r )
895+{
896+ kernel_vars_t *kv = (kernel_vars_t*)r->gpr[8];
897+
898+#ifndef LINUX_26
899+ /* the 0x2f00 trap does not enable MSR_EE */
900+ local_irq_enable();
901+#endif
902+ TICK_CNTR_PUSH( kv );
903+ r->gpr[3] = (*(kernelfunc_t)r->gpr[3])( kv, r->gpr[4], r->gpr[5], r->gpr[6] );
904+ TICK_CNTR_POP( kv, in_kernel );
905+}
906+
907+static trampoline_t
908+set_trampoline( trampoline_t tramp )
909+{
910+ trampoline_t old;
911+#ifdef LINUX_26
912+ extern trampoline_t mol_trampoline;
913+ old = mol_trampoline;
914+ mol_trampoline = tramp;
915+#else
916+ /* we steal the unused 0x2f00 exception vector... */
917+ u32 *p = (u32*)(KERNELBASE + 0x2f00);
918+ static trampoline_t *tptr = NULL;
919+ int i;
920+
921+ /* look for bl xxxx ; .long vector; .long exception_return */
922+ for( i=0; !tptr && i<0x100/4; i++ ) {
923+ if( (p[i] & ~0xffff) != 0x48000000 )
924+ continue;
925+ if( (p[i+1] & ~0x7fffff) != KERNELBASE || (p[i+2] & ~0x0fffff) != KERNELBASE )
926+ continue;
927+ tptr = (trampoline_t*)&p[i+1];
928+ }
929+ if( !tptr ) {
930+ printk("MOL trampoline not found!\n");
931+ return NULL;
932+ }
933+ old = *tptr;
934+ *tptr = tramp;
935+#endif
936+ return old;
937+}
938+
939+int
940+arch_common_init( void )
941+{
942+ old_trampoline = set_trampoline( mol_trampoline_vector );
943+ return !old_trampoline;
944+}
945+
946+void
947+arch_common_cleanup( void )
948+{
949+ set_trampoline( old_trampoline );
950+}
951--- /dev/null
952+++ b/drivers/macintosh/mol/_mmu.c
953@@ -0,0 +1,41 @@
954+/*
955+ * Creation Date: <2002/07/13 13:58:00 samuel>
956+ * Time-stamp: <2004/02/14 12:47:09 samuel>
957+ *
958+ * <mmu.c>
959+ *
960+ *
961+ *
962+ * Copyright (C) 2002, 2003 Samuel Rydh (samuel@ibrium.se)
963+ *
964+ * This program is free software; you can redistribute it and/or
965+ * modify it under the terms of the GNU General Public License
966+ * as published by the Free Software Foundation
967+ *
968+ */
969+
970+#include "archinclude.h"
971+#include "alloc.h"
972+#include "kernel_vars.h"
973+#include "mmu.h"
974+#include "asmfuncs.h"
975+
976+#define MMU (kv->mmu)
977+
978+#ifdef CONFIG_SMP
979+void (*xx_tlbie_lowmem)( void );
980+void (*xx_store_pte_lowmem)( void );
981+#else
982+void (*xx_store_pte_lowmem)( ulong *slot, int pte0, int pte1 );
983+#endif
984+
985+int
986+arch_mmu_init( kernel_vars_t *kv )
987+{
988+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
989+ MMU.emulator_context = current->mm->context.id;
990+#else
991+ MMU.emulator_context = current->mm->context;
992+#endif
993+ return 0;
994+}
995--- /dev/null
996+++ b/drivers/macintosh/mol/actions.c
997@@ -0,0 +1,548 @@
998+/*
999+ * Creation Date: <2001/04/07 17:33:52 samuel>
1000+ * Time-stamp: <2004/03/13 14:17:40 samuel>
1001+ *
1002+ * <actions.c>
1003+ *
1004+ * Handle assambly actions (relocations, exception vector
1005+ * hooking, lowmem relocations and other stuff)
1006+ *
1007+ * Copyright (C) 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
1008+ *
1009+ * This program is free software; you can redistribute it and/or
1010+ * modify it under the terms of the GNU General Public License
1011+ * as published by the Free Software Foundation
1012+ *
1013+ */
1014+
1015+#include "archinclude.h"
1016+#include "alloc.h"
1017+#include "kernel_vars.h"
1018+#include "misc.h"
1019+#include "asmfuncs.h"
1020+#include "actions.h"
1021+#include "map.h"
1022+
1023+
1024+/* globals */
1025+int reloc_virt_offs;
1026+
1027+static char *code_base;
1028+static uint code_size;
1029+
1030+/* some opcodes */
1031+#define OPCODE_ADDIS( dreg, sreg, hi_val ) ((15<<26) | ((dreg)<<21) | ((sreg)<<16) | (hi_val))
1032+#define OPCODE_LIS( dreg, hi_val ) OPCODE_ADDIS( dreg, 0, hi_val )
1033+#define OPCODE_ORI( dreg, sreg, val ) ((24<<26) | ((dreg)<<16) | ((sreg)<<21) | (val))
1034+#define OPCODE_MTSPRG2( sreg ) (0x7c1243a6 + ((sreg)<<21))
1035+
1036+
1037+/************************************************************************/
1038+/* lowmem allocations (allocates within the first 32 MB of RAM) */
1039+/************************************************************************/
1040+
1041+/* The low-level assembly code need to be located in memory which is
1042+ * physically continuous. The kernel exception vector are patched
1043+ * through pseudo symbols (action symbols).
1044+ */
1045+
1046+#define MAX_NUM_CLEANUP_HANDLERS 32
1047+
1048+typedef struct {
1049+ char *lowmem_addr;
1050+ int alloc_size;
1051+ int alloc_method;
1052+
1053+ ulong *inst_addr; /* these fields are used */
1054+ ulong opcode; /* be the hook code */
1055+} cleanup_entry_t;
1056+
1057+static int num_cleanup_entries;
1058+static cleanup_entry_t cleanup_table[ MAX_NUM_CLEANUP_HANDLERS ];
1059+static ulong lowmem_phys_cursor;
1060+
1061+/* Memory mapping of exception vectors */
1062+static ulong lowmem_phys_base;
1063+static char *lowmem_virt_base;
1064+static void *lowmem_mapping;
1065+
1066+
1067+static inline ulong *
1068+lowmem_phys_to_virt( ulong paddr ) {
1069+ return (ulong*)(lowmem_virt_base + (paddr - lowmem_phys_base));
1070+}
1071+
1072+static inline ulong
1073+lowmem_tophys( void *vaddr ) {
1074+ return lowmem_phys_base + ((ulong)vaddr - (ulong)lowmem_virt_base);
1075+}
1076+
1077+
1078+static void
1079+lowmem_initialize( void )
1080+{
1081+ if( num_cleanup_entries ) {
1082+ printk("Internal error in lowmem_initialize\n");
1083+ return;
1084+ }
1085+ lowmem_phys_cursor = 0x100;
1086+
1087+ /* In Darwin, the mapping will fail if we put lowmem_phys_base to zero */
1088+ lowmem_phys_base = 0x100;
1089+ lowmem_mapping = map_phys_range( lowmem_phys_base, 0x4000, &lowmem_virt_base );
1090+}
1091+
1092+static char *
1093+lowmem_alloc( int size, cleanup_entry_t **ret_ce )
1094+{
1095+ ulong *pstart;
1096+ cleanup_entry_t ce;
1097+ int found=0;
1098+
1099+ memset( &ce, 0, sizeof(ce) );
1100+ if( ret_ce )
1101+ *ret_ce = NULL;
1102+
1103+ if( num_cleanup_entries >= MAX_NUM_CLEANUP_HANDLERS ) {
1104+ printk("MOL: Need more cleanup slots!\n");
1105+ return NULL;
1106+ }
1107+
1108+ /* Find big enough empty piece of memory */
1109+ if( size < 0x10 )
1110+ size = 0x10;
1111+
1112+ pstart = lowmem_phys_to_virt(lowmem_phys_cursor);
1113+ pstart = (ulong*)(((ulong)pstart + 0xf) & ~0xf);
1114+ for( ; lowmem_phys_cursor < 0x3000; lowmem_phys_cursor+=4 ) {
1115+ ulong *p = lowmem_phys_to_virt(lowmem_phys_cursor);
1116+ if( ((int)p - (int)pstart) >= size ) {
1117+ found = 1;
1118+ break;
1119+ }
1120+ if( *p ) {
1121+ pstart = (ulong*)(((ulong)p + sizeof(ulong) + 0xf) & ~0xf);
1122+ continue;
1123+ }
1124+ }
1125+ if( !found ) {
1126+ printk("MOL: Did not find an empty piece of lowmem memory!\n");
1127+ return NULL;
1128+ }
1129+ /* printk("lowmem alloc: %08lX\n", pstart ); */
1130+
1131+ ce.lowmem_addr = (char*)pstart;
1132+ ce.alloc_method = 0;
1133+ ce.alloc_size = size;
1134+ /* printk("lowmem-alloc SPACE %X bytes at %08lX\n", size, (ulong)pstart ); */
1135+
1136+ cleanup_table[num_cleanup_entries] = ce;
1137+ if( ret_ce )
1138+ *ret_ce = &cleanup_table[num_cleanup_entries];
1139+ num_cleanup_entries++;
1140+
1141+ return ce.lowmem_addr;
1142+}
1143+
1144+static void
1145+lowmem_free_all( void )
1146+{
1147+ cleanup_entry_t *ce = &cleanup_table[0];
1148+ int i;
1149+
1150+ for(i=0; i<num_cleanup_entries; i++, ce++ )
1151+ memset( ce->lowmem_addr, 0, ce->alloc_size );
1152+
1153+ num_cleanup_entries = 0;
1154+
1155+ if( lowmem_mapping ) {
1156+ unmap_phys_range( lowmem_mapping );
1157+ lowmem_mapping = NULL;
1158+ }
1159+}
1160+
1161+
1162+/************************************************************************/
1163+/* helper functions */
1164+/************************************************************************/
1165+
1166+static action_pb_t *
1167+find_action( int action, int index )
1168+{
1169+ extern int r__actions_offs_section[], r__actions_offs_section_end[];
1170+ extern char *r__actions_section[];
1171+ const int n = ((int)r__actions_offs_section_end - (int)r__actions_offs_section)/sizeof(int);
1172+ int i, *op = r__actions_offs_section;
1173+
1174+ for( i=0; i<n; i++ ) {
1175+ action_pb_t *p = (action_pb_t*)((char*)r__actions_section + op[i]);
1176+
1177+ if( p->action != action || index-- )
1178+ continue;
1179+ return p;
1180+ }
1181+ return NULL;
1182+}
1183+
1184+static int
1185+relocate_inst( ulong *opc_ptr, ulong from, ulong to )
1186+{
1187+ ulong opcode = *opc_ptr;
1188+ int offs=-1;
1189+
1190+ /* XXX: UNTESTED if target instruction is a branch */
1191+
1192+ /* Since we use this on the _first_ instruction of the
1193+ * exception vector, it can't touch LR/CR. Thus, we
1194+ * only look for unconditional, relative branches.
1195+ */
1196+
1197+ /* relativ branch b */
1198+ if( (opcode & 0xfc000003) == (18<<26) ){
1199+ offs = (opcode & 0x03fffffc);
1200+ /* sign extend */
1201+ if( offs & 0x03000000 )
1202+ offs |= ~0x03ffffff;
1203+ }
1204+ /* unconditional, relativ bc branch (b 0100 001z1zz ...) */
1205+ if( (opcode & 0xfe800003) == 0x42800000 ){
1206+ offs = (opcode & 0xfffc);
1207+ if( offs & 0x8000 )
1208+ offs |= ~0xffff;
1209+ }
1210+ /* construct the absolute branch */
1211+ if( offs != -1 ) {
1212+ int dest = from + offs;
1213+ if( dest < 0 || dest > 33554431 ) {
1214+ printk("relocation of branch at %08lX to %08lX failed\n", from, to);
1215+ return 1;
1216+ }
1217+ /* absolute branch */
1218+ *opc_ptr = ((18<<26) + 2) | dest;
1219+ }
1220+ return 0;
1221+}
1222+
1223+
1224+/************************************************************************/
1225+/* actions */
1226+/************************************************************************/
1227+
1228+typedef int (*action_func_t)( int action, ulong *target, const int *pb );
1229+
1230+static int
1231+action_li_phys( int action, ulong *target, const int *pb )
1232+{
1233+ int r = pb[0] & 0x1f;
1234+ ulong addr = pb[1] + tophys_mol( code_base );
1235+
1236+ /* target[0] = addis r,0,addr@h ; target[1] = ori r,r,addr@l */
1237+ target[0] = (15 << 26) | (r << 21) | (addr >> 16);
1238+ target[1] = (24 << 26) | (r << 21) | (r << 16) | (addr & 0xffff);
1239+
1240+ /* printk("ACTION_LI_PHYS %d %08lX\n", dreg, addr ); */
1241+ return 0;
1242+}
1243+
1244+static int
1245+action_lwz_physaddr_r( int action, ulong *target, const int *pb )
1246+{
1247+ ulong addr = pb[1] + tophys_mol( code_base );
1248+ int dr = (pb[0] >> 5) & 0x1f;
1249+ int r = pb[0] & 0x1f;
1250+ short low = (addr & 0xffff);
1251+
1252+ /* target[0] = addis dr,r,addr@h ; target[1] = lwz dr,addr@l(dr) */
1253+ target[0] = (15 << 26) | (dr << 21) | (r << 16) | ((addr - low) >> 16);
1254+ target[1] = (32 << 26) | (dr << 21) | (dr << 16) | ((int)low & 0xffff);
1255+
1256+ /* printk("ACTION_LI_PHYS %d %08lX\n", dreg, addr ); */
1257+ return 0;
1258+}
1259+
1260+static int
1261+action_specvar( int action, ulong *target, const int *pb )
1262+{
1263+ int r = pb[0] & 0x1f;
1264+ ulong addr;
1265+
1266+ switch( pb[1] ) {
1267+ case SPECVAR_SESSION_TABLE:
1268+ addr = tophys_mol(g_sesstab);
1269+ break;
1270+ default:
1271+ return 1;
1272+ }
1273+
1274+ if( action == ACTION_LIS_SPECVAR_H ) {
1275+ /* target[0] = addis r,0,addr@h */
1276+ target[0] = OPCODE_LIS( r, (addr >> 16) & 0xffff );
1277+ return 0;
1278+ }
1279+ if( action == ACTION_ORI_SPECVAR_L ) {
1280+ /* target[0] = ori rD,rS,addr@l */
1281+ int rD = (pb[0] >> 5) & 0x1f;
1282+ target[0] = OPCODE_ORI( rD, r, (addr & 0xffff));
1283+ return 0;
1284+ }
1285+ return 1;
1286+}
1287+
1288+
1289+/* Note: this only works under linux */
1290+static int
1291+action_tophysvirt( int action, ulong *target, const int *pb )
1292+{
1293+ ulong addr = tophys_mol(0);
1294+ int dr = (pb[0] >> 5) & 0x1f;
1295+ int sr = pb[0] & 0x1f;
1296+
1297+ if( action == ACTION_TOVIRT )
1298+ addr = -addr;
1299+
1300+ /* target[0] = addis dr,sr,(tophys(0))@hi */
1301+ target[0] = OPCODE_ADDIS( dr, sr, (addr >> 16) & 0xffff );
1302+ return 0;
1303+}
1304+
1305+/* pb[] = { vector, size, vret_offs, ...hook_code... } */
1306+static int
1307+action_reloc_hook( int action, ulong *hookcode, const int *pb )
1308+{
1309+ ulong addr, inst, vector=pb[0], size=pb[1], vret_offs=pb[2];
1310+ cleanup_entry_t *clean;
1311+ ulong *vector_virt, *target;
1312+ action_pb_t *apb;
1313+ char *lowmem;
1314+ int i;
1315+
1316+ /* Virtual address of exception vector */
1317+ vector_virt = lowmem_phys_to_virt(vector);
1318+
1319+ /* address of the vector hook code */
1320+ addr = tophys_mol( (char*)hookcode );
1321+
1322+ /* allocate lowmem and add cleanup handler */
1323+ if( !(lowmem=lowmem_alloc(size, &clean)) )
1324+ return 1;
1325+
1326+ /* printk("ACTION_RELOC_HOOK: %lx, %lx, %lx, %lx %p\n", vector, size, vret_action, vret_offs, lowmem); */
1327+
1328+ memcpy( lowmem, &pb[3], size );
1329+
1330+ /* perform the vret_action */
1331+ for( i=0; (apb=find_action(ACTION_VRET, i)); i++ ) {
1332+ if( apb->params[0] != vector )
1333+ continue;
1334+
1335+ /* insert the absolut branch */
1336+ target = (ulong*)(code_base + apb->offs);
1337+ *target = ((18<<26) + 2) | lowmem_tophys(lowmem + vret_offs);
1338+ flush_icache_mol( (ulong)target, (ulong)target + 4 );
1339+ /* printk("'ba xxx' added (opcode %08lX at %p)\n", *target, target ); */
1340+ }
1341+
1342+ /* fix the hook address in the glue code */
1343+ target = (ulong*)lowmem;
1344+ target[1] = (target[1] & ~0xffff) | (addr >> 16); /* target[0] = addis r3,0,0 */
1345+ target[3] = (target[3] & ~0xffff) | (addr & 0xffff); /* target[1] = ori r3,r3,0 */
1346+
1347+ /* relocate instruction to be overwritten with a branch */
1348+ inst = *vector_virt;
1349+ clean->opcode = inst;
1350+ if( relocate_inst( &inst, vector, lowmem_tophys(lowmem+vret_offs) ))
1351+ return 1;
1352+ *(ulong*)(lowmem + vret_offs) = inst;
1353+ flush_icache_mol( (ulong)lowmem, (ulong)lowmem + size );
1354+
1355+ /* insert branch, 'ba lowmem_ph' */
1356+ *(volatile ulong*)vector_virt = 0x48000002 + lowmem_tophys(lowmem);
1357+ flush_icache_mol( (ulong)vector_virt, (ulong)vector_virt+4 );
1358+
1359+ /* we are in business! */
1360+ clean->inst_addr = vector_virt;
1361+ return 0;
1362+}
1363+
1364+
1365+/* pb = { size, where_to_store_lowmem_addr, ...code... } */
1366+static int
1367+action_reloc_low( int action, ulong *dummy, const int *pb )
1368+{
1369+ int size = pb[0];
1370+ char **func_ptr = (char**)pb[1];
1371+ char *lowmem;
1372+
1373+ if( !(lowmem=lowmem_alloc(size, NULL)) )
1374+ return 1;
1375+ memcpy( lowmem, (char*)&pb[2], size );
1376+
1377+ flush_icache_mol( (ulong)lowmem, (ulong)lowmem+size );
1378+ *func_ptr = lowmem;
1379+ return 0;
1380+}
1381+
1382+/* pb = { symind, size, fret_offset, codeglue... } */
1383+static int
1384+action_hook_function( int action, ulong *hookcode, const int *pb )
1385+{
1386+ ulong addr, fhook=pb[0], size=pb[1], fret_offs=pb[2];
1387+ ulong *target, inst;
1388+ char *lowmem, *func_addr=NULL;
1389+ cleanup_entry_t *clean;
1390+
1391+ switch( fhook ) {
1392+#ifdef __linux__
1393+ case FHOOK_FLUSH_HASH_PAGE:
1394+ func_addr = (char*)compat_flush_hash_pages;
1395+ break;
1396+#endif
1397+ default:
1398+ printk("Bad fhook index %ld\n", fhook );
1399+ return 1;
1400+ }
1401+
1402+ /* this does not have to be in lowmem, but it is simpler with a unified approach */
1403+ if( !(lowmem=lowmem_alloc(size, &clean)) )
1404+ return 1;
1405+
1406+ /* printk("ACTION_HOOK_FUNCTION: %lx, %lx, %lx %p\n", fhook, size, fret_offs, lowmem); */
1407+
1408+ memcpy( lowmem, &pb[3], size );
1409+
1410+ /* fix the hook address in the glue code */
1411+ target = (ulong*)lowmem;
1412+ addr = (ulong)hookcode;
1413+ target[1] = (target[1] & ~0xffff) | (addr >> 16); /* target[1] = addis rX,0,0 */
1414+ target[2] = (target[2] & ~0xffff) | (addr & 0xffff); /* target[2] = ori rX,rX,0 */
1415+
1416+ /* relocate overwritten instruction and add relative return branch */
1417+ inst = *(ulong*)func_addr;
1418+ clean->opcode = inst;
1419+ if( relocate_inst(&inst, (ulong)func_addr, (ulong)lowmem + fret_offs) )
1420+ return 1;
1421+ target = (ulong*)(lowmem + fret_offs);
1422+ target[0] = inst;
1423+ target[1] = (18<<26) | (((ulong)func_addr - (ulong)&target[1] + sizeof(long)) & 0x03fffffc);
1424+ flush_icache_mol( (ulong)lowmem, (ulong)lowmem + size );
1425+ _sync();
1426+
1427+ /* insert relative branch, 'b lowmem' */
1428+ *(volatile ulong*)func_addr = (18<<26) | ((lowmem - func_addr) & 0x03fffffc);
1429+ flush_icache_mol( (ulong)func_addr, (ulong)func_addr+4 );
1430+
1431+ _sync();
1432+
1433+ /* we are in business! */
1434+ clean->inst_addr = (ulong*)func_addr;
1435+ return 0;
1436+}
1437+
1438+static int
1439+action_fix_sprg2( int action, ulong *target, const int *pb )
1440+{
1441+#ifdef __darwin__
1442+ int sprg2;
1443+ int r = pb[0] & 0x1f;
1444+ asm volatile("mfspr %0,274" : "=r" (sprg2) );
1445+ target[0] = OPCODE_LIS( r, (sprg2 >> 16) & 0xffff );
1446+ target[1] = OPCODE_ORI( r, r, (sprg2 & 0xffff) );
1447+ target[2] = OPCODE_MTSPRG2( r );
1448+#endif
1449+ return 0;
1450+}
1451+
1452+static int
1453+action_noaction( int action, ulong *hookcode, const int *pb )
1454+{
1455+ return 0;
1456+}
1457+
1458+static action_func_t actiontable[MAX_NUM_ACTIONS] = {
1459+ [ACTION_LI_PHYS] = action_li_phys,
1460+ [ACTION_LWZ_PHYSADDR_R] = action_lwz_physaddr_r,
1461+ [ACTION_TOPHYS] = action_tophysvirt,
1462+ [ACTION_TOVIRT] = action_tophysvirt,
1463+ [ACTION_RELOC_HOOK] = action_reloc_hook,
1464+ [ACTION_RELOCATE_LOW] = action_reloc_low,
1465+ [ACTION_HOOK_FUNCTION] = action_hook_function,
1466+ [ACTION_VRET] = action_noaction,
1467+ [ACTION_FIX_SPRG2] = action_fix_sprg2,
1468+
1469+ [ACTION_LIS_SPECVAR_H] = action_specvar,
1470+ [ACTION_ORI_SPECVAR_L] = action_specvar,
1471+};
1472+
1473+
1474+/************************************************************************/
1475+/* write/remove hooks */
1476+/************************************************************************/
1477+
1478+static int
1479+relocate_code( void )
1480+{
1481+ extern char r__reloctable_start[], r__reloctable_end[];
1482+
1483+ code_size = r__reloctable_end - r__reloctable_start;
1484+
1485+ if( !(code_base=kmalloc_cont_mol(code_size)) )
1486+ return 1;
1487+
1488+ memcpy( code_base, r__reloctable_start, code_size );
1489+ reloc_virt_offs = (int)code_base - (int)r__reloctable_start;
1490+ return 0;
1491+}
1492+
1493+int
1494+perform_actions( void )
1495+{
1496+ action_pb_t *pb;
1497+ int action, i;
1498+
1499+ if( relocate_code() )
1500+ return 1;
1501+ lowmem_initialize();
1502+
1503+ for( action=0; action < MAX_NUM_ACTIONS; action++ ) {
1504+ for( i=0; (pb=find_action(action,i)); i++ ) {
1505+ ulong *target = (ulong*)(code_base + pb->offs);
1506+
1507+ if( pb->offs > code_size ) {
1508+ printk("OFFSET ERROR!\n");
1509+ goto error;
1510+ }
1511+
1512+ if( !actiontable[action] )
1513+ goto error;
1514+ if( (*actiontable[action])(action, target, pb->params) )
1515+ goto error;
1516+ }
1517+
1518+ /* we need to flush the icache before the hook actions are performed */
1519+ if( action == FLUSH_CACHE_ACTION )
1520+ flush_icache_mol( (ulong)code_base, (ulong)code_base + code_size );
1521+ }
1522+ /* to be on the safe side, flush the cache once more */
1523+ flush_icache_mol( (ulong)code_base, (ulong)code_base + code_size );
1524+ return 0;
1525+ error:
1526+ printk("MOL: action %d error\n", action );
1527+ cleanup_actions();
1528+ return 1;
1529+}
1530+
1531+void
1532+cleanup_actions( void )
1533+{
1534+ cleanup_entry_t *ce = &cleanup_table[0];
1535+ int i;
1536+
1537+ for( i=0; i<num_cleanup_entries; i++, ce++ ) {
1538+ if( ce->inst_addr ) {
1539+ *(volatile ulong*)ce->inst_addr = cleanup_table[i].opcode;
1540+ flush_icache_mol( (ulong)ce->inst_addr, (ulong)ce->inst_addr + 4 );
1541+ }
1542+ }
1543+ lowmem_free_all();
1544+ kfree_cont_mol( code_base );
1545+}
1546--- /dev/null
1547+++ b/drivers/macintosh/mol/asm-files/603.S
1548@@ -0,0 +1,218 @@
1549+/*
1550+ * Creation Date: <2001/06/15 20:10:49 samuel>
1551+ * Time-stamp: <2001/06/16 15:35:22 samuel>
1552+ *
1553+ * <603.S>
1554+ *
1555+ * 603 MMU support
1556+ *
1557+ * Copyright (C) 2001 Samuel Rydh (samuel@ibrium.se)
1558+ *
1559+ * This program is free software; you can redistribute it and/or
1560+ * modify it under the terms of the GNU General Public License
1561+ * as published by the Free Software Foundation
1562+ *
1563+ */
1564+
1565+#define P603_USE_G_BIT
1566+#define P603_USE_R_BIT
1567+#define P603_USE_C_BIT
1568+
1569+/* NOTE: The 603 vectors are called with ctr saved in r0.
1570+ * Secondary interrupts are not detected automatically.
1571+ */
1572+
1573+/************************************************************************/
1574+/* Instruction TLB Miss (603 specific vector) */
1575+/************************************************************************/
1576+
1577+VECTOR_603( 0x1000, "Instruction TLB Miss - 603" )
1578+// mfctr r0 // Need to save this - CTR can't be touched!
1579+ mfspr r2,HASH1 // Get PTE pointer
1580+ mfspr r3,ICMP // Partial item compare value
1581+00: li r1,8 // 8 items / bucket
1582+ mtctr r1
1583+ subi r2,r2,8 // Preset pointer
1584+10: lwzu r1,8(r2) // Get next PTE
1585+ cmp 0,r1,r3 // Found entry yet?
1586+ bdnzf 2,10b // Jump back if not, until CTR==0
1587+ bne 30f // Try secondary hash if CTR==0
1588+ lwz r1,4(r2) // Get second word of entry
1589+#ifdef P603_USE_G_BIT
1590+ andi. r3,r1,8 // check G-bit
1591+ bne DoISI_603_G // if guarded, take an ISI
1592+#endif
1593+ mtctr r0 // Restore CTR
1594+ mfspr r3,SRR1 // Need to restore CR0
1595+ mtcrf 0x80,r3
1596+ mfspr r0,IMISS // Set to update TLB
1597+ mtspr RPA,r1
1598+#ifdef P603_USE_R_BIT
1599+ ori r1,r1,0x100 // Set reference bit
1600+ srwi r1,r1,8 // Get byte 7 of pte
1601+ tlbli r0 // Load the ITLB
1602+ stb r1,6(r2) // update page table
1603+#else
1604+ tlbli r0 // Load the ITLB
1605+#endif
1606+ rfi // All done
1607+
1608+ // Secondary hash
1609+30: andi. r1,r3,0x40 // Already doing secondary hash?
1610+ bne DoISI_603 // Yes - item not in hash table
1611+ mfspr r2,HASH2 // Get hash table pointer
1612+ ori r3,r3,0x40 // Set secondary hash
1613+ b 00b // Try lookup again
1614+
1615+
1616+/************************************************************************/
1617+/* Data Store TLB Miss (603 specific vector) */
1618+/************************************************************************/
1619+
1620+VECTOR_603( 0x1200, "Data Store TLB Miss - 603" )
1621+// mfctr r0 // Need to save this - CTR can't be touched!
1622+ mfspr r2,HASH1 // Get PTE pointer
1623+ mfspr r3,DCMP // Partial item compare value
1624+00: li r1,8 // 8 items / bucket
1625+ mtctr r1
1626+ subi r2,r2,8 // Preset pointer
1627+10: lwzu r1,8(r2) // Get next PTE
1628+ cmp 0,r1,r3 // Found entry yet?
1629+ bdnzf 2,10b // Jump back if not, until CTR==0
1630+ bne 30f // Try secondary hash if CTR==0
1631+ lwz r1,4(r2) // Get second word of entry
1632+#ifdef P603_USE_C_BIT
1633+ andi. r3,r1,0x80 // Check the C-bit
1634+ beq CheckProt_603
1635+16:
1636+#endif
1637+20: mtctr r0 // Restore CTR
1638+ mfspr r3,SRR1 // Need to restore CR0
1639+ mtcrf 0x80,r3
1640+ mfspr r0,DMISS // Set to update TLB
1641+ mtspr RPA,r1
1642+ tlbld r0
1643+ rfi // All done
1644+
1645+ // Secondary hash
1646+30: andi. r1,r3,0x40 // Already doing secondary hash?
1647+ bne DoDSI_603 // Yes - item not in hash table
1648+ mfspr r2,HASH2 // Get hash table pointer
1649+ ori r3,r3,0x40 // Set secondary hash
1650+ b 00b // Try lookup again
1651+
1652+#ifdef P603_USE_C_BIT
1653+ // Entry found and PTE[c] == 0. Check protection before setting PTE[c]
1654+ // r0 = saved ctr, r1 = second word of PTE, r2 = pointer to pteg, r3 = trash
1655+CheckProt_603:
1656+ rlwinm. r3,r1,30,0,1 // test PP
1657+ bge- 50f // if (PP == 00 or PP == 01) goto 50
1658+ andi. r3,r1,1 // test PP[0]
1659+ beq+ 60f // return if PP[0] == 0
1660+ b DoDSI_603_P // else DSI_P, (PP==11, read-only)
1661+
1662+50: mfspr r3,SRR1 // get old msr
1663+ andis. r3,r3,0x0008 // test the KEY bit (SRR1-bit 12)
1664+ beq 60f // if KEY==0, goto 60
1665+ b DoDSI_603_P // else DSI_P
1666+
1667+60: ori r1,r1,0x180 // set reference and change bit
1668+ sth r1,6(r2) // update page table
1669+ b 16b // and back we go
1670+#endif
1671+
1672+
1673+/************************************************************************/
1674+/* Data Load TLB Miss (603 specific vector) */
1675+/************************************************************************/
1676+
1677+VECTOR_603( 0x1100, "Data Load TLB Miss - 603" )
1678+// mfctr r0 // Need to save this - CTR can't be touched!
1679+ mfspr r2,HASH1 // Get PTE pointer
1680+ mfspr r3,DCMP // Partial item compare value
1681+00: li r1,8 // 8 items / bucket
1682+ mtctr r1
1683+ subi r2,r2,8 // Preset pointer
1684+10: lwzu r1,8(r2) // Get next PTE
1685+ cmp 0,r1,r3 // Found entry yet?
1686+ bdnzf 2,10b // Jump back if not, until CTR==0
1687+ bne 30f // Try secondary hash if CTR==0
1688+ lwz r1,4(r2) // Get second word of entry
1689+20: mtctr r0 // Restore CTR
1690+ mfspr r3,SRR1 // Need to restore CR0
1691+ mtcrf 0x80,r3
1692+ mfspr r0,DMISS // Set to update TLB
1693+ mtspr RPA,r1
1694+#ifdef P603_USE_R_BIT
1695+ ori r1,r1,0x100 // set reference bit
1696+ srwi r1,r1,8
1697+ tlbld r0
1698+ stb r1,6(r2)
1699+#else
1700+ tlbld r0
1701+#endif
1702+ rfi // All done
1703+
1704+// Secondary hash
1705+30: andi. r1,r3,0x40 // Already doing secondary hash?
1706+ bne DoDSI_603 // Yes - item not in hash table
1707+ mfspr r2,HASH2 // Get hash table pointer
1708+ ori r3,r3,0x40 // Set secondary hash
1709+ b 00b // Try lookup again
1710+
1711+
1712+/************************************************************************/
1713+/* Synthesize an ISI Exception */
1714+/************************************************************************/
1715+
1716+DoISI_603:
1717+ mfspr r3,SRR1
1718+ andi. r2,r3,0xFFFF // Clear upper bits of SRR1
1719+ addis r2,r2,0x4000 // Set bit 1 -> PTE not found (in HTAB)
1720+ mtctr r0 // Restore CTR
1721+40: mtspr SRR1,r2
1722+ mfmsr r0 // Restore "normal" registers
1723+ xoris r0,r0,MSR_TGPR>>16
1724+ mtcrf 0x80,r3 // Restore CR0
1725+ sync // Some chip revs have problems here...
1726+ mtmsr r0
1727+ SOFT_VECTOR_ENTRY_603( 0x400 ) // Jump to the ISI vector
1728+
1729+
1730+#ifdef P603_USE_G_BIT
1731+DoISI_603_G:
1732+ mfspr r3,SRR1
1733+ andi. r2,r3,0xFFFF // Clear upper bits of SRR1
1734+// addis r2,r2,0x0800 // Page protection violation
1735+ addis r2,r2,0x1000 // Guarded memory access
1736+ b 40b
1737+#endif
1738+
1739+
1740+/************************************************************************/
1741+/* Synthesize a DSI exception */
1742+/************************************************************************/
1743+
1744+DoDSI_603:
1745+ mfspr r3,SRR1
1746+ rlwinm r1,r3,9,6,6 // Get load/store bit
1747+ addis r1,r1,0x4000 // Set bit 1 -> PTE not found
1748+
1749+10: mtspr DSISR,r1
1750+ mtctr r0 // Restore CTR
1751+ andi. r2,r3,0xFFFF // Clear upper bits of SRR1
1752+ mtspr SRR1,r2
1753+ mfspr r1,DMISS // Get failing address
1754+ mtspr DAR,r1 // Set fault address
1755+ mfmsr r0 // Restore "normal" registers
1756+ xoris r0,r0,MSR_TGPR>>16
1757+ mtcrf 0x80,r3 // Restore CR0
1758+ sync // Some chip revs have problems here...
1759+ mtmsr r0
1760+ SOFT_VECTOR_ENTRY_603( 0x300 ) // Jump to the DSI vector
1761+
1762+DoDSI_603_P:
1763+ mfspr r3,SRR1
1764+ rlwinm r1,r3,9,6,6 // get load/store bit
1765+ addis r1,r1,0x800 // Set bit 4 (prot. violation)
1766+ b 10b
1767--- /dev/null
1768+++ b/drivers/macintosh/mol/asm-files/dec.S
1769@@ -0,0 +1,228 @@
1770+/*
1771+ * Creation Date: <2001/06/21 17:10:35 samuel>
1772+ * Time-stamp: <2004/03/07 13:16:58 samuel>
1773+ *
1774+ * <dec.S>
1775+ *
1776+ * DEC / TimeBase stuff
1777+ *
1778+ * Copyright (C) 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
1779+ *
1780+ * This program is free software; you can redistribute it and/or
1781+ * modify it under the terms of the GNU General Public License
1782+ * as published by the Free Software Foundation
1783+ *
1784+ */
1785+
1786+/************************************************************************/
1787+/* TBWU / TBWL */
1788+/************************************************************************/
1789+
1790+#if 0
1791+spr_tbwu:
1792+ blr // read (won't come here)
1793+ mr r3,r0
1794+ mftb r4
1795+ b update_tb
1796+
1797+spr_tbwl:
1798+ blr // read (won't come here)
1799+ mftbu r3
1800+ mr r4,r0
1801+ // ...fall through...
1802+
1803+// r3 = tbu, r4 = tbl, r0,r2,r5 free.
1804+update_tb:
1805+ lwz r5,K_LOADED_DEC(r1)
1806+ mfdec r2
1807+ sub r5,r5,r2 // r5 = elapsed ticks
1808+
1809+ li r2,0 // Set timebase
1810+ mttbl r4
1811+ mttbu r3
1812+ mttbl r4
1813+
1814+ mfxer r2
1815+ subfc r4,r5,r4
1816+ addme r3,r3
1817+ stw r4,xTBL(r1)
1818+ stw r3,xTBU(r1)
1819+ mtxer r2
1820+ b emulation_done
1821+#endif
1822+
1823+
1824+/************************************************************************/
1825+/* Load/restore DEC and TB */
1826+/************************************************************************/
1827+
1828+ //////////////////////////////////////////////////////////////
1829+ // recalc_int_stamp
1830+ //
1831+ // May modify: r0,r2-r5
1832+ //
1833+
1834+recalc_int_stamp:
1835+ crclr FBIT_RecalcDecInt
1836+
1837+ lwz r5,xTIMER_STAMP(r1)
1838+ bf FBIT_DecSeenZero, 1f // FBIT_DecSeenZero must be set when DEC is loaded
1839+ bt FBIT_DecINT, 1f // interrupt might already be flagged...
1840+ mftb r3
1841+ lwz r4,xDEC_STAMP(r1) // Has the xDEC overflown already?
1842+ sub. r0,r4,r3
1843+ blt 2f // branch if xDEC < 0
1844+ sub. r0,r4,r5
1845+ blt 2f // branch if xDEC < xTIMER
1846+1: mr r4,r5
1847+2: stw r4,K_INT_STAMP(r1) // dec = xTIMER
1848+ blr
1849+
1850+
1851+ //////////////////////////////////////////////////////////////
1852+ // set_mol_dec
1853+ //
1854+ // May modify: r0,r2-r5
1855+ //
1856+ // Old 2.4 kernels assume that linux-DEC never ticks faster
1857+ // than the DEC interval measured from TB. Unfortunately,
1858+ // it is virtually impossible to keep DEC/TB in sync.
1859+ //
1860+ // Experimentally, the "worst case" senario is a linux DEC tick
1861+ // beeing delayed 0.04 ms (to be compare with the 20 ms period).
1862+ //
1863+ // Sequences similar to
1864+ //
1865+ // 1: mftb r2; mfdec r3; mftb r4; cmp r2,r4; bne 1b
1866+ //
1867+ // do *not* work - DEC and TB probably ticks on different edges.
1868+
1869+set_mol_dec:
1870+ lwz r5,K_INT_STAMP(r1) // DEC = K_INT_STAMP - tbl
1871+ mfdec r3 // Make sure linux interrupts *never*
1872+ mftb r2 // occur too fast
1873+
1874+ sub r4,r5,r2
1875+ cmpw r4,r3
1876+ bgtlr
1877+ add r5,r3,r2 // K_DEC_STAMP = DEC + tbl
1878+ mtdec r4
1879+
1880+ stw r5,K_DEC_STAMP(r1)
1881+ crset FBIT_MolDecLoaded
1882+ blr
1883+
1884+ ///////////////////////////////////////////////////////////////
1885+ // set_kernel_dec
1886+ //
1887+ // May modify: r0,r2, cr
1888+ //
1889+
1890+set_kernel_dec:
1891+ lwz r0,K_DEC_STAMP(r1)
1892+ crclr FBIT_MolDecLoaded
1893+ mftb r2 // Keep linux-DEC coherent
1894+ sub r2,r0,r2 // DEC = stamp - tbl
1895+ mtdec r2
1896+ blr
1897+
1898+
1899+
1900+/************************************************************************/
1901+/* DEC read/write */
1902+/************************************************************************/
1903+
1904+_dec_read:
1905+ lwz r4,xDEC_STAMP(r1)
1906+ mftb r3
1907+ sub r0,r4,r3
1908+
1909+ BUMP("dec_read")
1910+ GET_TICK_CNT(entry,"dec_read")
1911+ b simple_mfspr
1912+
1913+spr_dec:
1914+ b _dec_read
1915+
1916+ // dec write. r0 = spr_value
1917+ BUMP("mtdec")
1918+ rlwinm. r5,r0,0,0,0 // seen zero?
1919+ mftb r4
1920+ cror FBIT_DecSeenZero,FBIT_DecSeenZero,eq
1921+ add r5,r4,r0
1922+ stw r5,xDEC_STAMP(r1) // set new dec value
1923+ bf FBIT_DecSeenZero, emulation_done
1924+ bl recalc_int_stamp // M: r0,r2-r5
1925+ btl FBIT_MolDecLoaded, set_kernel_dec // M: r0,r2
1926+ bl set_mol_dec // M: r0,r2-r5
1927+ b emulation_done
1928+
1929+
1930+/************************************************************************/
1931+/* Decrementer Exception */
1932+/************************************************************************/
1933+
1934+ // __dec_VECTOR (non-MOL dec exception)
1935+ //
1936+ // r3=cr, sprg1=saved_r1, sprg0=saved_r3
1937+ //
1938+ // An exception with DEC>=0 can occur if a mac-DEC overflows occurs
1939+ // just prior to a context switch. These exceptions should be
1940+ // dropped silently.
1941+
1942+__dec_VECTOR:
1943+ mfdec r1
1944+ cmpwi r1,0
1945+ blt+ 1f
1946+ mtcr r3 // Restore and exit
1947+ ABORT_TRAP( 0x900 )
1948+1:
1949+ mtcr r3 // Restore and continue trap
1950+ CONTINUE_TRAP( 0x900 )
1951+
1952+VECTOR_( 0x900, "Decrementer", secint_bad, __dec_VECTOR )
1953+ EXCEPTION_PREAMBLE // r0-r5, CR, LR, r6/r7 = msr/nip
1954+ TRACE(0x900, "Decrementer")
1955+ mfdec r4
1956+ cmpwi r4,0
1957+ bge exception_return
1958+ bf FBIT_MolDecLoaded, take_linux_dec_exception
1959+
1960+ mftb r3
1961+ lis r2,0x1000 // r2 = DEC rearm constant
1962+
1963+ bf FBIT_DecSeenZero, 1f // check for xDEC overflow
1964+ lwz r4,xDEC_STAMP(r1)
1965+ sub. r0,r4,r3 // lt set if xDEC has overflown
1966+ cror FBIT_DecINT, FBIT_DecINT, lt // dec_int |= lt
1967+ crandc FBIT_DecSeenZero, FBIT_DecSeenZero, lt // szero &= ~lt
1968+1:
1969+ lwz r5,xTIMER_STAMP(r1) // r5 = xTIMER_STAMP
1970+ sub. r0,r5,r3 // lt set if xTIMER has overflown
1971+ mtdec r2 // rearm DEC
1972+ blt- 2f // xTIMER has higher priority...
1973+
1974+ // mac-dec interrupt
1975+ BUMP("DEC-overflow")
1976+ bl set_kernel_dec
1977+ bl recalc_int_stamp
1978+ bl set_mol_dec
1979+ GET_TICK_CNT(entry,"dec-overflow")
1980+ bf- FBIT_DecINT,exception_return // could occur if xTIMER has changed on us
1981+ lwz r4,xMSR(r1)
1982+ rlwinm. r0,r4,0,MSR_EE
1983+ beq- exception_return // no... simply return
1984+ BUMP("DEC-exception")
1985+ b mac_dec_trap
1986+
1987+ // timer interrupt
1988+2: BUMP("Timer-interrupt")
1989+ crset FBIT_RecalcDecInt // dec must be recalced
1990+ GET_TICK_CNT(entry,"timer-overflow")
1991+ MAC_EXIT_SAVE( RVEC_TIMER )
1992+
1993+
1994+take_linux_dec_exception:
1995+ BUMP("Linux-DEC")
1996+ bl save_middle_regs
1997+ TAKE_EXCEPTION( 0x900 )
1998--- /dev/null
1999+++ b/drivers/macintosh/mol/asm-files/emuaccel.S
2000@@ -0,0 +1,188 @@
2001+/*
2002+ * Creation Date: <2003/01/24 13:54:52 samuel>
2003+ * Time-stamp: <2003/08/14 03:12:00 samuel>
2004+ *
2005+ * <emuaccel.S>
2006+ *
2007+ * Emulation acceleration
2008+ *
2009+ * Copyright (C) 2003, 2004 Samuel Rydh (samuel@ibrium.se)
2010+ *
2011+ * This program is free software; you can redistribute it and/or
2012+ * modify it under the terms of the GNU General Public License
2013+ * as published by the Free Software Foundation
2014+ *
2015+ */
2016+
2017+#include "emuaccel_sh.h"
2018+
2019+ // emuaccel registers:
2020+ //
2021+ // r2 = emuaccel_slot
2022+ // r6,r7 = nip(return address)/mregs
2023+ //
2024+
2025+ balign_8
2026+emuaccel_mtmsr_rNN:
2027+mFORLOOP([i],0,31,[
2028+ LOAD_EMUGPR_IM r0,i
2029+ b emulate_mtmsr_accel
2030+])
2031+emuaccel_mtsrr0_rNN:
2032+mFORLOOP([i],0,31,[
2033+ .if (i <= 7)
2034+ LOAD_EMUGPR_IM r0,i
2035+ b emulate_mtsrr0_accel
2036+ .else
2037+ stw rPREFIX[]i,xSRR0(r1)
2038+ b emulation_done_noinc
2039+ .endif
2040+])
2041+emuaccel_mtsrr1_rNN:
2042+mFORLOOP([i],0,31,[
2043+ .if (i <= 7)
2044+ LOAD_EMUGPR_IM r0,i
2045+ b emulate_mtsrr1_accel
2046+ .else
2047+ stw rPREFIX[]i,xSRR1(r1)
2048+ b emulation_done_noinc
2049+ .endif
2050+])
2051+emuaccel_mtsprg0_rNN:
2052+mFORLOOP([i],0,31,[
2053+ .if (i <= 7)
2054+ LOAD_EMUGPR_IM r0,i
2055+ b emulate_mtsprg0_accel
2056+ .else
2057+ stw rPREFIX[]i,xSPRG0(r1)
2058+ b emulation_done_noinc
2059+ .endif
2060+])
2061+emuaccel_mtsprg1_rNN:
2062+mFORLOOP([i],0,31,[
2063+ .if (i <= 7)
2064+ LOAD_EMUGPR_IM r0,i
2065+ b emulate_mtsprg1_accel
2066+ .else
2067+ stw rPREFIX[]i,xSPRG1(r1)
2068+ b emulation_done_noinc
2069+ .endif
2070+])
2071+emuaccel_mtsprg2_rNN:
2072+mFORLOOP([i],0,31,[
2073+ .if (i <= 7)
2074+ LOAD_EMUGPR_IM r0,i
2075+ b emulate_mtsprg2_accel
2076+ .else
2077+ stw rPREFIX[]i,xSPRG2(r1)
2078+ b emulation_done_noinc
2079+ .endif
2080+])
2081+emuaccel_mtsprg3_rNN:
2082+mFORLOOP([i],0,31,[
2083+ .if (i <= 7)
2084+ LOAD_EMUGPR_IM r0,i
2085+ b emulate_mtsprg3_accel
2086+ .else
2087+ stw rPREFIX[]i,xSPRG3(r1)
2088+ b emulation_done_noinc
2089+ .endif
2090+])
2091+emuaccel_mthid0_rNN:
2092+mFORLOOP([i],0,31,[
2093+ .if (i <= 7)
2094+ LOAD_EMUGPR_IM r0,i
2095+ b emulate_mthid0_accel
2096+ .else
2097+ stw rPREFIX[]i,xHID0(r1)
2098+ b emulation_done_noinc
2099+ .endif
2100+])
2101+
2102+emuaccel_nop:
2103+ b emulation_done_noinc
2104+
2105+emuaccel_rfi:
2106+ addi r6,r6,-4 // point nip to the rfi instruction
2107+ b emulate_rfi
2108+
2109+emuaccel_update_dec:
2110+ lwz r4,xDEC_STAMP(r1)
2111+ mftb r3
2112+ sub r0,r4,r3
2113+ stw r0,xDEC(r1)
2114+ b emulation_done_noinc
2115+
2116+ balign_8
2117+emuaccel_mtsr:
2118+ lwz r4,12(r2) // emuaccel paramamter (opcode)
2119+ addi r6,r6,-4 // back NIP
2120+ rlwinm r5,r4,14,24,28 // reg_num << 3
2121+ b emulate_mtsr
2122+
2123+
2124+/************************************************************************/
2125+/* implementation */
2126+/************************************************************************/
2127+
2128+emulate_mtsrr0_accel:
2129+ stw r0,xSRR0(r1)
2130+ b emulation_done_noinc
2131+emulate_mtsrr1_accel:
2132+ stw r0,xSRR1(r1)
2133+ b emulation_done_noinc
2134+emulate_mtsprg0_accel:
2135+ stw r0,xSPRG0(r1)
2136+ b emulation_done_noinc
2137+emulate_mtsprg1_accel:
2138+ stw r0,xSPRG1(r1)
2139+ b emulation_done_noinc
2140+emulate_mtsprg2_accel:
2141+ stw r0,xSPRG2(r1)
2142+ b emulation_done_noinc
2143+emulate_mtsprg3_accel:
2144+ stw r0,xSPRG3(r1)
2145+ b emulation_done_noinc
2146+emulate_mthid0_accel:
2147+ stw r0,xHID0(r1)
2148+ b emulation_done_noinc
2149+
2150+ balign_32
2151+emulate_mtmsr_accel:
2152+ lwz r3,xMSR(r1) // r3 = old MSR
2153+ bl msr_altered
2154+
2155+ GET_TICK_CNT(entry, "mtmsr-accel")
2156+ BUMP("emulate_mtmsr-accel")
2157+
2158+ beq+ cr1,emulation_done_noinc // no doze... we are done
2159+ MAC_EXIT_SAVE( RVEC_MSR_POW ) // doze
2160+
2161+
2162+
2163+/************************************************************************/
2164+/* setup */
2165+/************************************************************************/
2166+
2167+#define EMUACCEL_REL(s) s - emuaccel_table
2168+
2169+#ifdef __linux__
2170+ .text 70 /* this table does not need to be relocated */
2171+#endif
2172+ // format: emuaccel_inst, offset, table_index_mask
2173+GLOBAL_SYMBOL(emuaccel_table):
2174+ .long EMUACCEL_MTMSR, EMUACCEL_REL( emuaccel_mtmsr_rNN ), 0x1f
2175+ .long EMUACCEL_MTSRR0, EMUACCEL_REL( emuaccel_mtsrr0_rNN ), 0x1f
2176+ .long EMUACCEL_MTSRR1, EMUACCEL_REL( emuaccel_mtsrr1_rNN ), 0x1f
2177+ .long EMUACCEL_MTSPRG0, EMUACCEL_REL( emuaccel_mtsprg0_rNN ), 0x1f
2178+ .long EMUACCEL_MTSPRG1, EMUACCEL_REL( emuaccel_mtsprg1_rNN ), 0x1f
2179+ .long EMUACCEL_MTSPRG2, EMUACCEL_REL( emuaccel_mtsprg2_rNN ), 0x1f
2180+ .long EMUACCEL_MTSPRG3, EMUACCEL_REL( emuaccel_mtsprg3_rNN ), 0x1f
2181+ .long EMUACCEL_MTHID0, EMUACCEL_REL( emuaccel_mthid0_rNN ), 0x1f
2182+ .long EMUACCEL_RFI, EMUACCEL_REL( emuaccel_rfi ), 0
2183+ .long EMUACCEL_UPDATE_DEC, EMUACCEL_REL( emuaccel_update_dec ), 0
2184+ .long EMUACCEL_MTSR, EMUACCEL_REL( emuaccel_mtsr ), 0
2185+ .long EMUACCEL_NOP, EMUACCEL_REL( emuaccel_nop ), 0
2186+ .long 0, 0, 0 /* end marker */
2187+
2188+ .text
2189--- /dev/null
2190+++ b/drivers/macintosh/mol/asm-files/emulation.S
2191@@ -0,0 +1,714 @@
2192+/*
2193+ * Creation Date: <97/07/26 18:23:02 samuel>
2194+ * Time-stamp: <2004/02/22 13:12:14 samuel>
2195+ *
2196+ * <emulation.S>
2197+ *
2198+ * Low-level emulation of some privileged instructions
2199+ *
2200+ * Copyright (C) 1997-2004 Samuel Rydh (samuel@ibrium.se)
2201+ *
2202+ * This program is free software; you can redistribute it and/or
2203+ * modify it under the terms of the GNU General Public License
2204+ * as published by the Free Software Foundation
2205+ *
2206+ */
2207+
2208+MACRO_0(INC_NIP, [
2209+ addi r6,r6,4
2210+])
2211+
2212+
2213+/************************************************************************/
2214+/* program exception vector */
2215+/************************************************************************/
2216+
2217+ //////////////////////////////////////////////////////////////
2218+ // exception preamble
2219+ // r1 stack (mregs)
2220+ // r6,r7 nip / srr1
2221+ // cr4-7 flag_bits
2222+ //
2223+ // Saved r0-r5 (NOT SAVED: ctr, xer)
2224+
2225+VECTOR_( 0x700, "Program", secint_bad, mac_entry )
2226+ EXCEPTION_PREAMBLE // 46 cycles on a G3
2227+ TRACE(0x700, "Program")
2228+
2229+ mtcrf 0x10,r7 // put srr1 bits (12-15) into cr3
2230+ bt 14,mac_program_trap
2231+ GET_INSTR_OPCODE // r6=nip, r2-r3, r4=opcode (cr not touched)
2232+ bt+ 13,emulate_priv_instr
2233+ bt+ 12,emulate_illegal_instr
2234+ mtcrf 0x20,r7 // put srr1 bits (8-11) into cr2
2235+ bt+ 11,mac_program_trap // bit 11 = fpu_exception
2236+
2237+ // we should not come here
2238+ MAC_EXIT_SAVE( RVEC_UNUSUAL_PROGRAM_EXCEP )
2239+
2240+unhandled_priv_inst:
2241+ MAC_EXIT_SAVE( RVEC_PRIV_INST ) // r4 = opcode
2242+
2243+emulate_illegal_instr:
2244+ rlwinm r2,r4,32-1,22,31
2245+ lwz r3,xMSR(r1)
2246+ rlwinm r5,r4,14,24,28 // r5 = reg_num << 3 (instr. bits 6-10)
2247+ rlwimi r2,r4,16,16,21 // r2 = opcode
2248+
2249+ rlwinm r0,r2,0,~0x80 // clear mtspr/mfspr bit
2250+ cmpwi r0,OPCODE(31,339) // mfspr/mtspr
2251+ bne 1f
2252+
2253+ rlwinm r7,r7,0,14,10 // clear srr1 bit 11-13
2254+ cmpwi cr1,r2,OPCODE(31,339) // mfspr
2255+ oris r7,r7,0x4 // set bit 13 (privileged instr)
2256+
2257+ beq- cr1,emulate_mfspr // r3=xMSR, r4=opcode, r5=reg_num
2258+ b emulate_mtspr // must be mtspr
2259+1:
2260+#ifdef EMULATE_603
2261+ bl emulate_603_instr
2262+#endif
2263+ MAC_EXIT_SAVE( RVEC_ILLEGAL_INST ) // r4 = opcode
2264+
2265+
2266+/************************************************************************/
2267+/* mac exceptions */
2268+/************************************************************************/
2269+
2270+ /////////////////////////////////////////////////////////////
2271+ // mac_trap
2272+ //
2273+ // r2 exception vector
2274+ // r6 nip
2275+ // r7 reason bits (0-15)
2276+ //
2277+ // r0,r2-r5 may be modified
2278+
2279+mac_irq_trap:
2280+ li r2,0x500
2281+ li r7,0 // no reason bits
2282+ b mac_trap
2283+
2284+mac_dec_trap:
2285+ li r2,0x900
2286+ crclr FBIT_DecINT
2287+ li r7,0 // no reason bits
2288+ b mac_trap
2289+
2290+ balign_32
2291+mac_program_trap: // the reason bits already in r7 are used
2292+ __BUMP("mac_trap")
2293+ li r2,0x700
2294+mac_trap:
2295+ lwz r3,xMSR(r1)
2296+ stw r6,xSRR0(r1) // mac-srr0 = nip
2297+ mr r4,r3 // copy xMSR to SRR1
2298+ mr r6,r2 // new nip
2299+ rlwinm r5,r3,25+1,31,31 // put MSR_IP (bit 25) in r5[31]
2300+ rlwimi r4,r7,0,0,15 // copy reason bits from r7 to SRR1
2301+ rlwimi r4,r3,0,6,6 // copy MSR_VEC bit of xMSR to SRR1
2302+ stw r4,xSRR1(r1) // srr1 = (msr & (0xffff|MSR_VEC)) | (srr1 & ~(0xffff|MSR_VEC))
2303+ rlwinm r4,r3,0,25,25 // copy MSR_IP to xMSR
2304+ neg r5,r5 // r5 = 0xffffffff * MSR_IP
2305+ rlwimi r4,r3,0,19,19 // copy MSR_ME to xMSR
2306+ rlwimi r6,r5,0,0,11 // insert exception prefix
2307+ stw r4,xMSR(r1)
2308+ GET_TICK_CNT(entry,"mac-expception")
2309+ b msr_exception_return
2310+
2311+rvec_trace_trap:
2312+ MAC_EXIT_SAVE( RVEC_TRACE_TRAP )
2313+
2314+
2315+/************************************************************************/
2316+/* decode privileged instruction */
2317+/************************************************************************/
2318+
2319+ /////////////////////////////////////////////////////////////
2320+ // emulate_priv_instr
2321+ // r4 opcode
2322+ // r6,r7 nip/srr1
2323+ //
2324+ // r0,r2-r5,lr free
2325+
2326+ balign_32
2327+emulate_priv_instr:
2328+ rlwinm r2,r4,32-1,22,31
2329+ lwz r3,xMSR(r1)
2330+ rlwinm r5,r4,14,24,28 // r5 = reg_num << 3 (instr. bits 6-10)
2331+ rlwimi r2,r4,16,16,21 // r2 = opcode
2332+
2333+ GET_TICK_CNT(entry,"get_inst")
2334+ BUMP("decode_priv_inst")
2335+
2336+ cmpwi cr1,r2,OPCODE(31,339) // mfspr (both user and supervisor mode)
2337+ beq- cr1,emulate_mfspr // r3=xMSR, r4=opcode, r5=reg_num
2338+
2339+ cmpwi cr2,r2,OPCODE(31,467) // mtspr (both user and supervisor mode)
2340+ beq- cr2,emulate_mtspr
2341+
2342+ andi. r3,r3,MSR_PR // only emulate in supervisor mode
2343+ bne- mac_program_trap
2344+
2345+ cmpwi cr3,r2,OPCODE(31,83) // mfmsr
2346+ beq- cr3,emulate_mfmsr
2347+
2348+ cmpwi cr0,r2,OPCODE(31,146) // mtmsr
2349+ beq- cr0,emulate_mtmsr
2350+
2351+ cmpwi cr1,r2,OPCODE(19,50) // rfi
2352+ beq- cr1,emulate_rfi
2353+
2354+ cmpwi cr2,r2,OPCODE(31,595) // mfsr
2355+ beq- cr2,emulate_mfsr
2356+
2357+ cmpwi cr3,r2,OPCODE(31,659) // mfsrin
2358+ beq- cr3,emulate_mfsrin
2359+
2360+ cmpwi cr0,r2,OPCODE(31,210) // mtsr
2361+ beq- cr0,emulate_mtsr
2362+
2363+ cmpwi cr1,r2,OPCODE(31,242) // mtsrin
2364+ beq- cr1,emulate_mtsrin
2365+
2366+ cmpwi cr2,r2,OPCODE(31,306) // tlbie
2367+ beq- cr2,emulate_tlbie
2368+
2369+ cmpwi cr3,r2,OPCODE(31,566) // tlbsync
2370+ beq- cr3,emulate_tlbsync
2371+
2372+ cmpwi cr0,r2,OPCODE(31,467) // dcbi
2373+ beq- cr0,emulate_dcbi
2374+#ifdef EMULATE_603
2375+ cmpwi cr1,r2,OPCODE(31,978) // tlbld
2376+ beq- cr1,emulate_tlbld
2377+
2378+ cmpwi cr2,r2,OPCODE(31,1010) // tlbli
2379+ beq- cr2,emulate_tlbli
2380+#endif
2381+ // Program-trap, illegal instruction
2382+ b unhandled_priv_inst // r4 = opcode
2383+
2384+
2385+#ifdef EMULATE_603
2386+emulate_603_instr:
2387+ rlwinm r2,r4,32-1,22,31
2388+ rlwimi r2,r4,16,16,21 // r2 = opcode
2389+
2390+ cmpwi cr0,r2,OPCODE(31,978) // tlbld
2391+ beq cr0,2f
2392+ cmpwi cr1,r2,OPCODE(31,1010) // tlbli
2393+ beq cr1,2f
2394+ cmpwi cr2,r2,OPCODE(31,339) // mfspr
2395+ beq cr2,1f
2396+ cmpwi cr3,r2,OPCODE(31,467) // mtspr
2397+ bnelr cr3
2398+1: rlwinm r3,r4,32-16,27,31
2399+ rlwimi r3,r4,32-6,22,26 // r3 = spr#
2400+ cmpwi r3,976 // first 603 SPR
2401+ bltlr
2402+ cmpwi r3,982 // last 603 SPR
2403+ bgtlr
2404+2:
2405+ rlwinm r7,r7,0,14,10 // clear bit 11-13
2406+ oris r7,r7,0x4 // set bit 13
2407+ b emulate_priv_instr
2408+
2409+#endif /* EMULATE_603 */
2410+
2411+
2412+/************************************************************************/
2413+/* mac register access */
2414+/************************************************************************/
2415+
2416+MACRO(LOAD_EMUGPR_IM, [dreg,ereg], [
2417+.if _ereg <= 7
2418+ lwz _dreg,xGPR0+_ereg[]*4(r1)
2419+.else
2420+ mr _dreg,rPREFIX[]_ereg
2421+.endif
2422+])
2423+
2424+MACRO(STORE_EMUGPR_IM, [sreg,ereg], [
2425+.if _ereg <= 7
2426+ stw _sreg,xGPR0+_ereg[]*4(r1)
2427+.else
2428+ mr rPREFIX[]_ereg, _sreg
2429+.endif
2430+])
2431+
2432+ balign_32
2433+store_gpr_table:
2434+mFORLOOP([i],0,31,[
2435+ STORE_EMUGPR_IM r0,i
2436+ blr
2437+])
2438+
2439+load_gpr_table:
2440+mFORLOOP([i],0,31,[
2441+ LOAD_EMUGPR_IM r0,i
2442+ blr
2443+])
2444+
2445+MACRO(EMU_LOAD_GPR, [reg, scr], [
2446+ LI_PHYS( _scr, load_gpr_table )
2447+ add rPREFIX[]_scr,_reg,rPREFIX[]_scr
2448+ mtlr rPREFIX[]_scr
2449+ blrl
2450+])
2451+
2452+MACRO(EMU_STORE_GPR, [reg, scr], [
2453+ LI_PHYS( _scr, store_gpr_table )
2454+ add rPREFIX[]_scr,_reg,rPREFIX[]_scr
2455+ mtlr rPREFIX[]_scr
2456+ blrl
2457+])
2458+
2459+
2460+
2461+/************************************************************************/
2462+/* instruction emulation */
2463+/************************************************************************/
2464+
2465+ //////////////////////////////////////////////////////////
2466+ // emulate_xxxxx
2467+ // r3 xMSR
2468+ // r4 opcode
2469+ // r5 regnum<<3 (from opcode bits 6-10)
2470+ //
2471+ // May modify: r0,r2-r5 (lr)
2472+
2473+/********************************************************************/
2474+emulate_mfmsr:
2475+ lwz r0,xMSR(r1)
2476+ EMU_STORE_GPR r5, /**/ R2
2477+ GET_TICK_CNT( entry, "mfmsr" )
2478+ b emulation_done
2479+
2480+/********************************************************************/
2481+emulate_mfspr: // r3 = xMSR
2482+ BUMP("emulate_mfspr")
2483+ rlwimi r4,r4,32-10,21,25 // flip spr
2484+ rlwinm r0,r3,32-14,31,31 // r0(bit31) = MSR_PR
2485+ addi r3,r1,K_SPR_HOOKS
2486+ rlwinm r2,r4,32-4,20,29 // r2 = spr# << 2
2487+ addi r4,r1,xSPR_BASE
2488+ lwzx r3,r2,r3 // hook in r3
2489+ and. r0,r0,r3 // privileged SPR?
2490+ bne- mac_program_trap
2491+ lwzx r0,r2,r4 // value in r0
2492+ mtlr r3
2493+ blr // call hook
2494+
2495+/********************************************************************/
2496+emulate_mtspr: // r3 = xMSR
2497+ BUMP("emulate_mtspr")
2498+ rlwimi r4,r4,32-10,21,25 // flip spr
2499+ EMU_LOAD_GPR r5, /**/ R2 // value in r0
2500+ rlwinm r2,r4,32-4,20,29 // r2 = spr# << 2
2501+ addi r4,r1,K_SPR_HOOKS
2502+ rlwinm r3,r3,32-14,31,31 // r3(bit31) = MSR_PR
2503+ lwzx r4,r2,r4 // hook in r4
2504+ addi r5,r2,xSPR_BASE // r5+r1 points to SPR reg
2505+ addi r4,r4,4 // branch to hook +4
2506+ and. r3,r3,r4 // privileged SPR?
2507+ bne- mac_program_trap // privileged exception
2508+ mtlr r4 // lsb is discarded...
2509+ blr // call hook
2510+
2511+
2512+/********************************************************************/
2513+ balign_32
2514+emulate_mtmsr:
2515+ lwz r3,xMSR(r1) // r3 = old MSR
2516+ LI_PHYS( R2, load_gpr_table )
2517+ add r2,r5,r2
2518+ mtlr r2
2519+ blrl // r0 = new MSR
2520+
2521+ INC_NIP
2522+ bl msr_altered
2523+
2524+ GET_TICK_CNT(entry, "mtmsr")
2525+ BUMP("emulate_mtmsr")
2526+
2527+ beq+ cr1,emulation_done_noinc
2528+ MAC_EXIT_SAVE( RVEC_MSR_POW ) // POW 1 => doze
2529+
2530+
2531+/********************************************************************/
2532+emulate_rfi:
2533+ BUMP("rfi")
2534+ lis r4,(MSR_VEC)>>16
2535+ lwz r0,xSRR1(r1)
2536+ ori r4,r4,0xffff
2537+#ifdef EMULATE_603
2538+ oris r4,r4,(MSR_TGPR)>>16
2539+#endif
2540+ lwz r3,xMSR(r1) // r3 = old MSR
2541+ and r0,r0,r4
2542+ andc r5,r3,r4
2543+ lwz r6,xSRR0(r1) // new nip = SRR0
2544+ or r0,r0,r5
2545+
2546+ bl msr_altered // r0,r2-r5, r7 [srr1] updated
2547+
2548+ GET_TICK_CNT(entry,"rfi")
2549+
2550+ lwz r3,K_BREAK_FLAGS(r1) // break at rfi support
2551+ andi. r3,r3,BREAK_RFI
2552+ beq+ exception_return
2553+ li r4,BREAK_RFI // r4 = flag causing the break
2554+ MAC_EXIT_SAVE( RVEC_BREAK )
2555+
2556+
2557+/********************************************************************/
2558+#ifdef EMULATE_603
2559+emulate_tlbli:
2560+ LOADI r3,EXTERN(do_tlbli)
2561+ b 1f
2562+emulate_tlbld:
2563+ LOADI r3,EXTERN(do_tlbld)
2564+ b 1f
2565+emulate_tlbie:
2566+ LOADI r3,EXTERN(do_tlbie)
2567+1: INC_NIP
2568+ rlwinm r5,r4,32-8,24,28 // r5 = #B << 3
2569+ EMU_LOAD_GPR r5, /**/ R2 // value ret. in r0
2570+ mr r4,r0 // r4 = ea
2571+ b call_kernel_save
2572+#else
2573+emulate_tlbie:
2574+ b emulation_done
2575+#endif /* EMULATE_603 */
2576+
2577+/********************************************************************/
2578+emulate_tlbsync:
2579+ b emulation_done
2580+
2581+/********************************************************************/
2582+emulate_dcbi:
2583+ b unhandled_priv_inst // r4 = opcode
2584+
2585+/********************************************************************/
2586+emulate_mfsrin:
2587+ rlwinm r2,r4,32-8,24,28 // r2 = #B << 3
2588+ EMU_LOAD_GPR r2, /**/ R3 // r0 = reg B
2589+ rlwinm r3,r0,6,26,29 // r3 = #sr << 2
2590+ b 1f
2591+emulate_mfsr:
2592+ rlwinm r3,r4,32-14,26,29 // r3 = #sr << 2
2593+1: addi r2,r1,xSEGR_BASE
2594+ lwzx r0,r3,r2
2595+ EMU_STORE_GPR r5, /**/ R2
2596+ GET_TICK_CNT(entry, "mfsr")
2597+ BUMP("mfsr_")
2598+ b emulation_done
2599+
2600+
2601+
2602+/************************************************************************/
2603+/* SPR - emulation */
2604+/************************************************************************/
2605+
2606+ ////////////////////////////////////////////////////////////
2607+ // read (offset 0)
2608+ // r0 spr_value
2609+ // r2 spr << 2
2610+ // r5 dreg << 3
2611+ //
2612+ // write (offset 4)
2613+ // r0 gpr_value
2614+ // r2 spr << 2
2615+ // r5 spr offset (relative r1)
2616+ //
2617+ // Safe to modify: r2-r5, lr
2618+ // NOT SAVED: ctr, xer
2619+
2620+/********************************************************************/
2621+simple_mfspr:
2622+ EMU_STORE_GPR r5, /**/ R3
2623+ GET_TICK_CNT(entry,"simple_mfspr")
2624+ b emulation_done
2625+
2626+GLOBAL_SYMBOL(r__spr_read_write):
2627+spr_read_write:
2628+ b simple_mfspr
2629+ stwx r0,r5,r1 // value in r0
2630+ GET_TICK_CNT(entry,"simple_mtspr")
2631+ b emulation_done
2632+
2633+
2634+/********************************************************************/
2635+GLOBAL_SYMBOL(r__spr_read_only):
2636+spr_read_only:
2637+ b simple_mfspr // allow read
2638+ b emulation_done // ignore write
2639+
2640+/********************************************************************/
2641+GLOBAL_SYMBOL(r__spr_illegal):
2642+spr_illegal:
2643+ nop // spr read entry
2644+ rlwinm r7,r7,0,15,10 // clear srr1 bit 11-14
2645+ oris r7,r7,0x8 // set bit 12 (privileged instr)
2646+ b mac_program_trap
2647+
2648+
2649+/********************************************************************/
2650+unhandled_spr_read:
2651+ srwi r4,r2,2
2652+ srwi r5,r5,3
2653+ // r4 = spr#
2654+ // r5 = dest gpr
2655+ MAC_EXIT_SAVE( RVEC_SPR_READ )
2656+
2657+unhandled_spr:
2658+ b unhandled_spr_read // read hook (offs 0)
2659+unhandled_spr_write: // write hook (offs 4)
2660+ srwi r4,r2,2
2661+ mr r5,r0
2662+ // r4 = spr#
2663+ // r5 = register-value
2664+ MAC_EXIT_SAVE( RVEC_SPR_WRITE )
2665+
2666+/********************************************************************/
2667+spr_bat:
2668+ b simple_mfspr // read has no side-effects
2669+ INC_NIP
2670+ LOADI r3,EXTERN(do_mtbat)
2671+ bl save_middle_regs // Must do this before touching r6-r12
2672+ srwi r4,r2,2 // r4 = spr#
2673+ mr r5,r0 // r5 = value
2674+ li r6,0 // not forced
2675+ b call_kernel
2676+
2677+/********************************************************************/
2678+spr_sdr1:
2679+ b simple_mfspr // read has no side-effects
2680+ INC_NIP
2681+ LOADI r3,EXTERN(do_mtsdr1)
2682+ mr r4,r0 // r4 = value
2683+ b call_kernel_save
2684+
2685+
2686+
2687+
2688+/************************************************************************/
2689+/* handle MSR changes */
2690+/************************************************************************/
2691+
2692+ ////////////////////////////////////////////////////////////
2693+ // msr_exception_return (exception taken)
2694+ //
2695+ // r6, r7: nip / srr1
2696+ //
2697+ // modifies: r0,r2-r5 (r7 updated)
2698+
2699+ balign_16
2700+msr_exception_return:
2701+ addi r3,r1,K_UNMAPPED_SR_BASE // set unmapped context
2702+ li r7,(MSR_ME | MSR_SE | MSR_IR | MSR_DR | MSR_PR)
2703+ stw r3,K_CUR_SR_BASE(r1)
2704+ li r5,(fb_DbgTrace | fb_Trace)
2705+ ori r7,r7,MSR_EE
2706+
2707+ bt+ FBIT_DbgTrace, 1f
2708+ li r5,0
2709+ rlwinm r7,r7,0,~MSR_SE
2710+1:
2711+ stw r3,K_SR_DATA(r1)
2712+ li r4,fb_LoadSegreg
2713+
2714+ stw r3,K_SR_INST(r1)
2715+ mtcrf TRACE_CR_FIELD,r5 // set singlestep bits [cr6]
2716+ mtcrf MMU_CR_FIELD,r4
2717+
2718+ stw r7,K_MSR(r1)
2719+ b exception_return
2720+
2721+
2722+ ////////////////////////////////////////////////////////////
2723+ // msr_altered
2724+ //
2725+ // r6, r7: nip / srr1
2726+ //
2727+ // r0 = new msr
2728+ // r3 = old msr
2729+ //
2730+ // Sets cr1.ne if we MSR_POW is set
2731+ //
2732+ // M: r2-r5 (r7 updated).
2733+ // r0 may _NOT_ be modified
2734+
2735+#define MSR_CLEARBITS (MSR_FP | MSR_FE0 | MSR_FE1 | MSR_BE | MSR_SE)
2736+#define MSR_COPYBITS (MSR_BE | MSR_SE)
2737+
2738+ balign_32
2739+msr_altered:
2740+#ifdef EMULATE_603
2741+ bf+ FBIT_603_AltGPR,7f // 603 alternate GPR support
2742+ rlwinm. r5,r0,0,MSR_TGPR
2743+ bne+ 7f
2744+ lwz r2,xGPRSAVE0_603(r1) // MSR_TGPR cleared...
2745+ lwz r4,xGPRSAVE1_603(r1)
2746+ lwz r5,xGPRSAVE2_603(r1)
2747+ stw r2,xGPR0(r1)
2748+ lwz r2,xGPRSAVE3_603(r1)
2749+ stw r4,xGPR1(r1)
2750+ stw r5,xGPR2(r1)
2751+ stw r2,xGPR3(r1)
2752+ crclr FBIT_603_AltGPR
2753+7:
2754+#endif
2755+ li r7,(MSR_ME | MSR_SE | MSR_IR | MSR_DR | MSR_PR)
2756+ stw r0,xMSR(r1)
2757+ xor r3,r3,r0 // r3 == MSR bit toggle
2758+ bt- FBIT_IRQPending,test_for_irq // M: r2
2759+irq_test_ret:
2760+ rlwinm r4,r0,0,MSR_POW // MSR_POW
2761+ ori r7,r7,MSR_EE
2762+ andi. r3,r3,(MSR_DR|MSR_IR|MSR_PR) // MMU change (cr unused)?
2763+ bt- FBIT_DecINT,test_for_dec // M: r2
2764+dec_test_ret:
2765+ cmpwi cr1,r4,0 // MSR_POW set?
2766+ li r2,(fb_DbgTrace | fb_Trace)
2767+ cmpwi cr2,r3,0
2768+ bt- FBIT_DbgTrace,1f
2769+ rlwinm r2,r0,(21+32-FBIT_Trace),fb_Trace // MSR_SE[21] -> FBIT_Trace
2770+ rlwimi r7,r0,0,(MSR_SE|MSR_BE) // no debugger; copy MSR_SE and MSR_BE
2771+1:
2772+ stw r7,K_MSR(r1)
2773+ mtcrf TRACE_CR_FIELD,r2 // set singlestep bits [cr6]
2774+
2775+ bne cr2,1f // bnelr is slower...
2776+ blr
2777+1:
2778+ /* MMU change */
2779+ BUMP("MMU-change")
2780+
2781+ andi. r3,r0,(MSR_IR | MSR_DR) // IR DR part of index
2782+ addi r5,r1,K_MSR_SR_TABLE
2783+ addi r4,r3,MSR_DR // splitmode (MSR_DR != MSR_IR) testing
2784+ rlwimi r3,r0,32-8,25,25 // [PR IR DR] index to K_MSR_SR_TABLE
2785+ lwzux r3,r5,r3 // set sr bases from K_MSR_SR_TABLE
2786+ andi. r4,r4,MSR_IR // non-zero if in splitmode
2787+ lwz r2,4(r5)
2788+ li r4,(fb_InSplitmode | fb_LoadSegreg | fb_PrepareSplitmode)
2789+ lwz r5,8(r5)
2790+ stw r3,K_CUR_SR_BASE(r1) // new sr base in r3 (used below)
2791+ stw r2,K_SR_DATA(r1)
2792+ bne- 1f
2793+ li r4,fb_LoadSegreg // cur_sr_base changed
2794+1: stw r5,K_SR_INST(r1)
2795+ mtcrf MMU_CR_FIELD,r4
2796+ blr
2797+
2798+test_for_irq:
2799+ BUMP("test-for-irq")
2800+ and r2,r3,r0 // check whether we are turning external interrupts on
2801+ andi. r2,r2,MSR_EE // we need to recheck IRQs in userspace then
2802+ beq+ 1f
2803+ lwz r4,xHOSTIRQ_ACTIVE_CNT(r1)
2804+ cmpwi r4,0 // only return if some host irq is up
2805+ beq+ 1f
2806+ MAC_EXIT_SAVE(RVEC_CHECK_IRQS)
2807+
2808+1: andi. r2,r0,MSR_EE
2809+ beq irq_test_ret
2810+ b mac_irq_trap
2811+
2812+test_for_dec:
2813+ BUMP("test-for-dec")
2814+ andi. r2,r0,MSR_EE
2815+ beq dec_test_ret
2816+ b mac_dec_trap
2817+
2818+force_msr_altered:
2819+ BUMP("force-msr-altered")
2820+ lwz r0,xMSR(r1) // r0 = new MSR
2821+ xori r3,r0,(MSR_DR|MSR_IR) // r3 = faked old MSR
2822+ b msr_altered // might throw an exception...
2823+
2824+ // msr_altered( kv )
2825+GLOBAL_SYMBOL(r__msr_altered):
2826+ lwz r5,xFLAG_BITS(r3)
2827+ ori r5,r5,fb_MsrModified
2828+ stw r5,xFLAG_BITS(r3)
2829+ blr
2830+
2831+
2832+/************************************************************************/
2833+/* initialize special purpose register table */
2834+/************************************************************************/
2835+
2836+MACRO(SPR_HOOK, [spr, hook], [ LI_PHYS( R8, _hook ) ; stw r8,(((_spr)*4)+K_SPR_HOOKS)(r3) ])
2837+
2838+// The LSB of a SPR hook specifies that the SPR is privileged (these bits are
2839+// set from C-code).
2840+
2841+ // r3 = kvars
2842+GLOBAL_SYMBOL(r__initialize_spr_table):
2843+ LI_PHYS( R7, unhandled_spr )
2844+ addi r8,r3,K_SPR_HOOKS-4
2845+ li r9,1024
2846+ mtctr r9
2847+1: stwu r7,4(r8)
2848+ bdnz 1b
2849+
2850+ // XXX for now...
2851+ SPR_HOOK TBWU, spr_read_write
2852+ SPR_HOOK TBWL, spr_read_write
2853+
2854+ // SPRs that have side effects
2855+ SPR_HOOK SDR1, spr_sdr1
2856+ SPR_HOOK DEC, spr_dec
2857+
2858+ // BATs
2859+ mFORLOOP([nn],0,15,[
2860+ SPR_HOOK eval(nn+IBAT0U), spr_bat
2861+ ])
2862+ blr
2863+
2864+
2865+/************************************************************************/
2866+/* initialize msr segment register table */
2867+/************************************************************************/
2868+
2869+ /////////////////////////////////////////////////////////////
2870+ // initialize_sr_offs_table
2871+ //
2872+ // Copy sr_offs_table to K_MSR_SR_TABLE
2873+ // r1 is added to each element
2874+
2875+initialize_msr_sr_table:
2876+ mflr r8 // Get address of table
2877+ bl sr_offs_table
2878+ mflr r3
2879+ mtlr r8
2880+
2881+ li r5,4*8 // #words in table
2882+ mtctr r5
2883+ addi r3,r3,-4
2884+ addi r4,r1,K_MSR_SR_TABLE-4
2885+1:
2886+ lwzu r6,4(r3)
2887+ add r6,r6,r1 // And add r1
2888+ stwu r6,4(r4)
2889+ bdnz 1b
2890+ blr
2891+
2892+ // Used to construct msr_sr_table (mbase is added)
2893+sr_offs_table:
2894+ blrl
2895+ /* K_CUR_SR_BASE, K_SR_DATA_BASE, K_SR_INST_BASE, dummy */
2896+
2897+ .long K_UNMAPPED_SR_BASE, K_UNMAPPED_SR_BASE, K_UNMAPPED_SR_BASE, 0
2898+ .long K_SPLIT_SR_BASE, K_SV_SR_BASE, K_UNMAPPED_SR_BASE, 0 /* DR */
2899+ .long K_SPLIT_SR_BASE, K_UNMAPPED_SR_BASE, K_SV_SR_BASE, 0 /* IR */
2900+ .long K_SV_SR_BASE, K_SV_SR_BASE, K_SV_SR_BASE, 0 /* DR|IR */
2901+
2902+ .long K_UNMAPPED_SR_BASE, K_UNMAPPED_SR_BASE, K_UNMAPPED_SR_BASE, 0 /* PR */
2903+ .long K_SPLIT_SR_BASE, K_USER_SR_BASE, K_UNMAPPED_SR_BASE, 0 /* PR|DR */
2904+ .long K_SPLIT_SR_BASE, K_UNMAPPED_SR_BASE, K_USER_SR_BASE, 0 /* PR|IR */
2905+ .long K_USER_SR_BASE, K_USER_SR_BASE, K_USER_SR_BASE, 0 /* PR|DR|IR */
2906--- /dev/null
2907+++ b/drivers/macintosh/mol/asm-files/entry.S
2908@@ -0,0 +1,433 @@
2909+/*
2910+ * Creation Date: <2001/01/30 00:22:35 samuel>
2911+ * Time-stamp: <2004/03/07 13:33:39 samuel>
2912+ *
2913+ * <entry.S>
2914+ *
2915+ * Emulator/mac switching
2916+ *
2917+ * Copyright (C) 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
2918+ *
2919+ * This program is free software; you can redistribute it and/or
2920+ * modify it under the terms of the GNU General Public License
2921+ * as published by the Free Software Foundation
2922+ *
2923+ */
2924+
2925+/* Short note about DEC. Due to the kernel implementation of the DEC
2926+ * exception handler (and get_time_of_day) in the 2.3/2.4 kernel, we
2927+ * must try to maintain coherency between DEC and TB. In any case,
2928+ * we must NEVER let DEC tick faster than TB, or get_time_of_day will
2929+ * occasionally return bogus values (the result is usually
2930+ * misbehaving X).
2931+ */
2932+
2933+/************************************************************************/
2934+/* Mac Entry */
2935+/************************************************************************/
2936+
2937+ //////////////////////////////////////////////////////////
2938+ // mac_entry_initialize
2939+ //
2940+ // Run once in order to store certain things (segment
2941+ // registers and NIP)
2942+ //
2943+ // sprg1 userspace stack
2944+ // r6 emulator return point after 'call_kernel'
2945+ //
2946+ // Safe to modify: r0-r12, lr, ctr
2947+
2948+mac_entry_initialize:
2949+ __ZERO_TICK_CNT(entry)
2950+
2951+ // Save emulator return point (skip over illegal inst)
2952+ mfsrr0 r5
2953+ addi r5,r5,4
2954+ stw r5,K_EMULATOR_NIP(r1) // This sets the return point once and for all
2955+ stw r2,K_EMULATOR_TOC(r1) // r2==TOC (not on linux though)
2956+ stw r6,K_EMULATOR_KCALL_NIP(r1) // Return point after 'call_kernel'
2957+ mfsrr1 r6
2958+ mfsprg_a1 r3
2959+ stw r6,K_EMULATOR_MSR(r1) // we want to return through mac_exit
2960+ stw r3,K_EMULATOR_STACK(r1)
2961+
2962+ lwz r3,xFLAG_BITS(r1) // Best to initialize the flag bits
2963+ mtcr r3
2964+
2965+ // msr to be used in mac-mode
2966+ LOADI r3,(MSR_ME | MSR_IR | MSR_DR | MSR_PR | MSR_EE)
2967+ stw r3,K_MSR(r1)
2968+
2969+ PERF_MONITOR_SETUP /**/ r4
2970+
2971+ addi r3,r1,K_EMULATOR_SR // Save segment registers
2972+ SAVE_SEGMENT_REGS r3, /**/ r4,r5
2973+ SAVE_IBATS K_IBAT0U_SAVE, /**/ r3 // And save linux BAT registers
2974+ SAVE_DBATS K_DBAT0U_SAVE, /**/ r3
2975+
2976+ bl initialize_msr_sr_table
2977+
2978+ addi r3,r1,K_EMULATOR_SR
2979+ LOAD_SEGMENT_REGS r3, /**/ r4,r5
2980+
2981+ li r3,RVEC_EXIT
2982+ b exit_
2983+
2984+
2985+ ////////////////////////////////////////////////////////////////////
2986+ // mac_entry [ENTRYPOINT]
2987+ //
2988+ // sprg1 userspace stack
2989+ // r4 MOL_ENTRY_R4_MAGIC
2990+ // r5 magic
2991+ // r6 call_kernel return point (if initializing)
2992+ // r7 session number | initialize flag
2993+ //
2994+ // srr1 emulator msr
2995+ // r13-r31 mac gprs
2996+ // fr14-fr31 mac fp registers
2997+ // fr0-fr12 mac fp registers (see xFPU_STATE)
2998+
2999+1: li r4,1
3000+ stw r4,ST_MAGIC(r1)
3001+2: mtcr r3 // restore registers
3002+ CONTINUE_TRAP( 0x700 ) // not MOL, take the trap
3003+
3004+ balign_32
3005+mac_entry:
3006+ lis_svh R1,SPECVAR_SESSION_TABLE
3007+ cmpwi r4,MOL_ENTRY_R4_MAGIC // MOL switch magic.
3008+ ori_svl R1,R1,SPECVAR_SESSION_TABLE
3009+ bne- 2b
3010+ lwz r4,ST_MAGIC(r1) // check that the magic match
3011+ cmplwi r5,1 // and is greater than 1
3012+ cmpw cr1,r5,r4
3013+ ble- 2b
3014+ addi r5,r1,ST_KVARS_PH // get kvars for this session
3015+ rlwinm r4,r7,2,((MAX_NUM_SESSIONS-1)*4)
3016+ bne- cr1,1b // r1 must point to session table
3017+ lwzx r1,r4,r5 // set r1 to kvars
3018+ cmpwi cr1,r1,0
3019+ cmplwi r7,MAX_NUM_SESSIONS
3020+ beq- cr1,2b // kvars == NULL
3021+ bge- mac_entry_initialize // initialize flag set
3022+
3023+ // =====================================================================
3024+ // entrypoint
3025+ // =====================================================================
3026+
3027+ __ZERO_TICK_CNT(entry)
3028+ TRACE(0x1111, "mac_entry")
3029+
3030+ // Save emulator registers (r1,msr) and restore flag bits
3031+ mfsprg_a1 r3
3032+ lwz r4,xFLAG_BITS(r1)
3033+ stw r3,K_EMULATOR_STACK(r1)
3034+ mfsrr1 r6
3035+ mtcr r4
3036+ stw r6,K_EMULATOR_MSR(r1) // The MSR_FP/MSR_VEC bits are of interest...
3037+
3038+ // Setup mac-environment
3039+
3040+ btl FBIT_RecalcDecInt, recalc_int_stamp // M: r0,r2-r5
3041+ bl set_mac_context // M: r0,r2-r12,XER
3042+ bl set_mol_dec // M: r0,r2-r5
3043+
3044+ crset FBIT_LoadSegreg // Load segment registers below
3045+
3046+ RESTORE_MIDDLE_REGS // Loads r6,r7 (nip/msr) r8-r12, ctr, xer,
3047+
3048+ rlwinm r7,r7,0,~MSR_VEC // We always clear MSR_VEC (MSR_FP should be off already)
3049+ stw r7,K_MSR(r1) // (enabling MSR_VEC is relatively cheap)
3050+ btl- FBIT_MsrModified,msr_altered_entry
3051+
3052+ GET_TICK_CNT(entry, "mac_entry")
3053+
3054+ bt- FBIT_DecINT,test_for_dec_int // check for DEC interrupts
3055+ b exception_return
3056+
3057+test_for_dec_int:
3058+ lwz r3,xMSR(r1)
3059+ rlwinm. r3,r3,0,MSR_EE // MSR_EE is set?
3060+ bne mac_dec_trap // if so take a DEC interrupt
3061+ b exception_return
3062+
3063+msr_altered_entry:
3064+ crclr FBIT_MsrModified
3065+ b force_msr_altered
3066+
3067+
3068+ /////////////////////////////////////////////////////////////
3069+ // All paths back to mac-mode goes through one of these
3070+ // functions.
3071+ //
3072+ // emulation_done
3073+ // emulation_done_noinc
3074+ // exception_return
3075+
3076+ balign_32
3077+emulation_done:
3078+ addi r6,r6,4 // increase NIP
3079+emulation_done_noinc:
3080+ bt- FBIT_Trace, rvec_trace_trap
3081+ GET_TICK_CNT(entry,"emulation_done")
3082+exception_return:
3083+ btl- FBIT_LoadSegreg,reload_sr // M: r3-r5, r6=nip
3084+ mtsrr1 r7 // setup SRR1
3085+ lwz r0,xCR(r1)
3086+ lwz r3,xLINK(r1)
3087+ mtsrr0 r6
3088+ lwz r4,xGPR4(r1)
3089+ lwz r5,xGPR5(r1)
3090+ mfcr r2 // Save flag bits
3091+ lwz r6,xGPR6(r1)
3092+ lwz r7,xGPR7(r1)
3093+ mtlr r3
3094+ stw r2,xFLAG_BITS(r1)
3095+ lwz r2,xGPR2(r1)
3096+ lwz r3,xGPR3(r1)
3097+ mtcr r0
3098+ lwz r0,xGPR0(r1)
3099+ __GET_TICK_CNT(entry,"asm-all") // performance measurements
3100+ __BUMP("asm-all")
3101+ lwz r1,xGPR1(r1)
3102+ rfi
3103+
3104+
3105+/************************************************************************/
3106+/* Exit Mac-Mode Paths */
3107+/************************************************************************/
3108+
3109+ // THESE ARE _ALL_ THE POSSIBLE EXIT PATHS. KEEP IT THAT WAY
3110+ // OR HAVE A *VERY GOOD* REASON TO INTRODUCE A NEW ONE.
3111+
3112+ /////////////////////////////////////////////////////////
3113+ // giveup_fpu
3114+ //
3115+ // Save fpscr and fpr13 and clear the MSR_FP bit.
3116+ // Restore the emulator fpscr value.
3117+ //
3118+ // IMPORTANT: Call this function only if FBIT_FPUInUse is set
3119+ //
3120+ // modifies: r7,r8 (turns on MSR_FP if FP is set in K_MSR)
3121+
3122+giveup_fpu:
3123+ li r8,MSR_FP | MSR_FE0 | MSR_FE1
3124+ lwz r7,K_MSR(r1)
3125+ andc r8,r7,r8 // Clear MSR_FEx bits
3126+ stw r8,K_MSR(r1)
3127+
3128+ mfmsr r7 // Temporary enable FPU in order to
3129+ ori r8,r7,MSR_FP // save fpscr and fpr13
3130+ mtmsr r8
3131+ isync
3132+ stfd fr13,xFPR13(r1)
3133+ mffs fr13
3134+ stfd fr13,xFPSCR-4(r1)
3135+ li r7,FPU_STATE_DIRTY
3136+ lfd fr13,xEMULATOR_FPSCR-4(r1) // We must restore FPSCR before since the emulator might
3137+ mtfsf 0xff,fr13 // use the FPU at any time, for instance in a signal handler.
3138+ stw r7,xFPU_STATE(r1) // Go to FPU_STATE_DIRTY
3139+
3140+ crclr FBIT_FPUInUse // FPU no longer in use
3141+ blr
3142+
3143+
3144+ ////////////////////////////////////////////////////////
3145+ // PREPARE_ERET
3146+ //
3147+ // M: r0,r2, r9-r11
3148+
3149+MACRO(PREP_ERET,[nip_variable], [
3150+ btl FBIT_MolDecLoaded, set_kernel_dec // M: r0,r2,r9-r11
3151+
3152+ lwz r10,_nip_variable[](r1)
3153+ mfcr r9
3154+ lwz r11,K_EMULATOR_MSR(r1)
3155+ mtsrr0 r10
3156+ lwz r2,K_EMULATOR_TOC(r1)
3157+ stw r9,xFLAG_BITS(r1)
3158+ mtsrr1 r11
3159+])
3160+
3161+ ////////////////////////////////////////////////////////
3162+ // mac_exit (return to emulator)
3163+ // r3 RVEC return code
3164+ //
3165+ // On stack: nip, ctr, lr, xer, r0-r12
3166+ // In registers: r13-r31
3167+
3168+mac_exit:
3169+ TRACE(0x2220, "mac_exit")
3170+ bl set_emulator_context // M: r0,r2,r7-r11,XER
3171+exit_:
3172+ PREP_ERET K_EMULATOR_NIP // M: r0-r2,r9-r11
3173+ GET_TICK_CNT(entry, "mac_exit")
3174+ lwz r1,K_EMULATOR_STACK(r1)
3175+ rfi
3176+
3177+
3178+ ////////////////////////////////////////////////////////
3179+ // take_exception (take a linux exception)
3180+ //
3181+ // On stack: nip, ctr, lr, xer, r0-r12
3182+ // In registers: r13-r31
3183+
3184+take_exception:
3185+ TRACE(0x2221, "take_exception")
3186+
3187+ mflr r12
3188+ bl set_emulator_context // M: r0,r2,r7-r11,XER
3189+
3190+ PREP_ERET K_EMULATOR_NIP // M: r0,r2,r9-r11
3191+ GET_TICK_CNT(entry, "take_exception")
3192+ lwz r1,K_EMULATOR_STACK(r1)
3193+ mtlr r12
3194+ li r3,RVEC_NOP
3195+ blr
3196+
3197+
3198+ //////////////////////////////////////////////////////////////
3199+ // call_kernel (call mol kernel routine)
3200+ // r3 kernel routine
3201+ // r4..r6 args
3202+ //
3203+ // On stack: nip, ctr, lr, xer, r0-r12
3204+ // In registers: r13-r31
3205+
3206+#ifdef __linux__
3207+call_kernel_save:
3208+ bl save_middle_regs // saves r8-r11, nip, ctr, xer
3209+call_kernel:
3210+ bl set_emulator_context // M: r0,r2,r7-r11,XER
3211+
3212+ TRACE(0x2222, "call_kernel")
3213+
3214+ lwz r8,K_KERNEL_VARS(r1) // r8 = kvars (lvptr)
3215+ PREP_ERET K_EMULATOR_KCALL_NIP // M: r0,r2,r9-r11
3216+ GET_TICK_CNT(entry, "call_kernel_save")
3217+ lwz r1,K_EMULATOR_STACK(r1)
3218+ ba 0x2f00 // MOL trampoline
3219+#endif
3220+
3221+/************************************************************************/
3222+/* Set Mac/Emulator Context */
3223+/************************************************************************/
3224+
3225+ //////////////////////////////////////////////////////////////
3226+ // set_mac_context [r0,r2-r12, ctr, --->XER<---]
3227+ //
3228+ // - clear BATs (except DBAT0)
3229+ // - setup sprgs
3230+ // - reload_sr loads segment registers later on
3231+ //
3232+ // Currently unmodified r8-r12, ctr
3233+
3234+set_mac_context:
3235+ // Save and setup SPRG2 (magic) and SPRG3 (mol stack)
3236+ mfsprg_a2 r6
3237+ mfsprg_a3 r7
3238+ stw r6,K_EMULATOR_SPRG2(r1)
3239+ stw r7,K_EMULATOR_SPRG3(r1)
3240+ li r2,MOL_SPRG2_MAGIC
3241+ mtsprg_a3 r1
3242+ mtsprg_a2 r2
3243+
3244+ li r4,0
3245+ mtspr IBAT0U,r4
3246+ mtspr IBAT1U,r4
3247+ mtspr IBAT2U,r4
3248+ mtspr IBAT3U,r4
3249+ // DBAT0 set from reload_sr
3250+ mtspr DBAT1U,r4
3251+ mtspr DBAT2U,r4
3252+ mtspr DBAT3U,r4
3253+#ifdef __darwin__
3254+ lwz r4,K_MOL_SDR1(r1)
3255+ mtsdr1 r4
3256+#endif
3257+ blr
3258+
3259+
3260+ ///////////////////////////////////////////////////////////////
3261+ // set_emulator_context [r0,r2,r7-r11,cr, --->XER<---]
3262+ //
3263+ // - load segr 0-15 with emulator context
3264+ // - restore BATs
3265+ // - restore DEC register
3266+
3267+set_emulator_context:
3268+ lwz r0,K_EMULATOR_SPRG2(r1)
3269+ lwz r2,K_EMULATOR_SPRG3(r1)
3270+ mtsprg_a2 r0
3271+ mtsprg_a3 r2
3272+
3273+ // Restore segment registers
3274+ addi r8,r1,K_EMULATOR_SR
3275+ LOAD_SEGMENT_REGS r8, /**/ r2,r10
3276+
3277+ // BATS, r11 = linux DEC
3278+
3279+ lwz r7,K_IBAT0U_SAVE(r1)
3280+ mtspr IBAT0U,r7
3281+ lwz r2,K_IBAT1U_SAVE(r1)
3282+ mtspr IBAT1U,r2
3283+ lwz r7,K_IBAT2U_SAVE(r1)
3284+ mtspr IBAT2U,r7
3285+ lwz r2,K_IBAT3U_SAVE(r1)
3286+ mtspr IBAT3U,r2
3287+
3288+ lwz r7,K_DBAT0U_SAVE(r1)
3289+ mtspr DBAT0U,r7
3290+ lwz r7,K_DBAT0L_SAVE(r1) // must also restore lower bat...
3291+ mtspr DBAT0L,r7
3292+ lwz r2,K_DBAT1U_SAVE(r1)
3293+ mtspr DBAT1U,r2
3294+ lwz r7,K_DBAT2U_SAVE(r1)
3295+ mtspr DBAT2U,r7
3296+ lwz r2,K_DBAT3U_SAVE(r1)
3297+ mtspr DBAT3U,r2
3298+#ifdef __darwin__
3299+ lwz r2,K_OS_SDR1(r1)
3300+ mtsdr1 r2
3301+ fix_sprg2 /**/ R2 // must not modify sprg2 (i.e. sprg_a0) under OSX 10.3
3302+#endif
3303+ blr
3304+
3305+
3306+/************************************************************************/
3307+/* Reload Segment Registers */
3308+/************************************************************************/
3309+
3310+ //////////////////////////////////////////////////////////////
3311+ // reload_sr
3312+ //
3313+ // r6 = mac-nip
3314+ //
3315+ // - loads segr 0-15 with mac context [modifies r3-r5]
3316+ // - reloads DBAT0 (used for splitmode)
3317+ //
3318+ // Modifies: r3-r5
3319+
3320+reload_sr:
3321+ bt FBIT_InSplitmode,prepare_splitmode // M: r0,r3-r5, r6=mac-nip
3322+
3323+ lwz r3,K_TRANSL_DBAT0L(r1)
3324+ lwz r4,K_TRANSL_DBAT0U(r1)
3325+ li r5,0
3326+ mtspr DBAT0L,r3
3327+ mtcrf MMU_CR_FIELD,r5 // clear FBIT_LoadSegreg (and splitmode stuff)
3328+ mtspr DBAT0U,r4
3329+1:
3330+ lwz r4,K_CUR_SR_BASE(r1)
3331+ LOAD_SEGMENT_REGS r4, /**/ r3,r5
3332+ blr
3333+
3334+ret_from_prep_splitmode:
3335+ lwz r3,K_SPLIT_DBAT0L(r1)
3336+ lwz r4,K_SPLIT_DBAT0U(r1)
3337+ li r5,fb_InSplitmode
3338+ mtspr DBAT0L,r3
3339+ mtcrf MMU_CR_FIELD,r5 // clear FBIT_LoadSegreg and FBIT_PrepareSplitmode
3340+ mtspr DBAT0U,r4
3341+ b 1b
3342--- /dev/null
3343+++ b/drivers/macintosh/mol/asm-files/iopage.S
3344@@ -0,0 +1,89 @@
3345+/*
3346+ * Creation Date: <97/07/26 18:23:02 samuel>
3347+ * Time-stamp: <2002/07/06 12:12:10 samuel>
3348+ *
3349+ * <iopage.S>
3350+ *
3351+ * IO low-level support
3352+ *
3353+ * Copyright (C) 2002 Samuel Rydh (samuel@ibrium.se)
3354+ *
3355+ * This program is free software; you can redistribute it and/or
3356+ * modify it under the terms of the GNU General Public License
3357+ * as published by the Free Software Foundation
3358+ *
3359+ */
3360+
3361+ // NOTE: This function is also called from the splitmode secondary interrupt
3362+ // handler (splitmode segment registers are resetup at return).
3363+
3364+
3365+ ///////////////////////////////////////////////////////////////////
3366+ // check_io_page
3367+ //
3368+ // xINST_OPCODE is always valid at this point
3369+ //
3370+ // Examine if the page (which DAR points to) is an I/O page.
3371+ // Safe to modify: r0,r2-r12
3372+
3373+check_io_page:
3374+ // Is this is an IO-page? IMPORTANT: we must *never* insert mappings
3375+ // that are unreadable by supervisor (will cause a freeze right here).
3376+
3377+ mfdsisr r10 // r10 = DSISR
3378+ rlwinm. r3,r10,0,1,1 // BIT 1 set if no PTE (or BAT mapping)
3379+ bnelr
3380+ mfdar r8
3381+
3382+ mfmsr r7
3383+ ori r3,r7,MSR_DR // set MSR_DR
3384+ mtmsr r3
3385+ isync
3386+
3387+ rlwinm r5,r8,0,0,19 // mask page index
3388+
3389+ // XXX: TO BE FIXED. These instruction will _never_ cause an exceptions on a
3390+ // single processor system. However, on a SMP machine we *could* receive a
3391+ // tlbie invalidate broadcast. Thus we must implement a secondary
3392+ // interrupt handler to cover that case.
3393+
3394+ lwz r2,IOP_MAGIC(r5)
3395+ lwz r3,IOP_MAGIC2(r5) // These should _never_ cause any exceptions
3396+ lwz r9,IOP_ME_PHYS(r5) // r9 = physical addr of iopage
3397+
3398+ mtmsr r7 // restore MSR
3399+ isync
3400+
3401+ lis r6,HI(IO_PAGE_MAGIC_1) // check MAGIC 1
3402+ ori r6,r6,LO(IO_PAGE_MAGIC_1)
3403+ cmplw r6,r2
3404+ bnelr
3405+
3406+ lis r7,HI(IO_PAGE_MAGIC_2) // check MAGIC 2
3407+ ori r7,r7,LO(IO_PAGE_MAGIC_2)
3408+ cmplw r7,r3
3409+ bnelr
3410+
3411+ // Obtain translation info from the iopage:
3412+ //
3413+ // r4 = mphys_ioaddr = iop->mphys | (dar & 0xfff);
3414+ // r5 = usr_data = iop->usr_data[ (dar & 0xfff) >> 3 ];
3415+ //
3416+ lwz r4,IOP_MPHYS(r9)
3417+ rlwimi r4,r8,0,20,31 // insert page offset
3418+
3419+ rlwinm r7,r8,32-1,21,29 // grain = double word
3420+ addi r7,r7,IOP_USR_DATA // usr_data[ (dar&0xfff) ]
3421+ lwzx r5,r9,r7 // r5 = usr_data
3422+
3423+ rlwinm. r2,r10,0,6,6 // was it a write? (r10=DSISR)
3424+ bne handle_write
3425+
3426+ // r4 = mphys_ioaddr
3427+ // r5 = usr_data
3428+ MAC_EXIT( RVEC_IO_READ )
3429+
3430+handle_write:
3431+ // r4 = mphys_ioaddr
3432+ // r5 = usr_data
3433+ MAC_EXIT( RVEC_IO_WRITE )
3434--- /dev/null
3435+++ b/drivers/macintosh/mol/asm-files/linux.S
3436@@ -0,0 +1,129 @@
3437+/*
3438+ * Creation Date: <2001/02/24 14:08:28 samuel>
3439+ * Time-stamp: <2003/09/03 12:34:20 samuel>
3440+ *
3441+ * <platform.S>
3442+ *
3443+ * Linux Kernel Hooks
3444+ *
3445+ * Copyright (C) 2001, 2002, 2003 Samuel Rydh (samuel@ibrium.se)
3446+ *
3447+ * This program is free software; you can redistribute it and/or
3448+ * modify it under the terms of the GNU General Public License
3449+ * as published by the Free Software Foundation
3450+ *
3451+ */
3452+
3453+ ////////////////////////////////////////////////////////
3454+ // flush_hash_page_hook
3455+ //
3456+ // Kernel hook
3457+ //
3458+ // r3: context
3459+ // r4: virtual address
3460+ // r5: 2.4.6 pointer to linux PTE (2.4.6 or later)
3461+ // 2.6 pmdval
3462+ // r6: 2.6 count
3463+ // r10: return address
3464+ //
3465+ // [must not modify: r3-r5,r10 - otherwise normal C-function]
3466+ // MMU is ON
3467+
3468+.set STACK_SPACE, 32
3469+.set STACK_LR, STACK_SPACE+4
3470+.set STACK_V0, 8
3471+.set STACK_V1, 12
3472+.set STACK_V2, 16
3473+.set STACK_V3, 20
3474+.set STACK_V4, 24
3475+.set STACK_V5, 28
3476+
3477+FHOOK( FHOOK_FLUSH_HASH_PAGE )
3478+GLOBAL_SYMBOL( r__flush_hash_page_hook ):
3479+ stwu r1,-STACK_SPACE(r1) // Push stackframe
3480+ mflr r0
3481+ stw r0,STACK_LR(r1)
3482+
3483+ LOADI r7,EXTERN(do_flush)
3484+ mtctr r7
3485+
3486+ stw r10,STACK_V1(r1) // Save registers
3487+ stw r3,STACK_V2(r1)
3488+ stw r4,STACK_V3(r1)
3489+ stw r5,STACK_V4(r1)
3490+#ifdef LINUX_26
3491+ stw r6,STACK_V5(r1)
3492+#else
3493+ li r6,1
3494+#endif
3495+ bctrl
3496+
3497+ lwz r10,STACK_V1(r1) // Restore registers
3498+ lwz r3,STACK_V2(r1)
3499+ lwz r4,STACK_V3(r1)
3500+ lwz r5,STACK_V4(r1)
3501+#ifdef LINUX_26
3502+ lwz r6,STACK_V5(r1)
3503+#endif
3504+
3505+ lwz r0,STACK_LR(r1) // Pop stackframe
3506+ addi r1,r1,STACK_SPACE
3507+ mtlr r0
3508+ blr
3509+
3510+
3511+/************************************************************************/
3512+/* lowmem reallocations */
3513+/************************************************************************/
3514+
3515+#ifdef CONFIG_SMP
3516+
3517+ /* r3=ea, r4=pte_slot, r5=pte1, r6=pte2, r7=lock, r8=lockval, M: r0 */
3518+RELOC_LOW(xx_store_pte_lowmem)
3519+1: lwarx r0,0,r7
3520+ cmpwi r0,0
3521+ bne- 1b
3522+ stwcx. r8,0,r7 // take hash lock
3523+ bne- 1b
3524+ // isync // sync below is sufficient
3525+ stw r0,0(r4) // clear old PTE[V] (if we evict something)
3526+ sync // probably not needed - no other CPU uses this PTE
3527+ stw r6,4(r4) // store PTE2
3528+ eieio
3529+ stw r5,0(r4) // store PTE1
3530+ tlbie r3 // flush old pte
3531+ eieio // order tlbie before tlbsync
3532+ tlbsync // ensure tlbie finish on all processors
3533+ sync // ensure tlbsync completed
3534+ stw r0,0(r7) // release hash lock
3535+ blr
3536+RELOC_LOW_END(xx_store_pte_lowmem)
3537+
3538+
3539+ /* r3=ea, r7=lock, r8=lockval, M: r0 */
3540+RELOC_LOW(xx_tlbie_lowmem)
3541+1: lwarx r0,0,r7
3542+ cmpwi r0,0
3543+ bne- 1b
3544+ stwcx. r8,0,r7 // take hash lock
3545+ bne- 1b
3546+ //isync // needed if we get rid of the sync
3547+ sync // make sure any PTE zero-outs have finished
3548+ tlbie r3 // flush old pte
3549+ eieio // order tlbie before tlbsync
3550+ tlbsync // ensure tlbie finish on all processors
3551+ sync // ensure tlbsync completed
3552+ stw r0,0(r7) // release hash lock
3553+ blr
3554+RELOC_LOW_END(xx_tlbie_lowmem)
3555+
3556+#else
3557+
3558+ /* r3=pte_slot, r4=pte0, r5=pte1 */
3559+RELOC_LOW(xx_store_pte_lowmem)
3560+ stw r4,0(r3) // interrupts are off and we won't take a page fault
3561+ stw r5,4(r3) // so this is safe...
3562+ blr
3563+RELOC_LOW_END(xx_store_pte_lowmem)
3564+
3565+#endif
3566--- /dev/null
3567+++ b/drivers/macintosh/mol/asm-files/ptintercept.S
3568@@ -0,0 +1,303 @@
3569+/*
3570+ * Creation Date: <2001/03/17 18:00:05 samuel>
3571+ * Time-stamp: <2003/05/26 00:08:48 samuel>
3572+ *
3573+ * <ptintercept.S>
3574+ *
3575+ * Handles writes to the (mac) hash table
3576+ *
3577+ * Copyright (C) 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
3578+ *
3579+ * This program is free software; you can redistribute it and/or
3580+ * modify it under the terms of the GNU General Public License
3581+ * as published by the Free Software Foundation
3582+ *
3583+ */
3584+
3585+//////////////////////////////////////////////////////////////////////
3586+// Implementing the tlbie instruction properly is tricky.
3587+// The tlbie is supposed to invalidate an equivalence
3588+// class of PTEs and this does not map well to the huge TLB
3589+// MOL uses (the linux PTE hash, a lot bigger than the 2x64
3590+// table found in most CPUs).
3591+//
3592+// The solution is intercepting PTE writes and maintain
3593+// coherence without relying on the tlbie instruction (which
3594+// can safely be replaced by a nop).
3595+//
3596+// Splitmode: The instruction sr might be active. DBAT0 does
3597+// _not_ have the supervisor valid bit set so we have to load
3598+// the data segment register.
3599+//////////////////////////////////////////////////////////////////////
3600+
3601+MACRO(SET_MSR_DR, [scr], [
3602+ li _scr,MSR_DR
3603+ mtmsr _scr
3604+ isync
3605+])
3606+MACRO(CLEAR_MSR_DR, [scr], [
3607+ li _scr,0
3608+ mtmsr _scr
3609+ isync
3610+])
3611+
3612+ // r3 = exception vector
3613+secint_pt_store:
3614+ bf+ FBIT_InSplitmode,1f
3615+ mfdar r2
3616+ lwz r4,K_TMP_SCRATCH0(r1) // in splitmode (might be
3617+ mtsrin r4,r2 // the instrucion sr)
3618+1:
3619+ lwz r6,xNIP(r1) // restore NIP & MSR
3620+ lwz r7,K_MSR(r1)
3621+ cmpwi r3,0x300
3622+ beq 1f
3623+ cmpwi r3,0x600 // Alignment
3624+ beq 2f
3625+ DEBUGGER_SAVE( 0x6909 )
3626+1: bl save_middle_regs
3627+ b dsi_cont
3628+2: bl save_middle_regs
3629+ b alignment_cont
3630+
3631+ ////////////////////////////////////////////////////////////////////////
3632+ // check_pthash_hit
3633+ //
3634+ // m: r0,r2-r5, cr
3635+
3636+check_pthash_hit:
3637+ mfdsisr r3
3638+ rlwinm. r4,r3,0,4,4 // Is this a protection violation?
3639+ beqlr
3640+ rlwinm. r4,r3,0,6,6 // and a write?
3641+ beqlr-
3642+
3643+ mfdar r2 // Is this a pthash hit?
3644+ lwz r3,K_TLBHASH_BASE_EA(r1) // First check EA...
3645+ lwz r4,K_HASH_MASK(r1)
3646+ sub r5,r2,r3
3647+ cmplw r5,r4
3648+ bgtlr+
3649+
3650+ lwz r5,K_SR_DATA(r1) // Correct context for EA?
3651+ rlwinm r3,r2,4+2,26,29 // #sr << 2
3652+ lwz r4,K_TLBHASH_SR(r1)
3653+ lwzx r3,r3,r5
3654+ cmpw r3,r4
3655+ bnelr-
3656+
3657+ /////////////////////////////////////////////////
3658+ // Handle page table write, r2=dar, r4=segreg
3659+ /////////////////////////////////////////////////
3660+
3661+ bf+ FBIT_InSplitmode,1f
3662+ mfsrin r3,r2 // save old segment register
3663+ stw r3,K_TMP_SCRATCH0(r1) // in splitmode (might be
3664+ mtsrin r4,r2 // the instrucion sr)
3665+1:
3666+ lwz r3,xINST_OPCODE(r1)
3667+ LI_PHYS( R4,secint_pt_store ) // r4 = secondary exception handler
3668+ stw r6,xNIP(r1)
3669+
3670+ // r2 = dar, r3 = opcode
3671+ rlwinm r0,r3,6,0x3e // primary opcode & ~1
3672+ rlwinm r5,r3,6+5+3,(0x1f<<3) // r5 = rS << 3
3673+ cmpwi r0,30 // 31 & ~1
3674+ beq- do_opcode_31
3675+ mtcrf 0x40,r3 // cr[5] = update bit
3676+ cmpwi r0,36 // 36, stw/stwu
3677+ beq do_stw
3678+ cmpwi r0,38 // 38, stb/stbu
3679+ beq do_stb
3680+ cmpwi r0,44 // 44, stb/stbu
3681+ beq do_sth
3682+ cmpwi r0,52 // 52, stfs/stsu
3683+ beq do_stfs
3684+ cmpwi r0,54 // 54, stfd/stfdu
3685+ beq do_stfd
3686+ cmpwi r0,46 // 47, stmw
3687+ beq do_stmw
3688+ b do_st_bad // ???
3689+
3690+do_opcode_31:
3691+ rlwinm r0,r3,32-1,22,31 // secondary opcode
3692+ rlwinm. r6,r3,0,(32<<1) // update form?
3693+ rlwinm r0,r0,0,~32 // clear update bit
3694+ crnot 5,eq
3695+
3696+ cmpwi r0,151 // stwx/stwxu
3697+ beq+ do_stw
3698+ cmpwi r0,215 // stbx / stbxu
3699+ beq- do_stb
3700+ cmpwi r0,150 // stwcx.
3701+ beq- do_stwcx
3702+ cmpwi r0,407 // sthx / sthxu
3703+ beq- do_sth
3704+ cmpwi r0,727 // stfdx / stfdxu
3705+ beq- do_stfd
3706+ cmpwi r0,663 // stfsx / stfsxu
3707+ beq- do_stfs
3708+ crclr 5
3709+ rlwinm r0,r3,32-1,22,31 // unmasked secondary opcode
3710+ cmpwi r0,470 // dcbi
3711+ beq- do_dcbi
3712+ cmpwi r0,1014 // dcbz
3713+ beq- do_dcbz
3714+ cmpwi r0,983 // stfiwx [optional]
3715+ beq- do_stfiw
3716+ cmpwi r0,725 // stswi
3717+ beq- do_stswi
3718+ cmpwi r0,661
3719+ beq- do_stswx
3720+ b do_st_bad // float, cache or altivec
3721+
3722+do_st_bad:
3723+do_stfd:
3724+do_stfs:
3725+do_stfiw:
3726+do_stswi:
3727+do_stswx:
3728+ lwz r6,xNIP(r1)
3729+ DEBUGGER_SAVE(0x1882) // unimplemented store instruction
3730+
3731+ // r2=dar, r3=opcode, r4=secint_handler, r5=rS_offs
3732+do_dcbi:
3733+do_dcbz:
3734+ mtlr r4
3735+ SET_MSR_DR /**/ r6
3736+ rlwinm r6,r2,0,~0x7
3737+ lwz r4,0(r6)
3738+ lwz r5,4(r6)
3739+ dcbz 0,r2
3740+ CLEAR_MSR_DR /**/ r0
3741+ b st_continue_2
3742+do_stwcx:
3743+ EMU_LOAD_GPR r5, /**/ R6 // r0 = value
3744+ mtlr r4
3745+ SET_MSR_DR /**/ r6
3746+ rlwinm r6,r2,0,~0x7
3747+ lwz r4,0(r6)
3748+ lwz r5,4(r6)
3749+ stwcx. r0,0,r2
3750+ CLEAR_MSR_DR /**/ r0
3751+ lwz r6,xCR(r1)
3752+ mfcr r0
3753+ rlwimi r6,r0,0,0,3
3754+ stw r6,xCR(r1)
3755+ b st_continue_2
3756+do_sth:
3757+ EMU_LOAD_GPR r5, /**/ R6 // r0 = value
3758+ mtlr r4
3759+ SET_MSR_DR /**/ r6
3760+ rlwinm r6,r2,0,~0x7
3761+ lwz r4,0(r6)
3762+ lwz r5,4(r6)
3763+ sth r0,0(r2)
3764+ b st_continue
3765+do_stb:
3766+ EMU_LOAD_GPR r5, /**/ R6 // r0 = value
3767+ mtlr r4
3768+ SET_MSR_DR /**/ r6
3769+ rlwinm r6,r2,0,~0x7
3770+ lwz r4,0(r6)
3771+ lwz r5,4(r6)
3772+ stb r0,0(r2)
3773+ b st_continue
3774+do_stw:
3775+ EMU_LOAD_GPR r5, /**/ R6 // r0 = value
3776+ mtlr r4
3777+ SET_MSR_DR /**/ r6
3778+ rlwinm r6,r2,0,~0x7
3779+ lwz r4,0(r6)
3780+ lwz r5,4(r6)
3781+ stw r0,0(r2)
3782+ b st_continue
3783+
3784+ // r4=PTE0, r5=PTE1, r3=opcode, r2=dar, scratch: r0
3785+st_continue:
3786+ CLEAR_MSR_DR /**/ r0
3787+ bf+ 5,st_continue_2 // update form?
3788+ rlwinm r3,r3,6+5+5+3,(31<<3)
3789+ mr r0,r2
3790+ EMU_STORE_GPR r3, /**/ R6 // r0 = value
3791+st_continue_2:
3792+ // check if the old PTE has been used (r2=dar,r4/r5=PTE)
3793+ lwz r3,K_TLBHASH_BASE_EA(r1) // Calculate tlb offset
3794+ sub r0,r2,r3 // r0 = pte_nr * 8
3795+ lwz r6,K_PTHASH_INUSE_PH(r1)
3796+ rlwinm r3,r0,32-6,6,29 // r3 = word offset
3797+ cmpwi r6,0
3798+ beq- 1f
3799+ lwzx r3,r3,r6
3800+ rlwinm r6,r2,32-3,27,31 // pte_nr & 0x1f
3801+ li r0,1
3802+ slw r6,r0,r6 // r6 = bit
3803+ and. r6,r6,r3
3804+ GET_TICK_CNT(entry,"ptintercept-1")
3805+ bne- pt_intercept
3806+1:
3807+ BUMP("pt_intercept_not_taken")
3808+ // return from exception [r2=dar]
3809+ lwz r6,xNIP(r1) // restore r6
3810+ bf+ FBIT_InSplitmode,emulation_done
3811+ lwz r3,K_TMP_SCRATCH0(r1) // in splitmode (might be
3812+ mtsrin r3,r2 // the instrucion sr)
3813+ b emulation_done
3814+
3815+ // transfer to C-function [r2=dar, r3/r4=pte]
3816+pt_intercept:
3817+ BUMP("pt_intercept_taken")
3818+ lwz r6,xNIP(r1) // restore r6
3819+ lwz r3,K_TLBHASH_BASE_EA(r1) // calculate tlb offset
3820+ addi r6,r6,4 // inc NIP
3821+ bl save_middle_regs
3822+ sub r6,r2,r3
3823+ rlwinm r6,r6,0,0,28 // argument pteoffs (dword aligned)
3824+
3825+ // r4=PTE0, r5=PTE1
3826+ LOADI r3,EXTERN(do_intercept_tlbie)
3827+ b call_kernel
3828+
3829+ // stmw uses another emulator entry point because it might overwrite a bunch of PTEs
3830+do_stmw:
3831+ mtlr r4
3832+
3833+ // save some debugging info
3834+// stw r2,xDBG_TRACE_SPACE(r1)
3835+
3836+ SET_MSR_DR /**/ r6
3837+
3838+ // now do the stmw. we do that manually since we have to access emulator regs.
3839+ mr r4,r2 // r4: memory pointer
3840+ srwi r6,r5,3 // r6: rS
3841+1: cmpwi r5,32 << 3 // loop condition
3842+ bge 2f
3843+ EMU_LOAD_GPR r5, /**/ R3 // r0 = value
3844+ stw r0,0(r4) // store the value
3845+ addi r5,r5,1 << 3 // update register counter
3846+ addi r4,r4,4 // and memory pointer
3847+ b 1b
3848+
3849+2: CLEAR_MSR_DR /**/ r0
3850+
3851+ // load up r4 and r5 for do_intercept_tlbie_block (see below)
3852+ subfic r5,r6,32 // number of registers (=words) stored
3853+ slwi r5,r5,2 // number of bytes stored
3854+ add r4,r2,r5 // last byte stored
3855+ addi r4,r4,7 // alignment to
3856+ rlwinm r5,r4,0,~0x7 // PTE size
3857+ rlwinm r4,r2,0,~0x7 // pte block pointer
3858+ sub r5,r5,r4 // substract block pointer -> length (in bytes)
3859+ lwz r3,K_TLBHASH_BASE_EA(r1) // calculate tlb offset
3860+ sub r4,r4,r3 // tlb offset
3861+ b st_block_continue
3862+
3863+ // transfer to C-function [r2=dar, r4=pte block offset, r5=pte block length]
3864+st_block_continue:
3865+ BUMP("pt_intercept_taken")
3866+ lwz r6,xNIP(r1)
3867+ addi r6,r6,4 // inc NIP
3868+ bl save_middle_regs
3869+
3870+ LOADI r3,EXTERN(do_intercept_tlbie_block)
3871+ b call_kernel
3872--- /dev/null
3873+++ b/drivers/macintosh/mol/asm-files/splitmode.S
3874@@ -0,0 +1,428 @@
3875+/*
3876+ * Creation Date: <2000/07/11 03:38:32 samuel>
3877+ * Time-stamp: <2003/08/20 16:37:04 samuel>
3878+ *
3879+ * <splitmode.S>
3880+ *
3881+ * Handles splitmode (MSR_IR != MSR_DR)
3882+ *
3883+ * Copyright (C) 2000, 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
3884+ *
3885+ * This program is free software; you can redistribute it and/or
3886+ * modify it under the terms of the GNU General Public License
3887+ * as published by the Free Software Foundation
3888+ *
3889+ */
3890+
3891+MACRO(SM_SET_MSR_DR, [scr], [
3892+ li _scr,MSR_DR
3893+ mtmsr _scr
3894+ isync
3895+])
3896+MACRO(SM_CLEAR_MSR_DR, [scr], [
3897+ li _scr,0
3898+ mtmsr _scr
3899+ isync
3900+])
3901+MACRO(SPLITMODE_SMP_LOCK, [scr1,scr2], [
3902+#ifdef CONFIG_SMP
3903+ LI_PHYS( _scr1,splitmode_lock )
3904+7: lwarx _scr2,0,_scr1
3905+ cmpwi _scr2,0
3906+ li _scr2,1
3907+ bne- 7b
3908+ stwcx. _scr2,0,_scr1
3909+ bne- 7b
3910+ isync
3911+#endif
3912+])
3913+MACRO(SPLITMODE_SMP_UNLOCK, [scr1,scr2], [
3914+#ifdef CONFIG_SMP
3915+ LI_PHYS( _scr1,splitmode_lock )
3916+ li _scr2,0
3917+ stw _scr2,0(_scr1)
3918+#endif
3919+])
3920+
3921+ /////////////////////////////////////////////////////////////
3922+ // prepare_splitmode
3923+ //
3924+ // r6,r7: nip/srr1
3925+ //
3926+ // M: r0,r3-r5
3927+ //
3928+ // Fill in splitmode segment register table. The segment register
3929+ // containing xNIP is set up for instruction access (if xNIP does
3930+ // not hold nip, an extra ISI exception will occur). The instruction
3931+ // segment is protected from data access through the use of a DBAT
3932+ // register.
3933+ //
3934+ // It MUST be safe to call this function even if we are *not* in
3935+ // splitmode.
3936+
3937+prepare_splitmode:
3938+ bf FBIT_PrepareSplitmode, ret_from_prep_splitmode
3939+
3940+ ZERO_TICK_CNT(splitmode_prep)
3941+
3942+ // fill split mode table with data segment registers
3943+ lwz r3,K_SR_DATA(r1) // physical addr
3944+ addi r4,r1,K_SPLIT_SR_BASE-4
3945+ li r5,16
3946+ mfctr r0 // save ctr in r0
3947+ mtctr r5
3948+ addi r3,r3,-4
3949+1: lwzu r5,4(r3)
3950+ oris r5,r5,0x1000 // no-execute segment bit
3951+ stwu r5,4(r4)
3952+ bdnz 1b
3953+ mtctr r0 // restore ctr
3954+
3955+ // insert instruction mode segment
3956+ rlwinm r3,r6,0,0,3
3957+ stw r3,K_SPLIT_NIP_SEGMENT(r1)
3958+ rlwinm r3,r6,4+2,26,29 // r3 = offset, ((sr & 0xf000000) >> 28 ) * 4
3959+ lwz r5,K_SR_INST(r1)
3960+ lwzx r5,r3,r5 // segment register for instructions
3961+ addi r4,r1,K_SPLIT_SR_BASE
3962+ stwx r5,r3,r4
3963+
3964+ // and protect it with DBAT0.
3965+ //
3966+ // The supervisor valid bit must be cleared
3967+ // - we don't want to block get_opcode.
3968+
3969+ rlwinm r3,r6,0,0,3 // segment base
3970+ ori r3,r3,0x1ffd // user valid bit | 256MB mask
3971+ stw r3,K_SPLIT_DBAT0U(r1)
3972+ li r4,0
3973+ stw r4,K_SPLIT_DBAT0L(r1) // pp=0, wimg=0
3974+ GET_TICK_CNT(splitmode_prep, "splitmode_prep")
3975+ b ret_from_prep_splitmode
3976+
3977+
3978+ ///////////////////////////////////////////////////////////////////
3979+ // split_sr_no_execute
3980+ //
3981+ // r6,r7: nip/srr1
3982+ //
3983+ // An instruction is to be fetched from one of the no-execute
3984+ // segments. This function reinitializes the segment registers.
3985+ //
3986+ // M: r0, r3-r5
3987+
3988+split_sr_no_execute:
3989+ rlwinm. r0,r7,0,3,3 // Guarded access or no-execute?
3990+ beqlr
3991+
3992+ rlwinm r3,r6,0,0,3 // segment
3993+ lwz r4,K_SPLIT_NIP_SEGMENT(r1)
3994+ cmpw r3,r4
3995+ beqlr // guarded PTE/mac-guarded segment
3996+
3997+ crset FBIT_PrepareSplitmode
3998+ crset FBIT_LoadSegreg
3999+ b exception_return
4000+
4001+
4002+
4003+ //////////////////////////////////////////////////////////////////
4004+ // splitmode_dsi
4005+ //
4006+ // r6/r7: nip/srr1
4007+ //
4008+ // An DSI exception occured (DBAT protection violation).
4009+ // That is, a load/store instruction targeted the segment
4010+ // instructions was fetched from.
4011+ //
4012+ // Safe to modify: r0,r2-r5, (lr)
4013+
4014+splitmode_dsi:
4015+ mfdsisr r3 // DBAT/page protection violation?
4016+ rlwinm. r0,r3,0,4,4
4017+ beqlr- // If not, it does not concern us
4018+
4019+ mfdar r2 // Normal page protected exception?
4020+ lwz r4,K_SPLIT_NIP_SEGMENT(r1) // the instruction segment?
4021+ rlwinm r5,r2,0,0,3 // data segment
4022+ cmpw r4,r5
4023+ bnelr // exit - not in the instruction segment
4024+
4025+ // splitmode write, r2=dar
4026+ mfsrin r0,r2 // r0 = old segment register
4027+ stw r6,xNIP(r1) // need one additional reg
4028+ rlwinm r4,r2,4+2,26,29 // sr_offset = sr_num * 4
4029+ lwz r5,K_SR_DATA(r1)
4030+ lwzx r4,r4,r5
4031+ stw r0,K_TMP_SCRATCH0(r1) // save old segment register
4032+ oris r4,r4,0x4000 // set supervisor key bit (Ks)
4033+ mtsrin r4,r2
4034+
4035+ rlwinm. r3,r3,0,6,6 // cr[eq] set if this a read
4036+ lwz r3,xINST_OPCODE(r1)
4037+ LI_PHYS( R4, secint_splitm ) // r4 = secint handler
4038+
4039+ // handle simple stores r2=seg#, r3=opcode, r4=secint
4040+ beq splitm_load
4041+
4042+ rlwinm r5,r3,6+5+3,(0x1f<<3) // r5 = rS << 3
4043+ EMU_LOAD_GPR r5, /**/ R6 // r0 = value
4044+ mtlr r4 // secint handler
4045+ SM_SET_MSR_DR /**/ r5
4046+
4047+ rlwinm r6,r3,6,0x3e // primary opcode & ~1
4048+ mtcrf 0x40,r3 // cr[5] = update bit (if opcode != 31)
4049+ cmpwi r6,30 // 31 & ~1
4050+ beq- splitm_store_op31
4051+ cmpwi r6,36 // 36, stw/stwu
4052+ beq splitm_stw
4053+ cmpwi r6,38 // 38, stb/stbu
4054+ beq splitm_stb
4055+ cmpwi r6,44 // 44, stb/stbu
4056+ beq splitm_sth
4057+ b splitm_fallback
4058+splitm_store_op31:
4059+ rlwinm. r6,r3,0,(32<<1) // update form?
4060+ rlwinm r6,r3,32-1,22,31 // secondary opcode
4061+ rlwinm r6,r6,0,~32 // clear update bit
4062+ crnot 5,eq
4063+ cmpwi r6,151 // stwx/stwxu
4064+ beq+ splitm_stw
4065+ cmpwi r6,215 // stbx / stbxu
4066+ beq- splitm_stb
4067+ cmpwi r6,407 // sthx / sthxu
4068+ beq- splitm_sth
4069+ rlwinm r6,r3,32-1,22,31 // secondary opcode
4070+ cmpwi r6,150 // stwcx.
4071+ beq- splitm_stwcx
4072+ cmpwi r6,1014 // 1014, dcbz
4073+ beq- splitm_dcbz
4074+ cmpwi r6,662 // 662, stwbrx
4075+ beq- splitm_stwbrx
4076+ b splitm_fallback
4077+
4078+splitm_load:
4079+ mtlr r4 // secint handler
4080+ SM_SET_MSR_DR /**/ r5
4081+ rlwinm r6,r3,6,0x3e // primary opcode & ~1
4082+ mtcrf 0x40,r3 // cr[5] = update bit (if opcode != 31)
4083+ cmpwi r6,30 // 31 & ~1
4084+ beq- splitm_load_op31
4085+ cmpwi r6,32 // 32, lwz/lwzu
4086+ beq+ splitm_lwz
4087+ cmpwi r6,34 // 34, lbz/lbzu
4088+ beq- splitm_lbz
4089+ cmpwi r6,40 // 40, lhz/lhzu
4090+ beq- splitm_lhz
4091+ b splitm_fallback
4092+splitm_load_op31:
4093+ rlwinm. r6,r3,0,(32<<1) // update form?
4094+ rlwinm r6,r3,32-1,22,31 // secondary opcode
4095+ rlwinm r6,r6,0,~32 // clear update bit
4096+ crnot 5,eq
4097+ cmpwi r6,23 // 23, lwzx/lwzux
4098+ beq+ splitm_lwz
4099+ cmpwi r6,87 // 87, lbzx/lbzux
4100+ beq- splitm_lbz
4101+ cmpwi r6,279 // 279, lhzx/lhzux
4102+ beq- splitm_lhz
4103+ rlwinm r6,r3,32-1,22,31 // secondary opcode
4104+ crclr 5
4105+ cmpwi r6,20 // 20, lwarx
4106+ beq- splitm_lwarx
4107+ cmpwi r6,86 // 86, dcbf
4108+ beq- splitm_dcbf
4109+ cmpwi r6,982 // 982, icbi
4110+ beq- splitm_icbi
4111+ cmpwi r6,534 // 534, lwbrx
4112+ beq- splitm_lwbrx
4113+ b splitm_fallback
4114+
4115+
4116+ // r0=value, r2=ea, r3=opcode
4117+splitm_stwcx:
4118+ stwcx. r0,0,r2
4119+ SM_CLEAR_MSR_DR /**/ r0
4120+ lwz r6,xCR(r1)
4121+ mfcr r0
4122+ rlwimi r6,r0,0,0,3
4123+ stw r6,xCR(r1)
4124+ b splitm_done2
4125+splitm_sth:
4126+ sth r0,0(r2)
4127+ b splitm_store_continue
4128+splitm_stb:
4129+ stb r0,0(r2)
4130+ b splitm_store_continue
4131+splitm_stw:
4132+ stw r0,0(r2)
4133+ b splitm_store_continue
4134+splitm_lwz:
4135+ lwz r0,0(r2)
4136+ b splitm_load_continue
4137+splitm_lhz:
4138+ lhz r0,0(r2)
4139+ b splitm_load_continue
4140+splitm_lbz:
4141+ lbz r0,0(r2)
4142+ b splitm_load_continue
4143+splitm_lwarx:
4144+ lwarx r0,0,r2
4145+ b splitm_load_continue
4146+splitm_lwbrx:
4147+ lwbrx r0,0,r2
4148+ b splitm_load_continue
4149+splitm_dcbz:
4150+ dcbz 0,r2
4151+ b splitm_done
4152+splitm_icbi:
4153+ icbi 0,r2
4154+ b splitm_done
4155+splitm_dcbf:
4156+ dcbf 0,r2
4157+ b splitm_done
4158+splitm_stwbrx:
4159+ stwbrx r0,0,r2
4160+ b splitm_done
4161+
4162+splitm_load_continue:
4163+ SM_CLEAR_MSR_DR /**/ r4
4164+ BUMP("splitm_load")
4165+ rlwinm r4,r3,6+5+3,(0x1f<<3) // r5 = rS << 3
4166+ EMU_STORE_GPR r4, /**/ R6 // r0 = value
4167+ bf+ 5,splitm_done2 // update form?
4168+ b 1f
4169+
4170+splitm_store_continue:
4171+ SM_CLEAR_MSR_DR /**/ r0
4172+ BUMP("splitm_store")
4173+ bf+ 5,splitm_done2 // update form?
4174+1: rlwinm r3,r3,6+5+5+3,(31<<3)
4175+ mr r0,r2
4176+ EMU_STORE_GPR r3, /**/ R6 // r0 = value
4177+ b splitm_done2
4178+splitm_done:
4179+ SM_CLEAR_MSR_DR /**/ r0
4180+splitm_done2:
4181+ lwz r3,K_TMP_SCRATCH0(r1)
4182+ lwz r6,xNIP(r1) // restore NIP
4183+ mtsrin r3,r2
4184+ b emulation_done
4185+
4186+
4187+ // fallback, store and execute the instruction, r3=opcode
4188+splitm_fallback:
4189+ SM_CLEAR_MSR_DR /**/ r0
4190+#if 0
4191+ stw r3,xDEBUG1(r1)
4192+ stw r6,xDEBUG0(r1)
4193+ lwz r6,xNIP(r1)
4194+ DEBUGGER_SAVE(0x1111)
4195+#endif
4196+ SPLITMODE_SMP_LOCK /**/ r0,r2
4197+
4198+ BUMP("splitm_fallback")
4199+ bl secint_splitm_fallback // set secondary exception handler
4200+
4201+ LI_PHYS( R2,split_store_patch ) // r2 = addr of split_store_patch
4202+ stw r3,0(r2) // store instruction
4203+ dcbst 0,r2
4204+ sync
4205+ icbi 0,r2
4206+ sync // 74xx needs this
4207+
4208+ mtsrr0 r2 // The simplest thing is to do an RFI
4209+ LOADI r3,(MSR_EE | MSR_PR | MSR_IR | MSR_SE | MSR_BE)
4210+ andc r4,r7,r3 // Clear msr bits (r7=srr1)
4211+ xGPR_LOAD R6
4212+ xGPR_LOAD R7
4213+ mtsrr1 r4
4214+ xGPR_LOAD_RANGE R2,R5,r1 // Restore registers (except r1)
4215+ xGPR_LOAD R0
4216+ xGPR_LOAD R1
4217+ rfi
4218+
4219+split_store_patch:
4220+ nop
4221+
4222+ mtsprg_a0 r1 // restore MSR
4223+ li r1,MSR_ME
4224+ mtmsr r1
4225+ isync
4226+ mfsprg_a3 r1 // and stack pointer
4227+
4228+ xGPR_SAVE_RANGE R2,R7,r1
4229+ SPLITMODE_SMP_UNLOCK /**/ r3,r4
4230+
4231+ mfsprg_a0 r2 // r1 - to be saved
4232+ lwz r6,xNIP(r1) // restore r6,r7 and segment register
4233+ lwz r7,K_MSR(r1)
4234+ stw r0,xGPR0(r1)
4235+ stw r2,xGPR1(r1)
4236+ lwz r2,K_TMP_SCRATCH0(r1)
4237+ mtsrin r2,r6
4238+
4239+ GET_TICK_CNT( entry, "splitmode_dsi" )
4240+ b emulation_done
4241+
4242+
4243+ //////////////////////////////////////////////////////////////////////
4244+ // secint_splitm / secint_splitm_fallback
4245+ // r1: stack (sprg1 = old r1)
4246+ // r3: vector index (sprg0 = old r3)
4247+ // srr0/srr1: kernel nip/msr
4248+ //
4249+ // xGPR(0-5) are valid (unless this is a trace exception)
4250+
4251+secint_splitm_fallback:
4252+ blrl
4253+ SPLITMODE_SMP_UNLOCK /**/ R2,R4
4254+
4255+secint_splitm:
4256+ lwz r6,xNIP(r1) // Restore nip/msr
4257+ lwz r7,K_MSR(r1)
4258+
4259+ cmpwi r3,0x300 // ** DSI **
4260+ bne- 1f
4261+ mfsrin r2,r6 // r6 = NIP
4262+ rlwinm r2,r2,0,2,0 // Clear Ks [bit1] (supervisor key bit)
4263+ mtsrin r2,r6
4264+ bl save_middle_regs // Note: If dsi_cont ever returns immediately,
4265+ bl check_io_page // we will need to fix the segment registers before
4266+ b dsi_cont // the last dsi_cont branch.
4267+
4268+1: lwz r2,K_TMP_SCRATCH0(r1) // We might return immediately...
4269+ mtsrin r2,r6
4270+
4271+ cmpwi r3,0x600 // ** Alignment **
4272+ bne 2f
4273+ bl save_middle_regs
4274+ b alignment_cont
4275+
4276+2: cmpwi r3,0x800 // ** FPU Unavailable **
4277+ beq fpu_cont
4278+ cmpwi r3,0xf20 // ** AltiVec Unavailable **
4279+ beq altivec_cont
4280+
4281+ DEBUGGER_SAVE( 0x5918 ) // ERROR...
4282+
4283+
4284+ ////////////////////////////////////////////////////////////////////////
4285+ // invalidate_splitmode( kernel_vars_t *kv )
4286+ //
4287+ // This function must be called whenever the segment registers are
4288+ // modified. A flag is set which will force a refresh of the slitmode
4289+ // segment registers (at mac context switch in). We could rewrite this
4290+ // in C but it might be better to keep things centralized.
4291+
4292+GLOBAL_SYMBOL(r__invalidate_splitmode_sr):
4293+ // this will have no effect if fb_InSplitmode is not set
4294+ lwz r4,xFLAG_BITS(r3)
4295+ ori r4,r4,fb_PrepareSplitmode | fb_LoadSegreg
4296+ stw r4,xFLAG_BITS(r3)
4297+ blr
4298+
4299+#ifdef CONFIG_SMP
4300+splitmode_lock:
4301+ .long 0
4302+#endif
4303--- /dev/null
4304+++ b/drivers/macintosh/mol/asm-files/traps.S
4305@@ -0,0 +1,501 @@
4306+/*
4307+ * Creation Date: <2001/01/27 16:25:14 samuel>
4308+ * Time-stamp: <2004/03/07 21:58:48 samuel>
4309+ *
4310+ * <traps.S>
4311+ *
4312+ * Exception Vectors
4313+ *
4314+ * Copyright (C) 2000, 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
4315+ *
4316+ * This program is free software; you can redistribute it and/or
4317+ * modify it under the terms of the GNU General Public License
4318+ * as published by the Free Software Foundation
4319+ *
4320+ */
4321+
4322+#define DBG_TRACE 0 // enable TRACE macro?
4323+
4324+#include "archinclude.h"
4325+#include "processor.h" /* avoid <asm/processor.h> (bogus SPRN_TBWU/L) */
4326+#include "asm_offsets.h"
4327+#include "asmdefs.h"
4328+#include "molasm.h"
4329+#include "asmdbg.h"
4330+#include "actions.h"
4331+#include "vector.h"
4332+#include "rvec.h"
4333+#include "constants.h"
4334+#include "mac_registers.h"
4335+#include "mmu.h"
4336+#include "osi.h"
4337+#include "kernel_vars.h"
4338+
4339+
4340+/************************************************************************/
4341+/* Exception Vector Definitions */
4342+/************************************************************************/
4343+
4344+ ACTIONS_SECTION
4345+GLOBAL_SYMBOL(r__actions_section):
4346+ ACTIONS_OFFS_SECTION
4347+GLOBAL_SYMBOL(r__actions_offs_section):
4348+
4349+ .text
4350+GLOBAL_SYMBOL(r__reloctable_start):
4351+
4352+MACRO_0(EXCEPTION_PREAMBLE, [
4353+ // SPRG1 = r1, SPRG0 = r3, r3=CR, r1=MOL_STACK
4354+ __ZERO_TICK_CNT(entry)
4355+ stw r4,xGPR4(r1) // store instruction are store serializing
4356+ lwz r4,xFLAG_BITS(r1)
4357+ stw r5,xGPR5(r1) // and mix very badly with execution serializing
4358+ stw r6,xGPR6(r1) // instructions (like mfspr)
4359+ mfsrr0 r6
4360+ stw r7,xGPR7(r1)
4361+ mfsrr1 r7
4362+ stw r0,xGPR0(r1)
4363+ mtcr r4
4364+ stw r2,xGPR2(r1)
4365+ mflr r2
4366+ stw r3,xCR(r1)
4367+ mfsprg_a1 r5 // SPRG1 = r1
4368+ stw r2,xLINK(r1)
4369+ mfsprg_a0 r3 // SPRG0 = r3
4370+ stw r5,xGPR1(r1)
4371+ stw r3,xGPR3(r1)
4372+
4373+ // saved: r0-r7, cr, lr
4374+ // r1 = stack, cr5-7=flag_bits, r6/r7 = nip/msr
4375+])
4376+
4377+ balign_32
4378+save_middle_regs: // save r8-r12 and nip (r13-r31 should always be in regs)
4379+ stw r6,xNIP(r1)
4380+ mfxer r7
4381+ mfctr r6
4382+ stw r8,xGPR8(r1)
4383+ stw r9,xGPR9(r1)
4384+ stw r10,xGPR10(r1)
4385+ stw r11,xGPR11(r1)
4386+ stw r12,xGPR12(r1)
4387+ stw r6,xCTR(r1)
4388+ stw r7,xXER(r1)
4389+ bt- FBIT_FPUInUse,giveup_fpu // modifies r7/r8
4390+ blr
4391+
4392+MACRO_0(RESTORE_MIDDLE_REGS, [ // reverse save_middle_regs, restores registers
4393+ lwz r11,xCTR(r1) // r8-r12, ctr, xer, r6/r7 = nip/msr
4394+ lwz r12,xXER(r1)
4395+ lwz r8,xGPR8(r1)
4396+ lwz r9,xGPR9(r1)
4397+ mtctr r11
4398+ lwz r10,xGPR10(r1)
4399+ lwz r11,xGPR11(r1)
4400+ mtxer r12
4401+ lwz r12,xGPR12(r1)
4402+ lwz r6,xNIP(r1)
4403+ lwz r7,K_MSR(r1)
4404+])
4405+
4406+#define EXCEPTION_SAVE_ALL \
4407+ EXCEPTION_PREAMBLE ;\
4408+ bl save_middle_regs ;
4409+
4410+#define VECTOR_KERNEL( v, dummy_name, secint ) \
4411+ VECTOR( v, dummy_name, secint ) ;\
4412+ EXCEPTION_SAVE_ALL ;\
4413+ TAKE_EXCEPTION( v ) ;
4414+
4415+#define VECTOR_RESERVED( v, dummy_name, secint ) \
4416+ VECTOR( v, dummy_name, secint ) ;\
4417+ DEBUGGER_SAVE( v ) ;
4418+
4419+#define MAC_EXIT( rvec_code ) \
4420+ li r3,rvec_code ;\
4421+ b mac_exit ;
4422+
4423+#define MAC_EXIT_SAVE( rvec_code ) \
4424+ bl save_middle_regs ;\
4425+ li r3,rvec_code ;\
4426+ b mac_exit ;
4427+
4428+#define MAC_TRAP( trap_num ) \
4429+ li r2,trap_num ;\
4430+ b mac_trap ;
4431+
4432+#define DEBUGGER(n) li r4,n ; MAC_EXIT( RVEC_DEBUGGER );
4433+#define DEBUGGER_SAVE(n) li r4,n ; MAC_EXIT_SAVE( RVEC_DEBUGGER );
4434+
4435+
4436+/************************************************************************/
4437+/* Misc macros */
4438+/************************************************************************/
4439+
4440+ //////////////////////////////////////////////////////////////
4441+ // _get_instr_opcode
4442+ // r6 nip
4443+ // ret: r4 opcode
4444+ //
4445+ // Modifies: r2,r3.
4446+ // Side-effects: Might return from the exception
4447+
4448+MACRO(GET_INSTR_OPCODE, [dummy], [
4449+ mfmsr r3 // r3 = exception MSR
4450+ ori r2,r3,MSR_DR
4451+ bl 8f
4452+
4453+ // secondary interrupt entry (we _know_ this must be a DSI)
4454+#ifdef CONFIG_SMP
4455+ LOADI r5,EXTERN(compat_hash_table_lock)
4456+ li r4,1
4457+ tophys r5,r5
4458+7: lwarx r0,0,r5 // lock
4459+ cmpwi r0,0
4460+ bne- 7b
4461+ stwcx. r4,0,r5
4462+ bne- 7b
4463+ isync
4464+ tlbie r6
4465+ eieio
4466+ tlbsync
4467+ sync
4468+ stw r0,0(r5) // release lock
4469+#else
4470+ tlbie r6 // flush PTE from ITLB
4471+#endif
4472+ b exception_return
4473+8:
4474+ mtmsr r2
4475+ isync
4476+
4477+ lwz r4,0(r6) // get opcode
4478+
4479+ mtmsr r3 // restore exception MSR
4480+ isync
4481+])
4482+
4483+/************************************************************************/
4484+/* Reserved / Kernel Vectors */
4485+/************************************************************************/
4486+
4487+VECTOR_KERNEL( 0x100, "System Reset", secint_bad )
4488+VECTOR_KERNEL( 0x500, "External Interrupt", secint_bad )
4489+VECTOR_KERNEL( 0x1400, "System Management Interrupt", secint_bad )
4490+VECTOR_KERNEL( 0x1700, "Thermal Management Interrupt", secint_bad )
4491+
4492+VECTOR_RESERVED( 0x200, "Machine Check", secint_bad )
4493+VECTOR_RESERVED( 0xa00, "Reserved", secint_bad )
4494+VECTOR_RESERVED( 0xb00, "Reserved", secint_bad )
4495+VECTOR_RESERVED( 0xe00, "FPU Assist", secint_bad )
4496+
4497+PERFMON_VECTOR_RELOCATION( PERFMON_VECTOR )
4498+VECTOR_RESERVED( PERFMON_VECTOR, "Performance Monitor Interrupt", secint_bad )
4499+
4500+//VECTOR_RESERVED( 0x1000, "InstructionTLBMiss-603", secint_bad )
4501+//VECTOR_RESERVED( 0x1100, "DataLoadTLBMiss-603", secint_bad )
4502+//VECTOR_RESERVED( 0x1200, "DataLoadTLBMiss-603", secint_bad )
4503+
4504+/************************************************************************/
4505+/* DSI Exceptions */
4506+/************************************************************************/
4507+
4508+VECTOR( 0x300, "DSI", secint_lr_call )
4509+ EXCEPTION_PREAMBLE
4510+ TRACE(0x300, "DSI")
4511+
4512+ GET_INSTR_OPCODE // m: r2-r3, ret: r4=opcode, r6=nip
4513+ stw r4,xINST_OPCODE(r1)
4514+ bl check_pthash_hit // m: r0,r2-r5
4515+ btl- FBIT_InSplitmode,splitmode_dsi
4516+ bl save_middle_regs
4517+ bl check_io_page
4518+
4519+dsi_cont:
4520+ LOADI r3,EXTERN(dsi_exception)
4521+ mfdar r4 // We might need to do this earlier
4522+ mfdsisr r5 // when the splitmode code is activated...
4523+ b call_kernel
4524+
4525+
4526+/************************************************************************/
4527+/* ISI Exceptions */
4528+/************************************************************************/
4529+
4530+VECTOR( 0x400, "ISI", secint_bad )
4531+ EXCEPTION_PREAMBLE
4532+ TRACE(0x400, "ISI")
4533+
4534+ // emuaccel engine
4535+ rlwinm. r0,r7,0,4,4 // protection violation
4536+ beq- 1f
4537+ lwz r3,K_EMUACCEL_MPHYS(r1)
4538+ rlwinm r4,r6,0,~0x0fff // nip page
4539+ rlwinm r2,r6,0,0x0ff8 // nip offset (dword align)
4540+ lwz r5,K_EMUACCEL_PAGE_PHYS(r1)
4541+ cmpw r3,r4
4542+ bne- 1f
4543+ lwzux r0,r2,r5 // r0 = handler
4544+ mtlr r0
4545+ lwz r6,4(r2) // address of next instruction
4546+ blr // parameters: r2 == emuaccel_slot
4547+1:
4548+ btl- FBIT_InSplitmode, split_sr_no_execute
4549+ bl save_middle_regs
4550+
4551+ LOADI r3,EXTERN(isi_exception)
4552+ mfsrr0 r4
4553+ mfsrr1 r5
4554+ b call_kernel
4555+
4556+
4557+/************************************************************************/
4558+/* Alignement Exception */
4559+/************************************************************************/
4560+
4561+VECTOR( 0x600, "Alignment", secint_lr_call )
4562+ EXCEPTION_SAVE_ALL
4563+ TRACE(0x400, "Alignment")
4564+
4565+alignment_cont:
4566+ mfdar r4
4567+ mfdsisr r5
4568+ MAC_EXIT( RVEC_ALIGNMENT_TRAP )
4569+
4570+
4571+/************************************************************************/
4572+/* FPU Unavailable Exception */
4573+/************************************************************************/
4574+
4575+ // xFPU_STATE has only meaning when FBIT_FPUInUse is not set
4576+ //
4577+ // FPU_STATE_DIRTY - fr13 & fpscr are not loaded (everything else is).
4578+ // FPU_STATE_HALF_SAVED - fr14-fr31 are loaded.
4579+ // FPU_STATE_SAVED - fr14-fr31 are loaded (but also saved in mregs).
4580+ //
4581+ // FPU_STATE_DIRTY in the *emulator* means that all floating point
4582+ // registers *EXCEPT* fr13 and fpscr are valid.
4583+ //
4584+ // Implementation note: When we do not own the fpu, the MSR_FEx bits
4585+ // must be cleared. Otherwise we might experience bogus FPU exceptions.
4586+ //
4587+ // MOL will never throw FPU exceptions went the FP bit is off. This
4588+ // is a small violation of the standard but the alternative would be
4589+ // always loading FPSCR (which requires FPU ownership...)
4590+ //
4591+
4592+VECTOR( 0x800, "FPU Unavailable", secint_lr_call )
4593+ EXCEPTION_PREAMBLE
4594+ TRACE(0x800, "FPU Unavailable")
4595+fpu_cont:
4596+
4597+ lwz r2,xMSR(r1) // r2 = xMSR (used below too)
4598+ andi. r4,r2,MSR_FP
4599+ beq- mac_fpu_unavailable // mac trap?
4600+ bt FBIT_FPUInUse,2f // FPU ready for use?
4601+
4602+ lwz r3,K_EMULATOR_MSR(r1) // FPU owned by our userland process?
4603+ andi. r4,r3,MSR_FP
4604+ bne+ 1f
4605+ MAC_EXIT_SAVE( RVEC_ENABLE_FPU ) // No... grab FPU in userspace
4606+
4607+mac_fpu_unavailable:
4608+ BUMP( "mac-fpu-trap" )
4609+ MAC_TRAP( 0x800 )
4610+
4611+ // userland process owns FPU
4612+1: BUMP( "enable-fpu" )
4613+ ENABLE_MSR_FP /**/ r4 // enable kernel FPU
4614+ // flag the fpu dirty
4615+ lwz r3,xFPU_STATE(r1)
4616+ lfd fr13,xFPSCR-4(r1) // fp13 and fpscr are *ALWAYS* saved
4617+ crset FBIT_FPUInUse // we own the FPU now
4618+ cmpwi r3,FPU_STATE_HALF_SAVED
4619+ mtfsf 0xff,fr13
4620+ lfd fr13,xFPR13(r1)
4621+ bne 2f
4622+ xLOAD_LOW_FPU r1 // load fr0-fr12
4623+2:
4624+ li r3,MSR_FP| MSR_FE0 | MSR_FE1 // FPU bits
4625+ lwz r7,K_MSR(r1) // enable MSR_FP
4626+ and r2,r2,r3 // r2 = (xMSR & MSR_FEx)
4627+ andc r7,r7,r3 // K_MSR &= ~MSR_FEx
4628+ or r7,r7,r2 // K_MSR |= (xMSR & MSR_FEx)
4629+ stw r7,K_MSR(r1)
4630+ GET_TICK_CNT(entry,"enable_fpu")
4631+ b exception_return
4632+
4633+
4634+/************************************************************************/
4635+/* Decrementer Exception */
4636+/************************************************************************/
4637+
4638+// The 0x900 decrementer vector is in dec.S
4639+
4640+/************************************************************************/
4641+/* System Call Exception */
4642+/************************************************************************/
4643+
4644+VECTOR( 0xc00, "System Call", secint_bad )
4645+ EXCEPTION_PREAMBLE
4646+ TRACE( 0xc00, "System Call")
4647+
4648+ lwz r3,xGPR3(r1)
4649+ LOADI r5,OSI_SC_MAGIC_R3
4650+ lwz r4,xGPR4(r1)
4651+ LOADI r2,OSI_SC_MAGIC_R4
4652+ cmpw cr1,r3,r5
4653+ cmpw cr0,r4,r2
4654+ crand eq,eq,cr1_eq
4655+ beq+ 2f
4656+
4657+ MAC_TRAP(0xc00) // r7 reason bits used (zero)
4658+2:
4659+ MAC_EXIT_SAVE( RVEC_OSI_SYSCALL )
4660+
4661+
4662+/************************************************************************/
4663+/* Trace Exception */
4664+/************************************************************************/
4665+
4666+VECTOR( 0xd00, "Trace", secint_bad )
4667+trace_vector:
4668+ EXCEPTION_PREAMBLE
4669+ TRACE(0xd00, "Trace")
4670+
4671+ MAC_EXIT_SAVE( RVEC_TRACE_TRAP );
4672+
4673+
4674+/************************************************************************/
4675+/* AltiVec Exception */
4676+/************************************************************************/
4677+
4678+VECTOR( 0xf20, "AltiVec", secint_lr_call )
4679+ EXCEPTION_PREAMBLE
4680+ TRACE(0xf20, "AltiVec")
4681+altivec_cont:
4682+
4683+ lwz r4,xNO_ALTIVEC(r1) // AltiVec support disabled?
4684+ cmpwi r4,0
4685+ bne- mac_altivec_unavailable
4686+
4687+ lwz r2,xMSR(r1)
4688+ rlwinm. r4,r2,0,6,6 // bit 6 = MSR_VEC
4689+ beq- mac_altivec_unavailable
4690+
4691+ lwz r3,K_EMULATOR_MSR(r1)
4692+ rlwinm. r4,r3,0,6,6 // bit 6 = MSR_VEC
4693+ bne+ enable_altivec
4694+ MAC_EXIT_SAVE( RVEC_ENABLE_ALTIVEC )
4695+
4696+mac_altivec_unavailable:
4697+ MAC_EXIT_SAVE( RVEC_ALTIVEC_UNAVAIL_TRAP )
4698+
4699+enable_altivec:
4700+ // We don't need to load any registers since the emulator
4701+ // won't touch the altivec unit (at least for now).
4702+
4703+ lwz r7,K_MSR(r1)
4704+ oris r7,r7,HI(MSR_VEC)
4705+ stw r7,K_MSR(r1)
4706+ b exception_return
4707+
4708+
4709+VECTOR( 0x1600, "AltiVec Assist", secint_bad )
4710+ EXCEPTION_SAVE_ALL
4711+ TRACE(0x1600, "AltiVec Assist")
4712+
4713+ mr r4,r7
4714+ MAC_EXIT( RVEC_ALTIVEC_ASSIST ) // r4 = srr1
4715+
4716+
4717+/************************************************************************/
4718+/* Instruction Breakpoint */
4719+/************************************************************************/
4720+
4721+VECTOR( 0x1300, "Instruction Breakpoint", secint_bad )
4722+ EXCEPTION_SAVE_ALL
4723+ TRACE(0x1300, "IABR")
4724+
4725+ DEBUGGER(0x1300)
4726+
4727+
4728+/************************************************************************/
4729+/* RunMode-601 (trace) */
4730+/************************************************************************/
4731+
4732+VECTOR( 0x2000, "RunMode-601", secint_bad )
4733+ b trace_vector
4734+
4735+
4736+/************************************************************************/
4737+/* Secondary Interrupt Handlers */
4738+/************************************************************************/
4739+
4740+ //////////////////////////////////////////////////////////////////////
4741+ // secint_xxx
4742+ //
4743+ // r1: stack (sprg1 = old r1)
4744+ // r3: vector addr (sprg0 = old r3)
4745+ // srr0/srr1: kernel nip/msr
4746+ //
4747+ // secint_lr_call:
4748+ // lr secondary interrupt handler
4749+
4750+secint_bad:
4751+ TRACE(0xbad, "secint_bad")
4752+ mr r4,r3
4753+ MAC_EXIT( RVEC_INTERNAL_ERROR )
4754+
4755+secint_lr_call:
4756+ blrl
4757+ li r4,0x6666
4758+ MAC_EXIT( RVEC_INTERNAL_ERROR )
4759+
4760+
4761+/**************************************************************
4762+* Includes
4763+**************************************************************/
4764+
4765+// We need to be sure this code is contiguous, the simplest/safest
4766+// method is using only a single file. This will also effectively
4767+// reduce the size of the relocation table.
4768+
4769+#ifdef __darwin__
4770+#include "darwin.S"
4771+#endif
4772+#include "entry.S"
4773+#include "dec.S"
4774+#include "emulation.S"
4775+#include "emuaccel.S"
4776+#include "iopage.S"
4777+#include "splitmode.S"
4778+#include "ptintercept.S"
4779+#include "vsid.S"
4780+#ifdef __MPC107__
4781+#include "./mpc107/mpc107.S"
4782+#else
4783+#ifdef __linux__
4784+#include "linux.S"
4785+#include "603.S"
4786+#endif
4787+#endif
4788+
4789+#ifdef __linux__
4790+ .text 50
4791+#endif
4792+GLOBAL_SYMBOL(r__reloctable_end):
4793+
4794+ ACTIONS_OFFS_SECTION
4795+GLOBAL_SYMBOL(r__actions_offs_section_end):
4796+
4797+// The BUMP("counter") macro adds entries to text subsection 90.
4798+// This adds labels before the counter entries.
4799+
4800+#ifdef __linux__
4801+ .text 89
4802+GLOBAL_SYMBOL(__start_bumptable):
4803+ .text 91
4804+GLOBAL_SYMBOL(__end_bumptable):
4805+ .text
4806+#endif
4807--- /dev/null
4808+++ b/drivers/macintosh/mol/asm-files/vsid.S
4809@@ -0,0 +1,123 @@
4810+/*
4811+ * Creation Date: <2003/03/06 22:03:59 samuel>
4812+ * Time-stamp: <2004/02/21 16:30:45 samuel>
4813+ *
4814+ * <vsid.S>
4815+ *
4816+ * VSID lookup (skiplist search)
4817+ *
4818+ * Copyright (C) 2003, 2004 Samuel Rydh (samuel@ibrium.se)
4819+ *
4820+ * This program is free software; you can redistribute it and/or
4821+ * modify it under the terms of the GNU General Public License
4822+ * as published by the Free Software Foundation
4823+ *
4824+ */
4825+
4826+#include "mtable.h"
4827+
4828+#if (SKIPLIST_LEVELSIZE == 4)
4829+#define SLEVEL_SHIFT 2
4830+#endif
4831+#if (SKIPLIST_LEVELSIZE == 8)
4832+#define SLEVEL_SHIFT 3
4833+#endif
4834+
4835+emulate_mtsrin:
4836+ rlwinm r2,r4,32-8,24,28 // r2 = #B << 8
4837+ EMU_LOAD_GPR r2, /**/ R3 // r0 = reg B
4838+ rlwinm r4,r0,0,0,3 // #sr top 4 bits of r4
4839+ b 1f
4840+emulate_mtsr:
4841+ rlwinm r4,r4,12,0,3 // #sr in top 4 bits of r4
4842+1: EMU_LOAD_GPR r5, /**/ R2 // r0 = new segr value
4843+
4844+ stw r8,xGPR8(r1) // save r8
4845+ rlwinm r8,r4,6,26,29 // r8 = #sr << 2
4846+ stw r9,xGPR9(r1) // save r9
4847+ add r8,r8,r1 // r8 = r1 + sr_offset
4848+ stw r6,xNIP(r1) // save r6 (need more registers)
4849+ rlwinm r9,r0,0,0,3 // r9 = [T Ks Kp N]
4850+ stw r0,xSEGR_BASE(r8) // store new value
4851+ rlwinm r0,r0,0,8,31 // mask VSID
4852+
4853+ /******* vsid lookup (skiplist search) *******/
4854+
4855+ lwz r2,K_VSID_SL_SLEVEL(r1) // n = search level (0..15)
4856+ rlwinm r2,r2,SLEVEL_SHIFT,0,29 // n *= 4 (or n *= 8 on darwin)
4857+
4858+ addi r3,r1,K_VSID_SL_ROOT_ELEM // p = root element
4859+1: add r5,r2,r3 //
4860+2: lwz r3,SKIPLIST_NEXT(r5) // r3 = p->next[n]
4861+#ifdef __linux__
4862+ tophys R3,R3
4863+#endif
4864+ lwz r4,SKIPLIST_KEY(r3) // r0 = p->next[n].key
4865+ cmpw cr1,r4,r0
4866+ bge- cr1,3f
4867+ b 1b
4868+3:
4869+ addi r2,r2,-SKIPLIST_LEVELSIZE // r2 -= 4|8
4870+ beq- cr1,vsid_found // jump if key matches
4871+ cmpwi r2,0
4872+ addi r5,r5,-SKIPLIST_LEVELSIZE // r5 -= 4|8
4873+ bge+ 2b
4874+
4875+ /******* vsid missing *******/
4876+ BUMP("vsid_missing")
4877+ // r8 used
4878+ lwz r2,K_ILLEGAL_SR(r1) // vsid unallocated...
4879+ li r4,0 // no entry...
4880+ stw r2,K_SV_SR_BASE(r8)
4881+ stw r2,K_USER_SR_BASE(r8)
4882+ stw r2,K_SPLIT_SR_BASE(r8) // this way we can forget the splitmode case
4883+ stw r4,K_VSID_ENT_BASE(r8)
4884+ sub r5,r8,r1 // r5 = VSID offset
4885+ lwz r0,K_CUR_SR_BASE(r1) // r0 = cur_sr_table
4886+ b 6f
4887+
4888+ /******* vsid found *******/
4889+vsid_found:
4890+
4891+ BUMP("vsid_found")
4892+ // match, r3 points to the skiplist element
4893+ addi r4,r3,-SIZEOF_VSID_ENT // sizeof(vsid_ent_t)
4894+ lwz r2,VSID_USER_OFFS(r4) // vsid_user
4895+ lwz r3,VSID_SV_OFFS(r4) // vsid_sv
4896+#ifdef __linux__
4897+ tovirt R4,R4 // r4 = vsid_element
4898+#else
4899+ lwz r4,VSID_MYSELF_VIRT(r4)
4900+#endif
4901+ rlwinm r6,r9,2,31,31 // r6 = Ks ? 1:0
4902+ stw r4,K_VSID_ENT_BASE(r8) // store vsid entry (possibly NULL)
4903+ rlwinm r4,r9,3,31,31 // r4 = Kp ? 1:0
4904+ rlwimi r2,r9,0,3,3 // copy the N-bit (no-execute)
4905+ rlwimi r3,r9,0,3,3 // copy the N-bit (no-execute)
4906+ cror FBIT_LoadSegreg, FBIT_LoadSegreg, FBIT_InSplitmode
4907+ addi r6,r6,-1 // r6 = Ks-mask
4908+ addi r4,r4,-1 // r4 = Kp-mask
4909+ andc r0,r2,r6 // Kp == 1 case
4910+ and r6,r3,r6 // Kp == 0 case
4911+ crmove FBIT_PrepareSplitmode, FBIT_InSplitmode
4912+ andc r9,r2,r4 // Ks == 1 case
4913+ or r6,r6,r0
4914+ lwz r0,K_CUR_SR_BASE(r1) // r0 = cur_sr_table
4915+ and r4,r3,r4 // Ks == 0 case
4916+ stw r6,K_SV_SR_BASE(r8) // sv_sr set
4917+ or r4,r4,r9
4918+ sub r5,r8,r1 // r5 = VSID offset
4919+ stw r4,K_USER_SR_BASE(r8) // user_sr set
4920+6:
4921+ // r0,r5 used
4922+ rlwinm r2,r5,32-6,0,3 // r2 = sr# in bits 0-3
4923+ lwzx r3,r5,r0 // r3 = sr to be loaded into sr#
4924+ mtsrin r3,r2 // update segment register
4925+
4926+ lwz r6,xNIP(r1) // restore r6
4927+ lwz r8,xGPR8(r1) // restore r8
4928+ lwz r9,xGPR9(r1) // restore r9
4929+ GET_TICK_CNT(entry, "mtsr")
4930+ BUMP("mtsr_")
4931+ b emulation_done
4932+
4933--- /dev/null
4934+++ b/drivers/macintosh/mol/asm_offsets.c
4935@@ -0,0 +1,161 @@
4936+/*
4937+ * This program is used to generate definitions needed by
4938+ * some assembly functions.
4939+ *
4940+ * We use the technique used in the OSF Mach kernel code:
4941+ * generate asm statements containing #defines,
4942+ * compile this file to assembler, and then extract the
4943+ * #defines from the assembly-language output.
4944+ */
4945+
4946+#ifdef __KERNEL__
4947+#include "archinclude.h"
4948+#include "kernel_vars.h"
4949+#include "mmu.h"
4950+#else
4951+#include "mol_config.h"
4952+#include <stddef.h>
4953+#include "mac_registers.h"
4954+#endif
4955+
4956+#include "processor.h"
4957+
4958+#define DEFINE(sym, val) \
4959+ asm volatile("\n#define\t" #sym "\t%0" : : "i" (val))
4960+
4961+#define K_DEF(sym, val ) \
4962+ DEFINE(sym, offsetof(kernel_vars_t, val ))
4963+
4964+#define ST_DEF(sym, val ) \
4965+ DEFINE(sym, offsetof(session_table_t, val ))
4966+
4967+#define M_DEF(sym, val ) \
4968+ DEFINE(sym, XOFFS + offsetof(mac_regs_t, val ))
4969+
4970+#define IO_DEF(sym, val) \
4971+ DEFINE(sym, offsetof(struct io_page, val ))
4972+
4973+int main( void )
4974+{
4975+#ifdef __KERNEL__
4976+ #define XOFFS offsetof(kernel_vars_t, mregs)
4977+#else
4978+ #define XOFFS 0
4979+#endif
4980+ /* --- mac_regs offsets --- */
4981+
4982+ M_DEF( xVEC_BASE, vec[0] );
4983+ M_DEF( xVEC0, vec[0] );
4984+ M_DEF( xVEC1, vec[1] );
4985+ M_DEF( xVEC2, vec[2] );
4986+ M_DEF( xVSCR, vscr );
4987+ M_DEF( xVRSAVE, spr[S_VRSAVE] );
4988+
4989+ M_DEF( xGPR_BASE, gpr[0] );
4990+ M_DEF( xGPR0, gpr[0] );
4991+ M_DEF( xGPR1, gpr[1] );
4992+ M_DEF( xGPR2, gpr[2] );
4993+ M_DEF( xGPR3, gpr[3] );
4994+ M_DEF( xGPR4, gpr[4] );
4995+ M_DEF( xGPR5, gpr[5] );
4996+ M_DEF( xGPR6, gpr[6] );
4997+ M_DEF( xGPR7, gpr[7] );
4998+ M_DEF( xGPR8, gpr[8] );
4999+ M_DEF( xGPR9, gpr[9] );
5000+ M_DEF( xGPR10, gpr[10] );
5001+ M_DEF( xGPR11, gpr[11] );
5002+ M_DEF( xGPR12, gpr[12] );
5003+ M_DEF( xGPR13, gpr[13] );
5004+ M_DEF( xGPR14, gpr[14] );
5005+ M_DEF( xGPR15, gpr[15] );
5006+ M_DEF( xGPR16, gpr[16] );
5007+ M_DEF( xGPR17, gpr[17] );
5008+ M_DEF( xGPR18, gpr[18] );
5009+ M_DEF( xGPR19, gpr[19] );
5010+ M_DEF( xGPR20, gpr[20] );
5011+ M_DEF( xGPR21, gpr[21] );
5012+ M_DEF( xGPR22, gpr[22] );
5013+ M_DEF( xGPR23, gpr[23] );
5014+ M_DEF( xGPR24, gpr[24] );
5015+ M_DEF( xGPR25, gpr[25] );
5016+ M_DEF( xGPR26, gpr[26] );
5017+ M_DEF( xGPR27, gpr[27] );
5018+ M_DEF( xGPR28, gpr[28] );
5019+ M_DEF( xGPR29, gpr[29] );
5020+ M_DEF( xGPR30, gpr[30] );
5021+ M_DEF( xGPR31, gpr[31] );
5022+
5023+ M_DEF( xNIP, nip);
5024+ M_DEF( xCR, cr);
5025+ M_DEF( xFPR_BASE, fpr[0]);
5026+ M_DEF( xFPR13, fpr[13]);
5027+ M_DEF( xFPSCR, fpscr );
5028+ M_DEF( xEMULATOR_FPSCR, emulator_fpscr );
5029+ M_DEF( xFPU_STATE, fpu_state );
5030+
5031+ M_DEF( xLINK, link);
5032+ M_DEF( xXER, xer);
5033+ M_DEF( xCTR, ctr);
5034+ M_DEF( xFLAG_BITS, flag_bits );
5035+ M_DEF( xDEC, spr[S_DEC]);
5036+ M_DEF( xDEC_STAMP, dec_stamp);
5037+ M_DEF( xTIMER_STAMP, timer_stamp);
5038+ M_DEF( xMSR, msr);
5039+ M_DEF( xSPR_BASE, spr[0]);
5040+
5041+ M_DEF( xHID0, spr[S_HID0]);
5042+
5043+ M_DEF( xSRR0, spr[S_SRR0]);
5044+ M_DEF( xSRR1, spr[S_SRR1]);
5045+
5046+ M_DEF( xSPRG0, spr[S_SPRG0]);
5047+ M_DEF( xSPRG1, spr[S_SPRG1]);
5048+ M_DEF( xSPRG2, spr[S_SPRG2]);
5049+ M_DEF( xSPRG3, spr[S_SPRG3]);
5050+
5051+ M_DEF( xSEGR_BASE, segr[0]);
5052+ M_DEF( xIBAT_BASE, spr[S_IBAT0U] );
5053+ M_DEF( xSDR1, spr[S_SDR1] );
5054+
5055+ M_DEF( xINST_OPCODE, inst_opcode );
5056+ M_DEF( xALTIVEC_USED, altivec_used );
5057+ M_DEF( xNO_ALTIVEC, no_altivec );
5058+
5059+ M_DEF( xINTERRUPT, interrupt );
5060+ M_DEF( xIN_VIRTUAL_MODE, in_virtual_mode );
5061+
5062+ M_DEF( xRVEC_PARAM0, rvec_param[0] );
5063+ M_DEF( xRVEC_PARAM1, rvec_param[1] );
5064+ M_DEF( xRVEC_PARAM2, rvec_param[2] );
5065+
5066+#ifdef EMULATE_603
5067+ M_DEF( xGPRSAVE0_603, gprsave_603[0] );
5068+ M_DEF( xGPRSAVE1_603, gprsave_603[1] );
5069+ M_DEF( xGPRSAVE2_603, gprsave_603[2] );
5070+ M_DEF( xGPRSAVE3_603, gprsave_603[3] );
5071+#endif
5072+
5073+ M_DEF( xDEBUG0, debug[0] );
5074+ M_DEF( xDEBUG1, debug[1] );
5075+ M_DEF( xDEBUG2, debug[2] );
5076+ M_DEF( xDEBUG3, debug[3] );
5077+ M_DEF( xDEBUG4, debug[4] );
5078+ M_DEF( xDEBUG5, debug[5] );
5079+ M_DEF( xDEBUG6, debug[6] );
5080+ M_DEF( xDEBUG7, debug[7] );
5081+ M_DEF( xDEBUG8, debug[8] );
5082+ M_DEF( xDEBUG9, debug[9] );
5083+
5084+ M_DEF( xDEBUG_SCR1, debug_scr1 );
5085+ M_DEF( xDEBUG_SCR2, debug_scr2 );
5086+ M_DEF( xDEBUG_TRACE, debug_trace );
5087+ M_DEF( xDBG_TRACE_SPACE, dbg_trace_space[0] );
5088+ M_DEF( xDBG_LAST_RVEC, dbg_last_rvec );
5089+
5090+ M_DEF( xKERNEL_DBG_STOP, kernel_dbg_stop );
5091+
5092+ M_DEF( xHOSTIRQ_ACTIVE_CNT, hostirq_active_cnt );
5093+
5094+ return 0;
5095+}
5096+
5097--- /dev/null
5098+++ b/drivers/macintosh/mol/context.c
5099@@ -0,0 +1,99 @@
5100+/*
5101+ * Creation Date: <1998-11-20 16:18:20 samuel>
5102+ * Time-stamp: <2004/02/28 19:16:44 samuel>
5103+ *
5104+ * <context.c>
5105+ *
5106+ * MMU context allocation
5107+ *
5108+ * Copyright (C) 1998-2004 Samuel Rydh (samuel@ibrium.se)
5109+ *
5110+ * This program is free software; you can redistribute it and/or
5111+ * modify it under the terms of the GNU General Public License
5112+ * as published by the Free Software Foundation
5113+ *
5114+ */
5115+
5116+#include "archinclude.h"
5117+#include "alloc.h"
5118+#include "mmu.h"
5119+#include "mmu_contexts.h"
5120+#include "misc.h"
5121+#include "asmfuncs.h"
5122+#include "emu.h"
5123+#include "mtable.h"
5124+#include "performance.h"
5125+#include "context.h"
5126+#include "hash.h"
5127+
5128+#define MMU (kv->mmu)
5129+
5130+
5131+static int
5132+flush_all_PTEs( kernel_vars_t *kv )
5133+{
5134+ int i, count=0, npte=(ptehash.pte_mask + 8)/8;
5135+ ulong *pte, ea, v;
5136+
5137+ for( pte=ptehash.base, i=0; i<npte; i++, pte+=2 ) {
5138+ v = *pte;
5139+ if( !(v & BIT(0)) ) /* test V-bit */
5140+ continue;
5141+ v = (v & ~BIT(0)) >> 7;
5142+ v = (v - ((v & 0xf) * MUNGE_ESID_ADD)) * MUNGE_MUL_INVERSE;
5143+ v = (v>>4) & CTX_MASK;
5144+
5145+ if( v >= MMU.first_mol_context && v <= MMU.last_mol_context ) {
82094b55 5146+ *pte = 0;
2cb7cef9
BS		 5147+ count++;
5148+ }
5149+ }
5150+
5151+ /* perform a tlbia */
5152+ for( ea=0; ea <= (0x3f << 12); ea += 0x1000 )
5153+ __tlbie( ea );
5154+
5155+ if( count )
5156+ printk("%d stale PTEs flushed (something is wrong)\n", count );
5157+ return count;
5158+}
5159+
5160+int
5161+init_contexts( kernel_vars_t *kv )
5162+{
5163+ MMU.first_mol_context = FIRST_MOL_CONTEXT( kv->session_index );
5164+ MMU.last_mol_context = LAST_MOL_CONTEXT( kv->session_index );
5165+ MMU.next_mol_context = MMU.first_mol_context;
5166+
5167+ MMU.illegal_sr = alloc_context(kv) | VSID_Kp | VSID_N;
5168+
5169+ flush_all_PTEs( kv );
5170+ return 0;
5171+}
5172+
5173+void
5174+cleanup_contexts( kernel_vars_t *kv )
5175+{
5176+ flush_all_PTEs( kv );
5177+}
5178+
5179+void
5180+handle_context_wrap( kernel_vars_t *kv, int n )
5181+{
5182+ if( MMU.next_mol_context + n > MMU.last_mol_context ) {
5183+ printk("MOL context wrap\n");
5184+
5185+ clear_all_vsids( kv );
5186+ init_contexts( kv );
5187+ }
5188+}
5189+
5190+int
5191+alloc_context( kernel_vars_t *kv )
5192+{
5193+ int mol_context = MMU.next_mol_context++;
5194+ int vsid = MUNGE_CONTEXT(mol_context >> 4);
5195+
5196+ vsid += MUNGE_ESID_ADD * (mol_context & 0xf);
5197+ return (vsid & VSID_MASK);
5198+}
5199--- /dev/null
5200+++ b/drivers/macintosh/mol/emu.c
5201@@ -0,0 +1,228 @@
5202+/*
5203+ * Creation Date: <1998-11-21 16:07:47 samuel>
5204+ * Time-stamp: <2004/03/13 14:08:18 samuel>
5205+ *
5206+ * <emu.c>
5207+ *
5208+ * Emulation of some assembly instructions
5209+ *
5210+ * Copyright (C) 1998-2004 Samuel Rydh (samuel@ibrium.se)
5211+ *
5212+ * This program is free software; you can redistribute it and/or
5213+ * modify it under the terms of the GNU General Public License
5214+ * as published by the Free Software Foundation
5215+ *
5216+ */
5217+
5218+#include "archinclude.h"
5219+#include "alloc.h"
5220+#include "mmu.h"
5221+#include "kernel_vars.h"
5222+#include "emu.h"
5223+#include "asmfuncs.h"
5224+#include "rvec.h"
5225+#include "processor.h"
5226+#include "mtable.h"
5227+#include "performance.h"
5228+#include "emuaccel_sh.h"
5229+#include "misc.h"
5230+#include "map.h"
5231+
5232+#define BAT_PERFORMANCE_HACK
5233+// #define DEBUG
5234+
5235+/* If BAT_PERFORMANCE_HACK is defined, PTEs corresponding to a mac bat
5236+ * mapping will not necessary be flushed when the bat registers are
5237+ * touched. This gives a huge performance gain in MacOS 9.1 (which
5238+ * clears the bat registers in the idle loop). Of course, this break
5239+ * compatibility (although most operating systems initializes the
5240+ * BATs once and for all).
5241+ */
5242+
5243+#ifdef BAT_PERFORMANCE_HACK
5244+ #define BAT_HACK(kv) (!MREGS.use_bat_hack || kv->mmu.bat_hack_count++ < 0x100)
5245+#else
5246+ #define BAT_HACK(kv) 1
5247+#endif
5248+
5249+#define MREGS (kv->mregs)
5250+#define MMU (kv->mmu)
5251+
5252+
5253+int
5254+do_mtsdr1( kernel_vars_t *kv, ulong value )
5255+{
5256+ ulong mbase, mask;
5257+ int s;
5258+
5259+ MREGS.spr[S_SDR1] = value;
5260+
5261+ /* the mask must be a valid one; we hade better make sure we are
5262+ * not tricked by a bogus sdr1 value
5263+ */
5264+ for( mask=BIT(23); mask && !(mask & value) ; mask=mask>>1 )
5265+ ;
5266+ mask = mask? ((mask | (mask-1)) << 16) | 0xffff : 0xffff;
5267+ mbase = value & ~mask;
5268+
5269+ if( mbase + mask >= MMU.ram_size ) {
5270+ /* S_SDR1 out of range, fallback to a safe setting */
5271+ printk("WARNING, S_SDR1, %08lX is out of range\n", value);
5272+ mbase = 0;
5273+ mask = 0xffff;
5274+ }
5275+
5276+ MMU.hash_mbase = mbase;
5277+ MMU.hash_mask = mask;
5278+ MMU.pthash_sr = -1; /* clear old tlbhash matching */
5279+
5280+ if( MMU.hash_base )
5281+ unmap_emulated_hash( kv );
5282+ MMU.hash_base = map_emulated_hash( kv, MMU.hash_mbase, mask+1 );
5283+
5284+ /* try to allocate the PTE bitfield table (16K/128 MB ram). The worst
5285+ * case is 512K which will fail since the kmalloc limit is 128K.
5286+ * If the allocation fails, we simply don't use the bitfield table.
5287+ */
5288+ s = (mask+1)/8/8;
5289+ if( MMU.pthash_inuse_bits )
5290+ kfree_cont_mol( MMU.pthash_inuse_bits );
5291+ if( !(MMU.pthash_inuse_bits=kmalloc_cont_mol(s)) )
5292+ MMU.pthash_inuse_bits_ph = 0;
5293+ else {
5294+ memset( MMU.pthash_inuse_bits, 0, s );
5295+ MMU.pthash_inuse_bits_ph = tophys_mol( MMU.pthash_inuse_bits );
5296+ }
5297+
5298+ /* make sure the unmapped ram range is flushed... */
5299+ flush_lv_range( kv, MMU.userspace_ram_base + mbase, mask+1 );
5300+
5301+ /* ...as well as any MMU mappings */
5302+ clear_pte_hash_table( kv );
5303+
5304+ BUMP(do_mtsdr1);
5305+ return RVEC_NOP;
5306+}
5307+
5308+/* This function is _very_ slow, since it must destroy a lot of PTEs.
5309+ * Fortunately, BAT-maps are normally static.
5310+ */
5311+int
5312+do_mtbat( kernel_vars_t *kv, int sprnum, ulong value, int force )
5313+{
5314+ mac_bat_t *d;
5315+ int batnum;
5316+ mBAT *p;
5317+
5318+ BUMP(do_mtbat);
5319+
5320+ if( !force && MREGS.spr[sprnum] == value )
5321+ return RVEC_NOP;
5322+
5323+ /* printk("do_mtbat %d %08lX\n", sprnum, value); */
5324+
5325+ MREGS.spr[sprnum] = value;
5326+
5327+ /* upper bat register have an even number */
5328+ batnum = (sprnum - S_IBAT0U) >>1;
5329+ d = &MMU.bats[batnum];
5330+
5331+ /* First we must make sure that all PTEs corresponding to
5332+ * the old BAT-mapping are purged from the hash table.
5333+ */
5334+ if( BAT_HACK(kv) && d->valid )
5335+ flush_ea_range(kv, d->base & ~0xf0000000, d->size );
5336+
5337+ p = (mBAT*)&MREGS.spr[sprnum & ~1];
5338+ d->valid = p->batu.vs | p->batu.vp;
5339+ d->vs = p->batu.vs;
5340+ d->vp = p->batu.vp;
5341+ d->wimg = (p->batl.w<<3) | (p->batl.i<<2) | (p->batl.m<<1) | p->batl.g;
5342+ d->ks = d->ku = 1; /* IBAT/DBATs, behaves as if key==1 */
5343+ d->pp = p->batl.pp;
5344+ d->size = (p->batu.bl+1)<<17;
5345+ d->base = (p->batu.bepi & ~p->batu.bl)<<17;
5346+ d->mbase = (p->batl.brpn & ~p->batu.bl)<<17;
5347+
5348+ /* Next, we must make sure that no PTEs refer to the new
5349+ * BAT-mapped area.
5350+ */
5351+
5352+ if( BAT_HACK(kv) && d->valid )
5353+ flush_ea_range( kv, d->base & ~0xf0000000, d->size );
5354+
5355+ return RVEC_NOP;
5356+}
5357+
5358+
5359+/************************************************************************/
5360+/* Emulation acceleration */
5361+/************************************************************************/
5362+
5363+static ulong
5364+lookup_emuaccel_handler( int emuaccel )
5365+{
5366+ extern ulong emuaccel_table[];
5367+ ulong handler, *p = emuaccel_table;
5368+
5369+ for( ; p[0]; p+=3 ) {
5370+ if( (emuaccel & EMUACCEL_INST_MASK) != p[0] )
5371+ continue;
5372+ emuaccel &= p[2]; /* offset mask */
5373+ handler = p[1] + (ulong)emuaccel_table + emuaccel * 8;
5374+ return tophys_mol( (ulong*)reloc_ptr(handler) );
5375+ }
5376+ return 0;
5377+}
5378+
5379+int
5380+alloc_emuaccel_slot( kernel_vars_t *kv, int emuaccel, int param, int inst_addr )
5381+{
5382+ ulong *p = (ulong*)((char*)kv->emuaccel_page + kv->emuaccel_size);
5383+ ulong handler = lookup_emuaccel_handler( emuaccel );
5384+ int size, ret;
5385+
5386+ size = (emuaccel & EMUACCEL_HAS_PARAM)? 16 : 8;
5387+ if( !handler || !p || kv->emuaccel_size + size > 0x1000 )
5388+ return 0;
5389+
5390+ ret = kv->emuaccel_mphys + kv->emuaccel_size;
5391+ p[0] = handler;
5392+ p[1] = inst_addr + 4;
5393+
5394+ if( emuaccel & EMUACCEL_HAS_PARAM ) {
5395+ /* p[2] is already EMUACCEL_NOP */
5396+ p[3] = param;
5397+ }
5398+
5399+ kv->emuaccel_size += size;
5400+ return ret;
5401+}
5402+
5403+int
5404+mapin_emuaccel_page( kernel_vars_t *kv, int mphys )
5405+{
5406+ int i, handler;
5407+ ulong *p;
5408+
5409+ if( kv->emuaccel_page || (mphys & 0xfff) )
5410+ return 0;
5411+
5412+ if( !(kv->emuaccel_page=alloc_page_mol()) )
5413+ return 0;
5414+
5415+ kv->emuaccel_page_phys = tophys_mol( (char*)kv->emuaccel_page );
5416+ kv->emuaccel_mphys = mphys;
5417+ p = (ulong*)kv->emuaccel_page;
5418+
5419+ handler = lookup_emuaccel_handler( EMUACCEL_NOP );
5420+ for( i=0; i<0x1000/sizeof(int); i+=2 ) {
5421+ p[i] = handler;
5422+ p[i+1] = 0;
5423+ }
5424+
5425+ /* flush translations - an old translation is overridden */
5426+ clear_pte_hash_table( kv );
5427+ /* printk("emuaccel_mapin: %08x\n", mphys ); */
5428+ return mphys;
5429+}
5430--- /dev/null
5431+++ b/drivers/macintosh/mol/fault.c
5432@@ -0,0 +1,601 @@
5433+/*
5434+ * Creation Date: <2002/06/08 20:53:20 samuel>
5435+ * Time-stamp: <2004/02/22 13:07:50 samuel>
5436+ *
5437+ * <fault.c>
5438+ *
5439+ * Page fault handler
5440+ *
5441+ * Copyright (C) 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
5442+ *
5443+ * This program is free software; you can redistribute it and/or
5444+ * modify it under the terms of the GNU General Public License
5445+ * as published by the Free Software Foundation
5446+ *
5447+ */
5448+
5449+#include "archinclude.h"
5450+#include "alloc.h"
5451+
5452+#include "kernel_vars.h"
5453+#include "mmu.h"
5454+#include "mmu_contexts.h"
5455+#include "asmfuncs.h"
5456+#include "emu.h"
5457+#include "misc.h"
5458+#include "constants.h"
5459+#include "rvec.h"
5460+#include "mtable.h"
5461+#include "performance.h"
5462+#include "processor.h"
5463+#include "hash.h"
5464+
5465+/* exception bits (srr1/dsisr and a couple of mol defined bits) */
5466+#define EBIT_PAGE_FAULT BIT(1) /* I/D, PTE missing */
5467+#define EBIT_NO_EXEC BIT(3) /* I, no-execute or guarded */
5468+#define EBIT_PROT_VIOL BIT(4) /* I/D, protection violation */
5469+#define EBIT_IS_WRITE BIT(6) /* D */
5470+#define EBIT_IS_DSI 1 /* D, virtual bit */
5471+#define EBIT_USE_MMU 2 /* I/D, virtual bit */
5472+
5473+#define use_mmu(ebits) ((ebits) & EBIT_USE_MMU)
5474+#define is_write(ebits) ((ebits) & EBIT_IS_WRITE)
5475+#define is_dsi(ebits) ((ebits) & EBIT_IS_DSI)
5476+#define is_prot_viol(ebits) ((ebits) & EBIT_PROT_VIOL)
5477+#define is_page_fault(ebits) ((ebits) & EBIT_PAGE_FAULT)
5478+
5479+typedef struct {
5480+ /* filled in by exception handler */
5481+ ulong ea;
5482+ ulong *sr_base;
5483+ struct vsid_ent **vsid_eptr; /* pointer to MMU.vsid or MMU.unmapped_vsid */
5484+
5485+ /* filled in by lookup_mphys */
5486+ mPTE_t *mpte; /* lvptr to mac-pte (if != NULL) */
5487+ ulong mphys_page; /* ea of mphys page */
5488+ int pte1; /* RPN | 000 | R | C | WIMG | 00 | PP */
5489+ int key; /* pp key bit */
5490+} fault_param_t;
5491+
5492+static const char priv_viol_table[16] = { /* [is_write | key | PP] */
5493+ 0,0,0,0,1,0,0,0, /* read (1 == violation) */
5494+ 0,0,0,1,1,1,0,1 /* write */
5495+};
5496+
5497+#define NO_MMU_PTE1 (PTE1_R | PTE1_C /*| PTE1_M*/ | 0x2 /*pp*/ )
5498+
5499+#define MREGS (kv->mregs)
5500+#define MMU (kv->mmu)
5501+
5502+#ifdef CONFIG_SMP
5503+#define SMP_PTE1_M PTE1_M
5504+#else
5505+#define SMP_PTE1_M 0
5506+#endif
5507+
5508+
5509+/************************************************************************/
5510+/* Debugging */
5511+/************************************************************************/
5512+
5513+static inline void
5514+DEBUG_print_inserted_pte( ulong *slot, ulong pte0, ulong pte1, ulong ea )
5515+{
5516+#if 0
5517+ mPTE_t pte;
5518+ ulong *p = (ulong)&pte;
5519+ p[0] = pte0;
5520+ p[1] = pte1;
5521+
5522+ printk("[%p] ", slot );
5523+ printk("RPN %08X API %08X EA %08lX ", pte.rpn << 12, pte.api<<12, ea );
5524+ printk("%c%c %c%c; PP %d\n",
5525+ pte.h ? 'H' : 'h',
5526+ pte.v ? 'V' : 'v',
5527+ pte.r ? 'R' : 'r',
5528+ pte.c ? 'C' : 'c', pte.pp );
5529+#endif
5530+}
5531+
5532+
5533+/************************************************************************/
5534+/* MMU virtualization and page fault handling */
5535+/************************************************************************/
5536+
5537+#ifdef EMULATE_603
5538+static inline int
5539+lookup_603_pte( kernel_vars_t *kv, ulong vsid, ulong ea, int is_dsi, mPTE_t **ret_pte )
5540+{
5541+ int ind = (ea >> 12) & 0x1f; /* 32x2 PTEs */
5542+ ulong mask, phash, cmp, pteg, cmp_ea, *eap;
5543+ mPTE_t *p;
5544+
5545+ // printk("lookup_603_pte %08lX\n", ea);
5546+
5547+ if( is_dsi ) {
5548+ p = &MMU.ptes_d_603[ind];
5549+ eap = &MMU.ptes_d_ea_603[ind];
5550+ } else {
5551+ p = &MMU.ptes_i_603[ind];
5552+ eap = &MMU.ptes_i_ea_603[ind];
5553+ }
5554+ cmp_ea = ea & 0x0ffff000;
5555+ for( ; ind < 64 ; ind += 32, p += 32, eap += 32 ) {
5556+ if( *eap == cmp_ea && p->vsid == vsid ) {
5557+ *ret_pte = p;
5558+ return 0;
5559+ }
5560+ }
5561+ mask = MMU.hash_mask >> 6;
5562+
5563+ /* calculate primary and secondary PTEG */
5564+ phash = (cmp_ea >> 12) ^ (vsid & 0x7ffff);
5565+ pteg = ((phash & mask) << 6);
5566+ MREGS.spr[S_HASH1] = MMU.hash_mbase + pteg;
5567+ MREGS.spr[S_HASH2] = MMU.hash_mbase + (pteg ^ (mask << 6));
5568+
5569+ /* construct compare word */
5570+ cmp = BIT(0) | (vsid <<7) | (cmp_ea >> 22);
5571+ if( is_dsi ) {
5572+ MREGS.spr[S_DCMP] = cmp;
5573+ MREGS.spr[S_DMISS] = ea;
5574+ } else {
5575+ MREGS.spr[S_ICMP] = cmp;
5576+ MREGS.spr[S_IMISS] = ea;
5577+ }
5578+ return 1;
5579+}
5580+#endif
5581+
5582+static inline mPTE_t *
5583+lookup_mac_pte( kernel_vars_t *kv, ulong vsid, ulong ea )
5584+{
5585+ ulong phash, cmp, pteg, *p;
5586+ ulong mask;
5587+ int i;
5588+
5589+ /* make sure the hash is mapped... */
5590+ if( !MMU.hash_base )
5591+ return NULL;
5592+
5593+ /* we are only interested in the page index */
5594+ ea &= 0x0ffff000;
5595+ mask = MMU.hash_mask>>6;
5596+
5597+ /* calculate primary hash function */
5598+ phash = (ea >> 12) ^ (vsid & 0x7ffff);
5599+ pteg = ((phash & mask) << 6);
5600+
5601+ /* construct compare word */
5602+ cmp = BIT(0) | (vsid <<7) | ((ea&0x0fffffff)>>22);
5603+
5604+ /* look in primary PTEG */
5605+ p = (ulong*)((ulong)MMU.hash_base + pteg);
5606+ for( i=0; i<8; i++, p+=2 )
5607+ if( cmp == *p )
5608+ return (mPTE_t*)p;
5609+
5610+ /* look in secondary PTEG */
5611+ p = (ulong*)( (ulong)MMU.hash_base + (pteg ^ (mask << 6)) );
5612+ cmp |= BIT(25);
5613+
5614+ for( i=0; i<8; i++,p+=2 )
5615+ if( cmp == *p )
5616+ return (mPTE_t*)p;
5617+ return NULL;
5618+}
5619+
5620+static int
5621+lookup_mphys( kernel_vars_t *kv, fault_param_t *pb, const int ebits )
5622+{
5623+ ulong ea = (pb->ea & ~0xfff);
5624+ mSEGREG segr;
5625+ mac_bat_t *bp;
82094b55 5626+ int sv_mode, i, sbits;
2cb7cef9
BS		 5627+ mPTE_t *mpte;
5628+
5629+ pb->mpte = NULL;
5630+
5631+ if( !use_mmu(ebits) ) {
5632+ pb->mphys_page = ea;
5633+ pb->pte1 = NO_MMU_PTE1;
5634+ pb->key = 0;
5635+ return 0;
5636+ }
5637+
5638+ segr = *(mSEGREG*)&MREGS.segr[ea>>28];
5639+ sv_mode = !(MREGS.msr & MSR_PR);
5640+
5641+ /* I/O segment? */
5642+ if( segr.t ) {
5643+ /* Memory forced (601/604)? Note that the 601 uses I/O segments
5644+ * even if translation is off(!). We don't implement this though.
5645+ */
5646+ ulong sr = MREGS.segr[ea>>28];
5647+ BUMP( memory_forced_segment );
5648+
5649+ if( ((sr >> 20) & 0x1ff) != 0x7f )
5650+ return RVEC_MMU_IO_SEG_ACCESS;
5651+ pb->mphys_page = (ea & 0x0ffff000) | ((sr & 0xf)<<28);
5652+ pb->pte1 = NO_MMU_PTE1;
5653+ pb->key = 0;
5654+ return 0;
5655+ }
5656+
5657+ /* BAT translation? 0-3 = IBATs, 4-7 = DBATs. Separated I/D BATS, hace 3/8/99 */
5658+ bp = is_dsi(ebits) ? &MMU.bats[4] : &MMU.bats[0];
5659+ for( i=0; i<4; i++, bp++ ) {
5660+ if( !bp->valid )
5661+ continue;
5662+ if( (sv_mode && !bp->vs) || (!sv_mode && !bp->vp) )
5663+ continue;
5664+ if( ea < bp->base || ea > bp->base+bp->size-1 )
5665+ continue;
5666+
5667+ pb->mphys_page = ea - bp->base + bp->mbase;
5668+ pb->pte1 = bp->pp | (bp->wimg << 3) | PTE1_R | PTE1_C;
5669+ pb->key = sv_mode ? bp->ks : bp->ku;
5670+ return 0;
5671+ }
5672+
5673+#ifdef EMULATE_603
5674+ if( (MREGS.spr[S_PVR] >> 16) == 3 ) {
5675+ if( lookup_603_pte(kv, segr.vsid, ea, is_dsi(ebits), &mpte) )
5676+ return is_dsi(ebits) ? (is_write(ebits) ? RVEC_DMISS_STORE_TRAP :
5677+ RVEC_DMISS_LOAD_TRAP) : RVEC_IMISS_TRAP;
5678+
5679+ pb->mpte = NULL; /* imporant */
5680+ pb->mphys_page = (mpte->rpn << 12);
5681+ pb->pte1 = ((ulong*)mpte)[1] & (PTE1_PP | PTE1_WIMG | PTE1_R | PTE1_C);
5682+ pb->key = sv_mode ? segr.ks : segr.kp;
5683+ return 0;
5684+ }
5685+#endif
5686+ /* mac page table lookup */
5687+ if( (mpte=lookup_mac_pte(kv, segr.vsid, ea)) ) {
5688+ pb->mpte = mpte;
5689+ pb->mphys_page = (mpte->rpn << 12);
5690+ pb->pte1 = ((ulong*)mpte)[1] & (PTE1_PP | PTE1_WIMG | PTE1_R | PTE1_C);
5691+ pb->key = sv_mode ? segr.ks : segr.kp;
5692+ return 0;
5693+ }
5694+ /* mac page fault */
5695+ sbits = EBIT_PAGE_FAULT | (ebits & EBIT_IS_WRITE); /* r/w bit + page_fault */
5696+ RVEC_RETURN_2( &MREGS, is_dsi(ebits) ? RVEC_DSI_TRAP : RVEC_ISI_TRAP, pb->ea, sbits );
5697+}
5698+
5699+
5700+/* PTE0 must be fully initialized on entry (with V=1 and H=0).
5701+ * The pte_present flag should be set from srr1/dsisr bit and indicates
5702+ * that a valid PTE might already be present in the hash table.
5703+ */
5704+static inline ulong *
5705+find_pte_slot( ulong ea, ulong *pte0, int pte_present, int *pte_replaced )
5706+{
5707+ static int grab_add=0;
5708+ ulong phash, pteg, *p, cmp = *pte0;
5709+ ulong *primary, *secondary;
5710+ int i;
5711+
5712+ /* we are only interested in the page index */
5713+ ea &= 0x0ffff000;
5714+
5715+ /* primary hash function */
5716+ phash = (ea >> 12) ^ (PTE0_VSID(cmp) & 0x7ffff);
5717+
5718+ pteg = (phash << 6) & ptehash.pteg_mask;
5719+ primary = (ulong*)((ulong)ptehash.base + pteg);
5720+
5721+ pteg = pteg ^ ptehash.pteg_mask;
5722+ secondary = (ulong*)((ulong)ptehash.base + pteg);
5723+
5724+ if( pte_present ) {
5725+ *pte_replaced = 1;
5726+
5727+ /* look in primary PTEG */
5728+ p = primary;
5729+ for( i=0; i<8; i++, p+=2 )
5730+ if( cmp == *p )
5731+ return p;
5732+
5733+ /* look in secondary PTEG */
5734+ p = secondary;
5735+ cmp |= BIT(25);
5736+ for( i=0; i<8; i++, p+=2 )
5737+ if( cmp == *p ) {
5738+ *pte0 |= PTE0_H;
5739+ return p;
5740+ }
5741+ /* we will actually come here if the previous PTE
5742+ * was only available in the on-chip cache.
5743+ */
5744+ }
5745+ *pte_replaced = 0;
5746+
5747+ /* free slot in primary PTEG? */
5748+ for( p=primary, i=0; i<8; i++, p+=2 )
5749+ if( !(*p & BIT(0)) )
5750+ return p;
5751+
5752+ /* free slot in secondary PTEG? */
5753+ for( p=secondary, i=0; i<8; i++, p+=2 )
5754+ if( !(*p & BIT(0)) ) {
5755+ *pte0 |= PTE0_H;
5756+ return p;
5757+ }
5758+
5759+ /* steal a primary PTEG slot */
5760+ grab_add = (grab_add+1) & 0x7;
5761+
5762+ /* printk("Grabbing slot %d, EA %08X\n",grab_add, ea ); */
5763+ return (ulong*)((ulong)primary + grab_add * sizeof(ulong[2]));
5764+}
5765+
5766+static inline int
5767+insert_pte( kernel_vars_t *kv, fault_param_t *pb, const int ebits )
5768+{
5769+ ulong ea=pb->ea, mphys=pb->mphys_page;
5770+ ulong sr=pb->sr_base[ea>>28];
5771+ int status, pte_replaced;
5772+ pte_lvrange_t *lvrange;
5773+ ulong pte0, pte1, *slot;
5774+ ulong lvptr;
5775+
5776+#ifdef CONFIG_AMIGAONE
5777+ pte1 = PTE1_R | (pb->pte1 & (PTE1_R | PTE1_C | PTE1_WIMG))
5778+ | (is_write(ebits) ? 2:3);
5779+#else
5780+ pte1 = PTE1_M | PTE1_R | (pb->pte1 & (PTE1_R | PTE1_C | PTE1_WIMG))
5781+ | (is_write(ebits) ? 2:3);
5782+#endif
5783+
5784+ /* PP and WIMG bits must set before the call to mphys_to_pte */
5785+ status = mphys_to_pte( kv, mphys, &pte1, is_write(ebits), &lvrange );
5786+
5787+ if( !status || (is_write(ebits) && (status & MAPPING_RO)) ) {
5788+ ulong addr = (mphys | (ea & 0xfff));
5789+ if( is_dsi(ebits) ) {
5790+ int rvec = is_write(ebits) ? RVEC_IO_WRITE : RVEC_IO_READ;
5791+ BUMP( io_read_write );
5792+ RVEC_RETURN_2( &MREGS, rvec, addr, NULL );
5793+ } else {
5794+ RVEC_RETURN_1( &MREGS, RVEC_BAD_NIP, addr );
5795+ }
5796+ }
5797+
5798+ /* tlbhash table hit? */
5799+ if( (ulong)(pb->mphys_page - MMU.hash_mbase) < (ulong)MMU.hash_mask ) {
5800+ /* printk("hash_table_hit at %08lX\n", pb->ea ); */
5801+ MMU.pthash_sr = sr;
5802+ MMU.pthash_ea_base = ea & ~MMU.hash_mask;
5803+
5804+ /* user read (always), superuser r/w */
5805+ pte1 &= ~PTE1_PP;
5806+ pte1 |= is_write(ebits) ? 1:3;
5807+ /* write accesses of the page table are handled in ptintercept.S */
5808+ }
5809+
5810+ pte0 = PTE0_V | (sr << 7) | ((ea>>22) & PTE0_API);
5811+ slot = find_pte_slot( ea, &pte0, !is_page_fault(ebits), &pte_replaced );
5812+
5813+ lvptr = (status & MAPPING_PHYSICAL) ? 0 : (pte1 & PTE1_RPN);
5814+
5815+ /* the RC bits should correspond to the is_write flag; this prevents the
5816+ * CPU from stamping RC bits unnecessary (besides, the kernel seems to
5817+ * assume no RC-stamps will ever occur so RC-stamping is unsafe).
5818+ */
5819+ if( is_write(ebits) )
5820+ pte1 |= PTE1_C;
5821+ pte1 |= SMP_PTE1_M;
5822+
5823+ /* if a page-out occurs between prepare_pte_insert() and the pte_inserted()
5824+ * call, then the PTE slot is zeroed out.
5825+ */
5826+ if( !(status & MAPPING_PHYSICAL) ) {
5827+#if 0
5828+ if( is_write(ebits) )
5829+ lvpage_dirty( kv, lvptr );
5830+#endif
5831+ pte1 &= ~PTE1_RPN;
5832+
5833+ /* zero pages should work just fine now... */
5834+ pte1 |= get_phys_page( kv, lvptr, is_write(ebits) );
5835+ /* pte1 |= get_phys_page( kv, lvptr, !(status & MAPPING_RO) ); */
5836+ }
5837+
5838+ if( status & MAPPING_FB_ACCEL )
5839+ video_pte_inserted( kv, lvptr, slot, pte0, pte1, ea );
5840+
5841+ BUMP( page_fault_ctr );
5842+ DEBUG_print_inserted_pte( slot, pte0, pte1, ea );
5843+
5844+ __store_PTE( ea, slot, pte0, pte1 );
5845+
5846+ pte_inserted( kv, ea, (char*)lvptr, lvrange, slot, pb->vsid_eptr[ea>>28], sr );
5847+
5848+ /* debugger support */
5849+ if( (kv->break_flags & BREAK_EA_PAGE) && (ea & ~0xfff) == MREGS.mdbg_ea_break )
5850+ RVEC_RETURN_1( &MREGS, RVEC_BREAK, BREAK_EA_PAGE );
5851+
5852+ return RVEC_NOP;
5853+}
5854+
5855+static int
5856+page_fault( kernel_vars_t *kv, fault_param_t *pb, const int ebits )
5857+{
5858+ int topind = pb->ea >> 28;
5859+ int ind, ret;
5860+
5861+ BUMP( access_exception_ctr );
5862+
5863+ if( (ret=lookup_mphys(kv, pb, ebits)) ) {
5864+ BUMP(mac_page_fault);
5865+ return ret;
5866+ }
5867+
5868+ /* printk("MPHYS_PAGE: %08lX, pp %d, key %d, wimg %d, mpte %p\n",
5869+ pb->mphys_page, (pb->pte1 & 3), pb->key, ((pb->pte1 >> 3) & 0xf), pb->mpte ); */
5870+
5871+ /* check privileges */
5872+ ind = (is_write(ebits) ? 8:0) | (pb->pte1 & PTE1_PP) | (pb->key?4:0);
5873+ if( priv_viol_table[ind] ) {
5874+ /* r/w bit + priv. violation */
5875+ int sbits = EBIT_PROT_VIOL | (ebits & EBIT_IS_WRITE);
5876+ BUMP(mac_priv_violation);
5877+ RVEC_RETURN_2( &MREGS, is_dsi(ebits) ? RVEC_DSI_TRAP : RVEC_ISI_TRAP, pb->ea, sbits );
5878+ }
5879+
5880+ /* stamp R/C bits (mpte is NULL if this is not a page translation). */
5881+ if( pb->mpte ) {
5882+ pb->mpte->r = 1;
5883+ if( is_write(ebits) )
5884+ pb->mpte->c = 1;
5885+
5886+ /* stamp pthash_inuse_bit */
5887+ if( MMU.pthash_inuse_bits ) {
5888+ int nr = ((int)pb->mpte - (int)MMU.hash_base) >> 3;
5889+ set_bit_mol( nr, MMU.pthash_inuse_bits );
5890+ }
5891+ }
5892+
5893+ /* perform memory allocations if necessary; we are not allowed to
5894+ * do this later (the mtable insertion must be atomic)
5895+ */
5896+ if( mtable_memory_check(kv) )
5897+ return RVEC_NOP; /* out of memory */
5898+
5899+ /* the vsid entry might have been released */
5900+ if( !pb->vsid_eptr[topind] )
5901+ return RVEC_NOP;
5902+
5903+ return insert_pte( kv, pb, ebits );
5904+}
5905+
5906+
5907+/************************************************************************/
5908+/* VSID allocation (the normal VSID lookup occurs in vsid.S) */
5909+/************************************************************************/
5910+
5911+static void
5912+fix_sr( kernel_vars_t *kv, int sr, int mapped )
5913+{
5914+ int macvsid = mapped ? (MREGS.segr[sr] & VSID_MASK) : VSID_MASK + 1 + sr;
5915+ ulong user_sr, sv_sr;
5916+ vsid_ent_t *r = vsid_get_user_sv( kv, macvsid, &user_sr, &sv_sr );
5917+
5918+ BUMP(fix_sr);
5919+ if( !r )
5920+ return;
5921+
5922+ if( mapped ) {
5923+ int value = MREGS.segr[sr];
5924+ int nbit = value & VSID_N;
5925+ MMU.vsid[sr] = r;
5926+ MMU.user_sr[sr] = ((value & VSID_Kp) ? user_sr : sv_sr) | nbit;
5927+ MMU.sv_sr[sr] = ((value & VSID_Ks) ? user_sr : sv_sr) | nbit;
5928+ } else {
5929+ MMU.unmapped_vsid[sr] = r;
5930+ MMU.unmapped_sr[sr] = user_sr;
5931+ }
5932+ invalidate_splitmode_sr( kv );
5933+}
5934+
5935+
5936+/************************************************************************/
5937+/* Exception entrypoints (called from assembly) */
5938+/************************************************************************/
5939+
5940+extern int dsi_exception( kernel_vars_t *kv, ulong dar, ulong dsisr );
5941+extern int isi_exception( kernel_vars_t *kv, ulong nip, ulong srr1 );
5942+
5943+int
5944+dsi_exception( kernel_vars_t *kv, ulong dar, ulong dsisr )
5945+{
5946+ int ebits, topind = dar >> 28;
5947+ fault_param_t pb;
5948+
5949+ /* printk("DSI: EA %08lX, DSISR %08lX\n", dar, dsisr ); */
5950+ if( dsisr & 0x84500000 ) /* 0,5,9,11 */
5951+ RVEC_RETURN_2( &MREGS, RVEC_UNUSUAL_DSISR_BITS, dar, dsisr );
5952+
5953+ pb.ea = dar;
5954+ ebits = EBIT_IS_DSI | (dsisr & (EBIT_PAGE_FAULT | EBIT_PROT_VIOL | EBIT_IS_WRITE))
5955+ | ((MREGS.msr & MSR_DR) ? EBIT_USE_MMU : 0);
5956+
5957+ pb.vsid_eptr = (MREGS.msr & MSR_DR) ? MMU.vsid : MMU.unmapped_vsid;
5958+ pb.sr_base = (ulong*)((ulong)MMU.sr_data - kv->kvars_tophys_offs);
5959+
5960+ /* segment register switch-in required? */
5961+ if( !pb.vsid_eptr[topind] ) {
5962+ fix_sr( kv, topind, use_mmu(ebits) );
5963+ return RVEC_NOP;
5964+ }
5965+ BUMP(dsi);
5966+ return page_fault( kv, &pb, ebits );
5967+}
5968+
5969+int
5970+isi_exception( kernel_vars_t *kv, ulong nip, ulong srr1 )
5971+{
5972+ fault_param_t pb;
5973+ /* printk("ISI: NIP %08lX, SRR1 %08lX\n", nip, srr1 ); */
5974+
5975+ pb.vsid_eptr = (MREGS.msr & MSR_IR) ? MMU.vsid : MMU.unmapped_vsid;
5976+
5977+ if( srr1 & EBIT_PAGE_FAULT ) {
5978+ int ebits = EBIT_PAGE_FAULT | ((MREGS.msr & MSR_IR) ? EBIT_USE_MMU : 0);
5979+ pb.ea = nip;
5980+ pb.sr_base = (ulong*)((ulong)MMU.sr_inst - kv->kvars_tophys_offs);
5981+ BUMP(isi_page_fault);
5982+ return page_fault( kv, &pb, ebits );
5983+ }
5984+ if( srr1 & EBIT_NO_EXEC ) {
5985+ int sr = nip >> 28;
5986+ if( !pb.vsid_eptr[sr] ) {
5987+ fix_sr( kv, sr, (MREGS.msr & MSR_IR) );
5988+ return RVEC_NOP;
5989+ }
5990+ /* printk("Guarded memory access at %08lX\n", nip ); */
5991+ RVEC_RETURN_2( &MREGS, RVEC_ISI_TRAP, nip, EBIT_NO_EXEC );
5992+ }
5993+
5994+ BUMP(isi_prot_violation);
5995+ /* must be privileges violation */
5996+ RVEC_RETURN_2( &MREGS, RVEC_ISI_TRAP, nip, EBIT_PROT_VIOL );
5997+}
5998+
5999+
6000+/************************************************************************/
6001+/* debugger functions */
6002+/************************************************************************/
6003+
6004+int
6005+dbg_translate_ea( kernel_vars_t *kv, int context, ulong va, int *ret_mphys, int data_access )
6006+{
6007+ int ebits = data_access ? EBIT_IS_DSI : 0;
6008+ fault_param_t pb;
6009+
6010+ memset( &pb, 0, sizeof(pb) );
6011+ pb.ea = va;
6012+
6013+ switch( context ) {
6014+ case kContextUnmapped:
6015+ pb.sr_base = MMU.unmapped_sr;
6016+ break;
6017+ case kContextMapped_S:
6018+ pb.sr_base = MMU.sv_sr;
6019+ ebits |= EBIT_USE_MMU;
6020+ break;
6021+ case kContextMapped_U:
6022+ pb.sr_base = MMU.user_sr;
6023+ ebits |= EBIT_USE_MMU;
6024+ break;
6025+ default:
6026+ return 1;
6027+ }
6028+
6029+ if( lookup_mphys(kv, &pb, ebits) )
6030+ return 1;
6031+ *ret_mphys = pb.mphys_page | (va & 0xfff);
6032+ return 0;
6033+}
6034--- /dev/null
6035+++ b/drivers/macintosh/mol/hash.c
6036@@ -0,0 +1,126 @@
6037+/*
6038+ * Creation Date: <2004/02/14 11:42:19 samuel>
6039+ * Time-stamp: <2004/03/13 14:25:00 samuel>
6040+ *
6041+ * <hash.c>
6042+ *
6043+ * CPU PTE hash handling
6044+ *
6045+ * Copyright (C) 2003, 2004 Samuel Rydh (samuel@ibrium.se)
6046+ *
6047+ * This program is free software; you can redistribute it and/or
6048+ * modify it under the terms of the GNU General Public License
6049+ * as published by the Free Software Foundation
6050+ *
6051+ */
6052+
6053+#include "archinclude.h"
6054+#include "alloc.h"
6055+#include "kernel_vars.h"
6056+#include "mmu.h"
6057+#include "mmu_contexts.h"
6058+#include "asmfuncs.h"
6059+#include "emu.h"
6060+#include "misc.h"
6061+#include "mtable.h"
6062+#include "performance.h"
6063+#include "context.h"
6064+#include "hash.h"
6065+#include "map.h"
6066+
6067+/* GLOBALS */
6068+hash_info_t ptehash;
6069+
6070+static struct {
6071+ int hash_mapped;
6072+ int sdr1_loaded;
6073+ char *allocation;
6074+} hs;
6075+
6076+
6077+static int
6078+create_pte_hash( void )
6079+{
6080+ ulong size = 1024*128; /* 128K is the kmalloc limit */
6081+ ulong sdr1, mask, base, physbase;
6082+ char *p;
6083+
6084+ if( !(p=kmalloc_cont_mol(size)) )
6085+ return 1;
6086+ memset( p, 0, size );
6087+ base = (ulong)p;
6088+ physbase = tophys_mol( (char*)base );
6089+
6090+ if( (physbase & (size-1)) ) {
6091+ int offs;
6092+ printk("Badly aligned SDR1 allocation - 64K wasted\n");
6093+ size /= 2;
6094+ offs = ((physbase + size) & ~(size-1)) - physbase;
6095+ physbase += offs;
6096+ base += offs;
6097+ }
6098+ mask = (size-1) >> 6;
6099+ sdr1 = mask >> 10;
6100+ sdr1 |= physbase;
6101+
6102+ hs.allocation = p;
6103+ ptehash.sdr1 = sdr1;
6104+ ptehash.base = (ulong*)base;
6105+
6106+ printk("SDR1 = %08lX\n", sdr1 );
6107+ return 0;
6108+}
6109+
6110+int
6111+init_hash( void )
6112+{
6113+ ulong sdr1;
6114+
6115+ memset( &ptehash, 0, sizeof(ptehash) );
6116+
6117+ if( IS_LINUX ) {
6118+ sdr1 = _get_sdr1();
6119+
6120+ /* linux does not use SDR1 on the 603[e] */
6121+ if( !sdr1 ) {
6122+ create_pte_hash();
6123+ sdr1 = ptehash.sdr1;
6124+ _set_sdr1( sdr1 );
6125+ hs.sdr1_loaded = 1;
6126+ }
6127+ } else {
6128+ /* sharing the hash under darwin is too complicated */
6129+ create_pte_hash();
6130+ sdr1 = ptehash.sdr1;
6131+ }
6132+
6133+ if( !sdr1 )
6134+ return 1;
6135+
6136+ ptehash.sdr1 = sdr1;
6137+ ptehash.pteg_mask = (((sdr1 & 0x1ff) << 10) | 0x3ff) << 6;
6138+ ptehash.pte_mask = ptehash.pteg_mask | 0x38;
6139+ ptehash.physbase = sdr1 & ~0xffff;
6140+
6141+ if( !ptehash.base ) {
6142+ hs.hash_mapped = 1;
6143+ ptehash.base = map_hw_hash( ptehash.physbase, ptehash.pte_mask + 8 );
6144+ }
6145+
6146+ return !ptehash.base;
6147+}
6148+
6149+void
6150+cleanup_hash( void )
6151+{
6152+ if( hs.hash_mapped )
6153+ unmap_hw_hash( ptehash.base );
6154+
6155+ if( hs.sdr1_loaded )
6156+ _set_sdr1( 0 );
6157+ if( hs.allocation )
6158+ kfree_cont_mol( hs.allocation );
6159+
6160+ memset( &ptehash, 0, sizeof(ptehash) );
6161+ memset( &hs, 0, sizeof(hs) );
6162+}
6163--- /dev/null
6164+++ b/drivers/macintosh/mol/include/actions.h
6165@@ -0,0 +1,177 @@
6166+/*
6167+ * Creation Date: <2004/01/31 13:08:42 samuel>
6168+ * Time-stamp: <2004/03/07 14:25:23 samuel>
6169+ *
6170+ * <actions.h>
6171+ *
6172+ *
6173+ *
6174+ * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
6175+ *
6176+ * This program is free software; you can redistribute it and/or
6177+ * modify it under the terms of the GNU General Public License
6178+ * version 2
6179+ *
6180+ */
6181+
6182+#ifndef _H_ACTIONS
6183+#define _H_ACTIONS
6184+
6185+/* Certain assembly macros (like LI_PHYS) adds meta information to a special
6186+ * ELF segment. This information is parsed when the module is loaded/used and
6187+ * the appropriate action is performed (a few assembly instruction are typically
6188+ * modified).
6189+ *
6190+ * Actions with lower opcodes are performed before actions with higher opcodes.
6191+ */
6192+
6193+#define ACTION_LIS_SPECVAR_H 1 /* dreg, special_var_index */
6194+#define ACTION_ORI_SPECVAR_L 2 /* dreg*32 + sreg, special_var_index */
6195+#define ACTION_LI_PHYS 3 /* dreg, addr_offs */
6196+#define ACTION_LWZ_PHYSADDR_R 4 /* dreg*32 + reg, addr_offs */
6197+#define ACTION_TOPHYS 5 /* dreg*32 + sreg */
6198+#define ACTION_TOVIRT 6 /* dreg*32 + sreg */
6199+#define ACTION_RELOCATE_LOW 7 /* code_size, destvar, code... */
6200+#define ACTION_VRET 8 /* vector [special, used by RELOC_HOOK] */
6201+#define ACTION_FIX_SPRG2 9 /* scratch_reg */
6202+
6203+#define FLUSH_CACHE_ACTION 9 /* flush the icache at this point */
6204+
6205+#define ACTION_HOOK_FUNCTION 10
6206+#define ACTION_RELOC_HOOK 11 /* trigger, size, vret_action#, vret_offs */
6207+#define MAX_NUM_ACTIONS 12
6208+
6209+/* Special vars (ACTION_*_SPECVAR) */
6210+#define SPECVAR_SESSION_TABLE 1
6211+
6212+/* Function hooks (ACTION_HOOK_FUNCTION) */
6213+#define FHOOK_FLUSH_HASH_PAGE 1
6214+
6215+#ifndef __ASSEMBLY__
6216+typedef struct {
6217+ int action; /* ACTION_xxx */
6218+ int offs; /* target instruction offset (from r__reloctable_start) */
6219+ int params[1]; /* parameters */
6220+} action_pb_t;
6221+#endif /* __ASSEMBLY__ */
6222+
6223+
6224+/************************************************************************/
6225+/* assembly macros */
6226+/************************************************************************/
6227+
6228+/*
6229+ * WARNING: These macros uses the 9 label (the OSX assembler
6230+ * can only use labels (0-9).
6231+ */
6232+
6233+#ifdef __ASSEMBLY__
6234+
6235+#ifdef __linux__
6236+#define ACTIONS_SECTION .text 95
6237+#define ACTIONS_OFFS_SECTION .text 96
6238+#endif
6239+#ifdef __darwin__
6240+#define ACTIONS_SECTION .section __TEXT,__areloc
6241+#define ACTIONS_OFFS_SECTION .section __DATA,__areloc_offs
6242+#endif
6243+
6244+mDEFINE(ACTION_PB, [action], [
6245+ .text
6246+9:
6247+ ACTIONS_SECTION
6248+ .long _action /* action */
6249+ .long (9b - r__reloctable_start) /* target PC */
6250+9:
6251+ ACTIONS_OFFS_SECTION
6252+ .long (9b - r__actions_section - 8) /* store pointer to PB */
6253+ ACTIONS_SECTION
6254+])
6255+
6256+mDEFINE(ACTION_1, [action, p1], [
6257+ ACTION_PB( _action )
6258+ .long _p1
6259+ .text
6260+ nop /* replaced */
6261+])
6262+
6263+mDEFINE(ACTION_21, [action, p1, p2], [
6264+ ACTION_PB( _action )
6265+ .long _p1, _p2
6266+ .text
6267+ nop /* replaced */
6268+])
6269+
6270+mDEFINE(ACTION_2, [action, p1, p2], [
6271+ ACTION_PB( _action )
6272+ .long _p1, _p2
6273+ .text
6274+ nop /* replaced */
6275+ nop /* replaced */
6276+])
6277+
6278+mDEFINE(ACTION_13, [action, p1], [
6279+ ACTION_PB( _action )
6280+ .long _p1
6281+ .text
6282+ nop /* replaced */
6283+ nop /* replaced */
6284+ nop /* replaced */
6285+])
6286+
6287+
6288+ /* replaced with lis dreg,addr@ha ; addi dreg,dreg,addr@l */
6289+#define LI_PHYS( dreg, addr ) \
6290+ ACTION_2( ACTION_LI_PHYS, dreg, (addr - r__reloctable_start) )
6291+
6292+ /* replaced with addis dreg,reg,addr@ha ; lwz dreg,addr@lo(dreg). */
6293+#define LWZ_PHYSADDR_R( dreg, addr, reg ) \
6294+ ACTION_2( ACTION_LWZ_PHYSADDR_R, (dreg*32 + reg), (addr - r__reloctable_start) )
6295+
6296+#define LWZ_PHYS( dreg, addr ) \
6297+ LWZ_PHYSADDR_R( dreg, addr, 0 );
6298+
6299+ /* syntax: tophys rD,rS */
6300+MACRO(tophys, [dreg, sreg], [
6301+ ACTION_1( ACTION_TOPHYS, (_dreg * 32 + _sreg) )
6302+])
6303+ /* syntax: tovirt rD,rS */
6304+MACRO(tovirt, [dreg, sreg], [
6305+ ACTION_1( ACTION_TOVIRT, (_dreg * 32 + _sreg) )
6306+])
6307+
6308+ /* syntax: lis_specvar_ha rD,SPECIAL_VAR */
6309+MACRO(lis_svh, [dreg, specvariable], [
6310+ ACTION_21( ACTION_LIS_SPECVAR_H, _dreg, _specvariable )
6311+])
6312+
6313+ /* syntax: addi_specvar_ha rD,rS,SPECIAL_VAR */
6314+MACRO(ori_svl, [dreg, sreg, specvariable], [
6315+ ACTION_21( ACTION_ORI_SPECVAR_L, (_dreg * 32)+_sreg, _specvariable )
6316+])
6317+
6318+ /* syntax: FIX_SPRG2 rN */
6319+MACRO(fix_sprg2, [reg], [
6320+ /* only darwin needs this (sprg_a0 holds bits describing the CPU) */
6321+#ifdef __darwin__
6322+ ACTION_13( ACTION_FIX_SPRG2, _reg )
6323+#endif
6324+])
6325+
6326+mDEFINE(RELOC_LOW, [destvar], [
6327+ ACTION_PB( ACTION_RELOCATE_LOW )
6328+ .long _destvar[]_end - _destvar[]_start
6329+ .long EXTERN([]_destvar)
6330+_destvar[]_start:
6331+])
6332+
6333+mDEFINE(RELOC_LOW_END, [destvar], [
6334+_destvar[]_end:
6335+ .text
6336+])
6337+
6338+
6339+#endif /* __ASSEMBLY__ */
6340+
6341+
6342+#endif /* _H_ACTIONS */
6343--- /dev/null
6344+++ b/drivers/macintosh/mol/include/alloc.h
6345@@ -0,0 +1,70 @@
6346+/*
6347+ * Creation Date: <2002/01/13 16:35:18 samuel>
6348+ * Time-stamp: <2004/01/25 17:36:49 samuel>
6349+ *
6350+ * <alloc.h>
6351+ *
6352+ * Memory allocation and mappings
6353+ *
6354+ * Copyright (C) 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
6355+ *
6356+ * This program is free software; you can redistribute it and/or
6357+ * modify it under the terms of the GNU General Public License
6358+ * version 2
6359+ *
6360+ */
6361+
6362+#ifndef _H_ALLOC
6363+#define _H_ALLOC
6364+
6365+#include <linux/slab.h>
6366+#include <linux/vmalloc.h>
6367+#include <linux/mm.h>
6368+#include <asm/uaccess.h>
6369+
6370+#ifdef LINUX_26
6371+#include <asm/cacheflush.h>
6372+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10)
6373+#include <asm/io.h>
6374+#endif
6375+#endif
6376+
6377+static inline void *kmalloc_mol( int size ) {
6378+ return kmalloc( size, GFP_KERNEL );
6379+}
6380+static inline void kfree_mol( void *p ) {
6381+ kfree( p );
6382+}
6383+static inline void *vmalloc_mol( int size ) {
6384+ return vmalloc( size );
6385+}
6386+static inline void vfree_mol( void *p ) {
6387+ vfree( p );
6388+}
6389+static inline ulong alloc_page_mol( void ) {
6390+ return get_zeroed_page( GFP_KERNEL );
6391+}
6392+static inline void free_page_mol( ulong addr ) {
6393+ free_page( addr );
6394+}
6395+static inline void *kmalloc_cont_mol( int size ) {
6396+ return kmalloc( size, GFP_KERNEL );
6397+}
6398+static inline void kfree_cont_mol( void *addr ) {
6399+ kfree( addr );
6400+}
6401+static inline ulong tophys_mol( void *addr ) {
6402+ return virt_to_phys(addr);
6403+}
6404+static inline void flush_icache_mol( ulong start, ulong stop ) {
6405+ flush_icache_range( start, stop );
6406+}
6407+static inline void *map_phys_range( ulong paddr, ulong size, char **ret_addr ) {
6408+ /* Warning: This works only for certain addresses... */
6409+ *ret_addr = phys_to_virt(paddr);
6410+ return (void*)(-2); /* dummy */
6411+}
6412+static inline void unmap_phys_range( void *handle ) {}
6413+
6414+
6415+#endif /* _H_ALLOC */
6416--- /dev/null
6417+++ b/drivers/macintosh/mol/include/archinclude.h
6418@@ -0,0 +1,77 @@
6419+/*
6420+ * Creation Date: <2002/01/12 22:11:51 samuel>
6421+ * Time-stamp: <2004/04/10 22:27:41 samuel>
6422+ *
6423+ * <archinclude.h>
6424+ *
6425+ *
6426+ *
6427+ * Copyright (C) 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
6428+ *
6429+ * This program is free software; you can redistribute it and/or
6430+ * modify it under the terms of the GNU General Public License
6431+ * as published by the Free Software Foundation
6432+ *
6433+ */
6434+
6435+#ifndef _H_ARCHINCLUDE
6436+#define _H_ARCHINCLUDE
6437+
6438+//#define PERF_MONITOR
6439+//#define PERFORMANCE_INFO /* collect performance statistics */
6440+//#define PERFORMANCE_INFO_LIGHT /* sample only the most important counters */
6441+
6442+#include "mol_config.h"
6443+#include "kconfig.h"
6444+
6445+#include <linux/version.h>
6446+
6447+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
6448+#include <linux/utsrelease.h>
6449+#endif
6450+
6451+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
6452+#include <linux/config.h>
6453+#else
6454+#include <linux/autoconf.h>
6455+#endif
6456+
6457+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
6458+#define LINUX_26
6459+#endif
6460+
6461+#ifndef __ASSEMBLY__
6462+#include <linux/kernel.h>
6463+#include <asm/atomic.h>
6464+#include <linux/sched.h> /* needed by <asm/mmu_context.h> */
6465+#include <asm/mmu_context.h>
6466+#include <asm/time.h>
6467+
6468+#include "dbg.h"
6469+
6470+/* these are declared, but we just want to be sure the definition does not change */
6471+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
6472+extern int flush_hash_pages( unsigned context, unsigned long va, unsigned long pmdval, int count ); /* 2.6 */
6473+#else
6474+extern int flush_hash_page( unsigned context, unsigned long va, pte_t *ptep ); /* 2.5 */
6475+#endif /* Linux 2.6 */
6476+
6477+#endif /* __ASSEMBLY__ */
6478+
6479+#ifdef LINUX_26
6480+#define compat_flush_hash_pages flush_hash_pages
6481+#define compat_hash_table_lock mmu_hash_lock
6482+#else
6483+#define compat_flush_hash_pages flush_hash_page
6484+#define compat_hash_table_lock hash_table_lock
6485+#endif
6486+
6487+
6488+#define ENOSYS_MOL ENOSYS
6489+#define EFAULT_MOL EFAULT
6490+
6491+#define IS_LINUX 1
6492+#define IS_DARWIN 0
6493+
6494+
6495+#endif /* _H_ARCHINCLUDE */
6496--- /dev/null
6497+++ b/drivers/macintosh/mol/include/asm.m4
6498@@ -0,0 +1,141 @@
6499+/* -*- asm -*-
6500+ * Creation Date: <2001/12/30 20:08:53 samuel>
6501+ * Time-stamp: <2002/01/14 00:48:09 samuel>
6502+ *
6503+ * <asm.m4>
6504+ *
6505+ * m4 initialization (m4 is used as an assembly preprocessor)
6506+ *
6507+ * Copyright (C) 2001, 2002, 2004 Samuel Rydh (samuel@ibrium.se)
6508+ *
6509+ * This program is free software; you can redistribute it and/or
6510+ * modify it under the terms of the GNU General Public License
6511+ * as published by the Free Software Foundation
6512+ *
6513+ */
6514+
6515+/* This end-of-quote matches the start-of-quote in mol_config.h */
6516+]]]]]
6517+divert(-1)
6518+changequote([,])
6519+
6520+dnl m4 macros to avoid in header files (we can not rename these)
6521+dnl ==========================================================
6522+dnl shift, eval, expr, decr, incr, ifelse, popdef, pushdef
6523+
6524+
6525+dnl **************************************************************
6526+dnl * Rename to reduce namespace conflicts
6527+dnl **************************************************************
6528+
6529+dnl *** Changing the name of built-in macros using defn does not always work ***
6530+
6531+undefine([changecom])
6532+undefine([changequote])
6533+dnl undefine([decr])
6534+undefine([defn])
6535+dnl undefine([divert])
6536+undefine([divnum])
6537+undefine([errprint])
6538+dnl undefine([eval])
6539+dnl undefine([expr])
6540+undefine([file])
6541+undefine([format])
6542+undefine([len])
6543+undefine([line])
6544+dnl undefine([ifelse])
6545+dnl undefine([incr])
6546+undefine([indir])
6547+undefine([include])
6548+undefine([index])
6549+undefine([maketemp])
6550+undefine([paste])
6551+undefine([patsubst])
6552+dnl undefine([popdef])
6553+dnl undefine([pushdef])
6554+undefine([regexp])
6555+dnl undefine([shift])
6556+undefine([sinclude])
6557+undefine([spaste])
6558+undefine([substr])
6559+undefine([syscmd])
6560+undefine([sysval])
6561+undefine([translit])
6562+undefine([traceoff])
6563+undefine([traceon])
6564+undefine([undivert])
6565+undefine([unix])
6566+dnl undefine([__gnu__])
6567+dnl undefine([__unix__])
6568+
6569+dnl Uncomment to list m4 definitions
6570+dnl dumpdef m4exit
6571+
6572+/************************************************************************/
6573+/* M4 Macros */
6574+/************************************************************************/
6575+
6576+dnl
6577+dnl WARNING - M4 BUG IN MacOS X (10.1.2):
6578+dnl eval() in MacOS X (10.1.2) handles '&' as '&&' and '|' as '||'.
6579+dnl
6580+
6581+/* FORLOOP(var, from, to, [body var...]) */
6582+define([mFORLOOP], [pushdef([$1], [$2])_mFORLOOP([$1], [$2], [$3], [$4])popdef([$1])])
6583+define([_mFORLOOP], [$4[]ifelse($1, [$3], ,
6584+ [define([$1], incr($1))_mFORLOOP([$1], [$2], [$3], [$4])])])
6585+
6586+define([mFIRST],[$1])
6587+define([mCONCAT_C],[ [$@] ])
6588+
6589+/* FOREACH(var, [item1, ...], [body var ...]) */
6590+define([mFOREACH],[pushdef([$1],mFIRST($2))_mFOREACH([$1],[shift($2)],[$3])popdef([$1])])
6591+define([_mFOREACH],[$3] [ifelse(mFIRST($2),,,[define([$1],mFIRST($2)) _mFOREACH([$1],[shift($2)],[$3])])])
6592+
6593+
6594+/******************** Nice macro definitions **************************/
6595+
6596+/* MACRO(name, [param1, ...], [body _param1 ...]) */
6597+#ifdef __linux__
6598+define([MACRO], [
6599+ .macro [$1] $2
6600+ mFOREACH([i],[$2],[ pushdef(_[]i,\i) ])
6601+ $3
6602+ .endm
6603+ mFOREACH([i],[$2],[ popdef(_[]i) ])
6604+])
6605+#else
6606+define([MACRO], [
6607+ .macro [$1]
6608+ pushdef([_n],0)
6609+ mFOREACH([i],[$2],[ pushdef(_[]i,[$[]]_n) define([_n],incr(_n)) ])
6610+ $3
6611+ .endmacro
6612+ mFOREACH([i],[$2],[ popdef(_[]i) ])
6613+ popdef([_n])
6614+])
6615+#endif
6616+define([MACRO_0], [MACRO([$1],[_dummy_param_],[$2])])
6617+
6618+
6619+/* mDEFINE(name, [param1, ...], [body _param1 ...]) */
6620+define([mDEFINE], [
6621+ pushdef([_n],1)
6622+ mFOREACH([i],[$2],[ pushdef(_[]i,[$[]]_n) define([_n],incr(_n)) ])
6623+ define([$1], mCONCAT_C($3) )
6624+ mFOREACH([i],[$2],[ popdef(_[]i) ])
6625+ popdef([_n])
6626+])
6627+
6628+
6629+/* rLABEL(label): b label_b ; b label_f */
6630+define(rLABEL,[dnl
6631+ifdef([$1]_curnum,,[$1[]f:])dnl
6632+ define([_tmp_curnum],ifdef($1[]_curnum, [eval($1_curnum+1)], 1)) dnl
6633+ define([$1]_curnum,_tmp_curnum)dnl
6634+ define([$1]f,$1_[]eval($1_curnum[]+1) )dnl
6635+ define([$1]b,$1_[]$1_curnum[] )
6636+$1[]_[]$1_curnum[]dnl
6637+])
6638+
6639+divert(0)dnl
6640--- /dev/null
6641+++ b/drivers/macintosh/mol/include/asm_offsets.inc
6642@@ -0,0 +1,136 @@
6643+/* -*-c-*-
6644+ * Creation Date: <2001/10/20 17:51:10 samuel>
6645+ * Time-stamp: <2004/02/21 21:38:27 samuel>
6646+ *
6647+ * <asm_offsets.inc>
6648+ *
6649+ * Extra offsets (included from asm_offsets.c)
6650+ *
6651+ * Copyright (C) 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
6652+ *
6653+ * This program is free software; you can redistribute it and/or
6654+ * modify it under the terms of the GNU General Public License
6655+ * as published by the Free Software Foundation
6656+ *
6657+ */
6658+
6659+extern void extra( void );
6660+
6661+void
6662+extra( void )
6663+{
6664+ DEFINE(SIZE_OF_KERNEL_VARS, sizeof( kernel_vars_t ));
6665+
6666+ ST_DEF( ST_MAGIC, magic );
6667+ ST_DEF( ST_KVARS_PH, kvars_ph );
6668+
6669+ K_DEF( K_EMUACCEL_PAGE, emuaccel_page );
6670+ K_DEF( K_EMUACCEL_PAGE_PHYS, emuaccel_page_phys );
6671+ K_DEF( K_EMUACCEL_MPHYS, emuaccel_mphys );
6672+ K_DEF( K_EMUACCEL_SIZE, emuaccel_size );
6673+
6674+ K_DEF( K_KERNEL_VARS, kvars_virt );
6675+ K_DEF( K_BREAK_FLAGS, break_flags );
6676+#ifdef PERFORMANCE_INFO
6677+ K_DEF( K_ASM_BUMP_CNTRS, asm_bump_cntr );
6678+ K_DEF( K_ASM_TICK_STAMPS, asm_tick_stamp );
6679+#endif
6680+ /* MMU */
6681+ K_DEF( K_ILLEGAL_SR, mmu.illegal_sr );
6682+ K_DEF( K_CUR_SR_BASE, mmu.cur_sr_base );
6683+ K_DEF( K_SR_DATA, mmu.sr_data );
6684+ K_DEF( K_SR_INST, mmu.sr_inst );
6685+
6686+ K_DEF( K_UNMAPPED_SR_BASE, mmu.unmapped_sr[0] );
6687+ K_DEF( K_USER_SR_BASE, mmu.user_sr[0] );
6688+ K_DEF( K_SV_SR_BASE, mmu.sv_sr[0] );
6689+ K_DEF( K_SPLIT_SR_BASE, mmu.split_sr[0] );
6690+ K_DEF( K_VSID_ENT_BASE, mmu.vsid[0] );
6691+
6692+#ifdef __darwin__
6693+ K_DEF( K_OS_SDR1, mmu.os_sdr1 );
6694+ K_DEF( K_MOL_SDR1, mmu.mol_sdr1 );
6695+ DEFINE( SKIPLIST_NEXT, offsetof(skiplist_el_t, level[0].next_phys) );
6696+#endif
6697+#ifdef __linux__
6698+ DEFINE( SKIPLIST_NEXT, offsetof(skiplist_el_t, level[0].next) );
6699+#endif
6700+ DEFINE( SKIPLIST_LEVELSIZE, sizeof(skiplist_level_t) );
6701+ DEFINE( SKIPLIST_KEY, offsetof(skiplist_el_t, key) );
6702+ DEFINE( K_VSID_SL_ROOT_ELEM, offsetof(kernel_vars_t, mmu.vsid_sl.root)
6703+ - offsetof(skiplist_el_t, level));
6704+ K_DEF( K_VSID_SL_SLEVEL, mmu.vsid_sl.slevel );
6705+
6706+ K_DEF( K_IBAT0U_SAVE, _bp.ibat_save[0].word[0] );
6707+ K_DEF( K_IBAT0L_SAVE, _bp.ibat_save[0].word[1] );
6708+ K_DEF( K_IBAT1U_SAVE, _bp.ibat_save[1].word[0] );
6709+ K_DEF( K_IBAT1L_SAVE, _bp.ibat_save[1].word[1] );
6710+ K_DEF( K_IBAT2U_SAVE, _bp.ibat_save[2].word[0] );
6711+ K_DEF( K_IBAT2L_SAVE, _bp.ibat_save[2].word[1] );
6712+ K_DEF( K_IBAT3U_SAVE, _bp.ibat_save[3].word[0] );
6713+ K_DEF( K_IBAT3L_SAVE, _bp.ibat_save[3].word[1] );
6714+
6715+ K_DEF( K_DBAT0U_SAVE, _bp.dbat_save[0].word[0] );
6716+ K_DEF( K_DBAT0L_SAVE, _bp.dbat_save[0].word[1] );
6717+ K_DEF( K_DBAT1U_SAVE, _bp.dbat_save[1].word[0] );
6718+ K_DEF( K_DBAT1L_SAVE, _bp.dbat_save[1].word[1] );
6719+ K_DEF( K_DBAT2U_SAVE, _bp.dbat_save[2].word[0] );
6720+ K_DEF( K_DBAT2L_SAVE, _bp.dbat_save[2].word[1] );
6721+ K_DEF( K_DBAT3U_SAVE, _bp.dbat_save[3].word[0] );
6722+ K_DEF( K_DBAT3L_SAVE, _bp.dbat_save[3].word[1] );
6723+
6724+ K_DEF( K_SPLIT_DBAT0U, mmu.split_dbat0.word[0] );
6725+ K_DEF( K_SPLIT_DBAT0L, mmu.split_dbat0.word[1] );
6726+ K_DEF( K_TRANSL_DBAT0U, mmu.transl_dbat0.word[0] );
6727+ K_DEF( K_TRANSL_DBAT0L, mmu.transl_dbat0.word[1] );
6728+
6729+ K_DEF( K_TLBHASH_SR, mmu.pthash_sr );
6730+ K_DEF( K_TLBHASH_BASE_EA, mmu.pthash_ea_base );
6731+ K_DEF( K_HASH_MASK, mmu.hash_mask );
6732+ K_DEF( K_PTHASH_INUSE_PH, mmu.pthash_inuse_bits_ph );
6733+
6734+ /* fields private to the assembly files */
6735+ K_DEF( K_MSR, _bp._msr );
6736+
6737+ K_DEF( K_DEC_STAMP, _bp.dec_stamp );
6738+ K_DEF( K_INT_STAMP, _bp.int_stamp);
6739+
6740+ K_DEF( K_TMP_SCRATCH0, _bp.tmp_scratch[0] );
6741+ K_DEF( K_TMP_SCRATCH1, _bp.tmp_scratch[1] );
6742+ K_DEF( K_TMP_SCRATCH2, _bp.tmp_scratch[2] );
6743+ K_DEF( K_TMP_SCRATCH3, _bp.tmp_scratch[3] );
6744+
6745+ K_DEF( K_SPLIT_NIP_SEGMENT, _bp.split_nip_segment );
6746+
6747+ K_DEF( K_SPR_HOOKS, _bp.spr_hooks );
6748+
6749+ /* private to emulation.S */
6750+ K_DEF( K_MSR_SR_TABLE, _bp.msr_sr_table[0] );
6751+
6752+ /* io_page_t type */
6753+ IO_DEF( IOP_MAGIC, magic );
6754+ IO_DEF( IOP_MAGIC2, magic2 );
6755+ IO_DEF( IOP_MPHYS, mphys );
6756+ IO_DEF( IOP_ME_PHYS, me_phys );
6757+ IO_DEF( IOP_NEXT, next );
6758+ IO_DEF( IOP_USR_DATA, usr_data );
6759+
6760+ /****** New Low-level assembly implementation ***********/
6761+
6762+ K_DEF( K_EMULATOR_STACK, _bp.emulator_stack );
6763+ K_DEF( K_EMULATOR_TOC, _bp.emulator_toc );
6764+ K_DEF( K_EMULATOR_NIP, _bp.emulator_nip );
6765+ K_DEF( K_EMULATOR_MSR, _bp.emulator_msr );
6766+ K_DEF( K_EMULATOR_SPRG2, _bp.emulator_sprg2 );
6767+ K_DEF( K_EMULATOR_SPRG3, _bp.emulator_sprg3 );
6768+ K_DEF( K_EMULATOR_KCALL_NIP, _bp.emulator_kcall_nip );
6769+
6770+ K_DEF( K_EMULATOR_SR, mmu.emulator_sr );
6771+
6772+#ifdef __darwin__
6773+ K_DEF( K_KCALL_ROUTINE, kcall_routine );
6774+ K_DEF( K_KCALL_ARG0, kcall_args[0] );
6775+ K_DEF( K_KCALL_ARG1, kcall_args[1] );
6776+ K_DEF( K_KCALL_ARG2, kcall_args[2] );
6777+#endif
6778+}
6779--- /dev/null
6780+++ b/drivers/macintosh/mol/include/asmdbg.h
6781@@ -0,0 +1,184 @@
6782+/*
6783+ * Creation Date: <2004/01/29 20:12:41 samuel>
6784+ * Time-stamp: <2004/03/06 13:17:36 samuel>
6785+ *
6786+ * <asmdbg.h>
6787+ *
6788+ * debug support
6789+ *
6790+ * Copyright (C) 2004 Samuel Rydh (samuel@ibrium.se)
6791+ *
6792+ * This program is free software; you can redistribute it and/or
6793+ * modify it under the terms of the GNU General Public License
6794+ * version 2
6795+ *
6796+ */
6797+
6798+#ifndef _H_ASMDBG
6799+#define _H_ASMDBG
6800+
6801+
6802+/************************************************************************/
6803+/* Performance Statistics */
6804+/************************************************************************/
6805+
6806+#ifdef PERFORMANCE_INFO
6807+ define([_bump_ind_], 0)
6808+
6809+#define __BUMP( str ) \
6810+ .text 92 ;\
6811+debug_str_[]_bump_ind_: ;\
6812+ .if (_bump_ind_ >= NUM_ASM_BUMP_CNTRS) ;\
6813+ .print "** too many BUMP counters **" ; .fail 1 ;\
6814+ .endif ;\
6815+ .ascii str "\0" ;\
6816+ balign_4 ;\
6817+ .text 90 ;\
6818+ .long (debug_str_[]_bump_ind_-__start_bumptable) ;\
6819+ .text ;\
6820+ stw r3,xDEBUG_SCR1(r1) ;\
6821+ lwz r3,(K_ASM_BUMP_CNTRS+4*_bump_ind_)(r1) ;\
6822+ addi r3,r3,1 ;\
6823+ stw r3,(K_ASM_BUMP_CNTRS+4*_bump_ind_)(r1) ;\
6824+ lwz r3,xDEBUG_SCR1(r1) ;\
6825+ define([_bump_ind_],eval(_bump_ind_+1))
6826+
6827+
6828+ define([_tick_ind_], 0)
6829+
6830+#define __ZERO_TICK_CNT(cntr) \
6831+ ifdef([##cntr##_ind_],[],[ \
6832+ define([##cntr##_ind_], _tick_ind_) \
6833+ define([_tick_ind_], eval(_tick_ind_+1)) \
6834+ ]) \
6835+ .if (_tick_ind_ > NUM_ASM_TICK_CNTRS) ;\
6836+ .print "** too many TICK counters **" ; .fail 1 ;\
6837+ .endif ;\
6838+ stw r3,xDEBUG_SCR1(r1) ;\
6839+ mftb r3 ;\
6840+ stw r3,(K_ASM_TICK_STAMPS + 4*cntr##_ind_)(r1) ;\
6841+ lwz r3,xDEBUG_SCR1(r1)
6842+
6843+#define __GET_TICK_CNT(cntr, name) \
6844+ .text 92 ;\
6845+debug_str_[]_bump_ind_: ;\
6846+ .if (_bump_ind_ >= NUM_ASM_BUMP_CNTRS) ;\
6847+ .print "** too many BUMP counters **" ; .fail 1 ;\
6848+ .endif ;\
6849+ .ascii name "_ticks\0" ;\
6850+ balign_4 ;\
6851+ .text 90 ;\
6852+ .long (debug_str_[]_bump_ind_-__start_bumptable) ;\
6853+ .text ;\
6854+ ifdef([##cntr##_ind_],[],[ \
6855+ define([##cntr##_ind_], _tick_ind_) \
6856+ define([_tick_ind_], eval(_tick_ind_+1)) \
6857+ ]) \
6858+ .if (_tick_ind_ > NUM_ASM_TICK_CNTRS) ;\
6859+ .print "** too many TICK counters **" ; .fail 1 ;\
6860+ .endif ;\
6861+ stw r3,xDEBUG_SCR1(r1) ;\
6862+ mftb r3 ;\
6863+ stw r4,xDEBUG_SCR2(r1) ;\
6864+ lwz r4,(K_ASM_TICK_STAMPS + 4*cntr##_ind_)(r1) ;\
6865+ sub r3,r3,r4 ;\
6866+ lwz r4,(K_ASM_BUMP_CNTRS+4*_bump_ind_)(r1) ;\
6867+ add r4,r4,r3 ;\
6868+ stw r4,(K_ASM_BUMP_CNTRS+4*_bump_ind_)(r1) ;\
6869+ lwz r3,xDEBUG_SCR1(r1) ;\
6870+ mftb r4 ;\
6871+ stw r4,(K_ASM_TICK_STAMPS + 4*cntr##_ind_)(r1) ;\
6872+ lwz r4,xDEBUG_SCR2(r1) ;\
6873+ define([_bump_ind_],eval(_bump_ind_+1))
6874+
6875+#endif /* PERFORMANCE_INFO */
6876+
6877+#ifndef PERFORMANCE_INFO_LIGHT
6878+#define BUMP(s) __BUMP(s)
6879+#define ZERO_TICK_CNT(c) __ZERO_TICK_CNT(c)
6880+#define GET_TICK_CNT(c, name) __GET_TICK_CNT(c,name)
6881+#else
6882+#define BUMP(s)
6883+#define ZERO_TICK_CNT(c)
6884+#define GET_TICK_CNT(c, name)
6885+#endif
6886+
6887+#ifndef __BUMP
6888+#define __BUMP(str)
6889+#define __ZERO_TICK_CNT(cntr)
6890+#define __GET_TICK_CNT(cntr, name)
6891+#endif
6892+
6893+#ifdef PERF_MONITOR
6894+MACRO(PERF_MONITOR_GET, [
6895+ stw r5,xDEBUG_SCR1(r1)
6896+ mfspr r5,S_PMC2
6897+ stw r4,xDEBUG_SCR2(r1)
6898+ mfmsr r4
6899+ ori r4,r4,MSR_PE
6900+ mtmsr r4
6901+ stw r5,xDEBUG0(r1)
6902+ li r5,0
6903+ mtspr S_PMC2,r5
6904+ lwz r4,xDEBUG_SCR2(r1)
6905+ lwz r5,xDEBUG_SCR1(r1)
6906+])
6907+MACRO(PERF_MONITOR_SETUP, [scr], [
6908+ LOADI _scr,BIT(2) | BIT(3) | BIT(31) // count in SV-mode if PM is zero.
6909+ mtspr S_MMCR0,_scr
6910+ li _scr,0
6911+ mtspr S_MMCR1,_scr
6912+ li _scr,0
6913+ mtspr S_PMC2,_scr
6914+])
6915+#else /* PERF_MONITOR */
6916+#define PERF_MONITOR_GET
6917+MACRO(PERF_MONITOR_SETUP, [scr], [])
6918+#endif
6919+
6920+
6921+/************************************************************************/
6922+/* debug */
6923+/************************************************************************/
6924+
6925+MACRO(STOP_EMULATION, [val], [
6926+ stw r3,xDEBUG_SCR1(r1)
6927+ li r3,_val
6928+ stw r3,xKERNEL_DBG_STOP(r1)
6929+ li r3,1
6930+ stw r3,xINTERRUPT(r1)
6931+ lwz r3,xDEBUG_SCR1(r1)
6932+])
6933+
6934+MACRO(DEBUG_TRACE, [num, dummy], [
6935+ stw r3,xDEBUG_SCR1(r1)
6936+ lwz r3,xDEBUG_TRACE(r1)
6937+ addi r3,r3,1
6938+ stw r3,xDEBUG_TRACE(r1)
6939+ stw r3,(xDEBUG0+4*_num)(r1)
6940+ lwz r3,xDEBUG_SCR1(r1)
6941+])
6942+
6943+MACRO(TRACE_VAL, [val, dummy], [
6944+#if DBG_TRACE
6945+ stw r30,xDEBUG_SCR1(r1)
6946+ stw r29,xDEBUG_SCR2(r1)
6947+ lwz r30,xDEBUG_TRACE(r1)
6948+ rlwinm r30,r30,0,24,31 // 256 entries
6949+ rlwinm r30,r30,2,22,29
6950+ addi r30,r30,xDBG_TRACE_SPACE
6951+ lis r29,HA(_val)
6952+ addi r29,r29,LO(_val)
6953+ stwx r29,r30,r1
6954+ lwz r30,xDEBUG_TRACE(r1)
6955+ addi r30,r30,1
6956+ rlwinm r30,r30,0,24,31 // 256 entries
6957+ stw r30,xDEBUG_TRACE(r1)
6958+ lwz r29,xDEBUG_SCR2(r1)
6959+ lwz r30,xDEBUG_SCR1(r1)
6960+#endif
6961+])
6962+#define TRACE( a,b ) TRACE_VAL a,b
6963+
6964+
6965+#endif /* _H_ASMDBG */
6966--- /dev/null
6967+++ b/drivers/macintosh/mol/include/asmdefs.h
6968@@ -0,0 +1,397 @@
6969+/* -*- asm -*-
6970+ *
6971+ * Creation Date: <2001/02/03 19:38:07 samuel>
6972+ * Time-stamp: <2004/02/22 15:36:20 samuel>
6973+ *
6974+ * <asmdefs.h>
6975+ *
6976+ * Common assembly definitions
6977+ *
6978+ * Copyright (C) 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
6979+ *
6980+ * This program is free software; you can redistribute it and/or
6981+ * modify it under the terms of the GNU General Public License
6982+ * as published by the Free Software Foundation
6983+ *
6984+ */
6985+
6986+#ifndef _H_ASMDEFS
6987+#define _H_ASMDEFS
6988+
6989+#include "asm.m4"
6990+
6991+#ifndef __ASSEMBLY__
6992+#error This file is only to be included from assembler code!
6993+#endif
6994+
6995+
6996+/************************************************************************/
6997+/* High/low halfword compatibility macros */
6998+/************************************************************************/
6999+
7000+#ifdef __linux__
7001+#define ha16( v ) (v)##@ha
7002+#define hi16( v ) (v)##@h
7003+#define lo16( v ) (v)##@l
7004+#endif
7005+#define HA(v) ha16(v)
7006+#define HI(v) hi16(v)
7007+#define LO(v) lo16(v)
7008+
7009+/************************************************************************/
7010+/* Stack Frame */
7011+/************************************************************************/
7012+
7013+#ifdef __linux__
7014+#define STACK_LR_OFFSET 4
7015+#endif
7016+
7017+#ifdef __darwin__
7018+#define STACK_LR_OFFSET 8 /* 4 is the CR offset */
7019+#endif
7020+
7021+/************************************************************************/
7022+/* Register name prefix */
7023+/************************************************************************/
7024+
7025+#ifdef __linux__
7026+define([rPREFIX], [])
7027+define([fPREFIX], [])
7028+define([srPREFIX], [])
7029+#else
7030+define([rPREFIX], [r])
7031+define([fPREFIX], [f])
7032+define([srPREFIX], [sr])
7033+/* frN -> fN */
7034+mFORLOOP([i],0,31,[define(fr[]i,f[]i)])
7035+#endif
7036+
7037+/************************************************************************/
7038+/* Macros and definitions */
7039+/************************************************************************/
7040+
7041+#ifdef __darwin__
7042+#define balign_4 .align 2,0
7043+#define balign_8 .align 3,0
7044+#define balign_16 .align 4,0
7045+#define balign_32 .align 5,0
7046+#endif
7047+
7048+#ifdef __linux__
7049+#define balign_4 .balign 4,0
7050+#define balign_8 .balign 8,0
7051+#define balign_16 .balign 16,0
7052+#define balign_32 .balign 32,0
7053+#endif
7054+
7055+MACRO(LOADVAR, [dreg, variable], [
7056+ lis _dreg,HA(_variable)
7057+ lwz _dreg,LO(_variable)(_dreg)
7058+])
7059+
7060+MACRO(LOADI, [dreg, addr], [
7061+ lis _dreg,HA(_addr)
7062+ addi _dreg,_dreg,LO(_addr)
7063+])
7064+
7065+MACRO(LOAD_GPR_RANGE, [start, endx, offs, base], [
7066+ mFORLOOP([i],0,31,[ .if (i >= _start) & (i <= _endx)
7067+ lwz rPREFIX[]i,_offs+i[]*4(_base)
7068+ .endif
7069+])])
7070+
7071+MACRO(STORE_GPR_RANGE, [start, endx, offs, base], [
7072+ mFORLOOP([i],0,31,[ .if (i >= _start) & (i <= _endx)
7073+ stw rPREFIX[]i,_offs+i[]*4(_base)
7074+ .endif
7075+])])
7076+
7077+MACRO(LOAD_FPR_RANGE, [start, endx, offs, base], [
7078+ mFORLOOP([i],0,31,[ .if (i >= _start) & (i <= _endx)
7079+ lfd fPREFIX[]i,_offs+i[]*8(_base)
7080+ .endif
7081+])])
7082+
7083+MACRO(STORE_FPR_RANGE, [start, endx, offs, base], [
7084+ mFORLOOP([i],0,31,[ .if (i >= _start) & (i <= _endx)
7085+ stfd fPREFIX[]i,_offs+i[]*8(_base)
7086+ .endif
7087+])])
7088+
7089+/************************************************************************/
7090+/* FPU load/save macros */
7091+/************************************************************************/
7092+
7093+ // The FPU macros are used both in the kernel and in
7094+ // mainloop_asm.h.
7095+
7096+MACRO(xFPR_LOAD_RANGE, [from, to, mbase], [
7097+ LOAD_FPR_RANGE _from,_to,xFPR_BASE,_mbase
7098+])
7099+MACRO(xFPR_SAVE_RANGE, [from, to, mbase], [
7100+ STORE_FPR_RANGE _from,_to,xFPR_BASE,_mbase
7101+])
7102+ // The low half of the fpu is fr0-fr12. I.e. the FPU registers
7103+ // that might be overwritten when a function call is taken
7104+ // (fr13 and fpscr are treated specially).
7105+
7106+MACRO(xLOAD_LOW_FPU, [mbase], [
7107+ xFPR_LOAD_RANGE 0,12,_mbase
7108+])
7109+
7110+MACRO(xLOAD_TOPHALF_FPU, [mbase], [
7111+ xFPR_LOAD_RANGE 14,31,_mbase
7112+])
7113+MACRO(xLOAD_FULL_FPU, [mbase], [
7114+ xLOAD_LOW_FPU _mbase
7115+ xLOAD_TOPHALF_FPU _mbase
7116+])
7117+
7118+MACRO(xSAVE_LOW_FPU, [mbase], [
7119+ xFPR_SAVE_RANGE 0,12,_mbase
7120+])
7121+MACRO(xSAVE_TOPHALF_FPU, [mbase], [
7122+ xFPR_SAVE_RANGE 14,31,_mbase
7123+])
7124+MACRO(xSAVE_FULL_FPU, [mbase], [
7125+ xSAVE_LOW_FPU _mbase
7126+ xSAVE_TOPHALF_FPU _mbase
7127+])
7128+
7129+
7130+/************************************************************************/
7131+/* GPR load/save macros */
7132+/************************************************************************/
7133+
7134+MACRO(xGPR_SAVE_RANGE, [from, to, mbase], [
7135+ STORE_GPR_RANGE _from, _to, xGPR0, _mbase
7136+])
7137+
7138+MACRO(xGPR_LOAD_RANGE, [from, to, mbase], [
7139+ LOAD_GPR_RANGE _from, _to, xGPR0, _mbase
7140+])
7141+
7142+
7143+/************************************************************************/
7144+/* AltiVec */
7145+/************************************************************************/
7146+
7147+#ifdef __linux__
7148+
7149+define(vPREFIX,[])
7150+
7151+#ifndef HAVE_ALTIVEC
7152+#define VEC_OPCODE( op1,op2,A,B,C ) \
7153+ .long (((op1) << (32-6)) | (op2) | ((A) << (32-11)) | ((B) << (32-16)) | ((C) << (32-21))) ;
7154+
7155+#define __stvx( vS,rA,rB ) VEC_OPCODE( 31,0x1ce,vS,rA,rB )
7156+#define __lvx( vD,rA,rB ) VEC_OPCODE( 31,0xce, vD,rA,rB )
7157+#define __mfvscr( vD ) VEC_OPCODE( 4,1540,vD,0,0 )
7158+#define __mtvscr( vB ) VEC_OPCODE( 4,1604,0,0,vB )
7159+#define __stvewx( vS,rA,rB ) VEC_OPCODE( 31,(199<<1), vS,rA,rB )
7160+
7161+mFORLOOP([i],0,31,[define(v[]i,[]i)])
7162+MACRO(stvx, [vS,rA,rB], [ __stvx( _vS,_rA,_rB ) ; ])
7163+MACRO(lvx, [vD,rA,rB], [ __lvx( _vD,_rA,_rB ) ; ])
7164+MACRO(mfvscr, [vD], [ __mfvscr( _vD ) ; ])
7165+MACRO(mtvscr, [vB], [ __mtvscr( _vB ) ; ])
7166+MACRO(stvewx, [vS,rA,rB], [ __stvewx( _vS,_rA,_rB ) ; ])
7167+#endif
7168+#else /* __linux__ */
7169+
7170+define(vPREFIX,[v])
7171+
7172+#endif /* __linux__ */
7173+
7174+
7175+// NOTE: Writing to VSCR won't cause exceptions (this
7176+// is different compared to FPSCR).
7177+
7178+MACRO(xVEC_SAVE, [mbase, scr], [
7179+ addi _scr,_mbase,xVEC_BASE
7180+ mFORLOOP([i],0,31,[
7181+ stvx vPREFIX[]i,0,_scr
7182+ addi _scr,_scr,16
7183+ ])
7184+ addi _scr,_mbase,xVSCR-12
7185+ mfvscr v0
7186+ stvx v0,0,_scr
7187+ addi _scr,_mbase,xVEC0
7188+ lvx v0,0,_scr
7189+ mfspr _scr,S_VRSAVE
7190+ stw _scr,xVRSAVE(_mbase)
7191+])
7192+
7193+MACRO(xVEC_LOAD, [mbase, scr], [
7194+ addi _scr,_mbase,xVSCR-12
7195+ lvx v0,0,_scr
7196+ mtvscr v0
7197+ addi _scr,_mbase,xVEC_BASE
7198+ mFORLOOP([i],0,31,[
7199+ lvx vPREFIX[]i,0,_scr
7200+ addi _scr,_scr,16
7201+ ])
7202+ lwz _scr,xVRSAVE(_mbase)
7203+ mtspr S_VRSAVE,_scr
7204+])
7205+
7206+/************************************************************************/
7207+/* Instructions */
7208+/************************************************************************/
7209+
7210+#ifdef __darwin__
7211+MACRO(mtsprg0, [reg], [mtspr SPRG0,_reg] )
7212+MACRO(mtsprg1, [reg], [mtspr SPRG1,_reg] )
7213+MACRO(mtsprg2, [reg], [mtspr SPRG2,_reg] )
7214+MACRO(mtsprg3, [reg], [mtspr SPRG3,_reg] )
7215+MACRO(mfsprg0, [reg], [mfspr _reg,SPRG0] )
7216+MACRO(mfsprg1, [reg], [mfspr _reg,SPRG1] )
7217+MACRO(mfsprg2, [reg], [mfspr _reg,SPRG2] )
7218+MACRO(mfsprg3, [reg], [mfspr _reg,SPRG3] )
7219+#endif
7220+
7221+/************************************************************************/
7222+/* Register names */
7223+/************************************************************************/
7224+
7225+#define cr0_lt 0
7226+#define cr0_gt 1
7227+#define cr0_eq 2
7228+#define cr0_so 3
7229+
7230+#define cr1_lt 4
7231+#define cr1_gt 5
7232+#define cr1_eq 6
7233+#define cr1_so 7
7234+
7235+#define cr2_lt 8
7236+#define cr2_gt 9
7237+#define cr2_eq 10
7238+#define cr2_so 11
7239+
7240+#define cr3_lt 12
7241+#define cr3_gt 13
7242+#define cr3_eq 14
7243+#define cr3_so 15
7244+
7245+#ifdef __darwin__
7246+/* IMPORTANT: we may *not* define crN on darwin; If we do, the
7247+ * assembler will generate bogus code. For instance,
7248+ * bne cr1,1f is not equivalent to bne 1,1f but to
7249+ * bne 4,1f...
7250+ */
7251+#define lt 0 /* Less than */
7252+#define gt 1 /* Greater than */
7253+#define eq 2 /* Equal */
7254+#define so 3 /* Summary Overflow */
7255+#define un 3 /* Unordered (after floating point) */
7256+#endif
7257+
7258+/* FPU register names (to be used as macro arguments) */
7259+#define FR0 0
7260+#define FR1 1
7261+#define FR2 2
7262+#define FR3 3
7263+#define FR4 4
7264+#define FR5 5
7265+#define FR6 6
7266+#define FR7 7
7267+#define FR8 8
7268+#define FR9 9
7269+#define FR10 10
7270+#define FR11 11
7271+#define FR12 12
7272+#define FR13 13
7273+#define FR14 14
7274+#define FR15 15
7275+#define FR16 16
7276+#define FR17 17
7277+#define FR18 18
7278+#define FR19 19
7279+#define FR20 20
7280+#define FR21 21
7281+#define FR22 22
7282+#define FR23 23
7283+#define FR24 24
7284+#define FR25 25
7285+#define FR26 26
7286+#define FR27 27
7287+#define FR28 28
7288+#define FR29 29
7289+#define FR30 30
7290+#define FR31 31
7291+
7292+/* GPR register names (to be used as macro arguments) */
7293+#define R0 0
7294+#define R1 1
7295+#define R2 2
7296+#define R3 3
7297+#define R4 4
7298+#define R5 5
7299+#define R6 6
7300+#define R7 7
7301+#define R8 8
7302+#define R9 9
7303+#define R10 10
7304+#define R11 11
7305+#define R12 12
7306+#define R13 13
7307+#define R14 14
7308+#define R15 15
7309+#define R16 16
7310+#define R17 17
7311+#define R18 18
7312+#define R19 19
7313+#define R20 20
7314+#define R21 21
7315+#define R22 22
7316+#define R23 23
7317+#define R24 24
7318+#define R25 25
7319+#define R26 26
7320+#define R27 27
7321+#define R28 28
7322+#define R29 29
7323+#define R30 30
7324+#define R31 31
7325+
7326+#ifndef __darwin__
7327+
7328+/* GPR register names, rN -> N, frN -> N, vN -> N */
7329+mFORLOOP([i],0,31,[define(r[]i,[]i)])
7330+mFORLOOP([i],0,31,[define(fr[]i,[]i)])
7331+mFORLOOP([i],0,31,[define(v[]i,[]i)])
7332+
7333+#endif /* __darwin__ */
7334+
7335+
7336+/************************************************************************/
7337+/* useful macros */
7338+/************************************************************************/
7339+
7340+MACRO(ori_, [reg1, reg2, value], [
7341+ .if (_value & 0xffff)
7342+ ori _reg1, _reg2, (_value) & 0xffff
7343+ .endif
7344+ .if (_value & ~0xffff)
7345+ oris _reg1, _reg2, (_value) >> 16
7346+ .endif
7347+])
7348+
7349+/************************************************************************/
7350+/* MISC */
7351+/************************************************************************/
7352+
7353+#ifdef __linux__
7354+#define GLOBL( name ) .globl name ; name
7355+#define EXTERN( name ) name
7356+#else
7357+/* an underscore is needed on Darwin */
7358+#define GLOBL( name ) .globl _##name ; name: ; _##name
7359+#define EXTERN( name ) _##name
7360+#endif
7361+
7362+#define BIT(n) (1<<(31-(n)))
7363+
7364+#endif /* _H_ASMDEFS */
7365+
7366--- /dev/null
7367+++ b/drivers/macintosh/mol/include/asmfuncs.h
7368@@ -0,0 +1,80 @@
7369+/*
7370+ * Creation Date: <1999/09/26 01:02:58 samuel>
7371+ * Time-stamp: <2003/07/27 19:20:24 samuel>
7372+ *
7373+ * <asmfuncs.h>
7374+ *
7375+ * Exports from <base.S>
7376+ *
7377+ * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
7378+ *
7379+ * This program is free software; you can redistribute it and/or
7380+ * modify it under the terms of the GNU General Public License
7381+ * as published by the Free Software Foundation
7382+ *
7383+ */
7384+
7385+#ifndef _H_ASMFUNCS
7386+#define _H_ASMFUNCS
7387+
7388+#include "kernel_vars.h"
7389+#include "tlbie.h"
7390+
7391+
7392+/* globl variable defined in actions.c */
7393+extern int reloc_virt_offs;
7394+#define reloc_ptr( v ) ((ulong)(v) + (ulong)reloc_virt_offs)
7395+
7396+
7397+/* The code in base.o (all low-level assembly) are copied to a physically
7398+ * continuous memory area. The following inline functions maps function calls
7399+ * to the relocated area.
7400+ */
7401+
7402+static inline void msr_altered( kernel_vars_t *kv ) {
7403+ typedef void ftype( kernel_vars_t * );
7404+ extern ftype r__msr_altered;
7405+ (*(ftype*)reloc_ptr( r__msr_altered ))( kv );
7406+}
7407+
7408+static inline void invalidate_splitmode_sr( kernel_vars_t *kv ) {
7409+ typedef void ftype( kernel_vars_t *);
7410+ extern ftype r__invalidate_splitmode_sr;
7411+ (*(ftype*)reloc_ptr( r__invalidate_splitmode_sr ))( kv );
7412+}
7413+
7414+static inline void initialize_spr_table( kernel_vars_t *kv ) {
7415+ typedef void ftype( kernel_vars_t *);
7416+ extern ftype r__initialize_spr_table;
7417+ (*(ftype*)reloc_ptr( r__initialize_spr_table ))( kv );
7418+}
7419+
7420+
7421+/************************************************************************/
7422+/* misc inlines */
7423+/************************************************************************/
7424+
7425+#define _sync() ({ asm volatile("sync ;\n isync" : : ); })
7426+
7427+static inline ulong _get_sdr1( void ) {
7428+ ulong sdr1;
7429+ asm volatile("mfsdr1 %0" : "=r" (sdr1) : );
7430+ return sdr1;
7431+}
7432+static inline void _set_sdr1( ulong sdr1 ) {
7433+ asm volatile("mtsdr1 %0" : : "r" (sdr1) );
7434+}
7435+
7436+static inline int cpu_is_601( void ) {
7437+ ulong pvr;
7438+ asm volatile("mfpvr %0" : "=r" (pvr) : );
7439+ return (pvr>>16)==1;
7440+}
7441+
7442+static inline int cpu_is_603( void ) {
7443+ ulong pvr;
7444+ asm volatile("mfpvr %0" : "=r" (pvr) : );
7445+ pvr = pvr >> 16;
7446+ return pvr==3 || pvr==6 || pvr==7; /* 603, 603e, 603ev */
7447+}
7448+#endif /* _H_ASMFUNCS */
7449--- /dev/null
7450+++ b/drivers/macintosh/mol/include/atomic.h
7451@@ -0,0 +1,26 @@
7452+/*
7453+ * Creation Date: <2004/01/25 17:00:12 samuel>
7454+ * Time-stamp: <2004/01/29 22:32:30 samuel>
7455+ *
7456+ * <atomic.h>
7457+ *
7458+ *
7459+ *
7460+ * Copyright (C) 2004 Samuel Rydh (samuel@ibrium.se)
7461+ *
7462+ * This program is free software; you can redistribute it and/or
7463+ * modify it under the terms of the GNU General Public License
7464+ * version 2
7465+ *
7466+ */
7467+
7468+#ifndef _H_ATOMIC
7469+#define _H_ATOMIC
7470+
7471+#define mol_atomic_t atomic_t
7472+#define atomic_inc_return_mol(x) atomic_inc_return(x)
7473+#define atomic_inc_mol(x) atomic_inc(x)
7474+#define atomic_dec_mol(x) atomic_dec(x)
7475+#define atomic_read_mol(x) atomic_read(x)
7476+
7477+#endif /* _H_ATOMIC */
7478--- /dev/null
7479+++ b/drivers/macintosh/mol/include/config.h
7480@@ -0,0 +1,90 @@
7481+/* config.h. Generated from config.h.in by configure. */
7482+/* config.h.in. Generated from configure.in by autoheader. */
7483+
7484+/* Define if _syscall macro is borken */
7485+#define BROKEN_SYSCALL 1
7486+
7487+/* Defined if ALSA support is available */
7488+#define HAVE_ALSA 1
7489+
7490+/* Define if clearenv is available */
7491+#define HAVE_CLEARENV 1
7492+
7493+/* Define to 1 if you have the <getopt.h> header file. */
7494+#define HAVE_GETOPT_H 1
7495+
7496+/* Define to 1 if you have the <inttypes.h> header file. */
7497+#define HAVE_INTTYPES_H 1
7498+
7499+/* Define to 1 if you have the <memory.h> header file. */
7500+#define HAVE_MEMORY_H 1
7501+
7502+/* Define to 1 if you have the <obstack.h> header file. */
7503+#define HAVE_OBSTACK_H 1
7504+
7505+/* Define if libpng support is to be included */
7506+#define HAVE_PNG 1
7507+
7508+/* Define to 1 if you have the <poll.h> header file. */
7509+#define HAVE_POLL_H 1
7510+
7511+/* Define to 1 if you have the <stdint.h> header file. */
7512+#define HAVE_STDINT_H 1
7513+
7514+/* Define to 1 if you have the <stdlib.h> header file. */
7515+#define HAVE_STDLIB_H 1
7516+
7517+/* Define to 1 if you have the <strings.h> header file. */
7518+#define HAVE_STRINGS_H 1
7519+
7520+/* Define to 1 if you have the <string.h> header file. */
7521+#define HAVE_STRING_H 1
7522+
7523+/* Define to 1 if you have the <sys/stat.h> header file. */
7524+#define HAVE_SYS_STAT_H 1
7525+
7526+/* Define to 1 if you have the <sys/types.h> header file. */
7527+#define HAVE_SYS_TYPES_H 1
7528+
7529+/* Define to 1 if you have the <unistd.h> header file. */
7530+#define HAVE_UNISTD_H 1
7531+
7532+/* Define if X11 is available */
7533+#define HAVE_X11 1
7534+
7535+/* Define if XDGA support is to be included */
7536+#define HAVE_XDGA 1
7537+
7538+/* Defined for the MOL user binary */
7539+#define MOL_PROPER 1
7540+
7541+/* Define if off_t is known to be 64-bit */
7542+#define OFF_T_IS_64 1
7543+
7544+/* Define to the address where bug reports for this package should be sent. */
7545+#define PACKAGE_BUGREPORT ""
7546+
7547+/* Define to the full name of this package. */
7548+#define PACKAGE_NAME ""
7549+
7550+/* Define to the full name and version of this package. */
7551+#define PACKAGE_STRING ""
7552+
7553+/* Define to the one symbol short name of this package. */
7554+#define PACKAGE_TARNAME ""
7555+
7556+/* Define to the version of this package. */
7557+#define PACKAGE_VERSION ""
7558+
7559+/* Define to 1 if you have the ANSI C header files. */
7560+#define STDC_HEADERS 1
7561+
7562+/* Define if uc_context has gregs field */
7563+/* #undef UCCONTEXT_HAS_GREGS */
7564+
7565+/* Define to 1 if the X Window System is missing or not being used. */
7566+/* #undef X_DISPLAY_MISSING */
7567+
7568+/* Define to 1 if `lex' declares `yytext' as a `char *' by default, not a
7569+ `char[]'. */
7570+#define YYTEXT_POINTER 1
7571--- /dev/null
7572+++ b/drivers/macintosh/mol/include/constants.h
7573@@ -0,0 +1,36 @@
7574+/*
7575+ * Creation Date: <2001/02/11 18:19:42 samuel>
7576+ * Time-stamp: <2003/07/27 18:58:35 samuel>
7577+ *
7578+ * <constants.h>
7579+ *
7580+ * Constants used both in the kernel module and in the emulator
7581+ *
7582+ * Copyright (C) 2001, 2002, 2003 Samuel Rydh (samuel@ibrium.se)
7583+ *
7584+ * This program is free software; you can redistribute it and/or
7585+ * modify it under the terms of the GNU General Public License
7586+ * as published by the Free Software Foundation
7587+ *
7588+ */
7589+
7590+#ifndef _H_CONSTANTS
7591+#define _H_CONSTANTS
7592+
7593+/* flags for _breakpoint_flags() */
7594+#define BREAK_RFI 1 /* break at next rfi */
7595+#define BREAK_SINGLE_STEP 2 /* singlestep */
7596+#define BREAK_EA_PAGE 4 /* break when mdbg_break_ea is mapped */
7597+#define BREAK_USER 8 /* break when MSR_PR is set */
7598+#define BREAK_SINGLE_STEP_CONT 16 /* single step (but don't continue running) */
7599+
7600+/* action for _tune_spr() */
7601+#define kTuneSPR_Illegal 1 /* SPR is illegal */
7602+#define kTuneSPR_Privileged 2 /* SPR is privileged */
7603+#define kTuneSPR_Unprivileged 3 /* SPR is unprivileged */
7604+#define kTuneSPR_ReadWrite 4 /* SPR is read-write */
7605+#define kTuneSPR_ReadOnly 5 /* SPR is read-only */
7606+
7607+#endif /* _H_CONSTANTS */
7608+
7609+
7610--- /dev/null
7611+++ b/drivers/macintosh/mol/include/context.h
7612@@ -0,0 +1,62 @@
7613+/*
7614+ * Creation Date: <2004/01/25 17:48:51 samuel>
7615+ * Time-stamp: <2004/01/25 22:12:13 samuel>
7616+ *
7617+ * <context.h>
7618+ *
7619+ *
7620+ *
7621+ * Copyright (C) 2004 Samuel Rydh (samuel@ibrium.se)
7622+ *
7623+ * This program is free software; you can redistribute it and/or
7624+ * modify it under the terms of the GNU General Public License
7625+ * version 2
7626+ *
7627+ */
7628+
7629+#ifndef _H_CONTEXT
7630+#define _H_CONTEXT
7631+
7632+#define CTX_MASK 0xfffff /* VSID_MASK >> 4 */
7633+
7634+/*
7635+ * Three types of contexts are used:
7636+ *
7637+ * VSIDs (24 bit, loaded into the CPU register)
7638+ * mol_contexts (number between FIRST_ and LAST_MOL_CONTEXT)
7639+ * arch_contexts (context number used by the kernel)
7640+ *
7641+ * The relation between them is
7642+ *
7643+ * mol_context = (os_context << 4) + segment#
7644+ * VSID_context = MUNGE_CONTEXT(mol_context>>4) + ESID_ADD * (mol_context & 0xf)
7645+ */
7646+
7647+/*
7648+ * The new MM implementation (about 2.4.14 (?)) uses the following algorithm
7649+ *
7650+ * VSID = (((context * 897) << 4) + ((va>>28) * 0x111)) & 0xffffff
7651+ *
7652+ * Only context 0..32767 are used. We can use context 32768..0xfffff.
7653+ * The old MM implementation used
7654+ *
7655+ * VSID = (((context * 897) << 4) + (va>>28)) & 0xffffff
7656+ */
7657+
7658+#define MUNGE_ADD_NEXT 897
7659+#define MUNGE_MUL_INVERSE 2899073 /* Multiplicative inverse of 897 (modulo VSID_MASK+1) */
7660+#define MUNGE_ESID_ADD 0x111
7661+#define MUNGE_CONTEXT(c) (((c) * (MUNGE_ADD_NEXT * 16)) & (CTX_MASK <<4))
7662+
7663+/* mol_contexts == linux_context * 16 + esid */
7664+#define PER_SESSION_CONTEXTS 0x10000 /* more than we will need (10^6) */
7665+#define FIRST_MOL_CONTEXT(sess) ((CTX_MASK - PER_SESSION_CONTEXTS*((sess)+1)) << 4)
7666+#define LAST_MOL_CONTEXT(sess) (((CTX_MASK - PER_SESSION_CONTEXTS*(sess)) << 4) | 0xf)
7667+
7668+
7669+#if FIRST_MOL_CONTEXT(MAX_NUM_SESSIONS-1) < (32768 << 4)
7670+#error "Too many MOL contexts..."
7671+#endif
7672+
7673+
7674+#endif /* _H_CONTEXT */
7675--- /dev/null
7676+++ b/drivers/macintosh/mol/include/dbg.h
7677@@ -0,0 +1,31 @@
7678+/*
7679+ * Creation Date: <2004/04/10 22:14:43 samuel>
7680+ * Time-stamp: <2004/04/10 22:26:24 samuel>
7681+ *
7682+ * <dbg.h>
7683+ *
7684+ *
7685+ *
7686+ * Copyright (C) 2004 Samuel Rydh (samuel@ibrium.se)
7687+ *
7688+ * This program is free software; you can redistribute it and/or
7689+ * modify it under the terms of the GNU General Public License
7690+ * version 2
7691+ */
7692+
7693+#ifndef _H_DBG
7694+#define _H_DBG
7695+
7696+#ifdef CONFIG_MOL_HOSTED
7697+
7698+#ifdef printk
7699+#undef printk
7700+#endif
7701+
7702+#define printk printm
7703+extern int printm( const char *fmt, ... );
7704+extern void debugger( int n );
7705+
7706+#endif /* CONFIG_MOL_HOSTED */
7707+
7708+#endif /* _H_DBG */
7709--- /dev/null
7710+++ b/drivers/macintosh/mol/include/debugger.h
7711@@ -0,0 +1,96 @@
7712+/*
7713+ * Creation Date: <1999/02/22 22:46:22 samuel>
7714+ * Time-stamp: <2003/07/27 14:42:05 samuel>
7715+ *
7716+ * <debugger.h>
7717+ *
7718+ * World interface of the debugger
7719+ *
7720+ * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
7721+ *
7722+ * This program is free software; you can redistribute it and/or
7723+ * modify it under the terms of the GNU General Public License
7724+ * as published by the Free Software Foundation
7725+ *
7726+ */
7727+
7728+#ifndef _H_DEBUGGER
7729+#define _H_DEBUGGER
7730+
7731+#ifdef CONFIG_DEBUGGER
7732+extern void debugger_init( void );
7733+extern void debugger_cleanup( void );
7734+extern int debugger_enabled( void );
7735+extern int debugger_attached( void );
7736+#else
7737+static inline int debugger_enabled( void ) { return 0; }
7738+static inline int debugger_attached( void ) { return 0; }
7739+static inline void debugger_init( void ) {}
7740+static inline void debugger_cleanup( void ) {}
7741+#endif
7742+
7743+/*******************************************/
7744+/* montior.c / nub.c */
7745+/*******************************************/
7746+
7747+extern void refresh_debugger_window( void );
7748+extern void refresh_debugger( void );
7749+extern void redraw_inst_win( void );
7750+extern int debugger_in_68k_mode( void );
7751+extern void debugger_nub_poll( void );
7752+
7753+/* debug actions */
7754+enum{
7755+ kDbgNOP=0, kDbgGo, kDbgGoRFI, kDbgStep, kDbgExit, kDbgStop, kDbgGoUser
7756+};
7757+
7758+
7759+/*******************************************/
7760+/* cmdline.c / nub.c */
7761+/*******************************************/
7762+
7763+/* put functions used exclusively in debugger mode in the dbg section */
7764+#ifdef __linux__
7765+#ifdef CONFIG_DEBUGGER
7766+#define __dbg __attribute__ ((__section__ (".moldbg")))
7767+#define __dcmd __dbg
7768+#else
7769+#define __dbg __attribute__ ((__section__ (".moldbg")))
7770+#define __dcmd inline __attribute__ ((__section__ (".moldbg")))
7771+#endif
7772+#else
7773+#define __dbg
7774+#define __dcmd inline
7775+#endif
7776+
7777+typedef struct {
7778+ const char *name;
7779+ int (*func)( int argc, char **argv );
7780+ const char *help;
7781+} dbg_cmd_t;
7782+
7783+typedef int (*dbg_cmd_fp)( int argc, char **argv );
7784+
7785+#ifdef CONFIG_DEBUGGER
7786+extern void add_cmd( const char *cmdname, const char *help,
7787+ int dummy, dbg_cmd_fp func );
7788+extern void add_dbg_cmds( dbg_cmd_t *table, int tablesize );
7789+#else
7790+#define add_cmd( a,b,c,d ) do {} while(0)
7791+static inline void add_dbg_cmds( dbg_cmd_t *table, int tablesize ) {}
7792+#endif
7793+
7794+/* for debugging */
7795+#define HARD_BREAKPOINT \
7796+ ({ printm("Hardcoded breakpoint in '"__FILE__"'\n"); stop_emulation(); })
7797+
7798+
7799+/*******************************************/
7800+/* mmu_cmds.c */
7801+/*******************************************/
7802+
7803+extern int __dbg get_inst_context( void );
7804+extern int __dbg get_data_context( void );
7805+extern int __dbg ea_to_lvptr( ulong ea, int context, char **lvptr, int data_access );
7806+
7807+#endif /* _H_DEBUGGER */
7808--- /dev/null
7809+++ b/drivers/macintosh/mol/include/emu.h
7810@@ -0,0 +1,29 @@
7811+/*
7812+ * Creation Date: <2003/01/26 00:45:55 samuel>
7813+ * Time-stamp: <2003/01/27 01:26:25 samuel>
7814+ *
7815+ * <emu.h>
7816+ *
7817+ * Emulation of some assembly functions
7818+ *
7819+ * Copyright (C) 1998, 2000, 2001, 2002, 2003 Samuel Rydh (samuel@ibrium.se)
7820+ *
7821+ * This program is free software; you can redistribute it and/or
7822+ * modify it under the terms of the GNU General Public License
7823+ * as published by the Free Software Foundation
7824+ *
7825+ */
7826+
7827+#ifndef _H_EMU
7828+#define _H_EMU
7829+
7830+#include "mmu.h"
7831+
7832+extern int do_mtsdr1( kernel_vars_t *kv, ulong value );
7833+extern int do_mtbat( kernel_vars_t *kv, int sprnum, ulong value, int force );
7834+
7835+extern int alloc_emuaccel_slot( kernel_vars_t *kv, int inst_flags, int param, int inst_addr );
7836+extern int mapin_emuaccel_page( kernel_vars_t *kv, int mphys );
7837+
7838+
7839+#endif /* _H_EMU */
7840--- /dev/null
7841+++ b/drivers/macintosh/mol/include/emuaccel_sh.h
7842@@ -0,0 +1,41 @@
7843+/*
7844+ * Creation Date: <2003/01/25 14:57:36 samuel>
7845+ * Time-stamp: <2003/01/27 23:11:29 samuel>
7846+ *
7847+ * <emuaccel.h>
7848+ *
7849+ * Acceleration of the emulation of certain privileged instructions
7850+ *
7851+ * Copyright (C) 2003 Samuel Rydh (samuel@ibrium.se)
7852+ *
7853+ * This program is free software; you can redistribute it and/or
7854+ * modify it under the terms of the GNU General Public License
7855+ * as published by the Free Software Foundation
7856+ *
7857+ */
7858+
7859+#ifndef _H_EMUACCEL
7860+#define _H_EMUACCEL
7861+
7862+/* OSI_AllocInstAccelSlot( EMULATE_xxx + source_reg, NIP ) */
7863+
7864+#define EMUACCEL_MAPIN_PAGE 0
7865+#define EMUACCEL_MTSRR0 (1 << 5)
7866+#define EMUACCEL_MTSRR1 (2 << 5)
7867+#define EMUACCEL_MTSPRG0 (3 << 5)
7868+#define EMUACCEL_MTSPRG1 (4 << 5)
7869+#define EMUACCEL_MTSPRG2 (5 << 5)
7870+#define EMUACCEL_MTSPRG3 (6 << 5)
7871+#define EMUACCEL_MTMSR (7 << 5)
7872+#define EMUACCEL_RFI (8 << 5)
7873+#define EMUACCEL_UPDATE_DEC (9 << 5) /* update xDEC */
7874+#define EMUACCEL_MTSR ((10 << 5) | EMUACCEL_HAS_PARAM)
7875+#define EMUACCEL_NOP (11 << 5)
7876+#define EMUACCEL_MTHID0 (12 << 5)
7877+
7878+#define EMUACCEL_HAS_PARAM (1 << 10)
7879+#define EMUACCEL_INST_MASK 0xffe0
7880+#define EMUACCEL_DESTREG_MASK 0x1f
7881+
7882+
7883+#endif /* _H_EMUACCEL */
7884--- /dev/null
7885+++ b/drivers/macintosh/mol/include/extralib.h
7886@@ -0,0 +1,70 @@
7887+/*
7888+ * Creation Date: <1997/07/02 19:52:18 samuel>
7889+ * Time-stamp: <2004/04/03 18:29:26 samuel>
7890+ *
7891+ * <extralib.h>
7892+ *
7893+ *
7894+ *
7895+ * Copyright (C) 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
7896+ *
7897+ * This program is free software; you can redistribute it and/or
7898+ * modify it under the terms of the GNU General Public License
7899+ * as published by the Free Software Foundation
7900+ *
7901+ */
7902+
7903+#ifndef _H_EXTRALIB
7904+#define _H_EXTRALIB
7905+
7906+#define CLEAR( x ) memset( &x, 0, sizeof(x))
7907+
7908+/* in extralib.h */
7909+extern int ilog2( int val );
7910+
7911+extern char *num_to_string( ulong num );
7912+extern int is_number_str( char *str );
7913+extern ulong string_to_ulong( char * );
7914+extern ulong hexbin( int num );
7915+
7916+extern char *strncpy0( char *dest, const char *str, size_t n );
7917+extern char *strncat0( char *dest, const char *str, size_t n );
7918+extern char *strncat3( char *dest, const char *s1, const char *s2, size_t n );
7919+extern char *strnpad( char *dest, const char *s1, size_t n );
7920+
7921+struct iovec;
7922+extern int memcpy_tovec( const struct iovec *vec, size_t nvec, const char *src, unsigned int len );
7923+extern int memcpy_fromvec( char *dst, const struct iovec *vec, size_t nvec, unsigned int len );
7924+extern int iovec_getbyte( int offs, const struct iovec *vec, size_t nvec );
7925+extern int iovec_skip( int skip, struct iovec *vec, size_t nvec );
7926+
7927+extern void open_logfile( const char *filename );
7928+extern void close_logfile( void );
7929+
7930+#define __printf_format __attribute__ ((format (printf, 1, 2)))
7931+extern int printm( const char *fmt,...) __printf_format;
7932+extern int aprint( const char *fmt,... ) __printf_format;
7933+extern void perrorm(const char *fmt,... ) __printf_format;
7934+extern void fatal(const char *fmt,... ) __printf_format __attribute__((noreturn));
7935+#define fatal_err(fmt, args...) \
7936+ do { printm("Fatal error: "); perrorm(fmt, ## args ); exit(1); } while(0)
7937+extern void fail_nil( void *p );
7938+extern void set_print_hook( int (*hook)(char *buf) );
7939+extern void set_print_guard( void (*hook)(void) );
7940+
7941+extern int script_exec( char *name, char *arg1, char *arg2 );
7942+
7943+/* in unicode.c */
7944+extern int asc2uni( unsigned char *ustr, const char *astr, int maxlen );
7945+extern int uni2asc( char *astr, const unsigned char *ustr, int ustrlen, int maxlen );
7946+
7947+/* in backtrace.c */
7948+extern void print_btrace_sym( ulong addr, const char *sym_filename );
7949+
7950+/* color output support */
7951+#define C_GREEN "\33[1;32m"
7952+#define C_YELLOW "\33[1;33m"
7953+#define C_NORMAL "\33[0;39m"
7954+#define C_RED "\33[1;31m"
7955+
7956+#endif /* _H_EXTRALIB */
7957--- /dev/null
7958+++ b/drivers/macintosh/mol/include/hash.h
7959@@ -0,0 +1,36 @@
7960+/*
7961+ * Creation Date: <2004/02/14 11:45:23 samuel>
7962+ * Time-stamp: <2004/02/21 21:24:46 samuel>
7963+ *
7964+ * <hash.h>
7965+ *
7966+ *
7967+ *
7968+ * Copyright (C) 2003, 2004 Samuel Rydh (samuel@ibrium.se)
7969+ *
7970+ * This program is free software; you can redistribute it and/or
7971+ * modify it under the terms of the GNU General Public License
7972+ * as published by the Free Software Foundation
7973+ *
7974+ */
7975+
7976+#ifndef _H_HASH
7977+#define _H_HASH
7978+
7979+typedef struct {
7980+ ulong sdr1; /* sdr1 used by MOL */
7981+
7982+ ulong pteg_mask; /* pteg offset mask (e.g. 0xffc0) */
7983+ ulong pte_mask; /* pte offset mask (e.g. 0xfff8) */
7984+
7985+ ulong *base; /* kernel mapping of hash */
7986+ ulong physbase; /* physical address of hash */
7987+} hash_info_t;
7988+
7989+extern hash_info_t ptehash;
7990+
7991+extern int init_hash( void );
7992+extern void cleanup_hash( void );
7993+
7994+
7995+#endif /* _H_HASH */
7996--- /dev/null
7997+++ b/drivers/macintosh/mol/include/kernel_vars.h
7998@@ -0,0 +1,225 @@
7999+/*
8000+ * Creation Date: <97/07/14 15:53:06 samuel>
8001+ * Time-stamp: <2004/02/21 21:37:37 samuel>
8002+ *
8003+ * <kernel_vars.h>
8004+ *
8005+ * Variables used by the kernel
8006+ *
8007+ * Copyright (C) 1997-2004 Samuel Rydh (samuel@ibrium.se)
8008+ *
8009+ * This program is free software; you can redistribute it and/or
8010+ * modify it under the terms of the GNU General Public License
8011+ * as published by the Free Software Foundation
8012+ *
8013+ */
8014+
8015+#ifndef H_KERNEL_VARS
8016+#define H_KERNEL_VARS
8017+
8018+#define MAX_NUM_SESSIONS 8
8019+
8020+#include "mac_registers.h"
8021+
8022+#ifdef PERFORMANCE_INFO
8023+#define NUM_ASM_BUMP_CNTRS 64
8024+#define NUM_ASM_TICK_CNTRS 6
8025+#endif
8026+
8027+#ifndef __ASSEMBLY__
8028+#include "mmu_mappings.h"
8029+#include "skiplist.h"
8030+
8031+#ifndef DUMPVARS
8032+#include "alloc.h"
8033+#include "locks.h"
8034+#include "atomic.h"
8035+#else
8036+typedef int mol_mutex_t;
8037+typedef int mol_atomic_t;
8038+#endif
8039+
8040+typedef struct {
8041+ ulong word[2]; /* upper, lower */
8042+} ppc_bat_t;
8043+
8044+typedef struct mac_bat {
8045+ int valid; /* record in use */
8046+ ulong base;
8047+ ulong mbase;
8048+ ulong size;
8049+
8050+ ulong wimg:4; /* WIMG-bits */
8051+ ulong vs:1; /* valid supervisor mode */
8052+ ulong vp:1; /* valid user mode */
8053+ ulong ks:1; /* key superuser */
8054+ ulong ku:1; /* key user */
8055+ ulong pp:2; /* page protection */
8056+
8057+ /* possibly we should track inserted PTEs here... */
8058+} mac_bat_t;
8059+
8060+typedef struct {
8061+ struct vsid_ent *vsid[16]; /* entries might be NULL */
8062+ struct vsid_ent *unmapped_vsid[16]; /* entries might be NULL, linux_vsid_sv used */
8063+
8064+ ulong emulator_sr[16]; /* segment registers used by the userspace process */
8065+
8066+ ulong user_sr[16]; /* segment registers for MSR=user */
8067+ ulong sv_sr[16]; /* segment registers for MSR=sv */
8068+ ulong unmapped_sr[16]; /* segment registers for unmapped mode */
8069+ ulong split_sr[16]; /* segment registers used in split mode */
8070+
8071+ ulong cur_sr_base; /* (physical) pointer to user_sr or sv_sr */
8072+ ulong sr_inst; /* (physical) pointer to us user_sr or sv_sr */
8073+ ulong sr_data; /* (physical) pointer to us user_sr or sv_sr */
8074+
8075+ ulong illegal_sr; /* used for the lazy segment register impl. */
8076+
8077+ ppc_bat_t split_dbat0; /* loaded to DBAT0 (used in splitmode) */
8078+ ppc_bat_t transl_dbat0; /* DBAT0 mapping the framebuffer */
8079+
8080+ ulong emulator_context; /* context of emulator (equals VSID >> 4) in Linux */
8081+
8082+ ulong userspace_ram_base; /* userspace RAM base */
8083+ size_t ram_size;
8084+
8085+ ulong bat_hack_count; /* HACK to speed up MacOS 9.1 */
8086+ mac_bat_t bats[8]; /* 4 IBAT + 4 DBAT */
8087+
8088+#ifdef EMULATE_603
8089+ ulong ptes_d_ea_603[64]; /* EA4-EA19 of dPTE */
8090+ mPTE_t ptes_d_603[64]; /* Data on-chip PTEs (603-emulation) */
8091+ ulong ptes_i_ea_603[64]; /* EA4-EA19 of iPTE */
8092+ mPTE_t ptes_i_603[64]; /* Instruction on-chip PTEs (603-emulation) */
8093+#endif
8094+ /* emulated PTE hash */
8095+ ulong hash_mbase; /* mac physical hash base */
8096+ ulong *hash_base; /* kernel pointer to mac hash */
8097+ ulong hash_mask; /* hash mask (0x000fffff etc) */
8098+
8099+ /* context number allocation */
8100+ int next_mol_context; /* in the range FIRST .. LAST_MOL_CONTEXT(n) */
8101+ int first_mol_context; /* first context number this session may use */
8102+ int last_mol_context; /* last context number this session may use */
8103+
8104+ ulong pthash_sr; /* segment register corresponding to */
8105+ ulong pthash_ea_base; /* pthash_ea_base */
8106+ void *pthash_inuse_bits; /* bitvector (one bit per PTE) */
8107+ ulong pthash_inuse_bits_ph; /* physical base address */
8108+
8109+ /* various tables */
8110+ struct io_data *io_data; /* translation info */
8111+ struct fb_data *fb_data; /* ea -> PTE table */
8112+ struct tracker_data *tracker_data; /* Keeps track of modified pages */
8113+
8114+ /* mtable stuff */
8115+ skiplist_t vsid_sl; /* skiplist (with vsid_ent_t objects) */
8116+ struct vsid_info *vsid_info; /* mtable data */
8117+
8118+ char *lvptr_reservation; /* lvptr associated with PTE to be inserted */
8119+ int lvptr_reservation_lost; /* set if reservation is lost (page out) */
8120+
8121+#ifdef __darwin__
8122+ ulong os_sdr1; /* SDR1 used by the host OS */
8123+ ulong mol_sdr1; /* SDR1 used by MOL */
8124+#endif
8125+} mmu_vars_t;
8126+
8127+
8128+/* variables which are private to the low level assembly code */
8129+typedef struct {
8130+ ulong spr_hooks[NUM_SPRS]; /* hooks */
8131+
8132+ ppc_bat_t ibat_save[4]; /* kernel values of the BAT-registers */
8133+ ppc_bat_t dbat_save[4];
8134+
8135+ ulong _msr; /* MSR used in mac-mode (_not_ the emulated msr) */
8136+
8137+ /* saved kernel/emulator registers */
8138+ ulong emulator_nip;
8139+ ulong emulator_msr;
8140+ ulong emulator_sprg2;
8141+ ulong emulator_sprg3;
8142+ ulong emulator_kcall_nip;
8143+ ulong emulator_stack;
8144+ ulong emulator_toc; /* == r2 on certain systems */
8145+
8146+ /* DEC and timebase */
8147+ ulong dec_stamp; /* linux DEC = dec_stamp - tbl */
8148+ ulong int_stamp; /* next DEC event = int_stamp - tbl */
8149+
8150+ /* splitmode */
8151+ int split_nip_segment; /* segment (top 4) used for inst. fetches */
8152+
8153+ /* segment register offset table */
8154+ ulong msr_sr_table[ 4*8 ]; /* see emulation.S */
8155+
8156+ ulong tmp_scratch[4]; /* temporary storage */
8157+} base_private_t;
8158+
8159+
8160+#ifdef PERFORMANCE_INFO
8161+#define MAX_ACC_CNTR_DEPTH 8
8162+typedef struct acc_counter {
8163+ ulong stamp;
8164+ ulong subticks;
8165+} acc_counter_t;
8166+#endif
8167+
8168+typedef struct kernel_vars {
8169+ struct mac_regs mregs; /* must go first */
8170+ char page_filler[0x1000 - (sizeof(mac_regs_t)&0xfff) ];
8171+
8172+ base_private_t _bp;
8173+ char aligner[32 - (sizeof(base_private_t)&0x1f) ];
8174+ mmu_vars_t mmu;
8175+ char aligner2[16 - (sizeof(mmu_vars_t)&0xf) ];
8176+
8177+ ulong emuaccel_mphys; /* mphys address of emuaccel_page */
8178+ int emuaccel_size; /* size used */
8179+ ulong emuaccel_page_phys; /* phys address of page */
8180+ ulong emuaccel_page; /* page used for instruction acceleration */
8181+
8182+ int break_flags;
8183+ ulong kvars_tophys_offs; /* physical - virtual address of kvars */
8184+ struct kernel_vars *kvars_virt; /* me */
8185+ int session_index;
8186+
8187+ mol_mutex_t ioctl_sem; /* ioctl lock */
8188+#ifdef __darwin__
8189+ void *kcall_routine;
8190+ int kcall_args[3];
8191+ char *mregs_virtual; /* mregs address used by client */
8192+
8193+#endif
8194+
8195+#ifdef PERFORMANCE_INFO
8196+ ulong asm_bump_cntr[NUM_ASM_BUMP_CNTRS];
8197+ ulong asm_tick_stamp[NUM_ASM_TICK_CNTRS];
8198+ int num_acntrs;
8199+ acc_counter_t acntrs[MAX_ACC_CNTR_DEPTH];
8200+#endif
8201+
8202+ void *main_thread; /* pointer to the main thread task_struct */
8203+
8204+} kernel_vars_t;
8205+
8206+#define NUM_KVARS_PAGES ((sizeof(kernel_vars_t)+0xfff)/0x1000)
8207+
8208+typedef struct {
8209+ kernel_vars_t *kvars[MAX_NUM_SESSIONS];
8210+ int magic;
8211+ ulong kvars_ph[MAX_NUM_SESSIONS];
8212+ mol_mutex_t lock;
8213+ mol_atomic_t external_thread_cnt;
8214+} session_table_t;
8215+
8216+#define SESSION_LOCK down_mol( &g_sesstab->lock )
8217+#define SESSION_UNLOCK up_mol( &g_sesstab->lock )
8218+
8219+extern session_table_t *g_sesstab;
8220+
8221+
8222+#endif /* __ASSEMBLY__ */
8223+#endif
8224--- /dev/null
8225+++ b/drivers/macintosh/mol/include/locks.h
8226@@ -0,0 +1,39 @@
8227+/*
8228+ * Creation Date: <2004/01/25 16:31:13 samuel>
8229+ * Time-stamp: <2004/01/29 22:33:29 samuel>
8230+ *
8231+ * <locks.h>
8232+ *
8233+ *
8234+ *
8235+ * Copyright (C) 2004 Samuel Rydh (samuel@ibrium.se)
8236+ *
8237+ * This program is free software; you can redistribute it and/or
8238+ * modify it under the terms of the GNU General Public License
8239+ * version 2
8240+ *
8241+ */
8242+
8243+#ifndef _H_LOCKS
8244+#define _H_LOCKS
8245+
8246+/* mutex locks */
8247+
8248+typedef struct semaphore mol_mutex_t;
8249+#define init_MUTEX_mol(mu) init_MUTEX( mu )
8250+#define free_MUTEX_mol(mu) do {} while(0)
8251+#define down_mol(x) down(x)
8252+#define up_mol(x) up(x)
8253+
8254+
8255+/* spinlocks */
8256+
8257+typedef spinlock_t mol_spinlock_t;
8258+#define spin_lock_mol(x) spin_lock(x)
8259+#define spin_unlock_mol(x) spin_unlock(x)
8260+//#define spin_lock_irqsave_mol(x, flags) spin_lock_irqsave(x, flags)
8261+//#define spin_unlock_irqrestore_mol(x,flags) spin_unlock_irqrestore(x, flags)
8262+#define spin_lock_init_mol(x) spin_lock_init(x)
8263+
8264+
8265+#endif /* _H_LOCKS */
8266--- /dev/null
8267+++ b/drivers/macintosh/mol/include/mac_registers.h
8268@@ -0,0 +1,168 @@
8269+/*
8270+ * Creation Date: <97/06/24 22:25:04 samuel>
8271+ * Time-stamp: <2004/02/08 20:32:59 samuel>
8272+ *
8273+ * <mac_registers.h>
8274+ *
8275+ *
8276+ *
8277+ * Copyright (C) 1997-2004 Samuel Rydh (samuel@ibrium.se)
8278+ *
8279+ * This program is free software; you can redistribute it and/or
8280+ * modify it under the terms of the GNU General Public License
8281+ * as published by the Free Software Foundation
8282+ *
8283+ */
8284+
8285+#ifndef _MAC_REGISTERS_H
8286+#define _MAC_REGISTERS_H
8287+
8288+#ifndef __ASSEMBLY__
8289+
8290+#include "mmutypes.h"
8291+#include "processor.h"
8292+
8293+typedef struct {
8294+ unsigned long h,l;
8295+} fpu_register;
8296+
8297+#define NUM_DEBUG_REGS 10
8298+
8299+typedef struct {
8300+ unsigned long words[4];
8301+} altivec_reg_t;
8302+
8303+#define NR_HOST_IRQS 64
8304+
8305+typedef struct irq_bitfield {
8306+ unsigned long irqs[(NR_HOST_IRQS - 1) / sizeof(unsigned long) + 1];
8307+} irq_bitfield_t;
8308+
8309+typedef struct mac_regs { /* this struct is page aligned */
8310+ /* the sprs should be page aligned (occupies one page) */
8311+ unsigned long spr[NUM_SPRS]; /* special purpose registers */
8312+
8313+ unsigned long segr[16]; /* segment registers */
8314+ altivec_reg_t vec[32]; /* AltiVec vector registers */
8315+ fpu_register fpr[32]; /* FPU registers (64 bits) */
8316+
8317+ unsigned long vscr_pad[3], vscr; /* AltiVec status control register */
8318+ unsigned long pad_fpscr, fpscr; /* fp. status and control register */
8319+ unsigned long pad_ef, emulator_fpscr; /* emulator fp. status and control reg */
8320+
8321+ /* Keep this cache-block aligned (typcically 8 words) */
8322+ unsigned long cr; /* Condition register */
8323+ unsigned long link; /* Link register */
8324+ unsigned long flag_bits; /* Various flags (fbXXXXX) */
8325+ unsigned long inst_opcode; /* opcode of instruction */
8326+ unsigned long gpr[32]; /* gprs */
8327+
8328+ unsigned long ctr; /* Count register */
8329+ unsigned long xer; /* Integer exception register */
8330+ unsigned long nip; /* Instruction pointer */
8331+ unsigned long msr; /* Machine state register (virtual) */
8332+
8333+ /* interrupts and timers */
8334+ int interrupt; /* set if the kernel should return to the emulator */
8335+ int in_virtual_mode; /* set while MOL is in virtualization mode */
8336+ ulong dec_stamp; /* xDEC = dec_stamp - tbl */
8337+ ulong timer_stamp; /* TIMER = dec_stamp - tbl */
8338+ int obsolete_irq; /* unused */
8339+
8340+ /* RVEC parameters */
8341+#ifdef __darwin__
8342+ ulong rvec_vector; /* Used in kernel C-mode */
8343+#endif
8344+ ulong rvec_param[3]; /* Used in kernel C-mode */
8345+
8346+ /* misc */
8347+ int fpu_state; /* FPU_STATE_xxx (see below) */
8348+ int processor; /* processor to emulate, 1=601, 4=604 */
8349+ int altivec_used; /* useful for altivec detection */
8350+ int no_altivec; /* Don't use altivec (e.g. no kernel support) */
8351+
8352+ int use_bat_hack; /* Newworld BAT optimization (HACK) */
8353+
8354+#ifdef EMULATE_603
8355+ unsigned long gprsave_603[4]; /* GPR0-3 (for 603 DMISS/IMISS) */
8356+#endif
8357+ /* moldeb support */
8358+ unsigned long mdbg_ea_break; /* used together with BREAK_EA_PAGE */
8359+
8360+ /* DEBUG */
8361+ unsigned long debug[NUM_DEBUG_REGS];
8362+ unsigned long debug_scr1; /* dbg scratch register */
8363+ unsigned long debug_scr2; /* dbg scratch register */
8364+ unsigned long debug_trace; /* dbg trace register */
8365+ unsigned long dbg_trace_space[256];
8366+ unsigned long dbg_last_rvec; /* useful for tracing segfaults etc. */
8367+ unsigned long dbg_last_osi;
8368+
8369+ unsigned long kernel_dbg_stop; /* stop emulation flag */
8370+
8371+ /* host irq mapping data */
8372+ irq_bitfield_t mapped_irqs; /* keeps track of used host irqs */
8373+ irq_bitfield_t active_irqs; /* irqs that are up are marked here */
8374+ int hostirq_update; /* whether userspace should update the pic */
8375+ /* should be mol_atomic_t but causes trouble... */
8376+ int hostirq_active_cnt; /* number of active host irq lines */
8377+
8378+} mac_regs_t;
8379+
8380+#define NUM_MREGS_PAGES ((sizeof(mac_regs_t)+0xfff)/0x1000)
8381+
8382+#define BIT(n) (1U<<(31-(n))) /* bit 0 is MSB */
8383+
8384+#ifndef __KERNEL__
8385+extern mac_regs_t *mregs;
8386+#endif
8387+#endif /* __ASSEMBLY__ */
8388+
8389+/* mregs->fpu_state (only valid when FBIT_FPUInUse is false) */
8390+#define FPU_STATE_HALF_SAVED 0 /* fpscr & fr0-fr13 saved */
8391+#define FPU_STATE_DIRTY 1 /* fpscr & fr13 saved */
8392+#define FPU_STATE_SAVED 3 /* everything is saved to mregs */
8393+
8394+/* flag_bits (loaded into cr4-7). TOUCH THESE *ONLY* FROM THE MAIN THREAD! */
8395+#ifdef __KERNEL__
8396+/* these must be in cr7 (set through a mtcrf) */
8397+#define MMU_CR_FIELD 0x01
8398+#define FBIT_InSplitmode 31 /* (S) */
8399+#define FBIT_PrepareSplitmode 30 /* (S) */
8400+#define FBIT_LoadSegreg 29 /* (S) */
8401+
8402+/* must be in cr6; (set through a mtcrf) */
8403+#define TRACE_CR_FIELD 0x02
8404+#define FBIT_DbgTrace 27 /* (S) equals BREAK_SINGLE_STEP */
8405+#define FBIT_Trace 26 /* (S) */
8406+
8407+#define FBIT_MolDecLoaded 23 /* (S) */
8408+#define FBIT_DecSeenZero 22 /* (S) */
8409+#define FBIT_DecINT 21 /* (S) */
8410+#define FBIT_FPUInUse 20 /* (S) Set when fpu is mac-owned (only valid in the kernel) */
8411+
8412+#endif
8413+
8414+#define FBIT_MsrModified 19 /* (U) */
8415+#define FBIT_RecalcDecInt 18 /* (U) */
8416+#define FBIT_IRQPending 17 /* (U) IRQ is pending */
8417+#ifdef EMULATE_603
8418+#define FBIT_603_AltGPR 16 /* (U) Alternate GPR0-3 in use */
8419+#endif
8420+
8421+
8422+#ifdef __KERNEL__
8423+#define fb_DbgTrace BIT( FBIT_DbgTrace )
8424+#define fb_Trace BIT( FBIT_Trace )
8425+#define fb_PrepareSplitmode BIT( FBIT_PrepareSplitmode )
8426+#define fb_InSplitmode BIT( FBIT_InSplitmode )
8427+#define fb_LoadSegreg BIT( FBIT_LoadSegreg )
8428+#endif
8429+#define fb_MsrModified BIT( FBIT_MsrModified )
8430+#define fb_RecalcDecInt BIT( FBIT_RecalcDecInt )
8431+#define fb_IRQPending BIT( FBIT_IRQPending )
8432+#ifdef EMULATE_603
8433+#define fb_603_AltGPR BIT( FBIT_603_AltGPR )
8434+#endif
8435+
8436+#endif /* _MAC_REGISTERS_H */
8437--- /dev/null
8438+++ b/drivers/macintosh/mol/include/map.h
8439@@ -0,0 +1,43 @@
8440+/*
8441+ * Creation Date: <2004/03/13 13:25:42 samuel>
8442+ * Time-stamp: <2004/03/13 14:07:11 samuel>
8443+ *
8444+ * <map.h>
8445+ *
8446+ *
8447+ *
8448+ * Copyright (C) 2004 Samuel Rydh (samuel@ibrium.se)
8449+ *
8450+ * This program is free software; you can redistribute it and/or
8451+ * modify it under the terms of the GNU General Public License
8452+ * version 2
8453+ */
8454+
8455+#ifndef _H_MAP
8456+#define _H_MAP
8457+
8458+/* map a userspace address into the kernel address space */
8459+extern void *map_phys_range( ulong paddr, ulong size, char **ret_addr );
8460+extern void unmap_phys_range( void *handle );
8461+
8462+/* map a userspace address into the kernel address space */
8463+extern void *map_virt_range( ulong va, ulong size, char **ret_addr );
8464+extern void unmap_virt_range( void *handle );
8465+
8466+/* map the virtualized PTE hash into the kernel address space */
8467+extern ulong *map_emulated_hash( kernel_vars_t *kv, ulong mbase, ulong size );
8468+extern void unmap_emulated_hash( kernel_vars_t *kv );
8469+
8470+#ifdef __linux__
8471+static inline ulong* map_hw_hash( ulong physbase, int size ) {
8472+ return phys_to_virt( physbase );
8473+}
8474+static inline void unmap_hw_hash( ulong *base ) {}
8475+#endif
8476+
8477+#ifdef __darwin__
8478+static inline void *map_hw_hash( ulong physbase, int size ) { return NULL; }
8479+static inline void unmap_hw_hash( ulong *base ) {}
8480+#endif
8481+
8482+#endif /* _H_MAP */
8483--- /dev/null
8484+++ b/drivers/macintosh/mol/include/misc.h
8485@@ -0,0 +1,105 @@
8486+/*
8487+ * Creation Date: <97/06/16 18:02:12 samuel>
8488+ * Time-stamp: <2004/03/13 14:03:30 samuel>
8489+ *
8490+ * <misc.h>
8491+ *
8492+ *
8493+ *
8494+ * Copyright (C) 1997-2004 Samuel Rydh (samuel@ibrium.se)
8495+ *
8496+ * This program is free software; you can redistribute it and/or
8497+ * modify it under the terms of the GNU General Public License
8498+ * as published by the Free Software Foundation
8499+ *
8500+ */
8501+
8502+#ifndef _H_MOD
8503+#define _H_MOD
8504+
8505+#ifdef __linux__
8506+
8507+#include <linux/version.h>
8508+#include <asm/uaccess.h>
8509+
8510+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
8511+#define compat_verify_area(a,b,c) ( ! access_ok(a,b,c) )
8512+#else
8513+#define compat_verify_area(a,b,c) verify_area(a,b,c)
8514+#endif
8515+
8516+#endif /* __linux__ */
8517+
8518+extern int g_num_sessions; /* number of active sessions */
8519+
8520+struct kernel_vars;
8521+
8522+/* init.c */
8523+extern int common_init( void );
8524+extern void common_cleanup( void );
8525+extern int initialize_session( unsigned int sess_index );
8526+extern void destroy_session( unsigned int sess_index );
8527+extern uint get_session_magic( uint random_magic );
8528+
8529+/* arch specific functions */
8530+extern int arch_common_init( void );
8531+extern void arch_common_cleanup( void );
8532+extern struct kernel_vars *alloc_kvar_pages( void );
8533+extern void free_kvar_pages( struct kernel_vars *kv );
8534+extern void prevent_mod_unload( void );
8535+
8536+/* misc.c */
8537+struct dbg_op_params;
8538+struct perf_ctr;
8539+extern int do_debugger_op( kernel_vars_t *kv, struct dbg_op_params *pb );
8540+extern int handle_ioctl( kernel_vars_t *kv, int what, int arg1, int arg2, int arg3 );
8541+
8542+/* hostirq.c */
8543+extern int grab_host_irq(kernel_vars_t *kv, int irq);
8544+extern int release_host_irq(kernel_vars_t *kv, int irq);
8545+extern void init_host_irqs(kernel_vars_t *kv);
8546+extern void cleanup_host_irqs(kernel_vars_t *kv);
8547+
8548+/* actions.c */
8549+extern int perform_actions( void );
8550+extern void cleanup_actions( void );
8551+
8552+/* bit table manipulation */
8553+static inline void
8554+set_bit_mol( int nr, char *addr )
8555+{
8556+ ulong mask = 1 << (nr & 0x1f);
8557+ ulong *p = ((ulong*)addr) + (nr >> 5);
8558+ *p |= mask;
8559+}
8560+
8561+static inline void
8562+clear_bit_mol( int nr, char *addr )
8563+{
8564+ ulong mask = 1 << (nr & 0x1f);
8565+ ulong *p = ((ulong*)addr) + (nr >> 5);
8566+ *p &= ~mask;
8567+}
8568+
8569+static inline int
8570+check_bit_mol( int nr, char *addr )
8571+{
8572+ ulong mask = 1 << (nr & 0x1f);
8573+ ulong *p = ((ulong*)addr) + (nr >> 5);
8574+ return (*p & mask) != 0;
8575+}
8576+
8577+/* typesafe min/max (stolen from kernel.h) */
8578+#define min_mol(x,y) ({ \
8579+ const typeof(x) _x = (x); \
8580+ const typeof(y) _y = (y); \
8581+ (void) (&_x == &_y); \
8582+ _x < _y ? _x : _y; })
8583+
8584+#define max_mol(x,y) ({ \
8585+ const typeof(x) _x = (x); \
8586+ const typeof(y) _y = (y); \
8587+ (void) (&_x == &_y); \
8588+ _x > _y ? _x : _y; })
8589+
8590+#endif
8591--- /dev/null
8592+++ b/drivers/macintosh/mol/include/mmu.h
8593@@ -0,0 +1,102 @@
8594+/*
8595+ * Creation Date: <1998-11-11 13:55:49 samuel>
8596+ * Time-stamp: <2004/02/28 19:20:23 samuel>
8597+ *
8598+ * <mmu.h>
8599+ *
8600+ * MMU related things
8601+ *
8602+ * Copyright (C) 1998-2004 Samuel Rydh (samuel@ibrium.se)
8603+ *
8604+ * This program is free software; you can redistribute it and/or
8605+ * modify it under the terms of the GNU General Public License
8606+ * as published by the Free Software Foundation
8607+ *
8608+ */
8609+
8610+#ifndef _H_MMU
8611+#define _H_MMU
8612+
8613+#ifndef __ASSEMBLY__
8614+#include "kernel_vars.h"
8615+#include "mac_registers.h"
8616+#include "mmu_mappings.h"
8617+#endif
8618+
8619+#ifdef CONFIG_MOL_HOSTED
8620+#define IO_PAGE_MAGIC_1 0x10BADA57
8621+#define IO_PAGE_MAGIC_2 0x136AB779
8622+#else
8623+#define IO_PAGE_MAGIC_1 0x10BACA57
8624+#define IO_PAGE_MAGIC_2 0x135AB779
8625+#endif
8626+
8627+#ifndef __ASSEMBLY__
8628+typedef struct io_page { /* Must fit within a single 4K page */
8629+ ulong magic; /* identifier 1 */
8630+ ulong magic2; /* identifier 2 */
8631+
8632+ ulong me_phys; /* physical address of this block */
8633+ ulong mphys; /* mac-physical address of block */
8634+ struct io_page *next; /* next io_page */
8635+
8636+ void *usr_data[512]; /* usr data (grain=double word) */
8637+} io_page_t;
8638+
8639+/* from mmu.c */
8640+extern int init_mmu( kernel_vars_t *kv );
8641+extern void cleanup_mmu( kernel_vars_t *kv );
8642+extern void do_flush( ulong vsid, ulong va, ulong *dummy, int num );
8643+extern void mmu_altered( kernel_vars_t *kv );
8644+extern void clear_vsid_refs( kernel_vars_t *kv );
8645+
8646+/* arch/mmu.c */
8647+extern int arch_mmu_init( kernel_vars_t *kv );
8648+
8649+/* from mmu_io.c */
8650+struct pte_lvrange;
8651+extern int init_mmu_io( kernel_vars_t *kv );
8652+extern void cleanup_mmu_io( kernel_vars_t *kv );
8653+extern int add_io_trans( kernel_vars_t *kv, ulong mbase, int size, void *usr_data );
8654+extern int remove_io_trans( kernel_vars_t *kv, ulong mbase, int size );
8655+extern int mphys_to_pte( kernel_vars_t *kv, ulong mphys, ulong *pte1, int is_write, struct pte_lvrange **lvrange );
8656+extern void mmu_add_map( kernel_vars_t *kv, struct mmu_mapping *m );
8657+extern void mmu_remove_map( kernel_vars_t *kv, struct mmu_mapping *m );
8658+
8659+/* from context.c */
8660+extern int init_contexts( kernel_vars_t *kv );
8661+extern void cleanup_contexts( kernel_vars_t *kv );
8662+extern int alloc_context( kernel_vars_t *kv );
8663+extern void handle_context_wrap( kernel_vars_t *kv, int nvsid_needed );
8664+
8665+/* from mmu_fb.c */
8666+extern int init_mmu_fb( kernel_vars_t *kv );
8667+extern void cleanup_mmu_fb( kernel_vars_t *kv );
8668+extern void video_pte_inserted( kernel_vars_t *kv, ulong lvptr, ulong *slot,
8669+ ulong pte0, ulong pte1, ulong ea );
8670+extern void setup_fb_acceleration( kernel_vars_t *kv, char *lvbase, int bytes_per_row, int height );
8671+extern int get_dirty_fb_lines( kernel_vars_t *kv, short *retbuf, int num_bytes );
8672+
8673+/* from mmu_tracker.c */
8674+extern int init_mmu_tracker( kernel_vars_t *kv );
8675+extern void cleanup_mmu_tracker( kernel_vars_t *kv );
8676+extern int track_lvrange( kernel_vars_t *kv );
8677+extern size_t get_track_buffer( kernel_vars_t *kv, char *retbuf );
8678+extern void set_track_buffer( kernel_vars_t *kv, char *buf );
8679+extern void lvpage_dirty( kernel_vars_t *kv, ulong lvpage );
8680+
8681+/* These functions should be used by the debugger only */
8682+struct dbg_page_info;
8683+extern int dbg_get_PTE( kernel_vars_t *kv, int context, ulong va, mPTE_t *ret );
8684+extern int dbg_get_linux_page( ulong va, struct dbg_page_info *r );
8685+extern int dbg_translate_ea( kernel_vars_t *kv, int context, ulong va, int *ret_mphys, int data_access );
8686+
8687+/* arch functions */
8688+extern ulong get_phys_page( kernel_vars_t *kv, ulong lvptr, int request_rw );
8689+
8690+/* VSID stuff */
8691+#define VSID_MASK 0xffffff
8692+
8693+
8694+#endif /* __ASSEMBLY__ */
8695+#endif /* _H_MMU */
8696--- /dev/null
8697+++ b/drivers/macintosh/mol/include/mmu_contexts.h
8698@@ -0,0 +1,55 @@
8699+/*
8700+ * Creation Date: <97/07/17 14:26:14 samuel>
8701+ * Time-stamp: <2003/06/06 19:17:26 samuel>
8702+ *
8703+ * <mmu_contexts.h>
8704+ *
8705+ *
8706+ *
8707+ * Copyright (C) 1997, 2001, 2002, 2003 Samuel Rydh
8708+ *
8709+ * This program is free software; you can redistribute it and/or
8710+ * modify it under the terms of the GNU General Public License
8711+ * version 2
8712+ *
8713+ */
8714+
8715+#ifndef _H_MMU_CONTEXTS
8716+#define _H_MMU_CONTEXTS
8717+
8718+/**********************************************************
8719+ * EVERYTHING IN THIS FILE IS UESED FOR DEBUGGING ONLY
8720+ *********************************************************/
8721+
8722+/* MMU context identifiers */
8723+#define kContextUnmapped 1
8724+#define kContextMapped_S 2
8725+#define kContextMapped_U 3
8726+
8727+#define kContextEmulator 20 /* for debugging purposes ONLY !!!! */
8728+#define kContextKernel 21 /* for debugging purposes ONLY !!!! */
8729+
8730+
8731+/* Flags returned by _get_physical_page(). The first flags should
8732+ * equal the _PAGE_XXX of the old MM implementation (<2.4.6).
8733+ */
8734+#define M_PAGE_PRESENT 0x001 /* software: pte contains a translation */
8735+#define M_PAGE_USER 0x002 /* usermode access allowed */
8736+#define M_PAGE_RW 0x004 /* usermode access allowed */
8737+#define M_PAGE_GUARDED 0x008 /* G: prohibit speculative access */
8738+#define M_PAGE_COHERENT 0x010 /* M: enforce memory coherence (SMP systems) */
8739+#define M_PAGE_NO_CACHE 0x020 /* I: cache inhibit */
8740+#define M_PAGE_WRITETHRU 0x040 /* W: cache write-through */
8741+#define M_PAGE_DIRTY 0x080 /* C: page changed */
8742+#define M_PAGE_ACCESSED 0x100 /* R: page referenced */
8743+/* new linux-MM implementation */
8744+#define M_PAGE_HASHPTE 0x1000 /* hash_page has made an HPTE for this pte */
8745+#define M_PAGE_EXEC 0x2000 /* software: i-cache coherency required */
8746+
8747+#ifdef __KERNEL__
8748+#define DBG_TRANSL_PAGE_FLAG( val, flagname ) \
8749+ (((val) & flagname )? M##flagname : 0)
8750+#endif
8751+
8752+
8753+#endif /* _H_MMU_CONTEXTS */
8754--- /dev/null
8755+++ b/drivers/macintosh/mol/include/mmu_mappings.h
8756@@ -0,0 +1,48 @@
8757+/*
8758+ * Creation Date: <1998-10-31 03:11:06 samuel>
8759+ * Time-stamp: <2004/03/13 16:44:58 samuel>
8760+ *
8761+ * <mmu_mappings.h>
8762+ *
8763+ * Mappings mac physical <-> linux virtual
8764+ *
8765+ * Copyright (C) 1998-2004 Samuel Rydh (samuel@ibrium.se)
8766+ *
8767+ * This program is free software; you can redistribute it and/or
8768+ * modify it under the terms of the GNU General Public License
8769+ * as published by the Free Software Foundation
8770+ *
8771+ */
8772+
8773+#ifndef _H_MMU_MAPPINGS
8774+#define _H_MMU_MAPPINGS
8775+
8776+typedef struct mmu_mapping {
8777+ ulong mbase; /* mac physical base */
8778+ char *lvbase; /* linux virtual base */
8779+ size_t size; /* size (in bytes) */
8780+ int flags; /* MAPPING_xxx */
8781+
8782+ int id; /* set to zero, returned by the kerrnel module */
8783+} mmu_mapping_t;
8784+
8785+/* mmu_mapping flags */
8786+
8787+#define MAPPING_RO 1 /* read only memory (ROM etc) */
8788+#define MAPPING_PHYSICAL 2 /* physical (ROM etc) */
8789+#define MAPPING_SCRATCH 4 /* (block transl) scratch area */
8790+#define MAPPING_FORCE_CACHE 8 /* force write-through caching */
8791+#define MAPPING_FB_ACCEL 16 /* offscreen framebuffer, track changes */
8792+#define MAPPING_FB 32 /* framebuffer (ea assumed to be constant) */
8793+#define MAPPING_DBAT 64 /* allow use of a DBAT register */
8794+#define MAPPING_MACOS_CONTROLS_CACHE 128 /* do not force WIM bits to 001 */
8795+#define MAPPING_PUT_FIRST 256 /* take precedence over other translations */
8796+#define MAPPING_MREGS 512 /* map mregs into emulated process */
8797+#define MAPPING_FORCE_WRITABLE 4096 /* guess what... */
8798+
8799+#ifdef __KERNEL__
8800+#define MAPPING_IO 1024 /* I/O translation */
8801+#define MAPPING_VALID 2048 /* valid bit */
8802+#endif
8803+
8804+#endif /* _H_MMU_MAPPINGS */
8805--- /dev/null
8806+++ b/drivers/macintosh/mol/include/mmutypes.h
8807@@ -0,0 +1,76 @@
8808+/*
8809+ * Creation Date: <2002/01/13 13:53:14 samuel>
8810+ * Time-stamp: <2002/01/27 19:56:11 samuel>
8811+ *
8812+ * <mmutypes.h>
8813+ *
8814+ * MMU definitions
8815+ *
8816+ * Most of these declarations originate from the Linux Kernel
8817+ *
8818+ * Copyright (C) 2002 Samuel Rydh (samuel@ibrium.se)
8819+ *
8820+ * This program is free software; you can redistribute it and/or
8821+ * modify it under the terms of the GNU General Public License
8822+ * as published by the Free Software Foundation
8823+ *
8824+ */
8825+
8826+#ifndef _H_MMUTYPES
8827+#define _H_MMUTYPES
8828+
8829+/* Hardware Page Table Entry */
8830+typedef struct mPTE {
8831+ unsigned long v:1; /* Entry is valid */
8832+ unsigned long vsid:24; /* Virtual segment identifier */
8833+ unsigned long h:1; /* Hash algorithm indicator */
8834+ unsigned long api:6; /* Abbreviated page index */
8835+
8836+ unsigned long rpn:20; /* Real (physical) page number */
8837+ unsigned long :3; /* Unused */
8838+ unsigned long r:1; /* Referenced */
8839+ unsigned long c:1; /* Changed */
8840+ unsigned long w:1; /* Write-thru cache mode */
8841+ unsigned long i:1; /* Cache inhibited */
8842+ unsigned long m:1; /* Memory coherence */
8843+ unsigned long g:1; /* Guarded */
8844+ unsigned long :1; /* Unused */
8845+ unsigned long pp:2; /* Page protection */
8846+} mPTE_t;
8847+
8848+
8849+typedef struct _mBATU { /* Upper part of BAT (all except 601) */
8850+ unsigned long bepi:15; /* Effective page index (virtual address) */
8851+ unsigned long :4; /* Unused */
8852+ unsigned long bl:11; /* Block size mask */
8853+ unsigned long vs:1; /* Supervisor valid */
8854+ unsigned long vp:1; /* User valid */
8855+} mBATU;
8856+
8857+typedef struct _mBATL { /* Lower part of BAT (all except 601) */
8858+ unsigned long brpn:15; /* Real page index (physical address) */
8859+ unsigned long :10; /* Unused */
8860+ unsigned long w:1; /* Write-thru cache */
8861+ unsigned long i:1; /* Cache inhibit */
8862+ unsigned long m:1; /* Memory coherence */
8863+ unsigned long g:1; /* Guarded (MBZ in IBAT) */
8864+ unsigned long :1; /* Unused */
8865+ unsigned long pp:2; /* Page access protections */
8866+} mBATL;
8867+
8868+typedef struct _mBAT {
8869+ mBATU batu; /* Upper register */
8870+ mBATL batl; /* Lower register */
8871+} mBAT;
8872+
8873+typedef struct _mSEGREG {
8874+ unsigned long t:1; /* Normal or I/O type */
8875+ unsigned long ks:1; /* Supervisor 'key' (normally 0) */
8876+ unsigned long kp:1; /* User 'key' (normally 1) */
8877+ unsigned long n:1; /* No-execute */
8878+ unsigned long :4; /* Unused */
8879+ unsigned long vsid:24; /* Virtual Segment Identifier */
8880+} mSEGREG;
8881+
8882+
8883+#endif /* _H_MMUTYPES */
8884--- /dev/null
8885+++ b/drivers/macintosh/mol/include/mol-ioctl.h
8886@@ -0,0 +1,121 @@
8887+/*
8888+ * Creation Date: <2003/08/26 10:53:07 samuel>
8889+ * Time-stamp: <2004/02/08 20:17:58 samuel>
8890+ *
8891+ * <mol-ioctl.h>
8892+ *
8893+ *
8894+ *
8895+ * Copyright (C) 2003, 2004 Samuel Rydh (samuel@ibrium.se)
8896+ *
8897+ * This program is free software; you can redistribute it and/or
8898+ * modify it under the terms of the GNU General Public License
8899+ * version 2
8900+ *
8901+ */
8902+
8903+#ifndef _H_MOL_IOCTL
8904+#define _H_MOL_IOCTL
8905+
8906+#ifndef __ASSEMBLY__
8907+#include "mmutypes.h"
8908+
8909+typedef struct {
8910+ int version; /* MOL version */
8911+ int smp_kernel; /* compiled with CONFIG_SMP */
8912+ int pvr; /* cpu version/revision (PVR) */
8913+ int rombase;
8914+ int romsize;
8915+ unsigned int tb_freq;
8916+} mol_kmod_info_t;
8917+
8918+typedef struct perf_ctr {
8919+ unsigned int ctr;
8920+ char name[40];
8921+} perf_ctr_t;
8922+
8923+typedef struct dbg_page_info {
8924+ int phys;
8925+ int mflags; /* M_PAGE_XXX */
8926+} dbg_page_info_t;
8927+
8928+typedef struct dbg_op_params {
8929+ /* input */
8930+ int operation; /* DBG_OP_xxx */
8931+ int ea;
8932+ int context;
8933+ int param;
8934+
8935+ /* output */
8936+ union {
8937+ int phys;
8938+ dbg_page_info_t page;
8939+ mPTE_t pte;
8940+ } ret;
8941+} dbg_op_params_t;
8942+
8943+typedef struct mol_ioctl_pb {
8944+ int arg1, arg2, arg3;
8945+#ifdef __darwin__
8946+ int ret;
8947+#endif
8948+} mol_ioctl_pb_t;
8949+
8950+#endif /* __ASSEMBLY__ */
8951+
8952+/* ioctls that do not use the mol_ioctl_pb arg */
8953+#define MOL_IOCTL_SMP_SEND_IPI _IO('M', 1) /* void ( void ) */
8954+#ifdef __darwin__
8955+#define MOL_IOCTL_CALL_KERNEL _IO('M', 2) /* void ( void ) */
8956+#endif
8957+
8958+/* debugger ioctls */
8959+#define MOL_IOCTL_DEBUGGER_OP _IOWR('M', 10, mol_ioctl_pb_t) /* int ( dbg_op_params *p ) */
8960+#define DBG_OP_EMULATE_TLBIE 1 /* void ( ulong pageindex ) */
8961+#define DBG_OP_EMULATE_TLBIA 2 /* void ( void ) */
8962+#define DBG_OP_GET_PTE 3 /* lvptr, context, int ( ulong vsid, ulong va, PTE *retpte ) */
8963+#define DBG_OP_GET_PHYS_PAGE 4 /* int ( ulong lvptr, ulong *retptr ) */
8964+#define DBG_OP_BREAKPOINT_FLAGS 5 /* void ( ulong flags ) */
8965+#define DBG_OP_TRANSLATE_EA 6 /* ea, context, is_data -- mphys */
8966+#define MOL_IOCTL_CLEAR_PERF_INFO _IOWR('M', 11, mol_ioctl_pb_t) /* void ( void ) */
8967+#define MOL_IOCTL_GET_PERF_INFO _IOWR('M', 12, mol_ioctl_pb_t) /* int ( int index, perf_ctr_t *ctr ) */
8968+
8969+/* config selectors */
8970+#define MOL_IOCTL_CREATE_SESSION _IOWR('M', 30, mol_ioctl_pb_t) /* int ( int session_index ) */
8971+#define MOL_IOCTL_GET_INFO _IOWR('M', 31, mol_ioctl_pb_t) /* int ( mol_kmod_info_t *retinfo, int size ) */
8972+#define MOL_IOCTL_SET_RAM _IOWR('M', 33, mol_ioctl_pb_t) /* void ( ulong ram_start, ulong ram_end ) */
8973+#define MOL_IOCTL_COPY_LAST_ROMPAGE _IOWR('M', 34, mol_ioctl_pb_t) /* void ( char *destpage ) */
8974+#define MOL_IOCTL_SPR_CHANGED _IOWR('M', 35, mol_ioctl_pb_t) /* void ( void ) */
8975+#define MOL_IOCTL_IDLE_RECLAIM_MEMORY _IOWR('M', 36, mol_ioctl_pb_t) /* void ( void ) */
8976+#define MOL_IOCTL_MMU_MAP _IOWR('M', 37, mol_ioctl_pb_t) /* void ( struct mmu_mapping *m, int add_map ) */
8977+#define MOL_IOCTL_ADD_IORANGE _IOWR('M', 39, mol_ioctl_pb_t) /* void ( ulong mbase, size_t size, io_ops_t *) */
8978+#define MOL_IOCTL_REMOVE_IORANGE _IOWR('M', 40, mol_ioctl_pb_t) /* void ( ulong mbase, size_t size ) */
8979+#define MOL_IOCTL_SETUP_FBACCEL _IOWR('M', 41, mol_ioctl_pb_t) /* void * ( char *lvbase, int bytes_per_row, int height ) */
8980+#define MOL_IOCTL_GET_DIRTY_FBLINES _IOWR('M', 42, mol_ioctl_pb_t) /* int ( short *rettable, int table_size_in_bytes ) */
8981+#define MOL_IOCTL_TRACK_DIRTY_RAM _IOWR('M', 43, mol_ioctl_pb_t) /* int ( char *lvbase, size_t size ) */
8982+#define MOL_IOCTL_GET_DIRTY_RAM _IOWR('M', 44, mol_ioctl_pb_t) /* size_t ( char *retbuf ) */
8983+#define MOL_IOCTL_SET_DIRTY_RAM _IOWR('M', 45, mol_ioctl_pb_t) /* void ( char *dirtybuf ) */
8984+#define MOL_IOCTL_GET_MREGS_PHYS _IOWR('M', 46, mol_ioctl_pb_t) /* ulong ( void ) */
8985+#define MOL_IOCTL_ALLOC_EMUACCEL_SLOT _IOWR('M', 47, mol_ioctl_pb_t) /* int ( int inst_flags, int param, int inst_addr ) */
8986+#define MOL_IOCTL_MAPIN_EMUACCEL_PAGE _IOWR('M', 48, mol_ioctl_pb_t) /* int ( int mphys ) */
8987+#define MOL_IOCTL_TUNE_SPR _IOWR('M', 49, mol_ioctl_pb_t) /* int ( int spr, int action ) */
8988+#define MOL_IOCTL_GET_SESSION_MAGIC _IOWR('M', 50, mol_ioctl_pb_t) /* uint ( uint new_random_magic ) */
8989+
8990+#define MOL_IOCTL_DBG_COPY_KVARS _IOWR('M', 51, mol_ioctl_pb_t) /* int ( int session, kernel_vars_t *dest ) */
8991+
8992+#ifdef __darwin__
8993+#define MOL_IOCTL_GET_MREGS_VIRT _IOWR('M', 52, mol_ioctl_pb_t) /* int ( mac_regs_t **ret ) */
8994+#endif
8995+
8996+#define MOL_IOCTL_GRAB_IRQ _IOWR('M', 53, mol_ioctl_pb_t) /* int ( int irq ) */
8997+#define MOL_IOCTL_RELEASE_IRQ _IOWR('M', 54, mol_ioctl_pb_t) /* int ( int irq ) */
8998+#define MOL_IOCTL_GET_IRQS _IOWR('M', 55, mol_ioctl_pb_t) /* int ( irq_bitfield_t * ) */
8999+
9000+
9001+/* MOL error codes */
9002+#define EMOLGENERAL 100
9003+#define EMOLINUSE 101
9004+#define EMOLINVAL 102
9005+#define EMOLSECURITY 103
9006+
9007+#endif /* _H_MOL_IOCTL */
9008--- /dev/null
9009+++ b/drivers/macintosh/mol/include/mol_config.h
9010@@ -0,0 +1,76 @@
9011+/*
9012+ * Creation Date: <1999/05/30 15:30:25 samuel>
9013+ * Time-stamp: <2004/06/05 19:47:33 samuel>
9014+ *
9015+ * <mol_config.h>
9016+ *
9017+ * Header to be included first...
9018+ *
9019+ * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
9020+ *
9021+ * This program is free software; you can redistribute it and/or
9022+ * modify it under the terms of the GNU General Public License
9023+ * as published by the Free Software Foundation
9024+ *
9025+ */
9026+
9027+#ifndef _H_MOL_CONFIG
9028+#define _H_MOL_CONFIG
9029+
9030+/* Some debugging flags */
9031+#define COLLECT_RVEC_STATISTICS
9032+//#define EMULATE_603
9033+//#define ENABLE_ASSERT
9034+
9035+#define _GNU_SOURCE
9036+#define _REENTRANT
9037+#define _LARGEFILE64_SOURCE
9038+
9039+#if defined(__powerpc__) && !defined(__ppc__)
9040+#define __ppc__
9041+#endif
9042+#if defined(__ppc__) && !defined(__powerpc__)
9043+#define __powerpc__
9044+#endif
9045+
9046+#if !defined(__linux__) && !defined(__ASSEMBLY__)
9047+typedef unsigned long ulong;
9048+#endif
9049+
9050+#if !defined(__ASSEMBLY__) && !defined(__KERNEL__)
9051+#include <stdio.h>
9052+#include <stdlib.h>
9053+#include <string.h>
9054+#include <unistd.h>
9055+#include <sys/types.h>
9056+#include <sys/stat.h>
9057+#include <fcntl.h>
9058+#include <errno.h>
9059+#include <ctype.h>
9060+
9061+#include "config.h"
9062+#include "autoconf.h"
9063+#include "unconfig.h"
9064+
9065+#ifdef CONFIG_OLDWORLD
9066+#define OLDWORLD_SUPPORT
9067+#endif
9068+
9069+#include "platform.h"
9070+
9071+/* from emulaiton/main.c */
9072+extern int in_security_mode;
9073+
9074+/* common MOL header fiels */
9075+
9076+#include "debugger.h" /* for printm */
9077+#include "extralib.h"
9078+
9079+#endif /* __ASSEMBLY__ && __KERNEL__ */
9080+
9081+#ifdef __ASSEMBLY__
9082+changequote([[[[[,]]]]])
9083+[[[[[ /* shield includes from m4-expansion */
9084+#endif
9085+
9086+#endif /* _H_MOL_CONFIG */
9087--- /dev/null
9088+++ b/drivers/macintosh/mol/include/molasm.h
9089@@ -0,0 +1,138 @@
9090+/* -*- asm -*-
9091+ *
9092+ * Creation Date: <2001/01/28 20:33:22 samuel>
9093+ * Time-stamp: <2004/01/29 19:29:10 samuel>
9094+ *
9095+ * <molasm.h>
9096+ *
9097+ * Utility assembly macros
9098+ *
9099+ * Copyright (C) 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
9100+ *
9101+ * This program is free software; you can redistribute it and/or
9102+ * modify it under the terms of the GNU General Public License
9103+ * as published by the Free Software Foundation
9104+ *
9105+ */
9106+
9107+#ifndef _H_MOLASM
9108+#define _H_MOLASM
9109+
9110+#define GLOBAL_SYMBOL( sym_name ) \
9111+GLOBL(sym_name)
9112+
9113+
9114+/************************************************************************/
9115+/* SPRG usage */
9116+/************************************************************************/
9117+
9118+/* Darwin and Linux uses the sprg's differently. Linux uses sprg0/1 in
9119+ * the exception vectors while Darwin uses sprg2/3.
9120+ */
9121+#ifdef __linux__
9122+define([mfsprg_a0], [mfsprg0])
9123+define([mfsprg_a1], [mfsprg1])
9124+define([mfsprg_a2], [mfsprg2])
9125+define([mfsprg_a3], [mfsprg3])
9126+define([mtsprg_a0], [mtsprg0])
9127+define([mtsprg_a1], [mtsprg1])
9128+define([mtsprg_a2], [mtsprg2])
9129+define([mtsprg_a3], [mtsprg3])
9130+#else
9131+define([mfsprg_a0], [mfsprg2])
9132+define([mfsprg_a1], [mfsprg3])
9133+define([mfsprg_a2], [mfsprg0])
9134+define([mfsprg_a3], [mfsprg1])
9135+define([mtsprg_a0], [mtsprg2])
9136+define([mtsprg_a1], [mtsprg3])
9137+define([mtsprg_a2], [mtsprg0])
9138+define([mtsprg_a3], [mtsprg1])
9139+#endif
9140+
9141+
9142+/************************************************************************/
9143+/* Utility */
9144+/************************************************************************/
9145+
9146+MACRO(LOAD_VARIABLE, [reg, offs], [
9147+ lis _reg,HA(k_mol_stack + _offs)
9148+ lwz _reg,LO(k_mol_stack + _offs)(_reg)
9149+])
9150+
9151+MACRO(SET_SESSION_TABLE, [reg], [
9152+ lis _reg,HA(EXTERN(Symbol_SESSION_TABLE))
9153+ addi _reg,_reg,LO(EXTERN(Symbol_SESSION_TABLE))
9154+])
9155+
9156+
9157+/************************************************************************/
9158+/* GPR save / restore */
9159+/************************************************************************/
9160+
9161+MACRO(xGPR_SAVE, [reg], [
9162+ stw rPREFIX[]_reg,(xGPR0 + _reg*4)(r1)
9163+])
9164+
9165+MACRO(xGPR_LOAD, [reg], [
9166+ lwz rPREFIX[]_reg,(xGPR0 + _reg*4)(r1)
9167+])
9168+
9169+
9170+/************************************************************************/
9171+/* FPU misc */
9172+/************************************************************************/
9173+
9174+MACRO(ENABLE_MSR_FP, [scr], [
9175+ mfmsr _scr
9176+ ori _scr,_scr,MSR_FP
9177+ mtmsr _scr
9178+ isync
9179+])
9180+
9181+/************************************************************************/
9182+/* Segment registers */
9183+/************************************************************************/
9184+
9185+MACRO(LOAD_SEGMENT_REGS, [base, scr, scr2], [
9186+ mFORLOOP([i],0,7,[
9187+ lwz _scr,eval(i * 8)(_base)
9188+ lwz _scr2,eval((i * 8)+4)(_base)
9189+ mtsr srPREFIX[]eval(i*2),_scr
9190+ mtsr srPREFIX[]eval(i*2+1),_scr2
9191+ ])
9192+])
9193+
9194+MACRO(SAVE_SEGMENT_REGS, [base, scr, scr2], [
9195+ mFORLOOP([i],0,7,[
9196+ mfsr _scr,srPREFIX[]eval(i*2)
9197+ mfsr _scr2,srPREFIX[]eval(i*2+1)
9198+ stw _scr,eval(i * 8)(_base)
9199+ stw _scr2,eval((i * 8) + 4)(_base)
9200+ ])
9201+])
9202+
9203+/************************************************************************/
9204+/* BAT register */
9205+/************************************************************************/
9206+
9207+MACRO(SAVE_DBATS, [varoffs, scr1], [
9208+ mfpvr _scr1
9209+ srwi _scr1,_scr1,16
9210+ cmpwi r3,1
9211+ beq 9f
9212+ mFORLOOP([nn],0,7,[
9213+ mfspr _scr1, S_DBAT0U + nn
9214+ stw _scr1,(_varoffs + (4 * nn))(r1)
9215+ ])
9216+9:
9217+])
9218+
9219+MACRO(SAVE_IBATS, [varoffs, scr1], [
9220+ mFORLOOP([nn],0,7,[
9221+ mfspr _scr1, S_IBAT0U + nn
9222+ stw _scr1,(_varoffs + (4 * nn))(r1)
9223+ ])
9224+])
9225+
9226+
9227+#endif /* _H_MOLASM */
9228--- /dev/null
9229+++ b/drivers/macintosh/mol/include/molversion.h
9230@@ -0,0 +1,6 @@
9231+#define MOL_BUILD_DATE "Okt 13 2007 11:49"
9232+#define MOL_VERSION_STR "0.9.73"
9233+#define MOL_RELEASE "0.9.73-SVN"
9234+#define MOL_MAJOR_VERSION 0
9235+#define MOL_MINOR_VERSION 9
9236+#define MOL_PATCHLEVEL 73
9237--- /dev/null
9238+++ b/drivers/macintosh/mol/include/mtable.h
9239@@ -0,0 +1,71 @@
9240+/*
9241+ * Creation Date: <2002/05/26 15:52:50 samuel>
9242+ * Time-stamp: <2004/02/21 16:18:11 samuel>
9243+ *
9244+ * <mtable.h>
9245+ *
9246+ * Keeps track of the PTEs
9247+ *
9248+ * Copyright (C) 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
9249+ *
9250+ * This program is free software; you can redistribute it and/or
9251+ * modify it under the terms of the GNU General Public License
9252+ * as published by the Free Software Foundation
9253+ *
9254+ */
9255+
9256+#ifndef _H_MTABLE
9257+#define _H_MTABLE
9258+
9259+#ifndef __ASSEMBLY__
9260+typedef struct pte_lvrange pte_lvrange_t;
9261+typedef struct vsid_info vsid_info_t;
9262+typedef struct vsid_ent vsid_ent_t;
9263+
9264+extern int init_mtable( kernel_vars_t *kv );
9265+extern void cleanup_mtable( kernel_vars_t *kv );
9266+
9267+extern pte_lvrange_t *register_lvrange( kernel_vars_t *kv, char *lvbase, int size );
9268+extern void free_lvrange( kernel_vars_t *kv, pte_lvrange_t *pte_range );
9269+
9270+extern vsid_ent_t *vsid_get_user_sv( kernel_vars_t *kv, int mac_vsid, ulong *user_sr, ulong *sv_sr );
9271+
9272+extern int mtable_memory_check( kernel_vars_t *kv );
9273+extern void pte_inserted( kernel_vars_t *kv, ulong ea, char *lvptr,
9274+ pte_lvrange_t *lvrange, ulong *pte, vsid_ent_t *r,
9275+ int segreg );
9276+
9277+extern void flush_vsid_ea( kernel_vars_t *kv, int vsid, ulong ea );
9278+extern void flush_ea_range( kernel_vars_t *kv, ulong ea, int size );
9279+extern void flush_lvptr( kernel_vars_t *kv, ulong lvptr );
9280+extern void flush_lv_range( kernel_vars_t *kv, ulong lvbase, int size );
9281+
9282+extern void clear_all_vsids( kernel_vars_t *kv );
9283+extern void clear_pte_hash_table( kernel_vars_t *kv );
9284+
9285+extern void mtable_reclaim( kernel_vars_t *kv );
9286+extern void mtable_tune_alloc_limit( kernel_vars_t *kv, int ramsize_mb );
9287+
9288+static inline void
9289+make_lvptr_reservation( kernel_vars_t *kv, char *lvptr ) {
9290+ kv->mmu.lvptr_reservation = lvptr;
9291+ kv->mmu.lvptr_reservation_lost = 0;
9292+}
9293+
9294+
9295+#endif /* __ASSEMBLY__ */
9296+
9297+/* offsets to linux_vsid and linux_vsid_sv (used from assembly) */
9298+#define VSID_MYSELF_VIRT 0
9299+#define VSID_USER_OFFS 4
9300+#define VSID_SV_OFFS 8
9301+#define SIZEOF_VSID_ENT (64*4 + 12)
9302+
9303+#define VSID_OFFSETS_OK \
9304+ ((offsetof(vsid_ent_t, linux_vsid) == VSID_USER_OFFS ) || \
9305+ (offsetof(vsid_ent_t, linux_vsid_sv) == VSID_SV_OFFS ) || \
9306+ (sizeof(vsid_ent_t) == SIZEOF_VSID_ENT))
9307+
9308+#endif /* _H_MTABLE */
9309+
9310+
9311--- /dev/null
9312+++ b/drivers/macintosh/mol/include/osi.h
9313@@ -0,0 +1,170 @@
9314+/*
9315+ * Creation Date: <1999/03/18 03:19:43 samuel>
9316+ * Time-stamp: <2003/12/26 16:58:19 samuel>
9317+ *
9318+ * <os_interface.h>
9319+ *
9320+ * This file includes definitions for drivers
9321+ * running in the "emulated" OS. (Mainly the 'sc'
9322+ * mechanism of communicating)
9323+ *
9324+ * Copyright (C) 1999, 2000, 2001, 2002, 2003 Samuel Rydh (samuel@ibrium.se)
9325+ *
9326+ * This program is free software; you can redistribute it and/or
9327+ * modify it under the terms of the GNU General Public License
9328+ * as published by the Free Software Foundation
9329+ *
9330+ */
9331+
9332+#ifndef _H_OSI
9333+#define _H_OSI
9334+
9335+/* Magic register values loaded into r3 and r4 before the 'sc' assembly instruction */
9336+#define OSI_SC_MAGIC_R3 0x113724FA
9337+#define OSI_SC_MAGIC_R4 0x77810F9B
9338+
9339+
9340+/************************************************************************/
9341+/* Selectors (passed in r5) */
9342+/************************************************************************/
9343+
9344+#define OSI_CALL_AVAILABLE 0
9345+#define OSI_DEBUGGER 1 /* enter debugger */
9346+/* obsolete OSI_LOG_STR 3 */
9347+#define OSI_CMOUNT_DRV_VOL 4 /* conditionally mount driver volume */
9348+/* obsolete OSI_SCSI_xxx 5-6 */
9349+#define OSI_GET_GMT_TIME 7
9350+#define OSI_MOUSE_CNTRL 8
9351+#define OSI_GET_LOCALTIME 9 /* return time in secs from 01/01/04 */
9352+
9353+#define OSI_ENET_OPEN 10
9354+#define OSI_ENET_CLOSE 11
9355+#define OSI_ENET_GET_ADDR 12
9356+#define OSI_ENET_GET_STATUS 13
9357+#define OSI_ENET_CONTROL 14
9358+#define OSI_ENET_ADD_MULTI 16
9359+#define OSI_ENET_DEL_MULTI 17
9360+#define OSI_ENET_GET_PACKET 18
9361+#define OSI_ENET_SEND_PACKET 19
9362+
9363+#define OSI_OF_INTERFACE 20
9364+#define OSI_OF_TRAP 21
9365+#define OSI_OF_RTAS 22
9366+
9367+#define OSI_SCSI_CNTRL 23
9368+#define OSI_SCSI_SUBMIT 24
9369+#define OSI_SCSI_ACK 25
9370+
9371+#define OSI_GET_MOUSE 26 /* -- r3 status, r4-r8 mouse data */
9372+#define OSI_ACK_MOUSE_IRQ 27 /* -- int */
9373+
9374+#define OSI_SET_VMODE 28 /* modeID, depth -- error */
9375+#define OSI_GET_VMODE_INFO 29 /* mode, depth -- r3 status, r4-r9 pb */
9376+#define OSI_GET_MOUSE_DPI 30 /* -- mouse_dpi */
9377+
9378+#define OSI_SET_VIDEO_POWER 31
9379+#define OSI_GET_FB_INFO 32 /* void -- r3 status, r4-r8 video data */
9380+
9381+#define OSI_SOUND_WRITE 33
9382+/* #define OSI_SOUND_FORMAT 34 */
9383+#define OSI_SOUND_SET_VOLUME 35
9384+#define OSI_SOUND_CNTL 36
9385+/* obsolete OSI_SOUND call 37 */
9386+
9387+#define OSI_VIDEO_ACK_IRQ 38
9388+#define OSI_VIDEO_CNTRL 39
9389+
9390+#define OSI_SOUND_IRQ_ACK 40
9391+#define OSI_SOUND_START_STOP 41
9392+
9393+#define OSI_REGISTER_IRQ 42 /* reg_property[0] appl_int -- irq_cookie */
9394+/* obsolete OSI_IRQ 43-46 */
9395+
9396+#define OSI_LOG_PUTC 47 /* char -- */
9397+
9398+#define OSI_KBD_CNTRL 50
9399+#define OSI_GET_ADB_KEY 51 /* -- adb_keycode (keycode | keycode_id in r4) */
9400+
9401+#define OSI_WRITE_NVRAM_BYTE 52 /* offs, byte -- */
9402+#define OSI_READ_NVRAM_BYTE 53 /* offs -- byte */
9403+
9404+#define OSI_EXIT 54
9405+
9406+#define OSI_KEYCODE_TO_ADB 55 /* (keycode | keycode_id) -- adb_keycode */
9407+#define OSI_MAP_ADB_KEY 56 /* keycode, adbcode -- */
9408+#define OSI_SAVE_KEYMAPPING 57 /* -- */
9409+#define OSI_USLEEP 58 /* usecs -- */
9410+#define OSI_SET_COLOR 59 /* index value -- */
9411+
9412+#define OSI_PIC_MASK_IRQ 60 /* irq -- */
9413+#define OSI_PIC_UNMASK_IRQ 61 /* irq -- */
9414+#define OSI_PIC_ACK_IRQ 62 /* irq mask_flag -- */
9415+#define OSI_PIC_GET_ACTIVE_IRQ 63
9416+
9417+#define OSI_GET_COLOR 64 /* index -- value */
9418+
9419+/* 65-67 old ablk implementation */
9420+#define OSI_IRQTEST 65
9421+
9422+#define OSI_ENET2_OPEN 68
9423+#define OSI_ENET2_CLOSE 69
9424+#define OSI_ENET2_CNTRL 70
9425+#define OSI_ENET2_RING_SETUP 71
9426+#define OSI_ENET2_KICK 72
9427+#define OSI_ENET2_GET_HWADDR 73
9428+#define OSI_ENET2_IRQ_ACK 74
9429+
9430+#define OSI_PROM_IFACE 76
9431+#define kPromClose 0
9432+#define kPromPeer 1
9433+#define kPromChild 2
9434+#define kPromParent 3
9435+#define kPromPackageToPath 4
9436+#define kPromGetPropLen 5
9437+#define kPromGetProp 6
9438+#define kPromNextProp 7
9439+#define kPromSetProp 8
9440+#define kPromChangePHandle 9
9441+
9442+#define OSI_PROM_PATH_IFACE 77
9443+#define kPromCreateNode 16
9444+#define kPromFindDevice 17
9445+
9446+#define OSI_BOOT_HELPER 78
9447+#define kBootHAscii2Unicode 32
9448+#define kBootHUnicode2Ascii 33
9449+#define kBootHGetStrResInd 34 /* key, buf, len -- buf */
9450+#define kBootHGetRAMSize 35 /* -- ramsize */
9451+
9452+#define OSI_ABLK_RING_SETUP 79
9453+#define OSI_ABLK_CNTRL 80
9454+#define OSI_ABLK_DISK_INFO 81
9455+#define OSI_ABLK_KICK 82
9456+#define OSI_ABLK_IRQ_ACK 83
9457+#define OSI_ABLK_SYNC_READ 84
9458+#define OSI_ABLK_SYNC_WRITE 85
9459+#define OSI_ABLK_BLESS_DISK 86
9460+
9461+#define OSI_EMUACCEL 89 /* EMULATE_xxx, nip -- index */
9462+#define OSI_MAPIN_MREGS 90 /* mphys */
9463+#define OSI_NVRAM_SIZE 91
9464+
9465+#define OSI_MTICKS_TO_USECS 92
9466+#define OSI_USECS_TO_MTICKS 93
9467+
9468+/* obsolete OSI_BLK 94-95 */
9469+
9470+#define OSI_PSEUDO_FS 96
9471+#define kPseudoFSOpen 1
9472+#define kPseudoFSClose 2
9473+#define kPseudoFSGetSize 3
9474+#define kPseudoFSRead 4
9475+#define kPseudoFSIndex2Name 5
9476+
9477+#define OSI_TTY_PUTC 97
9478+#define OSI_TTY_GETC 98
9479+#define OSI_TTY_IRQ_ACK 99
9480+
9481+#define NUM_OSI_SELECTORS 100 /* remember to increase this... */
9482+
9483+#endif /* _H_OSI */
9484--- /dev/null
9485+++ b/drivers/macintosh/mol/include/osi_calls.h
9486@@ -0,0 +1,475 @@
9487+/*
9488+ * Creation Date: <2002/06/16 01:40:57 samuel>
9489+ * Time-stamp: <2004/02/23 01:04:31 samuel>
9490+ *
9491+ * <osi_calls.h>
9492+ *
9493+ * OSI call inlines
9494+ *
9495+ * Copyright (C) 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
9496+ *
9497+ * This program is free software; you can redistribute it and/or
9498+ * modify it under the terms of the GNU General Public License
9499+ * as published by the Free Software Foundation
9500+ *
9501+ */
9502+
9503+#ifndef _H_OSI_CALLS
9504+#define _H_OSI_CALLS
9505+
9506+#include "osi.h"
9507+
9508+/* Old gcc versions have a limit on the number of registers used.
9509+ * Newer gcc versions (gcc 3.3) require that the clobber list does
9510+ * not overlap declared registers.
9511+ */
9512+#if __GNUC__ == 2 || ( __GNUC__ == 3 && __GNUC_MINOR__ < 3 )
9513+#define SHORT_REGLIST
9514+#endif
9515+
9516+
9517+/************************************************************************/
9518+/* OSI call instantiation macros */
9519+/************************************************************************/
9520+
9521+#define dreg(n) __oc_##n __asm__ (#n)
9522+#define ir(n) "r" (__oc_##n)
9523+#define rr(n) "=r" (__oc_##n)
9524+
9525+#define _oc_head( input_regs... ) \
9526+{ \
9527+ int _ret=0; \
9528+ { \
9529+ register unsigned long dreg(r3); \
9530+ register unsigned long dreg(r4); \
9531+ register unsigned long dreg(r5) \
9532+ ,##input_regs ;
9533+
9534+#define _oc_syscall( number, extra_ret_regs... ) \
9535+ __oc_r3 = OSI_SC_MAGIC_R3; \
9536+ __oc_r4 = OSI_SC_MAGIC_R4; \
9537+ __oc_r5 = number; \
9538+ __asm__ __volatile__ ( \
9539+ "sc " : rr(r3) ,## extra_ret_regs
9540+
9541+#define _oc_input( regs... ) \
9542+ : ir(r3), ir(r4), ir(r5) \
9543+ , ## regs \
9544+ : "memory" );
9545+
9546+/* the tail memory clobber is necessary since we violate the strict
9547+ * aliasing rules when we return structs through the registers.
9548+ */
9549+#define _oc_tail \
9550+ asm volatile ( "" : : : "memory" ); \
9551+ _ret = __oc_r3; \
9552+ } \
9553+ return _ret; \
9554+}
9555+
9556+
9557+/************************************************************************/
9558+/* Alternatives */
9559+/************************************************************************/
9560+
9561+#ifdef SHORT_REGLIST
9562+#ifdef __linux__
9563+#define _oc_syscall_r10w6( number, inputregs... ) \
9564+ __oc_r3 = OSI_SC_MAGIC_R3; \
9565+ __oc_r4 = OSI_SC_MAGIC_R4; \
9566+ __oc_r5 = number; \
9567+ __asm__ __volatile__ ( \
9568+ "sc \n" \
9569+ "stw 4,0(10) \n" \
9570+ "stw 5,4(10) \n" \
9571+ "stw 6,8(10) \n" \
9572+ "stw 7,12(10) \n" \
9573+ "stw 8,16(10) \n" \
9574+ "stw 9,20(10) \n" \
9575+ : rr(r3) \
9576+ : ir(r3), ir(r4), ir(r5), ir(r10) \
9577+ ,## inputregs \
9578+ : "memory", \
9579+ "r4", "r5", "r6", "r7", "r8", "r9" );
9580+#endif
9581+#ifdef __darwin__
9582+#define _oc_syscall_r10w6( number, inputregs... ) \
9583+ __oc_r3 = OSI_SC_MAGIC_R3; \
9584+ __oc_r4 = OSI_SC_MAGIC_R4; \
9585+ __oc_r5 = number; \
9586+ __asm__ __volatile__ ( \
9587+ "sc \n" \
9588+ "stw r4,0(r10) \n" \
9589+ "stw r5,4(r10) \n" \
9590+ "stw r6,8(r10) \n" \
9591+ "stw r7,12(r10) \n" \
9592+ "stw r8,16(r10) \n" \
9593+ "stw r9,20(r10) \n" \
9594+ : rr(r3) \
9595+ : ir(r3), ir(r4), ir(r5), ir(r10) \
9596+ ,## inputregs \
9597+ : "memory", \
9598+ "r4", "r5", "r6", "r7", "r8", "r9" );
9599+#endif
9600+#endif
9601+
9602+
9603+/************************************************************************/
9604+/* Common helper functions */
9605+/************************************************************************/
9606+
9607+#define _osi_call0( type, name, number ) \
9608+type name( void ) \
9609+ _oc_head() \
9610+ _oc_syscall( number ) \
9611+ _oc_input() \
9612+ _oc_tail
9613+
9614+#define _osi_call1( type, name, number, type1, arg1 ) \
9615+type name( type1 arg1 ) \
9616+ _oc_head( dreg(r6) ) \
9617+ __oc_r6 = (ulong)arg1; \
9618+ _oc_syscall( number ) \
9619+ _oc_input( ir(r6) ) \
9620+ _oc_tail
9621+
9622+#define _osi_call2( type, name, number, t1, a1, t2, a2 ) \
9623+type name( t1 a1, t2 a2 ) \
9624+ _oc_head( dreg(r6), dreg(r7) ) \
9625+ __oc_r6 = (ulong)a1; \
9626+ __oc_r7 = (ulong)a2; \
9627+ _oc_syscall( number ) \
9628+ _oc_input( ir(r6), ir(r7) ) \
9629+ _oc_tail
9630+
9631+#define _osi_call3( type, name, number, t1, a1, t2, a2, t3, a3 ) \
9632+type name( t1 a1, t2 a2, t3 a3 ) \
9633+ _oc_head( dreg(r6), dreg(r7), dreg(r8) ) \
9634+ __oc_r6 = (ulong)a1; \
9635+ __oc_r7 = (ulong)a2; \
9636+ __oc_r8 = (ulong)a3; \
9637+ _oc_syscall( number ) \
9638+ _oc_input( ir(r6), ir(r7), ir(r8) ) \
9639+ _oc_tail
9640+
9641+#define _osi_call4( type, name, number, t1, a1, t2, a2, t3, a3, t4, a4 ) \
9642+type name( t1 a1, t2 a2, t3 a3, t4 a4 ) \
9643+ _oc_head( dreg(r6), dreg(r7), dreg(r8), dreg(r9) ) \
9644+ __oc_r6 = (ulong)a1; \
9645+ __oc_r7 = (ulong)a2; \
9646+ __oc_r8 = (ulong)a3; \
9647+ __oc_r9 = (ulong)a4; \
9648+ _oc_syscall( number ) \
9649+ _oc_input( ir(r6), ir(r7), ir(r8), ir(r9) ) \
9650+ _oc_tail
9651+
9652+#define _osi_call5( type, name, number, t1, a1, t2, a2, t3, a3, t4, a4, t5, a5 ) \
9653+type name( t1 a1, t2 a2, t3 a3, t4 a4, t5 a5 ) \
9654+ _oc_head( dreg(r6), dreg(r7), dreg(r8), dreg(r9), dreg(r10) ) \
9655+ __oc_r6 = (ulong)a1; \
9656+ __oc_r7 = (ulong)a2; \
9657+ __oc_r8 = (ulong)a3; \
9658+ __oc_r9 = (ulong)a4; \
9659+ __oc_r10 = (ulong)a5; \
9660+ _oc_syscall( number ) \
9661+ _oc_input( ir(r6), ir(r7), ir(r8), ir(r9), ir(r10) ) \
9662+ _oc_tail
9663+
9664+#define _osi_call6( type, name, number, t1, a1, t2, a2, t3, a3, t4, a4, t5, a5, t6, a6 ) \
9665+type name( t1 a1, t2 a2, t3 a3, t4 a4, t5 a5, t6 a6 ) \
9666+ _oc_head( dreg(r6), dreg(r7), dreg(r8), dreg(r9), dreg(r10), dreg(r11) )\
9667+ __oc_r6 = (ulong)a1; \
9668+ __oc_r7 = (ulong)a2; \
9669+ __oc_r8 = (ulong)a3; \
9670+ __oc_r9 = (ulong)a4; \
9671+ __oc_r10 = (ulong)a5; \
9672+ __oc_r11 = (ulong)a6; \
9673+ _oc_syscall( number ) \
9674+ _oc_input( ir(r6), ir(r7), ir(r8), ir(r9), ir(r10), ir(r11) ) \
9675+ _oc_tail
9676+
9677+
9678+/************************************************************************/
9679+/* Special */
9680+/************************************************************************/
9681+
9682+/* r4 returned in retarg1 pointer */
9683+#define _osi_call0_w1( type, name, number, type1, retarg1 ) \
9684+type name( type1 retarg1 ) \
9685+ _oc_head() \
9686+ _oc_syscall( number, rr(r4) ) \
9687+ _oc_input() \
9688+ *retarg1 = __oc_r4; \
9689+ _oc_tail
9690+
9691+#define _osi_call0_w2( type, name, number, type1, retarg1 ) \
9692+type name( type1 retarg1 ) \
9693+ _oc_head() \
9694+ _oc_syscall( number, rr(r4), rr(r5) ) \
9695+ _oc_input() \
9696+ ((ulong*)retarg1)[0] = __oc_r4; \
9697+ ((ulong*)retarg1)[1] = __oc_r5; \
9698+ _oc_tail
9699+
9700+/* r4-r8 returned in retarg1 pointer */
9701+#define _osi_call0_w5( type, name, number, type1, retarg1 ) \
9702+type name( type1 retarg1 ) \
9703+ _oc_head( dreg(r6), dreg(r7), dreg(r8) ) \
9704+ _oc_syscall( number, \
9705+ rr(r4), rr(r5), rr(r6), rr(r7), rr(r8) ) \
9706+ _oc_input() \
9707+ ((ulong*)retarg1)[0] = __oc_r4; \
9708+ ((ulong*)retarg1)[1] = __oc_r5; \
9709+ ((ulong*)retarg1)[2] = __oc_r6; \
9710+ ((ulong*)retarg1)[3] = __oc_r7; \
9711+ ((ulong*)retarg1)[4] = __oc_r8; \
9712+ _oc_tail
9713+
9714+/* r4 returned in retarg pointer */
9715+#define _osi_call1_w1( type, name, number, t1, a1, t2, retarg ) \
9716+type name( t1 a1, t2 retarg ) \
9717+ _oc_head( dreg(r6) ) \
9718+ __oc_r6 = (ulong)a1; \
9719+ _oc_syscall( number, rr(r4) ) \
9720+ _oc_input( ir(r6) ) \
9721+ ((ulong*)retarg)[0] = __oc_r4; \
9722+ _oc_tail
9723+
9724+/* r4,r5 returned in retarg1, retarg2 */
9725+#define _osi_call1_w1w1( type, name, number, t1, a1, t2, retarg1, t3, retarg2 ) \
9726+type name( t1 a1, t2 retarg1, t3 retarg2 ) \
9727+ _oc_head( dreg(r6) ) \
9728+ __oc_r6 = (ulong)a1; \
9729+ _oc_syscall( number, rr(r4), rr(r5) ) \
9730+ _oc_input( ir(r6) ) \
9731+ ((ulong*)retarg1)[0] = __oc_r4; \
9732+ ((ulong*)retarg2)[0] = __oc_r5; \
9733+ _oc_tail
9734+
9735+/* r4,r5 returned in retarg1, retarg2, retarg3 */
9736+#define _osi_call1_w1w1w1( type, name, number, t1, a1, t2, retarg1, t3, retarg2, t4, retarg3 ) \
9737+type name( t1 a1, t2 retarg1, t3 retarg2, t4 retarg3 ) \
9738+ _oc_head( dreg(r6) ) \
9739+ __oc_r6 = (ulong)a1; \
9740+ _oc_syscall( number, rr(r4), rr(r5), rr(r6) ) \
9741+ _oc_input( ir(r6) ) \
9742+ ((ulong*)retarg1)[0] = __oc_r4; \
9743+ ((ulong*)retarg2)[0] = __oc_r5; \
9744+ ((ulong*)retarg3)[0] = __oc_r6; \
9745+ _oc_tail
9746+
9747+/* r4,r5 returned in retarg pointer */
9748+#define _osi_call1_w2( type, name, number, t1, a1, t2, retarg ) \
9749+type name( t1 a1, t2 retarg ) \
9750+ _oc_head( dreg(r6) ) \
9751+ __oc_r6 = (ulong)a1; \
9752+ _oc_syscall( number, rr(r4), rr(r5) ) \
9753+ _oc_input( ir(r6) ) \
9754+ ((ulong*)retarg)[0] = __oc_r4; \
9755+ ((ulong*)retarg)[1] = __oc_r5; \
9756+ _oc_tail
9757+
9758+/* r4-r7 returned in retarg pointer */
9759+#define _osi_call1_w4( type, name, number, t1, a1, t2, retarg ) \
9760+type name( t1 a1, t2 retarg ) \
9761+ _oc_head( dreg(r6), dreg(r7) ) \
9762+ __oc_r6 = (ulong)a1; \
9763+ _oc_syscall( number, rr(r4), rr(r5), rr(r6), rr(r7) ) \
9764+ _oc_input( ir(r6) ) \
9765+ ((ulong*)retarg)[0] = __oc_r4; \
9766+ ((ulong*)retarg)[1] = __oc_r5; \
9767+ ((ulong*)retarg)[2] = __oc_r6; \
9768+ ((ulong*)retarg)[3] = __oc_r7; \
9769+ _oc_tail
9770+
9771+
9772+/* r4-r5 returned in retarg pointer */
9773+#define _osi_call2_w2( type, name, number, t1, a1, t2, a2, t3, retarg ) \
9774+type name( t1 a1, t2 a2, t3 retarg ) \
9775+ _oc_head( dreg(r6), dreg(r7) ) \
9776+ __oc_r6 = (ulong)a1; \
9777+ __oc_r7 = (ulong)a2; \
9778+ _oc_syscall( number, rr(r4), rr(r5) ) \
9779+ _oc_input( ir(r6), ir(r7) ) \
9780+ ((ulong*)retarg)[0] = __oc_r4; \
9781+ ((ulong*)retarg)[1] = __oc_r5; \
9782+ _oc_tail
9783+
9784+/* r4-r7 returned in retarg pointer */
9785+#define _osi_call2_w4( type, name, number, t1, a1, t2, a2, t3, retarg ) \
9786+type name( t1 a1, t2 a2, t3 retarg ) \
9787+ _oc_head( dreg(r6), dreg(r7) ) \
9788+ __oc_r6 = (ulong)a1; \
9789+ __oc_r7 = (ulong)a2; \
9790+ _oc_syscall( number, rr(r4), rr(r5), rr(r6), rr(r7) ) \
9791+ _oc_input( ir(r6), ir(r7) ) \
9792+ ((ulong*)retarg)[0] = __oc_r4; \
9793+ ((ulong*)retarg)[1] = __oc_r5; \
9794+ ((ulong*)retarg)[2] = __oc_r6; \
9795+ ((ulong*)retarg)[3] = __oc_r7; \
9796+ _oc_tail
9797+
9798+#ifdef SHORT_REGLIST
9799+/* r4-r9 returned in retarg pointer */
9800+#define _osi_call2_w6( type, name, number, t1, a1, t2, a2, t3, retarg ) \
9801+type name( t1 a1, t2 a2, t3 retarg ) \
9802+ _oc_head( dreg(r6), dreg(r7), dreg(r10) ) \
9803+ __oc_r6 = (ulong)a1; \
9804+ __oc_r7 = (ulong)a2; \
9805+ __oc_r10 = (ulong)retarg; \
9806+ _oc_syscall_r10w6( number, ir(r6), ir(r7) ) \
9807+ _oc_tail
9808+
9809+#else /* SHORT_REGLIST */
9810+
9811+/* r4-r9 returned in retarg pointer */
9812+#define _osi_call2_w6( type, name, number, t1, a1, t2, a2, t3, retarg ) \
9813+type name( t1 a1, t2 a2, t3 retarg ) \
9814+ _oc_head( dreg(r6), dreg(r7), dreg(r8), dreg(r9) ) \
9815+ __oc_r6 = (ulong)a1; \
9816+ __oc_r7 = (ulong)a2; \
9817+ _oc_syscall( number, rr(r4), rr(r5), rr(r6), rr(r7), rr(r8), rr(r9) ) \
9818+ _oc_input( ir(r6), ir(r7) ) \
9819+ ((ulong*)retarg)[0] = __oc_r4; \
9820+ ((ulong*)retarg)[1] = __oc_r5; \
9821+ ((ulong*)retarg)[2] = __oc_r6; \
9822+ ((ulong*)retarg)[3] = __oc_r7; \
9823+ ((ulong*)retarg)[4] = __oc_r8; \
9824+ ((ulong*)retarg)[5] = __oc_r9; \
9825+ _oc_tail
9826+
9827+#endif /* SHORT_REGLIST */
9828+
9829+
9830+/************************************************************************/
9831+/* OSI call inlines */
9832+/************************************************************************/
9833+
9834+static inline _osi_call1( int, OSI_CallAvailable, OSI_CALL_AVAILABLE, int, osi_num );
9835+
9836+static inline _osi_call1( int, OSI_PutC, OSI_LOG_PUTC, int, ch );
9837+
9838+static inline _osi_call1( int, OSI_Debugger, OSI_DEBUGGER, int, num );
9839+static inline _osi_call0( int, OSI_Exit, OSI_EXIT );
9840+
9841+/* misc */
9842+static inline _osi_call0( ulong, OSI_GetLocalTime, OSI_GET_LOCALTIME );
9843+static inline _osi_call0( ulong, OSI_GetGMTTime, OSI_GET_GMT_TIME );
9844+static inline _osi_call1( int, OSI_USleep, OSI_USLEEP, int, usecs );
9845+
9846+/* NVRAM */
9847+static inline _osi_call0( int, OSI_NVRamSize, OSI_NVRAM_SIZE );
9848+static inline _osi_call1( int, OSI_ReadNVRamByte, OSI_READ_NVRAM_BYTE, int, offs );
9849+static inline _osi_call2( int, OSI_WriteNVRamByte, OSI_WRITE_NVRAM_BYTE, int, offs,
9850+ unsigned char, ch );
9851+
9852+/* keyboard stuff */
9853+static inline _osi_call0_w1( int, OSI_GetAdbKey2, OSI_GET_ADB_KEY, int *, raw_key );
9854+static inline _osi_call1( int, OSI_KbdCntrl, OSI_KBD_CNTRL, int, cmd );
9855+
9856+static inline int OSI_GetAdbKey( void )
9857+ { int dummy_raw_key; return OSI_GetAdbKey2( &dummy_raw_key ); }
9858+static inline _osi_call2( int, OSI_MapAdbKey, OSI_MAP_ADB_KEY, int, keycode, int, adbkey )
9859+static inline _osi_call1( int, OSI_KeycodeToAdb, OSI_KEYCODE_TO_ADB, int, keycode );
9860+static inline _osi_call0( int, OSI_SaveKeymapping, OSI_SAVE_KEYMAPPING );
9861+
9862+/* mouse support */
9863+struct osi_mouse;
9864+static inline _osi_call0_w5( int, OSI_GetMouse, OSI_GET_MOUSE, struct osi_mouse *, ret );
9865+static inline _osi_call0( int, OSI_GetMouseDPI, OSI_GET_MOUSE_DPI );
9866+
9867+/* video */
9868+static inline _osi_call2( int, OSI_SetVMode_, OSI_SET_VMODE, int, mode, int, depth_mode );
9869+struct osi_get_vmode_info;
9870+static inline _osi_call2_w6( int, OSI_GetVModeInfo_, OSI_GET_VMODE_INFO, int, mode, int, depth_mode,
9871+ struct osi_get_vmode_info *, ret );
9872+static inline _osi_call1( int, OSI_SetVPowerState, OSI_SET_VIDEO_POWER, int, power_state );
9873+static inline _osi_call2( int, OSI_SetColor, OSI_SET_COLOR, int, index, int, rgb );
9874+static inline _osi_call0_w1( int, OSI_VideoAckIRQ, OSI_VIDEO_ACK_IRQ, int *, events );
9875+
9876+static inline void OSI_RefreshPalette( void ) { OSI_SetColor(-1,0); }
9877+
9878+/* PIC (mac-io replacement) */
9879+static inline _osi_call1( int, OSI_PICMaskIRQ, OSI_PIC_MASK_IRQ, int, irq );
9880+static inline _osi_call1( int, OSI_PICUnmaskIRQ, OSI_PIC_UNMASK_IRQ, int, irq );
9881+static inline _osi_call2( int, OSI_PICAckIRQ, OSI_PIC_ACK_IRQ, int, irq, int, mask_it );
9882+static inline _osi_call0( int, OSI_PICGetActiveIRQ, OSI_PIC_GET_ACTIVE_IRQ );
9883+
9884+/* sound */
9885+static inline _osi_call1( int, OSI_SoundCntl, OSI_SOUND_CNTL, int, cmd );
9886+static inline _osi_call2( int, OSI_SoundCntl1, OSI_SOUND_CNTL, int, cmd, int, p1 );
9887+static inline _osi_call3( int, OSI_SoundCntl2, OSI_SOUND_CNTL, int, cmd, int, p1, int, p2 );
9888+static inline _osi_call0_w2( int, OSI_SoundIRQAck, OSI_SOUND_IRQ_ACK, ulong *, timestamp );
9889+static inline _osi_call3( int, OSI_SoundWrite, OSI_SOUND_WRITE, int, physbuf, int, len, int, restart );
9890+static inline _osi_call3( int, OSI_SoundSetVolume, OSI_SOUND_SET_VOLUME, int, hwvol, int, speakervol, int, mute );
9891+
9892+/* async block driver */
9893+struct ablk_disk_info;
9894+static inline _osi_call2_w4( int, OSI_ABlkDiskInfo, OSI_ABLK_DISK_INFO, int, channel, int, unit,
9895+ struct ablk_disk_info *, retinfo );
9896+static inline _osi_call1( int, OSI_ABlkKick, OSI_ABLK_KICK, int, channel );
9897+static inline _osi_call1_w1w1w1( int, OSI_ABlkIRQAck, OSI_ABLK_IRQ_ACK, int, channel, int *, req_count,
9898+ int *, active, int *, events );
9899+static inline _osi_call3( int, OSI_ABlkRingSetup, OSI_ABLK_RING_SETUP, int, channel, int, mphys, int, n_el );
9900+static inline _osi_call2( int, OSI_ABlkCntrl, OSI_ABLK_CNTRL, int, channel, int, cmd );
9901+static inline _osi_call3( int, OSI_ABlkCntrl1, OSI_ABLK_CNTRL, int, channel, int, cmd, int, param );
9902+static inline _osi_call5( int, OSI_ABlkSyncRead, OSI_ABLK_SYNC_READ, int, channel, int, unit,
9903+ int, blk, ulong, mphys, int, size );
9904+static inline _osi_call5( int, OSI_ABlkSyncWrite, OSI_ABLK_SYNC_WRITE, int, channel, int, unit,
9905+ int, blk, ulong, mphys, int, size );
9906+static inline _osi_call2( int, OSI_ABlkBlessDisk, OSI_ABLK_BLESS_DISK, int, channel, int, unit );
9907+
9908+static inline _osi_call0( int, OSI_CMountDrvVol, OSI_CMOUNT_DRV_VOL );
9909+
9910+/* enet2 */
9911+static inline _osi_call0( int, OSI_Enet2Open, OSI_ENET2_OPEN );
9912+static inline _osi_call0( int, OSI_Enet2Close, OSI_ENET2_CLOSE );
9913+static inline _osi_call3( int, OSI_Enet2RingSetup, OSI_ENET2_RING_SETUP, int, which_ring,
9914+ int, ring_mphys, int, n_el );
9915+static inline _osi_call2( int, OSI_Enet2Cntrl1, OSI_ENET2_CNTRL, int, cmd, int, param );
9916+static inline _osi_call1( int, OSI_Enet2Cntrl, OSI_ENET2_CNTRL, int, cmd );
9917+static inline _osi_call0( int, OSI_Enet2Kick, OSI_ENET2_KICK );
9918+
9919+static inline _osi_call0_w2( int, OSI_Enet2GetHWAddr__, OSI_ENET2_GET_HWADDR, ulong *, retbuf );
9920+static inline int OSI_Enet2GetHWAddr( unsigned char *addr ) {
9921+ int ret;
9922+ ulong buf[2];
9923+
9924+ ret = OSI_Enet2GetHWAddr__( buf );
9925+
9926+ ((ulong*)addr)[0] = buf[0];
9927+ ((ushort*)addr)[2] = (buf[1] >> 16);
9928+ return ret;
9929+}
9930+static inline _osi_call2( int, OSI_Enet2IRQAck, OSI_ENET2_IRQ_ACK, int, irq_enable, int, rx_head );
9931+
9932+/* PROM (device-tree) */
9933+static inline _osi_call2( int, OSI_PromIface, OSI_PROM_IFACE, int, what, int, ph );
9934+static inline _osi_call3( int, OSI_PromIface1, OSI_PROM_IFACE, int, what, int, ph, int, p1 );
9935+static inline _osi_call4( int, OSI_PromIface2, OSI_PROM_IFACE, int, what, int, ph, int, p1, int, p2 );
9936+static inline _osi_call5( int, OSI_PromIface3, OSI_PROM_IFACE, int, what, int, ph, int, p1, int, p2, int, p3 );
9937+static inline _osi_call2( int, OSI_PromPathIface, OSI_PROM_PATH_IFACE, int, what, const char *, p );
9938+
9939+/* emulation acceleration */
9940+static inline _osi_call1( int, OSI_MapinMregs, OSI_MAPIN_MREGS, ulong, mphys );
9941+static inline _osi_call3( int, OSI_EmuAccel, OSI_EMUACCEL, int, emuaccel_flags, int, param, int, inst_addr );
9942+
9943+/* timer frequency */
9944+static inline _osi_call1( int, OSI_MticksToUsecs, OSI_MTICKS_TO_USECS, ulong, mticks );
9945+static inline _osi_call1( int, OSI_UsecsToMticks, OSI_USECS_TO_MTICKS, ulong, usecs );
9946+
9947+/* fb info */
9948+struct osi_fb_info;
9949+static inline _osi_call0_w5( int, OSI_GetFBInfo, OSI_GET_FB_INFO, struct osi_fb_info *, retinfo );
9950+
9951+/* SCSI */
9952+static inline _osi_call0( int, OSI_SCSIAck, OSI_SCSI_ACK );
9953+static inline _osi_call1( int, OSI_SCSISubmit, OSI_SCSI_SUBMIT, int, req_mphys );
9954+static inline _osi_call2( int, OSI_SCSIControl, OSI_SCSI_CNTRL, int, sel, int, param );
9955+
9956+/* TTY */
9957+static inline _osi_call0( int, OSI_TTYGetc, OSI_TTY_GETC );
9958+static inline _osi_call1( int, OSI_TTYPutc, OSI_TTY_PUTC, int, ch );
9959+static inline _osi_call0( int, OSI_TTYIRQAck, OSI_TTY_IRQ_ACK );
9960+
9961+#endif /* _H_OSI_CALLS */
9962--- /dev/null
9963+++ b/drivers/macintosh/mol/include/performance.h
9964@@ -0,0 +1,71 @@
9965+/*
9966+ * Creation Date: <2001/04/01 00:44:40 samuel>
9967+ * Time-stamp: <2003/01/27 02:42:03 samuel>
9968+ *
9969+ * <performance.h>
9970+ *
9971+ * performance counters
9972+ *
9973+ * Copyright (C) 2001, 2002 Samuel Rydh (samuel@ibrium.se)
9974+ *
9975+ * This program is free software; you can redistribute it and/or
9976+ * modify it under the terms of the GNU General Public License
9977+ * as published by the Free Software Foundation
9978+ *
9979+ */
9980+
9981+#ifndef _H_PERFORMANCE
9982+#define _H_PERFORMANCE
9983+
9984+typedef struct {
9985+ char *name;
9986+ unsigned long *ctrptr;
9987+} perf_info_t;
9988+
9989+extern perf_info_t g_perf_info_table[];
9990+
9991+#if defined(PERFORMANCE_INFO) && !defined(PERFORMANCE_INFO_LIGHT)
9992+#define BUMP(x) do { extern int gPerf__##x; gPerf__##x++; } while(0)
9993+#define BUMP_N(x,n) do { extern int gPerf__##x; gPerf__##x+=(n); } while(0)
9994+#else
9995+#define BUMP(x) do {} while(0)
9996+#define BUMP_N(x,n) do {} while(0)
9997+#endif
9998+
9999+
10000+/************************************************************************/
10001+/* tick counters */
10002+/************************************************************************/
10003+
10004+#ifdef PERFORMANCE_INFO
10005+
10006+#define TICK_CNTR_PUSH( kv ) do { \
10007+ int ind = (kv)->num_acntrs; \
10008+ acc_counter_t *c = &(kv)->acntrs[ind]; \
10009+ if( ind < MAX_ACC_CNTR_DEPTH ) { \
10010+ c->subticks=0; \
10011+ (kv)->num_acntrs++; \
10012+ asm volatile( "mftb %0" : "=r" (c->stamp) : ); \
10013+ } \
10014+} while(0)
10015+
10016+#define TICK_CNTR_POP( kv, name ) do { \
10017+ int ind = (kv)->num_acntrs; \
10018+ ulong now, ticks; \
10019+ asm volatile( "mftb %0" : "=r" (now) : ); \
10020+ if( --ind >= 0 ) { \
10021+ acc_counter_t *c = &(kv)->acntrs[ind]; \
10022+ (kv)->num_acntrs = ind; \
10023+ ticks = now - c->stamp - c->subticks; \
10024+ BUMP_N( name##_ticks, ticks ); \
10025+ if( ind ) \
10026+ (kv)->acntrs[ind-1].subticks += ticks; \
10027+ } \
10028+} while(0)
10029+
10030+#else
10031+#define TICK_CNTR_PUSH( kv ) do {} while(0)
10032+#define TICK_CNTR_POP( kv, name ) do {} while(0)
10033+#endif
10034+
10035+#endif /* _H_PERFORMANCE */
10036--- /dev/null
10037+++ b/drivers/macintosh/mol/include/platform.h
10038@@ -0,0 +1,73 @@
10039+/*
10040+ * Creation Date: <2001/12/29 19:46:46 samuel>
10041+ * Time-stamp: <2004/02/07 16:51:57 samuel>
10042+ *
10043+ * <platform.h>
10044+ *
10045+ * Misc definitions needed on certain platforms
10046+ *
10047+ * Copyright (C) 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
10048+ *
10049+ * This program is free software; you can redistribute it and/or
10050+ * modify it under the terms of the GNU General Public License
10051+ * as published by the Free Software Foundation
10052+ *
10053+ */
10054+
10055+#ifndef _H_PLATFORM
10056+#define _H_PLATFORM
10057+
10058+#ifndef NULL
10059+#define NULL 0
10060+#endif /* NULL */
10061+
10062+typedef unsigned long long ullong;
10063+typedef long long llong;
10064+
10065+typedef signed char s8;
10066+typedef unsigned char u8;
10067+typedef signed short s16;
10068+typedef unsigned short u16;
10069+typedef signed int s32;
10070+typedef unsigned int u32;
10071+typedef signed long long s64;
10072+typedef unsigned long long u64;
10073+
10074+#define TO_ULLONG( hi, lo ) (((ullong)(hi)<< 32 ) | (lo) )
10075+#define TO_LLONG( hi, lo ) (((llong)(hi)<< 32 ) | (lo) )
10076+
10077+#ifndef TEMP_FAILURE_RETRY
10078+# define TEMP_FAILURE_RETRY(expression) \
10079+ (__extension__ \
10080+ ({ long int __result; \
10081+ do __result = (long int) (expression); \
10082+ while (__result == -1L && errno == EINTR); \
10083+ __result; }))
10084+#endif
10085+
10086+/*
10087+ * Allow us to mark functions as 'deprecated' and have gcc emit a nice
10088+ * warning for each use, in hopes of speeding the functions removal.
10089+ * Usage is:
10090+ * int __deprecated foo(void)
10091+ */
10092+#if __GNUC__ == 2 && __GNUC_MINOR__ < 96
10093+#define __builtin_expect(x, expected_value) (x)
10094+#endif
10095+
10096+#define likely(x) __builtin_expect((x),1)
10097+#define unlikely(x) __builtin_expect((x),0)
10098+
10099+#ifndef HAVE_CLEARENV
10100+static inline int clearenv( void ) { extern char **environ; environ=NULL; return 0; }
10101+#endif
10102+
10103+#ifdef __darwin__
10104+#define ARCH_STR "osx"
10105+#endif
10106+
10107+#ifdef __linux__
10108+#define ARCH_STR "linux"
10109+#endif
10110+
10111+#endif /* _H_PLATFORM */
10112--- /dev/null
10113+++ b/drivers/macintosh/mol/include/processor.h
10114@@ -0,0 +1,409 @@
10115+/*
10116+ * Creation Date: <2000/10/29 01:43:29 samuel>
10117+ * Time-stamp: <2003/07/27 22:37:49 samuel>
10118+ *
10119+ * <processor.h>
10120+ *
10121+ * Extract from <asm/processor.h>
10122+ *
10123+ *
10124+ * This program is free software; you can redistribute it and/or
10125+ * modify it under the terms of the GNU General Public License
10126+ * as published by the Free Software Foundation
10127+ *
10128+ */
10129+
10130+#ifndef _H_PROCESSOR
10131+#define _H_PROCESSOR
10132+
10133+
10134+#define PTE0_VSID(s) (((s)>>7) & 0xffffff)
10135+#define PTE0_V BIT(0)
10136+#define PTE0_H BIT(25)
10137+#define PTE0_API 0x3f
10138+
10139+#define PTE1_R BIT(23)
10140+#define PTE1_C BIT(24)
10141+#define PTE1_W BIT(25)
10142+#define PTE1_I BIT(26)
10143+#define PTE1_M BIT(27)
10144+#define PTE1_G BIT(28)
10145+#ifdef CONFIG_AMIGAONE
10146+/* Memory coherence locks up A1 compatible systems. */
10147+#define PTE1_WIMG (PTE1_W | PTE1_I | PTE1_G)
10148+#else
10149+#define PTE1_WIMG (PTE1_W | PTE1_I | PTE1_M | PTE1_G)
10150+#endif
10151+#define PTE1_PP 0x3
10152+#define PTE1_RPN (~0xfffUL)
10153+
10154+#define VSID_Ks BIT(1)
10155+#define VSID_Kp BIT(2)
10156+#define VSID_N BIT(3)
10157+
10158+
10159+
10160+#ifndef MSR_VEC
10161+
10162+#define MSR_VEC (1<<25) /* 6: Enable AltiVec */
10163+#define MSR_POW (1<<18) /* 13: Enable Power Management */
10164+#define MSR_TGPR (1<<17) /* 14: TLB Update registers in use */
10165+#define MSR_ILE (1<<16) /* 15: Interrupt Little Endian */
10166+#define MSR_EE (1<<15) /* 16: External Interrupt Enable */
10167+#define MSR_PR (1<<14) /* 17: Privilege Level */
10168+#define MSR_FP (1<<13) /* 18: Floating Point enable */
10169+#define MSR_ME (1<<12) /* 19: Machine Check Enable */
10170+#define MSR_FE0 (1<<11) /* 20: Floating Exception mode 0 */
10171+#define MSR_SE (1<<10) /* 21: Single Step */
10172+#define MSR_BE (1<<9) /* 22: Branch Trace */
10173+#define MSR_FE1 (1<<8) /* 23: Floating Exception mode 1 */
10174+#define MSR_IP (1<<6) /* 25: Exception prefix 0x000/0xFFF */
10175+#define MSR_IR (1<<5) /* 26: Instruction Relocate */
10176+#define MSR_DR (1<<4) /* 27: Data Relocate */
10177+#define MSR_PE (1<<2) /* 29: Performance Monitor Flag */
10178+#define MSR_RI (1<<1) /* 30: Recoverable Exception */
10179+#define MSR_LE (1<<0) /* 31: Little Endian */
10180+
10181+#endif /* MSR_VEC */
10182+
10183+#ifndef S_SPRG0
10184+
10185+#define NUM_SPRS 1024
10186+//#define S_XER 1
10187+#define S_RTCU_R 4 /* 601 RTC Upper/Lower (Reading) */
10188+#define S_RTCL_R 5
10189+//#define S_LR 8
10190+//#define S_CTR 9
10191+#define S_DSISR 18 /* Source Instruction Service Register */
10192+#define S_DAR 19 /* Data Address Register */
10193+#define S_RTCU_W 20 /* 601 RTC Upper/Lower (Writing) */
10194+#define S_RTCL_W 21
10195+#define S_DEC 22 /* Decrementer Register */
10196+#define S_SDR1 25 /* Table Search Description Register */
10197+#define S_SRR0 26 /* Save and Restore Register 0 */
10198+#define S_SRR1 27 /* Save and Restore Register 1 */
10199+#define S_VRSAVE 256 /* (AltiVec) Vector Register Save Register */
10200+#define S_TBRL 268 /* Time base Upper/Lower (Reading) */
10201+#define S_TBRU 269
10202+#define S_SPRG0 272 /* SPR General 0-3 */
10203+#define S_SPRG1 273
10204+#define S_SPRG2 274
10205+#define S_SPRG3 275
10206+#define S_SPRG4 276 /* SPR General 4-7 (7445/7455) */
10207+#define S_SPRG5 277
10208+#define S_SPRG6 278
10209+#define S_SPRG7 279
10210+#define S_EAR 282 /* External Access Register */
10211+#define S_TBWL 284 /* Time base Upper/Lower (Writing) */
10212+#define S_TBWU 285
10213+#define S_PVR 287 /* Processor Version Register */
10214+#define S_IBAT0U 528
10215+#define S_IBAT0L 529
10216+#define S_IBAT1U 530
10217+#define S_IBAT1L 531
10218+#define S_IBAT2U 532
10219+#define S_IBAT2L 533
10220+#define S_IBAT3U 534
10221+#define S_IBAT3L 535
10222+#define S_DBAT0U 536
10223+#define S_DBAT0L 537
10224+#define S_DBAT1U 538
10225+#define S_DBAT1L 539
10226+#define S_DBAT2U 540
10227+#define S_DBAT2L 541
10228+#define S_DBAT3U 542
10229+#define S_DBAT3L 543
10230+#define S_UMMCR2 928
10231+#define S_UPMC5 929 /* User Performance Monitor Counter Register */
10232+#define S_UPMC6 930
10233+#define S_UBAMR 935
10234+#define S_UMMCR0 936 /* User Monitor Mode Control Register */
10235+#define S_UPMC1 937
10236+#define S_UPMC2 938
10237+#define S_USIAR 939 /* User Sampled Instruction Address Register */
10238+#define S_UMMCR1 940
10239+#define S_UPMC3 941
10240+#define S_UPMC4 942 /* User Performance Monitor Counter Register 4 */
10241+#define S_USDAR 943 /* User Sampled Data Address Register */
10242+#define S_MMCR2 944 /* Monitor Mode Control Register */
10243+#define S_PMC5 945
10244+#define S_PMC6 946
10245+#define S_BAMR 951 /* Breakpoint Address Mask Register (74xx) */
10246+#define S_MMCR0 952 /* Monitor Mode Control Register 0 */
10247+#define S_PMC1 953 /* Performance Counter Register */
10248+#define S_PMC2 954
10249+#define S_SIAR 955 /* Sampled Instruction Address Register */
10250+#define S_MMCR1 956
10251+#define S_PMC3 957
10252+#define S_PMC4 958
10253+#define S_SDAR 959 /* Sampled Data Address Register */
10254+#define S_DMISS 976 /* 603 */
10255+#define S_DCMP 977 /* 603 */
10256+#define S_HASH1 978 /* 603 */
10257+#define S_HASH2 979 /* 603 */
10258+#define S_IMISS 980 /* 603 */
10259+#define S_TLBMISS 980 /* 7445/7455 */
10260+#define S_ICMP 981 /* 603 */
10261+#define S_PTEHI 981 /* 7445/7455 */
10262+#define S_RPA 982 /* 603 */
10263+#define S_PTELO 982 /* 7445/7455 */
10264+#define S_L3PM 983 /* L3 Private Memory Address Control Register */
10265+#define S_L3ITCR0 984 /* ??? */
10266+#define S_L3OHCR 1000 /* ??? */
10267+#define S_L3ITCR1 1001 /* ??? */
10268+#define S_L3ITCR2 1002 /* ??? */
10269+#define S_L3ITCR3 1003 /* ??? */
10270+#define S_HID0 1008 /* Hardware Implementation Registers */
10271+#define S_HID1 1009
10272+#define S_HID2 1010
10273+#define S_IABR S_HID2 /* HID2 - Instruction Address Breakpoint Register */
10274+#define S_ICTRL 1011 /* HID3 - Instruction Cache & Interrupt control reg */
10275+#define S_HID4 1012 /* HID4 - Instruction Address Compare 1 (?) */
10276+#define S_HID5 1013
10277+#define S_DABR S_HID5 /* HID5 - Data Address Breakpoint */
10278+#define S_MSSCR0 1014 /* HID6 - Memory Subsystem Control Register 0 */
10279+#define S_MSSCR1 1015 /* HID7 - Memory Subsystem Control Register 1 */
10280+#define S_LDSTCR 1016 /* HID8 - Load/Store Control Register */
10281+#define S_L2CR 1017 /* HID9 - Level 2 Cache Control Regsiter */
10282+#define S_L3CR 1018 /* HID10 - Level 3 Cache Control Regsiter (7450) */
10283+#define S_HID11 1019
10284+#define S_ICTC S_HID11 /* HID11 - Instruction Cache Throttling Control Reg */
10285+#define S_ICCR S_HID11 /* Instruction Cache Cacheability Reigster */
10286+#define S_THRM1 1020 /* HID12 - Thermal Management Register 1 */
10287+#define S_THRM2 1021 /* HID13 - Thermal Management Register 2 */
10288+#define S_THRM3 1022 /* HID14 - Thermal Management Register 3 */
10289+#define S_HID15 1023
10290+#define S_PIR S_HID15 /* HID15 - Processor Identification Register */
10291+
10292+#endif /* S_SPRG0 */
10293+
10294+/* the kernel might define these too... */
10295+#if !defined(__KERNEL__) || defined(__ASSEMBLY__)
10296+
10297+/* Floating Point Status and Control Register (FPSCR) Fields */
10298+#define FPSCR_FX 0x80000000 /* FPU exception summary */
10299+#define FPSCR_FEX 0x40000000 /* FPU enabled exception summary */
10300+#define FPSCR_VX 0x20000000 /* Invalid operation summary */
10301+#define FPSCR_OX 0x10000000 /* Overflow exception summary */
10302+#define FPSCR_UX 0x08000000 /* Underflow exception summary */
10303+#define FPSCR_ZX 0x04000000 /* Zero-devide exception summary */
10304+#define FPSCR_XX 0x02000000 /* Inexact exception summary */
10305+#define FPSCR_VXSNAN 0x01000000 /* Invalid op for SNaN */
10306+#define FPSCR_VXISI 0x00800000 /* Invalid op for Inv - Inv */
10307+#define FPSCR_VXIDI 0x00400000 /* Invalid op for Inv / Inv */
10308+#define FPSCR_VXZDZ 0x00200000 /* Invalid op for Zero / Zero */
10309+#define FPSCR_VXIMZ 0x00100000 /* Invalid op for Inv * Zero */
10310+#define FPSCR_VXVC 0x00080000 /* Invalid op for Compare */
10311+#define FPSCR_FR 0x00040000 /* Fraction rounded */
10312+#define FPSCR_FI 0x00020000 /* Fraction inexact */
10313+#define FPSCR_FPRF 0x0001f000 /* FPU Result Flags */
10314+#define FPSCR_FPCC 0x0000f000 /* FPU Condition Codes */
10315+#define FPSCR_VXSOFT 0x00000400 /* Invalid op for software request */
10316+#define FPSCR_VXSQRT 0x00000200 /* Invalid op for square root */
10317+#define FPSCR_VXCVI 0x00000100 /* Invalid op for integer convert */
10318+#define FPSCR_VE 0x00000080 /* Invalid op exception enable */
10319+#define FPSCR_OE 0x00000040 /* IEEE overflow exception enable */
10320+#define FPSCR_UE 0x00000020 /* IEEE underflow exception enable */
10321+#define FPSCR_ZE 0x00000010 /* IEEE zero divide exception enable */
10322+#define FPSCR_XE 0x00000008 /* FP inexact exception enable */
10323+#define FPSCR_NI 0x00000004 /* FPU non IEEE-Mode */
10324+#define FPSCR_RN 0x00000003 /* FPU rounding control */
10325+
10326+/* SPR_HID0 */
10327+#define HID0_EMCP (1<<31) /* Enable Machine Check pin */
10328+#define HID0_EBA (1<<29) /* Enable Bus Address Parity */
10329+#define HID0_EBD (1<<28) /* Enable Bus Data Parity */
10330+#define HID0_SBCLK (1<<27)
10331+#define HID0_EICE (1<<26)
10332+#define HID0_ECLK (1<<25)
10333+#define HID0_PAR (1<<24)
10334+#define HID0_DOZE (1<<23)
10335+#define HID0_NAP (1<<22)
10336+#define HID0_SLEEP (1<<21)
10337+#define HID0_DPM (1<<20)
10338+#define HID0_NHR (1<<16) /* Not Hard Reset */
10339+#define HID0_ICE (1<<15) /* Instruction Cache Enable */
10340+#define HID0_DCE (1<<14) /* Data Cache Enable */
10341+#define HID0_ILOCK (1<<13) /* Instruction Cache Lock */
10342+#define HID0_DLOCK (1<<12) /* Data Cache Lock */
10343+#define HID0_ICFI (1<<11) /* Instr. Cache Flash Invalidate */
10344+#define HID0_DCFI (1<<10) /* Data Cache Flash Invalidate */
10345+#define HID0_SPD (1<<9) /* Speculative disable */
10346+#define HID0_SGE (1<<7) /* Store Gathering Enable */
10347+#define HID0_SIED (1<<7) /* Serial Instr. Execution [Disable] */
10348+#define HID0_BTIC (1<<5) /* Branch Target Instruction Cache Enable */
10349+#define HID0_ABE (1<<3) /* Address Broadcast Enable */
10350+#define HID0_BHT (1<<2) /* Branch History Table Enable */
10351+#define HID0_BTCD (1<<1) /* Branch target cache disable */
10352+
10353+#define L2CR_L2E BIT(0) /* L2 enable */
10354+#define L2CR_L2PE BIT(1) /* L2 data parity generation and checking */
10355+#define L2CR_L2SIZ_512K BIT(2)
10356+#define L2CR_L2SIZ_256K BIT(3)
10357+#define L2CR_L2SIZ_1MB (BIT(2)|BIT(3))
10358+#define L2CR_L2CLK_1 BIT(6) /* L2 clock ration */
10359+#define L2CR_L2CLK_15 (BIT(6)*2)
10360+#define L2CR_L2CLK_2 (BIT(6)*4)
10361+#define L2CR_L2CLK_25 (BIT(6)*5)
10362+#define L2CR_L2CLK_3 (BIT(6)*6)
10363+#define L2CR_L2RAM_FT 0 /* flow-through (reg-buf) synchronous SRAM */
10364+#define L2CR_L2RAM_PB BIT(7) /* Piplined (reg-reg) synchronous burst SRAM */
10365+#define L2CR_L2RAM_PLW (BIT(7)|BIT(8)) /* Piplined (reg-reg) synchronous late-write */
10366+#define L2CR_L2DO BIT(9) /* L2 data-only */
10367+#define L2CR_L2I BIT(10) /* L2 global invalidate */
10368+#define L2CR_L2CTL BIT(11) /* L2 RAM control (ZZ enable, low-power mode) */
10369+#define L2CR_L2WT BIT(12) /* L2 write-through */
10370+#define L2CR_L2TS BIT(13) /* L2 test support */
10371+#define L2CR_L2OH_05 0 /* L2 output hold 0.5 nS */
10372+#define L2CR_L2OH_10 BIT(15) /* L2 output hold 1.0 nS */
10373+#define L2CR_L2SL BIT(16) /* L2 DLL slow (use if bus freq < 150 MHz) */
10374+#define L2CR_L2DF BIT(17) /* L2 differential clock */
10375+#define L2CR_L2BYP BIT(18) /* L2 DLL bypass */
10376+#define L2CR_L2IP BIT(31) /* L2 global invalidate in progress */
10377+
10378+/* SPR_THRM1 */
10379+#define THRM1_TIN (1 << 31)
10380+#define THRM1_TIV (1 << 30)
10381+#define THRM1_THRES(x) ((x&0x7f)<<23)
10382+#define THRM3_SITV(x) ((x&0x3fff)<<1)
10383+#define THRM1_TID (1<<2)
10384+#define THRM1_TIE (1<<1)
10385+#define THRM1_V (1<<0)
10386+
10387+/* SPR_THRM3 */
10388+#define THRM3_E (1<<0)
10389+
10390+/* Processor Version Numbers */
10391+
10392+#define PVR_VER(pvr) (((pvr) >> 16) & 0xFFFF) /* Version field */
10393+#define PVR_REV(pvr) (((pvr) >> 0) & 0xFFFF) /* Revison field */
10394+
10395+#define PVR_403GA 0x00200000
10396+#define PVR_403GB 0x00200100
10397+#define PVR_403GC 0x00200200
10398+#define PVR_403GCX 0x00201400
10399+#define PVR_405GP 0x40110000
10400+#define PVR_601 0x00010000
10401+#define PVR_602 0x00050000
10402+#define PVR_603 0x00030000
10403+#define PVR_603e 0x00060000
10404+#define PVR_603ev 0x00070000
10405+#define PVR_603r 0x00071000
10406+#define PVR_604 0x00040000
10407+#define PVR_604e 0x00090000
10408+#define PVR_604r 0x000A0000
10409+#define PVR_620 0x00140000
10410+#define PVR_740 0x00080000
10411+#define PVR_750 PVR_740
10412+#define PVR_740P 0x10080000
10413+#define PVR_750P PVR_740P
10414+#define PVR_821 0x00500000
10415+#define PVR_823 PVR_821
10416+#define PVR_850 PVR_821
10417+#define PVR_860 PVR_821
10418+#define PVR_7400 0x000C0000
10419+#define PVR_8240 0x00810100
10420+#define PVR_8260 PVR_8240
10421+
10422+/* Vector VSCR register */
10423+#define VSCR_NJ 0x10000
10424+#define VSCR_SAT 0x1
10425+
10426+#endif /* __KERNEL__ */
10427+
10428+
10429+#ifdef __ASSEMBLY__
10430+
10431+#define CTR S_CTR /* Counter Register */
10432+#define DAR S_DAR /* Data Address Register */
10433+#define DABR S_DABR /* Data Address Breakpoint Register */
10434+#define DBAT0L S_DBAT0L /* Data BAT 0 Lower Register */
10435+#define DBAT0U S_DBAT0U /* Data BAT 0 Upper Register */
10436+#define DBAT1L S_DBAT1L /* Data BAT 1 Lower Register */
10437+#define DBAT1U S_DBAT1U /* Data BAT 1 Upper Register */
10438+#define DBAT2L S_DBAT2L /* Data BAT 2 Lower Register */
10439+#define DBAT2U S_DBAT2U /* Data BAT 2 Upper Register */
10440+#define DBAT3L S_DBAT3L /* Data BAT 3 Lower Register */
10441+#define DBAT3U S_DBAT3U /* Data BAT 3 Upper Register */
10442+#define DCMP S_DCMP /* Data TLB Compare Register */
10443+#define DEC S_DEC /* Decrement Register */
10444+#define DMISS S_DMISS /* Data TLB Miss Register */
10445+#define DSISR S_DSISR /* Data Storage Interrupt Status Register */
10446+#define EAR S_EAR /* External Address Register */
10447+#define HASH1 S_HASH1 /* Primary Hash Address Register */
10448+#define HASH2 S_HASH2 /* Secondary Hash Address Register */
10449+#define HID0 S_HID0 /* Hardware Implementation Register 0 */
10450+#define HID1 S_HID1 /* Hardware Implementation Register 1 */
10451+#define IABR S_IABR /* Instruction Address Breakpoint Register */
10452+#define IBAT0L S_IBAT0L /* Instruction BAT 0 Lower Register */
10453+#define IBAT0U S_IBAT0U /* Instruction BAT 0 Upper Register */
10454+#define IBAT1L S_IBAT1L /* Instruction BAT 1 Lower Register */
10455+#define IBAT1U S_IBAT1U /* Instruction BAT 1 Upper Register */
10456+#define IBAT2L S_IBAT2L /* Instruction BAT 2 Lower Register */
10457+#define IBAT2U S_IBAT2U /* Instruction BAT 2 Upper Register */
10458+#define IBAT3L S_IBAT3L /* Instruction BAT 3 Lower Register */
10459+#define IBAT3U S_IBAT3U /* Instruction BAT 3 Upper Register */
10460+#define ICMP S_ICMP /* Instruction TLB Compare Register */
10461+#define IMISS S_IMISS /* Instruction TLB Miss Register */
10462+#define IMMR S_IMMR /* PPC 860/821 Internal Memory Map Register */
10463+#define L2CR S_L2CR /* PPC 750 L2 control register */
10464+#define PVR S_PVR /* Processor Version */
10465+#define RPA S_RPA /* Required Physical Address Register */
10466+#define SDR1 S_SDR1 /* MMU hash base register */
10467+#define SPR0 S_SPRG0 /* Supervisor Private Registers */
10468+#define SPR1 S_SPRG1
10469+#define SPR2 S_SPRG2
10470+#define SPR3 S_SPRG3
10471+#define SPRG0 S_SPRG0
10472+#define SPRG1 S_SPRG1
10473+#define SPRG2 S_SPRG2
10474+#define SPRG3 S_SPRG3
10475+#define SRR0 S_SRR0 /* Save and Restore Register 0 */
10476+#define SRR1 S_SRR1 /* Save and Restore Register 1 */
10477+#define TBRL S_STBRL /* Time Base Read Lower Register */
10478+#define TBRU S_TBRU /* Time Base Read Upper Register */
10479+#define TBWL S_TBWL /* Time Base Write Lower Register */
10480+#define TBWU S_TBWU /* Time Base Write Upper Register */
10481+#define ICTC S_ICTC
10482+#define THRM1 S_THRM1 /* Thermal Management Register 1 */
10483+#define THRM2 S_THRM2 /* Thermal Management Register 2 */
10484+#define THRM3 S_THRM3 /* Thermal Management Register 3 */
10485+#define SIAR S_SIAR
10486+#define SDAR S_SDAR
10487+#define XER 1
10488+
10489+#define SR0 0 /* Segment registers */
10490+#define SR1 1
10491+#define SR2 2
10492+#define SR3 3
10493+#define SR4 4
10494+#define SR5 5
10495+#define SR6 6
10496+#define SR7 7
10497+#define SR8 8
10498+#define SR9 9
10499+#define SR10 10
10500+#define SR11 11
10501+#define SR12 12
10502+#define SR13 13
10503+#define SR14 14
10504+#define SR15 15
10505+
10506+#endif /* __ASSEMBLY__ */
10507+
10508+/* opcode macros */
10509+
10510+#define OPCODE_PRIM(n) ( ((ulong)(n)) >> 26 )
10511+#define OPCODE_EXT(n) ( (((ulong)(n)) >> 1) & 0x3ff )
10512+#define OPCODE(op,op_ext) ( ((op)<<10) + op_ext )
10513+
10514+#define B1(n) ( (((ulong)(n)) >> 21) & 0x1f )
10515+#define B2(n) ( (((ulong)(n)) >> 16) & 0x1f )
10516+#define B3(n) ( (((ulong)(n)) >> 11) & 0x1f )
10517+
10518+#define BD(n) ((ulong)((n) & 0x7fff) + (((n) & 0x8000) ? (ulong)0xffff8000 : 0))
10519+
10520+#define SPRNUM_FLIP( v ) ( (((v)>>5) & 0x1f) | (((v)<<5) & 0x3e0) )
10521+
10522+#endif /* _H_PROCESSOR */
10523+
10524--- /dev/null
10525+++ b/drivers/macintosh/mol/include/prom.h
10526@@ -0,0 +1,46 @@
10527+/*
10528+ * Creation Date: <1999/02/22 23:22:17 samuel>
10529+ * Time-stamp: <2003/06/02 16:17:36 samuel>
10530+ *
10531+ * <prom.h>
10532+ *
10533+ * OF device tree structs
10534+ *
10535+ * Copyright (C) 1999, 2000, 2002, 2003 Samuel Rydh (samuel@ibrium.se)
10536+ *
10537+ * This program is free software; you can redistribute it and/or
10538+ * modify it under the terms of the GNU General Public License
10539+ * as published by the Free Software Foundation
10540+ *
10541+ */
10542+
10543+#ifndef _H_PROM
10544+#define _H_PROM
10545+
10546+typedef void *p_phandle_t;
10547+
10548+typedef struct {
10549+ int nirq;
10550+ int irq[5];
10551+ unsigned long controller[5];
10552+} irq_info_t;
10553+
10554+typedef struct p_property {
10555+ char *name;
10556+ int length;
10557+ unsigned char *value;
10558+ struct p_property *next;
10559+} p_property_t;
10560+
10561+typedef struct mol_device_node {
10562+ p_phandle_t node;
10563+ struct p_property *properties;
10564+ struct mol_device_node *parent;
10565+ struct mol_device_node *child;
10566+ struct mol_device_node *sibling;
10567+ struct mol_device_node *next; /* next device of same type */
10568+ struct mol_device_node *allnext; /* next in list of all nodes */
10569+ char *unit_string;
10570+} mol_device_node_t;
10571+
10572+#endif /* _H_PROM */
10573--- /dev/null
10574+++ b/drivers/macintosh/mol/include/rvec.h
10575@@ -0,0 +1,147 @@
10576+/*
10577+ * Creation Date: <2001/01/26 21:33:45 samuel>
10578+ * Time-stamp: <2004/02/08 20:08:20 samuel>
10579+ *
10580+ * <return_vectors.h>
10581+ *
10582+ * Possible mac-return vectors (see mainloop.S)
10583+ *
10584+ * Copyright (C) 2000, 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
10585+ *
10586+ * This program is free software; you can redistribute it and/or
10587+ * modify it under the terms of the GNU General Public License
10588+ * as published by the Free Software Foundation
10589+ *
10590+ */
10591+
10592+#ifndef _H_RVEC
10593+#define _H_RVEC
10594+
10595+
10596+/* ---------------------------------------------------------------------------- */
10597+
10598+#define NRVECS_LOG2 6
10599+#define NUM_RVECS 64 /* = 2 ^ NRVECS_LOG2 */
10600+#define RVEC_MASK (NUM_RVECS-1)
10601+
10602+/* ---------------------------------------------------------------------------- */
10603+
10604+#define RVEC_NOP 0 /* Must be zero */
10605+#ifdef __darwin__
10606+#define RVEC_CALL_KERNEL 1 /* call kernel */
10607+#endif
10608+#define RVEC_ENABLE_FPU 3 /* Load up FPU */
10609+
10610+#define RVEC_TRACE_TRAP 6
10611+#define RVEC_ISI_TRAP 7 /* r4=nip, r5=srr1 */
10612+#define RVEC_DSI_TRAP 8 /* r4=dar, r5=srr1 */
10613+#define RVEC_ALIGNMENT_TRAP 9 /* r4=dar, r5=srr1 */
10614+#ifdef EMULATE_603
10615+#define RVEC_DMISS_LOAD_TRAP 10
10616+#define RVEC_DMISS_STORE_TRAP 11
10617+#define RVEC_IMISS_TRAP 12
10618+#endif
10619+
10620+#define RVEC_SPR_READ 13 /* r4=spr#, r5=gprnum */
10621+#define RVEC_SPR_WRITE 14 /* r4=spr#, r5=value */
10622+#define RVEC_PRIV_INST 15 /* r4=opcode */
10623+#define RVEC_ILLEGAL_INST 16 /* r4=opcode */
10624+
10625+#define RVEC_UNUSUAL_PROGRAM_EXCEP 17 /* r4=opcode, r5=srr1 */
10626+
10627+#define RVEC_ALTIVEC_UNAVAIL_TRAP 18
10628+#define RVEC_ALTIVEC_ASSIST 19 /* r4=srr1 */
10629+#define RVEC_ENABLE_ALTIVEC 20
10630+
10631+#define RVEC_EXIT 21
10632+/* 22 was RVEC_INTERRUPT */
10633+#define RVEC_OSI_SYSCALL 23
10634+#define RVEC_TIMER 24
10635+
10636+#define RVEC_IO_READ 25
10637+#define RVEC_IO_WRITE 26
10638+
10639+#define RVEC_MSR_POW 27 /* (MSR_POW 0->1) => doze */
10640+
10641+/* error/debug */
10642+#define RVEC_UNUSUAL_DSISR_BITS 28 /* dar, dsisr (bit 0,5,9 or 11 was set) */
10643+#define RVEC_MMU_IO_SEG_ACCESS 29 /* IO segment access (more or less unused) */
10644+#define RVEC_INTERNAL_ERROR 30
10645+#define RVEC_DEBUGGER 31
10646+#define RVEC_BREAK 32 /* r4 = break_flag */
10647+#define RVEC_BAD_NIP 33 /* r4 = phys_nip */
10648+#define RVEC_OUT_OF_MEMORY 34 /* fatal out of memory... */
10649+
10650+#define RVEC_CHECK_IRQS 35 /* check interrupts */
10651+
10652+
10653+/************************************************************************/
10654+/* MOL kernel/emulator switch magic */
10655+/************************************************************************/
10656+
10657+/* magic to be loaded into r4/r5 before the illegal instruction is issued */
10658+#define MOL_ENTRY_R4_MAGIC 0x7ba5
10659+#define MOL_INITIALIZE_FLAG 0x8000
10660+#define MOL_KERNEL_ENTRY_MAGIC mfmsr r0 /* any privileged instruction will do */
10661+
10662+
10663+/************************************************************************/
10664+/* Kernel definitions */
10665+/************************************************************************/
10666+
10667+#if defined(__KERNEL__) && !defined( __ASSEMBLY__ )
10668+
10669+#define RVEC_RETURN_1( mregsptr, rvec, arg1 ) \
10670+ ({ (mregsptr)->rvec_param[0] = (ulong)(arg1); \
10671+ return rvec; })
10672+
10673+#define RVEC_RETURN_2( mregsptr, rvec, arg1, arg2 ) \
10674+ ({ (mregsptr)->rvec_param[0] = (ulong)(arg1); \
10675+ (mregsptr)->rvec_param[1] = (ulong)(arg2); \
10676+ return rvec; })
10677+
10678+#define RVEC_RETURN_3( mregsptr, rvec, arg1, arg2, arg3 ) \
10679+ ({ (mregsptr)->rvec_param[0] = (ulong)(arg1); \
10680+ (mregsptr)->rvec_param[1] = (ulong)(arg2); \
10681+ (mregsptr)->rvec_param[2] = (ulong)(arg3); \
10682+ return rvec; })
10683+
10684+#endif /* !__ASSEMBLY__ && __KERNEL__ */
10685+
10686+
10687+/************************************************************************/
10688+/* userspace definitions */
10689+/************************************************************************/
10690+
10691+#if !defined(__KERNEL__) || defined(__MPC107__)
10692+
10693+#if !defined(__ASSEMBLY__)
10694+#if !defined(__KERNEL__)
10695+
10696+typedef struct {
10697+ int vnum;
10698+ void *vector;
10699+ const char *name;
10700+} rvec_entry_t;
10701+
10702+extern void rvec_init( void );
10703+extern void rvec_cleanup( void );
10704+extern void set_rvector( uint vnum, void *vector, const char *vector_name );
10705+extern void set_rvecs( rvec_entry_t *table, int tablesize );
10706+#endif
10707+
10708+/* this struct is private to rvec.c/mainloop.S (offsets are HARDCODED) */
10709+typedef struct {
10710+ int (*rvec)( int rvec /*, arguments */ );
10711+ int dbg_count;
10712+ const char *name;
10713+ int filler;
10714+} priv_rvec_entry_t;
10715+#endif /* __ASSEMBLY__ */
10716+
10717+#define RVEC_ESIZE_LOG2 4 /* 2^n = sizeof(priv_rvec_entry_t) */
10718+#define RVEC_ESIZE 16 /* sizeof(priv_rvec_entry_t) */
10719+
10720+#endif /* __KERNEL__ || __MPC107__ */
10721+
10722+#endif /* _H_RVEC */
10723--- /dev/null
10724+++ b/drivers/macintosh/mol/include/skiplist.h
10725@@ -0,0 +1,87 @@
10726+/*
10727+ * Creation Date: <2003/03/03 22:59:04 samuel>
10728+ * Time-stamp: <2004/02/21 12:17:38 samuel>
10729+ *
10730+ * <skiplist.h>
10731+ *
10732+ * Skiplist implementation
10733+ *
10734+ * Copyright (C) 2003, 2004 Samuel Rydh (samuel@ibrium.se)
10735+ *
10736+ * This program is free software; you can redistribute it and/or
10737+ * modify it under the terms of the GNU General Public License
10738+ * as published by the Free Software Foundation
10739+ *
10740+ */
10741+
10742+#ifndef _H_SKIPLIST
10743+#define _H_SKIPLIST
10744+
10745+#define SKIPLIST_MAX_HEIGHT 16
10746+
10747+typedef struct skiplist_el skiplist_el_t;
10748+
10749+typedef struct {
10750+#ifdef __darwin__
10751+ ulong next_phys; /* for usage from assembly */
10752+#endif
10753+ skiplist_el_t *next;
10754+} skiplist_level_t;
10755+
10756+/* data (of datasize) is stored before the skiplist_el */
10757+typedef struct skiplist_el {
10758+ int key;
10759+ skiplist_level_t level[1]; /* level 0 */
10760+ /* level 1..n are optionally stored here */
10761+} *skiplist_iter_t;
10762+
10763+typedef struct {
10764+ int nel;
10765+ int slevel; /* start level */
10766+ int datasize; /* size of data (stored before each key) */
10767+
10768+ skiplist_level_t root[SKIPLIST_MAX_HEIGHT];
10769+ skiplist_el_t nil_el;
10770+
10771+ skiplist_level_t freelist; /* key = level, linked list in next[0] */
10772+} skiplist_t;
10773+
10774+static inline int
10775+skiplist_getnext( skiplist_t *sl, skiplist_iter_t *iterator, char **data )
10776+{
10777+ skiplist_el_t *el = *iterator;
10778+ *data = (char*)el - sl->datasize;
10779+ *iterator = el->level[0].next;
10780+ return el != &sl->nil_el;
10781+}
10782+
10783+static inline int
10784+skiplist_iter_getkey( skiplist_t *sl, char *data )
10785+{
10786+ return ((skiplist_el_t*)(data + sl->datasize))->key;
10787+}
10788+
10789+static inline skiplist_iter_t
10790+skiplist_iterate( skiplist_t *sl )
10791+{
10792+ return sl->root[0].next;
10793+}
10794+
10795+static inline int
10796+skiplist_needalloc( skiplist_t *sl )
10797+{
10798+ return !sl->freelist.next;
10799+}
10800+
10801+typedef void (*skiplist_el_callback)( char *data, int ind, int n, void *usr1, void *usr2 );
10802+
10803+extern void skiplist_init( skiplist_t *sl, int datasize );
10804+extern int skiplist_prealloc( skiplist_t *sl, char *buf, unsigned int size,
10805+ skiplist_el_callback callback, void *usr1, void *usr2 );
10806+
10807+extern char *skiplist_insert( skiplist_t *sl, int key );
10808+extern char *skiplist_delete( skiplist_t *sl, int key );
10809+extern char *skiplist_lookup( skiplist_t *sl, int key );
10810+
10811+
10812+#endif /* _H_SKIPLIST */
10813--- /dev/null
10814+++ b/drivers/macintosh/mol/include/tlbie.h
10815@@ -0,0 +1,102 @@
10816+/*
10817+ * Creation Date: <2003/05/27 16:56:10 samuel>
10818+ * Time-stamp: <2003/08/16 16:55:31 samuel>
10819+ *
10820+ * <tlbie.h>
10821+ *
10822+ * tlbie and PTE operations
10823+ *
10824+ * Copyright (C) 2003 Samuel Rydh (samuel@ibrium.se)
10825+ *
10826+ * This program is free software; you can redistribute it and/or
10827+ * modify it under the terms of the GNU General Public License
10828+ * version 2
10829+ *
10830+ */
10831+
10832+#ifndef _H_TLBIE
10833+#define _H_TLBIE
10834+
10835+
10836+#ifdef CONFIG_SMP
10837+extern void (*xx_tlbie_lowmem)( void /* special */ );
10838+extern void (*xx_store_pte_lowmem)( void /* special */ );
10839+extern int compat_hash_table_lock;
10840+
10841+static inline void
10842+__tlbie( int ea )
10843+{
10844+ register ulong _ea __asm__ ("r3");
10845+ register ulong _lock __asm__ ("r7");
10846+ register ulong _func __asm__ ("r9");
10847+
10848+ _func = (ulong)xx_tlbie_lowmem;
10849+ _lock = (ulong)&compat_hash_table_lock;
10850+ _ea = ea;
10851+
10852+ asm volatile (
10853+ "mtctr 9 \n"
10854+ "li 8,0x1235 \n" /* lock value */
10855+ "mfmsr 10 \n"
10856+ "rlwinm 0,10,0,17,15 \n" /* clear MSR_EE */
10857+ "mtmsr 0 \n"
10858+ "bctrl \n" /* modifies r0 */
10859+ "mtmsr 10 \n"
10860+ :
10861+ : "r" (_ea), "r" (_lock), "r" (_func)
10862+ : "ctr", "lr", "cc", "r8", "r0", "r10"
10863+ );
10864+}
10865+
10866+static inline void
10867+__store_PTE( int ea, unsigned long *slot, int pte0, int pte1 )
10868+{
10869+ register ulong _ea __asm__ ("r3");
10870+ register ulong _pte_slot __asm__ ("r4");
10871+ register ulong _pte0 __asm__ ("r5");
10872+ register ulong _pte1 __asm__ ("r6");
10873+ register ulong _lock __asm__ ("r7");
10874+ register ulong _func __asm__ ("r9");
10875+
10876+ _func = (ulong)xx_store_pte_lowmem;
10877+ _ea = ea;
10878+ _pte_slot = (ulong)slot;
10879+ _pte0 = pte0;
10880+ _pte1 = pte1;
10881+ _lock = (ulong)&compat_hash_table_lock;
10882+
10883+ asm volatile (
10884+ "mtctr 9 \n"
10885+ "li 8,0x1234 \n" /* lock value */
10886+ "mfmsr 10 \n"
10887+ "rlwinm 0,10,0,17,15 \n" /* clear MSR_EE */
10888+ "mtmsr 0 \n"
10889+ "bctrl \n" /* modifies r0 */
10890+ "mtmsr 10 \n"
10891+ :
10892+ : "r" (_ea), "r" (_pte_slot), "r" (_pte0), "r" (_pte1), "r" (_lock), "r" (_func)
10893+ : "ctr", "lr", "cc", "r0", "r8", "r10"
10894+ );
10895+}
10896+
10897+#else /* CONFIG_SMP */
10898+extern void (*xx_store_pte_lowmem)( unsigned long *slot, int pte0, int pte1 );
10899+
10900+static inline void __tlbie( int ea ) {
10901+ asm volatile ("tlbie %0" : : "r"(ea));
10902+}
10903+
10904+static inline void
10905+__store_PTE( int ea, unsigned long *slot, int pte0, int pte1 )
10906+{
10907+ ulong flags;
10908+ local_irq_save(flags);
10909+ (*xx_store_pte_lowmem)( slot, pte0, pte1 );
10910+ local_irq_restore(flags);
10911+ __tlbie( ea );
10912+}
10913+
10914+#endif /* CONFIG_SMP */
10915+
10916+
10917+#endif /* _H_TLBIE */
10918--- /dev/null
10919+++ b/drivers/macintosh/mol/include/uaccess.h
10920@@ -0,0 +1,36 @@
10921+/*
10922+ * Creation Date: <2004/02/01 20:02:11 samuel>
10923+ * Time-stamp: <2004/02/01 20:02:11 samuel>
10924+ *
10925+ * <uaccess.h>
10926+ *
10927+ *
10928+ *
10929+ * Copyright (C) 2004 Samuel Rydh (samuel@ibrium.se)
10930+ *
10931+ * This program is free software; you can redistribute it and/or
10932+ * modify it under the terms of the GNU General Public License
10933+ * version 2
10934+ *
10935+ */
10936+
10937+#ifndef _H_UACCESS
10938+#define _H_UACCESS
10939+
10940+
10941+static inline unsigned int copy_to_user_mol( void *to, const void *from, ulong len ) {
10942+ return copy_to_user( to, from, len );
10943+}
10944+static inline unsigned int copy_from_user_mol( void *to, const void *from, ulong len ) {
10945+ return copy_from_user( to, from, len );
10946+}
10947+
10948+static inline unsigned int copy_int_to_user( int *to, int val ) {
10949+ return copy_to_user_mol( to, &val, sizeof(int) );
10950+}
10951+static inline unsigned int copy_int_from_user( int *retint, int *userptr ) {
10952+ return copy_from_user_mol( retint, userptr, sizeof(int) );
10953+}
10954+
10955+
10956+#endif /* _H_UACCESS */
10957--- /dev/null
10958+++ b/drivers/macintosh/mol/include/vector.h
10959@@ -0,0 +1,189 @@
10960+/*
10961+ * Creation Date: <2003/05/26 00:00:28 samuel>
10962+ * Time-stamp: <2004/03/07 14:44:50 samuel>
10963+ *
10964+ * <vector.h>
10965+ *
10966+ * Vector hooks
10967+ *
10968+ * Copyright (C) 2003, 2004 Samuel Rydh (samuel@ibrium.se)
10969+ *
10970+ * This program is free software; you can redistribute it and/or
10971+ * modify it under the terms of the GNU General Public License
10972+ * version 2
10973+ *
10974+ */
10975+
10976+#ifndef _H_VECTOR
10977+#define _H_VECTOR
10978+
10979+#define MOL_SPRG2_MAGIC 0x1779
10980+
10981+#ifdef __MPC107__
10982+#include "mpcvector.h"
10983+#else
10984+
10985+#define PERFMON_VECTOR 0xf00
10986+
10987+
10988+/************************************************************************/
10989+/* Vector entry point definitions */
10990+/************************************************************************/
10991+
10992+/*
10993+ * This code uses the dynamic linkage/action symbol functionality of
10994+ * the MOL kernel loader to automatically install the hooks. Refer to
10995+ * hook.c for the actual implementation.
10996+ */
10997+
10998+/* Description of ACTION_RELOC_HOOK:
10999+ *
11000+ * .long ACTION_RELOC_HOOK
11001+ * .long vector
11002+ * .long #bytes to copy to lowmem
11003+ * .long offset to vret function
11004+ * -- offsets are calculated from here --
11005+ */
11006+
11007+mDEFINE(VECTOR_HOOK, [v], [
11008+ balign_32
11009+ ACTION_PB( ACTION_RELOC_HOOK )
11010+ .long _v
11011+ .long vhook_end_[]_v - vhook_[]_v
11012+ .long vret_[]_v - vhook_[]_v
11013+vhook_[]_v:
11014+ mtsprg_a0 r3
11015+ addis r3,0,0 /* [1] hook address inserted */
11016+ mtsprg_a1 r1
11017+ ori r3,r3,0 /* [3] at module initialization */
11018+ mfctr r1
11019+ mtctr r3
11020+ bctr
11021+
11022+vret_[]_v:
11023+ nop /* overwritten instruction is inserted here */
11024+ ba _v + 0x4
11025+vhook_end_[]_v:
11026+
11027+ .text
11028+ /* entrypoint */
11029+])
11030+
11031+/* these macros are to be used from the not_mol vector hook */
11032+#define CONTINUE_TRAP( v ) \
11033+ mfsprg_a0 r3 ; \
11034+ fix_sprg2 /**/ R1 /* sprg2 == sprg_a0 */ ; \
11035+ mfsprg_a1 r1 ; \
11036+ ACTION_1( ACTION_VRET, v ) /* ba vret_xxx */
11037+
11038+#define ABORT_TRAP( dummy_v ) \
11039+ mfsprg_a0 r3 ; \
11040+ fix_sprg2 /**/ R1 /* sprg2 == sprg_a0 */ ; \
11041+ mfsprg_a1 r1 ; \
11042+ rfi
11043+
11044+/* SPRG0,1 = saved r3,r1, r1 = saved lr */
11045+mDEFINE(VECTOR_, [v, dummy_str, secondary, not_mol_label], [
11046+
11047+not_mol_[]_v:
11048+ mtcr r3
11049+ CONTINUE_TRAP( _v )
11050+
11051+secondary_int_[]_v:
11052+ li r3,_v
11053+ b _secondary
11054+
11055+ VECTOR_HOOK( _v )
11056+
11057+ /* entrypoint */
11058+ mtctr r1
11059+ mfcr r3
11060+ mfsprg_a2 r1
11061+ cmpwi r1,MOL_SPRG2_MAGIC
11062+ bne- _not_mol_label
11063+soft_603_entry_[]_v:
11064+ mfsrr1 r1
11065+ andi. r1,r1,MSR_PR /* MSR_PR set? */
11066+ mfsprg_a3 r1
11067+ beq- secondary_int_[]_v /* if not, take a secondary trap? */
11068+])
11069+
11070+#define VECTOR(v, dummy_str, secondary) \
11071+ VECTOR_(v, dummy_str, secondary, not_mol_##v )
11072+
11073+/* this macro takes an exception from mac mode (call save_middle_regs first) */
11074+#define TAKE_EXCEPTION( v ) \
11075+ bl take_exception ; \
11076+ ACTION_1( ACTION_VRET, v )
11077+
11078+/* no need to relocate the 0xf00 trap */
11079+#define PERFMON_VECTOR_RELOCATION( newvec )
11080+
11081+
11082+/************************************************************************/
11083+/* 603 vector HOOKs (r0-r3, cr0 saved by hardware) */
11084+/************************************************************************/
11085+
11086+mDEFINE(VECTOR_603, [v, dummy_str], [
11087+ balign_32
11088+ ACTION_PB( ACTION_RELOC_HOOK )
11089+ .long _v
11090+ .long vhook_end_[]_v - vhook_[]_v
11091+ .long vret_[]_v - vhook_[]_v
11092+vhook_[]_v:
11093+ mfsprg_a2 r1
11094+ addis r3,0,0 /* [1] hook address inserted */
11095+ cmpwi r1,MOL_SPRG2_MAGIC
11096+ ori r3,r3,0 /* [3] at module initialization */
11097+ bne vret_[]_v
11098+ mfctr r0
11099+ mtctr r3
11100+ bctr
11101+
11102+vret_[]_v:
11103+ nop /* overwritten instruction is inserted here */
11104+ ba _v + 0x4
11105+vhook_end_[]_v:
11106+
11107+ .text
11108+ /* entrypoint */
11109+])
11110+
11111+
11112+/* all register are assumed to be unmodified */
11113+mDEFINE(SOFT_VECTOR_ENTRY_603, [v], [
11114+ mtsprg_a0 r3
11115+ mtsprg_a1 r1
11116+ mfcr r3
11117+ b soft_603_entry_[]_v
11118+])
11119+
11120+
11121+/************************************************************************/
11122+/* FUNCTION_HOOK */
11123+/************************************************************************/
11124+
11125+mDEFINE(FHOOK, [symind], [
11126+ ACTION_PB( ACTION_HOOK_FUNCTION )
11127+ .long _symind
11128+ .long fhook_end_[]_symind - fhook_[]_symind
11129+ .long fret_[]_symind - fhook_[]_symind
11130+fhook_[]_symind:
11131+ mflr r10
11132+ addis r9,0,0 /* [1] address inserted */
11133+ ori r9,r9,0 /* [2] at runtime */
11134+ mtctr r9
11135+ bctrl
11136+ mtlr r10
11137+fret_[]_symind:
11138+ nop /* overwritten instruction is inserted here */
11139+ nop /* return (through a relative branch) */
11140+fhook_end_[]_symind:
11141+
11142+ .text
11143+ /* hook goes here */
11144+])
11145+
11146+
11147+#endif /* MOLMPC */
11148+#endif /* _H_VECTOR */
11149--- /dev/null
11150+++ b/drivers/macintosh/mol/include/version.h
11151@@ -0,0 +1,11 @@
11152+
11153+#ifndef _H_VERSION
11154+#define _H_VERSION
11155+
11156+#include "molversion.h"
11157+
11158+#define MOL_VERSION ((MOL_MAJOR_VERSION << 16) \
11159+ + (MOL_MINOR_VERSION << 8) \
11160+ + MOL_PATCHLEVEL )
11161+
11162+#endif /* _H_VERSION */
11163--- /dev/null
11164+++ b/drivers/macintosh/mol/include/weaksym.h
11165@@ -0,0 +1,39 @@
11166+/*
11167+ * Creation Date: <2001/08/02 23:53:57 samuel>
11168+ * Time-stamp: <2001/08/03 00:30:23 samuel>
11169+ *
11170+ * <weak.h>
11171+ *
11172+ * Support of weak symbols (extract, stolen from glibc)
11173+ *
11174+ * This program is free software; you can redistribute it and/or
11175+ * modify it under the terms of the GNU General Public License
11176+ * as published by the Free Software Foundation
11177+ *
11178+ */
11179+
11180+#ifndef _H_WEAKSYM
11181+#define _H_WEAKSYM
11182+
11183+
11184+/* Define ALIASNAME as a strong alias for NAME. */
11185+#define strong_alias(name, aliasname) _strong_alias(name, aliasname)
11186+#define _strong_alias(name, aliasname) \
11187+ extern __typeof (name) aliasname __attribute__ ((alias (#name)));
11188+
11189+/* This comes between the return type and function name in
11190+ a function definition to make that definition weak. */
11191+#define weak_function __attribute__ ((weak))
11192+#define weak_const_function __attribute__ ((weak, __const__))
11193+
11194+/* Define ALIASNAME as a weak alias for NAME. */
11195+#define weak_alias(name, aliasname) _weak_alias (name, aliasname)
11196+#define _weak_alias(name, aliasname) \
11197+ extern __typeof (name) aliasname __attribute__ ((weak, alias (#name)));
11198+
11199+/* Declare SYMBOL as weak undefined symbol (resolved to 0 if not defined). */
11200+#define weak_extern(symbol) _weak_extern (symbol)
11201+# define _weak_extern(symbol) asm (".weak " #symbol);
11202+
11203+
11204+#endif /* _H_WEAKSYM */
11205--- /dev/null
11206+++ b/drivers/macintosh/mol/init.c
11207@@ -0,0 +1,191 @@
11208+/*
11209+ * Creation Date: <2002/01/13 20:45:37 samuel>
11210+ * Time-stamp: <2004/02/14 14:01:09 samuel>
11211+ *
11212+ * <init.c>
11213+ *
11214+ * Kernel module initialization
11215+ *
11216+ * Copyright (C) 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
11217+ *
11218+ * This program is free software; you can redistribute it and/or
11219+ * modify it under the terms of the GNU General Public License
11220+ * as published by the Free Software Foundation
11221+ *
11222+ */
11223+
11224+#include "archinclude.h"
11225+#include "alloc.h"
11226+#include "kernel_vars.h"
11227+#include "misc.h"
11228+#include "mmu.h"
11229+#include "asmfuncs.h"
11230+#include "performance.h"
11231+#include "mol-ioctl.h"
11232+#include "version.h"
11233+#include "hash.h"
11234+
11235+/* globals */
11236+session_table_t *g_sesstab;
11237+int g_num_sessions;
11238+
11239+
11240+/************************************************************************/
11241+/* init/cleanup kernel module */
11242+/************************************************************************/
11243+
11244+int
11245+common_init( void )
11246+{
11247+ if( init_hash() )
11248+ return 1;
11249+
11250+ if( !(g_sesstab=kmalloc_cont_mol(sizeof(*g_sesstab))) ) {
11251+ cleanup_hash();
11252+ return 1;
11253+ }
11254+
11255+ memset( g_sesstab, 0, sizeof(*g_sesstab) );
11256+ init_MUTEX_mol( &g_sesstab->lock );
11257+
11258+ if( arch_common_init() ) {
11259+ free_MUTEX_mol( &g_sesstab->lock );
11260+ kfree_cont_mol( g_sesstab );
11261+ cleanup_hash();
11262+ return 1;
11263+ }
11264+ return 0;
11265+}
11266+
11267+void
11268+common_cleanup( void )
11269+{
11270+ arch_common_cleanup();
11271+
11272+ free_MUTEX_mol( &g_sesstab->lock );
11273+ kfree_cont_mol( g_sesstab );
11274+ g_sesstab = NULL;
11275+
11276+ cleanup_hash();
11277+}
11278+
11279+
11280+/************************************************************************/
11281+/* initialize / destroy session */
11282+/************************************************************************/
11283+
11284+static int
11285+initialize_session_( uint index )
11286+{
11287+ kernel_vars_t *kv;
11288+ ulong kv_phys;
11289+
11290+ if( g_sesstab->magic == 1 )
11291+ return -EMOLSECURITY;
11292+
11293+ /* printk("initialize_session\n" ); */
11294+ if( g_sesstab->kvars[index] )
11295+ return -EMOLINUSE;
11296+
11297+ if( !g_num_sessions && perform_actions() )
11298+ return -EMOLGENERAL;
11299+
11300+ if( !(kv=alloc_kvar_pages()) )
11301+ goto error;
11302+
11303+ memset( kv, 0, NUM_KVARS_PAGES * 0x1000 );
11304+ kv->session_index = index;
11305+ kv->kvars_virt = kv;
11306+ kv_phys = tophys_mol(kv);
11307+ kv->kvars_tophys_offs = kv_phys - (ulong)kv;
11308+
11309+ if( init_mmu(kv) )
11310+ goto error;
11311+
11312+ init_host_irqs(kv);
11313+ initialize_spr_table( kv );
11314+
11315+ msr_altered( kv );
11316+
11317+ g_num_sessions++;
11318+
11319+ g_sesstab->kvars_ph[index] = kv_phys;
11320+ g_sesstab->kvars[index] = kv;
11321+
11322+ return 0;
11323+ error:
11324+ if( !g_num_sessions )
11325+ cleanup_actions();
11326+ if( kv )
11327+ free_kvar_pages( kv );
11328+ return -EMOLGENERAL;
11329+}
11330+
11331+int
11332+initialize_session( uint index )
11333+{
11334+ int ret;
11335+ if( index >= MAX_NUM_SESSIONS )
11336+ return -EMOLINVAL;
11337+
11338+ SESSION_LOCK;
11339+ ret = initialize_session_( index );
11340+ SESSION_UNLOCK;
11341+
11342+ return ret;
11343+}
11344+
11345+void
11346+destroy_session( uint index )
11347+{
11348+ kernel_vars_t *kv;
11349+
11350+ if( index >= MAX_NUM_SESSIONS )
11351+ return;
11352+
11353+ if( g_sesstab->magic == 1 ) {
11354+ printk("Security alert! Somebody other than MOL has tried to invoke\n"
11355+ "the MOL switch magic. The MOL infrastructure has been disabled.\n"
11356+ "Reboot in order to get MOL running again\n");
11357+ /* make it impossible to unload the module */
11358+ prevent_mod_unload();
11359+ }
11360+
11361+ SESSION_LOCK;
11362+ if( (kv=g_sesstab->kvars[index]) ) {
11363+
11364+ g_sesstab->kvars[index] = NULL;
11365+ g_sesstab->kvars_ph[index] = 0;
11366+
11367+ /* decrease before freeing anything (simplifies deallocation of shared resources) */
11368+ g_num_sessions--;
11369+ cleanup_host_irqs(kv);
11370+ cleanup_mmu( kv );
11371+
11372+ if( kv->emuaccel_page )
11373+ free_page_mol( kv->emuaccel_page );
11374+
11375+ memset( kv, 0, NUM_KVARS_PAGES * 0x1000 );
11376+ free_kvar_pages( kv );
11377+
11378+ if( !g_num_sessions )
11379+ cleanup_actions();
11380+ }
11381+ SESSION_UNLOCK;
11382+}
11383+
11384+uint
11385+get_session_magic( uint random_magic )
11386+{
11387+ if( random_magic < 2 )
11388+ random_magic = 2;
11389+ /* negative return values are interpreted as errors */
11390+ random_magic &= 0x7fffffff;
11391+
11392+ SESSION_LOCK;
11393+ if( !g_sesstab->magic )
11394+ g_sesstab->magic = random_magic;
11395+ SESSION_UNLOCK;
11396+
11397+ return g_sesstab->magic;
11398+}
11399--- /dev/null
11400+++ b/drivers/macintosh/mol/misc.c
11401@@ -0,0 +1,255 @@
11402+/*
11403+ * Creation Date: <2003/06/06 20:00:52 samuel>
11404+ * Time-stamp: <2004/03/06 13:54:26 samuel>
11405+ *
11406+ * <misc.c>
11407+ *
11408+ * Miscellaneous
11409+ *
11410+ * Copyright (C) 2003, 2004 Samuel Rydh (samuel@ibrium.se)
11411+ *
11412+ * This program is free software; you can redistribute it and/or
11413+ * modify it under the terms of the GNU General Public License
11414+ * version 2
11415+ *
11416+ */
11417+
11418+#include "archinclude.h"
11419+#include "mol-ioctl.h"
11420+#include "mmu.h"
11421+#include "mtable.h"
11422+#include "constants.h"
11423+#include "asmfuncs.h"
11424+#include "performance.h"
11425+#include "misc.h"
11426+#include "emu.h"
11427+#include "alloc.h"
11428+#include "uaccess.h"
11429+
11430+
11431+/************************************************************************/
11432+/* Performance Info */
11433+/************************************************************************/
11434+
11435+#ifdef PERFORMANCE_INFO
11436+
11437+static void
11438+clear_performance_info( kernel_vars_t *kv )
11439+{
11440+ perf_info_t *p = g_perf_info_table;
11441+ int i;
11442+
11443+ for( ; p->name ; p++ )
11444+ *p->ctrptr = 0;
11445+ for( i=0; i<NUM_ASM_BUMP_CNTRS; i++ )
11446+ kv->asm_bump_cntr[i] = 0;
11447+ kv->num_acntrs = 0;
11448+}
11449+
11450+static int
11451+get_performance_info( kernel_vars_t *kv, uint ind, perf_ctr_t *r )
11452+{
11453+ perf_info_t *p;
11454+ int len;
11455+ char *name;
11456+
11457+ for( p=g_perf_info_table; p->name && ind; p++, ind-- )
11458+ ;
11459+ if( !p->name ) {
11460+ extern int __start_bumptable[], __end_bumptable[];
11461+ if( ind >= __end_bumptable - __start_bumptable )
11462+ return 1;
11463+ name = (char*)__start_bumptable + __start_bumptable[ind];
11464+ r->ctr = kv->asm_bump_cntr[ind];
11465+ } else {
11466+ name = p->name;
11467+ r->ctr = *p->ctrptr;
11468+ }
11469+
11470+ if( (len=strlen(name)+1) > sizeof(r->name) )
11471+ len = sizeof(r->name);
11472+ memcpy( r->name, name, len );
11473+ return 0;
11474+}
11475+
11476+#else /* PERFORMANCE_INFO */
11477+
11478+static void
11479+clear_performance_info( kernel_vars_t *kv )
11480+{
11481+}
11482+
11483+static int
11484+get_performance_info( kernel_vars_t *kv, uint ind, perf_ctr_t *r )
11485+{
11486+ return 1;
11487+}
11488+
11489+#endif /* PERFORMANCE_INFO */
11490+
11491+
11492+
11493+/************************************************************************/
11494+/* misc */
11495+/************************************************************************/
11496+
11497+int
11498+do_debugger_op( kernel_vars_t *kv, dbg_op_params_t *pb )
11499+{
11500+ int ret = 0;
11501+
11502+ switch( pb->operation ) {
11503+ case DBG_OP_EMULATE_TLBIE:
11504+ flush_ea_range( kv, (pb->ea & ~0xf0000000), 0x1000 );
11505+ break;
11506+
11507+ case DBG_OP_EMULATE_TLBIA:
11508+ clear_all_vsids( kv );
11509+ break;
11510+
11511+ case DBG_OP_GET_PTE:
11512+ ret = dbg_get_PTE( kv, pb->context, pb->ea, &pb->ret.pte );
11513+ break;
11514+
11515+ case DBG_OP_BREAKPOINT_FLAGS:
11516+ kv->break_flags = pb->param;
11517+ kv->mregs.flag_bits &= ~fb_DbgTrace;
11518+ kv->mregs.flag_bits |= (pb->param & BREAK_SINGLE_STEP)? fb_DbgTrace : 0;
11519+ msr_altered( kv );
11520+ break;
11521+
11522+ case DBG_OP_TRANSLATE_EA:
11523+ /* param == is_data_access */
11524+ ret = dbg_translate_ea( kv, pb->context, pb->ea, &pb->ret.phys, pb->param );
11525+ break;
11526+
11527+ default:
11528+ printk("Unimplemended debugger operation %d\n", pb->operation );
11529+ ret = -ENOSYS_MOL;
11530+ break;
11531+ }
11532+ return ret;
11533+}
11534+
11535+static void
11536+tune_spr( kernel_vars_t *kv, uint spr, int action )
11537+{
11538+ extern int r__spr_illegal[], r__spr_read_only[], r__spr_read_write[];
11539+ int hook, newhook=0;
11540+
11541+ if( spr >= 1024 )
11542+ return;
11543+
11544+ hook = kv->_bp.spr_hooks[spr];
11545+
11546+ /* LSB of hook specifies whether the SPR is privileged */
11547+ switch( action ) {
11548+ case kTuneSPR_Illegal:
11549+ newhook = (int)r__spr_illegal;
11550+ hook &= ~1;
11551+ break;
11552+
11553+ case kTuneSPR_Privileged:
11554+ hook |= 1;
11555+ break;
11556+
11557+ case kTuneSPR_Unprivileged:
11558+ hook &= ~1;
11559+ break;
11560+
11561+ case kTuneSPR_ReadWrite:
11562+ newhook = (int)r__spr_read_write;
11563+ break;
11564+
11565+ case kTuneSPR_ReadOnly:
11566+ newhook = (int)r__spr_read_only;
11567+ break;
11568+ }
11569+ if( newhook )
11570+ hook = (hook & 1) | tophys_mol( (char*)reloc_ptr(newhook) );
11571+ kv->_bp.spr_hooks[spr] = hook;
11572+}
11573+
11574+/* return value: <0: system error, >=0: ret value */
11575+int
11576+handle_ioctl( kernel_vars_t *kv, int cmd, int arg1, int arg2, int arg3 )
11577+{
11578+ struct mmu_mapping map;
11579+ perf_ctr_t pctr;
11580+ int ret = 0;
11581+
11582+ switch( cmd ) {
11583+ case MOL_IOCTL_GET_SESSION_MAGIC:
11584+ ret = get_session_magic( arg1 );
11585+ break;
11586+
11587+ case MOL_IOCTL_IDLE_RECLAIM_MEMORY:
11588+ mtable_reclaim( kv );
11589+ break;
11590+
11591+ case MOL_IOCTL_SPR_CHANGED:
11592+ msr_altered(kv);
11593+ mmu_altered(kv);
11594+ break;
11595+
11596+ case MOL_IOCTL_ADD_IORANGE: /* void ( ulong mbase, int size, void *usr_data )*/
11597+ add_io_trans( kv, arg1, arg2, (void*)arg3 );
11598+ break;
11599+ case MOL_IOCTL_REMOVE_IORANGE: /* void ( ulong mbase, int size ) */
11600+ remove_io_trans( kv, arg1, arg2 );
11601+ break;
11602+
11603+ case MOL_IOCTL_ALLOC_EMUACCEL_SLOT: /* EMULATE_xxx, param, ret_addr -- mphys */
11604+ ret = alloc_emuaccel_slot( kv, arg1, arg2, arg3 );
11605+ break;
11606+ case MOL_IOCTL_MAPIN_EMUACCEL_PAGE: /* arg1 = mphys */
11607+ ret = mapin_emuaccel_page( kv, arg1 );
11608+ break;
11609+
11610+ case MOL_IOCTL_SETUP_FBACCEL: /* lvbase, bytes_per_row, height */
11611+ setup_fb_acceleration( kv, (char*)arg1, arg2, arg3 );
11612+ break;
11613+ case MOL_IOCTL_TUNE_SPR: /* spr#, action */
11614+ tune_spr( kv, arg1, arg2 );
11615+ break;
11616+
11617+ case MOL_IOCTL_MMU_MAP: /* arg1=struct mmu_mapping *m, arg2=map/unmap */
11618+ if( copy_from_user_mol(&map, (struct mmu_mapping*)arg1, sizeof(map)) )
11619+ break;
11620+ if( arg2 )
11621+ mmu_add_map( kv, &map );
11622+ else
11623+ mmu_remove_map( kv, &map );
11624+ if( copy_to_user_mol((struct mmu_mapping*)arg1, &map, sizeof(map)) )
11625+ ret = -EFAULT_MOL;
11626+ break;
11627+
11628+ case MOL_IOCTL_GET_PERF_INFO:
11629+ ret = get_performance_info( kv, arg1, &pctr );
11630+ if( copy_to_user_mol((perf_ctr_t*)arg2, &pctr, sizeof(pctr)) )
11631+ ret = -EFAULT_MOL;
11632+ break;
11633+
11634+#if 0
11635+ case MOL_IOCTL_TRACK_DIRTY_RAM:
11636+ ret = track_lvrange( kv );
11637+ break;
11638+ case MOL_IOCTL_GET_DIRTY_RAM:
11639+ ret = get_track_buffer( kv, (char*)arg1 );
11640+ break;
11641+ case MOL_IOCTL_SET_DIRTY_RAM:
11642+ set_track_buffer( kv, (char*)arg1 );
11643+ break;
11644+#endif
11645+ /* ---------------- performance statistics ------------------ */
11646+
11647+ case MOL_IOCTL_CLEAR_PERF_INFO:
11648+ clear_performance_info( kv );
11649+ break;
11650+
11651+ default:
11652+ printk("unsupported MOL ioctl %d\n", cmd );
11653+ ret = -ENOSYS_MOL;
11654+ }
11655+ return ret;
11656+}
11657--- /dev/null
11658+++ b/drivers/macintosh/mol/mmu.c
11659@@ -0,0 +1,251 @@
11660+/*
11661+ * Creation Date: <1998-11-11 11:56:45 samuel>
11662+ * Time-stamp: <2004/03/13 14:25:26 samuel>
11663+ *
11664+ * <mmu.c>
11665+ *
11666+ * Handles page mappings and the mac MMU
11667+ *
11668+ * Copyright (C) 1998-2004 Samuel Rydh (samuel@ibrium.se)
11669+ *
11670+ * This program is free software; you can redistribute it and/or
11671+ * modify it under the terms of the GNU General Public License
11672+ * as published by the Free Software Foundation
11673+ *
11674+ */
11675+
11676+#include "archinclude.h"
11677+#include "alloc.h"
11678+#include "kernel_vars.h"
11679+#include "mmu.h"
11680+#include "mmu_contexts.h"
11681+#include "asmfuncs.h"
11682+#include "emu.h"
11683+#include "misc.h"
11684+#include "mtable.h"
11685+#include "performance.h"
11686+#include "context.h"
11687+#include "hash.h"
11688+#include "map.h"
11689+
11690+#define MREGS (kv->mregs)
11691+#define MMU (kv->mmu)
11692+
11693+
11694+/************************************************************************/
11695+/* init / cleanup */
11696+/************************************************************************/
11697+
11698+int
11699+init_mmu( kernel_vars_t *kv )
11700+{
11701+ int success;
11702+
11703+ success =
11704+ !arch_mmu_init( kv ) &&
11705+ !init_contexts( kv ) &&
11706+ !init_mtable( kv ) &&
11707+ !init_mmu_io( kv ) &&
11708+ !init_mmu_fb( kv ) &&
11709+ !init_mmu_tracker( kv );
11710+
11711+ if( !success ) {
11712+ cleanup_mmu( kv );
11713+ return 1;
11714+ }
11715+
11716+ clear_vsid_refs( kv );
11717+
11718+ /* SDR1 is set from fStartEmulation */
11719+ return 0;
11720+}
11721+
11722+void
11723+cleanup_mmu( kernel_vars_t *kv )
11724+{
11725+ /* We have to make sure the flush thread are not using the mtable
11726+ * facilities. The kvars entry has been clear so we just have
11727+ * to wait around until no threads are using it.
11728+ */
11729+ while( atomic_read_mol(&g_sesstab->external_thread_cnt) )
11730+ ;
11731+
11732+ cleanup_mmu_tracker( kv );
11733+ cleanup_mmu_fb( kv );
11734+ cleanup_mmu_io( kv );
11735+ cleanup_mtable( kv );
11736+ cleanup_contexts( kv );
11737+
11738+ if( MMU.pthash_inuse_bits )
11739+ kfree_cont_mol( MMU.pthash_inuse_bits );
11740+ if( MMU.hash_base )
11741+ unmap_emulated_hash( kv );
11742+
11743+ memset( &MMU, 0, sizeof(mmu_vars_t) );
11744+}
11745+
11746+
11747+/************************************************************************/
11748+/* misc */
11749+/************************************************************************/
11750+
11751+/* All vsid entries have been flushed; clear dangling pointers */
11752+void
11753+clear_vsid_refs( kernel_vars_t *kv )
11754+{
11755+ int i;
11756+ for( i=0; i<16; i++ ) {
11757+ MMU.vsid[i] = NULL;
11758+ MMU.unmapped_vsid[i] = NULL;
11759+
11760+ MMU.user_sr[i] = MMU.illegal_sr;
11761+ MMU.sv_sr[i] = MMU.illegal_sr;
11762+ MMU.unmapped_sr[i] = MMU.illegal_sr;
11763+ MMU.split_sr[i] = MMU.illegal_sr;
11764+ }
11765+ invalidate_splitmode_sr( kv );
11766+}
11767+
11768+/*
11769+ * This function is called whenever the mac MMU-registers have
11770+ * been manipulated externally.
11771+ */
11772+void
11773+mmu_altered( kernel_vars_t *kv )
11774+{
11775+ int i;
11776+
11777+ for( i=0; i<16; i++ ) {
11778+ MMU.vsid[i] = NULL;
11779+ MMU.user_sr[i] = MMU.illegal_sr;
11780+ MMU.sv_sr[i] = MMU.illegal_sr;
11781+ }
11782+ invalidate_splitmode_sr( kv );
11783+
11784+ do_mtsdr1( kv, MREGS.spr[S_SDR1] );
11785+
11786+ for( i=0; i<16; i++ )
11787+ do_mtbat( kv, S_IBAT0U+i, MREGS.spr[ S_IBAT0U+i ], 1 );
11788+}
11789+
11790+/*
11791+ * A page we might be using is about to be destroyed (e.g. swapped out).
11792+ * Any PTEs referencing this page must be flushed. The context parameter
11793+ * is vsid >> 4.
11794+ *
11795+ * ENTRYPOINT!
11796+ */
11797+void
11798+do_flush( ulong context, ulong va, ulong *dummy, int n )
11799+{
11800+ int i;
11801+ kernel_vars_t *kv;
11802+ BUMP( do_flush );
11803+
11804+ atomic_inc_mol( &g_sesstab->external_thread_cnt );
11805+
11806+ for( i=0; i<MAX_NUM_SESSIONS; i++ ) {
11807+ if( !(kv=g_sesstab->kvars[i]) || context != kv->mmu.emulator_context )
11808+ continue;
11809+
11810+ BUMP_N( block_destroyed_ctr, n );
11811+ for( ; n-- ; va += 0x1000 )
11812+ flush_lvptr( kv, va );
11813+ break;
11814+ }
11815+
11816+ atomic_dec_mol( &g_sesstab->external_thread_cnt );
11817+}
11818+
11819+
11820+/************************************************************************/
11821+/* Debugger functions */
11822+/************************************************************************/
11823+
11824+int
11825+dbg_get_PTE( kernel_vars_t *kv, int context, ulong va, mPTE_t *retptr )
11826+{
11827+ ulong base, mask;
11828+ ulong vsid, ptmp, stmp, *pteg, *steg;
11829+ ulong cmp;
11830+ ulong *uret = (ulong*)retptr;
11831+ int i, num_match=0;
11832+
11833+ switch( context ) {
11834+ case kContextUnmapped:
11835+ vsid = MMU.unmapped_sr[va>>28];
11836+ break;
11837+ case kContextMapped_S:
11838+ vsid = MMU.sv_sr[va>>28];
11839+ break;
11840+ case kContextMapped_U:
11841+ vsid = MMU.user_sr[va>>28];
11842+ break;
11843+ case kContextEmulator:
11844+ vsid = (MUNGE_CONTEXT(MMU.emulator_context) + ((va>>28) * MUNGE_ESID_ADD)) & 0xffffff;
11845+ break;
11846+ case kContextKernel:
11847+ vsid = 0;
11848+ break;
11849+ default:
11850+ printk("get_PTE: no such context: %d\n", context );
11851+ return 0;
11852+ }
11853+
11854+ /* mask vsid and va */
11855+ vsid &= 0xffffff;
11856+ va &= 0x0ffff000;
11857+
11858+ /* get hash base and hash mask */
11859+ base = (ulong)ptehash.base;
11860+ mask = ptehash.pteg_mask >> 6;
11861+
11862+ /* hash function */
11863+ ptmp = (vsid ^ (va>>12)) & mask;
11864+ stmp = mask & ~ptmp;
11865+ pteg = (ulong*)((ptmp << 6) + base);
11866+ steg = (ulong*)((stmp << 6) + base);
11867+
11868+ /* construct compare word */
11869+ cmp = 0x80000000 | (vsid <<7) | (va>>22);
11870+
11871+ /* look in primary PTEG */
11872+ for( i=0; i<8; i++ ) {
11873+ if( cmp == pteg[i*2] ) {
11874+ if( !num_match++ && uret ) {
11875+ uret[0] = pteg[i*2];
11876+ uret[1] = pteg[i*2+1];
11877+ }
11878+ if( num_match == 2 ) {
11879+ printk("Internal ERROR: duplicate PTEs!\n");
11880+ printk("p-hash: low_pte: %08lX high_pte: %08lX\n",
11881+ uret ? uret[0]:0, retptr? uret[1]:0 );
11882+ }
11883+ if( num_match >= 2 ) {
11884+ printk("p-hash: low_pte: %08lX high_pte: %08lX\n",
11885+ pteg[i*2], pteg[i*2+1] );
11886+ }
11887+ }
11888+ }
11889+
11890+ /* look in secondary PTEG */
11891+ cmp |= 0x40;
11892+ for( i=0; i<8; i++ ) {
11893+ if( cmp == steg[i*2] ) {
11894+ if( !num_match++ && uret ) {
11895+ uret[0] = steg[i*2];
11896+ uret[1] = steg[i*2+1];
11897+ }
11898+ if( num_match == 2 ) {
11899+ printk("Internal ERROR: duplicate PTEs!\n");
11900+ printk("?-hash: low_pte: %08lX high_pte: %08lX\n",
11901+ uret? uret[0]:0, uret? uret[1]:0 );
11902+ }
11903+ if( num_match >= 2 ) {
11904+ printk("s-hash: low_pte: %08lX high_pte: %08lX\n",
11905+ steg[i*2], steg[i*2+1] );
11906+ }
11907+ }
11908+ }
11909+ return num_match;
11910+}
11911--- /dev/null
11912+++ b/drivers/macintosh/mol/mmu_fb.c
11913@@ -0,0 +1,186 @@
11914+/*
11915+ * Creation Date: <1999-12-28 14:03:18 samuel>
11916+ * Time-stamp: <2004/02/14 14:52:52 samuel>
11917+ *
11918+ * <mmu_fb.c>
11919+ *
11920+ * Offscreen framebuffer acceleration
11921+ *
11922+ * Copyright (C) 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
11923+ *
11924+ * This program is free software; you can redistribute it and/or
11925+ * modify it under the terms of the GNU General Public License
11926+ * as published by the Free Software Foundation
11927+ *
11928+ */
11929+
11930+#include "archinclude.h"
11931+#include "alloc.h"
11932+#include "uaccess.h"
11933+#include "mmu.h"
11934+#include "asmfuncs.h"
11935+#include "performance.h"
11936+#include "misc.h"
11937+
11938+typedef struct line_entry {
11939+ short y1, y2;
11940+ int dirty;
11941+ ulong *slot;
11942+ ulong pte0;
11943+ ulong pte1;
11944+ ulong ea;
11945+} line_entry_t;
11946+
11947+typedef struct fb_data {
11948+ line_entry_t *line_table;
11949+ int nrec;
11950+ char *lv_base; /* linux virtual of first entry in table */
11951+} fb_data_t;
11952+
11953+#define MMU (kv->mmu)
11954+#define DECLARE_FB fb_data_t *fb = MMU.fb_data
11955+
11956+#ifdef __darwin__
11957+static inline void
11958+__put_user( short val, short *destptr )
11959+{
11960+ copy_to_user_mol( destptr, &val, sizeof(short) );
11961+}
11962+#endif
11963+
11964+
11965+int
11966+init_mmu_fb( kernel_vars_t *kv )
11967+{
11968+ /* setup_fb_acceleration does the initialization */
11969+ return 0;
11970+}
11971+
11972+void
11973+cleanup_mmu_fb( kernel_vars_t *kv )
11974+{
11975+ DECLARE_FB;
11976+ if( !fb )
11977+ return;
11978+ if( fb->line_table )
11979+ vfree_mol( fb->line_table );
11980+
11981+ kfree_mol( fb );
11982+ MMU.fb_data = NULL;
11983+}
11984+
11985+void
11986+video_pte_inserted( kernel_vars_t *kv, ulong lvptr, ulong *slot, ulong pte0, ulong pte1, ulong ea )
11987+{
11988+ DECLARE_FB;
11989+ int i;
11990+
11991+ if( !fb )
11992+ return;
11993+
11994+ i = (lvptr - (ulong)fb->lv_base) >> 12;
11995+ if( i >= 0 && i < fb->nrec ) {
11996+ line_entry_t *p = &fb->line_table[i];
11997+
11998+ /* allow at most one video PTE to be mapped at any time */
11999+ if( p->slot && (p->slot != slot || p->pte0 != pte0) ) {
12000+ BUMP( video_pte_reinsert );
12001+ if( p->slot != slot )
12002+ p->slot[0] = 0;
12003+ __tlbie(p->ea);
12004+ p->dirty = 1;
12005+ }
12006+
12007+ p->slot = slot;
12008+ p->pte0 = pte0;
12009+ p->pte1 = pte1 & ~PTE1_C;
12010+ p->ea = ea;
12011+ } else {
12012+ printk("Warning: video_page outside range, %lx %p\n", lvptr, fb->lv_base );
12013+ }
12014+}
12015+
12016+/* setup/remove framebuffer acceleration */
12017+void
12018+setup_fb_acceleration( kernel_vars_t *kv, char *lvbase, int bytes_per_row, int height )
12019+{
12020+ DECLARE_FB;
12021+ int i, offs = (ulong)lvbase & 0xfff;
12022+ line_entry_t *p;
12023+
12024+ if( fb )
12025+ cleanup_mmu_fb( kv );
12026+ if( !lvbase )
12027+ return;
12028+ if( !(fb=kmalloc_mol(sizeof(fb_data_t))) )
12029+ return;
12030+ memset( fb, 0, sizeof(fb_data_t) );
12031+ MMU.fb_data = fb;
12032+
12033+ fb->nrec = (bytes_per_row * height + offs + 0xfff) >> 12;
12034+ if( !(p=(line_entry_t*)vmalloc_mol(sizeof(line_entry_t) * fb->nrec)) ) {
12035+ cleanup_mmu_fb( kv );
12036+ return;
12037+ }
12038+ memset( p, 0, sizeof(line_entry_t) * fb->nrec );
12039+ fb->line_table = p;
12040+
12041+ fb->lv_base = (char*)((ulong)lvbase & ~0xfff);
12042+ for( i=0; i<fb->nrec; i++, p++ ){
12043+ p->y1 = (0x1000*i - offs) / bytes_per_row;
12044+ p->y2 = (0x1000*(i+1)-1 -offs) / bytes_per_row;
12045+ if( p->y1 < 0 )
12046+ p->y1 = 0;
12047+ if( p->y2 >= height )
12048+ p->y2 = height-1;
12049+
12050+ /* we should make sure the page is really unmapped here! */
12051+ p->slot = NULL;
12052+ }
12053+}
12054+
12055+/* return format is {startline,endline} pairs */
12056+int
12057+get_dirty_fb_lines( kernel_vars_t *kv, short *userbuf, int num_bytes )
12058+{
12059+ DECLARE_FB;
12060+ int i, n, s, start;
12061+ line_entry_t *p;
12062+
12063+ s = num_bytes/sizeof(short[2]) - 1;
12064+
12065+ if( !fb || (uint)s <= 0 )
12066+ return -1;
12067+
12068+ p = fb->line_table;
12069+ for( start=-1, n=0, i=0; i<fb->nrec; i++, p++ ) {
12070+ if( p->slot ) {
12071+ if( p->slot[0] != p->pte0 ) {
12072+ /* evicted FB PTE */
12073+ p->slot = NULL;
12074+ p->dirty = 1;
12075+ __tlbie( p->ea );
12076+ } else if( p->slot[1] & BIT(24) ) { /* C-BIT */
12077+ p->dirty = 1;
12078+ __store_PTE( p->ea, p->slot, p->pte0, p->pte1 );
12079+ BUMP(fb_ptec_flush);
12080+ }
12081+ }
12082+ if( p->dirty && start < 0 )
12083+ start = p->y1;
12084+ else if( !p->dirty && start >= 0 ) {
12085+ __put_user( start, userbuf++ );
12086+ __put_user( p->y2, userbuf++ );
12087+ start = -1;
12088+ if( ++n >= s )
12089+ break;
12090+ }
12091+ p->dirty = 0;
12092+ }
12093+ if( start >= 0 ) {
12094+ __put_user( start, userbuf++ );
12095+ __put_user( fb->line_table[fb->nrec-1].y2, userbuf++ );
12096+ n++;
12097+ }
12098+ return n;
12099+}
12100--- /dev/null
12101+++ b/drivers/macintosh/mol/mmu_io.c
12102@@ -0,0 +1,470 @@
12103+/*
12104+ * Creation Date: <1998-12-02 03:23:31 samuel>
12105+ * Time-stamp: <2004/03/13 16:57:31 samuel>
12106+ *
12107+ * <mmu_io.c>
12108+ *
12109+ * Translate mac_phys to whatever has been mapped in at
12110+ * a particular address (linux ram, framebuffer, ROM, etc.)
12111+ *
12112+ * Copyright (C) 1998-2004 Samuel Rydh (samuel@ibrium.se)
12113+ *
12114+ * This program is free software; you can redistribute it and/or
12115+ * modify it under the terms of the GNU General Public License
12116+ * as published by the Free Software Foundation
12117+ *
12118+ */
12119+
12120+#include "archinclude.h"
12121+#include "alloc.h"
12122+#include "kernel_vars.h"
12123+#include "mmu.h"
12124+#include "misc.h"
12125+#include "mtable.h"
12126+#include "performance.h"
12127+#include "processor.h"
12128+
12129+#define MAX_BLOCK_TRANS 6
12130+
12131+/* Block translations are used for ROM, RAM, VRAM and similar things.
12132+ *
12133+ * IO-translations are a different type of mappings. Whenever an IO-area
12134+ * is accessed, a page fault occurs. If there is a page present (although
12135+ * r/w prohibited), then the low-level exception handler examines if the
12136+ * page has a magic signature in the first 8 bytes. If there is a match,
12137+ * then the page is of the type io_page_t and contains the information
12138+ * necessary to emulate the IO. If no page is present, then the corresponding
12139+ * IO-page is looked up and hashed.
12140+ */
12141+
12142+typedef struct {
12143+ ulong mbase;
12144+ char *lvbase;
12145+ pte_lvrange_t *lvrange;
12146+
12147+ size_t size;
12148+ int flags;
12149+
12150+ int id;
12151+} block_trans_t;
12152+
12153+typedef struct io_data {
12154+ block_trans_t btable[MAX_BLOCK_TRANS];
12155+ int num_btrans;
12156+ int next_free_id;
12157+ io_page_t *io_page_head;
12158+} io_data_t;
12159+
12160+static char *scratch_page;
12161+
12162+#define MMU (kv->mmu)
12163+#define DECLARE_IOD io_data_t *iod = kv->mmu.io_data
12164+
12165+
12166+
12167+int
12168+init_mmu_io( kernel_vars_t *kv )
12169+{
12170+ if( !(MMU.io_data=kmalloc_mol(sizeof(io_data_t))) )
12171+ return 1;
12172+ memset( MMU.io_data, 0, sizeof(io_data_t) );
12173+ return 0;
12174+}
12175+
12176+void
12177+cleanup_mmu_io( kernel_vars_t *kv )
12178+{
12179+ DECLARE_IOD;
12180+ io_page_t *next2, *p2;
12181+ int i;
12182+
12183+ if( !iod )
12184+ return;
12185+
12186+ for( p2=iod->io_page_head; p2; p2=next2 ) {
12187+ next2 = p2->next;
12188+ free_page_mol( (ulong)p2 );
12189+ }
12190+ iod->io_page_head = 0;
12191+
12192+ /* release the scratch page (not always allocated) */
12193+ if( !g_num_sessions && scratch_page ) {
12194+ free_page_mol( (int)scratch_page );
12195+ scratch_page = 0;
12196+ }
12197+
12198+ /* release any lvranges */
12199+ for( i=0; i<iod->num_btrans; i++ )
12200+ if( iod->btable[i].lvrange )
12201+ free_lvrange( kv, iod->btable[i].lvrange );
12202+
12203+ kfree_mol( iod );
12204+ MMU.io_data = NULL;
12205+}
12206+
12207+
12208+/* This is primarily intended for framebuffers */
12209+static int
12210+bat_align( int flags, ulong ea, ulong lphys, ulong size, ulong bat[2] )
12211+{
12212+ ulong s;
12213+ ulong offs1, offs2;
12214+
12215+ s=0x20000; /* 128K */
12216+ if( s> size )
12217+ return 1;
12218+ /* Limit to 128MB in order not to cross segments (256MB is bat-max) */
12219+ if( size > 0x10000000 )
12220+ size = 0x10000000;
12221+ for( ; s<size ; s = (s<<1) )
12222+ ;
12223+ offs1 = ea & (s-1);
12224+ offs2 = lphys & (s-1);
12225+ if( offs1 != offs2 ) {
12226+ printk("Can't use DBAT since offsets differ (%ld != %ld)\n", offs1, offs2 );
12227+ return 1;
12228+ }
12229+ /* BEPI | BL | VS | VP */
12230+ bat[0] = (ea & ~(s-1)) | (((s-1)>>17) << 2) | 3;
12231+ bat[1] = (lphys & ~(s-1)) | 2; /* pp=10, R/W */
12232+
12233+#ifndef CONFIG_AMIGAONE
12234+ bat[1] |= BIT(27); /* [M] (memory coherence) */
12235+#endif
12236+
12237+ if( !(flags & MAPPING_FORCE_CACHE) ) {
12238+ bat[1] |= BIT(26); /* [I] (inhibit cache) */
12239+ } else {
12240+ bat[1] |= BIT(25); /* [W] (write through) */
12241+ }
12242+ return 0;
12243+}
12244+
12245+
12246+/*
12247+ * Handle block translations (translations of mac-physical
12248+ * blocks to linux virtual physical addresses)
12249+ */
12250+static int
12251+add_block_trans( kernel_vars_t *kv, ulong mbase, char *lvbase, ulong size, int flags )
12252+{
12253+ DECLARE_IOD;
12254+ block_trans_t *bt;
12255+ pte_lvrange_t *lvrange = NULL;
12256+ int ind, i;
12257+
12258+ /* warn if things are not aligned properly */
12259+ if( (size & 0xfff) || ((int)lvbase & 0xfff) || (mbase & 0xfff) )
12260+ printk("Bad block translation alignement\n");
12261+
12262+ /* we keep an unsorted list - RAM should be added first, then ROM, then VRAM etc */
12263+ if( iod->num_btrans >= MAX_BLOCK_TRANS ) {
12264+ printk("Maximal number of block translations exceeded!\n");
12265+ return -1;
12266+ }
12267+
12268+ /* remove illegal combinations */
12269+ flags &= ~MAPPING_IO;
12270+ if( (flags & MAPPING_DBAT) && !(flags & MAPPING_PHYSICAL) )
12271+ flags &= ~MAPPING_DBAT;
12272+
12273+ /* scratch pages are always physical - lvbase isn't used */
12274+ if( (flags & MAPPING_SCRATCH) ) {
12275+ lvbase = NULL;
12276+ flags |= MAPPING_PHYSICAL;
12277+ flags &= ~MAPPING_DBAT;
12278+ }
12279+
12280+ /* IMPORTANT: DBATs can _only_ be used when we KNOW that ea == mphys. */
12281+ if( (flags & MAPPING_DBAT) ) {
12282+ ulong bat[2];
12283+ if( !bat_align(flags, mbase, (ulong)lvbase, size, bat) ) {
12284+ /* printk("BATS: %08lX %08lX\n", bat[0], bat[1] ); */
12285+ MMU.transl_dbat0.word[0] = bat[0];
12286+ MMU.transl_dbat0.word[1] = bat[1];
12287+ }
12288+ }
12289+
12290+ if( !(flags & MAPPING_PHYSICAL) )
12291+ if( !(lvrange=register_lvrange(kv, lvbase, size)) )
12292+ return -1;
12293+
12294+ /* Determine where to insert the translation in the table.
12295+ * RAM should go right efter entries marked with MAPPING_PUT_FIRST.
12296+ * The MAPPING_PUT_FIRST flag is used to do magic things like
12297+ * embedding a copy of mregs in RAM.
12298+ */
12299+ ind = (!mbase || (flags & MAPPING_PUT_FIRST)) ? 0 : iod->num_btrans;
12300+ for( i=0; i<iod->num_btrans && ind <= i; i++ )
12301+ if( iod->btable[i].flags & MAPPING_PUT_FIRST )
12302+ ind++;
12303+ bt = &iod->btable[ind];
12304+ if( ind < iod->num_btrans )
12305+ memmove( &iod->btable[ind+1], bt, sizeof(iod->btable[0]) * (iod->num_btrans - ind) );
12306+ iod->num_btrans++;
12307+ memset( bt, 0, sizeof(block_trans_t) );
12308+
12309+ bt->mbase = mbase;
12310+ bt->lvbase = lvbase;
12311+ bt->lvrange = lvrange;
12312+ bt->size = size;
12313+ bt->flags = flags | MAPPING_VALID;
12314+ bt->id = ++iod->next_free_id;
12315+
12316+ /* flush everything if we a translation was overridden */
12317+ if( flags & MAPPING_PUT_FIRST )
12318+ clear_pte_hash_table( kv );
12319+
12320+ return bt->id;
12321+}
12322+
12323+static void
12324+remove_block_trans( kernel_vars_t *kv, int id )
12325+{
12326+ DECLARE_IOD;
12327+ block_trans_t *p;
12328+ int i;
12329+
12330+ /* Remove all mappings in the TLB table...
12331+ * (too difficult to find the entries we need to flush)
12332+ */
12333+ BUMP(remove_block_trans);
12334+ clear_pte_hash_table( kv );
12335+
12336+ for( p=iod->btable, i=0; i<iod->num_btrans; i++, p++ ) {
12337+ if( id == p->id ) {
12338+ if( p->flags & MAPPING_DBAT ) {
12339+ MMU.transl_dbat0.word[0] = 0;
12340+ MMU.transl_dbat0.word[1] = 0;
12341+ }
12342+ if( p->lvrange )
12343+ free_lvrange( kv, p->lvrange );
12344+
12345+ memmove( p,p+1, (iod->num_btrans-1-i)*sizeof(block_trans_t) );
12346+ iod->num_btrans--;
12347+ return;
12348+ }
12349+ }
12350+ printk("Trying to remove nonexistent block mapping!\n");
12351+}
12352+
12353+/* adds an I/O-translation. It is legal to add the same
12354+ * range multiple times (for instance, to alter usr_data)
12355+ */
12356+int
12357+add_io_trans( kernel_vars_t *kv, ulong mbase, int size, void *usr_data )
12358+{
12359+ DECLARE_IOD;
12360+ io_page_t *ip, **pre_next;
12361+ ulong mb;
12362+ int i, num;
12363+
12364+ /* align mbase and size to double word boundarys */
12365+ size += mbase & 7;
12366+ mbase -= mbase & 7;
12367+ size = (size+7) & ~7;
12368+
12369+ while( size > 0 ) {
12370+ mb = mbase & 0xfffff000;
12371+
12372+ pre_next = &iod->io_page_head;
12373+ for( ip=iod->io_page_head; ip && ip->mphys < mb; ip=ip->next )
12374+ pre_next = &ip->next;
12375+
12376+ if( !ip || ip->mphys != mb ) {
12377+ /* create new page */
12378+ if( !(ip=(io_page_t*)alloc_page_mol()) ) {
12379+ printk("Failed allocating IO-page\n");
12380+ return 1;
12381+ }
12382+ ip->next = *pre_next;
12383+ *pre_next = ip;
12384+
12385+ /* setup block */
12386+ ip->magic = IO_PAGE_MAGIC_1;
12387+ ip->magic2 = IO_PAGE_MAGIC_2;
12388+ ip->me_phys = tophys_mol(ip);
12389+ ip->mphys = mb;
12390+ }
12391+ /* fill in IO */
12392+ num = size>>3;
12393+ i = (mbase & 0xfff) >> 3;
12394+ if( i+num > 512 )
12395+ num = 512-i;
12396+ mbase += num<<3;
12397+ size -= num<<3;
12398+ while( num-- )
12399+ ip->usr_data[i++] = usr_data;
12400+ }
12401+ return 0;
12402+}
12403+
12404+int
12405+remove_io_trans( kernel_vars_t *kv, ulong mbase, int size )
12406+{
12407+ DECLARE_IOD;
12408+ io_page_t *ip, **pre_next;
12409+ ulong mb;
12410+ int i, num;
12411+
12412+ /* To remove an unused IO-page, we must make sure there are no
12413+ * dangling references to it. Hence we must search the PTE hash
12414+ * table and remove all references. We must also issue a
12415+ * tlbia to make sure it is not in the on-chip DTLB/ITLB cashe.
12416+ *
12417+ * XXX: Instead of seraching the hash, we simply make sure the magic
12418+ * constants are invalid. This is perfectly safe since the exception
12419+ * handler doesn't write to the page in question - and the physical
12420+ * page always exists even if it is allocated by somebody else.
12421+ * It is better to make sure there are no references of it though.
12422+ *
12423+ * XXX: This needs to be fixed... commonly, we reallocate
12424+ * the page ourselves for I/O so the magic constants might
12425+ * be valid...
12426+ */
12427+
12428+ /* align mbase and size to double word boundarys */
12429+ size += mbase & 7;
12430+ mbase -= mbase & 7;
12431+ size = (size+7) & ~7;
12432+
12433+ while( size > 0 ) {
12434+ mb = mbase & 0xfffff000;
12435+
12436+ pre_next = &iod->io_page_head;
12437+ for( ip=iod->io_page_head; ip && ip->mphys < mb; ip=ip->next )
12438+ pre_next = &ip->next;
12439+
12440+ if( !ip || ip->mphys != mb ) {
12441+ /* no page... */
12442+ size -= 0x1000 - (mbase & 0xfff);
12443+ mbase += 0x1000 - (mbase & 0xfff);
12444+ continue;
12445+ }
12446+ /* clear IO */
12447+ num = size>>3;
12448+ i = (mbase & 0xfff) >> 3;
12449+ if( i+num > 512 )
12450+ num = 512-i;
12451+ mbase += num<<3;
12452+ size -= num<<3;
12453+ while( num-- )
12454+ ip->usr_data[i++] = 0;
12455+
12456+ /* May we free the page? */
12457+ for( i=0; i<512 && !ip->usr_data[i]; i++ )
12458+ ;
12459+ if( i==512 ) {
12460+ /* Free page (XXX: Remove page fram hash, see above ) */
12461+ *pre_next = ip->next;
12462+ ip->magic2 = ip->magic = 0; /* IMPORTANT */
12463+ free_page_mol( (ulong)ip );
12464+ }
12465+ }
12466+ return 0;
12467+
12468+}
12469+
12470+
12471+/* Translate a mac-physical address (32 bit, not page-index)
12472+ * and fill in rpn (and _possibly_ other fields) of the pte.
12473+ * The WIMG bits are not modified after this call.
12474+ * The calling function is not supposed to alter the pte after
12475+ * this function call.
12476+ *
12477+ * Retuns:
12478+ * 0 no translation found
12479+ * block_flags translation found
12480+ */
12481+
12482+int
12483+mphys_to_pte( kernel_vars_t *kv, ulong mphys, ulong *the_pte1, int is_write, pte_lvrange_t **lvrange )
12484+{
12485+ DECLARE_IOD;
12486+ int i, num_btrans;
12487+ block_trans_t *p;
12488+ io_page_t *p2;
12489+ int pte1 = *the_pte1;
12490+
12491+ num_btrans = iod->num_btrans;
12492+ mphys &= ~0xfff;
12493+
12494+ /* check for emuaccel page */
12495+ if( mphys == kv->emuaccel_mphys && kv->emuaccel_page_phys ) {
12496+ /* printk("emuaccel - PTE-insert\n"); */
12497+ pte1 |= kv->emuaccel_page_phys;
12498+ /* supervisor r/w, no user access */
12499+ pte1 &= ~(PTE1_W | PTE1_I | PTE1_PP);
12500+ *lvrange = NULL;
12501+ *the_pte1 = pte1;
12502+ return MAPPING_VALID | MAPPING_PHYSICAL;
12503+ }
12504+
12505+ /* check for a block mapping. */
12506+ for( p=iod->btable, i=0; i<num_btrans; i++,p++ ) {
12507+ if( mphys - p->mbase < (ulong)p->size ) {
12508+ if( (p->flags & MAPPING_SCRATCH) ) {
12509+ /* it is OK to return silently if we run out of memory */
12510+ if( !scratch_page && !(scratch_page=(char*)alloc_page_mol()) )
12511+ return 0;
12512+ pte1 |= tophys_mol(scratch_page);
12513+ } else
12514+ pte1 |= (mphys - p->mbase + (ulong)p->lvbase) & PTE1_RPN;
12515+
12516+ if( p->flags & MAPPING_FORCE_CACHE ) {
12517+ /* use write through for now */
12518+ pte1 |= PTE1_W;
12519+ pte1 &= ~PTE1_I;
12520+ } else if( !(p->flags & MAPPING_MACOS_CONTROLS_CACHE) )
12521+ pte1 &= ~(PTE1_W | PTE1_I);
12522+
12523+ /* well, just a try... */
12524+ if ( p->flags & MAPPING_FORCE_WRITABLE ) {
12525+ /* printk("forcing mphys page %lx writable\n", mphys); */
12526+ pte1 = (pte1 & ~3) | 2;
12527+ }
12528+
12529+ *lvrange = p->lvrange;
12530+ *the_pte1 = pte1;
12531+ return p->flags;
12532+ }
12533+ }
12534+
12535+ /* check for an I/O mapping. */
12536+ for( p2=iod->io_page_head; p2 && p2->mphys<=mphys; p2=p2->next ) {
12537+ if( p2->mphys != mphys )
12538+ continue;
12539+ pte1 |= p2->me_phys;
12540+ /* supervisor R/W */
12541+ pte1 &= ~(PTE1_PP | PTE1_W | PTE1_I);
12542+ *lvrange = NULL;
12543+ *the_pte1 = pte1;
12544+ return MAPPING_VALID | MAPPING_IO | MAPPING_PHYSICAL;
12545+ }
12546+ return 0;
12547+}
12548+
12549+void
12550+mmu_add_map( kernel_vars_t *kv, struct mmu_mapping *m )
12551+{
12552+ if( m->flags & MAPPING_MREGS ) {
12553+ char *start = (char*)tophys_mol(&kv->mregs);
12554+ uint offs = (uint)m->lvbase;
12555+ m->flags &= ~MAPPING_MREGS;
12556+ m->flags |= MAPPING_PHYSICAL;
12557+ m->lvbase = start + offs;
12558+ m->id = -1;
12559+ if( offs + (uint)m->size > NUM_MREGS_PAGES * 0x1000 ) {
12560+ printk("Invalid mregs mapping\n");
12561+ return;
12562+ }
12563+ }
12564+ m->id = add_block_trans( kv, m->mbase, m->lvbase, m->size, m->flags );
12565+}
12566+
12567+void
12568+mmu_remove_map( kernel_vars_t *kv, struct mmu_mapping *m )
12569+{
12570+ remove_block_trans( kv, m->id );
12571+ m->id = 0;
12572+}
12573--- /dev/null
12574+++ b/drivers/macintosh/mol/mmu_tracker.c
12575@@ -0,0 +1,128 @@
12576+/*
12577+ * Creation Date: <2000/09/07 20:36:54 samuel>
12578+ * Time-stamp: <2004/02/14 14:45:33 samuel>
12579+ *
12580+ * <mmu_tracker.c>
12581+ *
12582+ * Keeps track of dirty RAM pages
12583+ *
12584+ * Copyright (C) 2000, 2001, 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
12585+ *
12586+ * This program is free software; you can redistribute it and/or
12587+ * modify it under the terms of the GNU General Public License
12588+ * as published by the Free Software Foundation
12589+ *
12590+ */
12591+
12592+#include "archinclude.h"
12593+#include "alloc.h"
12594+#include "uaccess.h"
12595+#include "mmu.h"
12596+
12597+
12598+typedef struct tracker_data {
12599+ char *table;
12600+ size_t table_size;
12601+
12602+ int npages;
12603+ ulong lvbase;
12604+} tracker_data_t;
12605+
12606+#define MMU (kv->mmu)
12607+#define DECLARE_TS tracker_data_t *ts = MMU.tracker_data
12608+
12609+
12610+
12611+int
12612+init_mmu_tracker( kernel_vars_t *kv )
12613+{
12614+ /* track_lvrange does the initialization */
12615+ return 0;
12616+}
12617+
12618+void
12619+cleanup_mmu_tracker( kernel_vars_t *kv )
12620+{
12621+ DECLARE_TS;
12622+ if( !ts )
12623+ return;
12624+
12625+ if( ts->table )
12626+ vfree_mol( ts->table );
12627+
12628+ kfree_mol( ts );
12629+ MMU.tracker_data = NULL;
12630+}
12631+
12632+int
12633+track_lvrange( kernel_vars_t *kv )
12634+{
12635+ ulong lvbase = MMU.userspace_ram_base;
12636+ int size = MMU.ram_size;
12637+
12638+ DECLARE_TS;
12639+ if( ts )
12640+ cleanup_mmu_tracker( kv );
12641+ if( !size )
12642+ return 0;
12643+
12644+ if( !(ts=kmalloc_mol(sizeof(tracker_data_t))) )
12645+ return 1;
12646+ memset( ts, 0, sizeof(tracker_data_t) );
12647+ MMU.tracker_data = ts;
12648+
12649+ ts->npages = size >> 12;
12650+ ts->table_size = (ts->npages+7)/8;
12651+ ts->lvbase = lvbase;
12652+ if( !(ts->table=vmalloc_mol(ts->table_size)) ) {
12653+ cleanup_mmu_tracker( kv );
12654+ return 1;
12655+ }
12656+ memset( ts->table, 0, ts->table_size );
12657+ return 0;
12658+}
12659+
12660+void
12661+lvpage_dirty( kernel_vars_t *kv, ulong lvbase )
12662+{
12663+ DECLARE_TS;
12664+ int pgindex;
12665+
12666+ if( !ts )
12667+ return;
12668+
12669+ pgindex = (lvbase - ts->lvbase) >> 12;
12670+
12671+ if( pgindex >=0 && pgindex < ts->npages )
12672+ ts->table[pgindex >> 3] |= (1 << (pgindex & 7));
12673+}
12674+
12675+
12676+size_t
12677+get_track_buffer( kernel_vars_t *kv, char *retbuf )
12678+{
12679+ DECLARE_TS;
12680+
12681+ if( !ts )
12682+ return 0;
12683+ if( !retbuf )
12684+ return ts->table_size;
12685+
12686+ if( copy_to_user_mol(retbuf, ts->table, ts->table_size) )
12687+ return 0;
12688+ return ts->table_size;
12689+}
12690+
12691+void
12692+set_track_buffer( kernel_vars_t *kv, char *buf )
12693+{
12694+ DECLARE_TS;
12695+
12696+ if( !ts || !buf ) {
12697+ printk("set_track_buffer: error\n");
12698+ return;
12699+ }
12700+ if( copy_from_user_mol(ts->table, buf, ts->table_size) ) {
12701+ printk("set_track_buffer: Bad access\n");
12702+ }
12703+}
12704--- /dev/null
12705+++ b/drivers/macintosh/mol/mtable.c
12706@@ -0,0 +1,960 @@
12707+/*
12708+ * Creation Date: <2002/05/26 14:46:42 samuel>
12709+ * Time-stamp: <2004/02/28 19:33:21 samuel>
12710+ *
12711+ * <mtable.c>
12712+ *
12713+ * Keeps track of all PTEs MOL uses.
12714+ *
12715+ * Copyright (C) 2002, 2003, 2004 Samuel Rydh (samuel@ibrium.se)
12716+ *
12717+ * This program is free software; you can redistribute it and/or
12718+ * modify it under the terms of the GNU General Public License
12719+ * as published by the Free Software Foundation
12720+ *
12721+ */
12722+
12723+#ifdef UL_DEBUG
12724+#include "mtable_dbg.c"
12725+#else
12726+#include "archinclude.h"
12727+#include "alloc.h"
12728+#include "kernel_vars.h"
12729+#include "asmfuncs.h"
12730+#include "mmu.h"
12731+#include "performance.h"
12732+#endif
12733+#include "mtable.h"
12734+#include "hash.h"
12735+
12736+/* #define DEBUG */
12737+
12738+/*
12739+ * Implementation notes:
12740+ *
12741+ * - It is assumed bit the ITLB/DTLB is addressed by ea bits 14-19.
12742+ * This holds true for all CPUs at the moment (603, 604, 750, 7400,
12743+ * 7410, 7450) except the 601 (which uses bits 13-19).
12744+ */
12745+
12746+typedef struct pterec pterec_t;
12747+
12748+struct pterec {
12749+ pterec_t *ea_next; /* ea ring (MUST GO FIRST) */
12750+ pterec_t *lv_next; /* lv ring */
12751+ uint pent; /* defined below */
12752+};
12753+
12754+#define PENT_LV_HEAD BIT(0) /* Resident - do not put on free list */
12755+#define PENT_UNUSED BIT(1) /* (lvhead) PTE index is not valid */
12756+#define PENT_EA_BIT14 BIT(2) /* for the partial ea used by tlbie */
12757+#define PENT_EA_LAST BIT(3) /* next entry is the pelist pointer */
12758+#define PENT_TOPEA_MASK 0x0f800000 /* bit 4-8 of ea */
12759+#define PENT_SV_BIT 0x00400000 /* PTE uses vsid_sv */
12760+#define PENT_INDEX_MASK 0x003fffff /* PTE index (there can be at most 2^22 PTEs) */
12761+#define PENT_CMP_MASK (PENT_TOPEA_MASK | PENT_SV_BIT)
12762+
12763+/* The index below corresponds to bit 15-19 of the ea. Bit 14 of the ea
12764+ * is stored in the pent field. Thus bits 14-19 of the ea can hence always
12765+ * be reconstructed (this struct is always properly aligned). Note that the
12766+ * pelist forms a ring (this is the reason why ea_next must be
12767+ * the first element in the pterec struct).
12768+ */
12769+
12770+typedef struct {
12771+ pterec_t *pelist[32]; /* always NULL if ring is empty */
12772+} pent_table_t;
12773+
12774+struct vsid_ent { /* record which describes a mac vsid */
12775+ vsid_ent_t *myself_virt; /* virtual address of this struct */
12776+ int linux_vsid; /* munged mac context | VSID(Kp) */
12777+ int linux_vsid_sv; /* munged privileged mac context | VSID(Kp) */
12778+ pent_table_t *lev2[64]; /* bit 9-14 of ea */
12779+};
12780+
12781+#define LEV2_MASK 0x0001ffff /* bit 15-31 */
12782+
12783+#define LEV2_IND(ea) (((ea) >> (12+5)) & 0x3f) /* lev2 index is bit 9-14 */
12784+#define PELIST_IND(ea) (((ea) >> 12) & 0x1f) /* pelist index is 15-19 */
12785+
12786+#define PTE_TO_IND(pte) ((((int)pte - (int)ptehash.base) & ptehash.pte_mask) >> 3)
12787+
12788+#define ZERO_PTE(pent) *((ulong*)ptehash.base + ((pent & PENT_INDEX_MASK) << 1)) = 0
12789+
12790+
12791+struct pte_lvrange {
12792+ pterec_t *pents;
12793+ ulong base; /* we want to do unsigned compares */
12794+ ulong size;
12795+ pte_lvrange_t *next; /* linked list */
12796+};
12797+
12798+typedef struct alloc_ent {
12799+ struct alloc_ent *next;
12800+ char *ptr;
12801+ int what; /* ALLOC_CONTENTS_XXX */
12802+} alloc_ent_t;
12803+
12804+struct vsid_info {
12805+ mol_spinlock_t lock; /* lvrange and pent ring lock */
12806+
12807+ pte_lvrange_t *lvrange_head;
12808+ pterec_t *free_pents; /* free list (lv_next is used) */
12809+ pent_table_t *free_pent_tables; /* pelist[0] is used for the linked list */
12810+
12811+ alloc_ent_t *allocations; /* the allocations we have performed */
12812+ int alloc_size; /* total size of allocations */
12813+ int alloc_limit; /* imposed limit */
12814+};
12815+
12816+/* don't change the CHUNK_SIZE unless you know what you are doing... */
12817+#define CHUNK_SIZE (0x1000 - sizeof(alloc_ent_t))
12818+
12819+#define ALLOC_CONT_ANY 0
12820+#define ALLOC_CONT_VSID 1
12821+#define ALLOC_CONT_PENT 2
12822+#define ALLOC_CONT_LEV2 3
12823+
12824+#define MMU (kv->mmu)
12825+
12826+#define LOCK spin_lock_mol( &vi->lock )
12827+#define UNLOCK spin_unlock_mol( &vi->lock )
12828+
12829+/*
12830+ * Remarks about locking: There is one asynchronous entrypoint
12831+ * (flush_lvptr). This function touches the lvranges as well
12832+ * as all pent rings. It will not free vsids or unlink
12833+ * level2 tables (but pents are put on the free list).
12834+ */
12835+
12836+
12837+/************************************************************************/
12838+/* Table Flushing */
12839+/************************************************************************/
12840+
12841+#define vsid_ent_lookup( kv, mvsid ) ((vsid_ent_t*)skiplist_lookup( &kv->mmu.vsid_sl, mvsid ))
12842+
12843+static void
12844+flush_vsid_ea_( vsid_info_t *vi, vsid_ent_t *r, ulong ea )
12845+{
12846+ pent_table_t *t = r->lev2[LEV2_IND(ea)];
12847+ pterec_t **pp, **headp, *pr, *next, *lvp;
12848+ uint topea, pent;
12849+ int worked;
12850+
12851+ if( !t || !(*(pp=&t->pelist[PELIST_IND(ea)])) )
12852+ return;
12853+
12854+ topea = (ea & PENT_TOPEA_MASK);
12855+ worked = 0;
12856+ headp = pp;
12857+ pr = *pp;
12858+ do {
12859+ pent = pr->pent;
12860+ next = pr->ea_next;
12861+
12862+ if( (pent & PENT_TOPEA_MASK) == topea ) {
12863+ worked = 1;
12864+ /* unlink ea */
12865+ *pp = pr->ea_next;
12866+
12867+ /* unlink it from lv ring (unless it is the lv-head) */
12868+ if( pent & PENT_LV_HEAD ) {
12869+ pr->pent = PENT_UNUSED | PENT_LV_HEAD;
12870+ } else {
12871+ /* it is not certain it belong to a lv ring at all... */
12872+ if( pr->lv_next ) {
12873+ for( lvp=pr->lv_next ; lvp->lv_next != pr ; lvp=lvp->lv_next )
12874+ ;
12875+ lvp->lv_next = pr->lv_next;
12876+ }
12877+ /* ...and put it on the free list */
12878+ //printk("pent released\n");
12879+ pr->lv_next = vi->free_pents;
12880+ vi->free_pents = pr;
12881+ }
12882+ ZERO_PTE( pent );
12883+
12884+ if( pent & PENT_EA_LAST ) {
12885+ if( pp == headp ) {
12886+ /* ring empty, set pelist pointer to NULL */
12887+ *headp = NULL;
12888+ } else {
12889+ /* put marker on previous entry */
12890+ ((pterec_t*)pp)->pent |= PENT_EA_LAST;
12891+ }
12892+ }
12893+ } else {
12894+ pp = &pr->ea_next;
12895+ }
12896+ pr = next;
12897+ } while( !(pent & PENT_EA_LAST) );
12898+
12899+ if( worked )
12900+ __tlbie( ea );
12901+}
12902+
12903+void
12904+flush_vsid_ea( kernel_vars_t *kv, int mac_vsid, ulong ea )
12905+{
12906+ vsid_info_t *vi = MMU.vsid_info;
12907+ vsid_ent_t *r;
12908+
12909+ LOCK;
12910+ if( (r=vsid_ent_lookup(kv, mac_vsid)) )
12911+ flush_vsid_ea_( vi, r, ea );
12912+ UNLOCK;
12913+}
12914+
12915+
12916+static void
12917+pent_flush_unlink_ea( pterec_t *pr )
12918+{
12919+ pterec_t **head, *prev;
12920+ uint ea;
12921+
12922+ //BUMP( pent_flush_unlink_ea );
12923+#ifdef DEBUG
12924+ if( pr->pent & PENT_UNUSED )
12925+ printk("pent_flush_unlink_ea: Internal error\n");
12926+#endif
12927+ /* find head and previous pent in ea ring */
12928+ for( prev=pr; !(prev->pent & PENT_EA_LAST); prev=prev->ea_next )
12929+ ;
12930+ head = (pterec_t**)prev->ea_next;
12931+ for( ; prev->ea_next != pr ; prev=prev->ea_next )
12932+ ;
12933+
12934+ if( (pr->pent & PENT_EA_LAST) ) {
12935+ /* just a single entry in the ea ring? */
12936+ if( prev == (pterec_t*)head ) {
12937+ pr->ea_next = NULL; /* prev->ea_next is set to this below */
12938+ } else {
12939+ prev->pent |= PENT_EA_LAST;
12940+ }
12941+ }
12942+ prev->ea_next = pr->ea_next;
12943+
12944+ /* OK... it is unlinked. Reconstruct EA and flush it */
12945+ ZERO_PTE( pr->pent );
12946+ ea = ((uint)head >> 2) & 0x1f; /* Bits 15-19 of ea */
12947+ if( pr->pent & PENT_EA_BIT14 )
12948+ ea |= 0x20;
12949+ ea = ea << 12;
12950+ __tlbie(ea); /* Bits 14-19 used */
12951+
12952+ // printk("lvflush: ea (bit 14-19) %08X (pent %08X)\n", ea, pr->pent );
12953+
12954+ /* caller's responsibility to free the pent */
12955+}
12956+
12957+static void
12958+flush_lvptr_( vsid_info_t *vi, ulong lvptr )
12959+{
12960+ pterec_t *head, *last, *first;
12961+ pte_lvrange_t *lvr;
12962+
12963+ //BUMP( pent_flush_lvptr );
12964+
12965+ for( lvr=vi->lvrange_head; lvr && lvptr - lvr->base >= lvr->size ; lvr=lvr->next )
12966+ ;
12967+ if( !lvr )
12968+ return;
12969+ // printk("flush_lvptr: %08lX\n", lvptr );
12970+
12971+ head = lvr->pents + ((lvptr - lvr->base) >> 12);
12972+#ifdef DEBUG
12973+ if( !(head->pent & PENT_LV_HEAD) ) {
12974+ printk("flush: Internal error\n");
12975+ return;
12976+ }
12977+#endif
12978+ /* first pent to be put on the free list */
12979+ first = head->lv_next;
12980+
12981+ /* not just a single entry? */
12982+ if( first != head ) {
12983+ last = head;
12984+ do {
12985+ last = last->lv_next;
12986+ pent_flush_unlink_ea( last );
12987+ } while( last->lv_next != head );
12988+
12989+ last->lv_next = vi->free_pents;
12990+ vi->free_pents = first;
12991+ }
12992+ if( !(head->pent & PENT_UNUSED) )
12993+ pent_flush_unlink_ea( head );
12994+
12995+ //head->ea_next = NULL;
12996+ head->lv_next = head;
12997+ head->pent = PENT_UNUSED | PENT_LV_HEAD;
12998+}
12999+
13000+/* asynchronous entrypoint (caused e.g. a swapout) */
13001+void
13002+flush_lvptr( kernel_vars_t *kv, ulong lvptr )
13003+{
13004+ vsid_info_t *vi = MMU.vsid_info;
13005+ LOCK;
13006+ if( (char*)lvptr == MMU.lvptr_reservation )
13007+ MMU.lvptr_reservation_lost = 1;
13008+ flush_lvptr_( vi, lvptr );
13009+ UNLOCK;
13010+}
13011+
13012+
13013+void
13014+flush_lv_range( kernel_vars_t *kv, ulong lvbase, int size )
13015+{
13016+ vsid_info_t *vi = MMU.vsid_info;
13017+ LOCK;
13018+ /* this is quite inefficient but the function is seldom used */
13019+ for( ; size > 0 ; lvbase += 0x1000, size -= 0x1000 )
13020+ flush_lvptr_( vi, lvbase );
13021+ UNLOCK;
13022+}
13023+
13024+void
13025+flush_ea_range( kernel_vars_t *kv, ulong org_ea, int size )
13026+{
13027+ vsid_info_t *vi = MMU.vsid_info;
13028+ skiplist_iter_t iter;
13029+ pent_table_t *t;
13030+ char *userdata;
13031+ ulong ea, end;
13032+ int i;
13033+
13034+ //BUMP( flush_ea_range );
13035+ //printk("flush_ea_range\n");
13036+
13037+ LOCK;
13038+#ifdef DEBUG
13039+ if( size > 0x10000000 || org_ea & 0xf0000000 ) {
13040+ printk("flush_ea_range: Bad parameters %08lX %08X\n", org_ea, size);
13041+ size=0x10000000;
13042+ org_ea=0;
13043+ }
13044+#endif
13045+ end = org_ea + size;
13046+
13047+ /* XXX: This is horribly inefficient */
13048+ iter = skiplist_iterate( &MMU.vsid_sl );
13049+ while( skiplist_getnext(&MMU.vsid_sl, &iter, &userdata) ) {
13050+ vsid_ent_t *r = (vsid_ent_t*)userdata;
13051+ ea = org_ea;
13052+ while( ea < end ) {
13053+ if( !(t=r->lev2[LEV2_IND(ea)]) ) {
13054+ ea = (ea & ~LEV2_MASK) + LEV2_MASK + 1;
13055+ continue;
13056+ }
13057+ for( i=PELIST_IND(ea); i<32 && ea < end; i++, ea += 0x1000 ) {
13058+ if( t->pelist[i] )
13059+ flush_vsid_ea_( vi, r, ea );
13060+ }
13061+ }
13062+ }
13063+ UNLOCK;
13064+}
13065+
13066+/* clear all pte entries belonging to this vsid */
13067+static void
13068+flush_vsid( vsid_info_t *vi, vsid_ent_t *r )
13069+{
13070+ pent_table_t *t;
13071+ ulong ea=0;
13072+ int i;
13073+
13074+ //BUMP( flush_vsid );
13075+
13076+ /* not very efficient */
13077+ while( ea < 0x10000000 ) {
13078+ if( !(t=r->lev2[LEV2_IND(ea)]) ) {
13079+ ea = (ea & ~LEV2_MASK) + LEV2_MASK + 1;
13080+ continue;
13081+ }
13082+ for( i=PELIST_IND(ea); i<32; i++, ea += 0x1000 ) {
13083+ if( t->pelist[i] )
13084+ flush_vsid_ea_( vi, r, ea );
13085+ }
13086+ }
13087+ /* free level2 tables */
13088+ for( i=0; i<64; i++ ) {
13089+ pent_table_t *t = r->lev2[i];
13090+ r->lev2[i] = NULL;
13091+
13092+ /* XXX: The lev2 table _should_ be empty but we
13093+ * might want to verify this...
13094+ */
13095+ if( t ) {
13096+ t->pelist[0] = (void*)vi->free_pent_tables;
13097+ vi->free_pent_tables = t;
13098+ }
13099+ }
13100+}
13101+
13102+
13103+/************************************************************************/
13104+/* Allocations */
13105+/************************************************************************/
13106+
13107+/* this function allocates 0x1000 - sizeof(alloc_ent_t) zeroed bytes */
13108+static void *
13109+do_chunk_kmalloc( vsid_info_t *vi, int what )
13110+{
13111+ alloc_ent_t *mp;
13112+ char *ptr;
13113+
13114+ if( vi->alloc_size > vi->alloc_limit )
13115+ return NULL;
13116+ if( !(ptr=(char*)alloc_page_mol()) )
13117+ return NULL;
13118+ mp = (alloc_ent_t*)((char*)ptr + 0x1000 - sizeof(alloc_ent_t));
13119+
13120+ mp->next = vi->allocations;
13121+ mp->ptr = ptr;
13122+ mp->what = what;
13123+ vi->allocations = mp;
13124+
13125+ vi->alloc_size += 0x1000;
13126+ BUMP_N( alloced, 0x1000 );
13127+ return ptr;
13128+}
13129+
13130+static void
13131+do_kfree( vsid_info_t *vi, int what )
13132+{
13133+ alloc_ent_t *p, **mp = &vi->allocations;
13134+
13135+ while( *mp ) {
13136+ p = *mp;
13137+ if( p->what == what || what == ALLOC_CONT_ANY ) {
13138+ *mp = p->next;
13139+ free_page_mol( (ulong)p->ptr );
13140+
13141+ vi->alloc_size -= 0x1000;
13142+ BUMP_N( released, 0x1000 );
13143+ } else {
13144+ mp = &p->next;
13145+ }
13146+ }
13147+}
13148+
13149+/* Note: mtable_memory_check() must have been called previously */
13150+static inline pent_table_t *
13151+get_free_lev2( vsid_info_t *vi )
13152+{
13153+ pent_table_t *t = vi->free_pent_tables;
13154+
13155+ vi->free_pent_tables = (pent_table_t*)vi->free_pent_tables->pelist[0];
13156+ t->pelist[0] = NULL;
13157+ return t;
13158+}
13159+
13160+/* this function is responsible for setting PENT_LV_HEAD and lv_next */
13161+static pterec_t *
13162+get_free_pent( vsid_info_t *vi, pte_lvrange_t *lvrange, char *lvptr )
13163+{
13164+ pterec_t *pr, *pr2;
13165+ int pent = 0;
13166+ int ind;
13167+
13168+ if( lvrange ) {
13169+ ind = (((int)lvptr - lvrange->base) >> 12);
13170+ pr2 = &lvrange->pents[ind];
13171+
13172+ if( (pr2->pent & PENT_UNUSED) ) {
13173+ pr = pr2;
13174+ pent = PENT_LV_HEAD;
13175+ } else {
13176+ /* alloc new entry */
13177+ pr = vi->free_pents;
13178+ vi->free_pents = pr->lv_next;
13179+
13180+ /* add to lv ring (after the head element) */
13181+ pr->lv_next = pr2->lv_next;
13182+ pr2->lv_next = pr;
13183+ }
13184+ } else {
13185+ /* alloc new entry */
13186+ pr = vi->free_pents;
13187+ vi->free_pents = pr->lv_next;
13188+
13189+ pr->lv_next = NULL;
13190+ }
13191+
13192+ /* allocate pterec_t and insert into the lv ring */
13193+ pr->pent = pent;
13194+ return pr;
13195+}
13196+
13197+static int
13198+lev2_alloc( vsid_info_t *vi )
13199+{
13200+ const int m = sizeof(pent_table_t) - 1;
13201+ pent_table_t *t;
13202+ int i, n = CHUNK_SIZE/sizeof(pent_table_t);
13203+
13204+ //BUMP( lev2_alloc );
13205+
13206+ if( !(t=do_chunk_kmalloc(vi, ALLOC_CONT_LEV2)) )
13207+ return 1;
13208+
13209+ /* the alignment must be correct (the ea calculation will fail otherwise) */
13210+ if( (int)t & m ) {
13211+ t = (pent_table_t*)((int)t + m + 1 - ((int)t & m));
13212+ n--;
13213+ }
13214+
13215+ memset( t, 0, n*sizeof(pent_table_t) );
13216+ for( i=0; i<n-1; i++ )
13217+ t[i].pelist[0] = (void*)&t[i+1];
13218+ LOCK;
13219+ t[i].pelist[0] = (void*)vi->free_pent_tables;
13220+ vi->free_pent_tables = &t[0];
13221+ UNLOCK;
13222+ return 0;
13223+}
13224+
13225+static int
13226+pent_alloc( vsid_info_t *vi )
13227+{
13228+ const int n = CHUNK_SIZE/sizeof(pterec_t);
13229+ pterec_t *pr;
13230+ int i;
13231+
13232+ //BUMP( pent_alloc );
13233+
13234+ if( !(pr=do_chunk_kmalloc(vi, ALLOC_CONT_PENT)) )
13235+ return 1;
13236+ memset( pr, 0, CHUNK_SIZE );
13237+
13238+ for( i=0; i<n-1; i++ )
13239+ pr[i].lv_next = &pr[i+1];
13240+ LOCK;
13241+ pr[i].lv_next = vi->free_pents;
13242+ vi->free_pents = &pr[0];
13243+ UNLOCK;
13244+ return 0;
13245+}
13246+
13247+
13248+/* This function is to be called at a safe time (it might allocate
13249+ * memory). It ensures the next pte_inserted call will succeed.
13250+ */
13251+int
13252+mtable_memory_check( kernel_vars_t *kv )
13253+{
13254+ vsid_info_t *vi = MMU.vsid_info;
13255+
13256+ /* optimize the common case */
13257+ if( vi->free_pents && vi->free_pent_tables )
13258+ return 0;
13259+
13260+ if( !vi->free_pent_tables )
13261+ lev2_alloc(vi);
13262+ if( !vi->free_pents )
13263+ pent_alloc(vi);
13264+
13265+ if( !vi->free_pents || !vi->free_pent_tables ) {
13266+ clear_all_vsids( kv );
13267+ return 1;
13268+ }
13269+ return 0;
13270+}
13271+
13272+
13273+/************************************************************************/
13274+/* pte_insert */
13275+/************************************************************************/
13276+
13277+static inline void
13278+relink_lv( vsid_info_t *vi, pterec_t *pr, pte_lvrange_t *lvrange, char *lvptr )
13279+{
13280+ int ind = (((int)lvptr - lvrange->base) >> 12);
13281+ pterec_t *pnew, *p, *lv_head = &lvrange->pents[ind];
13282+
13283+ if( !pr->lv_next ) {
13284+ //printk("Not previously on lvlist\n");
13285+ pr->lv_next = lv_head->lv_next;
13286+ lv_head->lv_next = pr;
13287+ return;
13288+ }
13289+
13290+ if( pr->pent & PENT_LV_HEAD ) {
13291+ if( pr == lv_head ) {
13292+ //printk("lvptr is head (correct lv ring)\n");
13293+ return;
13294+ }
13295+
13296+ /* unlink from ea ring and add new pent */
13297+ for( p=pr->ea_next; p->ea_next != pr ; p=p->ea_next )
13298+ ;
13299+ pnew = get_free_pent( vi, lvrange, lvptr );
13300+ pnew->ea_next = pr->ea_next;
13301+ p->ea_next = pnew;
13302+
13303+ pnew->pent |= (pr->pent & ~(PENT_UNUSED | PENT_LV_HEAD));
13304+
13305+ /* clear old lvhead */
13306+ // pr->ea_next = NULL;
13307+ pr->pent = PENT_LV_HEAD | PENT_UNUSED;
13308+
13309+ //printk("lvptr is head\n");
13310+ return;
13311+ } else {
13312+ for( p=pr->lv_next; !(p->pent & PENT_LV_HEAD) ; p=p->lv_next )
13313+ ;
13314+ if( p == lv_head ) {
13315+ //printk("lvptr is on the correct lv ring\n");
13316+ return;
13317+ }
13318+
13319+ /* lvptr has chagned, unlink */
13320+ for( ; p->lv_next != pr ; p=p->lv_next )
13321+ ;
13322+ p->lv_next = pr->lv_next;
13323+
13324+ /* add to lv ring */
13325+ pr->lv_next = lv_head->lv_next;
13326+ lv_head->lv_next = pr;
13327+ }
13328+}
13329+
13330+/* Note: If lvrange is NULL then lvptr should be ignored */
13331+void
13332+pte_inserted( kernel_vars_t *kv, ulong ea, char *lvptr, pte_lvrange_t *lvrange,
13333+ ulong *pte, vsid_ent_t *r, int segreg )
13334+{
13335+ vsid_info_t *vi = MMU.vsid_info;
13336+ int pl_ind = PELIST_IND(ea);
13337+ uint pent, pent_cmp;
13338+ pterec_t *pr, **pp;
13339+ pent_table_t **tt;
13340+
13341+ LOCK;
13342+ if( lvrange && MMU.lvptr_reservation_lost ) {
13343+ printk("mtable: lvptr reservation lost %08x\n", (int)lvptr );
13344+ pte[0] = 0;
13345+ __tlbie(ea);
13346+ goto out;
13347+ }
13348+
13349+ tt = &r->lev2[ LEV2_IND(ea) ];
13350+
13351+ pent_cmp = (ea & PENT_TOPEA_MASK);
13352+ if( (r->linux_vsid_sv & VSID_MASK) == (segreg & VSID_MASK) )
13353+ pent_cmp |= PENT_SV_BIT;
13354+
13355+ if( !*tt )
13356+ *tt = get_free_lev2(vi);
13357+
13358+ pp = &(**tt).pelist[ pl_ind ];
13359+ if( (pr=*pp) ) {
13360+ do {
13361+ pent = pr->pent;
13362+ if( (pent & PENT_CMP_MASK) == pent_cmp ) {
13363+ pent &= ~PENT_INDEX_MASK;
13364+ pent |= PTE_TO_IND(pte);
13365+ pr->pent = pent;
13366+
13367+ /* the lvptr might have changed */
13368+ if( lvrange )
13369+ relink_lv( vi, pr, lvrange, lvptr );
13370+ else {
13371+ /* The pent might belong to a lvring unnecessarily.
13372+ * It is not worth the extra overhead addressing this
13373+ * (uncommon) case
13374+ */
13375+ }
13376+ //printk("PTE entry reused\n");
13377+ goto out;
13378+ }
13379+ pr=pr->ea_next;
13380+ } while( !(pent & PENT_EA_LAST) );
13381+
13382+ /* get_free_pent inserts the entry into the lvring and sets a few pent bits */
13383+ pr = get_free_pent(vi, lvrange, lvptr);
13384+ pr->pent |= PTE_TO_IND(pte) | pent_cmp | ((ea & BIT(14)) ? PENT_EA_BIT14 : 0);
13385+
13386+ /* insert in (non-empty) ea ring */
13387+ pr->ea_next = *pp;
13388+ *pp = pr;
13389+ } else {
13390+ /* ea ring was empty */
13391+ pr = *pp = get_free_pent(vi, lvrange, lvptr);
13392+ pr->pent |= PENT_EA_LAST | PTE_TO_IND(pte) | pent_cmp
13393+ | ((ea & BIT(14)) ? PENT_EA_BIT14 : 0);
13394+ pr->ea_next = (pterec_t*)pp;
13395+ }
13396+ out:
13397+ UNLOCK;
13398+}
13399+
13400+
13401+/************************************************************************/
13402+/* VSID allocation */
13403+/************************************************************************/
13404+
13405+/* initialize vsid element callback (ind loops from 0 to n-1) */
13406+static void
13407+_vsid_el_callback( char *data, int ind, int n, void *usr1_kv, void *dummy )
13408+{
13409+ kernel_vars_t *kv = (kernel_vars_t*)usr1_kv;
13410+ vsid_ent_t *r = (vsid_ent_t*)data;
13411+
13412+ r->linux_vsid = alloc_context(kv) | VSID_Kp;
13413+ r->linux_vsid_sv = alloc_context(kv) | VSID_Kp;
13414+ r->myself_virt = r;
13415+}
13416+
13417+/* mac_vsid might be negative (used as vsid for unmapped access).
13418+ * Thus, do not apply this VSID mask anywhere...
13419+ */
13420+static vsid_ent_t *
13421+alloc_vsid_ent( kernel_vars_t *kv, int mac_vsid )
13422+{
13423+ char *buf;
13424+
13425+ if( skiplist_needalloc(&MMU.vsid_sl) ) {
13426+ /* this check might invoke clear_all_vsids() */
13427+ handle_context_wrap( kv, CHUNK_SIZE/sizeof(vsid_ent_t)*2 );
13428+
13429+ if( !(buf=do_chunk_kmalloc(MMU.vsid_info, ALLOC_CONT_VSID)) )
13430+ return NULL;
13431+ memset( buf, 0, CHUNK_SIZE );
13432+
13433+ (void) skiplist_prealloc( &MMU.vsid_sl, buf, CHUNK_SIZE, _vsid_el_callback, kv, NULL );
13434+ }
13435+ return (vsid_ent_t*)skiplist_insert( &MMU.vsid_sl, mac_vsid );
13436+}
13437+
13438+/* flushes all vsids (including the fake no-MMU vsids) */
13439+void
13440+clear_all_vsids( kernel_vars_t *kv )
13441+{
13442+ vsid_info_t *vi = MMU.vsid_info;
13443+ skiplist_iter_t iter;
13444+ char *userdata;
13445+
13446+ LOCK;
13447+ iter = skiplist_iterate( &MMU.vsid_sl );
13448+ while( skiplist_getnext(&MMU.vsid_sl, &iter, &userdata) )
13449+ flush_vsid( vi, (vsid_ent_t*)userdata );
13450+
13451+ skiplist_init( &MMU.vsid_sl, sizeof(vsid_ent_t) );
13452+
13453+ /* flush any dangling pointers */
13454+ clear_vsid_refs( kv );
13455+
13456+ /* all vsids cleared -> all lev2 cleared -> no pents in use */
13457+ vi->free_pents = NULL;
13458+ vi->free_pent_tables = NULL;
13459+ UNLOCK;
13460+ do_kfree( vi, ALLOC_CONT_ANY );
13461+
13462+ BUMP(clear_all_vsids);
13463+}
13464+
13465+/* This function flushes *ALL* PTEs inserted by MOL. It is primarily
13466+ * used when it is too difficult to make a more specific invalidation.
13467+ */
13468+void
13469+clear_pte_hash_table( kernel_vars_t *kv )
13470+{
13471+ /* this will free the vsids too... */
13472+ clear_all_vsids( kv );
13473+}
13474+
13475+vsid_ent_t *
13476+vsid_get_user_sv( kernel_vars_t *kv, int mac_vsid, ulong *user_ret, ulong *sv_ret )
13477+{
13478+ vsid_ent_t *r = vsid_ent_lookup( kv, mac_vsid );
13479+
13480+ if( !r && !(r=alloc_vsid_ent(kv, mac_vsid)) ) {
13481+ clear_all_vsids( kv );
13482+ if( !(r=alloc_vsid_ent(kv, mac_vsid)) ) {
13483+ printk("VSID allocation failure\n");
13484+ return NULL;
13485+ }
13486+ }
13487+ *user_ret = r->linux_vsid;
13488+ *sv_ret = r->linux_vsid_sv;
13489+ return r;
13490+}
13491+
13492+/************************************************************************/
13493+/* resource reclaiming */
13494+/************************************************************************/
13495+
13496+void
13497+mtable_reclaim( kernel_vars_t *kv )
13498+{
13499+ vsid_info_t *vi = MMU.vsid_info;
13500+ skiplist_iter_t iter;
13501+ pent_table_t *t;
13502+ char *userdata;
13503+ int i,j;
13504+
13505+ /* This thread runs on the main thread, thus the skiplist stuff does
13506+ * not need locking. In fact, it is only the free_pent_tables
13507+ * list that needs spinlock protection.
13508+ */
13509+ LOCK;
13510+ iter = skiplist_iterate( &MMU.vsid_sl );
13511+ while( skiplist_getnext(&MMU.vsid_sl, &iter, &userdata) ) {
13512+ vsid_ent_t *r = (vsid_ent_t*)userdata;
13513+ const int n1 = sizeof(r->lev2)/sizeof(r->lev2[0]);
13514+ const int n2 = sizeof(t->pelist)/sizeof(t->pelist[0]);
13515+
13516+ for( i=0; i<n1; i++ ) {
13517+ if( !(t=r->lev2[i]) )
13518+ continue;
13519+ for( j=0; j<n2 && !(t->pelist[j]) ; j++ )
13520+ ;
13521+ if( j != n2 )
13522+ break;
13523+ /* level2 empty... */
13524+ r->lev2[i]->pelist[0] = (void*)vi->free_pent_tables;
13525+ vi->free_pent_tables = r->lev2[i];
13526+ r->lev2[i] = NULL;
13527+
13528+ BUMP(lev2_reclaim);
13529+ }
13530+ if( i == n1 ) {
13531+ int vsid = skiplist_iter_getkey( &MMU.vsid_sl, (char*)r );
13532+
13533+ /* the segment might be in use... */
13534+ for( i=0; i<16 && MMU.vsid[i] != r; i++ )
13535+ ;
13536+ if( i != 16 || (uint)vsid > VSID_MASK )
13537+ continue;
13538+ skiplist_delete( &MMU.vsid_sl, vsid );
13539+ BUMP(vsid_reclaim);
13540+ }
13541+ }
13542+ UNLOCK;
13543+}
13544+
13545+/************************************************************************/
13546+/* lvrange allocation */
13547+/************************************************************************/
13548+
13549+pte_lvrange_t *
13550+register_lvrange( kernel_vars_t *kv, char *lvbase, int size )
13551+{
13552+ vsid_info_t *vi = MMU.vsid_info;
13553+ pte_lvrange_t *lvr;
13554+ int i, nel = (size >> 12);
13555+ int s = sizeof(pterec_t) * nel;
13556+
13557+ /* printk("register_lvrange\n"); */
13558+
13559+ if( !(lvr=kmalloc_mol(sizeof(pte_lvrange_t))) )
13560+ return NULL;
13561+ memset( lvr, 0, sizeof(pte_lvrange_t) );
13562+
13563+ if( !(lvr->pents=vmalloc_mol(s)) ) {
13564+ kfree_mol( lvr );
13565+ return NULL;
13566+ }
13567+ /* setup empty lvrings */
13568+ for( i=0; i<nel; i++ ) {
13569+ lvr->pents[i].pent = PENT_LV_HEAD | PENT_UNUSED;
13570+ lvr->pents[i].lv_next = &lvr->pents[i];
13571+ lvr->pents[i].ea_next = NULL;
13572+ }
13573+ lvr->base = (ulong)lvbase;
13574+ lvr->size = size;
13575+
13576+ LOCK;
13577+ /* add to linked list */
13578+ lvr->next = vi->lvrange_head;
13579+ vi->lvrange_head = lvr;
13580+ UNLOCK;
13581+
13582+ return lvr;
13583+}
13584+
13585+void
13586+free_lvrange( kernel_vars_t *kv, pte_lvrange_t *lvrange )
13587+{
13588+ vsid_info_t *vi = MMU.vsid_info;
13589+ pte_lvrange_t **lvr;
13590+
13591+ lvr = &vi->lvrange_head;
13592+ for( ; *lvr && *lvr != lvrange; lvr=&(**lvr).next )
13593+ ;
13594+ if( !*lvr ) {
13595+ printk("free_lvrange: Internal error\n");
13596+ return;
13597+ }
13598+ flush_lv_range( kv, (**lvr).base, (**lvr).size );
13599+ LOCK;
13600+ *lvr = (**lvr).next;
13601+ UNLOCK;
13602+
13603+ vfree_mol( lvrange->pents );
13604+ kfree_mol( lvrange );
13605+}
13606+
13607+/************************************************************************/
13608+/* init / cleanup */
13609+/************************************************************************/
13610+
13611+void
13612+mtable_tune_alloc_limit( kernel_vars_t *kv, int ramsize_mb )
13613+{
13614+ vsid_info_t *vi = MMU.vsid_info;
13615+ vi->alloc_limit = (ramsize_mb + 160) * 4096;
13616+ /* printk("alloc_limit: %d K\n", vi->alloc_limit/1024 ); */
13617+}
13618+
13619+int
13620+init_mtable( kernel_vars_t *kv )
13621+{
13622+ vsid_info_t *vi = kmalloc_mol( sizeof(vsid_info_t) );
13623+
13624+ MMU.vsid_info = vi;
13625+ if( !vi )
13626+ return 1;
13627+ memset( vi, 0, sizeof(vsid_info_t) );
13628+ spin_lock_init_mol( &vi->lock );
13629+
13630+ /* will be tuned when we know how much RAM we have */
13631+ vi->alloc_limit = 2 * 1024 * 1024;
13632+
13633+ skiplist_init( &MMU.vsid_sl, sizeof(vsid_ent_t) );
13634+
13635+ if( !VSID_OFFSETS_OK ) {
13636+ printk("VSID offsets are BAD (fix offset in source)!\n");
13637+ return 1;
13638+ }
13639+ return 0;
13640+}
13641+
13642+void
13643+cleanup_mtable( kernel_vars_t *kv )
13644+{
13645+ vsid_info_t *vi = MMU.vsid_info;
13646+
13647+ if( vi ) {
13648+ while( vi->lvrange_head ) {
13649+ printk("Bug: lvrange unreleased!\n");
13650+ free_lvrange( kv, vi->lvrange_head );
13651+ }
13652+ do_kfree( vi, ALLOC_CONT_ANY );
13653+ kfree_mol( vi );
13654+ }
13655+ memset( &MMU.vsid_sl, 0, sizeof(MMU.vsid_sl) );
13656+ MMU.vsid_info = NULL;
13657+}
13658+
13659+
13660+/************************************************************************/
13661+/* userland debug */
13662+/************************************************************************/
13663+
13664+#ifdef UL_DEBUG
13665+#include "mtable_dbg.c"
13666+#endif
13667--- /dev/null
13668+++ b/drivers/macintosh/mol/ptaccess.c
13669@@ -0,0 +1,153 @@
13670+/*
13671+ * Creation Date: <2001/03/25 18:04:45 samuel>
13672+ * Time-stamp: <2002/08/03 17:43:10 samuel>
13673+ *
13674+ * <ptaccess.c>
13675+ *
13676+ * Handle stores to the (emulated) page table
13677+ *
13678+ * Copyright (C) 2001, 2002 Samuel Rydh (samuel@ibrium.se)
13679+ *
13680+ * This program is free software; you can redistribute it and/or
13681+ * modify it under the terms of the GNU General Public License
13682+ * as published by the Free Software Foundation
13683+ *
13684+ */
13685+
13686+#include "archinclude.h"
13687+#include "mmu.h"
13688+#include "rvec.h"
13689+#include "mtable.h"
13690+#include "misc.h"
13691+#include "performance.h"
13692+
13693+extern int do_intercept_tlbie( kernel_vars_t *kv, ulong pte0, ulong pte1, ulong pteoffs );
13694+extern int do_intercept_tlbie_block( kernel_vars_t *kv, ulong pteoffs, ulong length );
13695+
13696+#define MMU (kv->mmu)
13697+#define MREGS (kv->mregs)
13698+
13699+int
13700+do_intercept_tlbie( kernel_vars_t *kv, ulong pte0, ulong pte1, ulong pteoffs )
13701+{
13702+ int vsid = (pte0 >> 7) & VSID_MASK;
13703+ ulong v;
13704+
13705+ BUMP( do_intercept_tlbie );
13706+
13707+ if( MMU.pthash_inuse_bits )
13708+ clear_bit_mol( pteoffs >> 3, MMU.pthash_inuse_bits );
13709+
13710+ v = (pteoffs >> 6);
13711+ if( pte0 & BIT(25) ) /* secondary hash? */
13712+ v = ~v;
13713+ v ^= (pte0 >> 7);
13714+ v = ((pte0 << 10) & 0xfc00) | (v & 0x3ff);
13715+
13716+ //printk("do_intercept_tlbie: vsid %08lX, ea %08lX\n", vsid, (v<<12) );
13717+ flush_vsid_ea( kv, vsid, (v<<12) );
13718+
13719+ return RVEC_NOP;
13720+}
13721+
13722+int
13723+do_intercept_tlbie_block( kernel_vars_t *kv, ulong pteoffs, ulong length )
13724+{
13725+ unsigned int finish;
13726+
13727+ //printk("do_intercept_tlbie_block: pteoffs %08lX length %08lX\n", pteoffs, length);
13728+
13729+ if (pteoffs + length > MMU.hash_mask) {
13730+ printk("do_intercept_tlbie_block: length exceeding hash!\n");
13731+ finish = MMU.hash_mask + 1;
13732+ } else
13733+ finish = pteoffs + length;
13734+
13735+ if (MMU.pthash_inuse_bits == NULL)
13736+ return RVEC_NOP;
13737+
13738+ while (pteoffs < finish) {
13739+ if (check_bit_mol(pteoffs >> 3, MMU.pthash_inuse_bits)) {
13740+ ulong pte0, pte1;
13741+
13742+ pte0 = *((unsigned int *) (MMU.hash_base + pteoffs));
13743+ pte1 = *((unsigned int *) (MMU.hash_base + pteoffs + 4));
13744+ do_intercept_tlbie(kv, pte0, pte1, pteoffs);
13745+ }
13746+
13747+ pteoffs += 8;
13748+ }
13749+
13750+ return RVEC_NOP;
13751+}
13752+
13753+#ifdef EMULATE_603
13754+
13755+extern int do_tlbli( kernel_vars_t *kv, ulong ea );
13756+extern int do_tlbld( kernel_vars_t *kv, ulong ea );
13757+
13758+int
13759+do_tlbli( kernel_vars_t *kv, ulong ea )
13760+{
13761+ int ind = (ea >> 12) & 0x1f;
13762+ mPTE_t *p;
13763+
13764+ //printk("do_tlbli %08lX : %08lX %08lX\n", ea, MREGS.spr[S_ICMP], MREGS.spr[S_RPA] );
13765+ if( MREGS.spr[S_SRR1] & BIT(14) )
13766+ ind += 32;
13767+
13768+ p = &MMU.ptes_i_603[ind];
13769+ if( p->v )
13770+ flush_vsid_ea( kv, p->vsid, MMU.ptes_i_ea_603[ind] );
13771+ MMU.ptes_i_ea_603[ind] = ea & 0x0ffff000;
13772+ *(ulong*)p = MREGS.spr[ S_ICMP ];
13773+ *((ulong*)p+1) = MREGS.spr[ S_RPA ];
13774+
13775+ return RVEC_NOP;
13776+}
13777+
13778+int
13779+do_tlbld( kernel_vars_t *kv, ulong ea )
13780+{
13781+ int ind = (ea >> 12) & 0x1f;
13782+ mPTE_t *p;
13783+
13784+ //printk("do_tlbld %08lX\n", ea );
13785+
13786+ if( MREGS.spr[S_SRR1] & BIT(14) )
13787+ ind += 32;
13788+
13789+ p = &MMU.ptes_d_603[ind];
13790+ if( p->v )
13791+ flush_vsid_ea( kv, p->vsid, MMU.ptes_d_ea_603[ind] );
13792+ MMU.ptes_d_ea_603[ind] = ea & 0x0ffff000;
13793+ *(ulong*)p = MREGS.spr[ S_DCMP ];
13794+ *((ulong*)p+1) = MREGS.spr[ S_RPA ];
13795+
13796+ return RVEC_NOP;
13797+}
13798+
13799+int
13800+do_tlbie( kernel_vars_t *kv, ulong ea )
13801+{
13802+ int ind = (ea >> 12) & 0x1f;
13803+ mPTE_t *pi, *pd;
13804+ ulong *iea, *dea;
13805+
13806+ pi = &MMU.ptes_i_603[ind];
13807+ pd = &MMU.ptes_d_603[ind];
13808+ iea = &MMU.ptes_i_ea_603[ind];
13809+ dea = &MMU.ptes_d_ea_603[ind];
13810+ for( ; ind < 64; ind +=32, pd += 32, pi += 32, iea += 32, dea +=32 ) {
13811+ if( pi->v )
13812+ flush_vsid_ea( kv, pi->vsid, *iea );
13813+ if( pd->v )
13814+ flush_vsid_ea( kv, pd->vsid, *dea );
13815+ *(ulong*)pi = 0;
13816+ *(ulong*)pd = 0;
13817+ }
13818+ return RVEC_NOP;
13819+}
13820+
13821+#endif /* EMULATE_603 */
13822+
13823--- /dev/null
13824+++ b/drivers/macintosh/mol/sheep.c
13825@@ -0,0 +1,701 @@
13826+/*
13827+ * sheep_net.c - Linux driver for SheepShaver/Basilisk II networking (access to raw Ethernet packets)
13828+ *
13829+ * SheepShaver (C) 1997-1999 Mar"c" Hellwig and Christian Bauer
13830+ * Basilisk II (C) 1997-1999 Christian Bauer
13831+ *
13832+ * Ported to 2.4 and reworked, Samuel Rydh 1999-2003
13833+ */
13834+
13835+#include <linux/kernel.h>
13836+#include <linux/module.h>
13837+#include <linux/version.h>
13838+#include <linux/miscdevice.h>
13839+#include <linux/netdevice.h>
13840+#include <linux/etherdevice.h>
13841+#include <linux/if_ether.h>
13842+#include <linux/if_arp.h>
13843+#include <linux/fs.h>
13844+#include <linux/poll.h>
13845+#include <linux/init.h>
13846+#include <net/sock.h>
13847+#include <asm/uaccess.h>
13848+#include <net/arp.h>
13849+#include <net/ip.h>
13850+#include <linux/in.h>
13851+#include <linux/wait.h>
13852+
13853+MODULE_AUTHOR("Marc Hellwig and Christian Bauer");
13854+MODULE_DESCRIPTION("SheepShaver/Basilisk II networking");
13855+MODULE_LICENSE("GPL");
13856+
13857+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
13858+#define LINUX_26
13859+#endif
13860+
13861+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,9)
13862+#define ETH_HDR(skb) eth_hdr((skb))
13863+#else
13864+#define ETH_HDR(skb) (skb)->mac.ethernet
13865+#endif
13866+
13867+#define DEBUG 0
13868+
13869+#define bug printk
13870+#if DEBUG
13871+#define D(x) (x);
13872+#else
13873+#define D(x) ;
13874+#endif
13875+
13876+#define SHEEP_NET_MINOR 198 // Driver minor number
13877+#define MAX_QUEUE 32 // Maximum number of packets in queue
13878+#define PROT_MAGIC 1520 // Our "magic" protocol type
13879+
13880+#define ETH_ADDR_MULTICAST 0x1
13881+#define ETH_ADDR_LOCALLY_DEFINED 0x2
13882+
13883+#define SIOC_MOL_GET_IPFILTER SIOCDEVPRIVATE
13884+#define SIOC_MOL_SET_IPFILTER (SIOCDEVPRIVATE + 1)
13885+
13886+struct SheepVars {
13887+ /* IMPORTANT: the packet_type struct must go first. It no longer (2.6) contains
13888+ * a data field so we typecast to get the SheepVars struct
13889+ */
13890+ struct packet_type pt; // Receiver packet type
13891+ struct net_device *ether; // The Ethernet device we're attached to
13892+ struct sock *skt; // Socket for communication with Ethernet card
13893+ struct sk_buff_head queue; // Receiver packet queue
13894+ wait_queue_head_t wait; // Wait queue for blocking read operations
13895+ unsigned long ipfilter; // only receive ip packets destined for this address
13896+ char fake_addr[6];
13897+};
13898+
13899+/*
13900+ * How various hosts address MOL
13901+ *
13902+ * External hosts: eth_addr, MOL_IP
13903+ * Local host: fake_addr, MOL_IP
13904+ * MOL: fake_addr, MOL_IP
13905+ */
13906+
13907+#ifdef LINUX_26
13908+
13909+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12))
13910+#define compat_sk_alloc(a,b,c) sk_alloc( (a), (b), &mol_proto, 1 )
13911+#else
13912+#define compat_sk_alloc(a,b,c) sk_alloc( (a), (b), (c), NULL )
13913+#endif
13914+
13915+#define skt_set_dead(skt) do {} while(0)
13916+#define wmem_alloc sk_wmem_alloc
13917+#else
13918+#define compat_sk_alloc sk_alloc
13919+#define skt_set_dead(skt) (skt)->dead = 1
13920+#endif
13921+
13922+/************************************************************************/
13923+/* ethernet address masquerading */
13924+/************************************************************************/
13925+
13926+static inline int
13927+addrcmp( const char *a1, const char *a2 )
13928+{
13929+ if( *(u32*)a1 != *(u32*)a2 )
13930+ return 1;
13931+ return *((u16*)a1+2) != *((u16*)a2+2);
13932+}
13933+
13934+/* Outgoing packet. Replace the fake enet addr with the real one. */
13935+static inline void
13936+cpyaddr( char *d, const char *s )
13937+{
13938+ *(u32*)d = *(u32*)s;
13939+ *(u16*)&d[4] = *(u16*)&s[4];
13940+}
13941+
13942+static void
13943+demasquerade( struct sk_buff *skb, struct SheepVars *v )
13944+{
13945+ const char *local_addr = v->ether->dev_addr;
13946+ const char *fake_addr = v->fake_addr;
13947+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,21))
13948+ char *p = skb_mac_header(skb);
13949+#else
13950+ char *p = skb->mac.raw;
13951+#endif
13952+ int proto = *(short*)&p[12];
13953+
13954+ cpyaddr( &p[6], local_addr ); // Source address
13955+
13956+ // Need to fix ARP packets
13957+ if( proto == htons(ETH_P_ARP) )
13958+ if( !addrcmp(&p[14+8], fake_addr) ) // sender HW-addr
13959+ cpyaddr( &p[14+8], local_addr );
13960+
13961+ // ...and AARPs (snap code: 0x00,0x00,0x00,0x80,0xF3)
13962+ if( !p[17] && *(u32*)&p[18] == 0x000080F3 ){
13963+ // XXX: we should perhaps look for the 802 frame too
13964+ if( !addrcmp(&p[30], fake_addr) )
13965+ cpyaddr( &p[30], local_addr ); // sender HW-addr
13966+ }
13967+}
13968+
13969+
13970+/************************************************************************/
13971+/* receive filter (also intercepts outgoing packets) */
13972+/************************************************************************/
13973+
13974+/* This function filters both outgoing and incoming traffic.
13975+ *
13976+ * - Outgoing PROT_MAGIC packets are outgoing mol packets
13977+ * addressed to the world (not to the local host).
13978+ *
13979+ * - Outgoing packets addressed to the fake address
13980+ * are incoming MOL packets (from the local host).
13981+ * These packets will be seen on the wire, since we can't
13982+ * block them...
13983+ *
13984+ * - Incoming packets which originate from the fake address
13985+ * are MOL packets addressed to the local host.
13986+ *
13987+ * - Incomming external traffic to the MOL IP address are incoming
13988+ * MOL packets. Linux will see these packets too. (Hmm... if
13989+ * we change protocol to PROT_MAGIC then linux ought to ignore
13990+ * them; currently linux responds to ICMP packets even though
13991+ * the IP address is wrong.)
13992+ */
13993+
13994+
13995+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14))
13996+static int
13997+sheep_net_receiver( struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev )
13998+#else
13999+static int
14000+sheep_net_receiver( struct sk_buff *skb, struct net_device *dev, struct packet_type *pt )
14001+#endif
14002+{
14003+ int multicast = (ETH_HDR(skb)->h_dest[0] & ETH_ADDR_MULTICAST);
14004+ const char *laddr = dev->dev_addr;
14005+ struct sk_buff *skb2;
14006+ struct SheepVars *v = (struct SheepVars*)pt;
14007+
14008+ D(bug("sheep_net: packet received\n"));
14009+
14010+ if( skb->pkt_type == PACKET_OUTGOING ) {
14011+ // Is this an MOL packet to the world?
14012+ if( skb->protocol == PROT_MAGIC )
14013+ goto drop;
14014+
14015+ if( !multicast ) {
14016+ // Drop, unless this is a localhost -> MOL transmission */
14017+ if( addrcmp((char*)&ETH_HDR(skb)->h_dest, v->fake_addr) )
14018+ goto drop;
14019+
14020+ /* XXX: If it were possible, we would prevent the packet from beeing sent out
14021+ * on the wire (after having put it on our packet reception queue).
14022+ * A transmission to a non-existent mac address will unfortunately
14023+ * be subnet-visible (having a switched network doesn't help). As a
14024+ * workaround, we change the destination address to the address of
14025+ * the controller. This way, the packet ought to be discarded by
14026+ * switches.
14027+ */
14028+ cpyaddr( &ETH_HDR(skb)->h_dest[0], laddr );
14029+ }
14030+ } else {
14031+ // is this a packet to the local host from MOL?
14032+ if( !addrcmp((char*)&ETH_HDR(skb)->h_source, v->fake_addr) )
14033+ goto drop;
14034+
14035+ if( !multicast ) {
14036+ // if the packet is not meant for this host, discard it
14037+ if( addrcmp((char*)&ETH_HDR(skb)->h_dest, laddr) )
14038+ goto drop;
14039+
14040+ // filter IP-traffic
14041+ if( (skb->protocol == htons(ETH_P_IP)) ) {
14042+ // drop if not addreesed to MOL?
14043+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,21))
14044+ if( !v->ipfilter || (ipip_hdr(skb)->daddr != v->ipfilter) )
14045+#else
14046+ if( !v->ipfilter || (skb->h.ipiph->daddr != v->ipfilter) )
14047+#endif
14048+ goto drop;
14049+ // we don't want this packet interpreted by linux...
14050+ skb->protocol = PROT_MAGIC;
14051+ }
14052+ }
14053+ }
14054+ // Discard packets if queue gets too full
14055+ if( skb_queue_len(&v->queue) > MAX_QUEUE )
14056+ goto drop;
14057+
14058+ /* masquerade. The skb is typically has a refcount != 1 so we play safe
14059+ * and make a copy before modifying it. This also takes care of fragmented
14060+ * skbuffs (we might receive those if we are attached to a device with support
14061+ * for it)
14062+ */
14063+ if( !(skb2=skb_copy(skb, GFP_ATOMIC)) )
14064+ goto drop;
14065+ kfree_skb( skb );
14066+ skb = skb2;
14067+
14068+ if( !multicast )
14069+ cpyaddr( &ETH_HDR(skb)->h_dest[0], v->fake_addr );
14070+
14071+ // We also want the Ethernet header
14072+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,21))
14073+ skb_push( skb, skb->data - skb_mac_header(skb) );
14074+#else
14075+ skb_push( skb, skb->data - skb->mac.raw );
14076+#endif
14077+
14078+ // Enqueue packet
14079+ skb_queue_tail( &v->queue, skb );
14080+
14081+ // Unblock blocked read
14082+ wake_up_interruptible( &v->wait );
14083+ return 0;
14084+
14085+drop:
14086+ kfree_skb( skb );
14087+ return 0;
14088+}
14089+
14090+
14091+/************************************************************************/
14092+/* misc device ops */
14093+/************************************************************************/
14094+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12))
14095+static struct proto mol_proto =
14096+{
14097+ .name = "MOL",
14098+ .owner = THIS_MODULE,
14099+ .obj_size = sizeof(struct sock)
14100+};
14101+#endif
14102+
14103+
14104+static int
14105+sheep_net_open( struct inode *inode, struct file *f )
14106+{
14107+ static char fake_addr_[6] = { 0xFE, 0xFD, 0xDE, 0xAD, 0xBE, 0xEF };
14108+ struct SheepVars *v;
14109+ D(bug("sheep_net: open\n"));
14110+
14111+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12))
14112+ if (proto_register(&mol_proto,0) < 0)
14113+ {
14114+ printk(KERN_INFO "Unable to register protocol type\n");
14115+ return -1;
14116+ }
14117+#endif
14118+
14119+ // Must be opened with read permissions
14120+ if( (f->f_flags & O_ACCMODE) == O_WRONLY )
14121+ return -EPERM;
14122+
14123+ // Allocate private variables
14124+ f->private_data = kmalloc(sizeof(struct SheepVars), GFP_USER);
14125+ if( f->private_data == NULL)
14126+ return -ENOMEM;
14127+
14128+ v = (struct SheepVars *) f->private_data;
14129+
14130+ memset( v, 0, sizeof(*v) );
14131+ memcpy( v->fake_addr, fake_addr_, 6 );
14132+
14133+ skb_queue_head_init( &v->queue );
14134+ init_waitqueue_head( &v->wait );
14135+ return 0;
14136+}
14137+
14138+
14139+static int
14140+sheep_net_release( struct inode *inode, struct file *f )
14141+{
14142+ struct SheepVars *v = (struct SheepVars *)f->private_data;
14143+ struct sk_buff *skb;
14144+ D(bug("sheep_net: close\n"));
14145+
14146+ // Detach from Ethernet card
14147+ if( v->ether ) {
14148+ dev_remove_pack( &v->pt );
14149+ sk_free( v->skt );
14150+ v->skt = NULL;
14151+ dev_put( v->ether );
14152+ v->ether = NULL;
14153+ }
14154+
14155+ // Empty packet queue
14156+ while( (skb=skb_dequeue(&v->queue)) )
14157+ kfree_skb(skb);
14158+
14159+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12))
14160+ proto_unregister(&mol_proto);
14161+#endif
14162+
14163+ // Free private variables
14164+ kfree(v);
14165+ return 0;
14166+}
14167+
14168+static inline int
14169+get_iovsize( const struct iovec *iv, int count )
14170+{
14171+ int s;
14172+ for( s=0; count-- ; iv++ )
14173+ s += iv->iov_len;
14174+ return s;
14175+}
14176+
14177+static int
14178+memcpy_tov( const struct iovec *iv, const char *buf, int s )
14179+{
14180+ while( s > 0 ) {
14181+ int len = min_t( unsigned int, iv->iov_len, s );
14182+
14183+ if( copy_to_user(iv->iov_base, buf, len) )
14184+ return -EFAULT;
14185+ s -= len;
14186+ buf += len;
14187+ iv++;
14188+ }
14189+ return 0;
14190+}
14191+
14192+static int
14193+memcpy_fromv( char *buf, const struct iovec *iv, int s )
14194+{
14195+ while( s > 0 ) {
14196+ int len = min_t( unsigned int, iv->iov_len, s );
14197+
14198+ if( copy_from_user(buf, iv->iov_base, len) )
14199+ return -EFAULT;
14200+ s -= len;
14201+ buf += len;
14202+ iv++;
14203+ }
14204+ return 0;
14205+}
14206+
14207+static ssize_t
14208+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
14209+sheep_net_aio_read(struct kiocb *iocb, const struct iovec *iv, unsigned long count, loff_t pos)
14210+{
14211+ struct file *f = iocb->ki_filp;
14212+#else /* Linux 2.6.18 or older */
14213+sheep_net_readv( struct file *f, const struct iovec *iv, unsigned long count, loff_t *pos )
14214+{
14215+#endif
14216+ struct SheepVars *v = (struct SheepVars *)f->private_data;
14217+ struct sk_buff *skb;
14218+ int size = get_iovsize( iv, count );
14219+
14220+ D(bug("sheep_net: read\n"));
14221+
14222+ while( !(skb=skb_dequeue(&v->queue)) ) {
14223+ // wait around...
14224+ if( (f->f_flags & O_NONBLOCK))
14225+ return -EAGAIN;
14226+
14227+ interruptible_sleep_on( &v->wait );
14228+
14229+ if( signal_pending(current) )
14230+ return -EINTR;
14231+ }
14232+
14233+ // Pass packet to caller
14234+ if( size > skb->len )
14235+ size = skb->len;
14236+ if( memcpy_tov(iv, skb->data, size) )
14237+ size = -EFAULT;
14238+
14239+ kfree_skb( skb );
14240+ return size;
14241+}
14242+
14243+static ssize_t
14244+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
14245+sheep_net_aio_write(struct kiocb *iocb, const struct iovec *iv, unsigned long count, loff_t off)
14246+{
14247+ struct file *f = iocb->ki_filp;
14248+#else /* Linux 2.6.18 or older */
14249+sheep_net_writev( struct file *f, const struct iovec *iv, unsigned long count, loff_t *off )
14250+{
14251+#endif
14252+ struct SheepVars *v = (struct SheepVars *)f->private_data;
14253+ struct sk_buff *skb;
14254+ int size = get_iovsize( iv, count );
14255+ char *p, *laddr;
14256+ D(bug("sheep_net: write\n"));
14257+
14258+ // Check packet size
14259+ if( size < sizeof(struct ethhdr) )
14260+ return -EINVAL;
14261+ if( size > 1514 ) {
14262+ printk("sheep_net_write: packet > 1514!\n");
14263+ size = 1514;
14264+ }
14265+
14266+ // Interface active?
14267+ if( !v->ether )
14268+ return size;
14269+ laddr = v->ether->dev_addr;
14270+
14271+ // Allocate buffer for packet
14272+ if( !(skb=dev_alloc_skb(size)) )
14273+ return -ENOBUFS;
14274+
14275+ // Stuff packet in buffer
14276+ p = skb_put( skb, size );
14277+ if( memcpy_fromv(p, iv, size) ) {
14278+ kfree_skb(skb);
14279+ return -EFAULT;
14280+ }
14281+
14282+ // Transmit packet
14283+ atomic_add( skb->truesize, &v->skt->wmem_alloc );
14284+ skb->sk = v->skt;
14285+ skb->dev = v->ether;
14286+ skb->priority = 0;
14287+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,21))
14288+ skb_set_network_header(skb, v->ether->hard_header_len);
14289+ skb_set_transport_header(skb, v->ether->hard_header_len);
14290+ skb_reset_mac_header(skb);
14291+#else
14292+ skb->nh.raw = skb->h.raw = skb->data + v->ether->hard_header_len;
14293+ skb->mac.raw = skb->data;
14294+#endif
14295+
14296+ // Base the IP-filter on the IP address of outgoing ARPs
14297+ if( ETH_HDR(skb)->h_proto == htons(ETH_P_ARP) ) {
14298+ char *s = &skb->data[14+14]; /* source IP-address */
14299+ int n[4];
14300+ if( *(long*)s != v->ipfilter ) {
14301+ v->ipfilter = *(long*)s;
14302+ n[0]=s[0], n[1]=s[1], n[2]=s[2], n[3]=s[3];
14303+ printk("IP-filter: %d.%d.%d.%d\n", n[0], n[1], n[2], n[3] );
14304+ }
14305+ }
14306+
14307+ // Is this package addressed solely to the local host?
14308+ if( !addrcmp(skb->data, laddr) && !(skb->data[0] & ETH_ADDR_MULTICAST) ) {
14309+ skb->protocol = eth_type_trans( skb, v->ether );
14310+ netif_rx_ni( skb );
14311+ return size;
14312+ }
14313+ if( skb->data[0] & ETH_ADDR_MULTICAST ) {
14314+ // We can't clone the skb since we will manipulate the data below
14315+ struct sk_buff *lskb = skb_copy( skb, GFP_ATOMIC );
14316+ if( lskb ) {
14317+ lskb->protocol = eth_type_trans( lskb, v->ether );
14318+ netif_rx_ni( lskb );
14319+ }
14320+ }
14321+ // Outgoing packet (will be seen on the wire)
14322+ demasquerade( skb, v );
14323+
14324+ skb->protocol = PROT_MAGIC; // Magic value (we can recognize the packet in sheep_net_receiver)
14325+ dev_queue_xmit( skb );
14326+ return size;
14327+}
14328+
14329+/* We take care of this using do_sync_* instead in 2.6.19 and newer */
14330+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
14331+static ssize_t
14332+sheep_net_read( struct file *f, char *buf, size_t count, loff_t *off )
14333+{
14334+ struct iovec iv;
14335+ iv.iov_base = buf;
14336+ iv.iov_len = count;
14337+ return sheep_net_readv( f, &iv, 1, off );
14338+}
14339+
14340+static ssize_t
14341+sheep_net_write( struct file *f, const char *buf, size_t count, loff_t *off )
14342+{
14343+ struct iovec iv;
14344+ iv.iov_len = count;
14345+ iv.iov_base = (char *)buf;
14346+ return sheep_net_writev( f, &iv, 1, off );
14347+}
14348+#endif
14349+
14350+static unsigned int
14351+sheep_net_poll( struct file *f, struct poll_table_struct *wait )
14352+{
14353+ struct SheepVars *v = (struct SheepVars *)f->private_data;
14354+ D(bug("sheep_net: poll\n"));
14355+
14356+ poll_wait( f, &v->wait, wait );
14357+
14358+ if( !skb_queue_empty(&v->queue) )
14359+ return POLLIN | POLLRDNORM;
14360+ return 0;
14361+}
14362+
14363+static int
14364+sheep_net_ioctl( struct inode *inode, struct file *f, unsigned int code, unsigned long arg )
14365+{
14366+ struct SheepVars *v = (struct SheepVars *)f->private_data;
14367+ D(bug("sheep_net: ioctl %04x\n", code));
14368+
14369+ switch( code ) {
14370+ // Attach to Ethernet card
14371+ // arg: pointer to name of Ethernet device (char[20])
14372+ case SIOCSIFLINK: {
14373+ char name[20];
14374+ int err;
14375+
14376+ // Already attached?
14377+ if( v->ether )
14378+ return -EBUSY;
14379+
14380+ // Get Ethernet card name
14381+ if( copy_from_user(name, (void *)arg, 20) )
14382+ return -EFAULT;
14383+ name[19] = 0;
14384+
14385+ // Find card
14386+ if( !(v->ether=dev_get_by_name(name)) )
14387+ return -ENODEV;
14388+
14389+ // Is it Ethernet?
14390+ if( v->ether->type != ARPHRD_ETHER) {
14391+ err = -EINVAL;
14392+ goto error;
14393+ }
14394+
14395+ // Allocate socket
14396+ if( !(v->skt=compat_sk_alloc(0, GFP_USER, 1)) ) {
14397+ err = -ENOMEM;
14398+ goto error;
14399+ }
14400+ skt_set_dead( v->skt );
14401+
14402+ // Attach packet handler
14403+ v->pt.type = htons(ETH_P_ALL);
14404+ v->pt.dev = v->ether;
14405+ v->pt.func = sheep_net_receiver;
14406+ //v->pt.data = v;
14407+ dev_add_pack( &v->pt );
14408+ return 0;
14409+error:
14410+ if( v->ether )
14411+ dev_put( v->ether );
14412+ v->ether = NULL;
14413+ return err;
14414+ }
14415+
14416+ // Get hardware address of Ethernet card
14417+ // arg: pointer to buffer (6 bytes) to store address
14418+ case SIOCGIFADDR:
14419+ if( copy_to_user((void *)arg, v->fake_addr, 6))
14420+ return -EFAULT;
14421+ return 0;
14422+
14423+ // Set the fake HW-address the client will see
14424+ case SIOCSIFADDR:
14425+ if( copy_from_user(v->fake_addr, (void*)arg, 6 ))
14426+ return -EFAULT;
14427+ return 0;
14428+
14429+ // Add multicast address
14430+ // arg: pointer to address (6 bytes)
14431+ case SIOCADDMULTI: {
14432+ char addr[6];
14433+ int ret;
14434+ if( !v->ether )
14435+ return -ENODEV;
14436+ if( copy_from_user(addr, (void *)arg, 6))
14437+ return -EFAULT;
14438+ ret = dev_mc_add(v->ether, addr, 6, 0);
14439+ return ret;
14440+ }
14441+
14442+ // Remove multicast address
14443+ // arg: pointer to address (6 bytes)
14444+ case SIOCDELMULTI: {
14445+ char addr[6];
14446+ if( !v->ether )
14447+ return -ENODEV;
14448+ if( copy_from_user(addr, (void *)arg, 6))
14449+ return -EFAULT;
14450+ return dev_mc_delete(v->ether, addr, 6, 0);
14451+ }
14452+
14453+#if 0
14454+ // Return size of first packet in queue
14455+ case FIONREAD: {
14456+ int count = 0;
14457+ struct sk_buff *skb;
14458+ long flags;
14459+ spin_lock_irqsave(&v->queue.lock, flags );
14460+
14461+ skb = skb_peek(&v->queue);
14462+ if( skb )
14463+ count = skb->len;
14464+
14465+ spin_unlock_irqrestore(&v->queue.lock, flags );
14466+ return put_user(count, (int *)arg);
14467+ }
14468+#endif
14469+ case SIOC_MOL_GET_IPFILTER:
14470+ return put_user(v->ipfilter, (int *)arg );
14471+
14472+ case SIOC_MOL_SET_IPFILTER:
14473+ v->ipfilter = arg;
14474+ return 0;
14475+ }
14476+ return -ENOIOCTLCMD;
14477+}
14478+
14479+
14480+/************************************************************************/
14481+/* init / cleanup */
14482+/************************************************************************/
14483+
14484+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
14485+static struct file_operations sheep_net_fops = {
14486+ .owner = THIS_MODULE,
14487+ .read = do_sync_read,
14488+ .aio_read = sheep_net_aio_read,
14489+ .write = do_sync_write,
14490+ .aio_write = sheep_net_aio_write,
14491+ .poll = sheep_net_poll,
14492+ .ioctl = sheep_net_ioctl,
14493+ .open = sheep_net_open,
14494+ .release = sheep_net_release,
14495+};
14496+#else
14497+static struct file_operations sheep_net_fops = {
14498+ .owner = THIS_MODULE,
14499+ .read = sheep_net_read,
14500+ .write = sheep_net_write,
14501+ .readv = sheep_net_readv,
14502+ .writev = sheep_net_writev,
14503+ .poll = sheep_net_poll,
14504+ .ioctl = sheep_net_ioctl,
14505+ .open = sheep_net_open,
14506+ .release = sheep_net_release,
14507+};
14508+#endif
14509+
14510+static struct miscdevice sheep_net_device = {
14511+ .minor = SHEEP_NET_MINOR,
14512+ .name = "sheep_net",
14513+ .fops = &sheep_net_fops
14514+};
14515+
14516+int
14517+init_module( void )
14518+{
14519+ return misc_register( &sheep_net_device );
14520+}
14521+
14522+void
14523+cleanup_module( void )
14524+{
14525+ (void) misc_deregister( &sheep_net_device );
14526+}
14527--- /dev/null
14528+++ b/drivers/macintosh/mol/skiplist.c
14529@@ -0,0 +1,222 @@
14530+/*
14531+ * Creation Date: <2003/03/03 23:19:47 samuel>
14532+ * Time-stamp: <2004/02/21 16:24:56 samuel>
14533+ *
14534+ * <skiplist.c>
14535+ *
14536+ * Skiplist implementation
14537+ *
14538+ * Copyright (C) 2003, 2004 Samuel Rydh (samuel@ibrium.se)
14539+ *
14540+ * This program is free software; you can redistribute it and/or
14541+ * modify it under the terms of the GNU General Public License
14542+ * as published by the Free Software Foundation
14543+ *
14544+ */
14545+
14546+#include "archinclude.h"
14547+#include "skiplist.h"
14548+#include "alloc.h"
14549+
14550+#define SKIPLIST_END INT_MAX /* this key is reserved */
14551+
14552+/*
14553+ * Skiplist Example:
14554+ *
14555+ * level 0 -> el1 -> el2 -> el3 --> el4 --> null_el
14556+ * level 1 --> el2 -> el3 --> el4 --> null_el
14557+ * level 2 --> el2 --> el4 --> null_el
14558+ * level 3 --> el2 -----> null_el
14559+ * level 4 ------------> null_el
14560+ * ...
14561+ * SKIPLIST_MAX_HEIGHT-1 ------------> null_el
14562+ */
14563+
14564+static unsigned int mol_rand_seed = 152;
14565+
14566+static inline int
14567+_cntlz( int val )
14568+{
14569+ int ret;
14570+ asm volatile("cntlzw %0,%1" : "=r" (ret) : "r"(val) );
14571+ return ret;
14572+}
14573+
14574+static unsigned long
14575+mol_random( void )
14576+{
14577+ unsigned int t;
14578+ asm( "mftb %0" : "=r"(t) : );
14579+ mol_rand_seed = mol_rand_seed*69069L+1;
14580+ return mol_rand_seed^t;
14581+}
14582+
14583+static void
14584+mol_random_entropy( void )
14585+{
14586+ unsigned int entropy;
14587+ asm( "mftb %0" : "=r" (entropy) : );
14588+ mol_rand_seed ^= entropy;
14589+}
14590+
14591+static inline void
14592+set_level_next( skiplist_level_t *level, skiplist_el_t *el )
14593+{
14594+ level->next = el;
14595+#ifdef __darwin__
14596+ level->next_phys = el ? tophys_mol(el) : 0;
14597+#endif
14598+}
14599+
14600+
14601+/************************************************************************/
14602+/* skiplist operations */
14603+/************************************************************************/
14604+
14605+int
14606+skiplist_prealloc( skiplist_t *sl, char *buf, unsigned int size,
14607+ skiplist_el_callback callback, void *usr1, void *usr2 )
14608+{
14609+ skiplist_el_t *p, *head;
14610+ unsigned int s;
14611+ int n, count;
14612+
14613+ head = NULL;
14614+ for( count=0 ;; size -= s, buf += s, count++ ) {
14615+ for( n=0; n<SKIPLIST_MAX_HEIGHT-1 && (mol_random() & 0x40) ; n++ )
14616+ ;
14617+ s = sl->datasize + sizeof(skiplist_t) + n*sizeof(skiplist_level_t);
14618+ if( s > size )
14619+ break;
14620+ p = (skiplist_el_t*)(buf + sl->datasize);
14621+ p->key = n;
14622+ set_level_next( &p->level[0], head );
14623+ head = p;
14624+ }
14625+
14626+ /* note: the callback is allowed to manipulate the skiplist */
14627+ for( n=0, p=head; p; p=p->level[0].next, n++ ) {
14628+ if( callback )
14629+ (*callback)( (char*)p - sl->datasize, n, count, usr1, usr2 );
14630+ if( !p->level[0].next ) {
14631+ p->level[0] = sl->freelist;
14632+ set_level_next( &sl->freelist, head );
14633+ break;
14634+ }
14635+ }
14636+ return count;
14637+}
14638+
14639+char *
14640+skiplist_insert( skiplist_t *sl, int key )
14641+{
14642+ skiplist_el_t *pleft = (skiplist_el_t*)((char*)&sl->root[0] - offsetof(skiplist_el_t, level));
14643+ skiplist_level_t el = sl->freelist;
14644+ skiplist_el_t *p = el.next;
14645+ int n, slev;
14646+
14647+ if( !p )
14648+ return NULL;
14649+ sl->freelist = p->level[0];
14650+ n = p->key;
14651+ p->key = key;
14652+
14653+ /* pick a good search level (the -3 is benchmarked) */
14654+ sl->nel++;
14655+ slev = 31 - _cntlz(sl->nel) - 3;
14656+ if( slev > SKIPLIST_MAX_HEIGHT-1 )
14657+ slev = SKIPLIST_MAX_HEIGHT-1;
14658+ else if( slev < 0 )
14659+ slev = 0;
14660+ sl->slevel = slev;
14661+
14662+ /* insert element */
14663+ if( slev < n )
14664+ slev = n;
14665+ for( ; slev >= 0; slev-- ) {
14666+ for( ; pleft->level[slev].next->key < key ; pleft=pleft->level[slev].next )
14667+ ;
14668+ if( slev <= n ) {
14669+ p->level[slev] = pleft->level[slev];
14670+ pleft->level[slev] = el;
14671+ }
14672+ }
14673+
14674+ return (char*)p - sl->datasize;
14675+}
14676+
14677+char *
14678+skiplist_delete( skiplist_t *sl, int key )
14679+{
14680+ skiplist_el_t *p = (skiplist_el_t*)((char*)&sl->root[0] - offsetof(skiplist_el_t, level));
14681+ skiplist_level_t delptr;
14682+ int n, level = -1;
14683+
14684+ delptr.next = 0;
14685+
14686+ for( n=SKIPLIST_MAX_HEIGHT-1; n>=0; n-- ) {
14687+ for( ; p->level[n].next->key < key ; p=p->level[n].next )
14688+ ;
14689+ if( p->level[n].next->key != key )
14690+ continue;
14691+
14692+ if( level < 0 ) {
14693+ delptr = p->level[n];
14694+ level = n;
14695+ }
14696+ p->level[n] = delptr.next->level[n];
14697+ }
14698+ if( level < 0 )
14699+ return NULL;
14700+
14701+ /* put on freelist */
14702+ p = delptr.next;
14703+ p->key = level;
14704+ p->level[0] = sl->freelist;
14705+ sl->freelist = delptr;
14706+ sl->nel--;
14707+
14708+ return (char*)p - sl->datasize;
14709+}
14710+
14711+char *
14712+skiplist_lookup( skiplist_t *sl, int key )
14713+{
14714+ skiplist_el_t *p = (skiplist_el_t*)((char*)&sl->root[0] - offsetof(skiplist_el_t, level));
14715+ int n = sl->slevel;
14716+
14717+ for( ;; ) {
14718+ if( p->level[n].next->key < key ) {
14719+ p = p->level[n].next;
14720+ continue;
14721+ }
14722+ if( p->level[n].next->key > key ) {
14723+ if( --n < 0 )
14724+ break;
14725+ continue;
14726+ }
14727+ return (char*)p->level[n].next - sl->datasize;
14728+ }
14729+ return NULL;
14730+}
14731+
14732+void
14733+skiplist_init( skiplist_t *sl, int datasize )
14734+{
14735+ skiplist_level_t nilptr;
14736+ int i;
14737+
14738+ mol_random_entropy();
14739+
14740+ memset( sl, 0, sizeof(*sl) );
14741+
14742+ sl->nil_el.key = SKIPLIST_END;
14743+ sl->datasize = datasize;
14744+
14745+ /* remember: the nil element is of level 0 */
14746+ set_level_next( &nilptr, &sl->nil_el );
14747+ sl->nil_el.level[0] = nilptr;
14748+
14749+ for( i=0; i < SKIPLIST_MAX_HEIGHT ; i++ )
14750+ sl->root[i] = nilptr;
14751+}
IPFire 2.x development tree