001
002 /*
003 * @(#) $Id: bootsect.S,v 1.8 2004/11/20 16:00:11 d2 Exp $
004 * Description : Bootsecteur en syntaxe AT&T
005 * Auteurs : Thomas Petazzoni & Fabrice Gautier & Emmanuel Marty
006 * Jerome Petazzoni & Bernard Cassagne & coffeeman
007 * David Decotigny
008 * Bug reports to kos-misc@enix.org
009 */
010
011 /*
012 * But global de ce bootsecteur :
013 *
014 * - Initialiser la becane
015 * - Charger le kernel
016 * - Passer en mode protege
017 * - Executer le kernel
018 *
019 * Taille restante : Je vous rappelle qu'un bootsecteur ne peut faire
020 * qu'au maximum 512 octets dont 2 octets obligatoires 0xAA55. Sur
021 * les 510 octets reellement utilisables, il reste 3 octets dispo (60
022 * si on decide d'enlever le BPB un jour) !!!
023 *
024 * thomas_petazzoni : - detection des codes d'erreurs de chargement
025 * David_Decotigny : - Passage en GNU as
026 * David_Decotigny : - Chargement du noyau au-dela du 1er Mega (taille
027 * max = 0x9e000 octets = 632ko), pour avoir le
028 * meme noyau sous grub et avec le bootsecteur
029 */
030
031 /*
032 * Sequence d'operations :
033 * - Le BIOS charge le bootsect en 0x7c00 (BOOT_ADRESS). On choisit
034 * la representation 0x7c0:0000 pour que le .org 0 reste valide
035 * - Le bootsect se deplace de lui-meme en 0x9f000 (COPY_ADRESS). On
036 * choisit la representation 0x9f00:0000 pour que le .org 0 reste
037 * valide
038 * - Le bootsect verifie que le processeur est du type 386+
039 * - Il charge le noyau depuis la disquette en memoire a partir de
040 * 0x1000 (LOAD_ADRESS). Le noyau peut au max tenir sur
041 * SECTORS_TO_LOAD secteurs
042 * - Il passe en pmode flat (apres ouverture a20)
043 * - Il recopie le noyau (situe en LOAD_ADRESS) vers son adresse
044 * finale (FINAL_ADDRESS = 2Mo). La recopie se fait sur tout l'espace
045 * LOAD_ADRESS ---> COPY_ADRESS, c'est a dire sur 0x9e000 octets =
046 * 632ko. Le noyau peut donc au max faire 632ko. Le nombre max de
047 * secteurs de disquette qu'on peut charger est donc 1264
048 */
049
050
051 /* La taille de la pile */
052 #define BOOT_STACK_SIZE 0x4000
053
054 .file "bootsect.S"
055
056 /* Tout est place dans une seule section */
057 .section ".bootsect"
058
059 /* L'essentiel du bootsector (sauf les 1eres instructions)
060 sont a un offset 0. On fait en sorte que le compilo soit
061 d'accord la-dessus. Quand on a des adresse realm exotiques
062 (0x7c00, 0x9f000, ...), on s'arrange toujours pour avoir un
063 offset de 0 => on choisira le segment adapte (0x7c0,
064 0x9f00, ...). Il ne faut pas oublier le ld -Ttext 0 */
065 .org 0
066
067 /* Pour que gas genere du 16bits, afin que ca marche en realm */
068 .code16
069
070 #define SECTORS_TO_LOAD 128 /* 64 ko */ /* MAX=1264 */
071
072 /*
073 * Parametres de la disquette. Comme c'est chiant de faire une
074 * procedure de detection auto, et que ca prend de la place, on fait
075 * ca "a la main". Par exemple, une DD 720 Ko a 9 secteurs/piste, une
076 * 1.44 Mo a 18 secteurs/pistes
077 */
078 #define CYLS 80
079 #define HEADS 1
080 #define SECTS 18
081
082 #define BOOT_ADRESS 0x07C00 /* Adresse de demarrage (lineaire) */
083 #define BOOT_SEG (BOOT_ADRESS>>4) /* Segment de Boot */
084 #define BOOT_SIZE 512 /* Taille bu bootsecteur */
085 #define COPY_ADRESS 0x9F000 /* La ou on va copier le
086 bootsecteur (lineaire) */
087 #define COPY_SEG (COPY_ADRESS>>4) /* Segment de la ou on va
088 copier le bootsecteur */
089 #define LOAD_ADRESS 0x01000 /* 1er chargement du systeme */
090 #define LOAD_SEG (LOAD_ADRESS>>4) /* Segment du 1er chargement du */
091 #define MAX_KERN_LEN COPY_ADRESS-LOAD_ADRESS /* Taille noyau maxi */
092
093 /* IMPORTANT : Cette valeur DOIT etre identique a l'adresse presente
094 dans sos.lds ! */
095 #define FINAL_ADDRESS 0x200000 /* Adresse finale (physique de 0 a 4G)
096 ou est charge le noyau */
097
098 #define OP16 .byte 0x66 ;
099 #define OP32 .byte 0x66 ;
100
101 /*
102 * Procedure qui vide le buffer clavier.
103 */
104 #define WAITKB \
105 1: ;\
106 .word 0xeb ;\
107 .word 0xeb ;\
108 inb $0x64, %al ;\
109 andb $0x2, %al ;\
110 jnz 1b
111
112 /* Le point d'entree dans le bootsect */
113 .globl _bsect
114 _bsect:
115
116 /*
117 * La portion qui suit est situee a un offset 0x7c00 en
118 * memoire. Attention donc aux references memoire dans cette
119 * partie. On choisit de rester en offset 0 (.org 0), mais on
120 * charge correctement les segments a 0x7c0.
121 */
122
123 movw $BOOT_SEG, %ax /* le bootsecteur est a 0x7C00 en lineaire */
124 movw %ax, %ds /* on le copie a l'adresse COPY_ADRESS */
125 xorw %si, %si /* comme cette adresse est la plus haute de la mem */
126 xorw %di, %di /* on pourra charger un kernel + gros */
127 movw $(BOOT_SIZE>>1), %cx
128 movw $COPY_SEG, %ax
129 movw %ax, %es
130 cld
131 rep ; movsw
132
133 /* on continue a executer le bootsecteur, mais maintenant a
134 partir de 0x9F000, qu'on represente sous la forme
135 0x9f00:offset */
136 ljmp $COPY_SEG, $here
137
138 /*
139 * A partir de maintenant, on est a un offset 0 en memoire
140 * (segment 0x9f00), conformement a ce que veut le compilo.
141 */
142 here:
143 movw %ax, %ds
144
145 /* Petite pile temporaire (1k - 3.84k en RAM ; les adresses 0-1k
146 correspondent au vecteur d'interruptions). */
147 movw %ax, %ss
148 movw $(LOAD_ADRESS - 0x10), %sp
149
150 /* Efface l'ecran */
151 movb $0x0, %ah
152 movb $0x3, %al
153 int $0x10
154
155 /* Affiche les messages d'attente */
156 movw $loadkern, %si
157 call message
158 movw $check, %si
159 call message
160
161 check386:
162 /*
163 * la attention, plus complexe : on teste si le proc est un
164 * 386+ pour cela, on va essayer de modifier les bits 12 ? 14
165 * du registre E-flag si la modification reste, alors le proc
166 * est un 386+, sinon, c'est =< 286
167 *
168 * Merci a Emmanuel Marty pour la compatibilite avec les 386
169 * "pre-jurassique"
170 */
171
172 pushf /* on sauvegarde le E-Flag */
173 movb $0x70, %ah
174 pushw %ax
175 popf
176 pushf
177 popw %ax
178 orb %ah, %ah
179 je no386 /* si la modif n'est pas valable, alors on saute a
180 no386 */
181 popf /* on les restaure ? la fin ... */
182
183 /* Message de confirmation de 386+ et d'attente */
184 movw $found386, %si
185 call message
186 movw $loading, %si
187 call message
188
189 /* Copie du noyau disquette => RAM a partir de 0x1000
190 L'adresse de destination est définie par es:0, où es vaut
191 initialement 0x100 (ie correspond alors à l'adresse 256*16, soit 4
192 ko). Chaque itération incrémente ce registre es de 32, ce qui
193 correspond à un bond de 32*16 en mémoire, soit la taille d'un
194 secteur. De cette façon, puisqu'on joue sur les segments plutôt que
195 sur les offsets, la taille du noyau n'est pas limitée à 64 ko. Elle
196 est limitée par contre à la taille de la mémoire disponible sous
197 les 1Mo, \ie 640 ko (0x9f000 - 0x1000). */
198 copyKernel:
199 /* Chargement du noyau en LOAD_SEG:0 */
200 /* 3 iterateurs :
201 - load_size : le nbre de secteurs a charger
202 - cl : le secteur ou on en est pour le
203 cylindre en cours (<= SECTS)
204 - dh : la tete en cours (0/1)
205 */
206 movb $0, %dl
207 movw $LOAD_SEG, %ax
208 movw %ax, %es
209
210 xorw %bx, %bx
211 xorw %dx, %dx
212 movw $1, %cx /* premier secteur */
213
214 .nextsector: /* prochain secteur */
215 incb %cl /* en incrementant CL */
216 cmpb $SECTS, %cl /* si CL =< SECTS (=nbre de secteurs/pistes)
217 alors on charge */
218 jbe .sector
219 movb $1, %cl /* sinon on revient au secteur 1 */
220 incb %dh /* mais sur l'autre tete */
221 cmpb $1, %dh /* on recompare, si DH =< 1 */
222 je .sector /* on charge */
223 movb $0, %dh /* sinon on repasse a la tete 0 */
224 incb %ch /* mais on change de cylindre */
225
226 .sector:
227 pushw %es
228 movw $0x0201, %ax /* service 0x2, chargement 0x1 seecteur */
229 int $0x13 /* Go ! */
230 jc halt /* erreur */
231 popw %ax
232 addw $32, %ax /* on a charge un secteur, donc on doit
233 charger 512 bytes plus loin */
234 movw %ax, %es /* on avance donc le segment du buffer de
235 32bytes, ie 1 secteur en RAM (car 32*16=512) */
236
237 movw $(0x0E*256+'.'), %ax /* affiche un point */
238 int $0x10
239
240 decw (load_size) /* et on repart pour le prochain secteur
241 tant qu'on n'a pas fini ! */
242 jnz .nextsector
243
244 after:
245 movw $0x03f2, %dx
246 inb %dx, %al /* stoppe le moteur */
247 andb $0x0f, %al
248 outb %al, %dx
249
250 cli /* on interdit les interruptions */
251
252 fincopie:
253 pushw %cs
254 popw %ds
255
256 /* on ouvre la porte A20 */
257 WAITKB /* on vide le buffer */
258 movb $0xd1, %al /* on met a jour le port */
259 outb %al, $0x64
260 WAITKB
261 movb $0xdf, %al /* bit 2 = ouverture/fermeture */
262 outb %al, $0x60
263
264 /*
265 * init gdt
266 */
267 InitGDT:
268 /* Préparation du flat mode */
269 lgdt gdtr
270
271 GoPMode:
272 /* Passage en mode protégé */
273 movl %cr0, %eax
274 orb $1, %al /* set PE bit to 1 */
275 movl %eax, %cr0
276
277 /* we are not yet in Pmode jump 'in' pmode clearing prefetch
278 * queue and loading a new selector */
279 movw $0x10, %ax
280 movw %ax, %ds
281 movw %ax, %es
282 movw %ax, %fs
283 movw %ax, %gs
284
285 /*
286 * Code 32 bits ============================================================
287 */
288 .code32
289
290 JumpToHere32: /* Se deplace a l'endroit actuel, en passant en 32bits
291 et en utilisant la gdt, et vide la prefetch queue */
292 .byte 0x66 /* Prefixe 32bits : en realite, jusqu'au jmp, on est
293 encore en 16 bits */
294 ljmp $0x8, $(COPY_ADRESS+(Here32))
295 Here32:
296 /* Et voila : On est en 32 bits vrai */
297
298 MoveKernelToFinalAddr: /* Deplace le noyau (en LOAD_ADDRESS) vers sa
299 destination finale (FINAL_ADDRESS) */
300 movl $0x10, %eax
301 movl %eax, %ds /* Seg Src = DSeg */
302 movl %eax, %es /* Sed Dest = DSeg */
303 cld
304 movl $LOAD_ADRESS, %esi /* On commence la copie au debut du noyau */
305 movl $FINAL_ADDRESS, %edi /* On copie vers cette adresse */
306 movl $MAX_KERN_LEN, %ecx /* Taille recopie */
307 shrl $2, %ecx
308 rep
309 movsl
310
311 LaunchKernel:
312 /* Met en place une pile au niveau du symbole "stack" */
313 movl %eax, %ss
314 movl $(stack + BOOT_STACK_SIZE), %ebp
315 movl %ebp, %esp
316
317 /* Saut vers le noyau. La GDT est en place (flat mode), les
318 * selecteurs aussi, a20 est ouverte, et les interruptions sont
319 * cli + pas de idt. Le PIC n'est pas programme */
320 ljmp $0x8, $sos_main
321
322 /*
323 * Utilities ============================================================
324 */
325 .code16
326
327 message:
328 lodsb /* charge ds:si dans al et incremente si */
329 orb %al, %al /* si al = 0 */
330 jz 1f
331 movb $0x0e, %ah /* service 0Eh (affichage d'un caractere) */
332 movw $0x0007, %bx /* Parametres : blanc sur fond noir */
333 int $0x10 /* Appel de l'interruption 10h */
334 jmp message /* On repart au début ... */
335 1: ret /* si la chaine est finie alors on retourne
336 dans la fonction appelante */
337
338 halt:
339 pushw %cs
340 popw %es
341 movw $haltmsg, %si
342 call message
343 cli
344 1: jmp 1b
345 ret
346
347 no386:
348 movw $need386, %si
349 call message
350 call halt
351
352 /*
353 * GDT
354 */
355
356 gdt:
357 gdtr:
358 NULL_Desc:
359 .word (EndGDT)-(gdt)-1 /* Taille GDT */
360 .long (gdt)+COPY_ADRESS
361 unused:
362 .word 0
363
364 CS_Desc: /* 0x8 */
365 .word 0xFFFF, 0
366 .byte 0, 0x9B, 0xCF, 0
367
368 DS_Desc: /* 0x10 */
369 .word 0xFFFF, 0
370 .byte 0, 0x93, 0xCF, 0
371
372 EndGDT:
373
374 /* quelques messages */
375
376 loadkern: .string "-= S O S =- : The Simple Operating System \r\n"
377 check: .string "Checking for a 386+ processor... "
378 found386: .string " [OK]\r\n"
379 need386: .string " [FAILED]\r\n"
380 diskerror: .string "Disk Error\r\n"
381 loading: .string "Loading... "
382 haltmsg: .string "System Halted\r\n"
383
384 /*** Les code/données du boot secteur se terminent ICI. le marqueur de
385 * fin (aa55) est ajouté automatiquement par le script ld
386 * sos_bsect.lds ***/
387
388 /* La pile de 16k qu'on utilise au niveau de LaunchKernel se trouve
389 declaree avec le noyau, dans sa section ".init_stack", cad HORS du boot
390 secteur ! (sinon ca depasserait 512B, forcément). On aurait pu la
391 définir directement dans le sos_bsect.lds, ou dans un fichier .c
392 auxiliaire pour plus de clarté */
393 /* Here is the stack */
394 .section ".init_stack", "aw", @nobits
395 .p2align 4
396 .size stack, BOOT_STACK_SIZE
397 stack:
398 .space BOOT_STACK_SIZE
399
400 /* Some data characterizing the stack addresses */
401 .data
402 .globl bootstrap_stack_bottom
403 bootstrap_stack_bottom: .long stack
404
405 .globl bootstrap_stack_size
406 bootstrap_stack_size: .long BOOT_STACK_SIZE