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_init2(kernel_args *ka)
  28 {
  29         return 0;
  30 }
  31
  32 void sh4_set_kstack(addr_t kstack)
  33 {
  34 //      dprintf("sh4_set_kstack: setting kstack to 0x%x\n", kstack);
  35         vcpu->kstack = (unsigned int *)kstack;
  36 }
  37
  38 void sh4_set_user_pgdir(addr_t pgdir)
  39 {
  40 //      dprintf("sh4_set_user_pgdir: setting pgdir to 0x%x\n", pgdir);
  41         if((addr_t)vcpu->user_pgdir != pgdir)
  42                 arch_cpu_global_TLB_invalidate();
  43         vcpu->user_pgdir = (unsigned int *)pgdir;
  44 }
  45
  46 void sh4_invl_page(addr_t va)
  47 {
  48         int i;
  49
  50         va = ROUNDOWN(va, PAGE_SIZE);
  51
  52         int_disable_interrupts();
  53
  54         // wipe it out of the data tlbs
  55         for(i=0; i<UTLB_COUNT; i++) {
  56                 struct utlb_addr_array *ua = (struct utlb_addr_array *)(UTLB + (i << UTLB_ADDR_SHIFT));
  57                 if(ua->vpn == (va >> 10))
  58                         ua->valid = 0;
  59         }
  60
  61         // wipe it out of the instruction tlbs
  62         for(i=0; i<ITLB_COUNT; i++) {
  63                 struct itlb_addr_array *ia = (struct itlb_addr_array *)(ITLB + (i << ITLB_ADDR_SHIFT));
  64                 if(ia->vpn == (va >> 10))
  65                         ia->valid = 0;
  66         }
  67
  68         int_restore_interrupts();
  69 }
  70
  71 void arch_cpu_invalidate_TLB_range(addr_t start, addr_t end)
  72 {
  73         for(; start < end; start += PAGE_SIZE) {
  74                 sh4_invl_page(start);
  75         }
  76 }
  77
  78 void arch_cpu_invalidate_TLB_list(addr_t pages[], int num_pages)
  79 {
  80         int i;
  81         for(i=0; i<num_pages; i++) {
  82                 sh4_invl_page(pages[i]);
  83         }
  84 }
  85
  86 void arch_cpu_global_TLB_invalidate()
  87 {
  88         int i;
  89
  90         int_disable_interrupts();
  91
  92         // wipe out the data tlbs
  93         for(i=0; i<UTLB_COUNT; i++) {
  94                 struct utlb_addr_array *ua = (struct utlb_addr_array *)(UTLB + (i << UTLB_ADDR_SHIFT));
  95                 ua->valid = 0;
  96         }
  97
  98         // wipe out the instruction tlbs
  99         for(i=0; i<ITLB_COUNT; i++) {
 100                 struct itlb_addr_array *ia = (struct itlb_addr_array *)(ITLB + (i << ITLB_ADDR_SHIFT));
 101                 ia->valid = 0;
 102         }
 103
 104         int_restore_interrupts();
 105 }
 106
 107 void arch_cpu_sync_icache(void *address, size_t len)
 108 {
 109         PANIC_UNIMPLEMENTED();
 110 }
 111
 112 int arch_cpu_user_memcpy(void *to, const void *from, size_t size, addr_t *fault_handler)
 113 {
 114         char *tmp = (char *)to;
 115         char *s = (char *)from;
 116
 117         *fault_handler = (addr_t)&&error;
 118
 119         while(size--)
 120                 *tmp++ = *s++;
 121
 122         *fault_handler = 0;
 123
 124         return 0;
 125 error:
 126         *fault_handler = 0;
 127         return ERR_VM_BAD_USER_MEMORY;
 128 }
 129
 130 int arch_cpu_user_strcpy(char *to, const char *from, addr_t *fault_handler)
 131 {
 132         *fault_handler = (addr_t)&&error;
 133
 134         while((*to++ = *from++) != '\0')
 135                 ;
 136
 137         *fault_handler = 0;
 138
 139         return 0;
 140 error:
 141         *fault_handler = 0;
 142         return ERR_VM_BAD_USER_MEMORY;
 143 }
 144
 145 int arch_cpu_user_strncpy(char *to, const char *from, size_t size, addr_t *fault_handler)
 146 {
 147         *fault_handler = (addr_t)&&error;
 148
 149         while(size-- && (*to++ = *from++) != '\0')
 150                 ;
 151
 152         *fault_handler = 0;
 153
 154         return 0;
 155 error:
 156         *fault_handler = 0;
 157         return ERR_VM_BAD_USER_MEMORY;
 158 }
 159
 160 int arch_cpu_user_memset(void *s, char c, size_t count, addr_t *fault_handler)
 161 {
 162         char *xs = (char *) s;
 163
 164         *fault_handler = (addr_t)&&error;
 165
 166         while (count--)
 167                 *xs++ = c;
 168
 169         *fault_handler = 0;
 170
 171         return 0;
 172 error:
 173         *fault_handler = 0;
 174         return ERR_VM_BAD_USER_MEMORY;
 175 }
 176
 177 void arch_cpu_idle(void)
 178 {
 179 }