kernel/arch/sh4/arch_cpu.c

   1 /*
   2 ** Copyright 2001, Travis Geiselbrecht. All rights reserved.
   3 ** Distributed under the terms of the NewOS License.
   4 */
   5 #include <kernel/arch/cpu.h>
   6 #include <kernel/debug.h>
   7 #include <kernel/int.h>
   8 #include <boot/stage2.h>
   9
  10 static vcpu_struct *vcpu;
  11
  12 int arch_cpu_preboot_init(kernel_args *ka)
  13 {
  14         return 0;
  15 }
  16
  17 int arch_cpu_init(kernel_args *ka)
  18 {
  19         vcpu = ka->arch_args.vcpu;
  20
  21         vcpu->kernel_asid = 0;
  22         vcpu->user_asid = 0;
  23
  24         return 0;
  25 }
  26
  27 int arch_cpu_init_percpu(kernel_args *ka, int curr_cpu)
  28 {
  29         return 0;
  30 }
  31
  32 int arch_cpu_init2(kernel_args *ka)
  33 {
  34         return 0;
  35 }
  36
  37 void sh4_set_kstack(addr_t kstack)
  38 {
  39 //      dprintf("sh4_set_kstack: setting kstack to 0x%x\n", kstack);
  40         vcpu->kstack = (unsigned int *)kstack;
  41 }
  42
  43 void sh4_set_user_pgdir(addr_t pgdir)
  44 {
  45 //      dprintf("sh4_set_user_pgdir: setting pgdir to 0x%x\n", pgdir);
  46         if((addr_t)vcpu->user_pgdir != pgdir)
  47                 arch_cpu_global_TLB_invalidate();
  48         vcpu->user_pgdir = (unsigned int *)pgdir;
  49 }
  50
  51 void sh4_invl_page(addr_t va)
  52 {
  53         int i;
  54
  55         va = ROUNDOWN(va, PAGE_SIZE);
  56
  57         int_disable_interrupts();
  58
  59         // wipe it out of the data tlbs
  60         for(i=0; i<UTLB_COUNT; i++) {
  61                 struct utlb_addr_array *ua = (struct utlb_addr_array *)(UTLB + (i << UTLB_ADDR_SHIFT));
  62                 if(ua->vpn == (va >> 10))
  63                         ua->valid = 0;
  64         }
  65
  66         // wipe it out of the instruction tlbs
  67         for(i=0; i<ITLB_COUNT; i++) {
  68                 struct itlb_addr_array *ia = (struct itlb_addr_array *)(ITLB + (i << ITLB_ADDR_SHIFT));
  69                 if(ia->vpn == (va >> 10))
  70                         ia->valid = 0;
  71         }
  72
  73         int_restore_interrupts();
  74 }
  75
  76 void arch_cpu_invalidate_TLB_range(addr_t start, addr_t end)
  77 {
  78         for(; start < end; start += PAGE_SIZE) {
  79                 sh4_invl_page(start);
  80         }
  81 }
  82
  83 void arch_cpu_invalidate_TLB_list(addr_t pages[], int num_pages)
  84 {
  85         int i;
  86         for(i=0; i<num_pages; i++) {
  87                 sh4_invl_page(pages[i]);
  88         }
  89 }
  90
  91 void arch_cpu_global_TLB_invalidate()
  92 {
  93         int i;
  94
  95         int_disable_interrupts();
  96
  97         // wipe out the data tlbs
  98         for(i=0; i<UTLB_COUNT; i++) {
  99                 struct utlb_addr_array *ua = (struct utlb_addr_array *)(UTLB + (i << UTLB_ADDR_SHIFT));
 100                 ua->valid = 0;
 101         }
 102
 103         // wipe out the instruction tlbs
 104         for(i=0; i<ITLB_COUNT; i++) {
 105                 struct itlb_addr_array *ia = (struct itlb_addr_array *)(ITLB + (i << ITLB_ADDR_SHIFT));
 106                 ia->valid = 0;
 107         }
 108
 109         int_restore_interrupts();
 110 }
 111
 112 void arch_cpu_sync_icache(void *address, size_t len)
 113 {
 114         PANIC_UNIMPLEMENTED();
 115 }
 116
 117 int arch_cpu_user_memcpy(void *to, const void *from, size_t size, addr_t *fault_handler)
 118 {
 119         char *tmp = (char *)to;
 120         char *s = (char *)from;
 121
 122         *fault_handler = (addr_t)&&error;
 123
 124         while(size--)
 125                 *tmp++ = *s++;
 126
 127         *fault_handler = 0;
 128
 129         return 0;
 130 error:
 131         *fault_handler = 0;
 132         return ERR_VM_BAD_USER_MEMORY;
 133 }
 134
 135 int arch_cpu_user_strcpy(char *to, const char *from, addr_t *fault_handler)
 136 {
 137         *fault_handler = (addr_t)&&error;
 138
 139         while((*to++ = *from++) != '\0')
 140                 ;
 141
 142         *fault_handler = 0;
 143
 144         return 0;
 145 error:
 146         *fault_handler = 0;
 147         return ERR_VM_BAD_USER_MEMORY;
 148 }
 149
 150 int arch_cpu_user_strncpy(char *to, const char *from, size_t size, addr_t *fault_handler)
 151 {
 152         *fault_handler = (addr_t)&&error;
 153
 154         while(size-- && (*to++ = *from++) != '\0')
 155                 ;
 156
 157         *fault_handler = 0;
 158
 159         return 0;
 160 error:
 161         *fault_handler = 0;
 162         return ERR_VM_BAD_USER_MEMORY;
 163 }
 164
 165 int arch_cpu_user_memset(void *s, char c, size_t count, addr_t *fault_handler)
 166 {
 167         char *xs = (char *) s;
 168
 169         *fault_handler = (addr_t)&&error;
 170
 171         while (count--)
 172                 *xs++ = c;
 173
 174         *fault_handler = 0;
 175
 176         return 0;
 177 error:
 178         *fault_handler = 0;
 179         return ERR_VM_BAD_USER_MEMORY;
 180 }
 181
 182 void arch_cpu_idle(void)
 183 {
 184 }