xref: /openbmc/qemu/tests/tcg/alpha/system/boot.S (revision 8c1ecb590497b0349c550607db923972b37f6963) 
1 /*
2  * Minimal Alpha system boot code.
3  *
4  * Copyright Linaro Ltd 2019
5  */
6 
7 	.set	noat
8 	.set	nomacro
9 	.arch	ev6
10 	.text
11 
12 .macro load_pci_io reg
13 	/* For typhoon, this is
14 	 *   0xfffffc0000000000  -- kseg identity map
15 	 * +      0x10000000000  -- typhoon pio base
16 	 * +        0x1fc000000  -- typhoon pchip0 pci base
17 	 * = 0xfffffd01fc000000
18 	 */
19 	ldah	\reg, -3		/* ff..fd0000 */
20 	lda	\reg, 0x1fc(\reg)	/* ff..fd01fc */
21 	sll	\reg, 24, \reg
22 .endm
23 
24 #define com1Rbr 0x3f8
25 #define com1Thr 0x3f8
26 #define com1Ier 0x3f9
27 #define com1Iir 0x3fa
28 #define com1Lcr 0x3fb
29 #define com1Mcr 0x3fc
30 #define com1Lsr 0x3fd
31 #define com1Msr 0x3fe
32 #define com1Scr 0x3ff
33 #define com1Dll 0x3f8
34 #define com1Dlm 0x3f9
35 
36 #define PAL_halt    0
37 #define PAL_wrent  52
38 #define PAL_wrkgp  55
39 
40 	.text
41 	.p2align 4
42 	.globl	_start
43 	.ent	_start
44 _start:
45 	br	$gp, .+4
46 	ldah	$gp, 0($gp)		!gpdisp!1
47 	lda	$gp, 0($gp)		!gpdisp!1
48 
49 	ldah	$sp, $stack_end($gp)	!gprelhigh
50 	lda	$sp, $stack_end($sp)	!gprellow
51 
52 	/* Install kernel gp for exception handlers.  */
53 	mov	$gp, $16
54 	call_pal PAL_wrkgp
55 
56 	/* Install exception handlers.  */
57 	ldah	$16, entInt($gp)	!gprelhigh
58 	lda	$16, entInt($16)	!gprellow
59 	lda	$17, 0
60 	call_pal PAL_wrent
61 
62 	ldah	$16, entArith($gp)	!gprelhigh
63 	lda	$16, entArith($16)	!gprellow
64 	lda	$17, 1
65 	call_pal PAL_wrent
66 
67 	ldah	$16, entMM($gp)		!gprelhigh
68 	lda	$16, entMM($16)		!gprellow
69 	lda	$17, 2
70 	call_pal PAL_wrent
71 
72 	ldah	$16, entIF($gp)		!gprelhigh
73 	lda	$16, entIF($16)		!gprellow
74 	lda	$17, 3
75 	call_pal PAL_wrent
76 
77 	ldah	$16, entUna($gp)	!gprelhigh
78 	lda	$16, entUna($16)	!gprellow
79 	lda	$17, 4
80 	call_pal PAL_wrent
81 
82 	ldah	$16, entSys($gp)	!gprelhigh
83 	lda	$16, entSys($16)	!gprellow
84 	lda	$17, 5
85 	call_pal PAL_wrent
86 
87 	/*
88 	 * Initialize COM1.
89 	 */
90 	load_pci_io $1
91 	lda	$2, 0x87		/* outb(0x87, com1Lcr); */
92 	stb	$2, com1Lcr($1)
93 	stb	$31, com1Dlm($1)	/* outb(0, com1Dlm); */
94 	lda	$2, 3			/* baudconst 3 => 56000 */
95 	stb	$2, com1Dll($1)		/* outb(baudconst, com1Dll); */
96 	lda	$2, 0x07
97 	stb	$2, com1Lcr($1)		/* outb(0x07, com1Lcr) */
98 	lda	$2, 0x0f
99 	stb	$2, com1Mcr($1)		/* outb(0x0f, com1Mcr) */
100 
101 	bsr	$26, main		!samegp
102 
103 	/* fall through to _exit */
104 	.end	_start
105 
106 	.globl	_exit
107 	.ent	_exit
108 _exit:
109 	.frame	$sp, 0, $26, 0
110 	.prologue 0
111 
112 	/* We cannot return an error code.  */
113 	call_pal PAL_halt
114 	.end	_exit
115 
116 /*
117  * We have received an exception that we don't handle.  Log and exit.
118  */
119 	.ent	log_exit
120 log_exit:
121 entInt:
122 entArith:
123 entMM:
124 entIF:
125 entUna:
126 entSys:
127 	ldah	$16, $errormsg($gp)	!gprelhigh
128 	lda	$16, $errormsg($16)	!gprellow
129 	bsr	$26, __sys_outs		!samegp
130 	bsr	$26, _exit		!samegp
131 	.end	log_exit
132 
133 	.section .rodata
134 $errormsg:
135 	.string "Terminated by exception.\n"
136 	.previous
137 
138 	/*
139 	 * Helper Functions
140 	 */
141 
142 	/* Output a single character to serial port */
143 	.global __sys_outc
144 	.ent	__sys_outc
145 __sys_outc:
146 	.frame	$sp, 0, $26, 0
147 	.prologue 0
148 
149 	load_pci_io $1
150 
151 	/*
152 	 * while ((inb(com1Lsr) & 0x20) == 0)
153 	 *       continue;
154 	 */
155 1:	ldbu	$0, com1Lsr($1)
156 	and	$0, 0x20, $0
157 	beq	$0, 1b
158 
159 	/* outb(c, com1Thr); */
160 	stb	$16, com1Thr($1)
161 	ret
162 	.end	__sys_outc
163 
164 	/* Output a nul-terminated string to serial port */
165 	.global	__sys_outs
166 	.ent	__sys_outs
167 __sys_outs:
168 	.frame	$sp, 0, $26, 0
169 	.prologue 0
170 
171 	load_pci_io $1
172 
173 	ldbu	$2, 0($16)
174 	beq	$2, 9f
175 
176 	/*
177 	 * while ((inb(com1Lsr) & 0x20) == 0)
178 	 *       continue;
179 	 */
180 1:	ldbu	$0, com1Lsr($1)
181 	and	$0, 0x20, $0
182 	beq	$0, 1b
183 
184 	/* outb(c, com1Thr); */
185 	stb	$2, com1Thr($1)
186 
187 	addq	$16, 1, $16
188 	ldbu	$2, 0($16)
189 	bne	$2, 1b
190 
191 9:	ret
192 	.end	__sys_outs
193 
194 /*
195  * Division routines that are normally in libc.
196  *
197  * These do not follow the C calling convention.  Arguments are in $24+$25,
198  * the result is in $27.  Register $28 may be clobbered; everything else
199  * must be saved.
200  *
201  * We store the remainder in $28, so that we can share code.
202  *
203  * We do not signal divide by zero.
204  */
205 
206 /*
207  * Unsigned 64-bit division.
208  */
209 
210 	.globl	__divqu
211 	.ent	__divqu
212 __divqu:
213 	.frame	$sp, 48, $23
214 	subq	$sp, 48, $sp
215 	stq	$0, 0($sp)
216 	stq	$1, 8($sp)
217 	stq	$2, 16($sp)
218 	stq	$3, 24($sp)
219 	stq	$4, 32($sp)
220 	.prologue 0
221 
222 #define mask     $0
223 #define divisor  $1
224 #define compare  $2
225 #define tmp1     $3
226 #define tmp2     $4
227 #define quotient $27
228 #define modulus  $28
229 
230 	mov	$24, modulus
231 	mov	$25, divisor
232 	mov	$31, quotient
233 	mov	1, mask
234 	beq	$25, 9f
235 
236 	/* Shift left until divisor >= modulus.  */
237 1:	cmpult	divisor, modulus, compare
238 	blt	divisor, 2f
239 	addq	divisor, divisor, divisor
240 	addq	mask, mask, mask
241 	bne	compare, 1b
242 
243 2:	addq	quotient, mask, tmp2
244 	srl	mask, 1, mask
245 	cmpule	divisor, modulus, compare
246 	subq	modulus, divisor, tmp1
247 	cmovne	compare, tmp2, quotient
248 	srl	divisor, 1, divisor
249 	cmovne	compare, tmp1, modulus
250 	bne	mask, 2b
251 
252 9:	ldq	$0, 0($sp)
253 	ldq	$1, 8($sp)
254 	ldq	$2, 16($sp)
255 	ldq	$3, 24($sp)
256 	ldq	$4, 32($sp)
257 	addq	$sp, 48, $sp
258 	ret	$31, ($23), 1
259 
260 #undef mask
261 #undef divisor
262 #undef compare
263 #undef tmp1
264 #undef tmp2
265 #undef quotient
266 #undef modulus
267 
268 	.end	__divqu
269 
270 /*
271  * Unsigned 64-bit remainder.
272  * Note that __divqu above leaves the result in $28.
273  */
274 
275 	.globl	__remqu
276 	.ent	__remqu
277 __remqu:
278 	.frame	$sp, 16, $23
279 	subq	$sp, 16, $sp
280 	stq	$23, 0($sp)
281 	.prologue 0
282 
283 	bsr	$23, __divqu
284 
285 	ldq	$23, 0($sp)
286 	mov	$28, $27
287 	addq	$sp, 16, $sp
288 	ret	$31, ($23), 1
289 	.end	__remqu
290 
291 /*
292  * Signed 64-bit division.
293  */
294 
295 	.globl	__divqs
296 	.ent	__divqs
297 __divqs:
298 	.prologue 0
299 
300 	/* Common case: both arguments are positive.  */
301 	bis	$24, $25, $28
302 	bge	$28, __divqu
303 
304 	/* At least one argument is negative.  */
305 	subq	$sp, 32, $sp
306 	stq	$23, 0($sp)
307 	stq	$24, 8($sp)
308 	stq	$25, 16($sp)
309 
310 	/* Compute absolute values.  */
311 	subq	$31, $24, $28
312 	cmovlt	$24, $28, $24
313 	subq	$31, $25, $28
314 	cmovlt	$25, $28, $25
315 
316 	bsr	$23, __divqu
317 
318 	ldq	$24, 8($sp)
319 	ldq	$25, 16($sp)
320 
321 	/* -a / b = a / -b = -(a / b) */
322 	subq	$31, $27, $23
323 	xor	$24, $25, $28
324 	cmovlt	$28, $23, $27
325 
326 	ldq	$23, 0($sp)
327 	addq	$sp, 32, $sp
328 	ret	$31, ($23), 1
329 	.end	__divqs
330 
331 /*
332  * Signed 64-bit remainder.
333  */
334 
335 	.globl	__remqs
336 	.ent	__remqs
337 __remqs:
338 	.prologue 0
339 
340 	/* Common case: both arguments are positive.  */
341 	bis	$24, $25, $28
342 	bge	$28, __remqu
343 
344 	/* At least one argument is negative.  */
345 	subq	$sp, 32, $sp
346 	stq	$23, 0($sp)
347 	stq	$24, 8($sp)
348 	stq	$25, 16($sp)
349 
350 	/* Compute absolute values.  */
351 	subq	$31, $24, $28
352 	cmovlt	$24, $28, $24
353 	subq	$31, $25, $28
354 	cmovlt	$25, $28, $25
355 
356 	bsr	$23, __divqu
357 
358 	ldq	$23, 0($sp)
359 	ldq	$24, 8($sp)
360 	ldq	$25, 16($sp)
361 
362 	/* -a % b = -(a % b); a % -b = a % b.  */
363 	subq	$31, $28, $27
364 	cmovge	$24, $28, $27
365 
366 	addq	$sp, 32, $sp
367 	ret	$31, ($23), 1
368 	.end	__remqs
369 
370 /*
371  * Unsigned 32-bit division.
372  */
373 
374 	.globl	__divlu
375 	.ent	__divlu
376 __divlu:
377 	.frame	$sp, 32, $23
378 	subq	$sp, 32, $sp
379 	stq	$23, 0($sp)
380 	stq	$24, 8($sp)
381 	stq	$25, 16($sp)
382 	.prologue 0
383 
384 	/* Zero extend and use the 64-bit routine.  */
385 	zap	$24, 0xf0, $24
386 	zap	$25, 0xf0, $25
387 	bsr	$23, __divqu
388 
389 	addl	$27, 0, $27
390 	ldq	$23, 0($sp)
391 	ldq	$24, 8($sp)
392 	ldq	$25, 16($sp)
393 	addq	$sp, 32, $sp
394 	ret	$31, ($23), 1
395 	.end	__divlu
396 
397 /*
398  * Unsigned 32-bit remainder.
399  */
400 
401 	.globl	__remlu
402 	.ent	__remlu
403 __remlu:
404 	.frame	$sp, 32, $23
405 	subq	$sp, 32, $sp
406 	stq	$23, 0($sp)
407 	stq	$24, 8($sp)
408 	stq	$25, 16($sp)
409 	.prologue 0
410 
411 	/* Zero extend and use the 64-bit routine.  */
412 	zap	$24, 0xf0, $24
413 	zap	$25, 0xf0, $25
414 	bsr	$23, __divqu
415 
416 	/* Recall that the remainder is returned in $28.  */
417 	addl	$28, 0, $27
418 	ldq	$23, 0($sp)
419 	ldq	$24, 8($sp)
420 	ldq	$25, 16($sp)
421 	addq	$sp, 32, $sp
422 	ret	$31, ($23), 1
423 	.end	__remlu
424 
425 /*
426  * Signed 32-bit division.
427  */
428 
429 	.globl	__divls
430 	.ent	__divls
431 __divls:
432 	.frame	$sp, 32, $23
433 	subq	$sp, 32, $sp
434 	stq	$23, 0($sp)
435 	stq	$24, 8($sp)
436 	stq	$25, 16($sp)
437 	.prologue 0
438 
439 	/* Sign extend.  */
440 	addl	$24, 0, $24
441 	addl	$25, 0, $25
442 
443 	/* Compute absolute values.  */
444 	subq	$31, $24, $28
445 	cmovlt	$24, $28, $24
446 	subq	$31, $25, $28
447 	cmovlt	$25, $28, $25
448 
449 	bsr	$23, __divqu
450 
451 	ldq	$24, 8($sp)
452 	ldq	$25, 16($sp)
453 
454 	/* Negate the unsigned result, if necessary.  */
455 	xor	$24, $25, $28
456 	subl	$31, $27, $23
457 	addl	$27, 0, $27
458 	addl	$28, 0, $28
459 	cmovlt	$28, $23, $27
460 
461 	ldq	$23, 0($sp)
462 	addq	$sp, 32, $sp
463 	ret	$31, ($23), 1
464 	.end	__divls
465 
466 /*
467  * Signed 32-bit remainder.
468  */
469 
470 	.globl	__remls
471 	.ent	__remls
472 __remls:
473 	.frame	$sp, 32, $23
474 	subq	$sp, 32, $sp
475 	stq	$23, 0($sp)
476 	stq	$24, 8($sp)
477 	stq	$25, 16($sp)
478 	.prologue 0
479 
480 	/* Sign extend.  */
481 	addl	$24, 0, $24
482 	addl	$25, 0, $25
483 
484 	/* Compute absolute values.  */
485 	subq	$31, $24, $28
486 	cmovlt	$24, $28, $24
487 	subq	$31, $25, $28
488 	cmovlt	$25, $28, $25
489 
490 	bsr	$23, __divqu
491 
492 	ldq	$23, 0($sp)
493 	ldq	$24, 8($sp)
494 	ldq	$25, 16($sp)
495 
496 	/* Negate the unsigned result, if necessary.  */
497 	subl	$31, $28, $27
498 	addl	$28, 0, $28
499 	cmovge	$24, $28, $27
500 
501 	addq	$sp, 32, $sp
502 	ret	$31, ($23), 1
503 	.end	__remls
504 
505 	.data
506 	.p2align 4
507 stack:
508 	.skip	65536
509 $stack_end:
510 	.type	stack,@object
511 	.size	stack, . - stack
512