[deliverable/linux.git] / arch / tile / kernel / relocate_kernel_32.S

/*
 * Copyright 2010 Tilera Corporation. All Rights Reserved.
 *
 *   This program is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU General Public License
 *   as published by the Free Software Foundation, version 2.
 *
 *   This program is distributed in the hope that it will be useful, but
 *   WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 *   NON INFRINGEMENT.  See the GNU General Public License for
 *   more details.
 *
 * copy new kernel into place and then call hv_reexec
 *
 */

#include <linux/linkage.h>
#include <arch/chip.h>
#include <asm/page.h>
#include <hv/hypervisor.h>

#undef RELOCATE_NEW_KERNEL_VERBOSE

STD_ENTRY(relocate_new_kernel)

	move	r30, r0		/* page list */
	move	r31, r1		/* address of page we are on */
	move	r32, r2		/* start address of new kernel */

	shri	r1, r1, PAGE_SHIFT
	addi	r1, r1, 1
	shli	sp, r1, PAGE_SHIFT
	addi	sp, sp, -8
	/* we now have a stack (whether we need one or not) */

	moveli	r40, lo16(hv_console_putc)
	auli	r40, r40, ha16(hv_console_putc)

#ifdef RELOCATE_NEW_KERNEL_VERBOSE
	moveli	r0, 'r'
	jalr	r40

	moveli	r0, '_'
	jalr	r40

	moveli	r0, 'n'
	jalr	r40

	moveli	r0, '_'
	jalr	r40

	moveli	r0, 'k'
	jalr	r40

	moveli	r0, '\n'
	jalr	r40
#endif

	/*
	 * Throughout this code r30 is pointer to the element of page
	 * list we are working on.
	 *
	 * Normally we get to the next element of the page list by
	 * incrementing r30 by four.  The exception is if the element
	 * on the page list is an IND_INDIRECTION in which case we use
	 * the element with the low bits masked off as the new value
	 * of r30.
	 *
	 * To get this started, we need the value passed to us (which
	 * will always be an IND_INDIRECTION) in memory somewhere with
	 * r30 pointing at it.  To do that, we push the value passed
	 * to us on the stack and make r30 point to it.
	 */

	sw	sp, r30
	move	r30, sp
	addi	sp, sp, -8

	/*
	 * On TILEPro, we need to flush all tiles' caches, since we may
	 * have been doing hash-for-home caching there.  Note that we
	 * must do this _after_ we're completely done modifying any memory
	 * other than our output buffer (which we know is locally cached).
	 * We want the caches to be fully clean when we do the reexec,
	 * because the hypervisor is going to do this flush again at that
	 * point, and we don't want that second flush to overwrite any memory.
	 */
	{
	 move	r0, zero	 /* cache_pa */
	 move	r1, zero
	}
	{
	 auli	r2, zero, ha16(HV_FLUSH_EVICT_L2) /* cache_control */
	 movei	r3, -1		 /* cache_cpumask; -1 means all client tiles */
	}
	{
	 move	r4, zero	 /* tlb_va */
	 move	r5, zero	 /* tlb_length */
	}
	{
	 move	r6, zero	 /* tlb_pgsize */
	 move	r7, zero	 /* tlb_cpumask */
	}
	{
	 move	r8, zero	 /* asids */
	 moveli	r20, lo16(hv_flush_remote)
	}
	{
	 move	r9, zero	 /* asidcount */
	 auli	r20, r20, ha16(hv_flush_remote)
	}

	jalr	r20

	/* r33 is destination pointer, default to zero */

	moveli	r33, 0

.Lloop:	lw	r10, r30

	andi	r9, r10, 0xf	/* low 4 bits tell us what type it is */
	xor	r10, r10, r9	/* r10 is now value with low 4 bits stripped */

	seqi	r0, r9, 0x1	/* IND_DESTINATION */
	bzt	r0, .Ltry2

	move	r33, r10

#ifdef RELOCATE_NEW_KERNEL_VERBOSE
	moveli	r0, 'd'
	jalr	r40
#endif

	addi	r30, r30, 4
	j	.Lloop

.Ltry2:
	seqi	r0, r9, 0x2	/* IND_INDIRECTION */
	bzt	r0, .Ltry4

	move	r30, r10

#ifdef RELOCATE_NEW_KERNEL_VERBOSE
	moveli	r0, 'i'
	jalr	r40
#endif

	j	.Lloop

.Ltry4:
	seqi	r0, r9, 0x4	/* IND_DONE */
	bzt	r0, .Ltry8

	mf

#ifdef RELOCATE_NEW_KERNEL_VERBOSE
	moveli	r0, 'D'
	jalr	r40
	moveli	r0, '\n'
	jalr	r40
#endif

	move	r0, r32
	moveli	r1, 0		/* arg to hv_reexec is 64 bits */

	moveli	r41, lo16(hv_reexec)
	auli	r41, r41, ha16(hv_reexec)

	jalr	r41

	/* we should not get here */

	moveli	r0, '?'
	jalr	r40
	moveli	r0, '\n'
	jalr	r40

	j	.Lhalt

.Ltry8:	seqi	r0, r9, 0x8	/* IND_SOURCE */
	bz	r0, .Lerr	/* unknown type */

	/* copy page at r10 to page at r33 */

	move	r11, r33

	moveli	r0, lo16(PAGE_SIZE)
	auli	r0, r0, ha16(PAGE_SIZE)
	add	r33, r33, r0

	/* copy word at r10 to word at r11 until r11 equals r33 */

	/* We know page size must be multiple of 16, so we can unroll
	 * 16 times safely without any edge case checking.
	 *
	 * Issue a flush of the destination every 16 words to avoid
	 * incoherence when starting the new kernel.  (Now this is
	 * just good paranoia because the hv_reexec call will also
	 * take care of this.)
	 */

1:
	{ lw	r0, r10; addi	r10, r10, 4 }
	{ sw	r11, r0; addi	r11, r11, 4 }
	{ lw	r0, r10; addi	r10, r10, 4 }
	{ sw	r11, r0; addi	r11, r11, 4 }
	{ lw	r0, r10; addi	r10, r10, 4 }
	{ sw	r11, r0; addi	r11, r11, 4 }
	{ lw	r0, r10; addi	r10, r10, 4 }
	{ sw	r11, r0; addi	r11, r11, 4 }
	{ lw	r0, r10; addi	r10, r10, 4 }
	{ sw	r11, r0; addi	r11, r11, 4 }
	{ lw	r0, r10; addi	r10, r10, 4 }
	{ sw	r11, r0; addi	r11, r11, 4 }
	{ lw	r0, r10; addi	r10, r10, 4 }
	{ sw	r11, r0; addi	r11, r11, 4 }
	{ lw	r0, r10; addi	r10, r10, 4 }
	{ sw	r11, r0; addi	r11, r11, 4 }
	{ lw	r0, r10; addi	r10, r10, 4 }
	{ sw	r11, r0; addi	r11, r11, 4 }
	{ lw	r0, r10; addi	r10, r10, 4 }
	{ sw	r11, r0; addi	r11, r11, 4 }
	{ lw	r0, r10; addi	r10, r10, 4 }
	{ sw	r11, r0; addi	r11, r11, 4 }
	{ lw	r0, r10; addi	r10, r10, 4 }
	{ sw	r11, r0; addi	r11, r11, 4 }
	{ lw	r0, r10; addi	r10, r10, 4 }
	{ sw	r11, r0; addi	r11, r11, 4 }
	{ lw	r0, r10; addi	r10, r10, 4 }
	{ sw	r11, r0; addi	r11, r11, 4 }
	{ lw	r0, r10; addi	r10, r10, 4 }
	{ sw	r11, r0; addi	r11, r11, 4 }
	{ lw	r0, r10; addi	r10, r10, 4 }
	{ sw	r11, r0 }
	{ flush r11    ; addi	r11, r11, 4 }

	seq	r0, r33, r11
	bzt	r0, 1b

#ifdef RELOCATE_NEW_KERNEL_VERBOSE
	moveli	r0, 's'
	jalr	r40
#endif

	addi	r30, r30, 4
	j	.Lloop


.Lerr:	moveli	r0, 'e'
	jalr	r40
	moveli	r0, 'r'
	jalr	r40
	moveli	r0, 'r'
	jalr	r40
	moveli	r0, '\n'
	jalr	r40
.Lhalt:
	moveli	r41, lo16(hv_halt)
	auli	r41, r41, ha16(hv_halt)

	jalr	r41
	STD_ENDPROC(relocate_new_kernel)

	.section .rodata,"a"

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