arch/tile/kernel/relocate_kernel.S

   1 /*
   2  * Copyright 2010 Tilera Corporation. All Rights Reserved.
   3  *
   4  *   This program is free software; you can redistribute it and/or
   5  *   modify it under the terms of the GNU General Public License
   6  *   as published by the Free Software Foundation, version 2.
   7  *
   8  *   This program is distributed in the hope that it will be useful, but
   9  *   WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  11  *   NON INFRINGEMENT.  See the GNU General Public License for
  12  *   more details.
  13  *
  14  * copy new kernel into place and then call hv_reexec
  15  *
  16  */
  17
  18 #include <linux/linkage.h>
  19 #include <arch/chip.h>
  20 #include <asm/page.h>
  21 #include <hv/hypervisor.h>
  22
  23 #define ___hvb  MEM_SV_INTRPT + HV_GLUE_START_CPA
  24
  25 #define ___hv_dispatch(f) (___hvb + (HV_DISPATCH_ENTRY_SIZE * f))
  26
  27 #define ___hv_console_putc ___hv_dispatch(HV_DISPATCH_CONSOLE_PUTC)
  28 #define ___hv_halt         ___hv_dispatch(HV_DISPATCH_HALT)
  29 #define ___hv_reexec       ___hv_dispatch(HV_DISPATCH_REEXEC)
  30 #define ___hv_flush_remote ___hv_dispatch(HV_DISPATCH_FLUSH_REMOTE)
  31
  32 #undef RELOCATE_NEW_KERNEL_VERBOSE
  33
  34 STD_ENTRY(relocate_new_kernel)
  35
  36         move    r30, r0         /* page list */
  37         move    r31, r1         /* address of page we are on */
  38         move    r32, r2         /* start address of new kernel */
  39
  40         shri    r1, r1, PAGE_SHIFT
  41         addi    r1, r1, 1
  42         shli    sp, r1, PAGE_SHIFT
  43         addi    sp, sp, -8
  44         /* we now have a stack (whether we need one or not) */
  45
  46         moveli  r40, lo16(___hv_console_putc)
  47         auli    r40, r40, ha16(___hv_console_putc)
  48
  49 #ifdef RELOCATE_NEW_KERNEL_VERBOSE
  50         moveli  r0, 'r'
  51         jalr    r40
  52
  53         moveli  r0, '_'
  54         jalr    r40
  55
  56         moveli  r0, 'n'
  57         jalr    r40
  58
  59         moveli  r0, '_'
  60         jalr    r40
  61
  62         moveli  r0, 'k'
  63         jalr    r40
  64
  65         moveli  r0, '\n'
  66         jalr    r40
  67 #endif
  68
  69         /*
  70          * Throughout this code r30 is pointer to the element of page
  71          * list we are working on.
  72          *
  73          * Normally we get to the next element of the page list by
  74          * incrementing r30 by four.  The exception is if the element
  75          * on the page list is an IND_INDIRECTION in which case we use
  76          * the element with the low bits masked off as the new value
  77          * of r30.
  78          *
  79          * To get this started, we need the value passed to us (which
  80          * will always be an IND_INDIRECTION) in memory somewhere with
  81          * r30 pointing at it.  To do that, we push the value passed
  82          * to us on the stack and make r30 point to it.
  83          */
  84
  85         sw      sp, r30
  86         move    r30, sp
  87         addi    sp, sp, -8
  88
  89 #if CHIP_HAS_CBOX_HOME_MAP()
  90         /*
  91          * On TILEPro, we need to flush all tiles' caches, since we may
  92          * have been doing hash-for-home caching there.  Note that we
  93          * must do this _after_ we're completely done modifying any memory
  94          * other than our output buffer (which we know is locally cached).
  95          * We want the caches to be fully clean when we do the reexec,
  96          * because the hypervisor is going to do this flush again at that
  97          * point, and we don't want that second flush to overwrite any memory.
  98          */
  99         {
 100          move   r0, zero         /* cache_pa */
 101          move   r1, zero
 102         }
 103         {
 104          auli   r2, zero, ha16(HV_FLUSH_EVICT_L2) /* cache_control */
 105          movei  r3, -1           /* cache_cpumask; -1 means all client tiles */
 106         }
 107         {
 108          move   r4, zero         /* tlb_va */
 109          move   r5, zero         /* tlb_length */
 110         }
 111         {
 112          move   r6, zero         /* tlb_pgsize */
 113          move   r7, zero         /* tlb_cpumask */
 114         }
 115         {
 116          move   r8, zero         /* asids */
 117          moveli r20, lo16(___hv_flush_remote)
 118         }
 119         {
 120          move   r9, zero         /* asidcount */
 121          auli   r20, r20, ha16(___hv_flush_remote)
 122         }
 123
 124         jalr    r20
 125 #endif
 126
 127         /* r33 is destination pointer, default to zero */
 128
 129         moveli  r33, 0
 130
 131 .Lloop: lw      r10, r30
 132
 133         andi    r9, r10, 0xf    /* low 4 bits tell us what type it is */
 134         xor     r10, r10, r9    /* r10 is now value with low 4 bits stripped */
 135
 136         seqi    r0, r9, 0x1     /* IND_DESTINATION */
 137         bzt     r0, .Ltry2
 138
 139         move    r33, r10
 140
 141 #ifdef RELOCATE_NEW_KERNEL_VERBOSE
 142         moveli  r0, 'd'
 143         jalr    r40
 144 #endif
 145
 146         addi    r30, r30, 4
 147         j       .Lloop
 148
 149 .Ltry2:
 150         seqi    r0, r9, 0x2     /* IND_INDIRECTION */
 151         bzt     r0, .Ltry4
 152
 153         move    r30, r10
 154
 155 #ifdef RELOCATE_NEW_KERNEL_VERBOSE
 156         moveli  r0, 'i'
 157         jalr    r40
 158 #endif
 159
 160         j       .Lloop
 161
 162 .Ltry4:
 163         seqi    r0, r9, 0x4     /* IND_DONE */
 164         bzt     r0, .Ltry8
 165
 166         mf
 167
 168 #ifdef RELOCATE_NEW_KERNEL_VERBOSE
 169         moveli  r0, 'D'
 170         jalr    r40
 171         moveli  r0, '\n'
 172         jalr    r40
 173 #endif
 174
 175         move    r0, r32
 176         moveli  r1, 0           /* arg to hv_reexec is 64 bits */
 177
 178         moveli  r41, lo16(___hv_reexec)
 179         auli    r41, r41, ha16(___hv_reexec)
 180
 181         jalr    r41
 182
 183         /* we should not get here */
 184
 185         moveli  r0, '?'
 186         jalr    r40
 187         moveli  r0, '\n'
 188         jalr    r40
 189
 190         j       .Lhalt
 191
 192 .Ltry8: seqi    r0, r9, 0x8     /* IND_SOURCE */
 193         bz      r0, .Lerr       /* unknown type */
 194
 195         /* copy page at r10 to page at r33 */
 196
 197         move    r11, r33
 198
 199         moveli  r0, lo16(PAGE_SIZE)
 200         auli    r0, r0, ha16(PAGE_SIZE)
 201         add     r33, r33, r0
 202
 203         /* copy word at r10 to word at r11 until r11 equals r33 */
 204
 205         /* We know page size must be multiple of 16, so we can unroll
 206          * 16 times safely without any edge case checking.
 207          *
 208          * Issue a flush of the destination every 16 words to avoid
 209          * incoherence when starting the new kernel.  (Now this is
 210          * just good paranoia because the hv_reexec call will also
 211          * take care of this.)
 212          */
 213
 214 1:
 215         { lw    r0, r10; addi   r10, r10, 4 }
 216         { sw    r11, r0; addi   r11, r11, 4 }
 217         { lw    r0, r10; addi   r10, r10, 4 }
 218         { sw    r11, r0; addi   r11, r11, 4 }
 219         { lw    r0, r10; addi   r10, r10, 4 }
 220         { sw    r11, r0; addi   r11, r11, 4 }
 221         { lw    r0, r10; addi   r10, r10, 4 }
 222         { sw    r11, r0; addi   r11, r11, 4 }
 223         { lw    r0, r10; addi   r10, r10, 4 }
 224         { sw    r11, r0; addi   r11, r11, 4 }
 225         { lw    r0, r10; addi   r10, r10, 4 }
 226         { sw    r11, r0; addi   r11, r11, 4 }
 227         { lw    r0, r10; addi   r10, r10, 4 }
 228         { sw    r11, r0; addi   r11, r11, 4 }
 229         { lw    r0, r10; addi   r10, r10, 4 }
 230         { sw    r11, r0; addi   r11, r11, 4 }
 231         { lw    r0, r10; addi   r10, r10, 4 }
 232         { sw    r11, r0; addi   r11, r11, 4 }
 233         { lw    r0, r10; addi   r10, r10, 4 }
 234         { sw    r11, r0; addi   r11, r11, 4 }
 235         { lw    r0, r10; addi   r10, r10, 4 }
 236         { sw    r11, r0; addi   r11, r11, 4 }
 237         { lw    r0, r10; addi   r10, r10, 4 }
 238         { sw    r11, r0; addi   r11, r11, 4 }
 239         { lw    r0, r10; addi   r10, r10, 4 }
 240         { sw    r11, r0; addi   r11, r11, 4 }
 241         { lw    r0, r10; addi   r10, r10, 4 }
 242         { sw    r11, r0; addi   r11, r11, 4 }
 243         { lw    r0, r10; addi   r10, r10, 4 }
 244         { sw    r11, r0; addi   r11, r11, 4 }
 245         { lw    r0, r10; addi   r10, r10, 4 }
 246         { sw    r11, r0 }
 247         { flush r11    ; addi   r11, r11, 4 }
 248
 249         seq     r0, r33, r11
 250         bzt     r0, 1b
 251
 252 #ifdef RELOCATE_NEW_KERNEL_VERBOSE
 253         moveli  r0, 's'
 254         jalr    r40
 255 #endif
 256
 257         addi    r30, r30, 4
 258         j       .Lloop
 259
 260
 261 .Lerr:  moveli  r0, 'e'
 262         jalr    r40
 263         moveli  r0, 'r'
 264         jalr    r40
 265         moveli  r0, 'r'
 266         jalr    r40
 267         moveli  r0, '\n'
 268         jalr    r40
 269 .Lhalt:
 270         moveli  r41, lo16(___hv_halt)
 271         auli    r41, r41, ha16(___hv_halt)
 272
 273         jalr    r41
 274         STD_ENDPROC(relocate_new_kernel)
 275
 276         .section .rodata,"a"
 277
 278         .globl relocate_new_kernel_size
 279 relocate_new_kernel_size:
 280         .long .Lend_relocate_new_kernel - relocate_new_kernel