Compare commits
142 Commits
master
...
feature/cr
Author | SHA1 | Date |
---|---|---|
Nicolas Hordé | a0641a9226 | |
Nicolas Hordé | 41e07102c7 | |
Nicolas Hordé | c9cfc04919 | |
Nicolas H | 46a5733a47 | |
Nicolas Hordé | a4e4e981ca | |
Nicolas Hordé | 7cd20f6c0b | |
Nicolas Hordé | 5afa43629d | |
Nicolas Hordé | acb06bc8a8 | |
Nicolas Hordé | 4f7aae792e | |
Nicolas Hordé | 63f7e530cc | |
Nicolas Hordé | b565d073c7 | |
Nicolas Hordé | d3abee6a74 | |
Nicolas Hordé | 0c6b0635ab | |
Nicolas Hordé | a00965b7a3 | |
Nicolas Hordé | 705f92ce70 | |
Nicolas Hordé | 56a7665e69 | |
Nicolas Hordé | 9da86c9057 | |
Nicolas Hordé | e30592d7d4 | |
Nicolas Hordé | fda7fdc711 | |
Nicolas Hordé | edaae1d4c2 | |
Nicolas Hordé | 32af566aec | |
Nicolas Hordé | 21bc3d2e3d | |
Nicolas Hordé | 620f63d101 | |
Nicolas Hordé | e3d708850d | |
Nicolas Hordé | 75a8602c5b | |
Nicolas Hordé | c894b99170 | |
Nicolas Hordé | 6776594ece | |
Nicolas Hordé | 945bca37b5 | |
Nicolas Hordé | eff52c8853 | |
Nicolas Hordé | 74b0b4e2e9 | |
Nicolas Hordé | 11428c2415 | |
Nicolas Hordé | dd3e40d53e | |
Nicolas Hordé | d2f28e6795 | |
Nicolas Hordé | 0af99c069b | |
Nicolas Hordé | 3c3f0bb88e | |
Nicolas Hordé | ddfba60973 | |
Nicolas Hordé | deea5829d3 | |
Nicolas Hordé | 81e7dcaa50 | |
Nicolas Hordé | 3c7ddafc2d | |
Nicolas Hordé | 89ac2cc30f | |
Nicolas Hordé | c0b832ceed | |
Nicolas Hordé | 6cdfbcdd28 | |
Nicolas Hordé | 524af1729c | |
Nicolas Hordé | 69fa9567a1 | |
Nicolas Hordé | dd70f75ab8 | |
Nicolas Hordé | 12aacb33f1 | |
Nicolas Hordé | 44d5634532 | |
Nicolas Hordé | a31cf264c3 | |
Nicolas Hordé | f0f36a0f5c | |
Nicolas Hordé | ac537030a3 | |
Nicolas Hordé | 11071e5bbd | |
Nicolas Hordé | 8d3da6480a | |
Nicolas Hordé | 3129b5edcc | |
Nicolas Hordé | 9041832823 | |
Nicolas Hordé | e87aedb02e | |
Nicolas Hordé | 4ce5c7333c | |
Nicolas Hordé | b8e26a000b | |
Nicolas Hordé | 73c70d20bd | |
Nicolas Hordé | b6e2ead659 | |
Nicolas Hordé | 4f92e419e2 | |
Nicolas Hordé | 4a6b7542fc | |
Nicolas Hordé | 5d22ec2d48 | |
Nicolas Hordé | ed4e577086 | |
Nicolas Hordé | 6fa1bd6c2e | |
Nicolas Hordé | f399a6bf5c | |
Nicolas Hordé | b6f238ff8a | |
Nicolas Hordé | f0a64729ee | |
Nicolas Hordé | 6acbddab8d | |
Nicolas Hordé | f04bb66ec8 | |
Nicolas Hordé | c91c2a1e45 | |
Nicolas Hordé | 1a28e6ce45 | |
Nicolas Hordé | 812e3c0bed | |
Nicolas Hordé | 8b2fa6ae68 | |
Nicolas Hordé | 852509789d | |
Nicolas Hordé | 42f87229ad | |
Nicolas Hordé | 35ae3559db | |
Nicolas Hordé | c773880c2e | |
Nicolas Hordé | 5f526bf2b7 | |
Nicolas Hordé | c4e4462313 | |
Nicolas Hordé | f705b5fe3d | |
Nicolas Hordé | ac0bf016eb | |
Nicolas Hordé | f4b3ea6c10 | |
Nicolas Hordé | d0d125bbf8 | |
Nicolas Hordé | 660ce13fdf | |
Nicolas Hordé | 09e4ebbb38 | |
Nicolas Hordé | ba7361eae6 | |
Nicolas Hordé | 8863c798fc | |
Nicolas Hordé | 03aa538dc9 | |
Nicolas Hordé | c179f61bff | |
Nicolas Hordé | 26faaf8713 | |
Nicolas Hordé | aac62edd51 | |
Nicolas Hordé | 605953aa3b | |
Nicolas Hordé | 016b972d97 | |
Nicolas Hordé | 1e77ba8c3f | |
Nicolas Hordé | 86c4e4550e | |
Nicolas Hordé | 5683c69311 | |
Nicolas Hordé | 109738dca3 | |
Nicolas Hordé | bb21e15dc4 | |
Nicolas Hordé | 946355b687 | |
Nicolas Hordé | 5315bb549f | |
Nicolas Hordé | 02948e1f0f | |
Nicolas Hordé | 12f395461e | |
Nicolas Hordé | c36e8afd62 | |
Nicolas Hordé | a3d718e69e | |
Nicolas Hordé | 9b421fd7cc | |
Nicolas Hordé | b72b0c2f11 | |
Nicolas Hordé | f07f637447 | |
Nicolas Hordé | 72abe00043 | |
Nicolas Hordé | baf52f0594 | |
Nicolas Hordé | 28c831870e | |
Nicolas Hordé | 62bd72dfe0 | |
Nicolas Hordé | e137749be8 | |
Nicolas Hordé | 3447694319 | |
Nicolas Hordé | c8d925b324 | |
Nicolas Hordé | 60bf48343f | |
Nicolas Hordé | 4a4886886e | |
Nicolas Hordé | cd9129dc15 | |
Nicolas Hordé | 25c2ec0fbf | |
Nicolas Hordé | 31b139ab01 | |
Nicolas Hordé | 48778a7ef6 | |
Nicolas Hordé | 47e779ea1a | |
Nicolas Hordé | 87956a41a3 | |
Nicolas Hordé | a12ddfa03b | |
Nicolas Hordé | 93897a6cce | |
Nicolas Hordé | c3a153b091 | |
Nicolas Hordé | 8e9987ba8a | |
Nicolas Hordé | b1abb2f5a2 | |
Nicolas Hordé | debba65eba | |
Nicolas Hordé | aace138efe | |
Nicolas Hordé | 0c8419c91b | |
Nicolas Hordé | ca1f1c18a8 | |
Nicolas Hordé | e3c09a2191 | |
Nicolas Hordé | 647050d22e | |
Nicolas Hordé | 36185af660 | |
Nicolas Hordé | c76554dd4a | |
Nicolas Hordé | 2ce9d70b48 | |
Nicolas Hordé | aeeb371294 | |
Nicolas Hordé | b4ba872397 | |
Nicolas Hordé | 539eeb1d8f | |
Nicolas Hordé | 49a4bd4640 | |
Nicolas Hordé | 56da8273e8 | |
Nicolas Hordé | 3aa3adb92c |
|
@ -0,0 +1,75 @@
|
|||
## API List
|
||||
|
||||
APIs given by COS2000 libraries
|
||||
|
||||
|
||||
### LIBSYS
|
||||
|
||||
All fonctions in the "libsys" library.
|
||||
|
||||
------
|
||||
|
||||
`u32 exit(u32 resultcode);`
|
||||
|
||||
*Description:End a task for user or kernel domain*
|
||||
|
||||
* syscall id : **5**
|
||||
* arguments : **1**
|
||||
* * argument 1 : **u32 resultcode** *Code result of the execution*
|
||||
* results : **u32**
|
||||
* dump of register cpu: **no**
|
||||
|
||||
------
|
||||
|
||||
`u32 getticks(void);`
|
||||
|
||||
*Description:Return the internal value of the timer*
|
||||
|
||||
* syscall id : **4**
|
||||
* arguments : **0**
|
||||
* results : **u32**
|
||||
* dump of register cpu: **no**
|
||||
|
||||
------
|
||||
|
||||
`u8 waitkey(void);`
|
||||
|
||||
*Description:Wait for user to press a key and return the ascii code pressed*
|
||||
|
||||
* syscall id : **1**
|
||||
* arguments : **0**
|
||||
* results : **u8**
|
||||
* dump of register cpu: **no**
|
||||
|
||||
------
|
||||
|
||||
`u32 testapi(u32 arg1, u32 arg2, u32 arg3);`
|
||||
|
||||
*Description:Simple function to test if SYSCALL API is correctly running*
|
||||
|
||||
* syscall id : **0**
|
||||
* arguments : **3**
|
||||
* * argument 1 : **u32 arg1** *first argument of your choice*
|
||||
* * argument 2 : **u32 arg2** *second argument of your choice*
|
||||
* * argument 3 : **u32 arg3** *third argument of your choice*
|
||||
* results : **u32**
|
||||
* dump of register cpu: **yes**
|
||||
|
||||
|
||||
### LIBVIDEO
|
||||
|
||||
All fonctions in the "libvideo" library.
|
||||
|
||||
------
|
||||
|
||||
`u32 print(u8* string);`
|
||||
|
||||
*Description:Show a string on the screen*
|
||||
|
||||
* syscall id : **2**
|
||||
* arguments : **1**
|
||||
* * argument 1 : **u8* string** *string to show in ascii format*
|
||||
* results : **u32**
|
||||
* dump of register cpu: **no**
|
||||
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
## Liste de BUGS à corriger
|
||||
|
||||
### VIDEO
|
||||
|
||||
* Interpolation des droites lorsques les coordonnées sortent de l'écran : erreur les coefficient directeur sont faux.
|
||||
* Les modes VGA ne fonctionnent pas tous.
|
||||
* Ralentissement lors du défilemment de la console en VESA.
|
||||
|
||||
### 3D
|
||||
|
||||
La 3D utiliser sauvagement la mémoire sans malloc !!
|
||||
|
||||
### 2D
|
||||
|
||||
Le remplissage des triangles n'est pas parfais, 2 algo différents entre lignes et remplissage.
|
||||
|
||||
### SHELL
|
||||
|
||||
* La fonction regs est à reprendre...
|
||||
* La fonction IDT est à adapter à la taille de l'écran
|
||||
|
||||
|
||||
|
||||
|
Binary file not shown.
After Width: | Height: | Size: 530 KiB |
File diff suppressed because it is too large
Load Diff
After Width: | Height: | Size: 97 KiB |
Binary file not shown.
After Width: | Height: | Size: 215 KiB |
Binary file not shown.
After Width: | Height: | Size: 17 KiB |
Binary file not shown.
Before Width: | Height: | Size: 52 KiB After Width: | Height: | Size: 67 KiB |
|
@ -0,0 +1,13 @@
|
|||
![logo](https://github.com/dahut87/cos2000/raw/master/Graphisme/logo.png)
|
||||
|
||||
## Organisation du noyau
|
||||
|
||||
### Mémoire
|
||||
|
||||
L'organisation de la mémoire de COS2000 répond au schéma suivant:
|
||||
|
||||
![logo](https://github.com/dahut87/cos2000/raw/master/Graphisme/map.png)
|
||||
|
||||
### API
|
||||
|
||||
COS2000 utilise les fonctions SYSENTER/SYSEXIT
|
128
README.md
128
README.md
|
@ -1,4 +1,4 @@
|
|||
![logo](https://github.com/dahut87/cos2000v2/raw/master/Graphisme/logo.png)
|
||||
![logo](https://github.com/dahut87/cos2000v2/raw/develop/Graphisme/logo.png)
|
||||
|
||||
## COS2000
|
||||
|
||||
|
@ -49,7 +49,7 @@ Les détails se trouvent dans le fichier `LICENSE.md`
|
|||
|
||||
#### Logiciels utilisés
|
||||
|
||||
L'OS a été développé sous Linux afin de disposer d'un maximum d'outils dont GCC/NASM/Docker et l'ensemble des BINUTILS. Je vous conseille donc d'utiliser Linux afin de procéder à la compilation même si celle-ci peut fonctionner depuis Windows grace à Cygwin. Des distributions "Live" existent si vous ne souhaitez pas installer sur votre ordinateur (http://www.linuxmint.com/edition.php?id=259).
|
||||
L'OS a été développé sous Linux afin de disposer d'un maximum d'outils dont GCC/GAS/Docker et l'ensemble des BINUTILS. Je vous conseille donc d'utiliser Linux afin de procéder à la compilation même si celle-ci peut fonctionner depuis Windows grace à Cygwin. Des distributions "Live" existent si vous ne souhaitez pas installer sur votre ordinateur (http://www.linuxmint.com/edition.php?id=259).
|
||||
|
||||
Le système de conteneurisation Docker est exploité afin de d'assurer une reproductibilité totale de l'environnement de compilation quelque soit le système d'exploitation utilisé.
|
||||
|
||||
|
@ -57,7 +57,7 @@ Le système de conteneurisation Docker est exploité afin de d'assurer une repro
|
|||
|
||||
Téléchargez et exécutez le script d'installation automatique et de compilation "menu.sh"
|
||||
|
||||
`wget https://raw.githubusercontent.com/dahut87/cos2000v2/master/menu.sh`
|
||||
`wget https://raw.githubusercontent.com/dahut87/cos2000v2/develop/menu.sh`
|
||||
|
||||
Executez le script et les sources seront ainsi automatiquement téléchargées sur votre ordinateur par le biais de Git.
|
||||
|
||||
|
@ -65,7 +65,7 @@ Executez le script et les sources seront ainsi automatiquement téléchargées s
|
|||
|
||||
Un menu s'affiche ensuite qui vous propose de réaliser différentes tâches dont la compilation et/ou le test de COS2000.
|
||||
|
||||
![Menu de compilation](https://github.com/dahut87/cos2000v2/raw/master/Graphisme/screenshots/compilation.png)
|
||||
![Menu de compilation](https://github.com/dahut87/cos2000v2/raw/develop/Graphisme/screenshots/compilation.png)
|
||||
|
||||
#### Installation/compilation manuelle
|
||||
|
||||
|
@ -87,14 +87,17 @@ Docker est utilisé afin de permettre le fonctionnement correcte de la compilati
|
|||
|
||||
Commande de compilation de base
|
||||
|
||||
* `./make.sh all` compile tout le projet dans sa version disquette
|
||||
* `./make.sh all` compile tout le projet dans sa version disque dur et disque dur en UEFI
|
||||
|
||||
Autres commandes de compilation de COS2000
|
||||
* `./make.sh test` lance l'émulation QEMU en 32 bits sur disquette
|
||||
|
||||
* `./make.sh harddisk` compile la version disque dur
|
||||
* `./make.sh harddiskuefi` compile la version disque dur UEFI
|
||||
* `./make.sh test` lance l'émulation QEMU en 32 bits sur disque dur
|
||||
* `./make.sh test64` lance l'émulation QEMU en 64 bits sur disque dur en UEFI
|
||||
* `./make.sh clean` supprime les fichers compilés
|
||||
* `./make.sh debug-boot` debogue le système en mode réel depuis le boot
|
||||
* `./make.sh debug-loader` debogue le système en mode réel depuis le loader
|
||||
* `./make.sh debug-system` debogue le système en mode protégé
|
||||
* `./make.sh syscall` réactualise les librairies du domaine utilisateur
|
||||
* `./make.sh programs` compile les programmes du domaine utilisateur
|
||||
* `./make.sh config` change la configuration de la compilation
|
||||
|
||||
### Utilisation
|
||||
|
@ -103,6 +106,26 @@ Autres commandes de compilation de COS2000
|
|||
|
||||
Pour tester l'OS en émulation taper donc la commande `./make.sh test` qui compilera avant de lancer Qemu.
|
||||
|
||||
#### Sur un ordinateur physique
|
||||
|
||||
Lancer une compilation du système COS2000
|
||||
|
||||
`./make.sh all`
|
||||
|
||||
Puis, il faut copier l'image sur une clé (Attention l'opération effacera le contenu de la clé) :
|
||||
|
||||
`sudo dd if=./final/harddisk.img.final of=/dev/sdx bs=1M` (ou sdx est votre périphérique)
|
||||
|
||||
Bootez sur votre clé en mode bios (legacy).
|
||||
|
||||
Pour un boot en mode UEFI
|
||||
|
||||
`sudo dd if=./final/harddiskuefi.img.final of=/dev/sdx bs=1M` (ou sdx est votre périphérique)
|
||||
|
||||
Pour connaitre le numéro de votre périphérique (clé)
|
||||
|
||||
`lsblk`
|
||||
|
||||
#### Commandes de COS2000
|
||||
|
||||
Pour l'instant quelques commandes seulement sont disponibles:
|
||||
|
@ -113,12 +136,95 @@ Pour l'instant quelques commandes seulement sont disponibles:
|
|||
* `DETECTCPU` detecte et affiche les informations CPU,
|
||||
* `DETECTPCI` detecte et affiche les périphériques PCI,
|
||||
* `TEST2D` teste l'affichage graphique 2D,
|
||||
* `HELP` affiche les commandes disponibles.
|
||||
* `TEST3D` teste l'affichage graphique 2D,
|
||||
* `REGS` affiche les registres CPU,
|
||||
* `GDT` affiche la table des descripteurs,
|
||||
* `IDT` affiche la table des interruptions,
|
||||
* `MEM` affiche les statistiques d'occupation memoire,
|
||||
* `INFO` affiche des informations issues de GRUB,
|
||||
* `ERR` génère une exception (ARGUMENTS),
|
||||
* `VIEW` visionne la mémoire vive (ARGUMENTS),
|
||||
* `LOGO` affiche le logo,
|
||||
* `FONT` change la police d'affichage (ARGUMENTS),
|
||||
* `HELP` affiche les commandes disponibles,
|
||||
* `BPSET` met un point d'arrêt pour le débogueur (ARGUMENTS),
|
||||
* `BPCLR` efface un point d'arrêt (ARGUMENTS),
|
||||
* `DISASM` désassemble une portion de mémoire (ARGUMENTS),
|
||||
|
||||
![COS2000 le 28-09-2018](https://github.com/dahut87/cos2000v2/raw/master/Graphisme/screenshots/ansi.png)
|
||||
![COS2000 le 28-09-2018](https://github.com/dahut87/cos2000v2/raw/develop/Graphisme/screenshots/28-09-2018.png)
|
||||
|
||||
### Organisation du dépôt
|
||||
|
||||
* `debug` - fichiers configuration débogueur
|
||||
* `docker` - fichiers pour la construction de containers
|
||||
* `final` - img raw utilisables avec un émulateur des 3 versions
|
||||
* * `harddisk.img.xz`
|
||||
* * `harddiskuefi.img.xz`
|
||||
* `Graphisme` - fichiers images
|
||||
* * `screenshots` - screenshots de l'évolution du système
|
||||
* `include` - fichier d'entête C
|
||||
* `lib` - librairies pour le noyau
|
||||
* `makefile` - Makefile du projet
|
||||
* `make.sh` - Script de compilation utilisant Docker
|
||||
* `menu.sh` - Script du menu d'autocompilation
|
||||
* `templates` - Modèles utilisés pour générer des libraires du domaine utilisateur
|
||||
* `programs` - programmes pour le domaine utilisateur
|
||||
* * `include` - fichier d'entête C
|
||||
* * `lib` - librairies pour le domaine utilisateur
|
||||
* `README.md` - ce que vous lisez
|
||||
* `LICENSE.md` - la licence LGPLv3.0
|
||||
* `INFORMATIONS.md` - informations sur le développement de COS2000
|
||||
* `BUGS.md` - bugs rélevés dans le système
|
||||
* `API.md` - Liste des APIs fournies par le système COS2000
|
||||
* `system` - le noyau lui-même
|
||||
|
||||
### En savoir plus...
|
||||
|
||||
#### Avancement du projet
|
||||
|
||||
* démarrage tout support grâce à GRUB (disquette, disque dur/SSD, réseau...Etc),
|
||||
* pilotes souris et clavier,
|
||||
* pilotes VGA et VESA (framebuffer),
|
||||
* bibliothèque graphique 2D,
|
||||
* bibliothèque graphique 3D,
|
||||
* gestion des interruptions (IDT),
|
||||
* gestion de la segmentation (GDT),
|
||||
* gestion de la mémoire paginée,
|
||||
* débogueur et désassembleur intégré,
|
||||
* interpréteur de commande,
|
||||
* affichage de chaîne de caractères (prinfs,sprintf,vsprintf) avec type (bin,hexa,octal,float,double,string,char),
|
||||
* mode protégé limité à 4Go de mémoire vive (32 bits),
|
||||
* gestion avancée de la mémoire (vmalloc).
|
||||
* chargeur ELF32,
|
||||
* espace utilisateur et appels systèmes,
|
||||
* ordonnanceur de tâche (par TSS),
|
||||
|
||||
#### En cours
|
||||
|
||||
* correction de bogues - libération des ressources après destruction processus,
|
||||
* liste d'API automatiquement mise à jour avec intégration de librairies & header,
|
||||
* gestion du système de fichier CRAMFS,
|
||||
* lancement du noyau par kernel et non par multiboot afin de bénéficier de initrd,
|
||||
|
||||
#### A faire
|
||||
|
||||
* pilote IDE/ATA (PIO mode),
|
||||
* fonctions affichage image PNG,
|
||||
* double buffering,
|
||||
* gestion multiprocessing,
|
||||
* virtualisation par VMX,
|
||||
* Gestion du système de fichier EXT2FS.
|
||||
|
||||
![COS2000 le 29-11-2018](https://github.com/dahut87/cos2000v2/raw/develop/Graphisme/screenshots/29-11-2018.png)
|
||||
|
||||
#### Autres Licences (autres auteurs)
|
||||
|
||||
Des fichiers sources utilisés par COS2000 sont sous d'autres licences, parmis ceux-ci figurent :
|
||||
|
||||
* `include/queues.h` sous licence Berkeley Software Distribution License
|
||||
* `tools/*` sous licence GPL V2.0, fichiers issus du noyau Linux
|
||||
* `debug/gdbinit`, GDB dashboard - Modular visual interface for GDB in Python Copyright (c) 2015-2017 Andrea Cardaci <cyrus.and@gmail.com>.
|
||||
|
||||
#### Historique du projet
|
||||
* Version 2.2fr - C en mode protégé Reprise du projet
|
||||
* Version 2.1fr - C en mode protégé Abandon du projet
|
||||
|
|
|
@ -1,4 +1,6 @@
|
|||
![logo](https://github.com/dahut87/cos2000v2/raw/master/Graphisme/logo.png)
|
||||
|
||||
## Copies d'écran de COS2000
|
||||
![screen](https://github.com/dahut87/cos2000v2/raw/develop/Graphisme/screenshots/28-09-2018.png)
|
||||
![screen](https://github.com/dahut87/cos2000v2/raw/develop/Graphisme/screenshots/29-11-2018.png)
|
||||
![screen](https://github.com/dahut87/cos2000v2/raw/develop/Graphisme/screenshots/ansi.png)
|
||||
|
|
245
boot/boot12.asm
245
boot/boot12.asm
|
@ -1,245 +0,0 @@
|
|||
[BITS 16]
|
||||
[ORG 0x7C00]
|
||||
|
||||
section .text
|
||||
|
||||
start:
|
||||
jmp near Boot
|
||||
|
||||
Disk_ID db "COS2000A" ;Fabricant + n° de série Formatage
|
||||
Sectors_Size dw 512 ;Nombre d'octets/secteur
|
||||
Sectors_Per_Cluster db 1 ;Nombre de secteurs/cluster
|
||||
Reserved_Sectors dw 1 ;Nombre de secteurs réservé
|
||||
Fats_Number db 2 ;Nombre de copies de la FAT
|
||||
Fits_Number dw 224 ;Taille du répertoire racine
|
||||
Sectors_Per_Disk dw 2880 ;Nombre secteurs du volume si < 32 Mo
|
||||
Media_Descriptor db 0xF0 ;Descripteur de média
|
||||
Sectors_Per_Fat dw 9 ;Nombre secteurs/FAT
|
||||
Sectors_Per_Track dw 18 ;Nombre secteurs/piste
|
||||
Heads_Number dw 2 ;Nombre de tete de lecture/écriture
|
||||
Sectors_Hidden dd 0 ;Nombre de secteurs cachés
|
||||
Sectors_Per_Disk2 dd 0 ;Nombre secteurs du volume si > 32 Mo
|
||||
Boot_Drive db 0 ;Lecteur de démarrage
|
||||
Reserved db 0 ;NA (pour NT seulement)
|
||||
Extended_Boot_ID db 0x29 ;Signature Boot étendu 29h
|
||||
Serial_Number dd 0x01020304 ;N° de série
|
||||
Disk_Name db "COS2000 " ;Nom de volume
|
||||
Fat_Type db "FAT12 " ;Type de système de fichiers
|
||||
|
||||
Boot_Message db "Cos2000",0
|
||||
Entre_Message db "Fichier",0
|
||||
Loading_Message db "Charger",0
|
||||
System_File db "Al",0,"o",0,"a",0,"d",0,"e",0,0x0F,0,0x38,"r",0,".",0,"s",0,"y",0,"s",0,0,0,0,0,0xFF,0xFF,0xFF,0xFF
|
||||
Is_Ok db " [ OK ]",0x0A,0x0D,0
|
||||
Is_Failed db " [ERREUR]",0x0A,0x0D,0
|
||||
The_Dot db '.',0
|
||||
|
||||
Boot_Error:
|
||||
mov si,Is_Failed
|
||||
call ShowString
|
||||
xor ax,ax
|
||||
int 0x16
|
||||
int 0x19
|
||||
|
||||
Boot_Ok:
|
||||
mov si,Is_Ok
|
||||
call ShowString
|
||||
ret
|
||||
|
||||
Boot:
|
||||
push cs
|
||||
push cs
|
||||
pop es
|
||||
pop ds
|
||||
mov [Boot_Drive],dl
|
||||
cli
|
||||
mov ax,0x9000
|
||||
mov ss,ax
|
||||
mov sp,0xFFFF
|
||||
sti
|
||||
mov si,Boot_Message
|
||||
call ShowString
|
||||
xor ax,ax
|
||||
int 0x13
|
||||
jc Boot_Error
|
||||
mov cx,[Reserved_Sectors]
|
||||
add cx,[Sectors_Hidden]
|
||||
adc cx,[Sectors_Hidden+2]
|
||||
mov bx,[Sectors_Per_Fat]
|
||||
mov di,Fat_Buffer
|
||||
push bx
|
||||
push cx
|
||||
readfat:
|
||||
call ReadSector
|
||||
jc Boot_Error
|
||||
inc cx
|
||||
add di,[Sectors_Size]
|
||||
dec bx
|
||||
jnz readfat
|
||||
pop cx
|
||||
pop bx
|
||||
xor ax,ax
|
||||
mov al,[Fats_Number]
|
||||
mul bx
|
||||
add cx,ax
|
||||
mov ax,32
|
||||
mul word [Fits_Number]
|
||||
div word [Sectors_Size]
|
||||
add ax,cx
|
||||
sub ax,2
|
||||
mov word [Serial_Number],ax
|
||||
xor dx,dx
|
||||
call Boot_Ok
|
||||
mov si,Loading_Message
|
||||
call ShowString
|
||||
Find_System:
|
||||
mov di,Buffer
|
||||
call ReadSector
|
||||
jc Near Boot_Error
|
||||
xor bx,bx
|
||||
Next_Root_Entrie:
|
||||
cmp byte [di],0
|
||||
je near Boot_Error
|
||||
push di
|
||||
push cx
|
||||
mov si,System_File
|
||||
mov cx,32
|
||||
rep cmpsb
|
||||
pop cx
|
||||
pop di
|
||||
je System_Found
|
||||
add di,32
|
||||
add bx,32
|
||||
inc dx
|
||||
cmp dx,[Fits_Number]
|
||||
ja near Boot_Error
|
||||
cmp bx,[Sectors_Size]
|
||||
jb Next_Root_Entrie
|
||||
inc cx
|
||||
jmp Find_System
|
||||
System_Found:
|
||||
call Boot_Ok
|
||||
mov si,Entre_Message
|
||||
call ShowString
|
||||
mov cx,[di+26+32]
|
||||
mov ax,0x0080
|
||||
mov es,ax
|
||||
push es
|
||||
mov di,0x0
|
||||
push di
|
||||
mov si,The_Dot
|
||||
Resume_Loading:
|
||||
cmp cx,0x0FF0
|
||||
jae Finish_Loading
|
||||
push cx
|
||||
add cx,word [Serial_Number]
|
||||
call ReadSector
|
||||
pop cx
|
||||
jc near Boot_Error
|
||||
call ShowString
|
||||
add di,[Sectors_Size]
|
||||
call NextFatGroup
|
||||
jc near Boot_Error
|
||||
jmp Resume_Loading
|
||||
Finish_Loading:
|
||||
call Boot_Ok
|
||||
retf
|
||||
|
||||
;====================READSECTOR=======================
|
||||
;Lit le secteur logique LBA CX et le met en es:di
|
||||
;-> CX (limité à 65536 secteurs, soit 32 Mo avec secteur 512 octets)
|
||||
;<- Flag Carry si erreur
|
||||
;=====================================================
|
||||
ReadSector:
|
||||
pusha
|
||||
mov ax,cx
|
||||
xor dx,dx
|
||||
div word [Sectors_Per_Track]
|
||||
inc dl
|
||||
mov bl,dl
|
||||
xor dx,dx
|
||||
div word [Heads_Number]
|
||||
mov dh, [Boot_Drive]
|
||||
xchg dl,dh
|
||||
mov cx,ax
|
||||
xchg cl,ch
|
||||
shl cl,6
|
||||
or cl, bl
|
||||
mov bx,di
|
||||
mov si, 4
|
||||
mov al, 1
|
||||
Read_Again:
|
||||
mov ah, 2
|
||||
int 0x13
|
||||
jnc Read_Done
|
||||
dec si
|
||||
jnz Read_Again
|
||||
Read_Done:
|
||||
popa
|
||||
ret
|
||||
|
||||
;===================NEXTFATGROUP======================
|
||||
;Renvoie en CX le groupe qui succède dans la FAT le groupe CX
|
||||
;-> CX
|
||||
;<-
|
||||
;=====================================================
|
||||
NextFatGroup:
|
||||
push bx
|
||||
push dx
|
||||
push di
|
||||
mov ax,cx
|
||||
mov bx,ax
|
||||
and bx,0000000000000001b
|
||||
shr ax,1
|
||||
mov cx,3
|
||||
mul cx
|
||||
mov di,Fat_Buffer
|
||||
add di,ax
|
||||
cmp bx,0
|
||||
jnz Even_Group
|
||||
Odd_Group:
|
||||
mov dx,[di]
|
||||
and dx,0x0FFF
|
||||
mov cx,dx
|
||||
jmp Next_Group_Found
|
||||
Even_Group:
|
||||
mov dx,[di+1]
|
||||
and dx,0xFFF0
|
||||
shr dx,4
|
||||
mov cx,dx
|
||||
Next_Group_Found:
|
||||
pop di
|
||||
pop dx
|
||||
pop bx
|
||||
ret
|
||||
|
||||
;======================SHOWSTR========================
|
||||
;Affiche la chaine de caractère pointé par ds:si à l'écran
|
||||
;-> DS, SI
|
||||
;<- Flag Carry si erreur
|
||||
;=====================================================
|
||||
ShowString:
|
||||
pusha
|
||||
Next_Char:
|
||||
lodsb
|
||||
or al,al
|
||||
jz End_Show
|
||||
mov ah,0x0E
|
||||
mov bx,0x07
|
||||
int 0x10
|
||||
jmp Next_Char
|
||||
End_Show:
|
||||
popa
|
||||
ret
|
||||
|
||||
times 510-($-$$) db ' '
|
||||
|
||||
dw 0xAA55
|
||||
|
||||
Buffer equ $
|
||||
Fat_Buffer equ $+512
|
||||
|
||||
section .bss
|
||||
|
||||
;Buffer resb 512
|
||||
;Fat_Buffer resb 10000
|
270
boot/boot16.asm
270
boot/boot16.asm
|
@ -1,270 +0,0 @@
|
|||
[BITS 16]
|
||||
[ORG 0x7C00]
|
||||
|
||||
section .text
|
||||
|
||||
start:
|
||||
jmp near Boot
|
||||
|
||||
Disk_ID db "COS2000A" ;Fabricant + n° de série Formatage
|
||||
Sectors_Size dw 512 ;Nombre d'octets/secteur
|
||||
Sectors_Per_Cluster db 4 ;Nombre de secteurs/cluster
|
||||
Reserved_Sectors dw 1 ;Nombre de secteurs réservé
|
||||
Fats_Number db 2 ;Nombre de copies de la FAT
|
||||
Fits_Number dw 512 ;Taille du répertoire racine
|
||||
Sectors_Per_Disk dw 2880 ;Nombre secteurs du volume si < 32 Mo
|
||||
Media_Descriptor db 0xF8 ;Descripteur de média
|
||||
Sectors_Per_Fat dw 207 ;Nombre secteurs/FAT
|
||||
Sectors_Per_Track dw 18 ;Nombre secteurs/piste
|
||||
Heads_Number dw 38 ;Nombre de tete de lecture/écriture
|
||||
Sectors_Hidden dd 16 ;Nombre de secteurs cachés
|
||||
Sectors_Per_Disk2 dd 39 ;Nombre secteurs du volume si > 32 Mo
|
||||
Boot_Drive db 0x80 ;Lecteur de démarrage
|
||||
Reserved db 0 ;NA (pour NT seulement)
|
||||
Extended_Boot_ID db 0x29 ;Signature Boot étendu 29h
|
||||
Serial_Number dd 0x01020304 ;N° de série
|
||||
Disk_Name db "COS2000 " ;Nom de volume
|
||||
Fat_Type db "FAT16 " ;Type de système de fichiers
|
||||
|
||||
;Cpu_Message db "CPU test",0
|
||||
;Boot_Message db "Booting ",0
|
||||
;Finding_Message db "System ",0
|
||||
;Loading_Message db "Loading ",0
|
||||
System_File db "SYSTEM SYS"
|
||||
Is_Ok db "[ OK ]",0x0A,0x0D,0
|
||||
Is_Failed db "[Failed]",0x0A,0x0D,"Press a key",0x0A,0x0D,0
|
||||
The_Dot db '.',0
|
||||
|
||||
Boot_Error:
|
||||
mov si,Is_Failed
|
||||
call ShowString
|
||||
mov ah,0
|
||||
int 0x16
|
||||
int 0x19
|
||||
|
||||
Boot_Ok:
|
||||
; mov al,[Stage]
|
||||
; cmp al,0
|
||||
; jz No_Ok
|
||||
mov si,Is_Ok
|
||||
call ShowString
|
||||
;No_Ok:
|
||||
; xor ah,ah
|
||||
; mov si,ax
|
||||
; add si,Boot_Message ;Cpu_Message
|
||||
; call ShowString
|
||||
; add byte [Stage],0x09
|
||||
ret
|
||||
;
|
||||
;Stage db 0
|
||||
|
||||
Boot:
|
||||
push cs
|
||||
push cs
|
||||
pop es
|
||||
pop ds
|
||||
mov [Boot_Drive],dl
|
||||
cli
|
||||
mov ax,0x9000
|
||||
mov ss,ax
|
||||
mov sp,0xFFFF
|
||||
sti
|
||||
; call Detect_Cpu
|
||||
; jc Boot_Error
|
||||
; call Boot_Ok
|
||||
xor ax,ax
|
||||
int 0x13
|
||||
; jc Boot_Error
|
||||
xor eax,eax
|
||||
add ax,[Reserved_Sectors]
|
||||
add ecx,eax
|
||||
mov di,Fat_Buffer
|
||||
call ReadSector
|
||||
jc Boot_Error
|
||||
xor eax,eax
|
||||
mov al,[Fats_Number]
|
||||
mov bx,[Sectors_Per_Fat]
|
||||
mul bx
|
||||
add ecx,eax
|
||||
mov ax,32
|
||||
mul word [Fits_Number]
|
||||
div word [Sectors_Size]
|
||||
add eax,ecx
|
||||
mov dword [Serial_Number],eax
|
||||
xor dx,dx
|
||||
; call Boot_Ok
|
||||
Find_System:
|
||||
mov di,Buffer
|
||||
call ReadSector
|
||||
jc near Boot_Error
|
||||
xor bx,bx
|
||||
Next_Root_Entrie:
|
||||
cmp byte [di],0
|
||||
je near Boot_Error
|
||||
push di
|
||||
push cx
|
||||
mov si,System_File
|
||||
mov cx,11
|
||||
rep cmpsb
|
||||
pop cx
|
||||
pop di
|
||||
je System_Found
|
||||
add di,32
|
||||
add bx,32
|
||||
inc dx
|
||||
cmp dx,[Fits_Number]
|
||||
ja near Boot_Error
|
||||
cmp bx,[Sectors_Size]
|
||||
jb Next_Root_Entrie
|
||||
inc ecx
|
||||
jmp Find_System
|
||||
System_Found:
|
||||
xor ecx,ecx
|
||||
mov cx,[di+26]
|
||||
mov ax,0x0071
|
||||
mov es,ax
|
||||
push es
|
||||
mov di,0x100
|
||||
push di
|
||||
; call Boot_Ok
|
||||
mov si,The_Dot
|
||||
Resume_Loading:
|
||||
cmp cx,0x0FFF0
|
||||
jae Finish_Loading
|
||||
call ReadGroup
|
||||
jc near Boot_Error
|
||||
call ShowString
|
||||
mov bx,cx
|
||||
shl bx,1
|
||||
mov cx,[bx+Fat_Buffer]
|
||||
jmp Resume_Loading
|
||||
Finish_Loading:
|
||||
call Boot_Ok
|
||||
retf
|
||||
|
||||
;====================READSECTOR=======================
|
||||
;Lit le secteur logique LBA ECX et le met en es:di
|
||||
;-> ECX (limité à 2^32 secteurs, soit 2 To avec secteur 512 octets)
|
||||
;<- Flag Carry si erreur
|
||||
;=====================================================
|
||||
ReadSector:
|
||||
pushad
|
||||
mov ax, cx
|
||||
ror ecx,16
|
||||
mov dx,cx
|
||||
rol ecx,16
|
||||
cmp ecx,4128705
|
||||
ja Extended_CHS
|
||||
div word [Sectors_Per_Track]
|
||||
inc dl
|
||||
mov bl, dl
|
||||
xor dx,dx
|
||||
div word [Heads_Number]
|
||||
mov dh, [Boot_Drive]
|
||||
xchg dl, dh
|
||||
mov cx, ax
|
||||
xchg cl, ch
|
||||
shl cl, 6
|
||||
or cl, bl
|
||||
mov bx, di
|
||||
mov si, 4
|
||||
mov al, 1
|
||||
Read_Again:
|
||||
mov ah, 2
|
||||
int 0x13
|
||||
jnc Read_Done
|
||||
dec si
|
||||
jnz Read_Again
|
||||
Read_Done:
|
||||
popad
|
||||
ret
|
||||
Extended_CHS:
|
||||
mov si,ECHS_Block
|
||||
mov byte [si+Sizes],0x10
|
||||
mov byte [si+Reserve],0x01
|
||||
mov byte [si+NumSectors],0x01
|
||||
mov [si+Adressseg],es
|
||||
mov [si+Adressoff],di
|
||||
mov [si+SectorLow],ax
|
||||
mov [si+SectorHigh],dx
|
||||
mov di,4
|
||||
mov dl,[Boot_Drive]
|
||||
Read_AgainX:
|
||||
mov ah, 42h
|
||||
int 13h
|
||||
jnc Read_Done
|
||||
dec di
|
||||
jnz Read_AgainX
|
||||
|
||||
;======================READGROUP======================
|
||||
;lit le groupe cx en es:di et incr‚mente DI
|
||||
;-> cx, es:di
|
||||
;<- di, Flag Carry si erreur
|
||||
;=====================================================
|
||||
ReadGroup:
|
||||
push ax
|
||||
push cx
|
||||
push dx
|
||||
mov al,[Sectors_Per_Cluster]
|
||||
sub cx,2
|
||||
xor ah,ah
|
||||
mul cx
|
||||
mov cx,dx
|
||||
shl ecx,16
|
||||
mov cx,ax
|
||||
add ecx,dword [Serial_Number]
|
||||
mov al,[Sectors_Per_Cluster]
|
||||
read:
|
||||
call ReadSector
|
||||
jc errors
|
||||
inc ecx
|
||||
add di,[Sectors_Size]
|
||||
dec al
|
||||
jnz read
|
||||
clc
|
||||
errors:
|
||||
pop dx
|
||||
pop cx
|
||||
pop ax
|
||||
ret
|
||||
|
||||
;======================SHOWSTR========================
|
||||
;Affiche la chaine de caractère pointé par ds:si à l'écran
|
||||
;-> DS, SI
|
||||
;<- Flag Carry si erreur
|
||||
;=====================================================
|
||||
ShowString:
|
||||
;push ax
|
||||
;push bx
|
||||
;push si
|
||||
pusha
|
||||
Next_Char:
|
||||
lodsb
|
||||
or al,al
|
||||
jz End_Show
|
||||
mov ah,0x0E
|
||||
mov bx,0x07
|
||||
int 0x10
|
||||
jmp Next_Char
|
||||
End_Show:
|
||||
;pop si
|
||||
;pop bx
|
||||
;pop ax
|
||||
popa
|
||||
ret
|
||||
|
||||
times 510-($-$$) db ' '
|
||||
|
||||
dw 0xAA55
|
||||
|
||||
ECHS_Block equ $
|
||||
Buffer equ $+26
|
||||
Fat_Buffer equ $+26+512
|
||||
|
||||
section .bss
|
||||
|
||||
%include "echs.h"
|
||||
|
||||
;ECHS_Block resb 24
|
||||
;Buffer resb 512
|
||||
;Fat_Buffer resb 10000
|
10
boot/echs.h
10
boot/echs.h
|
@ -1,10 +0,0 @@
|
|||
struc echs
|
||||
Sizes resb 1
|
||||
Reserve resb 1
|
||||
NumSectors resw 1
|
||||
Adressoff resw 1
|
||||
Adressseg resw 1
|
||||
SectorLow resw 1
|
||||
SectorHigh resw 1
|
||||
Dummy resq 1
|
||||
endstuc
|
116
boot/elf.h
116
boot/elf.h
|
@ -1,116 +0,0 @@
|
|||
struc ELFheader
|
||||
.Magic resb 1;"0x7F"
|
||||
.MagicStr resb 3;"ELF"
|
||||
.Computertype resb 1;1
|
||||
.Endianness resb 1;1
|
||||
.Original resb 1;1
|
||||
.OS resb 1;0
|
||||
.ABI resb 1;0
|
||||
.Dummy resb 7;0
|
||||
.Type resw 1;2
|
||||
.Target resw 1;3
|
||||
.Version resd 1;1
|
||||
.Entrypoint resd 1
|
||||
.Offsetprogram resd 1
|
||||
.Offsetsection resd 1
|
||||
.Flags resd 1
|
||||
.SizeELFheader resw 1
|
||||
.Sizeprogram resw 1
|
||||
.Nbprogram resw 1
|
||||
.Sizesection resw 1
|
||||
.Nbsection resw 1
|
||||
.Index resw 1
|
||||
.end equ $
|
||||
endstruc
|
||||
|
||||
struc Program
|
||||
.Type resd 1
|
||||
.Offset resd 1
|
||||
.Vadress resd 1
|
||||
.PAdress resd 1
|
||||
.Size resd 1
|
||||
.Memsize resd 1
|
||||
.Flags resd 1
|
||||
.Align resd 1
|
||||
.end equ $
|
||||
endstruc
|
||||
|
||||
struc Sections
|
||||
.Name resd 1
|
||||
.Type resd 1
|
||||
.Flags resd 1
|
||||
.Vadress resd 1
|
||||
.Offset resd 1
|
||||
.Size resd 1
|
||||
.Link resd 1
|
||||
.Info resd 1
|
||||
.Align resd 1
|
||||
.Entrysize resd 1
|
||||
.end equ $
|
||||
endstruc
|
||||
|
||||
|
||||
;type
|
||||
PT_NULL equ 0
|
||||
PT_LOAD equ 1
|
||||
PT_DYNAMIC equ 2
|
||||
PT_INTERP equ 3
|
||||
PT_NOTE equ 4
|
||||
PT_SHLIB equ 5
|
||||
PT_PHDR equ 6
|
||||
PT_TLS equ 7
|
||||
PT_LOOS equ 0x60000000
|
||||
PT_HIOS equ 0x6fffffff
|
||||
PT_LOPROC equ 0x70000000
|
||||
PT_HIPROC equ 0x7fffffff
|
||||
|
||||
;flags
|
||||
PF_WRITE equ 0x1
|
||||
PF_ALLOC equ 0x2
|
||||
PF_X equ 0x1 ;Execute
|
||||
PF_W equ 0x2 ;Write
|
||||
PF_R equ 0x4 ;Read
|
||||
PF_MASKOS equ 0x0ff00000 ;Unspecified
|
||||
PF_MASKPROC equ 0xf0000000 ;Unspecified
|
||||
|
||||
;type
|
||||
ST_EXIT equ 1
|
||||
ST_NULL equ 0
|
||||
ST_PROGBITS equ 1
|
||||
ST_SYMTAB equ 2
|
||||
ST_STRTAB equ 3
|
||||
ST_RELA equ 4
|
||||
ST_HASH equ 5
|
||||
ST_DYNAMIC equ 6
|
||||
ST_NOTE equ 7
|
||||
ST_NOBITS equ 8
|
||||
ST_REL equ 9
|
||||
ST_SHLIB equ 10
|
||||
ST_DYNSYM equ 11
|
||||
ST_INIT_ARRAY equ 14
|
||||
ST_FINI_ARRAY equ 15
|
||||
ST_PREINIT_ARRAY equ 16
|
||||
ST_GROUP equ 17
|
||||
ST_SYMTAB_SHNDX equ 18
|
||||
ST_LOOS equ 0x60000000
|
||||
ST_HIOS equ 0x6fffffff
|
||||
ST_LOPROC equ 0x70000000
|
||||
ST_HIPROC equ 0x7fffffff
|
||||
ST_LOUSER equ 0x80000000
|
||||
ST_HIUSER equ 0xffffffff
|
||||
|
||||
;flags
|
||||
SF_WRITE equ 0x1
|
||||
SF_ALLOC equ 0x2
|
||||
SF_EXECINSTR equ 0x4
|
||||
SF_MERGE equ 0x10
|
||||
SF_STRINGS equ 0x20
|
||||
SF_INFO_LINK equ 0x40
|
||||
SF_LINK_ORDER equ 0x80
|
||||
SF_OS_NONCONFORMING equ 0x100
|
||||
SF_GROUP equ 0x200
|
||||
SF_TLS equ 0x400
|
||||
SF_COMPRESSED equ 0x800
|
||||
SF_MASKOS equ 0x0ff00000
|
||||
SF_MASKPROC equ 0xf0000000
|
||||
|
852
boot/loader.asm
852
boot/loader.asm
|
@ -1,852 +0,0 @@
|
|||
[BITS 16]
|
||||
[ORG 0x0]
|
||||
|
||||
SECTION .text
|
||||
push cs
|
||||
push cs
|
||||
pop ds
|
||||
pop es
|
||||
mov si,msg0
|
||||
call showstr
|
||||
|
||||
mov si,msg1
|
||||
call showstr
|
||||
call initfat
|
||||
call ok
|
||||
|
||||
mov si,msg2
|
||||
call showstr
|
||||
mov si,System_File
|
||||
call search
|
||||
call ok
|
||||
|
||||
mov si,msg3
|
||||
call showstr
|
||||
call EnableA20
|
||||
call ok
|
||||
|
||||
mov si,msg4
|
||||
call showstr
|
||||
mov eax,cs
|
||||
shl eax,4
|
||||
mov [GDT.Entry1+2],ax
|
||||
mov [GDT.Entry2+2],ax
|
||||
shr eax,16
|
||||
mov [GDT.Entry1+4],al
|
||||
mov [GDT.Entry2+4],al
|
||||
mov eax,cs
|
||||
shl eax,4
|
||||
add eax,gdt0
|
||||
mov [GDTR.Address],eax
|
||||
lgdt [GDTR]
|
||||
call ok
|
||||
|
||||
mov si,msg5
|
||||
call showstr
|
||||
cli
|
||||
mov eax,cr0
|
||||
or al,1
|
||||
mov cr0,eax
|
||||
jmp short $+2
|
||||
mov bx,SYS_DATA_SEL
|
||||
mov fs,bx
|
||||
mov ds,bx
|
||||
mov es,bx
|
||||
mov gs,bx
|
||||
and al,0FEh
|
||||
mov cr0,eax
|
||||
jmp short $+2
|
||||
mov bx,cs
|
||||
mov fs,bx
|
||||
mov ds,bx
|
||||
mov es,bx
|
||||
mov gs,bx
|
||||
sti
|
||||
call ok
|
||||
|
||||
|
||||
|
||||
mov si,msg6
|
||||
call showstr
|
||||
mov ebx,0x300000
|
||||
call load
|
||||
call ok
|
||||
|
||||
mov si,msg7
|
||||
call showstr
|
||||
call initpe
|
||||
call ok
|
||||
suite:
|
||||
;mov cx,suite
|
||||
;call debug
|
||||
mov si,msg8
|
||||
call showstr
|
||||
cli
|
||||
mov al,0x80
|
||||
out 0x70,al
|
||||
mov eax,cr0
|
||||
or al,1
|
||||
mov cr0,eax
|
||||
jmp SYS_CODE_SEL:GoPMode32
|
||||
|
||||
|
||||
Boot_Error:
|
||||
mov si,error
|
||||
call showstr
|
||||
xor ax,ax
|
||||
int 16h
|
||||
jmp 0xFFFF:0x0
|
||||
|
||||
ok:
|
||||
push si
|
||||
push cx
|
||||
mov cl,67
|
||||
call eol
|
||||
mov si,okay
|
||||
call showstr
|
||||
pop cx
|
||||
pop si
|
||||
ret
|
||||
|
||||
;======================INITPE========================
|
||||
;Initialise le PE de l'adresse EBX
|
||||
;->
|
||||
;<- Flag Carry si erreur
|
||||
;=====================================================
|
||||
initpe:
|
||||
pusha
|
||||
push es
|
||||
xor ax,ax
|
||||
mov es,ax
|
||||
mov [begin],ebx
|
||||
cmp word [es:ebx+ELFheader.Magic],0x457F ; bien l'entete .elf ?
|
||||
jne near errorelf
|
||||
cmp word [es:ebx+ELFheader.Magic+2],"LF" ; bien l'entete .elf ?
|
||||
jne near errorelf
|
||||
cmp byte [es:ebx+ELFheader.Computertype],0x1 ; type ok ?
|
||||
jne near errorelf
|
||||
cmp byte [es:ebx+ELFheader.Endianness],0x1 ; type ok ?
|
||||
jne near errorelf
|
||||
cmp byte [es:ebx+ELFheader.Original],0x1 ; type ok ?
|
||||
jne near errorelf
|
||||
cmp byte [es:ebx+ELFheader.OS],0x0 ; type ok ?
|
||||
jne near errorelf
|
||||
cmp byte [es:ebx+ELFheader.ABI],0x0 ; type ok ?
|
||||
jne near errorelf
|
||||
cmp byte [es:ebx+ELFheader.Dummy],0x0 ; type ok ?
|
||||
jne near errorelf
|
||||
mov si,info1
|
||||
call showstr
|
||||
mov esi,[es:ebx+ELFheader.Entrypoint]
|
||||
mov [entriepoint],esi
|
||||
mov esi,[es:ebx+ELFheader.Offsetprogram]
|
||||
add esi,ebx
|
||||
mov [offsetheader],esi
|
||||
mov esi,[es:ebx+ELFheader.Offsetsection]
|
||||
add esi,ebx
|
||||
mov [offsetsection],esi
|
||||
mov cx,[es:ebx+ELFheader.Nbprogram]
|
||||
mov [cs:nbprogram],cx
|
||||
mov cx,[es:ebx+ELFheader.Nbsection]
|
||||
mov [cs:nbsection],cx
|
||||
xor eax,eax
|
||||
mov ax,[es:ebx+ELFheader.Index]
|
||||
xor edx,edx
|
||||
mov dx,[es:ebx+ELFheader.Sizesection]
|
||||
mul edx
|
||||
add eax,esi
|
||||
mov eax,[es:eax+Sections.Offset]
|
||||
add eax,ebx
|
||||
mov [cs:symbol],eax
|
||||
xor eax,eax
|
||||
add ax,[es:ebx+ELFheader.Sizesection]
|
||||
add esi,eax
|
||||
sections:
|
||||
mov edi,esi
|
||||
cmp dword [es:edi+Sections.Type],0x00
|
||||
jz nothing
|
||||
mov esi,info2
|
||||
call showstr
|
||||
push ds
|
||||
push es
|
||||
pop ds
|
||||
mov esi,[es:edi+Sections.Name]
|
||||
add esi,[cs:symbol]
|
||||
call showstr
|
||||
pop ds
|
||||
mov esi,info3
|
||||
call showstr
|
||||
mov edx,[es:edi+Sections.Offset]
|
||||
push cx
|
||||
mov cx,32
|
||||
call ShowHex
|
||||
pop cx
|
||||
mov esi,info4
|
||||
call showstr
|
||||
mov edx,[es:edi+Sections.Size]
|
||||
push cx
|
||||
mov cx,32
|
||||
call ShowHex
|
||||
pop cx
|
||||
mov esi,info5
|
||||
call showstr
|
||||
mov edx,[es:edi+Sections.Vadress]
|
||||
push cx
|
||||
mov cx,32
|
||||
call ShowHex
|
||||
pop cx
|
||||
and dword [es:edi+Sections.Flags],SF_ALLOC
|
||||
jne itsok
|
||||
mov esi,info6
|
||||
call showstr
|
||||
jmp itsok2
|
||||
itsok:
|
||||
mov esi,info10
|
||||
call showstr
|
||||
call copy2mem
|
||||
cmp dword [es:edi+Sections.Type],ST_NOBITS
|
||||
jne itsok2
|
||||
mov esi,info9
|
||||
call showstr
|
||||
mov esi,info10
|
||||
call showstr
|
||||
call zero2mem
|
||||
itsok2:
|
||||
push cx
|
||||
xor cx,cx
|
||||
mov edx,[es:edi+Sections.Align]
|
||||
mov esi,info8
|
||||
call showstr
|
||||
nextpower:
|
||||
cmp edx,0
|
||||
je powerok
|
||||
cmp edx,1
|
||||
je powerok
|
||||
cmp cx,32
|
||||
je powerok
|
||||
inc cx
|
||||
shr edx,1
|
||||
jnc nextpower
|
||||
powerok:
|
||||
mov edx,ecx
|
||||
mov cx,4
|
||||
call ShowHex
|
||||
pop cx
|
||||
call showrtn
|
||||
mov esi,edi
|
||||
nothing:
|
||||
add esi,eax
|
||||
dec cx
|
||||
jnz sections
|
||||
mov esi,info7
|
||||
call showstr
|
||||
mov edx,[cs:entriepoint]
|
||||
mov cx,32
|
||||
call ShowHex
|
||||
clc
|
||||
pop es
|
||||
popa
|
||||
ret
|
||||
|
||||
errorelf:
|
||||
stc
|
||||
pop es
|
||||
popa
|
||||
ret
|
||||
|
||||
;==========DEBUG===========
|
||||
;CX adresse
|
||||
;->CX
|
||||
;<-
|
||||
;===========================================
|
||||
debug:
|
||||
mov esi,info11
|
||||
call showstr
|
||||
xor edx,edx
|
||||
mov dx,cs
|
||||
shl edx,4
|
||||
add edx,ecx
|
||||
mov cx,32
|
||||
call ShowHex
|
||||
infini:
|
||||
jmp infini
|
||||
|
||||
|
||||
;==========COPY2MEM===========
|
||||
;Copie de es:esi vers es:edi
|
||||
;->ES:ESI ES:EDI CX
|
||||
;<- Flag
|
||||
;===========================================
|
||||
copy2mem:
|
||||
push eax
|
||||
push esi
|
||||
push edi
|
||||
push ecx
|
||||
mov esi,[es:edi+Sections.Offset]
|
||||
add esi,[cs:begin]
|
||||
mov ecx,[es:edi+Sections.Size]
|
||||
shr ecx,2
|
||||
inc ecx
|
||||
mov edi,[es:edi+Sections.Vadress]
|
||||
copietomem:
|
||||
mov eax,[es:esi]
|
||||
mov [es:edi],eax
|
||||
add edi,4
|
||||
add esi,4
|
||||
dec ecx
|
||||
jnz copietomem
|
||||
pop ecx
|
||||
pop edi
|
||||
pop esi
|
||||
pop eax
|
||||
ret
|
||||
|
||||
;==========ZERO2MEM===========
|
||||
;Remise à zero de es:edi
|
||||
;->ES:EDI CX
|
||||
;<- Flag
|
||||
;===========================================
|
||||
zero2mem:
|
||||
push eax
|
||||
push esi
|
||||
push edi
|
||||
push ecx
|
||||
mov esi,[es:edi+Sections.Offset]
|
||||
add esi,[cs:begin]
|
||||
mov ecx,[es:edi+Sections.Size]
|
||||
shr ecx,2
|
||||
inc ecx
|
||||
mov edi,[es:edi+Sections.Vadress]
|
||||
mov eax,0
|
||||
zerotomem:
|
||||
mov [es:edi],eax
|
||||
add edi,4
|
||||
dec ecx
|
||||
jnz zerotomem
|
||||
pop ecx
|
||||
pop edi
|
||||
pop esi
|
||||
pop eax
|
||||
ret
|
||||
|
||||
begin dd 0
|
||||
entriepoint dd 0
|
||||
offsetheader dd 0
|
||||
offsetsection dd 0
|
||||
nbprogram dw 0
|
||||
nbsection dw 0
|
||||
symbol dd 0
|
||||
|
||||
;==========SHOWHEX===========
|
||||
;Affiche un nombre hexadécimal EDX de taille CX aprés le curseur
|
||||
;-> EDX un entier, CX la taille
|
||||
;<-
|
||||
;===========================================
|
||||
ShowHex:
|
||||
push ax
|
||||
push bx
|
||||
push cx
|
||||
push edx
|
||||
push si
|
||||
mov ax,cx
|
||||
shr ax,2
|
||||
sub cx,32
|
||||
neg cx
|
||||
shl edx,cl
|
||||
xor cx,cx
|
||||
inc cx
|
||||
Hexaize:
|
||||
rol edx,4
|
||||
mov bx,dx
|
||||
and bx,0fh
|
||||
mov si,ax
|
||||
mov al,[cs:bx+Tab]
|
||||
xor bx,bx
|
||||
mov ah,0x09
|
||||
mov bl,[cs:thecolor]
|
||||
int 0x10
|
||||
mov ah,0x0E
|
||||
int 0x10
|
||||
mov ax,si
|
||||
dec al
|
||||
jnz Hexaize
|
||||
pop si
|
||||
pop edx
|
||||
pop cx
|
||||
pop bx
|
||||
pop ax
|
||||
ret
|
||||
Tab db '0123456789ABCDEF'
|
||||
|
||||
;======================EOL========================
|
||||
;Va en colonne CX
|
||||
;->
|
||||
;<- Flag Carry si erreur
|
||||
;=====================================================
|
||||
eol:
|
||||
pusha
|
||||
mov bp,cx
|
||||
mov ah,03
|
||||
xor bx,bx
|
||||
int 10h
|
||||
mov ah,02
|
||||
mov cx,bp
|
||||
mov dl,cl
|
||||
int 10h
|
||||
popa
|
||||
ret
|
||||
|
||||
|
||||
;======================LOAD========================
|
||||
;Charge le groupe en mémoire en ebx
|
||||
;->
|
||||
;<- Flag Carry si erreur
|
||||
;=====================================================
|
||||
load:
|
||||
push ax
|
||||
push ebx
|
||||
push ecx
|
||||
push edx
|
||||
push esi
|
||||
push edi
|
||||
push fs
|
||||
xor edx,edx
|
||||
xor ax,ax
|
||||
mov fs,ax
|
||||
mov si,The_Dot
|
||||
mov dx,[Sectors_Size]
|
||||
Resume_Loading:
|
||||
cmp cx,0x0FF0
|
||||
jae Finish_Loading
|
||||
push cx
|
||||
add cx,word [data]
|
||||
mov edi,Buffer
|
||||
call ReadSector
|
||||
pop cx
|
||||
jc near Boot_Error
|
||||
call showstr
|
||||
push esi
|
||||
push ebx
|
||||
push cx
|
||||
mov esi,Buffer
|
||||
mov cx,dx
|
||||
shr cx,2
|
||||
copie:
|
||||
mov eax,[ds:esi]
|
||||
mov [fs:ebx],eax
|
||||
add ebx,4
|
||||
add esi,4
|
||||
dec cx
|
||||
jnz copie
|
||||
pop cx
|
||||
pop ebx
|
||||
pop esi
|
||||
add ebx,edx
|
||||
call NextFatGroup
|
||||
jc near Boot_Error
|
||||
jmp Resume_Loading
|
||||
Finish_Loading:
|
||||
pop fs
|
||||
pop edi
|
||||
pop esi
|
||||
pop edx
|
||||
pop ecx
|
||||
pop ebx
|
||||
pop ax
|
||||
ret
|
||||
|
||||
;======================INITFAT========================
|
||||
;Initialise les variables de la fat
|
||||
;->
|
||||
;<- Flag Carry si erreur
|
||||
;=====================================================
|
||||
initfat:
|
||||
pusha
|
||||
push ds
|
||||
xor ax,ax
|
||||
mov ds,ax
|
||||
mov si,0x7C0B
|
||||
mov di,bootsector
|
||||
mov cx, 512
|
||||
rep movsb
|
||||
pop ds
|
||||
mov cx,[Reserved_Sectors]
|
||||
add cx,[Sectors_Hidden]
|
||||
adc cx,[Sectors_Hidden+2]
|
||||
mov bx,[Sectors_Per_Fat]
|
||||
mov di,Fat_Buffer
|
||||
push bx
|
||||
push cx
|
||||
readfat:
|
||||
call ReadSector
|
||||
jc Boot_Error
|
||||
inc cx
|
||||
add di,[Sectors_Size]
|
||||
dec bx
|
||||
jnz readfat
|
||||
pop cx
|
||||
pop bx
|
||||
xor ax,ax
|
||||
mov al,[Fats_Number]
|
||||
mul bx
|
||||
add cx,ax
|
||||
mov [entries],cx
|
||||
mov ax,32
|
||||
mul word [Fits_Number]
|
||||
div word [Sectors_Size]
|
||||
add cx,ax
|
||||
sub cx,2
|
||||
mov word [data],cx
|
||||
popa
|
||||
ret
|
||||
|
||||
;======================SEARCH========================
|
||||
;Recherche le groupe d'un fichier
|
||||
;-> si nom du fichier
|
||||
;<- Flag Carry si erreur CX
|
||||
;=====================================================
|
||||
search:
|
||||
push bx
|
||||
push dx
|
||||
push di
|
||||
mov cx,[entries]
|
||||
mov di,Buffer
|
||||
call ReadSector
|
||||
jc Boot_Error
|
||||
xor bx,bx
|
||||
Next_Root_Entrie:
|
||||
cmp byte [di],0
|
||||
je Boot_Error
|
||||
push si
|
||||
push di
|
||||
push cx
|
||||
mov cx,32
|
||||
rep cmpsb
|
||||
pop cx
|
||||
pop di
|
||||
pop si
|
||||
je Found
|
||||
add di,32
|
||||
add bx,32
|
||||
inc dx
|
||||
cmp dx,[Fits_Number]
|
||||
ja Boot_Error
|
||||
cmp bx,[Sectors_Size]
|
||||
jb Next_Root_Entrie
|
||||
inc cx
|
||||
Found:
|
||||
mov cx,[di+26+32]
|
||||
pop di
|
||||
pop dx
|
||||
pop bx
|
||||
ret
|
||||
|
||||
;======================SHOWRTN========================
|
||||
;Affiche la chaine de caractère return
|
||||
;->
|
||||
;<- Flag Carry si erreur
|
||||
;=====================================================
|
||||
showrtn:
|
||||
push ds
|
||||
push ax
|
||||
push esi
|
||||
mov esi,return
|
||||
mov ax,cs
|
||||
mov ds,ax
|
||||
call showstr
|
||||
pop esi
|
||||
pop ax
|
||||
pop ds
|
||||
ret
|
||||
|
||||
;======================SHOWSTR========================
|
||||
;Affiche la chaine de caractère pointé par ds:esi à l'écran
|
||||
;-> DS, SI
|
||||
;<- Flag Carry si erreur
|
||||
;=====================================================
|
||||
showstr:
|
||||
pushad
|
||||
xor bh,bh
|
||||
nextchar:
|
||||
mov al,[ds:esi]
|
||||
inc esi
|
||||
or al,al
|
||||
jz endshow
|
||||
cmp al,' '
|
||||
jb justchar
|
||||
cmp al,'#'
|
||||
jne nocolor
|
||||
mov al,[ds:esi]
|
||||
inc esi
|
||||
sub al,'0'
|
||||
shl al,3
|
||||
mov [cs:thecolor],al
|
||||
shr al,2
|
||||
add [cs:thecolor],al
|
||||
mov al,[ds:esi]
|
||||
inc esi
|
||||
sub al,'0'
|
||||
add [cs:thecolor],al
|
||||
jmp nextchar
|
||||
nocolor:
|
||||
cmp al,'@'
|
||||
jne nocolor2
|
||||
mov al,[ds:esi]
|
||||
inc esi
|
||||
sub al,'0'
|
||||
shl al,3
|
||||
mov cl,al
|
||||
shr al,2
|
||||
add cl,al
|
||||
mov al,[ds:esi]
|
||||
inc esi
|
||||
sub cl,'0'
|
||||
add cl,al
|
||||
call eol
|
||||
jmp nextchar
|
||||
nocolor2:
|
||||
xor bx,bx
|
||||
mov ah,0x09
|
||||
mov bl,[cs:thecolor]
|
||||
xor cx,cx
|
||||
inc cx
|
||||
int 0x10
|
||||
justchar:
|
||||
mov ah,0x0E
|
||||
int 0x10
|
||||
jmp nextchar
|
||||
endshow:
|
||||
popad
|
||||
ret
|
||||
|
||||
|
||||
;====================READSECTOR=======================
|
||||
;Lit le secteur logique LBA CX et le met en es:di
|
||||
;-> CX (limité à 65536 secteurs, soit 32 Mo avec secteur 512 octets)
|
||||
;<- Flag Carry si erreur
|
||||
;=====================================================
|
||||
ReadSector:
|
||||
pusha
|
||||
mov ax,cx
|
||||
xor dx,dx
|
||||
div word [Sectors_Per_Track]
|
||||
inc dl
|
||||
mov bl,dl
|
||||
xor dx,dx
|
||||
div word [Heads_Number]
|
||||
mov dh, [Boot_Drive]
|
||||
xchg dl,dh
|
||||
mov cx,ax
|
||||
xchg cl,ch
|
||||
shl cl,6
|
||||
or cl, bl
|
||||
mov bx,di
|
||||
mov si, 4
|
||||
mov al, 1
|
||||
Read_Again:
|
||||
mov ah, 2
|
||||
int 0x13
|
||||
jnc Read_Done
|
||||
dec si
|
||||
jnz Read_Again
|
||||
Read_Done:
|
||||
popa
|
||||
ret
|
||||
|
||||
;===================NEXTFATGROUP======================
|
||||
;Renvoie en CX le groupe qui succède dans la FAT le groupe CX
|
||||
;-> CX
|
||||
;<-
|
||||
;=====================================================
|
||||
NextFatGroup:
|
||||
push bx
|
||||
push dx
|
||||
push di
|
||||
mov ax,cx
|
||||
mov bx,ax
|
||||
and bx,0000000000000001b
|
||||
shr ax,1
|
||||
mov cx,3
|
||||
mul cx
|
||||
mov di,Fat_Buffer
|
||||
add di,ax
|
||||
cmp bx,0
|
||||
jnz Even_Group
|
||||
Odd_Group:
|
||||
mov dx,[di]
|
||||
and dx,0x0FFF
|
||||
mov cx,dx
|
||||
jmp Next_Group_Found
|
||||
Even_Group:
|
||||
mov dx,[di+1]
|
||||
and dx,0xFFF0
|
||||
shr dx,4
|
||||
mov cx,dx
|
||||
Next_Group_Found:
|
||||
pop di
|
||||
pop dx
|
||||
pop bx
|
||||
ret
|
||||
|
||||
;***********************EnableA20*******************************
|
||||
;->
|
||||
;<-
|
||||
;Ouvre l'autoroute A20
|
||||
;***************************************************************
|
||||
EnableA20:
|
||||
cli
|
||||
call ClearKeybBuffer
|
||||
call WaitKeybCommand
|
||||
mov al,0xd1
|
||||
out 0x64,al
|
||||
call WaitKeybCommand
|
||||
mov al,0xdf
|
||||
out 0x60,al
|
||||
call WaitKeybCommand
|
||||
jmp A20Enabled
|
||||
WaitKeybCommand:
|
||||
in al,0x64
|
||||
test al,0x02
|
||||
jnz WaitKeybCommand
|
||||
ret
|
||||
ClearKeybBuffer:
|
||||
in al,0x64
|
||||
test al,0x01
|
||||
jnz ReadKeyb
|
||||
ret
|
||||
ReadKeyb:
|
||||
in al,0x60
|
||||
jmp ClearKeybBuffer
|
||||
A20Enabled:
|
||||
sti
|
||||
ret
|
||||
|
||||
|
||||
GoPMode32:
|
||||
[BITS 32]
|
||||
mov ax,ALL_DATA_SEL
|
||||
mov es,ax
|
||||
mov gs,ax
|
||||
mov fs,ax
|
||||
mov ss,ax
|
||||
mov ds,ax
|
||||
mov esp,0x3fffff
|
||||
push KERNEL_SEL
|
||||
push dword [cs:entriepoint]
|
||||
retf
|
||||
|
||||
section .data
|
||||
|
||||
thecolor db 0x07
|
||||
msg0 db '#12@20-=< Lancement du Chargeur ELF >=-',0x0A,0x0D,0x0A,0x0D,0
|
||||
msg1 db '#07Initialisation de la FAT',0
|
||||
msg2 db '#07Recherche du systeme',0
|
||||
msg3 db '#07Activation adressage 24 bits',0
|
||||
msg4 db '#07Chargement des descripteurs',0
|
||||
msg5 db '#07Passage en mode Flat real',0
|
||||
msg6 db '#07Chargement du systeme',0
|
||||
msg7 db '#07Mise en place format ELF',0
|
||||
msg8 db '#07Passage en mode protege',0
|
||||
|
||||
|
||||
info1 db 0x0A,0x0D,'Format ELF i386 reconnu, #08Sections :',0x0A,0x0D,0
|
||||
info2 db ' ',0
|
||||
info3 db '@12 | ',0
|
||||
info4 db ' - ',0
|
||||
info5 db ' -> ',0
|
||||
info6 db '@35#12NON ALLOUE #08',0
|
||||
info7 db 'Point entree en ',0
|
||||
info8 db '@48 2**',0
|
||||
info9 db '@15#12 VIDE #08',0
|
||||
info10 db '@70MEM',0
|
||||
info11 db 0x0A,0x0D,'#12Arret debug en ',0
|
||||
|
||||
return db 0x0A,0x0D,0
|
||||
|
||||
okay db ' #15[ #10OK #15]',0x0A,0x0D,0
|
||||
error db ' #15[#12Erreur#15]',0x0A,0x0D,0x0A,0x0D,' <Appuyez une touche pour redemarrer>',0
|
||||
The_Dot db '.',0
|
||||
System_File db "As",0,"y",0,"s",0,"t",0,"e",0,0x0F,0,0xB8,"m",0,".",0,"s",0,"y",0,"s",0,0,0,0,0,0xFF,0xFF,0xFF,0xFF
|
||||
entries dw 0
|
||||
data dw 0
|
||||
xy dw 0
|
||||
|
||||
GDTR:
|
||||
.Size: dw GDT_END
|
||||
.Address: dd 0
|
||||
|
||||
gdt0 equ $ ; null entry
|
||||
GDT:
|
||||
.Entry0: dw 0 ; limit 15:0
|
||||
dw 0 ; base 15:0
|
||||
db 0 ; base 23:16
|
||||
db 0 ; type
|
||||
db 0 ; limit 19:16, flags
|
||||
db 0 ; base 31:24
|
||||
|
||||
|
||||
SYS_CODE_SEL equ $-gdt0 ; code segment descriptor
|
||||
|
||||
.Entry1: dw 0xFFFF
|
||||
dw 0x0 ; base
|
||||
db 0x0 ; base
|
||||
db 0x9A ; present, ring 0, code, non-conforming, readable
|
||||
db 0xCF ; 32 bit
|
||||
db 0
|
||||
|
||||
|
||||
SYS_DATA_SEL equ $-gdt0 ; data segment descriptor
|
||||
|
||||
.Entry2: dw 0xFFFF
|
||||
dw 0x0 ; base
|
||||
db 0x0 ; base
|
||||
db 0x92 ; present, ring 0, data, expand-up, writable
|
||||
db 0xCF ; 32 bit
|
||||
db 0
|
||||
|
||||
|
||||
ALL_DATA_SEL equ $-gdt0 ; 4meg data segment descriptor
|
||||
|
||||
.Entry3: dw 0xFFFF
|
||||
dw 0x0 ; base
|
||||
db 0x0 ; base
|
||||
db 0x92 ; present, ring 0, data, expand-up, writable
|
||||
db 0xCF ; 4k pages, 32 bit
|
||||
db 0
|
||||
|
||||
|
||||
KERNEL_SEL equ $-gdt0 ; 4g code segment descriptor
|
||||
|
||||
.Entry4: dw 0xffff
|
||||
dw 0x0 ; base
|
||||
db 0x0 ; base
|
||||
db 0x9A ; present, ring 0, code, non-conforming, readable
|
||||
db 0xCF ; 4k pages, 32 bit
|
||||
db 0
|
||||
|
||||
GDT_END equ $-gdt0 -1
|
||||
|
||||
bootsector equ $
|
||||
Sectors_Size dw 0 ;Nombre d'octets/secteur
|
||||
Sectors_Per_Cluster db 0 ;Nombre de secteurs/cluster
|
||||
Reserved_Sectors dw 0 ;Nombre de secteurs réservé
|
||||
Fats_Number db 0 ;Nombre de copies de la FAT
|
||||
Fits_Number dw 0 ;Taille du répertoire racine
|
||||
Sectors_Per_Disk dw 0 ;Nombre secteurs du volume si < 32 Mo
|
||||
Media_Descriptor db 0 ;Descripteur de média
|
||||
Sectors_Per_Fat dw 0 ;Nombre secteurs/FAT
|
||||
Sectors_Per_Track dw 0 ;Nombre secteurs/piste
|
||||
Heads_Number dw 0 ;Nombre de tete de lecture/écriture
|
||||
Sectors_Hidden dd 0 ;Nombre de secteurs cachés
|
||||
Sectors_Per_Disk2 dd 0 ;Nombre secteurs du volume si > 32 Mo
|
||||
Boot_Drive db 0 ;Lecteur de démarrage
|
||||
Reserved db 0 ;NA (pour NT seulement)
|
||||
Extended_Boot_ID db 0 ;Signature Boot étendu 29h
|
||||
|
||||
Buffer equ $
|
||||
Fat_Buffer equ $+512
|
||||
|
||||
SECTION .bss
|
||||
|
||||
%include "elf.h"
|
||||
|
|
@ -1,22 +0,0 @@
|
|||
CC=nasm -f bin -o
|
||||
|
||||
all: makall
|
||||
|
||||
makall: boot12.bin boot16.bin loader.sys
|
||||
|
||||
boot12.bin: boot12.asm
|
||||
$(CC) $@ $^
|
||||
|
||||
boot16.bin: boot16.asm
|
||||
$(CC) $@ $^
|
||||
|
||||
loader.sys: loader.asm
|
||||
$(CC) $@ $^
|
||||
|
||||
clean:
|
||||
rm -f *.o
|
||||
rm -f *.bin
|
||||
rm -f *.sys
|
||||
rm -f *.com
|
||||
|
||||
|
|
@ -1,8 +1,10 @@
|
|||
target remote localhost:1234
|
||||
set disassembly-flavor intel
|
||||
set disassembly-flavor att
|
||||
add-symbol-file ./system/realmode/setup.sym 0x902f6
|
||||
set architecture i8086
|
||||
break *0x7c00
|
||||
break *0x90200
|
||||
cont
|
||||
clear *0x7c00
|
||||
layout asm
|
||||
layout regs
|
||||
clear *0x90200
|
||||
break main
|
||||
###cont
|
||||
clear main
|
||||
|
|
|
@ -0,0 +1,26 @@
|
|||
#!/bin/sh
|
||||
session="debug"
|
||||
tmux start-server
|
||||
tmux new-session -d -s $session -n gdb
|
||||
|
||||
tmux splitw -h -p 90
|
||||
tmux splitw -t 0 -v -p 50
|
||||
tmux splitw -t 2 -h -p 45
|
||||
tmux splitw -v -p 50
|
||||
tmux splitw -v -p 50
|
||||
|
||||
tmux send-keys -t 5 "gdb --init-command=./debug/gdbinit -x $1" Enter
|
||||
tmux send-keys -t 3 "telnet 127.0.0.1 6666" Enter
|
||||
tmux send-keys -t 5 "dashboard stack -output /dev/pts/4" Enter
|
||||
tmux send-keys -t 5 "dashboard threads -output /dev/null" Enter
|
||||
tmux send-keys -t 5 "dashboard assembly -output /dev/pts/3" Enter
|
||||
tmux send-keys -t 5 "dashboard registers -output /dev/pts/2" Enter
|
||||
tmux send-keys -t 5 "dashboard expressions -output /dev/pts/6" Enter
|
||||
tmux send-keys -t 5 "dashboard memory -output /dev/pts/6" Enter
|
||||
tmux send-keys -t 5 "dashboard source -output /dev/pts/3" Enter
|
||||
tmux send-keys -t 5 "dashboard history -output /dev/pts/7" Enter
|
||||
tmux send-keys -t 5 "dashboard threads -output /dev/null" Enter
|
||||
tmux send-keys -t 5 "dashboard stack -output /dev/pts/4" Enter
|
||||
tmux new-window -t $session:1 -n scratch
|
||||
tmux select-window -t $session:0
|
||||
tmux attach-session -t $session
|
File diff suppressed because it is too large
Load Diff
|
@ -1,7 +0,0 @@
|
|||
target remote localhost:1234
|
||||
set disassembly-flavor intel
|
||||
set architecture i8086
|
||||
break *0x800
|
||||
cont
|
||||
display/20i $pc+$cs*16
|
||||
clear *0x800
|
|
@ -1,8 +1,11 @@
|
|||
target remote localhost:1234
|
||||
set disassembly-flavor intel
|
||||
set disassembly-flavor att
|
||||
set architecture i386
|
||||
break *0x50000
|
||||
symbol-file ./system/system.sym
|
||||
break start
|
||||
break *0x100000
|
||||
cont
|
||||
clear *0x100000
|
||||
si
|
||||
break *0x100000
|
||||
cont
|
||||
symbol-file ./system/system.sys
|
||||
clear *0x50000
|
||||
display/20i $pc
|
||||
|
|
|
@ -3,6 +3,8 @@ RUN echo "http://alpine.42.fr/v3.12/main" > /etc/apk/repositories
|
|||
RUN echo "http://alpine.42.fr/v3.12/community" >> /etc/apk/repositories
|
||||
RUN apk --no-cache update
|
||||
RUN apk --no-cache upgrade
|
||||
RUN apk --no-cache add font-noto git gcc make qemu qemu-system-i386 dosfstools nasm sed gdb tar wget gzip indent binutils hexdump dos2unix xxd tmux git musl-dev gnome-terminal spice-gtk spice-gtk-tools python2
|
||||
RUN apk --no-cache add font-noto git gcc make qemu qemu-system-i386 qemu-system-x86_64 sed gdb ovmf tar wget gzip indent binutils hexdump dos2unix xxd xz tmux git musl-dev gnome-terminal spice-gtk spice-gtk-tools python2 cramfs
|
||||
RUN mkdir -p /usr/share/qemu/
|
||||
RUN ln -s /usr/share/OVMF/OVMF.fd /usr/share/qemu/OVMF.fd
|
||||
RUN mkdir /data
|
||||
WORKDIR /data
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
FROM debian:10
|
||||
|
||||
RUN apt-get update -yq \
|
||||
&& apt-get install --no-install-recommends gcc make qemu dosfstools gdb psmisc tmux git libc6-dev bsdmainutils tar wget bsdmainutils indent binutils xxd dos2unix nasm gnome-terminal spice-client-gtk python2.7 qemu-system-x86 -yq \
|
||||
&& apt-get install --no-install-recommends gcc make qemu fusefat fuseext2 gdb ovmf xz-utils psmisc tmux git libc6-dev bsdmainutils tar wget bsdmainutils indent binutils xxd dos2unix gnome-terminal spice-client-gtk python2.7 qemu-system-x86 -yq \
|
||||
&& apt-get clean -y
|
||||
RUN wget http://ftp.fr.debian.org/debian/pool/main/c/cramfs/cramfsprogs_1.1-6_amd64.deb -O /tmp/cramfsprogs_1.1-6_amd64.deb
|
||||
RUN dpkg -i /tmp/cramfsprogs_1.1-6_amd64.deb
|
||||
RUN mkdir /data
|
||||
WORKDIR /data
|
||||
|
|
Binary file not shown.
Binary file not shown.
|
@ -1,13 +1,57 @@
|
|||
all: cos2000.img
|
||||
REMOVE=rm -f
|
||||
INSTALL=sudo apt-get install
|
||||
COPY=cp
|
||||
DISKCOPY=dd
|
||||
COMPRESS=xz
|
||||
SYNC=sync
|
||||
CREATEDIR=mkdir
|
||||
CAT=cat
|
||||
|
||||
cos2000.img:
|
||||
(dd if=/dev/zero of=cos2000.img count=2880 bs=512)
|
||||
(mkfs.msdos -F 12 -n "COS2000" cos2000.img;mkdir ./mnt || true)
|
||||
(mount -t vfat cos2000.img ./mnt -o rw)
|
||||
(cp ../boot/loader.sys ./mnt/)
|
||||
(cp ../system/system.sys ./mnt/;sync)
|
||||
(umount ./mnt)
|
||||
(dd if=../boot/boot12.bin of=cos2000.img seek=0 count=1 conv=notrunc;sync)
|
||||
all: harddisk.img.final harddiskuefi.img.final
|
||||
|
||||
harddiskuefi.img.before:
|
||||
$(COMPRESS) -d -k harddiskuefi.img.xz
|
||||
$(DISKCOPY) if=harddiskuefi.img of=harddiskuefi.img.part1 skip=13672 bs=512
|
||||
$(DISKCOPY) if=harddiskuefi.img of=harddiskuefi.img.before count=13672 bs=512
|
||||
$(SYNC)
|
||||
$(CREATEDIR) ./mnt -p
|
||||
|
||||
harddiskuefi.img.final: harddiskuefi.img.before
|
||||
mount -t ext2 -o rw harddiskuefi.img.part1 ./mnt
|
||||
$(COPY) ../system/system.sys ./mnt/boot/
|
||||
$(SYNC)
|
||||
umount ./mnt
|
||||
cat harddiskuefi.img.before > harddiskuefi.img.final
|
||||
cat harddiskuefi.img.part1 >> harddiskuefi.img.final
|
||||
$(SYNC)
|
||||
|
||||
harddisk.img.before:
|
||||
$(COMPRESS) -d -k harddisk.img.xz
|
||||
$(DISKCOPY) if=harddisk.img of=harddisk.img.part1 skip=63 bs=512
|
||||
$(DISKCOPY) if=harddisk.img of=harddisk.img.before count=63 bs=512
|
||||
$(SYNC)
|
||||
$(CREATEDIR) ./mnt -p
|
||||
|
||||
harddisk.img.final: harddisk.img.before
|
||||
mount -t ext2 -o rw harddisk.img.part1 ./mnt
|
||||
$(COPY) ../system/system.sys ./mnt/boot/
|
||||
$(SYNC)
|
||||
umount ./mnt
|
||||
cat harddisk.img.before > harddisk.img.final
|
||||
cat harddisk.img.part1 >> harddisk.img.final
|
||||
$(SYNC)
|
||||
|
||||
initram.img:
|
||||
$(MAKE) ../programs
|
||||
|
||||
littleclean:
|
||||
$(REMOVE) *.final
|
||||
|
||||
togit: clean
|
||||
|
||||
clean:
|
||||
rm -f *.img
|
||||
$(REMOVE) *.before
|
||||
$(REMOVE) *.part1
|
||||
$(REMOVE) *.img
|
||||
$(REMOVE) *.final
|
||||
|
||||
|
|
|
@ -0,0 +1,31 @@
|
|||
#!/bin/bash
|
||||
dd if=/dev/zero of=harddisk.img count=10 bs=1048576
|
||||
parted -s -a cylinder harddisk.img mklabel msdos
|
||||
parted -s -a cylinder harddisk.img mkpart primary ext2 63s 10M
|
||||
parted -s -a cylinder harddisk.img toggle 1 boot
|
||||
lo=`losetup -f`
|
||||
echo ${lo}
|
||||
losetup -P ${lo} harddisk.img
|
||||
mkfs.ext2 ${lo}p1
|
||||
mount ${lo}p1 /mnt
|
||||
grub-install --no-floppy --install-modules="biosdisk part_msdos ext2 configfile normal linux16 linux vbe png gfxmenu video video_colors video_cirrus video_fb" --boot-directory=/mnt/boot ${lo} --target=i386-pc
|
||||
echo -en "\
|
||||
insmod ext2
|
||||
insmod biosdisk
|
||||
insmod part_msdos
|
||||
insmod linux
|
||||
insmod vbe
|
||||
insmod gfxterm
|
||||
insmod png
|
||||
insmod font
|
||||
set timeout=4\n\
|
||||
set default=0\n\
|
||||
menuentry "cos2000" {\n\
|
||||
set root=(hd0,1)\n\
|
||||
linux16 /boot/system.sys root=hd0,2 vesa=0318\n\
|
||||
initrd16 /boot/initram.img\n\
|
||||
boot\n\
|
||||
}" > /mnt/boot/grub/grub.cfg
|
||||
umount /mnt
|
||||
losetup -d ${lo}
|
||||
#xz -c harddisk.img > harddisk.img.xz
|
|
@ -0,0 +1,41 @@
|
|||
#!/bin/bash
|
||||
dd if=/dev/zero of=harddiskuefi.img count=10 bs=1048576
|
||||
parted -s harddiskuefi.img mklabel gpt
|
||||
parted -s -a cylinder harddiskuefi.img mkpart ESP fat16 63s 7M
|
||||
parted -s -a cylinder harddiskuefi.img mkpart linux ext2 7M 10M
|
||||
parted -s -a cylinder harddiskuefi.img toggle 1 boot
|
||||
lo=`losetup -f`
|
||||
echo ${lo}
|
||||
losetup -P ${lo} harddiskuefi.img
|
||||
mkfs.fat -F16 -s1 ${lo}p1
|
||||
mkfs.ext2 ${lo}p2
|
||||
mount ${lo}p1 /mnt
|
||||
mkdir /mnt/grub
|
||||
echo -en "(hd0) ${lo}\n(hd0,1) ${lo}p1\n(hd0,2) ${lo}p2" > /mnt/grub/device.map
|
||||
#LS MINICMD pour avoir vision paritions
|
||||
grub-install --no-floppy --boot-directory=/mnt/ --efi-directory=/mnt/ ${lo} --install-modules="part_gpt ext2 configfile normal linux16 video video_colors video_cirrus video_fb videotest all_video" --locales=fr --target=x86_64-efi --no-nvram
|
||||
mkdir /mnt/EFI/BOOT
|
||||
cp /mnt/EFI/ubuntu/grubx64.efi /mnt/EFI/BOOT/bootx64.efi
|
||||
#grub-mkimage -d /usr/lib/grub/x86_64-efi -o /mnt/EFI/BOOT/bootx64.efi -c /mnt/EFI/ubuntu/grub.cfg -p "(hd0,1)/grub/" -O x86_64-efi part_gpt ext2 configfile normal multiboot2 video video_color video_cirrus video_fb videotest all_video
|
||||
echo -en "\
|
||||
insmod ext2
|
||||
insmod biosdisk
|
||||
insmod part_msdos
|
||||
insmod linux
|
||||
insmod vbe
|
||||
insmod gfxterm
|
||||
insmod png
|
||||
insmod font
|
||||
set timeout=4\n\
|
||||
set default=0\n\
|
||||
menuentry "cos2000" {\n\
|
||||
set root=(hd0,gpt2)\n\
|
||||
linux16 /boot/system.sys root=hd0,gpt2\n
|
||||
boot\n\
|
||||
}" > /mnt/grub/grub.cfg
|
||||
umount /mnt
|
||||
mount ${lo}p2 /mnt
|
||||
mkdir /mnt/boot/
|
||||
umount /mnt
|
||||
losetup -d ${lo}
|
||||
xz -c harddiskuefi.img > harddiskuefi.img.xz
|
|
@ -0,0 +1,171 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "types.h"
|
||||
#include "matrix.h"
|
||||
#include "video.h"
|
||||
|
||||
typedef struct triface
|
||||
{
|
||||
u16 V1;
|
||||
u16 V2;
|
||||
u16 V3;
|
||||
} triface __attribute__ ((packed));
|
||||
|
||||
typedef struct model3d
|
||||
{
|
||||
u8 name[12];
|
||||
matrix44 view;
|
||||
vector4 *vertexlist;
|
||||
u16 vertexnb;
|
||||
triface *facelist;
|
||||
u16 facenb;
|
||||
} model3d __attribute__ ((packed));
|
||||
|
||||
typedef struct vertex3d
|
||||
{
|
||||
union
|
||||
{
|
||||
struct
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
};
|
||||
float v[3];
|
||||
};
|
||||
} vertex3d __attribute__ ((packed));
|
||||
|
||||
typedef enum type3D
|
||||
{
|
||||
TYPE3D_POINTS,
|
||||
TYPE3D_LINES,
|
||||
TYPE3D_FACES,
|
||||
TYPE3D_FLAT,
|
||||
TYPE3D_TEXTURE,
|
||||
} type3D __attribute__ ((packed));
|
||||
|
||||
|
||||
void proj(vector4 list[], vertex2d plane[], vector4 origin[],
|
||||
u16 number, float factor);
|
||||
void cube(model3d * model, vector4 * origin, u16 size);
|
||||
int load3ds(u8 * pointer, u32 size, model3d * model);
|
||||
void show3dmodel(model3d * model, matrix44 * transformation,
|
||||
vector4 origin[], float factor, type3D type);
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Fichier 3DS */
|
||||
|
||||
typedef enum dsState
|
||||
{
|
||||
DS_READ_CHUNK_ID,
|
||||
DS_READ_CHUNK_LENGTH,
|
||||
DS_READ_OBJECT_NAME,
|
||||
DS_SKIP_CHUNK,
|
||||
DS_READ_POINT_COUNT,
|
||||
DS_READ_POINTS,
|
||||
DS_READ_FACE_COUNT,
|
||||
DS_READ_FACES,
|
||||
DS_READ_MATRIX,
|
||||
DS_READ_DONE
|
||||
} dsState __attribute__ ((packed));
|
||||
|
||||
|
||||
#define MAIN3DS 0x4D4D
|
||||
|
||||
//>------ Main Chunks
|
||||
|
||||
#define EDIT3DS 0x3D3D // this is the start of the editor config
|
||||
#define KEYF3DS 0xB000 // this is the start of the keyframer config
|
||||
|
||||
//>------ sub defines of EDIT3DS
|
||||
|
||||
#define EDIT_MATERIAL 0xAFFF
|
||||
#define EDIT_CONFIG1 0x0100
|
||||
#define EDIT_CONFIG2 0x3E3D
|
||||
#define EDIT_VIEW_P1 0x7012
|
||||
#define EDIT_VIEW_P2 0x7011
|
||||
#define EDIT_VIEW_P3 0x7020
|
||||
#define EDIT_VIEW1 0x7001
|
||||
#define EDIT_BACKGR 0x1200
|
||||
#define EDIT_AMBIENT 0x2100
|
||||
#define EDIT_OBJECT 0x4000
|
||||
|
||||
#define EDIT_UNKNW01 0x1100
|
||||
#define EDIT_UNKNW02 0x1201
|
||||
#define EDIT_UNKNW03 0x1300
|
||||
#define EDIT_UNKNW04 0x1400
|
||||
#define EDIT_UNKNW05 0x1420
|
||||
#define EDIT_UNKNW06 0x1450
|
||||
#define EDIT_UNKNW07 0x1500
|
||||
#define EDIT_UNKNW08 0x2200
|
||||
#define EDIT_UNKNW09 0x2201
|
||||
#define EDIT_UNKNW10 0x2210
|
||||
#define EDIT_UNKNW11 0x2300
|
||||
#define EDIT_UNKNW12 0x2302 // new chunk type
|
||||
#define EDIT_UNKNW13 0x3000
|
||||
#define EDIT_UNKNW14 0xAFFF
|
||||
|
||||
//>------ sub defines of EDIT_MATERIAL
|
||||
#define MAT_NAME01 0xA000 //> includes name (see mli doc for materials)
|
||||
|
||||
//>------ sub defines of EDIT_OBJECT
|
||||
|
||||
#define OBJ_TRIMESH 0x4100
|
||||
#define OBJ_LIGHT 0x4600
|
||||
#define OBJ_CAMERA 0x4700
|
||||
|
||||
#define OBJ_UNKNWN01 0x4010
|
||||
#define OBJ_UNKNWN02 0x4012 //>>---- Could be shadow
|
||||
|
||||
//>------ sub defines of OBJ_CAMERA
|
||||
#define CAM_UNKNWN01 0x4710 // new chunk type
|
||||
#define CAM_UNKNWN02 0x4720 // new chunk type
|
||||
|
||||
//>------ sub defines of OBJ_LIGHT
|
||||
#define LIT_OFF 0x4620
|
||||
#define LIT_SPOT 0x4610
|
||||
#define LIT_UNKNWN01 0x465A
|
||||
|
||||
//>------ sub defines of OBJ_TRIMESH
|
||||
#define TRI_VERTEXL 0x4110
|
||||
#define TRI_FACEL2 0x4111 // unknown yet
|
||||
#define TRI_FACEL1 0x4120
|
||||
#define TRI_SMOOTH 0x4150
|
||||
#define TRI_LOCAL 0x4160
|
||||
#define TRI_VISIBLE 0x4165
|
||||
|
||||
//>>------ sub defs of KEYF3DS
|
||||
|
||||
#define KEYF_UNKNWN01 0xB009
|
||||
#define KEYF_UNKNWN02 0xB00A
|
||||
#define KEYF_FRAMES 0xB008
|
||||
#define KEYF_OBJDES 0xB002
|
||||
|
||||
#define KEYF_OBJHIERARCH 0xB010
|
||||
#define KEYF_OBJDUMMYNAME 0xB011
|
||||
#define KEYF_OBJUNKNWN01 0xB013
|
||||
#define KEYF_OBJUNKNWN02 0xB014
|
||||
#define KEYF_OBJUNKNWN03 0xB015
|
||||
#define KEYF_OBJPIVOT 0xB020
|
||||
#define KEYF_OBJUNKNWN04 0xB021
|
||||
#define KEYF_OBJUNKNWN05 0xB022
|
||||
|
||||
//>>------ these define the different color chunk types
|
||||
#define COL_RGB 0x0010
|
||||
#define COL_TRU 0x0011
|
||||
#define COL_UNK 0x0013 // unknown
|
||||
|
||||
//>>------ defines for viewport chunks
|
||||
|
||||
#define TOP 0x0001
|
||||
#define BOTTOM 0x0002
|
||||
#define LEFT 0x0003
|
||||
#define RIGHT 0x0004
|
||||
#define FRONT 0x0005
|
||||
#define BACK 0x0006
|
||||
#define USER 0x0007
|
||||
#define CAMERA 0x0008 // 0xFFFF is the code read from file
|
||||
#define LIGHT 0x0009
|
||||
#define DISABLED 0x0010
|
||||
#define BOGUS 0x0011
|
|
@ -1,26 +0,0 @@
|
|||
/***********************************/
|
||||
/* Librairie Kmemory.h */
|
||||
/* 20 Mars 2007 */
|
||||
/***********************************/
|
||||
|
||||
|
||||
#ifndef JREKCED_KERNEL_MEMORY
|
||||
# define JREKCED_KERNEL_MEMORY
|
||||
|
||||
# include "type.h"
|
||||
|
||||
# define MEMORY_BLOC_SIZE (1024L) /* Taille des blocs */
|
||||
|
||||
// Initialise les gestionnaire de memoire.
|
||||
void Kernel_InitMemory (void *DataMemory, // DataMemory pointe vers la zone de memoire disponible.
|
||||
UDWORD TotalMemorySize); // TotalMemorySize est la quantite total de memoire disponible.
|
||||
|
||||
void * Kernel_mballoc(UDWORD Size); // Alloue SIZE blocs de memoire et retourne un pointeur sur la zone.
|
||||
// Retourne un pointeur nul si l'allocation est impossible.
|
||||
|
||||
int Kernel_mbfree (void *Adresse); // Libere le bloc memoire alloue a l'adresse ADRESSE.
|
||||
// Retourne -1 si adresse incorrecte et 0 si tout s'est bien deroule.
|
||||
|
||||
void * Kernel_mbrealloc (void *Adresse, UDWORD Size); // Redimensionne un bloc, retourne NULL si le bloc
|
||||
// n'est pas redimensionne.
|
||||
#endif
|
|
@ -1,85 +0,0 @@
|
|||
/***********************************/
|
||||
/* Librairie LDT.h */
|
||||
/* 23 Mars 2007 */
|
||||
/***********************************/
|
||||
|
||||
#ifndef JREKCED_LDT
|
||||
# define JREKCED_LDT
|
||||
|
||||
# include "type.h"
|
||||
|
||||
# define LDT_BLOC_SIZE (128) /* Nombre de descripteur LDT dans un bloc */
|
||||
|
||||
// Types d'acces
|
||||
# define GLT_ACCESSED (0x1)
|
||||
|
||||
# define LDT_DATA (0x0)
|
||||
# define LDT_DATA_WRITE (0x2)
|
||||
# define LDT_DATA_EXPAND (0x4)
|
||||
|
||||
# define LDT_CODE (0x8)
|
||||
# define LDT_CODE_READ (0xA)
|
||||
# define LDT_CODE_CONFORMING (0xD)
|
||||
|
||||
// Granularite
|
||||
# define LDT_BYTE (0x0)
|
||||
# define LDT_4KB (0x1)
|
||||
|
||||
// Mode du CPU
|
||||
# define LDT_16BIT (0x0)
|
||||
# define LDT_32BIT (0x1)
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
UWORD Limite_0_15; // Bit 00-15 : Limite (0-15)
|
||||
UWORD Adresse_0_15; // Bit 16-31 : Adresse (0-15)
|
||||
UBYTE Adresse_16_23; // Bit 32-39 : Adresse (16-23)
|
||||
UBYTE Acces : 1; // 0 = System
|
||||
// 1 = Code ou data
|
||||
UBYTE Type : 4; // Bit 41-44 : Type
|
||||
UBYTE DPL : 2; // Spécifie le niveau de privilège du segment
|
||||
UBYTE Present : 1; // Indique si le segment est en mémoire (bit a 1) ou non (bit a 0)
|
||||
UBYTE Limite_16_19 : 4; // Bit 48-51 : Limite (16-19)
|
||||
UBYTE UserDefine : 1; // Bit 52 : Utilisation libre
|
||||
UBYTE Unused : 1; // Bit 53 : Non utilise (toujours = 0)
|
||||
UBYTE CPUMode : 1; // Bit 54 : = 0 -> 16-Bit
|
||||
// = 1 -> 32-Bit
|
||||
UBYTE Granularite : 1; // Si = 0 : Limite = 1 octet -> 1 Mo
|
||||
// Si = 1 : Limite = 4 Ko -> 4 Go
|
||||
UBYTE Adresse_24_31; // Bit 56-63 : Adresse (24-31)
|
||||
} T_LDT;
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
UWORD Size; // Taille de la GDT
|
||||
void * Adresse; // Adresse phisique de la GDT;
|
||||
UWORD Empty;
|
||||
|
||||
} T_LDT_reg;
|
||||
|
||||
|
||||
// T_LDT *GDT_BASE = ((T_LDT*)0x0800L); /* Addresse physique ou reside la GDT, le 1e element est toujours null */
|
||||
|
||||
|
||||
T_LDT * LDT_balloc (UWORD Size); // Alloue un bloc de Size LDT
|
||||
|
||||
int LDT_bfree (void * Adresse); // Libere un bloc LDT
|
||||
|
||||
T_LDT * LDT_brealloc (T_LDT * OldLDT, UWORD NewSize); // Redimensionne un bloc LDT, retourne NULL en cas d'erreur.
|
||||
|
||||
T_LDT * LDT_AllocLDT (T_LDT *BaseLDT); // Cherche un LDT libre dans un bloc precedement
|
||||
// alloue avec LDT_balloc.
|
||||
// Retourne NULL si aucun bloc disponible.
|
||||
// Si un bloc libre est trouve, il est marque comme
|
||||
// utilise et un pointeur sur ce LDT est retourne.
|
||||
|
||||
int LDT_FreeLDT (T_LDT *LDT); // Marque le LDT comme non utilise et le met a NULL.
|
||||
|
||||
int LDT_MapMemory (T_LDT *LDT, void * Linear, // Met des donnees dans un LDT.
|
||||
UDWORD Size, // Cette fonction est a tester.
|
||||
UBYTE Granularite,
|
||||
UBYTE DPL, UBYTE Type,
|
||||
UBYTE CPUMode);
|
||||
#endif
|
|
@ -1,74 +1,134 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "types.h"
|
||||
|
||||
#ifndef _ASM
|
||||
# define _ASM
|
||||
|
||||
/******************************************************************************/
|
||||
|
||||
#define sti() asm("sti"::)
|
||||
# define int20 asm("int $0x14")
|
||||
|
||||
#define cli() asm("cli"::)
|
||||
# define halt() asm("hlt"::)
|
||||
|
||||
#define nop() asm("nop"::)
|
||||
# define sti() asm("sti"::)
|
||||
|
||||
#define pushad() asm("pushal"::)
|
||||
# define cli() asm("cli"::)
|
||||
|
||||
#define popad() asm("popal"::)
|
||||
# define nop() asm("nop"::)
|
||||
|
||||
#define pushf() asm("pushf"::)
|
||||
# define pushad() asm("pushal"::)
|
||||
|
||||
#define popf() asm("popf"::)
|
||||
# define popad() asm("popal"::)
|
||||
|
||||
#define iret() asm("iret"::)
|
||||
# define pushf() asm("pushf"::)
|
||||
|
||||
#define irqendmaster() asm("movb $0x20,%al; \
|
||||
# define pop(mem) asm("popl %0":"=m" (mem))
|
||||
|
||||
# define push(mem) asm("pushl %0"::"m" (mem))
|
||||
|
||||
# define popf() asm("popf"::)
|
||||
|
||||
# define iret() asm("iret"::)
|
||||
|
||||
# define leave() asm("leave"::)
|
||||
|
||||
# define irqendmaster() asm("movb $0x20,%al; \
|
||||
outb %al,$0x20;")
|
||||
|
||||
#define irqendslave() asm("movb $0x20,%al; \
|
||||
# define irqendslave() asm("movb $0x20,%al; \
|
||||
outb %al,$0xA0;")
|
||||
|
||||
#define lidt(dtr) asm ("lidtl %0"::"m" (*dtr))
|
||||
# define lidt(idtr) asm ("lidtl %0"::"m" (idtr))
|
||||
|
||||
# define lgdt(gdtr) asm ("lgdtl %0"::"m" (gdtr))
|
||||
|
||||
# define lldt(ldtr) asm ("lldtl %0"::"m" (ldtr))
|
||||
|
||||
# define ltr(tss) asm volatile ("ltr %%ax":: "a" (tss))
|
||||
|
||||
# define sidt(idtr) asm ("sidtl %0"::"m" (idtr))
|
||||
|
||||
# define sgdt(gdtr) asm ("sgdtl %0"::"m" (gdtr))
|
||||
|
||||
# define sldt(ldtr) asm ("sldtl %0"::"m" (ldtr))
|
||||
|
||||
# define str(tss) asm volatile ("str %%ax;\
|
||||
mov %%ax,%0":: "m" (tss))
|
||||
|
||||
# define wrmsr(reg,low,high) asm volatile ("wrmsr" :: "c" (reg), "a" (low), "d" (high))
|
||||
|
||||
# define rdmsr(reg,low,high) asm volatile ("rdmsr" :: "=a" (low), "=d" (high) : "c" (reg) )
|
||||
|
||||
# define movsb(src,dst,count) \
|
||||
asm volatile ("cld;rep movsb"::"S" (src), "D" (dst), "c" (count));
|
||||
|
||||
# define movsw(src,dst,count) \
|
||||
asm volatile ("cld;rep movsw"::"S" (src), "D" (dst), "c" (count));
|
||||
|
||||
# define movsd(src,dst,count) \
|
||||
asm volatile ("cld;rep movsl"::"S" (src), "D" (dst), "c" (count));
|
||||
|
||||
# define stosb(pattern,dst,count) \
|
||||
asm volatile ("cld;rep stosb"::"c" (count), "D" (dst), "a" (pattern));
|
||||
|
||||
# define stosw(pattern,dst,count) \
|
||||
asm volatile ("cld;rep stosw"::"c" (count), "D" (dst), "a" (pattern));
|
||||
|
||||
# define stosd(pattern,dst,count) \
|
||||
asm volatile ("cld;rep stosl"::"c" (count), "D" (dst), "a" (pattern));
|
||||
|
||||
# define rol(addr) \
|
||||
asm volatile ("rolb $0x1,%0":"=m" (addr):);
|
||||
|
||||
# define ror(addr) \
|
||||
asm volatile ("rorb $0x1,%0":"=m" (addr):);
|
||||
|
||||
# define finit() \
|
||||
asm volatile ("finit"::);
|
||||
/******************************************************************************/
|
||||
|
||||
#define outb(port,value) \
|
||||
# define outb(port,value) \
|
||||
asm volatile ("outb %%al,%%dx"::"d" (port), "a" (value));
|
||||
|
||||
#define outw(port,value) \
|
||||
# define outw(port,value) \
|
||||
asm volatile ("outw %%ax,%%dx"::"d" (port), "a" (value));
|
||||
|
||||
#define outd(port,value) \
|
||||
# define outd(port,value) \
|
||||
asm volatile ("outl %%eax,%%dx"::"d" (port), "a" (value));
|
||||
|
||||
/******************************************************************************/
|
||||
|
||||
#define inb(port) ({ \
|
||||
# define inb(port) ({ \
|
||||
u8 _v; \
|
||||
asm volatile ("inb %%dx,%%al" : "=a" (_v) : "d" (port)); \
|
||||
_v; \
|
||||
})
|
||||
|
||||
#define inw(port) ({ \
|
||||
# define inw(port) ({ \
|
||||
u16 _v; \
|
||||
asm volatile ("inw %%dx,%%ax" : "=a" (_v) : "d"(port)); \
|
||||
_v; \
|
||||
}
|
||||
})
|
||||
|
||||
|
||||
#define ind(port) ({ \
|
||||
# define ind(port) ({ \
|
||||
u32 _v; \
|
||||
asm volatile ("inl %%dx,%%eax" : "=a" (_v) : "d"(port)); \
|
||||
_v; \
|
||||
}
|
||||
})
|
||||
|
||||
/******************************************************************************/
|
||||
|
||||
/* pas terminé */
|
||||
|
||||
#define rolb(input,rotate) ({ \
|
||||
# define rolb(input,rotate) ({ \
|
||||
u32 _v; \
|
||||
asm volatile ("roll %1,%0" : "=g" (_v) : "cI" (rotate), "0" (input)); \
|
||||
_v; \
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
|
|
@ -0,0 +1,85 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
/* Sources modifiées du noyau Linux linux-source-4.15.0/arch/x86/include/uapi/asm/bootparam.h
|
||||
/* Sources modifiées du noyau Linux linux-source-4.15.0/arch/x86/include/asm/e820/type.h
|
||||
|
||||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
|
||||
#ifndef _BOOT
|
||||
#define _BOOT
|
||||
|
||||
#include "types.h"
|
||||
#include "gdt.h"
|
||||
|
||||
#define E820_MAX_ENTRIES 128
|
||||
|
||||
typedef struct entrye820 {
|
||||
u64 addr;
|
||||
u64 size;
|
||||
u32 type;
|
||||
} entrye820 __attribute__((packed));
|
||||
|
||||
typedef struct bootparams {
|
||||
entrye820 e820_table[E820_MAX_ENTRIES];
|
||||
u32 e820_numbers;
|
||||
u8* cmdline;
|
||||
u8 kbflag;
|
||||
u32 ramdisksize;
|
||||
u32 ramdiskaddr;
|
||||
} bootparams;
|
||||
|
||||
|
||||
enum e820_type {
|
||||
E820_TYPE_RAM = 1,
|
||||
E820_TYPE_RESERVED = 2,
|
||||
E820_TYPE_ACPI = 3,
|
||||
E820_TYPE_NVS = 4,
|
||||
E820_TYPE_UNUSABLE = 5,
|
||||
E820_TYPE_PMEM = 7,
|
||||
E820_TYPE_PRAM = 12,
|
||||
E820_TYPE_RESERVED_KERN = 128,
|
||||
};
|
||||
|
||||
typedef struct header {
|
||||
u8 setup_sects;
|
||||
u16 root_flags;
|
||||
u32 syssize;
|
||||
u16 ram_size;
|
||||
u16 vid_mode;
|
||||
u16 root_dev;
|
||||
u16 boot_flag;
|
||||
u16 jump;
|
||||
u32 header;
|
||||
u16 version;
|
||||
u32 realmode_swtch;
|
||||
u16 start_sys_seg;
|
||||
u16 kernel_version;
|
||||
u8 type_of_loader;
|
||||
u8 loadflags;
|
||||
u16 setup_move_size;
|
||||
u32 code32_start;
|
||||
u32 ramdisk_image;
|
||||
u32 ramdisk_size;
|
||||
u32 bootsect_kludge;
|
||||
u16 heap_end_ptr;
|
||||
u8 ext_loader_ver;
|
||||
u8 ext_loader_type;
|
||||
u32 cmd_line_ptr;
|
||||
u32 initrd_addr_max;
|
||||
u32 kernel_alignment;
|
||||
u8 relocatable_kernel;
|
||||
u8 min_alignment;
|
||||
u16 xloadflags;
|
||||
u32 cmdline_size;
|
||||
u32 hardware_subarch;
|
||||
u64 hardware_subarch_data;
|
||||
u32 payload_offset;
|
||||
u32 payload_length;
|
||||
u64 setup_data;
|
||||
u64 pref_address;
|
||||
u32 init_size;
|
||||
u32 handover_offset;
|
||||
} __attribute__((packed)) header;
|
||||
|
||||
#endif
|
|
@ -1,31 +1,46 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "interrupts.h"
|
||||
|
||||
typedef struct cpuinfo
|
||||
{
|
||||
u8 vendor[13];
|
||||
u8 names[32];
|
||||
u8 detectedname[48];
|
||||
u8 techs[48];
|
||||
u8 stepping;
|
||||
u8 models;
|
||||
u8 family;
|
||||
u8 types;
|
||||
u8 emodels;
|
||||
u8 efamily;
|
||||
u8 apicid;
|
||||
u8 count;
|
||||
u8 linesize;
|
||||
u8 brandid;
|
||||
bool mmx;
|
||||
bool mmx2;
|
||||
bool sse;
|
||||
bool sse2;
|
||||
bool sse3;
|
||||
bool fpu;
|
||||
bool now3d;
|
||||
bool now3d2;
|
||||
bool htt;
|
||||
bool apic;
|
||||
} cpuinfo __attribute__ ((packed));
|
||||
|
||||
|
||||
u8 getcpuinfos(cpuinfo *inf);
|
||||
{
|
||||
u8 vendor[13];
|
||||
u8 names[32];
|
||||
u8 detectedname[256];
|
||||
u8 techs[256];
|
||||
u8 stepping;
|
||||
u8 models;
|
||||
u8 family;
|
||||
u8 types;
|
||||
u8 emodels;
|
||||
u8 efamily;
|
||||
u8 apicid;
|
||||
u8 count;
|
||||
u8 linesize;
|
||||
u8 brandid;
|
||||
bool mmx;
|
||||
bool mmx2;
|
||||
bool sse;
|
||||
bool sse2;
|
||||
bool sse3;
|
||||
bool fpu;
|
||||
bool now3d;
|
||||
bool now3d2;
|
||||
bool htt;
|
||||
bool apic;
|
||||
bool bits64;
|
||||
bool syscall;
|
||||
bool msr;
|
||||
bool sse4a;
|
||||
bool vmx;
|
||||
bool sse41;
|
||||
bool sse42;
|
||||
bool apic2;
|
||||
} cpuinfo __attribute__ ((packed));
|
||||
|
||||
bool cansetflag(u32 flag);
|
||||
void cpuid(u32 op, u32 * eax, u32 * ebx, u32 * ecx, u32 * edx);
|
||||
u8 getcpuinfos(cpuinfo * inf);
|
||||
void show_cpu(regs * stack);
|
||||
void cpuerror(const u8 * src, const regs * dump, bool returnto);
|
||||
|
|
|
@ -1,6 +0,0 @@
|
|||
|
||||
bool cansetflag (u32 flag);
|
||||
|
||||
void cpuid(u32 op, u32 *eax, u32 *ebx,u32 *ecx, u32 *edx);
|
||||
|
||||
void dump_regs();
|
|
@ -0,0 +1,83 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
|
||||
/* Sources modifiées du noyau Linux cramfs_fs.h
|
||||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
|
||||
#include "types.h"
|
||||
|
||||
#ifndef _CRAMFS
|
||||
#define _CRAMFS
|
||||
|
||||
#define CRAMFS_SIGNATURE "Compressed ROMFS"
|
||||
|
||||
#define CRAMFS_MODE_WIDTH 16
|
||||
#define CRAMFS_UID_WIDTH 16
|
||||
#define CRAMFS_SIZE_WIDTH 24
|
||||
#define CRAMFS_GID_WIDTH 8
|
||||
#define CRAMFS_NAMELEN_WIDTH 6
|
||||
#define CRAMFS_OFFSET_WIDTH 26
|
||||
#define CRAMFS_MAGIC 0x28cd3d45
|
||||
#define CRAMFS_MAXPATHLEN (((1 << CRAMFS_NAMELEN_WIDTH) - 1) << 2)
|
||||
#define PAD_SIZE 512
|
||||
#define PAGE_CACHE_SIZE (4096)
|
||||
typedef struct cramfs_inode {
|
||||
u32 mode:CRAMFS_MODE_WIDTH;
|
||||
u32 uid:CRAMFS_UID_WIDTH;
|
||||
u32 size:CRAMFS_SIZE_WIDTH;
|
||||
u32 gid:CRAMFS_GID_WIDTH;
|
||||
u32 namelen:CRAMFS_NAMELEN_WIDTH;
|
||||
u32 offset:CRAMFS_OFFSET_WIDTH;
|
||||
} cramfs_inode;
|
||||
|
||||
typedef struct cramfs_info {
|
||||
u32 crc;
|
||||
u32 edition;
|
||||
u32 blocks;
|
||||
u32 files;
|
||||
} cramfs_info;
|
||||
|
||||
typedef struct cramfs_super {
|
||||
u32 magic; /* 0x28cd3d45 - random number */
|
||||
u32 size; /* length in bytes */
|
||||
u32 flags; /* feature flags */
|
||||
u32 future; /* reserved for future use */
|
||||
u8 signature[16]; /* "Compressed ROMFS" */
|
||||
cramfs_info fsid; /* unique filesystem info */
|
||||
u8 name[16]; /* user-defined name */
|
||||
cramfs_inode root; /* root inode data */
|
||||
} cramfs_super;
|
||||
|
||||
#define S_ISDIR(m) ((m & 0170000) == 0040000) /* directory */
|
||||
#define S_ISCHR(m) ((m & 0170000) == 0020000) /* char special */
|
||||
#define S_ISBLK(m) ((m & 0170000) == 0060000) /* block special */
|
||||
#define S_ISREG(m) ((m & 0170000) == 0100000) /* regular file */
|
||||
#define S_ISFIFO(m) ((m & 0170000) == 0010000) /* fifo */
|
||||
#define S_ISLNK(m) ((m & 0170000) == 0120000) /* symbolic link */
|
||||
#define S_ISSOCK(m) ((m & 0170000) == 0140000) /* socket */
|
||||
|
||||
#define CRAMFS_FLAG_FSID_VERSION_2 0x00000001 /* fsid version #2 */
|
||||
#define CRAMFS_FLAG_SORTED_DIRS 0x00000002 /* sorted dirs */
|
||||
#define CRAMFS_FLAG_HOLES 0x00000100 /* support for holes */
|
||||
#define CRAMFS_FLAG_WRONG_SIGNATURE 0x00000200 /* reserved */
|
||||
#define CRAMFS_FLAG_SHIFTED_ROOT_OFFSET 0x00000400 /* shifted root fs */
|
||||
#define CRAMFS_FLAG_EXT_BLOCK_POINTERS 0x00000800 /* block pointer extensions */
|
||||
|
||||
#define CRAMFS_SUPPORTED_FLAGS ( 0x000000ff \
|
||||
| CRAMFS_FLAG_HOLES \
|
||||
| CRAMFS_FLAG_WRONG_SIGNATURE \
|
||||
| CRAMFS_FLAG_SHIFTED_ROOT_OFFSET \
|
||||
| CRAMFS_FLAG_EXT_BLOCK_POINTERS )
|
||||
|
||||
#define CRAMFS_BLK_FLAG_UNCOMPRESSED (1 << 31)
|
||||
#define CRAMFS_BLK_FLAG_DIRECT_PTR (1 << 30)
|
||||
|
||||
#define CRAMFS_BLK_FLAGS ( CRAMFS_BLK_FLAG_UNCOMPRESSED \
|
||||
| CRAMFS_BLK_FLAG_DIRECT_PTR )
|
||||
|
||||
#define CRAMFS_BLK_DIRECT_PTR_SHIFT 2
|
||||
|
||||
u32 test_super(u8 *src, u32 length);
|
||||
|
||||
#endif
|
|
@ -1,42 +0,0 @@
|
|||
#ifndef __TL_CTYPE_H
|
||||
#define __TL_CTYPE_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
extern char g_ctype[];
|
||||
|
||||
#define CT_UP 0x01 /* upper case */
|
||||
#define CT_LOW 0x02 /* lower case */
|
||||
#define CT_DIG 0x04 /* digit */
|
||||
#define CT_CTL 0x08 /* control */
|
||||
#define CT_PUN 0x10 /* punctuation */
|
||||
#define CT_WHT 0x20 /* white space (space/cr/lf/tab) */
|
||||
#define CT_HEX 0x40 /* hex digit */
|
||||
#define CT_SP 0x80 /* hard space (0x20) */
|
||||
|
||||
/* without the cast to unsigned, DJGPP complains (using -Wall) */
|
||||
#define isalnum(c) ((g_ctype + 1)[(unsigned)(c)] & (CT_UP | CT_LOW | CT_DIG))
|
||||
#define isalpha(c) ((g_ctype + 1)[(unsigned)(c)] & (CT_UP | CT_LOW))
|
||||
#define iscntrl(c) ((g_ctype + 1)[(unsigned)(c)] & (CT_CTL))
|
||||
#define isdigit(c) ((g_ctype + 1)[(unsigned)(c)] & (CT_DIG))
|
||||
#define isgraph(c) ((g_ctype + 1)[(unsigned)(c)] & (CT_PUN | CT_UP | CT_LOW | CT_DIG))
|
||||
#define islower(c) ((g_ctype + 1)[(unsigned)(c)] & (CT_LOW))
|
||||
#define isprint(c) ((g_ctype + 1)[(unsigned)(c)] & (CT_PUN | CT_UP | CT_LOW | CT_DIG | CT_SP))
|
||||
#define ispunct(c) ((g_ctype + 1)[(unsigned)(c)] & (CT_PUN))
|
||||
#define isspace(c) ((g_ctype + 1)[(unsigned)(c)] & (CT_WHT))
|
||||
#define isupper(c) ((g_ctype + 1)[(unsigned)(c)] & (CT_UP))
|
||||
#define isxdigit(c) ((g_ctype + 1)[(unsigned)(c)] & (CT_DIG | CT_HEX))
|
||||
#define isascii(c) ((unsigned)(c) <= 0x7F)
|
||||
#define toascii(c) ((unsigned)(c) & 0x7F)
|
||||
|
||||
#define tolower(c) (isupper(c) ? c + 'a' - 'A' : c)
|
||||
#define toupper(c) (islower(c) ? c + 'A' - 'a' : c)
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
|
@ -0,0 +1,51 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "types.h"
|
||||
|
||||
#define opBufSz 32
|
||||
|
||||
#define decodeSIB() \
|
||||
base = r32[*b&0x07]; \
|
||||
indx = r32[(*b&0x38)>>3]; \
|
||||
scale = ((*b&0xc0)>>6)*2; \
|
||||
if(scale && !indx){ \
|
||||
print("Invalid SIB byte."); \
|
||||
return; \
|
||||
}
|
||||
|
||||
#define setG() \
|
||||
reg = (*b&0x38)>>3; \
|
||||
if(!Gsz){ \
|
||||
} else if(Gsz == 1){ \
|
||||
G = r8[reg]; \
|
||||
} else if(Gsz == 2){ \
|
||||
G = r16[reg]; \
|
||||
} else if(Gsz == 3){ \
|
||||
G = r32[reg]; \
|
||||
} else if(Gsz == 4){ \
|
||||
if(reg < 8){ \
|
||||
G = rseg[reg]; \
|
||||
} else{ \
|
||||
print("Invalid Mod R/M byte."); \
|
||||
return; \
|
||||
} \
|
||||
} else{ \
|
||||
print("Invalid Mod R/M byte."); \
|
||||
return; \
|
||||
}
|
||||
|
||||
|
||||
#define DBG_EXEC 0b00
|
||||
#define DBG_WRITE 0b01
|
||||
#define DBG_CLEAR 0b10
|
||||
#define DBG_READWRITE 0b11
|
||||
|
||||
#define DBG_ONEBYTE 0b00
|
||||
#define DBG_TWOBYTE 0b01
|
||||
#define DBG_FOURBYTE 0b11
|
||||
|
||||
|
||||
void setdebugreg(u8 number, u8 * address, u8 type);
|
||||
u8 *getdebugreg(u8 number);
|
||||
u32 disasm(u8 * a, u8 * string, bool show);
|
|
@ -0,0 +1,99 @@
|
|||
#ifndef _GDT
|
||||
#define _GDT
|
||||
|
||||
/* Ordre imposé par SYSENTER */
|
||||
#define SEL_KERNEL_CODE 0x8 /* Selecteur code du kernel */
|
||||
#define SEL_KERNEL_STACK 0x10 /* Selecteur pile du kernel */
|
||||
#define SEL_USER_CODE 0x18 /* Selecteur code utilisateur */
|
||||
#define SEL_USER_STACK 0x20 /* Selecteur pile utilisateur */
|
||||
#define SEL_KERNEL_DATA 0x28 /* Selecteur data du kernel */
|
||||
#define SEL_USER_DATA 0x30 /* Selecteur data utilisateur */
|
||||
#define SEL_TSS 0x38 /* Selecteur TSR */
|
||||
|
||||
#define GDT_SIZE 0x8 /* Nombre de descripteurs */
|
||||
|
||||
/* Drapeau des descripteurs GDT */
|
||||
#define GRANULARITY_4K 0b00001000 /* Granularité alignement 4096 octet */
|
||||
#define GRANULARITY_1B 0b00000000 /* Granularité alignement 1 octet */
|
||||
#define OPSIZE_32B 0b00000100 /* Taille opérandes 32 bits */
|
||||
#define OPSIZE_16B 0b00000000 /* Taille opérandes 16 bits */
|
||||
#define SYS_AVAILABLE 0b00000001 /* Disponible pour le système (à définir) */
|
||||
|
||||
#define SEG_ACCESSED 0b00000001 /* Segment accédé (code ou data) */
|
||||
|
||||
#define SEG_DATA 0b00000000 /* Segment de données */
|
||||
#define SEG_CODE 0b00001000 /* Segment de données */
|
||||
|
||||
#define SEG_READ_WRITE 0b00000010 /* Segment lecture-ecriture (data) */
|
||||
#define SEG_EXPAND_DOWN 0b00000100 /* Segment avec expand-down (data) */
|
||||
|
||||
#define SEG_READ 0b00000010 /* Segment lecture (code) */
|
||||
#define SEG_CONFORMING 0b00000100 /* Segment conforming (code) */
|
||||
|
||||
#define SEG_PRESENT 0b10000000 /* Segment défini (obligatoire) */
|
||||
|
||||
#define SEG_RING0 0b00000000 /* Segment anneau 0 */
|
||||
#define SEG_RING1 0b00100000 /* Segment anneau 1 */
|
||||
#define SEG_RING2 0b01000000 /* Segment anneau 2 */
|
||||
#define SEG_RING3 0b01100000 /* Segment anneau 3 */
|
||||
|
||||
#define SEG_NORMAL 0b00010000 /* Segment normal pile/data/code (0 pour système) */
|
||||
|
||||
#ifndef __ASSEMBLY__
|
||||
|
||||
#include "types.h"
|
||||
|
||||
typedef struct gdtdes
|
||||
{
|
||||
u16 lim0_15;
|
||||
u16 base0_15;
|
||||
u8 base16_23;
|
||||
u8 acces;
|
||||
u8 lim16_19:4;
|
||||
u8 flags:4;
|
||||
u8 base24_31;
|
||||
} gdtdes __attribute__ ((packed));
|
||||
|
||||
struct gdtr
|
||||
{
|
||||
u16 limite;
|
||||
u32 base;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
typedef struct tss
|
||||
{
|
||||
u16 prevtask, reserved00;
|
||||
u32 esp0;
|
||||
u16 ss0, reserved0;
|
||||
u32 esp1;
|
||||
u16 ss1, reserved1;
|
||||
u32 esp2;
|
||||
u16 ss2, reserved2;
|
||||
u32 cr3;
|
||||
u32 eip, eflags, eax, ecx, edx, ebx, esp, ebp, esi, edi;
|
||||
u16 es, reserved3;
|
||||
u16 cs, reserved4;
|
||||
u16 ss, reserved5;
|
||||
u16 ds, reserved6;
|
||||
u16 fs, reserved7;
|
||||
u16 gs, reserved8;
|
||||
u16 ldt_selector, reserved9;
|
||||
u16 trapflag, iomap;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
void inittr(void);
|
||||
void initgdt();
|
||||
void makegdtdes(u32 base, u32 limite, u8 acces, u8 flags,
|
||||
gdtdes * desc);
|
||||
u32 getdesbase(u16 sel);
|
||||
u8 getdestype(u16 sel);
|
||||
u32 getdessize(u16 sel);
|
||||
u32 getdeslimit(u16 sel);
|
||||
bool isdesvalid(u16 sel);
|
||||
u8 getdesbit3(u16 sel);
|
||||
u32 getdesdpl(u16 sel);
|
||||
u16 getdesalign(u16 sel);
|
||||
void setTSS(u32 ss, u32 sp);
|
||||
|
||||
#endif
|
||||
#endif
|
|
@ -1 +0,0 @@
|
|||
void line(u32 x1, u32 y1, u32 x2, u32 y2, u8 color);
|
|
@ -0,0 +1,41 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "types.h"
|
||||
__attribute__ ((noreturn)) void exception_handler(regs *dump);
|
||||
__attribute__((interrupt)) void interruption(exception_stack_noerror *caller);
|
||||
void exception0();
|
||||
void exception1();
|
||||
void exception2();
|
||||
void exception3();
|
||||
void exception4();
|
||||
void exception5();
|
||||
void exception6();
|
||||
void exception7();
|
||||
void exception8();
|
||||
void exception9();
|
||||
void exception10();
|
||||
void exception11();
|
||||
void exception12();
|
||||
void exception13();
|
||||
void exception14();
|
||||
void exception15();
|
||||
void exception16();
|
||||
void exception17();
|
||||
void exception18();
|
||||
__attribute__((interrupt)) void irq0(exception_stack_noerror *caller);
|
||||
__attribute__((interrupt)) void irq1(exception_stack_noerror *caller);
|
||||
__attribute__((interrupt)) void irq2(exception_stack_noerror *caller);
|
||||
__attribute__((interrupt)) void irq3(exception_stack_noerror *caller);
|
||||
__attribute__((interrupt)) void irq4(exception_stack_noerror *caller);
|
||||
__attribute__((interrupt)) void irq5(exception_stack_noerror *caller);
|
||||
__attribute__((interrupt)) void irq6(exception_stack_noerror *caller);
|
||||
__attribute__((interrupt)) void irq7(exception_stack_noerror *caller);
|
||||
__attribute__((interrupt)) void irq8(exception_stack_noerror *caller);
|
||||
__attribute__((interrupt)) void irq9(exception_stack_noerror *caller);
|
||||
__attribute__((interrupt)) void irq10(exception_stack_noerror *caller);
|
||||
__attribute__((interrupt)) void irq11(exception_stack_noerror *caller);
|
||||
__attribute__((interrupt)) void irq12(exception_stack_noerror *caller);
|
||||
__attribute__((interrupt)) void irq13(exception_stack_noerror *caller);
|
||||
__attribute__((interrupt)) void irq14(exception_stack_noerror *caller);
|
||||
__attribute__((interrupt)) void irq15(exception_stack_noerror *caller);
|
|
@ -1,31 +0,0 @@
|
|||
#include "types.h"
|
||||
|
||||
|
||||
|
||||
#define INTGATE 0x8E00 /* utilise pour gerer les interruptions */
|
||||
#define TRAPGATE 0x8F00 /* utilise pour faire des appels systemes */
|
||||
#define TASKGATE 0x8500 /* utilise pour commuter des taches */
|
||||
#define CALLGATE 0x8C00 /* utilise pour appeler du code */
|
||||
#define LDTDES 0x8200 /* utilise pour pointer une LDT */
|
||||
|
||||
/* descripteur de segment */
|
||||
typedef struct idtdes {
|
||||
u16 offset0_15;
|
||||
u16 select;
|
||||
u16 type;
|
||||
u16 offset16_31;
|
||||
} idtdes __attribute__ ((packed));
|
||||
|
||||
|
||||
|
||||
void initidt(void);
|
||||
void setidt(u32 offset, u16 select, u16 type,u16 index);
|
||||
void makeidtdes(u32 offset, u16 select, u16 type, idtdes* desc);
|
||||
void initpic(void);
|
||||
void enableirq(u8 irq);
|
||||
void disableirq(u8 irq);
|
||||
void cpuerror(const u8 *src);
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,373 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "types.h"
|
||||
#include "asm.h"
|
||||
|
||||
#ifndef _INTERRUPTS
|
||||
# define _INTERRUPTS
|
||||
|
||||
# define PIC1_CMD 0x20 /*PIC 8259A Commandes n°1 */
|
||||
# define PIC1_DATA 0x21 /*PIC 8259A Données n°1 */
|
||||
# define PIC2_CMD 0xa0 /*PIC 8259A Commandes n°2 */
|
||||
# define PIC2_DATA 0xa1 /*PIC 8259A Données n°1 */
|
||||
|
||||
# define ICW1_ICW4 0x01 /* ICW4 ou pas */
|
||||
# define ICW1_SINGLE 0x02 /* mode seul ou cascadé */
|
||||
# define ICW1_INTERVAL4 0x04 /* adresses appel d'interval 4 ou 8 */
|
||||
# define ICW1_LEVEL 0x08 /* déclenchement sur niveau ou sur front */
|
||||
# define ICW1_INIT 0x10 /* Initialization */
|
||||
|
||||
# define ICW4_8086 0x01 /* 8086/88 (MCS-80/85) mode */
|
||||
# define ICW4_AUTO 0x02 /* Auto EOI ou normal */
|
||||
# define ICW4_BUF_SLAVE 0x08 /* mode/slave avec tampon */
|
||||
# define ICW4_BUF_MASTER 0x0C /* mode/master avec tampon */
|
||||
# define ICW4_SFNM 0x10 /* Complètement lié ou non */
|
||||
|
||||
# define INTGATE 0x0E00 /* utilise pour gerer les interruptions */
|
||||
# define TRAPGATE 0x0F00 /* utilise pour faire des appels systemes */
|
||||
# define TASKGATE 0x0500 /* utilise pour commuter des taches */
|
||||
# define CALLGATE 0x0C00 /* utilise pour appeler du code */
|
||||
# define LDTDES 0x0200 /* utilise pour pointer une LDT */
|
||||
|
||||
# define ENTRY_PRESENT 0b1000000000000000 /* Segment défini (obligatoire) */
|
||||
|
||||
# define ENTRY_STORAGE 0b0001000000000000 /* Segment défini (obligatoire) */
|
||||
|
||||
# define ENTRY_RING0 0b0000000000000000 /* Segment anneau 0 */
|
||||
# define ENTRY_RING1 0b0010000000000000 /* Segment anneau 1 */
|
||||
# define ENTRY_RING2 0b0100000000000000 /* Segment anneau 2 */
|
||||
# define ENTRY_RING3 0b0110000000000000 /* Segment anneau 3 */
|
||||
|
||||
/* 00-11-010-0 : Compteur 0 - LSB puis MSB - generateur taux - binaire */
|
||||
# define TIMER0 0x40 /* port E/S pour le timer canal 0 */
|
||||
# define TIMER_MODE 0x43 /* port E/S pour le mode controle du timer */
|
||||
# define RATE_GENERATOR 0x34 /* générateur de fréquence */
|
||||
# define SQUARE_WAVE 0x36 /* générateur d'onde carrée */
|
||||
# define TIMER_FREQ 1193180
|
||||
/* fréquence pour timer dans un PC ou AT */
|
||||
# define HZ 100 /* Fréquence d'horloge (ajutste logiciellement sur IBM-PC) */
|
||||
|
||||
# define setESP(mem) ({ \
|
||||
asm volatile ("movl %[frommem],%%esp;":[frommem] "=m" (mem):); \
|
||||
})
|
||||
|
||||
# define savecpu(dump,caller,oldesp) ({\
|
||||
getEBP(oldesp);\
|
||||
dumpcpu();\
|
||||
getESP(dump);\
|
||||
caller = (exception_stack *) (oldesp + 1);\
|
||||
dump->ebp = *oldesp;\
|
||||
dump->eip = caller->eip;\
|
||||
dump->cs = caller->cs;\
|
||||
if (caller->cs==SEL_KERNEL_CODE)\
|
||||
dump->esp = (u32) oldesp + sizeof(exception_stack);\
|
||||
else\
|
||||
{\
|
||||
dump->esp = (u32) ((exception_stack_user*) caller)->esp;\
|
||||
dump->ss = (u32) ((exception_stack_user*) caller)->ss;\
|
||||
}\
|
||||
})
|
||||
|
||||
# define savecpu_noerror(dump,caller,oldesp) ({\
|
||||
getEBP(oldesp);\
|
||||
dumpcpu();\
|
||||
getESP(dump);\
|
||||
caller = (exception_stack_noerror *) (oldesp + 1);\
|
||||
dump->ebp = *oldesp;\
|
||||
dump->eip = caller->eip;\
|
||||
dump->cs = caller->cs;\
|
||||
if (caller->cs==SEL_KERNEL_CODE)\
|
||||
dump->esp = (u32) oldesp + sizeof(exception_stack_noerror);\
|
||||
else\
|
||||
{\
|
||||
dump->esp = (u32) ((exception_stack_noerror_user*) caller)->esp;\
|
||||
dump->ss = (u32) ((exception_stack_noerror_user*) caller)->ss;\
|
||||
}\
|
||||
})
|
||||
|
||||
# define createdump(dump) ({ \
|
||||
push(dump.ss);\
|
||||
push(dump.esp);\
|
||||
push(dump.eflags);\
|
||||
push(dump.cs);\
|
||||
push(dump.eip);\
|
||||
push(dump.ds);\
|
||||
push(dump.es);\
|
||||
push(dump.fs);\
|
||||
push(dump.gs);\
|
||||
push(dump.eax);\
|
||||
push(dump.ebx);\
|
||||
push(dump.ecx);\
|
||||
push(dump.edx);\
|
||||
push(dump.esi);\
|
||||
push(dump.edi);\
|
||||
push(dump.ebp);\
|
||||
push(dump.cr0);\
|
||||
push(dump.cr2);\
|
||||
push(dump.cr3);\
|
||||
push(dump.cr4);\
|
||||
push(dump.dr0);\
|
||||
push(dump.dr1);\
|
||||
push(dump.dr2);\
|
||||
push(dump.dr3);\
|
||||
push(dump.dr6);\
|
||||
push(dump.dr7);\
|
||||
u32 eferlow=(u32) dump.efer & 0xFFFF;\
|
||||
u32 eferhigh=(u32) dump.efer >> 32;\
|
||||
push(eferlow);\
|
||||
push(eferhigh);\
|
||||
})
|
||||
|
||||
# define dumpcpu() ({ \
|
||||
asm("\
|
||||
pushl %%ss\n \
|
||||
pushl %%esp\n \
|
||||
pushf \n \
|
||||
pushl %%cs\n \
|
||||
pushl $0x0\n \
|
||||
pushl %%ds\n \
|
||||
pushl %%es\n \
|
||||
pushl %%fs\n \
|
||||
pushl %%gs\n \
|
||||
pushl %%eax\n \
|
||||
pushl %%ebx\n \
|
||||
pushl %%ecx\n \
|
||||
pushl %%edx\n \
|
||||
pushl %%esi\n \
|
||||
pushl %%edi\n \
|
||||
pushl %%ebp\n \
|
||||
mov %%cr0, %%eax \n \
|
||||
pushl %%eax\n \
|
||||
mov %%cr2, %%eax \n \
|
||||
pushl %%eax\n \
|
||||
mov %%cr3, %%eax \n \
|
||||
pushl %%eax\n \
|
||||
mov %%cr4, %%eax \n \
|
||||
pushl %%eax \n \
|
||||
mov %%dr0, %%eax \n \
|
||||
pushl %%eax\n \
|
||||
mov %%dr1, %%eax \n \
|
||||
pushl %%eax\n \
|
||||
mov %%dr2, %%eax \n \
|
||||
pushl %%eax\n \
|
||||
mov %%dr3, %%eax \n \
|
||||
pushl %%eax\n \
|
||||
mov %%dr6, %%eax \n \
|
||||
pushl %%eax\n \
|
||||
mov %%dr7, %%eax \n \
|
||||
pushl %%eax\n \
|
||||
mov $0xC0000080, %%ecx \n \
|
||||
rdmsr \n \
|
||||
pushl %%edx \n \
|
||||
pushl %%eax":::);\
|
||||
})
|
||||
|
||||
# define restcpu_kernel() ({\
|
||||
asm("\
|
||||
popl %%eax \n \
|
||||
popl %%edx \n \
|
||||
mov $0xC0000080, %%ecx \n \
|
||||
wrmsr\n \
|
||||
popl %%eax\n \
|
||||
popl %%eax \n \
|
||||
popl %%eax \n \
|
||||
popl %%eax \n \
|
||||
popl %%eax \n \
|
||||
popl %%eax \n \
|
||||
popl %%eax \n \
|
||||
popl %%eax \n \
|
||||
mov %%eax,%%cr3 \n \
|
||||
popl %%eax \n \
|
||||
popl %%eax \n \
|
||||
popl %%ebp\n \
|
||||
popl %%edi\n \
|
||||
popl %%esi\n \
|
||||
popl %%edx\n \
|
||||
popl %%ecx\n \
|
||||
mov 36(%%esp),%%eax\n \
|
||||
mov 32(%%esp),%%ebx\n \
|
||||
mov %%ebx,-4(%%eax)\n \
|
||||
mov 28(%%esp),%%ebx\n \
|
||||
mov %%ebx,-8(%%eax)\n \
|
||||
mov 24(%%esp),%%ebx\n \
|
||||
mov %%ebx,-12(%%eax)\n \
|
||||
popl %%ebx\n \
|
||||
popl %%eax\n \
|
||||
popl %%gs\n \
|
||||
popl %%fs\n \
|
||||
popl %%es\n \
|
||||
popl %%ds\n \
|
||||
add $12,%%esp\n \
|
||||
popl %%esp\n \
|
||||
sub $12,%%esp\n \
|
||||
iret ":::);\
|
||||
})
|
||||
|
||||
# define restcpu_user() ({\
|
||||
asm("\
|
||||
popl %%eax \n \
|
||||
popl %%edx \n \
|
||||
mov $0xC0000080, %%ecx \n \
|
||||
wrmsr\n \
|
||||
popl %%eax\n \
|
||||
popl %%eax \n \
|
||||
popl %%eax \n \
|
||||
popl %%eax \n \
|
||||
popl %%eax \n \
|
||||
popl %%eax \n \
|
||||
popl %%eax \n \
|
||||
popl %%eax \n \
|
||||
mov %%eax,%%cr3 \n \
|
||||
popl %%eax \n \
|
||||
popl %%eax \n \
|
||||
popl %%ebp\n \
|
||||
popl %%edi\n \
|
||||
popl %%esi\n \
|
||||
popl %%edx\n \
|
||||
popl %%ecx\n \
|
||||
popl %%ebx\n \
|
||||
popl %%eax\n \
|
||||
popl %%gs\n \
|
||||
popl %%fs\n \
|
||||
popl %%es\n \
|
||||
popl %%ds":::);\
|
||||
})
|
||||
|
||||
|
||||
/*
|
||||
lors d'un iret en mode user:
|
||||
pushl %%ss\n \
|
||||
pushl %%esp\n \
|
||||
lors d'un iret en mode kernel:
|
||||
pushf \n \
|
||||
pushl $cs\n \
|
||||
pushl $0x0\
|
||||
*/
|
||||
|
||||
|
||||
/* save pile */
|
||||
typedef struct regs
|
||||
{
|
||||
union {
|
||||
struct {
|
||||
u64 efer;
|
||||
u32 dr7;
|
||||
u32 dr6;
|
||||
u32 dr3;
|
||||
u32 dr2;
|
||||
u32 dr1;
|
||||
u32 dr0;
|
||||
u32 cr4;
|
||||
u32 cr3;
|
||||
u32 cr2;
|
||||
u32 cr0;
|
||||
u32 ebp;
|
||||
u32 edi;
|
||||
u32 esi;
|
||||
u32 edx;
|
||||
u32 ecx;
|
||||
u32 ebx;
|
||||
u32 eax;
|
||||
u32 gs;
|
||||
u32 fs;
|
||||
u32 es;
|
||||
u32 ds;
|
||||
u32 eip;
|
||||
u32 cs;
|
||||
u32 eflags;
|
||||
u32 esp;
|
||||
u32 ss;
|
||||
};
|
||||
struct {
|
||||
u32 efer_low, efer_high;
|
||||
u32 dummy[13*sizeof(u32)];
|
||||
u16 dx,hdx;
|
||||
u16 cx,hcx;
|
||||
u16 bx,hbx;
|
||||
u16 ax,hax;
|
||||
u16 gsl,dummy_gs;
|
||||
u16 fsl,dummy_fs;
|
||||
u16 esl,dummy_es;
|
||||
u16 dsl,dummy_ds;
|
||||
u16 ip,hip;
|
||||
u16 csl,dummy_cs;
|
||||
u16 flags,hflags;
|
||||
u16 sp,hsp;
|
||||
u16 ssl,dummy_ss;
|
||||
};
|
||||
struct {
|
||||
u64 dummy2;
|
||||
u32 dummy3[13*sizeof(u32)];
|
||||
u8 dl,dh,dx2,hdx2;
|
||||
u8 cl,ch,cx2,hcx2;
|
||||
u8 bl,bh,bx2,hbx2;
|
||||
u8 al,ah,ax2,hax2;
|
||||
};
|
||||
}
|
||||
} regs __attribute__ ((packed));
|
||||
|
||||
/* exception pile depuis code kernel*/
|
||||
typedef struct exception_stack
|
||||
{
|
||||
u32 error_code;
|
||||
u32 eip;
|
||||
u32 cs;
|
||||
u32 eflags;
|
||||
} exception_stack __attribute__ ((packed));
|
||||
|
||||
/* sans code erreur depuis code kernel*/
|
||||
typedef struct exception_stack_noerror
|
||||
{
|
||||
u32 eip;
|
||||
u32 cs;
|
||||
u32 eflags;
|
||||
} exception_stack_noerror __attribute__ ((packed));
|
||||
|
||||
/* exception pile depuis code user */
|
||||
typedef struct exception_stack_user
|
||||
{
|
||||
u32 error_code;
|
||||
u32 eip;
|
||||
u32 cs;
|
||||
u32 eflags;
|
||||
u32 esp;
|
||||
u32 ss;
|
||||
} exception_stack_user __attribute__ ((packed));
|
||||
|
||||
/* sans code erreu depuis code user */
|
||||
typedef struct exception_stack_noerror_user
|
||||
{
|
||||
u32 eip;
|
||||
u32 cs;
|
||||
u32 eflags;
|
||||
u32 esp;
|
||||
u32 ss;
|
||||
} exception_stack_noerror_user __attribute__ ((packed));
|
||||
|
||||
/* descripteur de segment */
|
||||
typedef struct idtdes
|
||||
{
|
||||
u16 offset0_15;
|
||||
u16 select;
|
||||
u16 type;
|
||||
u16 offset16_31;
|
||||
} idtdes __attribute__ ((packed));
|
||||
|
||||
|
||||
struct idtr
|
||||
{
|
||||
u16 limite;
|
||||
u32 base;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
void initretry(u32 address);
|
||||
void initidt(void);
|
||||
u32 getinitretry(void);
|
||||
void setidt(u32 offset, u16 select, u16 type, u16 index);
|
||||
void makeidtdes(u32 offset, u16 select, u16 type, idtdes * desc);
|
||||
void initpic(void);
|
||||
void enableirq(u8 irq);
|
||||
void disableirq(u8 irq);
|
||||
void cpuerror(const u8 * src, const regs * stack, bool returnto);
|
||||
#endif
|
|
@ -1,4 +1,10 @@
|
|||
#define SCAN_CTRL 0x1D
|
||||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
|
||||
#include "interrupts.h"
|
||||
|
||||
#define SCAN_CTRL 0x1D
|
||||
#define SCAN_LEFTSHIFT 0x2A
|
||||
#define SCAN_RIGHTSHIFT 0x36
|
||||
#define SCAN_ALT 0x38
|
||||
|
@ -20,14 +26,16 @@
|
|||
|
||||
/* bit de statut
|
||||
0x0100 est reservé pour les touches non-ASCII */
|
||||
#define STATUS_ALT 0x0200
|
||||
#define STATUS_CTRL 0x0400
|
||||
#define STATUS_ALT 0x0200
|
||||
#define STATUS_CTRL 0x0400
|
||||
#define STATUS_SHIFT 0x0800
|
||||
#define STATUS_ANY (STATUS_ALT | STATUS_CTRL | STATUS_SHIFT)
|
||||
#define STATUS_CAPS 0x1000
|
||||
#define STATUS_NUM 0x2000
|
||||
#define STATUS_SCRL 0x4000
|
||||
#define STATUS_CAPS 0x1000
|
||||
#define STATUS_NUM 0x2000
|
||||
#define STATUS_SCRL 0x4000
|
||||
|
||||
void keyboard();
|
||||
void outkbd(u8 port, u8 data);
|
||||
u8 waitascii();
|
||||
__attribute__((interrupt)) void keyboard_handler(exception_stack_noerror *caller);
|
||||
void reboot(void);
|
||||
void outkbd(u8 port, u8 data);
|
||||
u8 waitascii(void);
|
||||
u8 *getstring(u8 * temp);
|
||||
|
|
|
@ -1,3 +1,31 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#define sgn(x) ((x<0)?-1:((x>0)?1:0));
|
||||
|
||||
u32 abs(int x);
|
||||
#define M_PI 3.14159265358979323846 //Pi
|
||||
#define M_2_PI 0.636619772367581343076 //2 fois la réciproque de Pi
|
||||
#define M_PI_2 1.57079632679489661923 //Pi divisé par two
|
||||
#define EPSILON 1E-40
|
||||
#define degtorad(deg) (deg * PI / 180.0)
|
||||
#define radtodeg(rad) (rad * 180.0 / PI)
|
||||
u32 crc32(u32 inCrc32, u8 *buf, u32 size);
|
||||
double cos(double x);
|
||||
double sin(double x);
|
||||
float cosf(float x);
|
||||
float sinf(float x);
|
||||
float fabsf(float n);
|
||||
double fabs(double n);
|
||||
float sqrtf(float n);
|
||||
float rsqrtf(float n);
|
||||
double sqrt(double n);
|
||||
double rsqrt(double n);
|
||||
u32 abs(int x);
|
||||
u32 random(u32 lower, u32 upper);
|
||||
u32 rand(void);
|
||||
void randomize(void);
|
||||
u8 log2(u64 n);
|
||||
u8 log10(u64 n);
|
||||
unsigned long long __udivdi3(unsigned long long num,
|
||||
unsigned long long den);
|
||||
unsigned long long __umoddi3(unsigned long long n, unsigned long long d);
|
||||
u32 pow(u32 a, u8 n);
|
||||
|
|
|
@ -0,0 +1,81 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
|
||||
#ifndef MATRIX
|
||||
# define MATRIX
|
||||
|
||||
typedef struct vector4
|
||||
{
|
||||
union
|
||||
{
|
||||
struct
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
float w;
|
||||
};
|
||||
float v[4];
|
||||
};
|
||||
} vector4 __attribute__ ((packed));
|
||||
|
||||
typedef struct matrix44
|
||||
{
|
||||
union
|
||||
{
|
||||
struct
|
||||
{
|
||||
vector4 V[4];
|
||||
};
|
||||
float v[16];
|
||||
};
|
||||
} matrix44 __attribute__ ((packed));
|
||||
|
||||
void vector4_show(vector4 src);
|
||||
void vector4_create(float x, float y, float z, float w, vector4 * dst);
|
||||
void vector4_copy(vector4 src, vector4 * dst);
|
||||
void vector4_add(vector4 v1, vector4 v2, vector4 * dst);
|
||||
void vector4_sub(vector4 v1, vector4 v2, vector4 * dst);
|
||||
void vector4_scale(vector4 * dst, float factor);
|
||||
void vector4_crossproduct(vector4 v1, vector4 v2, vector4 * dst);
|
||||
void vector4_normalize(vector4 * dst);
|
||||
void vector4_divide(vector4 * v1, vector4 v2, vector4 * dst);
|
||||
void vector4_perpendicular(vector4 v1, vector4 v2, vector4 * dst);
|
||||
void vector4_rotate_x(vector4 * dst, float angle);
|
||||
void vector4_rotate_y(vector4 * dst, float angle);
|
||||
void vector4_rotate_z(vector4 * dst, float angle);
|
||||
float vector4_len(vector4 src);
|
||||
float vector4_dotproduct(vector4 v1, vector4 v2);
|
||||
float vector4_norm(vector4 src);
|
||||
float vector4_distance(vector4 v1, vector4 v2);
|
||||
int vector4_isequals(vector4 v1, vector4 v2);
|
||||
void vector4_planenormal(vector4 v1, vector4 v2, vector4 v3,
|
||||
vector4 * dst);
|
||||
|
||||
void matrix44_homogen(matrix44 * matrix);
|
||||
void matrix44_empty(matrix44 * matrix);
|
||||
void matrix44_scaling(vector4 v, matrix44 * dst);
|
||||
void matrix44_translation(vector4 v, matrix44 * dst);
|
||||
void matrix44_scale(matrix44 * dst, float factor);
|
||||
void matrix44_scale_translation(vector4 scale, vector4 translation,
|
||||
matrix44 * dst);
|
||||
void matrix44_rotation_x(float angle, matrix44 * dst);
|
||||
void matrix44_rotation_y(float angle, matrix44 * dst);
|
||||
void matrix44_rotation_z(float angle, matrix44 * dst);
|
||||
void matrix44_rotation(vector4 axis, float angle, matrix44 * dst);
|
||||
void matrix44_multiply(matrix44 * m1, matrix44 * m2, matrix44 * dst);
|
||||
void matrix44_transform(matrix44 * matrix, vector4 * dst);
|
||||
float matrix44_determinant(matrix44 * matrix);
|
||||
float todeterminant(float a1, float a2, float a3, float b1, float b2,
|
||||
float b3, float c1, float c2, float c3);
|
||||
void matrix44_adjoint(matrix44 * matrix);
|
||||
void matrix44_show(matrix44 * matrix);
|
||||
void matrix44_invert(matrix44 * matrix);
|
||||
void matrix44_transpose(matrix44 * matrix);
|
||||
void matrix44_lookat(vector4 eye, vector4 dst, vector4 up,
|
||||
matrix44 * matrix);
|
||||
int matrix44_isequals(matrix44 * m1, matrix44 * m2);
|
||||
float *toarray(matrix44 * m);
|
||||
|
||||
#endif
|
|
@ -1,6 +1,144 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#ifndef _MEMORY
|
||||
# define _MEMORY
|
||||
|
||||
# define TOPAGE(addr) (addr) >> 12
|
||||
# define TOPD(addr) ((addr) & 0xFFC00000) >> 22
|
||||
# define TOPT(addr) ((addr) & 0x003FF000) >> 12
|
||||
# define TOPG(addr) (addr) & 0x00000FFF
|
||||
|
||||
# define PAGESIZE 4096
|
||||
/* Taille d'une page */
|
||||
# define PAGENUMBER 1024
|
||||
/* Nombre de pages */
|
||||
# define KERNELSIZE PAGESIZE*PAGENUMBER*2 /* 2 pages de 4mo en identity mapping */
|
||||
|
||||
# define IDT_ADDR 0x00000000 /* adresse de la IDT */
|
||||
# define GDT_ADDR 0x00000800 /* adresse de la GDT */
|
||||
# define KERNEL_PD_ADDR 0x00001000
|
||||
/* adresse de la page directory */
|
||||
# define KERNEL_STACK_ADDR 0x0009FFFF
|
||||
/* adresse de la pile du kernel */
|
||||
# define KERNEL_CODE_ADDR 0x00100000
|
||||
/* adresse du code du noyau */
|
||||
# define KERNEL_PAGES 0x00800000 /* adresse des pages */
|
||||
# define KERNEL_HEAP 0x10000000 /* adresse du heap */
|
||||
# define VESA_FBMEM 0x38000000 /* adresse du framebuffer VESA */
|
||||
# define USER_CODE 0x40000000
|
||||
/* adresse du code utilisateur */
|
||||
# define USER_STACK 0xE0000000
|
||||
/* adresse de la pile utilisateur */
|
||||
|
||||
/* limites de la mémoire 32 bits */
|
||||
# define MAXMEMSIZE 0x100000000
|
||||
# define MAXMEMPAGE 1024*1024
|
||||
# define MAXHEAPSIZE VESA_FBMEM-KERNEL_HEAP
|
||||
# define MAXPAGESSIZE KERNEL_HEAP-KERNEL_PAGES
|
||||
|
||||
/* page directory */
|
||||
# define PAGE_NOFLAG 0x0
|
||||
# define PAGE_PRESENT 0b000000001 /* page directory / table */
|
||||
# define PAGE_WRITE 0b000000010 /* page lecture ecriture */
|
||||
# define PAGE_ALL 0b000000100 /* accessible user & supervisor */
|
||||
# define PAGE_WTROUGH 0b000001000 /* write-through cache */
|
||||
# define PAGE_NOCACHE 0b000010000 /* cache desactivé */
|
||||
# define PAGE_ACCESS 0b000100000 /* page accedée */
|
||||
# define PAGE_4MB 0b010000000 /* page de 4mb au lieu de 4k (NECESSITE PSE) */
|
||||
|
||||
/* page table */
|
||||
# define PAGE_CACHE 0b000010000 /* page en cache */
|
||||
# define PAGE_DIRTY 0b001000000 /* page écrite */
|
||||
# define PAGE_GLOBAL 0b100000000 /* évite que le TLB mette à jour l'adresse dans le cache si CR4 est remis à zéro (NECESSITE CR4) */
|
||||
|
||||
/* Selecteur RPL */
|
||||
# define RPL_RING0 0b00 /* Anneau 0 */
|
||||
# define RPL_RING1 0b01 /* Anneau 1 */
|
||||
# define RPL_RING2 0b01 /* Anneau 2 */
|
||||
# define RPL_RING3 0b11 /* Anneau 3 */
|
||||
|
||||
# define MALLOC_MINIMUM 16
|
||||
|
||||
# define setCR3(addr) \
|
||||
asm volatile ("mov %[memaddr], %%eax; mov %%eax, %%cr3"::[memaddr] "m" (addr) );
|
||||
|
||||
#ifndef __ASSEMBLY__
|
||||
|
||||
#include "types.h"
|
||||
#include "queue.h"
|
||||
#include "boot.h"
|
||||
|
||||
void memset(void *dst, u8 val, u32 count,u32 size);
|
||||
void memcpy(void *src, void *dst, u32 count, u32 size);
|
||||
u32 memcmp(void *src, void *dst, u32 count, u32 size);
|
||||
/* Malloc, pour l'attribution de mémoire en heap */
|
||||
typedef struct tmalloc
|
||||
{
|
||||
u32 size:31;
|
||||
u32 used:1;
|
||||
} __attribute__ ((packed)) tmalloc;
|
||||
|
||||
/* Page, pour la gestion de la mémoire virtuelle */
|
||||
typedef struct page
|
||||
{
|
||||
u8 *vaddr;
|
||||
u8 *paddr;
|
||||
TAILQ_ENTRY(page) tailq;
|
||||
} __attribute__ ((packed)) page;
|
||||
|
||||
typedef TAILQ_HEAD(page_s, page) page_t;
|
||||
|
||||
/* Page directory, pour la gestion de la mémoire virtuelle */
|
||||
typedef struct pd
|
||||
{
|
||||
page *addr;
|
||||
page_t page_head;
|
||||
} __attribute__ ((packed)) pd;
|
||||
|
||||
/* vaddrrange, pour la gestion des pages de la mémoire virtuelle */
|
||||
typedef struct vrange
|
||||
{
|
||||
u8 *vaddrlow;
|
||||
u8 *vaddrhigh;
|
||||
TAILQ_ENTRY(vrange) tailq;
|
||||
} __attribute__ ((packed)) vrange;
|
||||
|
||||
typedef TAILQ_HEAD(vrange_s, vrange) vrange_t;
|
||||
|
||||
void virtual_pd_show(pd *dst);
|
||||
void panic(u8 * string);
|
||||
void memset(void *dst, u8 val, u32 count, u32 size);
|
||||
void memcpy(void *src, void *dst, u32 count, u32 size);
|
||||
u32 memcmp(void *src, void *dst, u32 count, u32 size);
|
||||
u64 getmemoryfree(void);
|
||||
u64 physical_getmemorysize();
|
||||
void physical_page_use(u32 page);
|
||||
void physical_page_free(u32 page);
|
||||
void physical_range_use(u64 addr, u64 len);
|
||||
void physical_range_free(u64 addr, u64 len);
|
||||
u8 *physical_page_getfree(void);
|
||||
void physical_init();
|
||||
void initpaging();
|
||||
void virtual_init(void);
|
||||
tmalloc *mallocpage(u64 size);
|
||||
void *vmalloc(u32 size);
|
||||
void vfree(void *vaddr);
|
||||
page *virtual_page_getfree(void);
|
||||
pd *virtual_pd_create();
|
||||
void virtual_pd_destroy(pd * dst);
|
||||
void virtual_page_free(u8 * vaddr);
|
||||
u8 *virtual_to_physical(u8 * vaddr);
|
||||
void virtual_pd_page_remove(u8 * vaddr);
|
||||
void virtual_pd_page_add(pd * dst, u8 * vaddr, u8 * paddr, u32 flags);
|
||||
void virtual_range_use(pd * dst, u8 * vaddr, u8 * paddr, u64 len,
|
||||
u32 flags);
|
||||
void virtual_range_free(pd * dst, u8 * vaddr, u64 len);
|
||||
void virtual_range_new(pd * dst, u8 * vaddr, u64 len, u32 flags);
|
||||
void malloc_init(void);
|
||||
void identity_init(void);
|
||||
void registry_init(void);
|
||||
u32 getmallocused(void);
|
||||
u32 getmallocfree(void);
|
||||
u32 getmallocnonallocated(void);
|
||||
u32 virtual_getpagesfree();
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
|
|
@ -1,4 +1,10 @@
|
|||
bool initmouse();
|
||||
void mouse();
|
||||
void outmseack(u8 value);
|
||||
void outmsecmd(u8 command);
|
||||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
|
||||
#include "interrupts.h"
|
||||
|
||||
bool initmouse(void);
|
||||
__attribute__((interrupt)) void mouse_handler(exception_stack_noerror *caller);
|
||||
void outmseack(u8 value);
|
||||
void outmsecmd(u8 command);
|
||||
|
|
|
@ -0,0 +1,50 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
|
||||
|
||||
|
||||
typedef struct pciclass
|
||||
{
|
||||
u16 number;
|
||||
u8 *name;
|
||||
} pciclass __attribute__ ((packed));
|
||||
|
||||
typedef struct pcidev
|
||||
{
|
||||
u16 vendor_id;
|
||||
u16 device_id;
|
||||
u16 command;
|
||||
u16 status;
|
||||
u8 revision_id;
|
||||
u8 interface;
|
||||
u8 sub_class;
|
||||
u8 base_class;
|
||||
u8 cache_line_size;
|
||||
u8 latency_timer;
|
||||
u8 header_type;
|
||||
u8 bist;
|
||||
} pcidev __attribute__ ((packed));
|
||||
|
||||
|
||||
typedef struct pcidevmini
|
||||
{
|
||||
union
|
||||
{
|
||||
struct
|
||||
{
|
||||
u16 vendor_id;
|
||||
u16 device_id;
|
||||
};
|
||||
u32 dword;
|
||||
};
|
||||
} pcidevmini __attribute__ ((packed));
|
||||
|
||||
u16 pciConfigReadWord(const u8 bus, const u8 dev, const u8 function,
|
||||
const u8 offset);
|
||||
void scanPCImini(void);
|
||||
pcidevmini getPCImininfo(const u8 bus, const u8 dev, const u8 function);
|
||||
bool getPCInfo(pcidev * device, const u8 bus, const u8 dev,
|
||||
const u8 function);
|
||||
void scanPCI(void);
|
||||
u8 *pcigetclassname(const pcidev * device);
|
|
@ -1,6 +0,0 @@
|
|||
#include "types.h"
|
||||
|
||||
void outreg(u16 port,u8 *src,u16 num);
|
||||
void outregsame(u16 port,u8 *src,u16 num);
|
||||
void inreg(u16 port,u8 *src,u16 num);
|
||||
void inregsame(u16 port,u8 *src,u16 num);
|
|
@ -0,0 +1,226 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
|
||||
#include "types.h"
|
||||
#include "interrupts.h"
|
||||
#include "memory.h"
|
||||
|
||||
#define MAXPIDVALUE 0xFFFF
|
||||
#define MAXNUMPROCESS 256
|
||||
|
||||
#define PROCESS_STATUS_FREE 0x0
|
||||
#define PROCESS_STATUS_READY 0x1
|
||||
#define PROCESS_STATUS_RUN 0x2
|
||||
#define PROCESS_STATUS_SLEEP 0x3
|
||||
#define PROCESS_STATUS_ALL 0xFF
|
||||
|
||||
#define TASK_STATUS_READY 0x0
|
||||
#define TASK_STATUS_RUN 0x1
|
||||
#define TASK_STATUS_STOP 0x2
|
||||
#define TASK_STATUS_ALL 0xFF
|
||||
|
||||
/* ELF type */
|
||||
#define ET_NONE 0 //No file type
|
||||
#define ET_REL 1 //Relocatable file
|
||||
#define ET_EXEC 2 //Executable file
|
||||
#define ET_DYN 3 //Shared object file
|
||||
#define ET_CORE 4 //Core file
|
||||
#define ET_LOOS 0xfe00 //Operating system-specific
|
||||
#define ET_HIOS 0xfeff //Operating system-specific
|
||||
#define ET_LOPROC 0xff00 //Processor-specific
|
||||
#define ET_HIPROC 0xffff //Processor-specific
|
||||
|
||||
/* ELF identification */
|
||||
#define EI_MAG0 0 //File identification
|
||||
#define EI_MAG1 1 //File identification
|
||||
#define EI_MAG2 2 //File identification
|
||||
#define EI_MAG3 3 //File identification
|
||||
#define EI_CLASS 4 //File class
|
||||
#define EI_DATA 5 //Data encoding
|
||||
#define EI_VERSION 6 //File version
|
||||
#define EI_OSABI 7 //Operating system/ABI identification
|
||||
#define EI_ABIVERSION 8 //ABI version
|
||||
#define EI_PAD 9 //Start of padding bytes
|
||||
#define EI_NIDENT 16 //Size of e_ident[]
|
||||
|
||||
/* ELF version */
|
||||
#define EV_NONE 0 //Invalid version
|
||||
#define EV_CURRENT 1 //Current version
|
||||
|
||||
/* ELF machine type */
|
||||
|
||||
#define EM_NONE 0 //No machine
|
||||
#define EM_386 3 //Intel 80386
|
||||
#define EM_IA_64 50 //Intel IA-64 processor architecture
|
||||
#define EM_X86_64 62 //AMD x86-64 architecture
|
||||
|
||||
/* EI signature */
|
||||
#define ELFMAG0 0x7f
|
||||
#define ELFMAG1 'E'
|
||||
#define ELFMAG2 'L'
|
||||
#define ELFMAG3 'F'
|
||||
|
||||
/* EI file class */
|
||||
#define ELFCLASSNONE 0 /* invalid class */
|
||||
#define ELFCLASS32 1 /* 32-bit objects */
|
||||
#define ELFCLASS64 2 /* 64-bit objects */
|
||||
|
||||
/* EI data structure */
|
||||
#define ELFDATANONE 0 /* invalide data encoding */
|
||||
#define ELFDATA2LSB 1 /* least significant byte first (0x01020304 is 0x04 0x03 0x02 0x01) */
|
||||
#define ELFDATA2MSB 2 /* most significant byte first (0x01020304 is 0x01 0x02 0x03 0x04) */
|
||||
|
||||
/* p type */
|
||||
#define PT_NULL 0
|
||||
#define PT_LOAD 1
|
||||
#define PT_DYNAMIC 2
|
||||
#define PT_INTERP 3
|
||||
#define PT_NOTE 4
|
||||
#define PT_SHLIB 5
|
||||
#define PT_PHDR 6
|
||||
#define PT_LOPROC 0x70000000
|
||||
#define PT_HIPROC 0x7fffffff
|
||||
|
||||
/* p flags */
|
||||
#define PF_X 0x1
|
||||
#define PF_W 0x2
|
||||
#define PF_R 0x4
|
||||
|
||||
/* OS identification */
|
||||
#define ELFOSABI_NONE 0 //No extensions or unspecified
|
||||
#define ELFOSABI_LINUX 3 //Linux
|
||||
#define ELFOSABI_COS2000 16 //COS2000
|
||||
|
||||
/* ELF header */
|
||||
typedef struct elf32
|
||||
{
|
||||
u8 e_ident[EI_NIDENT];
|
||||
u16 e_type;
|
||||
u16 e_machine;
|
||||
u32 e_version;
|
||||
u8 *e_entry;
|
||||
u32 e_phoff;
|
||||
u32 e_shoff;
|
||||
u32 e_flags;
|
||||
u16 e_ehsize;
|
||||
u16 e_phentsize;
|
||||
u16 e_phnum;
|
||||
u16 e_shentsize;
|
||||
u16 e_shnum;
|
||||
u16 e_shstrndx;
|
||||
} elf32 __attribute__ ((packed));
|
||||
|
||||
typedef struct elf32p
|
||||
{
|
||||
u32 p_type;
|
||||
u32 p_offset;
|
||||
u8 *p_vaddr;
|
||||
u8 *p_paddr;
|
||||
u32 p_filesz;
|
||||
u32 p_memsz;
|
||||
u32 p_flags;
|
||||
u32 p_align;
|
||||
} elf32p __attribute__ ((packed));
|
||||
|
||||
typedef unsigned int pid_t;
|
||||
|
||||
typedef struct tid_t
|
||||
{
|
||||
pid_t pid;
|
||||
u32 number;
|
||||
} tid_t __attribute__ ((packed));
|
||||
|
||||
typedef struct stack
|
||||
{
|
||||
u32 esp0;
|
||||
u16 ss0;
|
||||
} stack __attribute__ ((packed));
|
||||
|
||||
typedef struct task
|
||||
{
|
||||
tid_t tid;
|
||||
stack kernel_stack;
|
||||
stack syscall_stack;
|
||||
u32 status;
|
||||
regs dump;
|
||||
TAILQ_ENTRY(task) tailq;
|
||||
} task __attribute__ ((packed));
|
||||
|
||||
typedef TAILQ_HEAD(task_s, task) task_t;
|
||||
|
||||
typedef struct child
|
||||
{
|
||||
pid_t pid;
|
||||
TAILQ_ENTRY(child) tailq;
|
||||
} child __attribute__ ((packed));
|
||||
|
||||
typedef TAILQ_HEAD(child_s, child) child_t;
|
||||
|
||||
typedef struct other
|
||||
{
|
||||
pid_t pid;
|
||||
TAILQ_ENTRY(other) tailq;
|
||||
} other __attribute__ ((packed));
|
||||
|
||||
typedef TAILQ_HEAD(other_s, other) other_t;
|
||||
|
||||
typedef struct process
|
||||
{
|
||||
pid_t pid;
|
||||
pid_t parent;
|
||||
bool iskernel;
|
||||
pd *pdd;
|
||||
s8 priority;
|
||||
u32 result;
|
||||
u8 status;
|
||||
u8 *exec_low;
|
||||
u8 *exec_high;
|
||||
u8 *bss_low;
|
||||
u8 *bss_high;
|
||||
page_t page_head;
|
||||
task_t task_head;
|
||||
child_t child_head;
|
||||
other_t other_head;
|
||||
u32 entry;
|
||||
} process __attribute__ ((packed));
|
||||
|
||||
pid_t getcurrentpid(void);
|
||||
pid_t getparentpid(void);
|
||||
pid_t getfreepid(void);
|
||||
tid_t getcurrenttid(void);
|
||||
tid_t maketid(pid_t pid, u32 number);
|
||||
|
||||
void stop(void);
|
||||
void wait(void);
|
||||
pid_t fork(void);
|
||||
pid_t clone(void);
|
||||
pid_t exec(u8* entry, u8* args, bool kerneltask);
|
||||
|
||||
void switchtask(tid_t tid);
|
||||
process* getnextprocess(process *aprocess, u32 status);
|
||||
task* getnexttask(task* atask, u32 status);
|
||||
task* getschedule(void);
|
||||
task* findtask(tid_t tid);
|
||||
task* findcurrenttask(void);
|
||||
process* findprocess(pid_t pid);
|
||||
process* findcurrentprocess(void);
|
||||
task* findfirsttask(process* aprocess);
|
||||
|
||||
tid_t createtask(pid_t pid,u8 *entry, bool kerneltask);
|
||||
void deletetask(tid_t tid);
|
||||
void runtask(tid_t tid);
|
||||
void stoptask(tid_t tid);
|
||||
|
||||
pid_t createprocess(u8 *src, bool kerneltask);
|
||||
void deleteprocess(pid_t pid);
|
||||
void runprocess(pid_t pid);
|
||||
void stopprocess(pid_t pid);
|
||||
|
||||
|
||||
void setpriority(pid_t pid,s8 priority);
|
||||
|
||||
void initprocesses(void);
|
||||
|
||||
u32 iself(u8 * src);
|
||||
u32 loadelf(u8 * src, pid_t pid);
|
|
@ -0,0 +1,698 @@
|
|||
/*-
|
||||
* Copyright (c) 1991, 1993
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 4. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* @(#)queue.h 8.5 (Berkeley) 8/20/94
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#ifndef _SYS_QUEUE_H_
|
||||
# define _SYS_QUEUE_H_
|
||||
|
||||
//#include <sys/cdefs.h>
|
||||
|
||||
/*
|
||||
* This file defines four types of data structures: singly-linked lists,
|
||||
* singly-linked tail queues, lists and tail queues.
|
||||
*
|
||||
* A singly-linked list is headed by a single forward pointer. The elements
|
||||
* are singly linked for minimum space and pointer manipulation overhead at
|
||||
* the expense of O(n) removal for arbitrary elements. New elements can be
|
||||
* added to the list after an existing element or at the head of the list.
|
||||
* Elements being removed from the head of the list should use the explicit
|
||||
* macro for this purpose for optimum efficiency. A singly-linked list may
|
||||
* only be traversed in the forward direction. Singly-linked lists are ideal
|
||||
* for applications with large datasets and few or no removals or for
|
||||
* implementing a LIFO queue.
|
||||
*
|
||||
* A singly-linked tail queue is headed by a pair of pointers, one to the
|
||||
* head of the list and the other to the tail of the list. The elements are
|
||||
* singly linked for minimum space and pointer manipulation overhead at the
|
||||
* expense of O(n) removal for arbitrary elements. New elements can be added
|
||||
* to the list after an existing element, at the head of the list, or at the
|
||||
* end of the list. Elements being removed from the head of the tail queue
|
||||
* should use the explicit macro for this purpose for optimum efficiency.
|
||||
* A singly-linked tail queue may only be traversed in the forward direction.
|
||||
* Singly-linked tail queues are ideal for applications with large datasets
|
||||
* and few or no removals or for implementing a FIFO queue.
|
||||
*
|
||||
* A list is headed by a single forward pointer (or an array of forward
|
||||
* pointers for a hash table header). The elements are doubly linked
|
||||
* so that an arbitrary element can be removed without a need to
|
||||
* traverse the list. New elements can be added to the list before
|
||||
* or after an existing element or at the head of the list. A list
|
||||
* may be traversed in either direction.
|
||||
*
|
||||
* A tail queue is headed by a pair of pointers, one to the head of the
|
||||
* list and the other to the tail of the list. The elements are doubly
|
||||
* linked so that an arbitrary element can be removed without a need to
|
||||
* traverse the list. New elements can be added to the list before or
|
||||
* after an existing element, at the head of the list, or at the end of
|
||||
* the list. A tail queue may be traversed in either direction.
|
||||
*
|
||||
* For details on the use of these macros, see the queue(3) manual page.
|
||||
*
|
||||
*
|
||||
* SLIST LIST STAILQ TAILQ
|
||||
* _HEAD + + + +
|
||||
* _HEAD_INITIALIZER + + + +
|
||||
* _ENTRY + + + +
|
||||
* _INIT + + + +
|
||||
* _EMPTY + + + +
|
||||
* _FIRST + + + +
|
||||
* _NEXT + + + +
|
||||
* _PREV - + - +
|
||||
* _LAST - - + +
|
||||
* _FOREACH + + + +
|
||||
* _FOREACH_FROM + + + +
|
||||
* _FOREACH_SAFE + + + +
|
||||
* _FOREACH_FROM_SAFE + + + +
|
||||
* _FOREACH_REVERSE - - - +
|
||||
* _FOREACH_REVERSE_FROM - - - +
|
||||
* _FOREACH_REVERSE_SAFE - - - +
|
||||
* _FOREACH_REVERSE_FROM_SAFE - - - +
|
||||
* _INSERT_HEAD + + + +
|
||||
* _INSERT_BEFORE - + - +
|
||||
* _INSERT_AFTER + + + +
|
||||
* _INSERT_TAIL - - + +
|
||||
* _CONCAT - - + +
|
||||
* _REMOVE_AFTER + - + -
|
||||
* _REMOVE_HEAD + - + -
|
||||
* _REMOVE + + + +
|
||||
* _SWAP + + + +
|
||||
*
|
||||
*/
|
||||
# ifdef QUEUE_MACRO_DEBUG
|
||||
/* Store the last 2 places the queue element or head was altered */
|
||||
struct qm_trace
|
||||
{
|
||||
unsigned long lastline;
|
||||
unsigned long prevline;
|
||||
const char *lastfile;
|
||||
const char *prevfile;
|
||||
};
|
||||
|
||||
# define TRACEBUF struct qm_trace trace;
|
||||
# define TRACEBUF_INITIALIZER { __FILE__, __LINE__, NULL, 0 } ,
|
||||
# define TRASHIT(x) do {(x) = (void *)-1;} while (0)
|
||||
# define QMD_SAVELINK(name, link) void **name = (void *)&(link)
|
||||
|
||||
# define QMD_TRACE_HEAD(head) do { \
|
||||
(head)->trace.prevline = (head)->trace.lastline; \
|
||||
(head)->trace.prevfile = (head)->trace.lastfile; \
|
||||
(head)->trace.lastline = __LINE__; \
|
||||
(head)->trace.lastfile = __FILE__; \
|
||||
} while (0)
|
||||
|
||||
# define QMD_TRACE_ELEM(elem) do { \
|
||||
(elem)->trace.prevline = (elem)->trace.lastline; \
|
||||
(elem)->trace.prevfile = (elem)->trace.lastfile; \
|
||||
(elem)->trace.lastline = __LINE__; \
|
||||
(elem)->trace.lastfile = __FILE__; \
|
||||
} while (0)
|
||||
|
||||
# else
|
||||
# define QMD_TRACE_ELEM(elem)
|
||||
# define QMD_TRACE_HEAD(head)
|
||||
# define QMD_SAVELINK(name, link)
|
||||
# define TRACEBUF
|
||||
# define TRACEBUF_INITIALIZER
|
||||
# define TRASHIT(x)
|
||||
# endif
|
||||
/* QUEUE_MACRO_DEBUG */
|
||||
|
||||
/*
|
||||
* Singly-linked List declarations.
|
||||
*/
|
||||
# define SLIST_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *slh_first; /* first element */ \
|
||||
}
|
||||
|
||||
# define SLIST_HEAD_INITIALIZER(head) \
|
||||
{ NULL }
|
||||
|
||||
# define SLIST_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *sle_next; /* next element */ \
|
||||
}
|
||||
|
||||
/*
|
||||
* Singly-linked List functions.
|
||||
*/
|
||||
# define SLIST_EMPTY(head) ((head)->slh_first == NULL)
|
||||
|
||||
# define SLIST_FIRST(head) ((head)->slh_first)
|
||||
|
||||
# define SLIST_FOREACH(var, head, field) \
|
||||
for ((var) = SLIST_FIRST((head)); \
|
||||
(var); \
|
||||
(var) = SLIST_NEXT((var), field))
|
||||
|
||||
# define SLIST_FOREACH_FROM(var, head, field) \
|
||||
for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \
|
||||
(var); \
|
||||
(var) = SLIST_NEXT((var), field))
|
||||
|
||||
# define SLIST_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = SLIST_FIRST((head)); \
|
||||
(var) && ((tvar) = SLIST_NEXT((var), field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
# define SLIST_FOREACH_FROM_SAFE(var, head, field, tvar) \
|
||||
for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \
|
||||
(var) && ((tvar) = SLIST_NEXT((var), field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
# define SLIST_FOREACH_PREVPTR(var, varp, head, field) \
|
||||
for ((varp) = &SLIST_FIRST((head)); \
|
||||
((var) = *(varp)) != NULL; \
|
||||
(varp) = &SLIST_NEXT((var), field))
|
||||
|
||||
# define SLIST_INIT(head) do { \
|
||||
SLIST_FIRST((head)) = NULL; \
|
||||
} while (0)
|
||||
|
||||
# define SLIST_INSERT_AFTER(slistelm, elm, field) do { \
|
||||
SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \
|
||||
SLIST_NEXT((slistelm), field) = (elm); \
|
||||
} while (0)
|
||||
|
||||
# define SLIST_INSERT_HEAD(head, elm, field) do { \
|
||||
SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \
|
||||
SLIST_FIRST((head)) = (elm); \
|
||||
} while (0)
|
||||
|
||||
# define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
|
||||
|
||||
# define SLIST_REMOVE(head, elm, type, field) do { \
|
||||
QMD_SAVELINK(oldnext, (elm)->field.sle_next); \
|
||||
if (SLIST_FIRST((head)) == (elm)) { \
|
||||
SLIST_REMOVE_HEAD((head), field); \
|
||||
} \
|
||||
else { \
|
||||
struct type *curelm = SLIST_FIRST((head)); \
|
||||
while (SLIST_NEXT(curelm, field) != (elm)) \
|
||||
curelm = SLIST_NEXT(curelm, field); \
|
||||
SLIST_REMOVE_AFTER(curelm, field); \
|
||||
} \
|
||||
TRASHIT(*oldnext); \
|
||||
} while (0)
|
||||
|
||||
# define SLIST_REMOVE_AFTER(elm, field) do { \
|
||||
SLIST_NEXT(elm, field) = \
|
||||
SLIST_NEXT(SLIST_NEXT(elm, field), field); \
|
||||
} while (0)
|
||||
|
||||
# define SLIST_REMOVE_HEAD(head, field) do { \
|
||||
SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \
|
||||
} while (0)
|
||||
|
||||
# define SLIST_SWAP(head1, head2, type) do { \
|
||||
struct type *swap_first = SLIST_FIRST(head1); \
|
||||
SLIST_FIRST(head1) = SLIST_FIRST(head2); \
|
||||
SLIST_FIRST(head2) = swap_first; \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* Singly-linked Tail queue declarations.
|
||||
*/
|
||||
# define STAILQ_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *stqh_first;/* first element */ \
|
||||
struct type **stqh_last;/* addr of last next element */ \
|
||||
}
|
||||
|
||||
# define STAILQ_HEAD_INITIALIZER(head) \
|
||||
{ NULL, &(head).stqh_first }
|
||||
|
||||
# define STAILQ_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *stqe_next; /* next element */ \
|
||||
}
|
||||
|
||||
/*
|
||||
* Singly-linked Tail queue functions.
|
||||
*/
|
||||
# define STAILQ_CONCAT(head1, head2) do { \
|
||||
if (!STAILQ_EMPTY((head2))) { \
|
||||
*(head1)->stqh_last = (head2)->stqh_first; \
|
||||
(head1)->stqh_last = (head2)->stqh_last; \
|
||||
STAILQ_INIT((head2)); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
# define STAILQ_EMPTY(head) ((head)->stqh_first == NULL)
|
||||
|
||||
# define STAILQ_FIRST(head) ((head)->stqh_first)
|
||||
|
||||
# define STAILQ_FOREACH(var, head, field) \
|
||||
for((var) = STAILQ_FIRST((head)); \
|
||||
(var); \
|
||||
(var) = STAILQ_NEXT((var), field))
|
||||
|
||||
# define STAILQ_FOREACH_FROM(var, head, field) \
|
||||
for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \
|
||||
(var); \
|
||||
(var) = STAILQ_NEXT((var), field))
|
||||
|
||||
# define STAILQ_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = STAILQ_FIRST((head)); \
|
||||
(var) && ((tvar) = STAILQ_NEXT((var), field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
# define STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \
|
||||
for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \
|
||||
(var) && ((tvar) = STAILQ_NEXT((var), field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
# define STAILQ_INIT(head) do { \
|
||||
STAILQ_FIRST((head)) = NULL; \
|
||||
(head)->stqh_last = &STAILQ_FIRST((head)); \
|
||||
} while (0)
|
||||
|
||||
# define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \
|
||||
if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
|
||||
(head)->stqh_last = &STAILQ_NEXT((elm), field); \
|
||||
STAILQ_NEXT((tqelm), field) = (elm); \
|
||||
} while (0)
|
||||
|
||||
# define STAILQ_INSERT_HEAD(head, elm, field) do { \
|
||||
if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \
|
||||
(head)->stqh_last = &STAILQ_NEXT((elm), field); \
|
||||
STAILQ_FIRST((head)) = (elm); \
|
||||
} while (0)
|
||||
|
||||
# define STAILQ_INSERT_TAIL(head, elm, field) do { \
|
||||
STAILQ_NEXT((elm), field) = NULL; \
|
||||
*(head)->stqh_last = (elm); \
|
||||
(head)->stqh_last = &STAILQ_NEXT((elm), field); \
|
||||
} while (0)
|
||||
|
||||
# define STAILQ_LAST(head, type, field) \
|
||||
(STAILQ_EMPTY((head)) ? NULL : \
|
||||
__containerof((head)->stqh_last, struct type, field.stqe_next))
|
||||
|
||||
# define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
|
||||
|
||||
# define STAILQ_REMOVE(head, elm, type, field) do { \
|
||||
QMD_SAVELINK(oldnext, (elm)->field.stqe_next); \
|
||||
if (STAILQ_FIRST((head)) == (elm)) { \
|
||||
STAILQ_REMOVE_HEAD((head), field); \
|
||||
} \
|
||||
else { \
|
||||
struct type *curelm = STAILQ_FIRST((head)); \
|
||||
while (STAILQ_NEXT(curelm, field) != (elm)) \
|
||||
curelm = STAILQ_NEXT(curelm, field); \
|
||||
STAILQ_REMOVE_AFTER(head, curelm, field); \
|
||||
} \
|
||||
TRASHIT(*oldnext); \
|
||||
} while (0)
|
||||
|
||||
# define STAILQ_REMOVE_AFTER(head, elm, field) do { \
|
||||
if ((STAILQ_NEXT(elm, field) = \
|
||||
STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL) \
|
||||
(head)->stqh_last = &STAILQ_NEXT((elm), field); \
|
||||
} while (0)
|
||||
|
||||
# define STAILQ_REMOVE_HEAD(head, field) do { \
|
||||
if ((STAILQ_FIRST((head)) = \
|
||||
STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \
|
||||
(head)->stqh_last = &STAILQ_FIRST((head)); \
|
||||
} while (0)
|
||||
|
||||
# define STAILQ_SWAP(head1, head2, type) do { \
|
||||
struct type *swap_first = STAILQ_FIRST(head1); \
|
||||
struct type **swap_last = (head1)->stqh_last; \
|
||||
STAILQ_FIRST(head1) = STAILQ_FIRST(head2); \
|
||||
(head1)->stqh_last = (head2)->stqh_last; \
|
||||
STAILQ_FIRST(head2) = swap_first; \
|
||||
(head2)->stqh_last = swap_last; \
|
||||
if (STAILQ_EMPTY(head1)) \
|
||||
(head1)->stqh_last = &STAILQ_FIRST(head1); \
|
||||
if (STAILQ_EMPTY(head2)) \
|
||||
(head2)->stqh_last = &STAILQ_FIRST(head2); \
|
||||
} while (0)
|
||||
|
||||
|
||||
/*
|
||||
* List declarations.
|
||||
*/
|
||||
# define LIST_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *lh_first; /* first element */ \
|
||||
}
|
||||
|
||||
# define LIST_HEAD_INITIALIZER(head) \
|
||||
{ NULL }
|
||||
|
||||
# define LIST_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *le_next; /* next element */ \
|
||||
struct type **le_prev; /* address of previous next element */ \
|
||||
}
|
||||
|
||||
/*
|
||||
* List functions.
|
||||
*/
|
||||
|
||||
# if (defined(_KERNEL) && defined(INVARIANTS))
|
||||
# define QMD_LIST_CHECK_HEAD(head, field) do { \
|
||||
if (LIST_FIRST((head)) != NULL && \
|
||||
LIST_FIRST((head))->field.le_prev != \
|
||||
&LIST_FIRST((head))) \
|
||||
panic("Bad list head %p first->prev != head", (head)); \
|
||||
} while (0)
|
||||
|
||||
# define QMD_LIST_CHECK_NEXT(elm, field) do { \
|
||||
if (LIST_NEXT((elm), field) != NULL && \
|
||||
LIST_NEXT((elm), field)->field.le_prev != \
|
||||
&((elm)->field.le_next)) \
|
||||
panic("Bad link elm %p next->prev != elm", (elm)); \
|
||||
} while (0)
|
||||
|
||||
# define QMD_LIST_CHECK_PREV(elm, field) do { \
|
||||
if (*(elm)->field.le_prev != (elm)) \
|
||||
panic("Bad link elm %p prev->next != elm", (elm)); \
|
||||
} while (0)
|
||||
# else
|
||||
# define QMD_LIST_CHECK_HEAD(head, field)
|
||||
# define QMD_LIST_CHECK_NEXT(elm, field)
|
||||
# define QMD_LIST_CHECK_PREV(elm, field)
|
||||
# endif
|
||||
/* (_KERNEL && INVARIANTS) */
|
||||
|
||||
# define LIST_EMPTY(head) ((head)->lh_first == NULL)
|
||||
|
||||
# define LIST_FIRST(head) ((head)->lh_first)
|
||||
|
||||
# define LIST_FOREACH(var, head, field) \
|
||||
for ((var) = LIST_FIRST((head)); \
|
||||
(var); \
|
||||
(var) = LIST_NEXT((var), field))
|
||||
|
||||
# define LIST_FOREACH_FROM(var, head, field) \
|
||||
for ((var) = ((var) ? (var) : LIST_FIRST((head))); \
|
||||
(var); \
|
||||
(var) = LIST_NEXT((var), field))
|
||||
|
||||
# define LIST_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = LIST_FIRST((head)); \
|
||||
(var) && ((tvar) = LIST_NEXT((var), field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
# define LIST_FOREACH_FROM_SAFE(var, head, field, tvar) \
|
||||
for ((var) = ((var) ? (var) : LIST_FIRST((head))); \
|
||||
(var) && ((tvar) = LIST_NEXT((var), field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
# define LIST_INIT(head) do { \
|
||||
LIST_FIRST((head)) = NULL; \
|
||||
} while (0)
|
||||
|
||||
# define LIST_INSERT_AFTER(listelm, elm, field) do { \
|
||||
QMD_LIST_CHECK_NEXT(listelm, field); \
|
||||
if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
|
||||
LIST_NEXT((listelm), field)->field.le_prev = \
|
||||
&LIST_NEXT((elm), field); \
|
||||
LIST_NEXT((listelm), field) = (elm); \
|
||||
(elm)->field.le_prev = &LIST_NEXT((listelm), field); \
|
||||
} while (0)
|
||||
|
||||
# define LIST_INSERT_BEFORE(listelm, elm, field) do { \
|
||||
QMD_LIST_CHECK_PREV(listelm, field); \
|
||||
(elm)->field.le_prev = (listelm)->field.le_prev; \
|
||||
LIST_NEXT((elm), field) = (listelm); \
|
||||
*(listelm)->field.le_prev = (elm); \
|
||||
(listelm)->field.le_prev = &LIST_NEXT((elm), field); \
|
||||
} while (0)
|
||||
|
||||
# define LIST_INSERT_HEAD(head, elm, field) do { \
|
||||
QMD_LIST_CHECK_HEAD((head), field); \
|
||||
if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \
|
||||
LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
|
||||
LIST_FIRST((head)) = (elm); \
|
||||
(elm)->field.le_prev = &LIST_FIRST((head)); \
|
||||
} while (0)
|
||||
|
||||
# define LIST_NEXT(elm, field) ((elm)->field.le_next)
|
||||
|
||||
# define LIST_PREV(elm, head, type, field) \
|
||||
((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL : \
|
||||
__containerof((elm)->field.le_prev, struct type, field.le_next))
|
||||
|
||||
# define LIST_REMOVE(elm, field) do { \
|
||||
QMD_SAVELINK(oldnext, (elm)->field.le_next); \
|
||||
QMD_SAVELINK(oldprev, (elm)->field.le_prev); \
|
||||
QMD_LIST_CHECK_NEXT(elm, field); \
|
||||
QMD_LIST_CHECK_PREV(elm, field); \
|
||||
if (LIST_NEXT((elm), field) != NULL) \
|
||||
LIST_NEXT((elm), field)->field.le_prev = \
|
||||
(elm)->field.le_prev; \
|
||||
*(elm)->field.le_prev = LIST_NEXT((elm), field); \
|
||||
TRASHIT(*oldnext); \
|
||||
TRASHIT(*oldprev); \
|
||||
} while (0)
|
||||
|
||||
# define LIST_SWAP(head1, head2, type, field) do { \
|
||||
struct type *swap_tmp = LIST_FIRST((head1)); \
|
||||
LIST_FIRST((head1)) = LIST_FIRST((head2)); \
|
||||
LIST_FIRST((head2)) = swap_tmp; \
|
||||
if ((swap_tmp = LIST_FIRST((head1))) != NULL) \
|
||||
swap_tmp->field.le_prev = &LIST_FIRST((head1)); \
|
||||
if ((swap_tmp = LIST_FIRST((head2))) != NULL) \
|
||||
swap_tmp->field.le_prev = &LIST_FIRST((head2)); \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* Tail queue declarations.
|
||||
*/
|
||||
# define TAILQ_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *tqh_first; /* first element */ \
|
||||
struct type **tqh_last; /* addr of last next element */ \
|
||||
TRACEBUF \
|
||||
}
|
||||
|
||||
# define TAILQ_HEAD_INITIALIZER(head) \
|
||||
{ NULL, &(head).tqh_first, TRACEBUF_INITIALIZER }
|
||||
|
||||
# define TAILQ_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *tqe_next; /* next element */ \
|
||||
struct type **tqe_prev; /* address of previous next element */ \
|
||||
TRACEBUF \
|
||||
}
|
||||
|
||||
/*
|
||||
* Tail queue functions.
|
||||
*/
|
||||
# if (defined(_KERNEL) && defined(INVARIANTS))
|
||||
# define QMD_TAILQ_CHECK_HEAD(head, field) do { \
|
||||
if (!TAILQ_EMPTY(head) && \
|
||||
TAILQ_FIRST((head))->field.tqe_prev != \
|
||||
&TAILQ_FIRST((head))) \
|
||||
panic("Bad tailq head %p first->prev != head", (head)); \
|
||||
} while (0)
|
||||
|
||||
# define QMD_TAILQ_CHECK_TAIL(head, field) do { \
|
||||
if (*(head)->tqh_last != NULL) \
|
||||
panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); \
|
||||
} while (0)
|
||||
|
||||
# define QMD_TAILQ_CHECK_NEXT(elm, field) do { \
|
||||
if (TAILQ_NEXT((elm), field) != NULL && \
|
||||
TAILQ_NEXT((elm), field)->field.tqe_prev != \
|
||||
&((elm)->field.tqe_next)) \
|
||||
panic("Bad link elm %p next->prev != elm", (elm)); \
|
||||
} while (0)
|
||||
|
||||
# define QMD_TAILQ_CHECK_PREV(elm, field) do { \
|
||||
if (*(elm)->field.tqe_prev != (elm)) \
|
||||
panic("Bad link elm %p prev->next != elm", (elm)); \
|
||||
} while (0)
|
||||
# else
|
||||
# define QMD_TAILQ_CHECK_HEAD(head, field)
|
||||
# define QMD_TAILQ_CHECK_TAIL(head, headname)
|
||||
# define QMD_TAILQ_CHECK_NEXT(elm, field)
|
||||
# define QMD_TAILQ_CHECK_PREV(elm, field)
|
||||
# endif
|
||||
/* (_KERNEL && INVARIANTS) */
|
||||
|
||||
# define TAILQ_CONCAT(head1, head2, field) do { \
|
||||
if (!TAILQ_EMPTY(head2)) { \
|
||||
*(head1)->tqh_last = (head2)->tqh_first; \
|
||||
(head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \
|
||||
(head1)->tqh_last = (head2)->tqh_last; \
|
||||
TAILQ_INIT((head2)); \
|
||||
QMD_TRACE_HEAD(head1); \
|
||||
QMD_TRACE_HEAD(head2); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
# define TAILQ_EMPTY(head) ((head)->tqh_first == NULL)
|
||||
|
||||
# define TAILQ_FIRST(head) ((head)->tqh_first)
|
||||
|
||||
# define TAILQ_FOREACH(var, head, field) \
|
||||
for ((var) = TAILQ_FIRST((head)); \
|
||||
(var); \
|
||||
(var) = TAILQ_NEXT((var), field))
|
||||
|
||||
# define TAILQ_FOREACH_FROM(var, head, field) \
|
||||
for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \
|
||||
(var); \
|
||||
(var) = TAILQ_NEXT((var), field))
|
||||
|
||||
# define TAILQ_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = TAILQ_FIRST((head)); \
|
||||
(var) && ((tvar) = TAILQ_NEXT((var), field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
# define TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \
|
||||
for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \
|
||||
(var) && ((tvar) = TAILQ_NEXT((var), field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
# define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
|
||||
for ((var) = TAILQ_LAST((head), headname); \
|
||||
(var); \
|
||||
(var) = TAILQ_PREV((var), headname, field))
|
||||
|
||||
# define TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field) \
|
||||
for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \
|
||||
(var); \
|
||||
(var) = TAILQ_PREV((var), headname, field))
|
||||
|
||||
# define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \
|
||||
for ((var) = TAILQ_LAST((head), headname); \
|
||||
(var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
# define TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar) \
|
||||
for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \
|
||||
(var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
# define TAILQ_INIT(head) do { \
|
||||
TAILQ_FIRST((head)) = NULL; \
|
||||
(head)->tqh_last = &TAILQ_FIRST((head)); \
|
||||
QMD_TRACE_HEAD(head); \
|
||||
} while (0)
|
||||
|
||||
# define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
|
||||
QMD_TAILQ_CHECK_NEXT(listelm, field); \
|
||||
if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
|
||||
TAILQ_NEXT((elm), field)->field.tqe_prev = \
|
||||
&TAILQ_NEXT((elm), field); \
|
||||
else { \
|
||||
(head)->tqh_last = &TAILQ_NEXT((elm), field); \
|
||||
QMD_TRACE_HEAD(head); \
|
||||
} \
|
||||
TAILQ_NEXT((listelm), field) = (elm); \
|
||||
(elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field); \
|
||||
QMD_TRACE_ELEM(&(elm)->field); \
|
||||
QMD_TRACE_ELEM(&listelm->field); \
|
||||
} while (0)
|
||||
|
||||
# define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
|
||||
QMD_TAILQ_CHECK_PREV(listelm, field); \
|
||||
(elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
|
||||
TAILQ_NEXT((elm), field) = (listelm); \
|
||||
*(listelm)->field.tqe_prev = (elm); \
|
||||
(listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field); \
|
||||
QMD_TRACE_ELEM(&(elm)->field); \
|
||||
QMD_TRACE_ELEM(&listelm->field); \
|
||||
} while (0)
|
||||
|
||||
# define TAILQ_INSERT_HEAD(head, elm, field) do { \
|
||||
QMD_TAILQ_CHECK_HEAD(head, field); \
|
||||
if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \
|
||||
TAILQ_FIRST((head))->field.tqe_prev = \
|
||||
&TAILQ_NEXT((elm), field); \
|
||||
else \
|
||||
(head)->tqh_last = &TAILQ_NEXT((elm), field); \
|
||||
TAILQ_FIRST((head)) = (elm); \
|
||||
(elm)->field.tqe_prev = &TAILQ_FIRST((head)); \
|
||||
QMD_TRACE_HEAD(head); \
|
||||
QMD_TRACE_ELEM(&(elm)->field); \
|
||||
} while (0)
|
||||
|
||||
# define TAILQ_INSERT_TAIL(head, elm, field) do { \
|
||||
QMD_TAILQ_CHECK_TAIL(head, field); \
|
||||
TAILQ_NEXT((elm), field) = NULL; \
|
||||
(elm)->field.tqe_prev = (head)->tqh_last; \
|
||||
*(head)->tqh_last = (elm); \
|
||||
(head)->tqh_last = &TAILQ_NEXT((elm), field); \
|
||||
QMD_TRACE_HEAD(head); \
|
||||
QMD_TRACE_ELEM(&(elm)->field); \
|
||||
} while (0)
|
||||
|
||||
# define TAILQ_LAST(head, headname) \
|
||||
(*(((struct headname *)((head)->tqh_last))->tqh_last))
|
||||
|
||||
# define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
|
||||
|
||||
# define TAILQ_PREV(elm, headname, field) \
|
||||
(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
|
||||
|
||||
# define TAILQ_REMOVE(head, elm, field) do { \
|
||||
QMD_SAVELINK(oldnext, (elm)->field.tqe_next); \
|
||||
QMD_SAVELINK(oldprev, (elm)->field.tqe_prev); \
|
||||
QMD_TAILQ_CHECK_NEXT(elm, field); \
|
||||
QMD_TAILQ_CHECK_PREV(elm, field); \
|
||||
if ((TAILQ_NEXT((elm), field)) != NULL) \
|
||||
TAILQ_NEXT((elm), field)->field.tqe_prev = \
|
||||
(elm)->field.tqe_prev; \
|
||||
else { \
|
||||
(head)->tqh_last = (elm)->field.tqe_prev; \
|
||||
QMD_TRACE_HEAD(head); \
|
||||
} \
|
||||
*(elm)->field.tqe_prev = TAILQ_NEXT((elm), field); \
|
||||
TRASHIT(*oldnext); \
|
||||
TRASHIT(*oldprev); \
|
||||
QMD_TRACE_ELEM(&(elm)->field); \
|
||||
} while (0)
|
||||
|
||||
# define TAILQ_SWAP(head1, head2, type, field) do { \
|
||||
struct type *swap_first = (head1)->tqh_first; \
|
||||
struct type **swap_last = (head1)->tqh_last; \
|
||||
(head1)->tqh_first = (head2)->tqh_first; \
|
||||
(head1)->tqh_last = (head2)->tqh_last; \
|
||||
(head2)->tqh_first = swap_first; \
|
||||
(head2)->tqh_last = swap_last; \
|
||||
if ((swap_first = (head1)->tqh_first) != NULL) \
|
||||
swap_first->field.tqe_prev = &(head1)->tqh_first; \
|
||||
else \
|
||||
(head1)->tqh_last = &(head1)->tqh_first; \
|
||||
if ((swap_first = (head2)->tqh_first) != NULL) \
|
||||
swap_first->field.tqe_prev = &(head2)->tqh_first; \
|
||||
else \
|
||||
(head2)->tqh_last = &(head2)->tqh_first; \
|
||||
} while (0)
|
||||
|
||||
#endif /* !_SYS_QUEUE_H_ */
|
|
@ -0,0 +1,97 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
/* Sources modifiées du noyau Linux linux-source-4.15.0/arch/x86/include/uapi/asm/bootparam.h
|
||||
/* Sources modifiées du noyau Linux linux-source-4.15.0/arch/x86/include/asm/e820/type.h
|
||||
|
||||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
|
||||
#include "types.h"
|
||||
#include "gdt.h"
|
||||
#include "boot.h"
|
||||
|
||||
typedef struct miniregs {
|
||||
union {
|
||||
struct {
|
||||
u32 eax;
|
||||
u32 ebx;
|
||||
u32 ecx;
|
||||
u32 edx;
|
||||
u32 esi;
|
||||
u32 edi;
|
||||
u32 ebp;
|
||||
u32 eflags;
|
||||
};
|
||||
struct {
|
||||
u16 ax, hax;
|
||||
u16 bx, hbx;
|
||||
u16 cx, hcx;
|
||||
u16 dx, hdx;
|
||||
u16 si, hsi;
|
||||
u16 di, hdi;
|
||||
u16 bp, hbp;
|
||||
u16 flags, hflags;
|
||||
};
|
||||
struct {
|
||||
u8 al, ah, hax2, hax3;
|
||||
u8 bl, bh, hbx2, hbx3;
|
||||
u8 cl, ch, hcx2, hcx3;
|
||||
u8 dl, dh, hdx2, hdx3;
|
||||
};
|
||||
};
|
||||
} miniregs __attribute__ ((packed));
|
||||
|
||||
|
||||
#define STRINGIFY(x) #x
|
||||
#define MACRO(x) STRINGIFY(x)
|
||||
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr))
|
||||
#define __must_be_array(a) BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
|
||||
#define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
|
||||
#define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:(-!!(e)); }))
|
||||
|
||||
#define EFLAGS_CF 0x00000001
|
||||
#define LOOPS_8042 100000
|
||||
#define FF_8042 32
|
||||
#define LOOPS_A20_ENABLE 255
|
||||
#define LOOPS_DELAY 32768
|
||||
#define SMAP 0x534d4150
|
||||
|
||||
#define interrupt(num, regs) ({\
|
||||
asm("mov %[eflagsregs],%%eax\n\
|
||||
pushl %%eax\n\
|
||||
popfl\n\
|
||||
mov %[eaxregs],%%eax\n\
|
||||
mov %[ebxregs],%%ebx\n\
|
||||
mov %[ecxregs],%%ecx\n\
|
||||
mov %[edxregs],%%edx\n\
|
||||
mov %[esiregs],%%esi\n\
|
||||
mov %[ediregs],%%edi\n\
|
||||
int %[numregs]\n\
|
||||
pushfl\n\
|
||||
popl %[eflagsregs]\n\
|
||||
mov %%eax,%[eaxregs]\n\
|
||||
mov %%ebx,%[ebxregs]\n\
|
||||
mov %%ecx,%[ecxregs]\n\
|
||||
mov %%edx,%[edxregs]\n\
|
||||
mov %%esi,%[esiregs]\n\
|
||||
mov %%edi,%[ediregs]":[eaxregs] "+m" (regs.eax),[ebxregs] "+m" (regs.ebx),[ecxregs] "+m" (regs.ecx),[edxregs] "+m" (regs.edx),[esiregs] "+m" (regs.esi),[ediregs] "+m" (regs.edi),[eflagsregs] "+m" (regs.eflags):[numregs] "i" (num):"%eax","%ebx","%ecx","%edx","%esi","%edi");})
|
||||
void cleanreg(miniregs *reg);
|
||||
u8 initmemory(void);
|
||||
void showchar(u8 achar);
|
||||
void showstr(u8 *str);
|
||||
u8 gettime(void);
|
||||
u8 waitchar(void);
|
||||
void initkeyboard(void);
|
||||
u8 empty8042(void);
|
||||
void iodelay(void);
|
||||
u8 testA20(void);
|
||||
void enableA20kbc(void);
|
||||
void enableA20fast(void);
|
||||
u8 enableA20(void);
|
||||
void memcpyto(void *src, void *dst, u32 count);
|
||||
void makegdtdes(u32 base, u32 limite, u8 acces, u8 flags, gdtdes * desc);
|
||||
void initgdt();
|
||||
void maskinterrupts(void);
|
||||
void initcoprocessor(void);
|
||||
void initpmode();
|
||||
void main(void);
|
|
@ -0,0 +1,33 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
typedef struct command
|
||||
{
|
||||
u8 name[64];
|
||||
u8 params[64];
|
||||
int (*function) ()} command __attribute__ ((packed));
|
||||
|
||||
int rebootnow();
|
||||
int test2d();
|
||||
int test3d();
|
||||
int showidt();
|
||||
int showgdt();
|
||||
int detectcpu();
|
||||
int mode();
|
||||
int clear();
|
||||
int showregs();
|
||||
int showinfo();
|
||||
int err();
|
||||
int view();
|
||||
int test(void);
|
||||
int disas(u8 * commandline);
|
||||
int bpset(u8 * commandline);
|
||||
int bpclr(u8 * commandline);
|
||||
int sfont(u8 * commandline);
|
||||
int help();
|
||||
int logo();
|
||||
int detectpci();
|
||||
int showmem();
|
||||
int testmem();
|
||||
int testtask();
|
||||
int ps();
|
|
@ -1,20 +1,23 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#ifndef _VA_LIST_T_H
|
||||
#define _VA_LIST_T_H
|
||||
# define _VA_LIST_T_H
|
||||
|
||||
#define __GNUC_VA_LIST
|
||||
# define __GNUC_VA_LIST
|
||||
|
||||
typedef void *__gnuc_va_list;
|
||||
|
||||
#define __va_rounded_size(TYPE) (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
|
||||
# define __va_rounded_size(TYPE) (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
|
||||
|
||||
#define va_start(AP, LASTARG) (AP = ((__gnuc_va_list) __builtin_next_arg (LASTARG)))
|
||||
# define va_start(AP, LASTARG) (AP = ((__gnuc_va_list) __builtin_next_arg (LASTARG)))
|
||||
|
||||
void va_end (__gnuc_va_list);
|
||||
#define va_end(AP) ((void)0)
|
||||
|
||||
#define va_arg(AP, TYPE) (AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (TYPE)), *((TYPE *) (void *) ((char *) (AP) - __va_rounded_size (TYPE))))
|
||||
|
||||
#define __va_copy(dest, src) (dest) = (src)
|
||||
void va_end(__gnuc_va_list);
|
||||
# define va_end(AP) ((void)0)
|
||||
|
||||
# define va_arg(AP, TYPE) (AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (TYPE)), *((TYPE *) (void *) ((char *) (AP) - __va_rounded_size (TYPE))))
|
||||
|
||||
# define __va_copy(dest, src) (dest) = (src)
|
||||
|
||||
typedef __gnuc_va_list va_list;
|
||||
|
||||
|
|
|
@ -1,8 +1,29 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "types.h"
|
||||
|
||||
s8 strcmp(const u8 *src,const u8 *des);
|
||||
u32 strlen(const u8 *src);
|
||||
u8 *strchr(const u8 *src, u8 achar);
|
||||
u8 *strncpy(const u8 *src,u8 *des,u32 count);
|
||||
u8 *strcat(const u8 *src,u8 *des);
|
||||
u8* strcpy(const u8 *src, u8 *des);
|
||||
s8 strcmp(const u8 * src, const u8 * des);
|
||||
u32 strlen(const u8 * src);
|
||||
u8 *strchr(const u8 * src, u8 achar);
|
||||
u8 *strncpy(const u8 * src, u8 * des, u32 count);
|
||||
u8 *strcat(const u8 * src, u8 * des);
|
||||
u8 *strcpy(const u8 * src, u8 * des);
|
||||
void strtolower(u8 * src);
|
||||
void strtoupper(u8 * src);
|
||||
void stronecase(u8 * src);
|
||||
void strsetlen(u8 * src, u32 size);
|
||||
void strinvert(u8 * src);
|
||||
void strreplace(u8 * src, u8 search, u8 replaced);
|
||||
u8 *strfill(u8 * dst, u8 pattern, u32 size);
|
||||
void strright(u8 * src, u8 * dest, u32 size);
|
||||
void strleft(u8 * src, u8 * dest, u32 size);
|
||||
void strdelete(u8 * src, u32 index, u32 size);
|
||||
void strcompressdelimiter(u8 * src, u8 delim);
|
||||
void strinsert(u8 * src, u8 * dest, u32 index);
|
||||
u8 *strgetitem(u8 * src, u8 * dest, u8 delim, u32 index);
|
||||
u8 *strgetpointeritem(u8 * src, u8 delim, u32 index);
|
||||
u32 strgetnbitems(u8 * src, u8 delim);
|
||||
u8 strgetminbase(u8 * src);
|
||||
u8 strgetbase(u8 * src);
|
||||
u32 strtoint(u8 * src);
|
||||
|
|
|
@ -0,0 +1,51 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
|
||||
#define sysexit() asm volatile ("sysexit"::);
|
||||
|
||||
|
||||
#define syscall0(syscall) ({ \
|
||||
u32 _v; \
|
||||
asm volatile (\
|
||||
"mov %%esp,%%ecx;\
|
||||
mov $1f,%%edx;\
|
||||
sysenter;\
|
||||
1:" : "=a" (_v) : "a" (syscall): "ecx","edx","memory"); \
|
||||
_v; \
|
||||
})
|
||||
|
||||
#define syscall1(syscall,arg1) ({ \
|
||||
u32 _v; \
|
||||
asm volatile (\
|
||||
"mov %%esp,%%ecx;\
|
||||
mov $1f,%%edx;\
|
||||
sysenter;\
|
||||
1:" : "=a" (_v) : "a" (syscall), "b" (arg1) : "ecx","edx","memory"); \
|
||||
_v; \
|
||||
})
|
||||
|
||||
#define syscall2(syscall,arg1,arg2) ({ \
|
||||
u32 _v; \
|
||||
asm volatile (\
|
||||
"mov %%esp,%%ecx;\
|
||||
mov $1f,%%edx;\
|
||||
sysenter;\
|
||||
1:" : "=a" (_v) : "a" (syscall), "b" (arg1), "S" (arg2) : "ecx","edx","memory"); \
|
||||
_v; \
|
||||
})
|
||||
|
||||
#define syscall3(syscall,arg1,arg2,arg3) ({ \
|
||||
u32 _v; \
|
||||
asm volatile (\
|
||||
"mov %%esp,%%ecx;\
|
||||
mov $1f,%%edx;\
|
||||
sysenter;\
|
||||
1:" : "=a" (_v) : "a" (syscall), "b" (arg1), "S" (arg2), "D" (arg3) : "ecx","edx","memory"); \
|
||||
_v; \
|
||||
})
|
||||
|
||||
/* Vers 6 arguments maximum */
|
||||
void initsyscall(void);
|
||||
__attribute__ ((noreturn)) void sysenter_handler(regs *dump);
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
|
||||
#include "boot.h";
|
||||
|
||||
extern restart;
|
|
@ -1 +1,7 @@
|
|||
void timer();
|
||||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
|
||||
#include "interrupts.h"
|
||||
|
||||
__attribute__ ((noreturn)) void timer_handler(regs *dump);
|
||||
|
|
|
@ -1,31 +0,0 @@
|
|||
/***********************************/
|
||||
/* Librairie Type.h */
|
||||
/* 20 Mars 2007 */
|
||||
/***********************************/
|
||||
|
||||
#ifndef JREKCED_TYPE
|
||||
# define JREKCED_TYPE
|
||||
|
||||
# define NULL (0x0LL)
|
||||
|
||||
typedef char int8;
|
||||
typedef short int16;
|
||||
typedef int int32;
|
||||
typedef long long int64;
|
||||
|
||||
typedef char BYTE;
|
||||
typedef short WORD;
|
||||
typedef long DWORD;
|
||||
typedef long long QWORD;
|
||||
|
||||
typedef signed char SBYTE;
|
||||
typedef signed short SWORD;
|
||||
typedef signed long SDWORD;
|
||||
typedef signed long long SQWORD;
|
||||
|
||||
typedef unsigned char UBYTE;
|
||||
typedef unsigned short UWORD;
|
||||
typedef unsigned long UDWORD;
|
||||
typedef unsigned long long UQWORD;
|
||||
|
||||
#endif
|
|
@ -1,66 +1,70 @@
|
|||
#ifndef I386_TYPE
|
||||
#define I386_TYPE
|
||||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#ifndef ALLTYPES
|
||||
# define ALLTYPES
|
||||
|
||||
typedef unsigned char u8;
|
||||
typedef unsigned short u16;
|
||||
typedef unsigned int u32;
|
||||
typedef char s8;
|
||||
typedef short s16;
|
||||
typedef int s32;
|
||||
typedef int bool;
|
||||
typedef char int8;
|
||||
typedef short int16;
|
||||
typedef int int32;
|
||||
typedef long long int64;
|
||||
|
||||
typedef char BYTE;
|
||||
typedef short WORD;
|
||||
typedef long DWORD;
|
||||
typedef long long QWORD;
|
||||
|
||||
#define true -1;
|
||||
#define false 0;
|
||||
#define NULL 0x0000;
|
||||
typedef signed char SBYTE;
|
||||
typedef signed short SWORD;
|
||||
typedef signed long SDWORD;
|
||||
typedef signed long long SQWORD;
|
||||
|
||||
struct dtr {
|
||||
typedef unsigned char UBYTE;
|
||||
typedef unsigned short UWORD;
|
||||
typedef unsigned long UDWORD;
|
||||
typedef unsigned long long UQWORD;
|
||||
|
||||
u16 limite;
|
||||
|
||||
u32 base;
|
||||
|
||||
} __attribute__ ((packed));
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
typedef unsigned char u8;
|
||||
typedef unsigned short u16;
|
||||
typedef unsigned int u32;
|
||||
typedef unsigned long long int u64;
|
||||
typedef char s8;
|
||||
typedef short s16;
|
||||
typedef int s32;
|
||||
typedef long int s64;
|
||||
typedef int bool;
|
||||
|
||||
extern char ctype[];
|
||||
|
||||
#define CT_UP 0x01 /* upper case */
|
||||
#define CT_LOW 0x02 /* lower case */
|
||||
#define CT_DIG 0x04 /* digit */
|
||||
#define CT_CTL 0x08 /* control */
|
||||
#define CT_PUN 0x10 /* punctuation */
|
||||
#define CT_WHT 0x20 /* white space (space/cr/lf/tab) */
|
||||
#define CT_HEX 0x40 /* hex digit */
|
||||
#define CT_SP 0x80 /* hard space (0x20) */
|
||||
# define true 1
|
||||
# define false 0
|
||||
# define NULL 0x0000
|
||||
|
||||
# define CT_UP 0x01 /* upper case */
|
||||
# define CT_LOW 0x02 /* lower case */
|
||||
# define CT_DIG 0x04 /* digit */
|
||||
# define CT_CTL 0x08 /* control */
|
||||
# define CT_PUN 0x10 /* punctuation */
|
||||
# define CT_WHT 0x20 /* white space (space/cr/lf/tab) */
|
||||
# define CT_HEX 0x40 /* hex digit */
|
||||
# define CT_SP 0x80 /* hard space (0x20) */
|
||||
|
||||
/* without the cast to unsigned, DJGPP complains (using -Wall) */
|
||||
#define isalnum(c) ((ctype + 1)[(unsigned)(c)] & (CT_UP | CT_LOW | CT_DIG))
|
||||
#define isalpha(c) ((ctype + 1)[(unsigned)(c)] & (CT_UP | CT_LOW))
|
||||
#define iscntrl(c) ((ctype + 1)[(unsigned)(c)] & (CT_CTL))
|
||||
#define isdigit(c) ((ctype + 1)[(unsigned)(c)] & (CT_DIG))
|
||||
#define isgraph(c) ((ctype + 1)[(unsigned)(c)] & (CT_PUN | CT_UP | CT_LOW | CT_DIG))
|
||||
#define islower(c) ((ctype + 1)[(unsigned)(c)] & (CT_LOW))
|
||||
#define isprint(c) ((ctype + 1)[(unsigned)(c)] & (CT_PUN | CT_UP | CT_LOW | CT_DIG | CT_SP))
|
||||
#define ispunct(c) ((ctype + 1)[(unsigned)(c)] & (CT_PUN))
|
||||
#define isspace(c) ((ctype + 1)[(unsigned)(c)] & (CT_WHT))
|
||||
#define isupper(c) ((ctype + 1)[(unsigned)(c)] & (CT_UP))
|
||||
#define isxdigit(c) ((ctype + 1)[(unsigned)(c)] & (CT_DIG | CT_HEX))
|
||||
#define isascii(c) ((unsigned)(c) <= 0x7F)
|
||||
#define toascii(c) ((unsigned)(c) & 0x7F)
|
||||
# define isalnum(c) ((ctype + 1)[(unsigned)(c)] & (CT_UP | CT_LOW | CT_DIG))
|
||||
# define isalpha(c) ((ctype + 1)[(unsigned)(c)] & (CT_UP | CT_LOW))
|
||||
# define iscntrl(c) ((ctype + 1)[(unsigned)(c)] & (CT_CTL))
|
||||
# define isdigit(c) ((ctype + 1)[(unsigned)(c)] & (CT_DIG))
|
||||
# define isgraph(c) ((ctype + 1)[(unsigned)(c)] & (CT_PUN | CT_UP | CT_LOW | CT_DIG))
|
||||
# define islower(c) ((ctype + 1)[(unsigned)(c)] & (CT_LOW))
|
||||
# define isprint(c) ((ctype + 1)[(unsigned)(c)] & (CT_PUN | CT_UP | CT_LOW | CT_DIG | CT_SP))
|
||||
# define ispunct(c) ((ctype + 1)[(unsigned)(c)] & (CT_PUN))
|
||||
# define isspace(c) ((ctype + 1)[(unsigned)(c)] & (CT_WHT))
|
||||
# define isupper(c) ((ctype + 1)[(unsigned)(c)] & (CT_UP))
|
||||
# define isxdigit(c) ((ctype + 1)[(unsigned)(c)] & (CT_DIG | CT_HEX))
|
||||
# define isascii(c) ((unsigned)(c) <= 0x7F)
|
||||
# define toascii(c) ((unsigned)(c) & 0x7F)
|
||||
|
||||
#define tolower(c) (isupper(c) ? c + 'a' - 'A' : c)
|
||||
#define toupper(c) (islower(c) ? c + 'A' - 'a' : c)
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
# define tolower(c) (isupper(c) ? c + 'a' - 'A' : c)
|
||||
# define toupper(c) (islower(c) ? c + 'A' - 'a' : c)
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -0,0 +1,49 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "types.h"
|
||||
#include "video.h"
|
||||
|
||||
#define STATE 0x3da
|
||||
|
||||
/* fonction obligatoires */
|
||||
void VESA_remap_memory(u32 vaddr);
|
||||
u8 *VESA_detect_hardware(void);
|
||||
u8 VESA_setvideo_mode(u8 mode);
|
||||
u8 *VESA_getvideo_drivername(void);
|
||||
u8 *VESA_getvideo_capabilities(void);
|
||||
videoinfos *VESA_getvideo_info(void);
|
||||
u32 VESA_mem_to_video(void *src, u32 dst, u32 size,
|
||||
bool increment_src);
|
||||
u32 VESA_video_to_mem(u32 src, void *dst, u32 size);
|
||||
u32 VESA_video_to_video(u32 src, u32 dst, u32 size);
|
||||
void VESA_wait_vretrace(void);
|
||||
void VESA_wait_hretrace(void);
|
||||
void VESA_page_set(u8 page);
|
||||
void VESA_page_show(u8 page);
|
||||
void VESA_dummy();
|
||||
|
||||
static videofonction vesafonctions = {
|
||||
&VESA_remap_memory,
|
||||
&VESA_detect_hardware,
|
||||
&VESA_setvideo_mode,
|
||||
&VESA_getvideo_drivername,
|
||||
&VESA_getvideo_capabilities,
|
||||
&VESA_getvideo_info,
|
||||
&VESA_mem_to_video,
|
||||
&VESA_video_to_mem,
|
||||
&VESA_video_to_video,
|
||||
&VESA_wait_vretrace,
|
||||
&VESA_wait_hretrace,
|
||||
&VESA_page_set,
|
||||
&VESA_page_show,
|
||||
&VESA_dummy,
|
||||
&VESA_dummy,
|
||||
&VESA_dummy,
|
||||
&VESA_dummy,
|
||||
&VESA_dummy,
|
||||
&VESA_dummy,
|
||||
&VESA_dummy,
|
||||
&VESA_dummy,
|
||||
&VESA_dummy
|
||||
};
|
|
@ -1,37 +1,148 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "types.h"
|
||||
#include "video.h"
|
||||
|
||||
#define TEXTSCREEN 0xB8000 /* debut de la memoire video texte*/
|
||||
#define GRPHSCREEN 0xA0000 /* debut de la memoire video graphique*/
|
||||
#define TEXTSCREEN 0xB8000 /* debut de la memoire video texte */
|
||||
#define GRPHSCREEN 0xA0000 /* debut de la memoire video graphique */
|
||||
#define ENDOFVMEM 0xC0000
|
||||
|
||||
typedef u8 mode_def[64];
|
||||
/* Registres VGAs */
|
||||
|
||||
#define SEQUENCER 0x3c4
|
||||
#define MISC_WRITE 0x3c2
|
||||
#define MISC_READ 0x3cc
|
||||
#define CCRT 0x3D4
|
||||
#define ATTRIBS 0x3c0
|
||||
#define GRAPHICS 0x3ce
|
||||
#define STATE 0x3da
|
||||
|
||||
u32 setvmode(u8);
|
||||
u32 loadfont(u8* def,u8 size,u8 font);
|
||||
void gotoscr(u16 x,u16 y);
|
||||
void useplane(u8 plan);
|
||||
u8 getfont();
|
||||
void setfont(u8 num);
|
||||
void waitvretrace (void);
|
||||
void waithretrace (void);
|
||||
void enablecursor (void);
|
||||
void disablecursor (void);
|
||||
void enablescroll (void);
|
||||
void disablescroll (void);
|
||||
void (*writepxl)(u16 x, u16 y, u32 c);
|
||||
void (*showchar)(u16 coordx,u16 coordy,u8 thechar,u8 attrib);
|
||||
void (*fill)(u8 attrib);
|
||||
void (*scroll)(u8 lines,u8 attrib);
|
||||
void split(u16 x);
|
||||
void showpage(u8 page);
|
||||
u8 getpage();
|
||||
void setpage(u8 page);
|
||||
u16 getnbpages();
|
||||
u16 getyres();
|
||||
u8 getdepth();
|
||||
u16 getxres();
|
||||
u8 getfont2();
|
||||
void enableblink();
|
||||
void disableblink();
|
||||
u8 (*getchar)(u16 coordx,u16 coordy);
|
||||
u8 (*getattrib)(u16 coordx,u16 coordy);
|
||||
/* Taille d'un plan de bit */
|
||||
|
||||
#define PLANESIZE 0x10000
|
||||
|
||||
/* Registres VGA */
|
||||
typedef struct misc_regs
|
||||
{
|
||||
u8 Miscellaneous_Output_Register;
|
||||
} misc_regs __attribute__ ((packed));
|
||||
|
||||
typedef struct sequencer_regs
|
||||
{
|
||||
u8 Reset_Register;
|
||||
u8 Clocking_Mode_Register;
|
||||
u8 Map_Mask_Register;
|
||||
u8 Character_Map_Select_Register;
|
||||
u8 Sequencer_Memory_Mode_Register;
|
||||
} sequencer_regs __attribute__ ((packed));
|
||||
|
||||
typedef struct crtc_regs
|
||||
{
|
||||
u8 Horizontal_Total_Register;
|
||||
u8 End_Horizontal_Display_Register;
|
||||
u8 Start_Horizontal_Blanking_Register;
|
||||
u8 End_Horizontal_Blanking_Register;
|
||||
u8 Start_Horizontal_Retrace_Register;
|
||||
u8 End_Horizontal_Retrace_Register;
|
||||
u8 Vertical_Total_Register;
|
||||
u8 Overflow_Register;
|
||||
u8 Preset_Row_Scan_Register;
|
||||
u8 Maximum_Scan_Line_Register;
|
||||
u8 Cursor_Start_Register;
|
||||
u8 Cursor_End_Register;
|
||||
u8 Start_Address_High_Register;
|
||||
u8 Start_Address_Low_Register;
|
||||
u8 Cursor_Location_High_Register;
|
||||
u8 Cursor_Location_Low_Register;
|
||||
u8 Vertical_Retrace_Start_Register;
|
||||
u8 Vertical_Retrace_End_Register;
|
||||
u8 Vertical_Display_End_Register;
|
||||
u8 Offset_Register;
|
||||
u8 Underline_Location_Register;
|
||||
u8 Start_Vertical_Blanking_Register;
|
||||
u8 End_Vertical_Blanking;
|
||||
u8 CRTC_Mode_Control_Register;
|
||||
u8 Line_Compare_Register;
|
||||
} crtc_regs __attribute__ ((packed));
|
||||
|
||||
typedef struct graphics_regs
|
||||
{
|
||||
u8 Set_Reset_Register;
|
||||
u8 Enable_Set_Reset_Register;
|
||||
u8 Color_Compare_Register;
|
||||
u8 Data_Rotate_Register;
|
||||
u8 Read_Map_Select_Register;
|
||||
u8 Graphics_Mode_Register;
|
||||
u8 Miscellaneous_Graphics_Register;
|
||||
u8 Color_Dont_Care_Register;
|
||||
u8 Bit_Mask_Register;
|
||||
} graphics_regs __attribute__ ((packed));
|
||||
|
||||
typedef struct attributs_regs
|
||||
{
|
||||
u8 Palette_Registers[16];
|
||||
u8 Attribute_Mode_Control_Register;
|
||||
u8 Overscan_Color_Register;
|
||||
u8 Color_Plane_Enable_Register;
|
||||
u8 Horizontal_Pixel_Panning_Register;
|
||||
u8 Color_Select_Register;
|
||||
} attributs_regs __attribute__ ((packed));
|
||||
|
||||
typedef struct vgamode
|
||||
{
|
||||
misc_regs misc;
|
||||
sequencer_regs sequencer;
|
||||
crtc_regs ctrc;
|
||||
graphics_regs graphic;
|
||||
attributs_regs attribut;
|
||||
} vgamode __attribute__ ((packed));
|
||||
|
||||
/* fonction obligatoires */
|
||||
void VGA_remap_memory(u32 vaddr);
|
||||
u8 *VGA_detect_hardware(void);
|
||||
u8 VGA_setvideo_mode(u8 mode);
|
||||
u8 *VGA_getvideo_drivername(void);
|
||||
u8 *VGA_getvideo_capabilities(void);
|
||||
videoinfos *VGA_getvideo_info(void);
|
||||
u32 VGA_mem_to_video(void *src, u32 dst, u32 size, bool increment_src);
|
||||
u32 VGA_video_to_mem(u32 src, void *dst, u32 size);
|
||||
u32 VGA_video_to_video(u32 src, u32 dst, u32 size);
|
||||
void VGA_wait_vretrace(void);
|
||||
void VGA_wait_hretrace(void);
|
||||
void VGA_page_set(u8 page);
|
||||
void VGA_page_show(u8 page);
|
||||
void VGA_page_split(u16 y);
|
||||
void VGA_cursor_enable(void);
|
||||
void VGA_cursor_disable(void);
|
||||
void VGA_cursor_set(u16 x, u16 y);
|
||||
u32 VGA_font_load(u8 * def, u8 size, u8 font);
|
||||
void VGA_font1_set(u8 num);
|
||||
void VGA_font2_set(u8 num);
|
||||
void VGA_blink_enable(void);
|
||||
void VGA_blink_disable(void);
|
||||
|
||||
static videofonction vgafonctions = {
|
||||
&VGA_remap_memory,
|
||||
&VGA_detect_hardware,
|
||||
&VGA_setvideo_mode,
|
||||
&VGA_getvideo_drivername,
|
||||
&VGA_getvideo_capabilities,
|
||||
&VGA_getvideo_info,
|
||||
&VGA_mem_to_video,
|
||||
&VGA_video_to_mem,
|
||||
&VGA_video_to_video,
|
||||
&VGA_wait_vretrace,
|
||||
&VGA_wait_hretrace,
|
||||
&VGA_page_set,
|
||||
&VGA_page_show,
|
||||
&VGA_page_split,
|
||||
&VGA_cursor_enable,
|
||||
&VGA_cursor_disable,
|
||||
&VGA_cursor_set,
|
||||
&VGA_font_load,
|
||||
&VGA_font1_set,
|
||||
&VGA_font2_set,
|
||||
&VGA_blink_enable,
|
||||
&VGA_blink_disable
|
||||
};
|
||||
|
|
|
@ -1,19 +1,188 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
|
||||
typedef struct console {
|
||||
u8 attrib;
|
||||
s16 cursX;
|
||||
s16 cursY;
|
||||
u8 ansi;
|
||||
u8 param1;
|
||||
u8 param2;
|
||||
u8 param3;
|
||||
u8 page;
|
||||
} console __attribute__ ((packed));
|
||||
#ifndef VIDEO
|
||||
# define VIDEO
|
||||
|
||||
# include "stdarg.h"
|
||||
|
||||
void showhex(u8 src);
|
||||
void putchar(u8 thechar);
|
||||
void print(u8* string);
|
||||
void printf (const u8 *string, ...);
|
||||
void changevc(u8 vc);
|
||||
# define MAXDRIVERS 10
|
||||
# define MAXFONTS 10
|
||||
|
||||
typedef struct vertex2d
|
||||
{
|
||||
s16 x;
|
||||
s16 y;
|
||||
} vertex2d __attribute__ ((packed));
|
||||
|
||||
typedef struct rgbcolor
|
||||
{
|
||||
u8 R;
|
||||
u8 G;
|
||||
u8 B;
|
||||
} rgbcolor __attribute__ ((packed));
|
||||
|
||||
typedef struct videoinfos
|
||||
{
|
||||
u8 currentmode;
|
||||
u16 currentwidth;
|
||||
u16 currentheight;
|
||||
u8 currentdepth;
|
||||
u8 currentactivepage;
|
||||
u8 currentshowedpage;
|
||||
u16 currentcursorX;
|
||||
u16 currentcursorY;
|
||||
u8 currentfont1;
|
||||
u8 currentfont2;
|
||||
u16 currentpitch;
|
||||
bool isgraphic;
|
||||
bool isblinking;
|
||||
bool iscursorvisible;
|
||||
u8 pagesnumber;
|
||||
u32 pagesize;
|
||||
u32 baseaddress;
|
||||
} videoinfos __attribute__ ((packed));
|
||||
|
||||
typedef struct videofonction
|
||||
{
|
||||
void (*remap_memory) ();
|
||||
u8 *(*detect_hardware) ();
|
||||
u8(*setvideo_mode) ();
|
||||
u8 *(*getvideo_drivername) ();
|
||||
u8 *(*getvideo_capabilities) ();
|
||||
videoinfos *(*getvideo_info) ();
|
||||
u32(*mem_to_video) ();
|
||||
u32(*video_to_mem) ();
|
||||
u32(*video_to_video) ();
|
||||
void (*wait_vretrace) ();
|
||||
void (*wait_hretrace) ();
|
||||
void (*page_set) ();
|
||||
void (*page_show) ();
|
||||
void (*page_split) ();
|
||||
void (*cursor_enable) ();
|
||||
void (*cursor_disable) ();
|
||||
void (*cursor_set) ();
|
||||
u32(*font_load) ();
|
||||
void (*font1_set) ();
|
||||
void (*font2_set) ();
|
||||
void (*blink_enable) ();
|
||||
void (*blink_disable) ();
|
||||
} videofonction __attribute__ ((packed));
|
||||
|
||||
typedef struct drivers
|
||||
{
|
||||
u8 *nom;
|
||||
videofonction *pointer;
|
||||
} drivers __attribute__ ((packed));
|
||||
|
||||
typedef struct font
|
||||
{
|
||||
u8 nom[8];
|
||||
u8 *pointer;
|
||||
u8 width;
|
||||
u8 height;
|
||||
} font __attribute__ ((packed));
|
||||
|
||||
typedef struct capabilities
|
||||
{
|
||||
u8 modenumber;
|
||||
u16 width;
|
||||
u16 height;
|
||||
bool graphic;
|
||||
u8 depth;
|
||||
u8 refresh;
|
||||
} capabilities __attribute__ ((packed));
|
||||
|
||||
typedef struct console
|
||||
{
|
||||
u8 attrib;
|
||||
s16 cursX;
|
||||
s16 cursY;
|
||||
u8 ansi;
|
||||
u8 param1;
|
||||
u8 param2;
|
||||
u8 param3;
|
||||
u8 page;
|
||||
bool scroll;
|
||||
} console __attribute__ ((packed));
|
||||
|
||||
/* Fonctions de bas niveau */
|
||||
void fill(u8 attrib);
|
||||
void scroll(u8 lines, u8 attrib);
|
||||
void scroll_enable(void);
|
||||
void scroll_disable(void);
|
||||
void showchar(u16 coordx, u16 coordy, u8 thechar, u8 attrib);
|
||||
u8 getchar(u16 coordx, u16 coordy);
|
||||
u8 getattrib(u16 coordx, u16 coordy);
|
||||
void v_writepxl(vertex2d * A, u32 color);
|
||||
void writepxl(s16 x, s16 y, u32 color);
|
||||
void line(s16 x1, s16 y1, s16 x2, s16 y2, u32 color);
|
||||
void hline(s16 x1, s16 x2, s16 y, u32 color);
|
||||
void changemode(u8 mode);
|
||||
u32 egatorgb(u8 ega);
|
||||
u8 egatovga(u8 ega);
|
||||
void v_line(vertex2d * A, vertex2d * B, u32 color);
|
||||
void trianglefilled(vertex2d * A, vertex2d * B, vertex2d * C,
|
||||
u32 color);
|
||||
void triangle(vertex2d * A, vertex2d * B, vertex2d * C, u32 color);
|
||||
|
||||
/* Fonctions de console */
|
||||
void changevc(u8 vc);
|
||||
void putchar(u8 thechar);
|
||||
void clearscreen(void);
|
||||
u16 getwidth(void);
|
||||
u16 getheight(void);
|
||||
void loadfont(u8 * name, font * pointer, u8 width, u8 height);
|
||||
void setfont(u8 * fontname);
|
||||
|
||||
/* Fonctions de haut niveau */
|
||||
u32 print(u8 * string);
|
||||
u32 printf(const u8 * string, ...);
|
||||
u32 sprintf(u8 * variable, const u8 * string, ...);
|
||||
u32 snprintf(u8 * variable, u32 maxsize, const u8 * string, ...);
|
||||
u32 vprintf(const u8 * string, va_list args);
|
||||
u32 vsprintf(u8 * variable, const u8 * string, va_list args);
|
||||
u32 vsnprintf(u8 * variable, u32 maxsize, const u8 * string,
|
||||
va_list args);
|
||||
|
||||
u8 *itoa(u64 num, u8 * str, u8 base, u64 dim, u8 achar);
|
||||
u8 *sitoa(u64 num, u8 * str, u64 dim);
|
||||
u8 *rtoadouble(double num, u8 * str, u8 precisioni, u8 precisionf);
|
||||
u8 *rtoasingle(float num, u8 * str, u8 precisioni, u8 precisionf);
|
||||
u32 format(const u8 * string, va_list args, u32 maxsize,
|
||||
u32(*fonction) (u8 * src, u8 ** dest, u32 len), u8 * dest);
|
||||
|
||||
/* Fonction pour gérer le pilote */
|
||||
void initdriver();
|
||||
void registerdriver(videofonction * pointer);
|
||||
void apply_bestdriver(void);
|
||||
void apply_nextdriver(void);
|
||||
void apply_driver(u8 * name);
|
||||
void apply_nextvideomode(void);
|
||||
|
||||
/* Fonctions du pilote */
|
||||
void (*remap_memory) (u32 vaddr);
|
||||
u8 *(*detect_hardware) (void);
|
||||
u8(*setvideo_mode) (u8 mode);
|
||||
u8 *(*getvideo_drivername) (void);
|
||||
u8 *(*getvideo_capabilities) (void);
|
||||
videoinfos *(*getvideo_info) (void);
|
||||
u32(*mem_to_video) (void *src, u32 dst, u32 size, bool increment_src);
|
||||
u32(*video_to_mem) (u32 src, void *dst, u32 size);
|
||||
u32(*video_to_video) (u32 src, u32 dst, u32 size);
|
||||
void (*wait_vretrace) (void);
|
||||
void (*wait_hretrace) (void);
|
||||
void (*page_set) (u8 page);
|
||||
void (*page_show) (u8 page);
|
||||
void (*page_split) (u16 y);
|
||||
void (*cursor_enable) (void);
|
||||
void (*cursor_disable) (void);
|
||||
void (*cursor_set) (u16 x, u16 y);
|
||||
u32(*font_load) (u8 * def, u8 size, u8 font);
|
||||
void (*font1_set) (u8 num);
|
||||
void (*font2_set) (u8 num);
|
||||
void (*blink_enable) (void);
|
||||
void (*blink_disable) (void);
|
||||
|
||||
#endif
|
||||
|
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -1,5 +1,280 @@
|
|||
#include "3d.h"
|
||||
#include "vga.h"
|
||||
#include "types.h"
|
||||
#include "video.h"
|
||||
#include "graph.h"
|
||||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "3d.h"
|
||||
#include "types.h"
|
||||
#include "video.h"
|
||||
#include "string.h"
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Crée une projection simple pour test */
|
||||
void proj(vector4 list[], vertex2d plane[], vector4 origin[], u16 number,
|
||||
float factor)
|
||||
{
|
||||
for (u32 i = 0; i < number; i++)
|
||||
{
|
||||
plane[i].x =
|
||||
(int) ((list[i].x * factor) /
|
||||
(list[i].z + origin->z) + origin->x);
|
||||
plane[i].y =
|
||||
(int) ((list[i].y * factor) /
|
||||
(list[i].z + origin->z) + origin->y);
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Crée une liste de vertex3D pour un cube */
|
||||
|
||||
void cube(model3d * model, vector4 * origin, u16 size)
|
||||
{
|
||||
strcpy("cube", model->name);
|
||||
model->vertexnb = 8;
|
||||
model->vertexlist = 0x00300000;
|
||||
model->vertexlist[0].x = origin->x;
|
||||
model->vertexlist[0].y = origin->y;
|
||||
model->vertexlist[0].z = origin->z;
|
||||
model->vertexlist[0].w = 1.0f;
|
||||
model->vertexlist[1].x = origin->x + size;
|
||||
model->vertexlist[1].y = origin->y;
|
||||
model->vertexlist[1].z = origin->z;
|
||||
model->vertexlist[1].w = 1.0f;
|
||||
model->vertexlist[2].x = origin->x;
|
||||
model->vertexlist[2].y = origin->y + size;
|
||||
model->vertexlist[2].z = origin->z;
|
||||
model->vertexlist[2].w = 1.0f;
|
||||
model->vertexlist[3].x = origin->x + size;
|
||||
model->vertexlist[3].y = origin->y + size;
|
||||
model->vertexlist[3].z = origin->z;
|
||||
model->vertexlist[3].w = 1.0f;
|
||||
model->vertexlist[4].x = origin->x;
|
||||
model->vertexlist[4].y = origin->y;
|
||||
model->vertexlist[4].z = origin->z + size;
|
||||
model->vertexlist[4].w = 1.0f;
|
||||
model->vertexlist[5].x = origin->x + size;
|
||||
model->vertexlist[5].y = origin->y;
|
||||
model->vertexlist[5].z = origin->z + size;
|
||||
model->vertexlist[5].w = 1.0f;
|
||||
model->vertexlist[6].x = origin->x;
|
||||
model->vertexlist[6].y = origin->y + size;
|
||||
model->vertexlist[6].z = origin->z + size;
|
||||
model->vertexlist[6].w = 1.0f;
|
||||
model->vertexlist[7].x = origin->x + size;
|
||||
model->vertexlist[7].y = origin->y + size;
|
||||
model->vertexlist[7].z = origin->z + size;
|
||||
model->vertexlist[7].w = 1.0f;
|
||||
model->facelist = 0x00310000;
|
||||
model->facelist[0].V1 = 0;
|
||||
model->facelist[0].V2 = 1;
|
||||
model->facelist[0].V3 = 3;
|
||||
model->facelist[1].V1 = 0;
|
||||
model->facelist[1].V2 = 2;
|
||||
model->facelist[1].V3 = 3;
|
||||
model->facelist[2].V1 = 4;
|
||||
model->facelist[2].V2 = 5;
|
||||
model->facelist[2].V3 = 7;
|
||||
model->facelist[3].V1 = 4;
|
||||
model->facelist[3].V2 = 6;
|
||||
model->facelist[3].V3 = 7;
|
||||
model->facelist[4].V1 = 0;
|
||||
model->facelist[4].V2 = 1;
|
||||
model->facelist[4].V3 = 5;
|
||||
model->facelist[5].V1 = 0;
|
||||
model->facelist[5].V2 = 1;
|
||||
model->facelist[5].V3 = 4;
|
||||
model->facelist[6].V1 = 0;
|
||||
model->facelist[6].V2 = 0;
|
||||
model->facelist[6].V3 = 0;
|
||||
model->facelist[7].V1 = 0;
|
||||
model->facelist[7].V2 = 0;
|
||||
model->facelist[7].V3 = 0;
|
||||
model->facelist[8].V1 = 0;
|
||||
model->facelist[8].V2 = 0;
|
||||
model->facelist[8].V3 = 0;
|
||||
model->facelist[9].V1 = 0;
|
||||
model->facelist[9].V2 = 0;
|
||||
model->facelist[9].V3 = 0;
|
||||
model->facelist[10].V1 = 0;
|
||||
model->facelist[10].V2 = 0;
|
||||
model->facelist[10].V3 = 0;
|
||||
model->facelist[11].V1 = 0;
|
||||
model->facelist[11].V2 = 0;
|
||||
model->facelist[11].V3 = 0;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Affiche un modèle 3D */
|
||||
|
||||
void show3dmodel(model3d * model, matrix44 * transformation,
|
||||
vector4 origin[], float factor, type3D type)
|
||||
{
|
||||
u16 i;
|
||||
vertex2d *plane = 0x00250000;
|
||||
for (i = 0; i < model->vertexnb; i++)
|
||||
{
|
||||
matrix44_transform(transformation, &model->vertexlist[i]);
|
||||
}
|
||||
proj(model->vertexlist, plane, origin, model->vertexnb, factor);
|
||||
switch (type)
|
||||
{
|
||||
case TYPE3D_POINTS:
|
||||
for (i = 0; i < model->vertexnb; i++)
|
||||
{
|
||||
v_writepxl(&plane[i], egatorgb(4));
|
||||
}
|
||||
break;
|
||||
case TYPE3D_LINES:
|
||||
for (i = 0; i < model->facenb; i++)
|
||||
{
|
||||
v_line(&plane[model->facelist[i].V1],
|
||||
&plane[model->facelist[i].V2],
|
||||
egatorgb(4));
|
||||
v_line(&plane[model->facelist[i].V1],
|
||||
&plane[model->facelist[i].V3],
|
||||
egatorgb(4));
|
||||
v_line(&plane[model->facelist[i].V2],
|
||||
&plane[model->facelist[i].V3],
|
||||
egatorgb(4));
|
||||
}
|
||||
break;
|
||||
case TYPE3D_FACES:
|
||||
break;
|
||||
case TYPE3D_FLAT:
|
||||
break;
|
||||
case TYPE3D_TEXTURE:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Charge un fichier 3DS */
|
||||
|
||||
int load3ds(u8 * pointer, u32 size, model3d * model)
|
||||
{
|
||||
u8 *ptr = pointer;
|
||||
u16 chunk_id;
|
||||
u32 chunk_size;
|
||||
u16 i;
|
||||
float *listfloat;
|
||||
u16 *listunsigned;
|
||||
dsState state = DS_READ_CHUNK_ID;
|
||||
bool dsfile = false;
|
||||
while (ptr - pointer < size)
|
||||
{
|
||||
switch (state)
|
||||
{
|
||||
case DS_READ_CHUNK_ID:
|
||||
chunk_id = *((u16 *) ptr);
|
||||
ptr += 2;
|
||||
state = DS_READ_CHUNK_LENGTH;
|
||||
break;
|
||||
case DS_READ_CHUNK_LENGTH:
|
||||
chunk_size = *((u32 *) ptr);
|
||||
ptr += 4;
|
||||
switch (chunk_id)
|
||||
{
|
||||
case MAIN3DS:
|
||||
dsfile = true;
|
||||
ptr += 10;
|
||||
state = DS_READ_CHUNK_ID;
|
||||
break;
|
||||
case EDIT3DS:
|
||||
state = DS_READ_CHUNK_ID;
|
||||
break;
|
||||
case OBJ_TRIMESH:
|
||||
state = DS_READ_CHUNK_ID;
|
||||
break;
|
||||
case EDIT_OBJECT:
|
||||
state = DS_READ_OBJECT_NAME;
|
||||
break;
|
||||
case TRI_VERTEXL:
|
||||
state = DS_READ_POINT_COUNT;
|
||||
break;
|
||||
case TRI_FACEL1:
|
||||
state = DS_READ_FACE_COUNT;
|
||||
break;
|
||||
case TRI_LOCAL:
|
||||
state = DS_READ_MATRIX;
|
||||
break;
|
||||
default:
|
||||
if (!dsfile)
|
||||
return 1;
|
||||
ptr += (chunk_size - 6);
|
||||
state = DS_READ_CHUNK_ID;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case DS_READ_OBJECT_NAME:
|
||||
strcpy(ptr, model->name);
|
||||
ptr += (strlen(ptr) + 1);
|
||||
state = DS_READ_CHUNK_ID;
|
||||
break;
|
||||
case DS_SKIP_CHUNK:
|
||||
break;
|
||||
case DS_READ_POINT_COUNT:
|
||||
model->vertexnb = *((u16 *) ptr);
|
||||
state = DS_READ_POINTS;
|
||||
ptr += 2;
|
||||
break;
|
||||
case DS_READ_POINTS:
|
||||
i = 0;
|
||||
listfloat = ptr;
|
||||
model->vertexlist = 0x00300000;
|
||||
while (i < model->vertexnb)
|
||||
{
|
||||
model->vertexlist[i].x =
|
||||
*(listfloat++);
|
||||
model->vertexlist[i].y =
|
||||
*(listfloat++);
|
||||
model->vertexlist[i].z =
|
||||
*(listfloat++);
|
||||
model->vertexlist[i++].w = 1.0;
|
||||
}
|
||||
ptr = listfloat;
|
||||
state = DS_READ_CHUNK_ID;
|
||||
break;
|
||||
case DS_READ_FACE_COUNT:
|
||||
model->facenb = *((u16 *) ptr);
|
||||
state = DS_READ_FACES;
|
||||
ptr += 2;
|
||||
break;
|
||||
case DS_READ_FACES:
|
||||
i = 0;
|
||||
listunsigned = ptr;
|
||||
model->facelist = 0x00400000;
|
||||
while (i < model->facenb)
|
||||
{
|
||||
model->facelist[i].V1 =
|
||||
*(listunsigned++);
|
||||
model->facelist[i].V2 =
|
||||
*(listunsigned++);
|
||||
model->facelist[i++].V3 =
|
||||
*(listunsigned++);
|
||||
listunsigned++;
|
||||
}
|
||||
ptr = listunsigned;
|
||||
state = DS_READ_CHUNK_ID;
|
||||
break;
|
||||
case DS_READ_MATRIX:
|
||||
i = 0;
|
||||
listfloat = ptr;
|
||||
while (i < 4)
|
||||
{
|
||||
model->view.V[i].x =
|
||||
*(listfloat++);
|
||||
model->view.V[i].y =
|
||||
*(listfloat++);
|
||||
model->view.V[i].z =
|
||||
*(listfloat++);
|
||||
model->view.V[i++].w = 0.0f;
|
||||
}
|
||||
model->view.V[3].w = 1.0f;
|
||||
ptr = listfloat;
|
||||
state = DS_READ_CHUNK_ID;
|
||||
break;
|
||||
case DS_READ_DONE:
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
|
259
lib/8x16fnt.c
259
lib/8x16fnt.c
|
@ -1,259 +0,0 @@
|
|||
/* Police de caract鑽e fine 8x16 */
|
||||
static u8 font8x16 [4096] = {
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x7E, 0x81, 0xA5, 0x81, 0x81, 0xBD, 0x99, 0x81, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x7E, 0xFF, 0xDB, 0xFF, 0xFF, 0xC3, 0xE7, 0xFF, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x36, 0x7F, 0x7F, 0x7F, 0x7F, 0x3E, 0x1C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x08, 0x1C, 0x3E, 0x7F, 0x3E, 0x1C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x3C, 0x3C, 0xE7, 0xE7, 0xE7, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0x7E, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE7, 0xC3, 0xC3, 0xE7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x3C, 0x66, 0x42, 0x42, 0x66, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0xFF, 0xFF, 0xFF, 0xFF, 0xC3, 0x99, 0xBD, 0xBD, 0x99, 0xC3, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
|
||||
0x00, 0x00, 0x0F, 0x07, 0x0D, 0x19, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x3F, 0x33, 0x3F, 0x30, 0x30, 0x30, 0x70, 0xF0, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x7F, 0x63, 0x7F, 0x63, 0x63, 0x63, 0x67, 0xE7, 0xE6, 0xC0, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x18, 0xDB, 0x3C, 0xE7, 0x3C, 0xDB, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x40, 0x60, 0x70, 0x7C, 0x7F, 0x7C, 0x70, 0x60, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x01, 0x03, 0x07, 0x1F, 0x7F, 0x1F, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x3C, 0x7E, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x00, 0x33, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x7F, 0xDB, 0xDB, 0xDB, 0x7B, 0x1B, 0x1B, 0x1B, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3E, 0x63, 0x30, 0x1C, 0x36, 0x63, 0x63, 0x36, 0x1C, 0x06, 0x63, 0x3E, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x7F, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x3C, 0x7E, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x7E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x3C, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x0C, 0x06, 0x7F, 0x06, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x7F, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60, 0x60, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x24, 0x66, 0xFF, 0x66, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x08, 0x1C, 0x1C, 0x3E, 0x3E, 0x7F, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x7F, 0x7F, 0x3E, 0x3E, 0x1C, 0x1C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x24, 0x24, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x42, 0x42, 0x42, 0xFF, 0x42, 0x42, 0x42, 0xFF, 0x42, 0x42, 0x42, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x10, 0x7E, 0x90, 0x90, 0x90, 0x7C, 0x12, 0x12, 0x12, 0xFC, 0x10, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x61, 0x91, 0x92, 0x64, 0x08, 0x10, 0x26, 0x49, 0x89, 0x86, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x70, 0x88, 0x88, 0x88, 0x50, 0x60, 0x91, 0x8A, 0x84, 0x4A, 0x31, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x18, 0x18, 0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x06, 0x18, 0x20, 0x40, 0x40, 0x40, 0x40, 0x40, 0x20, 0x18, 0x06, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x60, 0x18, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x04, 0x18, 0x60, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x10, 0x92, 0x54, 0x38, 0xFE, 0x38, 0x54, 0x92, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0xFE, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x10, 0x20, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x01, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x83, 0x85, 0x89, 0x91, 0xA1, 0xC1, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x10, 0x30, 0x50, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x7C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x01, 0x02, 0x3C, 0x40, 0x80, 0x80, 0x80, 0xFF, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x01, 0x02, 0x3C, 0x02, 0x01, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x02, 0x06, 0x0A, 0x12, 0x22, 0x42, 0x82, 0xFF, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFF, 0x80, 0x80, 0x80, 0xFC, 0x02, 0x01, 0x01, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x80, 0xBC, 0xC2, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFF, 0x81, 0x01, 0x02, 0x04, 0x08, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x81, 0x42, 0x3C, 0x42, 0x81, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x81, 0x43, 0x3D, 0x01, 0x01, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x10, 0x20, 0x00, 0x00,
|
||||
0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x38, 0x44, 0x82, 0x82, 0x04, 0x08, 0x10, 0x10, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x99, 0xA5, 0xA5, 0xA5, 0x9E, 0x80, 0x41, 0x3E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x18, 0x24, 0x42, 0x81, 0x81, 0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFC, 0x42, 0x41, 0x41, 0x42, 0x7C, 0x42, 0x41, 0x41, 0x42, 0xFC, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFC, 0x42, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x42, 0xFC, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFF, 0x80, 0x80, 0x80, 0x80, 0xFC, 0x80, 0x80, 0x80, 0x80, 0xFF, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFF, 0x80, 0x80, 0x80, 0x80, 0xFC, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x81, 0x80, 0x9F, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x38, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x38, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x07, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x82, 0x82, 0x44, 0x38, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x81, 0x82, 0x84, 0x88, 0x90, 0xE0, 0x90, 0x88, 0x84, 0x82, 0x81, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFF, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x81, 0xC3, 0xA5, 0x99, 0x99, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x81, 0xC1, 0xA1, 0x91, 0x89, 0x85, 0x83, 0x81, 0x81, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFC, 0x82, 0x81, 0x81, 0x82, 0xFC, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x81, 0x81, 0x81, 0x81, 0x89, 0x85, 0x42, 0x3D, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFC, 0x82, 0x81, 0x81, 0x82, 0xFC, 0x90, 0x88, 0x84, 0x82, 0x81, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x80, 0x40, 0x3C, 0x02, 0x01, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFE, 0x92, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0x42, 0x42, 0x24, 0x24, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x99, 0x99, 0xA5, 0xA5, 0x42, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x81, 0x81, 0x81, 0x42, 0x24, 0x18, 0x24, 0x42, 0x81, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x82, 0x82, 0x82, 0x82, 0x44, 0x28, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFF, 0x01, 0x01, 0x02, 0x04, 0x18, 0x20, 0x40, 0x80, 0x80, 0xFF, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x7E, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x7E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x80, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x7E, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x7E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x18, 0x24, 0x42, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
|
||||
0x00, 0x08, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0x02, 0x02, 0x7E, 0x82, 0x82, 0x7D, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x80, 0x80, 0x80, 0x80, 0xBC, 0xC2, 0x81, 0x81, 0x81, 0xC2, 0xBC, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x42, 0x80, 0x80, 0x80, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x01, 0x01, 0x01, 0x01, 0x3D, 0x43, 0x81, 0x81, 0x81, 0x43, 0x3D, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x42, 0x81, 0xFF, 0x80, 0x40, 0x3E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x0E, 0x11, 0x10, 0x10, 0xFE, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x3D, 0x43, 0x81, 0x81, 0x43, 0x3D, 0x01, 0x02, 0x7C, 0x00, 0x00,
|
||||
0x00, 0x80, 0x80, 0x80, 0x80, 0xBC, 0xC2, 0x81, 0x81, 0x81, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x08, 0x08, 0x00, 0x38, 0x08, 0x08, 0x08, 0x08, 0x08, 0x3E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x02, 0x02, 0x00, 0x06, 0x02, 0x02, 0x02, 0x02, 0x02, 0x82, 0x44, 0x38, 0x00, 0x00,
|
||||
0x00, 0x80, 0x80, 0x80, 0x80, 0x82, 0x84, 0x88, 0x90, 0xA8, 0xC4, 0x82, 0x00, 0x00, 0x00, 0x00,
|
||||
0x38, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x3E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xEC, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xB8, 0xC4, 0x82, 0x82, 0x82, 0x82, 0x82, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x42, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xBC, 0xC2, 0x81, 0x81, 0x81, 0xC2, 0xBC, 0x80, 0x80, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x3D, 0x43, 0x81, 0x81, 0x81, 0x43, 0x3D, 0x01, 0x01, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xBE, 0xC1, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x81, 0x80, 0x7E, 0x01, 0x81, 0x7E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x10, 0x10, 0x10, 0x10, 0x10, 0xFE, 0x10, 0x10, 0x10, 0x10, 0x11, 0x0E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0x43, 0x3D, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x81, 0x81, 0x81, 0x42, 0x24, 0x18, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x82, 0x92, 0x92, 0x92, 0xAA, 0x44, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x42, 0x24, 0x18, 0x24, 0x42, 0x81, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x81, 0x81, 0x81, 0x43, 0x3D, 0x01, 0x02, 0x7C, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x02, 0x04, 0x18, 0x20, 0x40, 0xFF, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x04, 0x08, 0x10, 0x10, 0x10, 0x20, 0x10, 0x10, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x40, 0x20, 0x10, 0x10, 0x10, 0x08, 0x10, 0x10, 0x10, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x70, 0x99, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x08, 0x1C, 0x36, 0x63, 0x63, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x1E, 0x33, 0x61, 0x60, 0x60, 0x61, 0x33, 0x1E, 0x06, 0x03, 0x3E, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x66, 0x66, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x06, 0x0C, 0x18, 0x00, 0x3E, 0x63, 0x7F, 0x60, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x08, 0x1C, 0x36, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x66, 0x66, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x30, 0x18, 0x0C, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x1C, 0x36, 0x1C, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x3C, 0x66, 0x60, 0x66, 0x3C, 0x0C, 0x06, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x08, 0x1C, 0x36, 0x00, 0x3E, 0x63, 0x7F, 0x60, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x66, 0x66, 0x00, 0x3E, 0x63, 0x7F, 0x60, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x30, 0x18, 0x0C, 0x00, 0x3E, 0x63, 0x7F, 0x60, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x66, 0x66, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x18, 0x3C, 0x66, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x60, 0x30, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x63, 0x63, 0x08, 0x1C, 0x36, 0x63, 0x63, 0x7F, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x1C, 0x36, 0x1C, 0x00, 0x1C, 0x36, 0x63, 0x63, 0x7F, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x0C, 0x18, 0x30, 0x00, 0x7F, 0x33, 0x30, 0x3E, 0x30, 0x33, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x6E, 0x3B, 0x1B, 0x7E, 0xD8, 0xDC, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x1F, 0x36, 0x66, 0x66, 0x7F, 0x66, 0x66, 0x66, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x08, 0x1C, 0x36, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x63, 0x63, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x30, 0x18, 0x0C, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x18, 0x3C, 0x66, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x30, 0x18, 0x0C, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x63, 0x63, 0x00, 0x63, 0x63, 0x63, 0x63, 0x3F, 0x03, 0x06, 0x3C, 0x00, 0x00, 0x00,
|
||||
0x00, 0x63, 0x63, 0x1C, 0x36, 0x63, 0x63, 0x63, 0x63, 0x36, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x63, 0x63, 0x00, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x18, 0x18, 0x7E, 0xC3, 0xC0, 0xC0, 0xC3, 0x7E, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x1C, 0x36, 0x32, 0x30, 0x78, 0x30, 0x30, 0x30, 0x73, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0xC3, 0x66, 0x3C, 0x18, 0xFF, 0x18, 0xFF, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFC, 0x66, 0x66, 0x7C, 0x62, 0x66, 0x6F, 0x66, 0x66, 0xF3, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x0E, 0x1B, 0x18, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x18, 0x18, 0xD8, 0x70, 0x00, 0x00, 0x00,
|
||||
0x00, 0x0C, 0x18, 0x30, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x0C, 0x18, 0x30, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x0C, 0x18, 0x30, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x0C, 0x18, 0x30, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x3B, 0x6E, 0x00, 0x6E, 0x33, 0x33, 0x33, 0x33, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x3B, 0x6E, 0x00, 0x63, 0x73, 0x7B, 0x7F, 0x6F, 0x67, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x6C, 0x6C, 0x3E, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x38, 0x6C, 0x6C, 0x38, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x30, 0x63, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x60, 0x60, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x60, 0xE0, 0x63, 0x66, 0x6C, 0x18, 0x30, 0x6E, 0xC3, 0x06, 0x0C, 0x1F, 0x00, 0x00, 0x00,
|
||||
0x00, 0x60, 0xE0, 0x63, 0x66, 0x6C, 0x18, 0x33, 0x67, 0xCF, 0x1F, 0x03, 0x03, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x3C, 0x3C, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x1B, 0x36, 0x6C, 0x36, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x6C, 0x36, 0x1B, 0x36, 0x6C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x00, 0x00,
|
||||
0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x00, 0x00,
|
||||
0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xF8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0xF8, 0x18, 0xF8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xF6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x18, 0xF8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0xF6, 0x06, 0xF6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x06, 0xF6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0xF6, 0x06, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0xF8, 0x18, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0xF7, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xF7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0xF7, 0x00, 0xF7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x18, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xFF, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x18, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
|
||||
0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0x00, 0x00,
|
||||
0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x00, 0x00,
|
||||
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x3B, 0x6E, 0x6C, 0x6C, 0x6E, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x3E, 0x63, 0x7E, 0x63, 0x63, 0x7E, 0x60, 0x60, 0x20, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x7F, 0x63, 0x63, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x7F, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x7F, 0x63, 0x30, 0x18, 0x0C, 0x18, 0x30, 0x63, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x6C, 0x6C, 0x6C, 0x6C, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x33, 0x33, 0x33, 0x33, 0x3E, 0x30, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x3B, 0x6E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x7E, 0x18, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x1C, 0x36, 0x63, 0x63, 0x7F, 0x63, 0x63, 0x36, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x1C, 0x36, 0x63, 0x63, 0x63, 0x36, 0x36, 0x36, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x1E, 0x30, 0x18, 0x0C, 0x3E, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0xDB, 0xDB, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x03, 0x06, 0x7E, 0xDB, 0xDB, 0xF3, 0x7E, 0x60, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x1C, 0x30, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x30, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x18, 0x18, 0xFF, 0x18, 0x18, 0x18, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x30, 0x18, 0x0C, 0x06, 0x0C, 0x18, 0x30, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x0C, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0C, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x0E, 0x1B, 0x1B, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xD8, 0xD8, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x3B, 0x6E, 0x00, 0x3B, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x38, 0x6C, 0x6C, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x0F, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0xEC, 0x6C, 0x3C, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xD8, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x70, 0xD8, 0x30, 0x60, 0xC8, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
};
|
131
lib/8x8fnt.c
131
lib/8x8fnt.c
|
@ -1,131 +0,0 @@
|
|||
/* Police de caract鑽e fine 8x8 */
|
||||
static u8 font8x8 [2048] = {
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x81, 0xA5, 0x81, 0xBD, 0x99, 0x81, 0x7E,
|
||||
0x7E, 0xFF, 0xDB, 0xFF, 0xC3, 0xE7, 0xFF, 0x7E, 0x6C, 0xFE, 0xFE, 0xFE, 0x7C, 0x38, 0x10, 0x00,
|
||||
0x10, 0x38, 0x7C, 0xFE, 0x7C, 0x38, 0x10, 0x00, 0x38, 0x7C, 0x38, 0xFE, 0xFE, 0x7C, 0x38, 0x7C,
|
||||
0x10, 0x10, 0x38, 0x7C, 0xFE, 0x7C, 0x38, 0x7C, 0x00, 0x00, 0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00,
|
||||
0xFF, 0xFF, 0xE7, 0xC3, 0xC3, 0xE7, 0xFF, 0xFF, 0x00, 0x3C, 0x66, 0x42, 0x42, 0x66, 0x3C, 0x00,
|
||||
0xFF, 0xC3, 0x99, 0xBD, 0xBD, 0x99, 0xC3, 0xFF, 0x0F, 0x07, 0x0F, 0x7D, 0xCC, 0xCC, 0xCC, 0x78,
|
||||
0x3C, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x18, 0x3F, 0x33, 0x3F, 0x30, 0x30, 0x70, 0xF0, 0xE0,
|
||||
0x7F, 0x63, 0x7F, 0x63, 0x63, 0x67, 0xE6, 0xC0, 0x99, 0x5A, 0x3C, 0xE7, 0xE7, 0x3C, 0x5A, 0x99,
|
||||
0x80, 0xE0, 0xF8, 0xFE, 0xF8, 0xE0, 0x80, 0x00, 0x02, 0x0E, 0x3E, 0xFE, 0x3E, 0x0E, 0x02, 0x00,
|
||||
0x18, 0x3C, 0x7E, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x00,
|
||||
0x7F, 0xDB, 0xDB, 0x7B, 0x1B, 0x1B, 0x1B, 0x00, 0x3E, 0x63, 0x38, 0x6C, 0x6C, 0x38, 0xCC, 0x78,
|
||||
0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0x7E, 0x00, 0x18, 0x3C, 0x7E, 0x18, 0x7E, 0x3C, 0x18, 0xFF,
|
||||
0x18, 0x3C, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x00,
|
||||
0x00, 0x18, 0x0C, 0xFE, 0x0C, 0x18, 0x00, 0x00, 0x00, 0x30, 0x60, 0xFE, 0x60, 0x30, 0x00, 0x00,
|
||||
0x00, 0x00, 0xC0, 0xC0, 0xC0, 0xFE, 0x00, 0x00, 0x00, 0x24, 0x66, 0xFF, 0x66, 0x24, 0x00, 0x00,
|
||||
0x00, 0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 0x40, 0x00,
|
||||
0x90, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x50, 0xF8, 0x50, 0xF8, 0x50, 0x50, 0x00,
|
||||
0x20, 0x78, 0xA0, 0x70, 0x28, 0xF0, 0x20, 0x00, 0xC8, 0xC8, 0x10, 0x20, 0x40, 0x98, 0x98, 0x00,
|
||||
0x70, 0x88, 0x50, 0x20, 0x54, 0x88, 0x74, 0x00, 0x60, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x20, 0x40, 0x80, 0x80, 0x80, 0x40, 0x20, 0x00, 0x20, 0x10, 0x08, 0x08, 0x08, 0x10, 0x20, 0x00,
|
||||
0x00, 0x20, 0xA8, 0x70, 0x70, 0xA8, 0x20, 0x00, 0x00, 0x00, 0x20, 0x20, 0xF8, 0x20, 0x20, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00,
|
||||
0x70, 0x88, 0x98, 0xA8, 0xC8, 0x88, 0x70, 0x00, 0x40, 0xC0, 0x40, 0x40, 0x40, 0x40, 0xE0, 0x00,
|
||||
0x70, 0x88, 0x08, 0x10, 0x20, 0x40, 0xF8, 0x00, 0x70, 0x88, 0x08, 0x10, 0x08, 0x88, 0x70, 0x00,
|
||||
0x08, 0x18, 0x28, 0x48, 0xFC, 0x08, 0x08, 0x00, 0xF8, 0x80, 0x80, 0xF0, 0x08, 0x88, 0x70, 0x00,
|
||||
0x20, 0x40, 0x80, 0xF0, 0x88, 0x88, 0x70, 0x00, 0xF8, 0x08, 0x10, 0x20, 0x40, 0x40, 0x40, 0x00,
|
||||
0x70, 0x88, 0x88, 0x70, 0x88, 0x88, 0x70, 0x00, 0x70, 0x88, 0x88, 0x78, 0x08, 0x08, 0x70, 0x00,
|
||||
0x00, 0x00, 0x60, 0x60, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x60, 0x60, 0x20,
|
||||
0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x00, 0x00, 0x00, 0xF8, 0x00, 0xF8, 0x00, 0x00, 0x00,
|
||||
0x80, 0x40, 0x20, 0x10, 0x20, 0x40, 0x80, 0x00, 0x78, 0x84, 0x04, 0x08, 0x10, 0x00, 0x10, 0x00,
|
||||
0x70, 0x88, 0x88, 0xA8, 0xB8, 0x80, 0x78, 0x00, 0x20, 0x50, 0x88, 0x88, 0xF8, 0x88, 0x88, 0x00,
|
||||
0xF0, 0x88, 0x88, 0xF0, 0x88, 0x88, 0xF0, 0x00, 0x70, 0x88, 0x80, 0x80, 0x80, 0x88, 0x70, 0x00,
|
||||
0xF0, 0x88, 0x88, 0x88, 0x88, 0x88, 0xF0, 0x00, 0xF8, 0x80, 0x80, 0xE0, 0x80, 0x80, 0xF8, 0x00,
|
||||
0xF8, 0x80, 0x80, 0xE0, 0x80, 0x80, 0x80, 0x00, 0x70, 0x88, 0x80, 0x80, 0x98, 0x88, 0x78, 0x00,
|
||||
0x88, 0x88, 0x88, 0xF8, 0x88, 0x88, 0x88, 0x00, 0xE0, 0x40, 0x40, 0x40, 0x40, 0x40, 0xE0, 0x00,
|
||||
0x38, 0x10, 0x10, 0x10, 0x10, 0x90, 0x60, 0x00, 0x88, 0x90, 0xA0, 0xC0, 0xA0, 0x90, 0x88, 0x00,
|
||||
0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xF8, 0x00, 0x82, 0xC6, 0xAA, 0x92, 0x82, 0x82, 0x82, 0x00,
|
||||
0x84, 0xC4, 0xA4, 0x94, 0x8C, 0x84, 0x84, 0x00, 0x70, 0x88, 0x88, 0x88, 0x88, 0x88, 0x70, 0x00,
|
||||
0xF0, 0x88, 0x88, 0xF0, 0x80, 0x80, 0x80, 0x00, 0x70, 0x88, 0x88, 0x88, 0xA8, 0x90, 0x68, 0x00,
|
||||
0xF0, 0x88, 0x88, 0xF0, 0xA0, 0x90, 0x88, 0x00, 0x70, 0x88, 0x80, 0x70, 0x08, 0x88, 0x70, 0x00,
|
||||
0xF8, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x70, 0x00,
|
||||
0x88, 0x88, 0x88, 0x50, 0x50, 0x20, 0x20, 0x00, 0x82, 0x82, 0x82, 0x82, 0x92, 0x92, 0x6C, 0x00,
|
||||
0x88, 0x88, 0x50, 0x20, 0x50, 0x88, 0x88, 0x00, 0x88, 0x88, 0x88, 0x50, 0x20, 0x20, 0x20, 0x00,
|
||||
0xF8, 0x08, 0x10, 0x20, 0x40, 0x80, 0xF8, 0x00, 0xE0, 0x80, 0x80, 0x80, 0x80, 0x80, 0xE0, 0x00,
|
||||
0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0xE0, 0x20, 0x20, 0x20, 0x20, 0x20, 0xE0, 0x00,
|
||||
0x20, 0x50, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x00,
|
||||
0x40, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x08, 0x78, 0x88, 0x74, 0x00,
|
||||
0x80, 0x80, 0xB0, 0xC8, 0x88, 0xC8, 0xB0, 0x00, 0x00, 0x00, 0x70, 0x88, 0x80, 0x88, 0x70, 0x00,
|
||||
0x08, 0x08, 0x68, 0x98, 0x88, 0x98, 0x68, 0x00, 0x00, 0x00, 0x70, 0x88, 0xF8, 0x80, 0x70, 0x00,
|
||||
0x30, 0x48, 0x40, 0xE0, 0x40, 0x40, 0x40, 0x00, 0x00, 0x00, 0x34, 0x48, 0x48, 0x38, 0x08, 0x30,
|
||||
0x80, 0x80, 0xB0, 0xC8, 0x88, 0x88, 0x88, 0x00, 0x20, 0x00, 0x60, 0x20, 0x20, 0x20, 0x70, 0x00,
|
||||
0x10, 0x00, 0x30, 0x10, 0x10, 0x10, 0x90, 0x60, 0x80, 0x80, 0x88, 0x90, 0xA0, 0xD0, 0x88, 0x00,
|
||||
0xC0, 0x40, 0x40, 0x40, 0x40, 0x40, 0xE0, 0x00, 0x00, 0x00, 0xEC, 0x92, 0x92, 0x92, 0x92, 0x00,
|
||||
0x00, 0x00, 0xB0, 0xC8, 0x88, 0x88, 0x88, 0x00, 0x00, 0x00, 0x70, 0x88, 0x88, 0x88, 0x70, 0x00,
|
||||
0x00, 0x00, 0xB0, 0xC8, 0xC8, 0xB0, 0x80, 0x80, 0x00, 0x00, 0x68, 0x98, 0x98, 0x68, 0x08, 0x08,
|
||||
0x00, 0x00, 0xB0, 0xC8, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x78, 0x80, 0x70, 0x08, 0xF0, 0x00,
|
||||
0x40, 0x40, 0xE0, 0x40, 0x40, 0x50, 0x20, 0x00, 0x00, 0x00, 0x88, 0x88, 0x88, 0x98, 0x68, 0x00,
|
||||
0x00, 0x00, 0x88, 0x88, 0x88, 0x50, 0x20, 0x00, 0x00, 0x00, 0x82, 0x82, 0x92, 0x92, 0x6C, 0x00,
|
||||
0x00, 0x00, 0x88, 0x50, 0x20, 0x50, 0x88, 0x00, 0x00, 0x00, 0x88, 0x88, 0x98, 0x68, 0x08, 0x70,
|
||||
0x00, 0x00, 0xF8, 0x10, 0x20, 0x40, 0xF8, 0x00, 0x10, 0x20, 0x20, 0x40, 0x20, 0x20, 0x10, 0x00,
|
||||
0x40, 0x40, 0x40, 0x00, 0x40, 0x40, 0x40, 0x00, 0x40, 0x20, 0x20, 0x10, 0x20, 0x20, 0x40, 0x00,
|
||||
0x76, 0xDC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00,
|
||||
0x3E, 0x60, 0xC0, 0x60, 0x3E, 0x08, 0x04, 0x18, 0x00, 0x48, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x76,
|
||||
0x18, 0x20, 0x00, 0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x10, 0x28, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76,
|
||||
0x00, 0x48, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x30, 0x08, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76,
|
||||
0x48, 0x30, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x78, 0xCC, 0xC0, 0xCC, 0x78, 0x10, 0x08, 0x30,
|
||||
0x30, 0x48, 0x84, 0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x00, 0x48, 0x00, 0x78, 0xCC, 0xFC, 0xC0, 0x78,
|
||||
0x30, 0x08, 0x00, 0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x00, 0x48, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30,
|
||||
0x30, 0x48, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x60, 0x10, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30,
|
||||
0x48, 0x00, 0x30, 0x78, 0xCC, 0xCC, 0xFC, 0xCC, 0x30, 0x48, 0x30, 0x48, 0x84, 0xFC, 0x84, 0x84,
|
||||
0x18, 0x20, 0x00, 0xF8, 0x80, 0xF0, 0x80, 0xF8, 0x00, 0x00, 0x00, 0x66, 0x19, 0x77, 0x88, 0x77,
|
||||
0x00, 0x00, 0x00, 0x0F, 0x14, 0x3E, 0x44, 0x87, 0x30, 0x48, 0x84, 0x78, 0xCC, 0xCC, 0xCC, 0x78,
|
||||
0x00, 0x48, 0x00, 0x78, 0xCC, 0xCC, 0xCC, 0x78, 0x60, 0x10, 0x00, 0x78, 0xCC, 0xCC, 0xCC, 0x78,
|
||||
0x30, 0x48, 0x84, 0x00, 0xCC, 0xCC, 0xCC, 0x76, 0x60, 0x10, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x76,
|
||||
0x48, 0x00, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8, 0x44, 0x00, 0x38, 0x6C, 0xC6, 0xC6, 0x6C, 0x38,
|
||||
0x24, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x08, 0x1C, 0x28, 0x28, 0x1C, 0x08, 0x00,
|
||||
0x1C, 0x22, 0x20, 0x70, 0x20, 0x22, 0x5C, 0x00, 0x44, 0x28, 0x10, 0x10, 0x38, 0x10, 0x38, 0x10,
|
||||
0xF0, 0x88, 0x8A, 0xF7, 0x82, 0x82, 0x83, 0x00, 0x06, 0x08, 0x08, 0x3C, 0x10, 0x10, 0x60, 0x00,
|
||||
0x18, 0x20, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x18, 0x20, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30,
|
||||
0x18, 0x20, 0x00, 0x78, 0xCC, 0xCC, 0xCC, 0x78, 0x18, 0x20, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x76,
|
||||
0x80, 0x78, 0x04, 0xF8, 0xCC, 0xCC, 0xCC, 0xCC, 0x80, 0x7E, 0x01, 0xC6, 0xE6, 0xD6, 0xCE, 0xC6,
|
||||
0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x00, 0xFE, 0x00, 0x78, 0xCC, 0xCC, 0xCC, 0x78, 0x00, 0xFC,
|
||||
0x00, 0x00, 0x18, 0x18, 0x30, 0x60, 0x66, 0x3C, 0xFF, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00,
|
||||
0xFF, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x40, 0xC4, 0x48, 0x50, 0x26, 0x49, 0x82, 0x07,
|
||||
0x40, 0xC4, 0x48, 0x50, 0x26, 0x4A, 0x9F, 0x02, 0x00, 0x30, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30,
|
||||
0x00, 0x12, 0x24, 0x48, 0x90, 0x48, 0x24, 0x12, 0x00, 0x48, 0x24, 0x12, 0x09, 0x12, 0x24, 0x48,
|
||||
0x49, 0x00, 0x92, 0x00, 0x49, 0x00, 0x92, 0x00, 0x6D, 0x00, 0xB6, 0x00, 0x6D, 0x00, 0xB6, 0x00,
|
||||
0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
|
||||
0x10, 0x10, 0x10, 0x10, 0xF0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xF0, 0x10, 0xF0, 0x10, 0x10,
|
||||
0x28, 0x28, 0x28, 0x28, 0xE8, 0x28, 0x28, 0x28, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x28, 0x28, 0x28,
|
||||
0x00, 0x00, 0x00, 0xF0, 0x10, 0xF0, 0x10, 0x10, 0x28, 0x28, 0x28, 0xE8, 0x08, 0xE8, 0x28, 0x28,
|
||||
0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x00, 0x00, 0x00, 0xF8, 0x08, 0xE8, 0x28, 0x28,
|
||||
0x28, 0x28, 0x28, 0xE8, 0x08, 0xF8, 0x00, 0x00, 0x28, 0x28, 0x28, 0x28, 0xF8, 0x00, 0x00, 0x00,
|
||||
0x10, 0x10, 0x10, 0xF0, 0x10, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x10, 0x10, 0x10,
|
||||
0x10, 0x10, 0x10, 0x10, 0x1F, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0xFF, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x10, 0x10, 0x10,
|
||||
0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x10, 0x10, 0x10,
|
||||
0x10, 0x10, 0x10, 0x1F, 0x10, 0x1F, 0x10, 0x10, 0x28, 0x28, 0x28, 0x28, 0x3F, 0x28, 0x28, 0x28,
|
||||
0x28, 0x28, 0x28, 0x2F, 0x20, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x20, 0x2F, 0x28, 0x28,
|
||||
0x28, 0x28, 0x28, 0xEF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xEF, 0x28, 0x28,
|
||||
0x28, 0x28, 0x28, 0x2F, 0x20, 0x2F, 0x28, 0x28, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00,
|
||||
0x28, 0x28, 0x28, 0xEF, 0x00, 0xEF, 0x28, 0x28, 0x10, 0x10, 0x10, 0xFF, 0x00, 0xFF, 0x00, 0x00,
|
||||
0x28, 0x28, 0x28, 0x28, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x10, 0x10,
|
||||
0x00, 0x00, 0x00, 0x00, 0xFF, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x3F, 0x00, 0x00, 0x00,
|
||||
0x10, 0x10, 0x10, 0x1F, 0x10, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x10, 0x1F, 0x10, 0x10,
|
||||
0x00, 0x00, 0x00, 0x00, 0x3F, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0xFF, 0x28, 0x28, 0x28,
|
||||
0x10, 0x10, 0x10, 0xFF, 0x10, 0xFF, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xF0, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x1F, 0x10, 0x10, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,
|
||||
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x02, 0x34, 0x4C, 0x4C, 0x32, 0x00, 0x5C, 0x22, 0x22, 0x3C, 0x44, 0x44, 0x78,
|
||||
0x7E, 0x42, 0x42, 0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 0x00, 0x02, 0x7C, 0xA8, 0x28, 0x28, 0x44,
|
||||
0x00, 0x7E, 0x61, 0x30, 0x18, 0x08, 0x10, 0x20, 0x00, 0x00, 0x08, 0x7F, 0x88, 0x88, 0x88, 0x70,
|
||||
0x00, 0x00, 0x00, 0x22, 0x44, 0x44, 0x7A, 0x80, 0x00, 0x00, 0x00, 0x7C, 0x10, 0x10, 0x10, 0x10,
|
||||
0x00, 0x1C, 0x08, 0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00, 0x00, 0x38, 0x44, 0x44, 0x7C, 0x44, 0x44,
|
||||
0x3C, 0x66, 0xC3, 0xC3, 0xC3, 0x66, 0x24, 0x66, 0x0C, 0x10, 0x08, 0x1C, 0x22, 0x22, 0x22, 0x1C,
|
||||
0x00, 0x00, 0x00, 0x00, 0x6C, 0x92, 0x92, 0x6C, 0x00, 0x01, 0x1A, 0x26, 0x2A, 0x32, 0x2C, 0x40,
|
||||
0x00, 0x18, 0x20, 0x20, 0x30, 0x20, 0x20, 0x18, 0x00, 0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
|
||||
0x00, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00, 0x3E,
|
||||
0x00, 0x10, 0x08, 0x04, 0x08, 0x10, 0x00, 0x3E, 0x00, 0x04, 0x08, 0x10, 0x08, 0x04, 0x00, 0x3E,
|
||||
0x00, 0x06, 0x09, 0x09, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x48, 0x48, 0x30,
|
||||
0x00, 0x00, 0x08, 0x00, 0x3E, 0x00, 0x08, 0x00, 0x00, 0x60, 0x92, 0x0C, 0x60, 0x92, 0x0C, 0x00,
|
||||
0x60, 0x90, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x78, 0x30, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04, 0x04, 0xC8, 0x28, 0x10, 0x00,
|
||||
0x00, 0x00, 0x00, 0x7C, 0x42, 0x42, 0x42, 0x00, 0x18, 0x24, 0x08, 0x10, 0x3C, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x3E, 0x3E, 0x3E, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
};
|
156
lib/Kmemory.c
156
lib/Kmemory.c
|
@ -1,156 +0,0 @@
|
|||
/***********************************/
|
||||
/* Librairie Kmemory.c */
|
||||
/* 20 Mars 2007 */
|
||||
/***********************************/
|
||||
|
||||
#include <type.h>
|
||||
#include <Kmemory.h>
|
||||
|
||||
/* Structure table d'allocation memoire */
|
||||
typedef struct
|
||||
{
|
||||
UBYTE Used : 1; // = 0 -> La zone memoire est libre.
|
||||
// = 1 -> La zone memoire est utilisee.
|
||||
UBYTE Expand : 1; // = 0 -> Fin du bloc.
|
||||
// = 1 -> Le bloc se prolonge sur le bloc suivant.
|
||||
UBYTE UnUsed : 6; // Zone libre.
|
||||
} T_KernelMemoryMap;
|
||||
|
||||
|
||||
T_KernelMemoryMap * BlocAllocate = NULL; // Table d'allocation des blocs memoire.
|
||||
void * BaseDynAlloc = NULL; // Pointeur sur la zone memoire allouable.
|
||||
UDWORD MaxMemoryBlocs;
|
||||
|
||||
|
||||
// Initialisation du gestionnaire de memoire.
|
||||
void Kernel_InitMemory (void *DataMemory, UDWORD TotalMemorySize)
|
||||
{
|
||||
UDWORD Boucle;
|
||||
UDWORD TableBlocs;
|
||||
UDWORD TotalBlocs;
|
||||
|
||||
// Alignement des bloc de memoire a un multiple de MEMORY_BLOC_SIZE
|
||||
if ( (UDWORD)DataMemory % MEMORY_BLOC_SIZE != 0)
|
||||
{ DataMemory = ((void*) ((((UDWORD)DataMemory) / MEMORY_BLOC_SIZE) * MEMORY_BLOC_SIZE) + MEMORY_BLOC_SIZE ); };
|
||||
|
||||
TotalBlocs = (((void*)TotalMemorySize) - DataMemory) / MEMORY_BLOC_SIZE;
|
||||
TableBlocs = TotalBlocs / MEMORY_BLOC_SIZE;
|
||||
MaxMemoryBlocs = TotalBlocs - TableBlocs;
|
||||
BlocAllocate = (T_KernelMemoryMap *)DataMemory;
|
||||
BaseDynAlloc = DataMemory + (TableBlocs * MEMORY_BLOC_SIZE);
|
||||
|
||||
for (Boucle = 0; Boucle < MaxMemoryBlocs; Boucle++)
|
||||
{
|
||||
BlocAllocate [Boucle].Used = 0;
|
||||
BlocAllocate [Boucle].Expand = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Alloue SIZE blocs de memoire
|
||||
void * Kernel_mballoc(UDWORD Size)
|
||||
{
|
||||
UDWORD Counter = 0;
|
||||
UDWORD Base = 0;
|
||||
UDWORD Boucle, Boucle2;
|
||||
|
||||
if (Size == 0) return NULL;
|
||||
|
||||
for (Boucle = 0; Boucle < MaxMemoryBlocs; Boucle++)
|
||||
{
|
||||
if (BlocAllocate[Boucle].Used == 0) { Counter++; }
|
||||
else { Counter = 0; Base = Boucle + 1; }
|
||||
|
||||
if (Counter >= Size)
|
||||
{
|
||||
if (Base+Size > MaxMemoryBlocs) return NULL;
|
||||
for (Boucle2=Base; Boucle2 < (Base+Size); Boucle2++)
|
||||
{
|
||||
BlocAllocate[Boucle2].Used = 1;
|
||||
if (Boucle2+1 < (Base+Size) ) { BlocAllocate[Boucle2].Expand = 1; }
|
||||
else { BlocAllocate[Boucle2].Expand = 0; }
|
||||
}
|
||||
return ((void*) (BaseDynAlloc + (Base * MEMORY_BLOC_SIZE) ));
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Libere un bloc memoire
|
||||
int Kernel_mbfree (void *Adresse)
|
||||
{
|
||||
UDWORD Bloc;
|
||||
|
||||
if (((Adresse - BaseDynAlloc) % MEMORY_BLOC_SIZE) != 0) return -1;
|
||||
if ((((UDWORD)Adresse) % MEMORY_BLOC_SIZE) != 0) return -1;
|
||||
|
||||
Bloc = (Adresse - BaseDynAlloc) / MEMORY_BLOC_SIZE;
|
||||
|
||||
for (; BlocAllocate[Bloc].Expand == 1; Bloc++)
|
||||
{
|
||||
BlocAllocate[Bloc].Used = 0;
|
||||
BlocAllocate[Bloc].Expand = 0;
|
||||
}
|
||||
|
||||
BlocAllocate[Bloc].Used = 0;
|
||||
BlocAllocate[Bloc].Expand = 0;
|
||||
|
||||
return 0;
|
||||
};
|
||||
|
||||
void * Kernel_mbrealloc (void *Adresse, UDWORD Size)
|
||||
{
|
||||
UDWORD Bloc, Boucle, OldSize, CopySize;
|
||||
void * NewAdresse;
|
||||
|
||||
if (((Adresse - BaseDynAlloc) % MEMORY_BLOC_SIZE) != 0) return NULL;
|
||||
Bloc = (Adresse - BaseDynAlloc) / MEMORY_BLOC_SIZE;
|
||||
if (BlocAllocate[Bloc].Used == 0) return NULL;
|
||||
|
||||
for (Boucle = Bloc; BlocAllocate[Boucle].Expand == 1; Boucle++)
|
||||
{ if (Boucle >= MaxMemoryBlocs) break; };
|
||||
|
||||
OldSize = Boucle - Bloc + 1;
|
||||
|
||||
// Si pas de changement de taille de bloc, ...
|
||||
if ( Size == OldSize) return Adresse;
|
||||
|
||||
// Si on reduit le nombre de bloc, ...
|
||||
if ( Size < OldSize)
|
||||
{
|
||||
for (Boucle = (Bloc + Size); Boucle < (Bloc + OldSize) ; Boucle++)
|
||||
{
|
||||
BlocAllocate[Boucle].Used = 0;
|
||||
BlocAllocate[Boucle].Expand = 0;
|
||||
}
|
||||
BlocAllocate[Size-1].Expand = 0;
|
||||
return Adresse;
|
||||
}
|
||||
|
||||
// Si on augmente le nombre de bloc
|
||||
for (Boucle = (Bloc + OldSize); Boucle < (Bloc + Size) ; Boucle++)
|
||||
{
|
||||
// Si le bloc ne peut etre simplement agrandit, ...
|
||||
if ( BlocAllocate[Boucle].Used == 1 )
|
||||
{
|
||||
NewAdresse = Kernel_mballoc (Size);
|
||||
if (NewAdresse == NULL) return NULL;
|
||||
CopySize = (OldSize * MEMORY_BLOC_SIZE) / sizeof (int64);
|
||||
for (Boucle = 0; Boucle < CopySize; Boucle++)
|
||||
{ ((int64*) NewAdresse)[Boucle] = ((int64*) Adresse)[Boucle]; };
|
||||
Kernel_mbfree (Adresse);
|
||||
return NewAdresse;
|
||||
}
|
||||
}
|
||||
|
||||
// Le bloc est simplement agrandit
|
||||
for (Boucle = (Bloc + OldSize - 1); Boucle < (Bloc + Size) ; Boucle++)
|
||||
{
|
||||
BlocAllocate[Boucle].Used = 1;
|
||||
BlocAllocate[Boucle].Expand = 1;
|
||||
}
|
||||
BlocAllocate[Size-1].Expand = 0;
|
||||
return Adresse;
|
||||
}
|
||||
|
||||
#undef MAX_MEMORY_BLOCS
|
236
lib/LDT.c
236
lib/LDT.c
|
@ -1,236 +0,0 @@
|
|||
/***********************************/
|
||||
/* Librairie LDT.c */
|
||||
/* 23 Mars 2007 */
|
||||
/***********************************/
|
||||
|
||||
#include "LDT.h"
|
||||
#include "Kmemory.h"
|
||||
|
||||
# define LDT_MANAGER_SIZE (127)
|
||||
|
||||
typedef struct // Structure de gestion des bloc LDT
|
||||
{
|
||||
void * Next; // Pointeur de chainage
|
||||
UDWORD Empty;
|
||||
T_LDT_reg LDTdesc [LDT_MANAGER_SIZE]; // Nombre de blocs LDT
|
||||
} T_LDT_Manager;
|
||||
|
||||
void LDT_initalloc (void *AllocTable, UDWORD Index, UDWORD SetSize, UDWORD TotalSize);
|
||||
T_LDT_Manager * LDT_mballoc (UWORD Size);
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
|
||||
T_LDT_Manager * LDT_Manager = NULL;
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
|
||||
T_LDT * LDT_balloc (UWORD Size) // Alloue un bloc de Size LDT
|
||||
{
|
||||
UWORD Boucle;
|
||||
UDWORD Blocs, Boucle2;
|
||||
T_LDT_Manager * * ptr_Manager = &LDT_Manager;
|
||||
T_LDT_Manager * Manager = LDT_Manager;
|
||||
|
||||
do
|
||||
{
|
||||
if (* ptr_Manager == NULL)
|
||||
{
|
||||
* ptr_Manager = Kernel_mballoc (1);
|
||||
Manager = * ptr_Manager;
|
||||
Manager->Next = NULL;
|
||||
for (Boucle = 0; Boucle < LDT_MANAGER_SIZE; Boucle++)
|
||||
{
|
||||
Manager->LDTdesc [Boucle].Adresse = NULL;
|
||||
Manager->LDTdesc [Boucle].Size = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
for (Boucle = 0; Boucle < LDT_MANAGER_SIZE; Boucle++)
|
||||
{
|
||||
if (Manager->LDTdesc [Boucle].Adresse == NULL)
|
||||
{
|
||||
|
||||
Blocs = Size * sizeof(T_LDT);
|
||||
if (Blocs % MEMORY_BLOC_SIZE == 0)
|
||||
{ Blocs /= MEMORY_BLOC_SIZE; } else { Blocs = (Blocs / MEMORY_BLOC_SIZE) + 1; }
|
||||
Manager->LDTdesc [Boucle].Adresse = Kernel_mballoc (Blocs);
|
||||
if (Manager->LDTdesc [Boucle].Adresse == NULL) return NULL;
|
||||
Manager->LDTdesc [Boucle].Size = (Blocs * MEMORY_BLOC_SIZE) / sizeof(T_LDT);
|
||||
|
||||
// Mise a zero de la LDT
|
||||
for (Boucle2 = 0; Boucle2 < Manager->LDTdesc [Boucle].Size; Boucle2++)
|
||||
{ ((int64*) Manager->LDTdesc [Boucle].Adresse)[Boucle2] = NULL; }
|
||||
|
||||
return Manager->LDTdesc [Boucle].Adresse;
|
||||
}
|
||||
}
|
||||
|
||||
*ptr_Manager = Manager;
|
||||
Manager = Manager->Next;
|
||||
} while (1);
|
||||
}
|
||||
|
||||
|
||||
int LDT_bfree (void * Adresse) // Libere un bloc LDT
|
||||
{
|
||||
UWORD Boucle, Boucle2;
|
||||
int RetVal;
|
||||
T_LDT_Manager * * ptr_Manager = &LDT_Manager;
|
||||
T_LDT_Manager * Manager = LDT_Manager;
|
||||
|
||||
do
|
||||
{
|
||||
if (*ptr_Manager == NULL) { return -1; }
|
||||
for (Boucle = 0; Boucle < LDT_MANAGER_SIZE; Boucle++)
|
||||
{
|
||||
if (Manager->LDTdesc [Boucle].Adresse == Adresse)
|
||||
{
|
||||
|
||||
RetVal = Kernel_mbfree(Manager->LDTdesc [Boucle].Adresse);
|
||||
if (Boucle == 0)
|
||||
{
|
||||
Kernel_mbfree (*ptr_Manager);
|
||||
*ptr_Manager = NULL;
|
||||
return RetVal;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (Boucle2 = Boucle; Boucle2 < LDT_MANAGER_SIZE-1; Boucle2++)
|
||||
{ Manager->LDTdesc [Boucle2] = Manager->LDTdesc [Boucle2+1]; }
|
||||
|
||||
Manager->LDTdesc [Boucle2+1].Size = NULL;
|
||||
Manager->LDTdesc [Boucle2+1].Adresse = NULL;
|
||||
}
|
||||
|
||||
Manager->LDTdesc [LDT_MANAGER_SIZE-1].Size = NULL;
|
||||
Manager->LDTdesc [LDT_MANAGER_SIZE-1].Adresse = NULL;
|
||||
|
||||
return RetVal;
|
||||
}
|
||||
}
|
||||
|
||||
*ptr_Manager = Manager;
|
||||
Manager = Manager->Next;
|
||||
} while (1);
|
||||
|
||||
}
|
||||
|
||||
T_LDT * LDT_brealloc (T_LDT * OldLDT, UWORD NewSize)
|
||||
{
|
||||
T_LDT * NewLDT;
|
||||
UDWORD Blocs;
|
||||
UWORD Boucle;
|
||||
|
||||
T_LDT_Manager * * ptr_Manager = &LDT_Manager;
|
||||
T_LDT_Manager * Manager = LDT_Manager;
|
||||
Blocs = NewSize * sizeof(T_LDT);
|
||||
|
||||
if (Blocs % MEMORY_BLOC_SIZE == 0)
|
||||
{ Blocs /= MEMORY_BLOC_SIZE; } else { Blocs = (Blocs / MEMORY_BLOC_SIZE) + 1; }
|
||||
|
||||
do
|
||||
{
|
||||
if (*ptr_Manager == NULL) { return NULL; }
|
||||
for (Boucle = 0; Boucle < LDT_MANAGER_SIZE; Boucle++)
|
||||
{
|
||||
if (Manager->LDTdesc [Boucle].Adresse == OldLDT)
|
||||
{
|
||||
NewLDT = Kernel_mbrealloc (OldLDT, Blocs);
|
||||
if (NewLDT == NULL) return NULL;
|
||||
Manager->LDTdesc [Boucle].Adresse = NewLDT;
|
||||
Manager->LDTdesc [Boucle].Size = NewSize;
|
||||
return NewLDT;
|
||||
}
|
||||
}
|
||||
|
||||
*ptr_Manager = Manager;
|
||||
Manager = Manager->Next;
|
||||
} while (1);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////
|
||||
|
||||
T_LDT * LDT_AllocLDT (T_LDT *BaseLDT)
|
||||
{
|
||||
UWORD Boucle;
|
||||
UDWORD Boucle2;
|
||||
UDWORD Size;
|
||||
T_LDT_Manager * Manager = LDT_Manager;
|
||||
|
||||
if (BaseLDT == NULL) return NULL;
|
||||
|
||||
do
|
||||
{
|
||||
if (Manager == NULL) { return NULL; }
|
||||
for (Boucle = 0; Boucle < LDT_MANAGER_SIZE; Boucle++)
|
||||
{
|
||||
Size = Manager->LDTdesc [Boucle].Size;
|
||||
if (Manager->LDTdesc [Boucle].Adresse == ((void*)BaseLDT) )
|
||||
{
|
||||
for (Boucle2 = 1; Boucle2 < Size; Boucle2++) // Le 1e LDT reste null
|
||||
{
|
||||
if ( BaseLDT[Boucle2].UserDefine == 0 )
|
||||
{
|
||||
BaseLDT[Boucle2].UserDefine = 1;
|
||||
return BaseLDT+Boucle2;
|
||||
};
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
Manager = Manager->Next;
|
||||
} while (1);
|
||||
}
|
||||
|
||||
int LDT_FreeLDT (T_LDT *LDT) // Marque le LDT comme non utilise et le met a NULL
|
||||
{
|
||||
if ( ((UDWORD)LDT & 0x07L) != NULL) { return -2; }
|
||||
if (LDT->UserDefine == 0) { return -1; }
|
||||
*((int64*)LDT) = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////
|
||||
|
||||
int LDT_MapMemory (T_LDT *LDT, void * Linear, UDWORD Size, UBYTE Granularite, UBYTE DPL, UBYTE Type, UBYTE CPUMode)
|
||||
{
|
||||
if ( ((UDWORD)LDT & 0x07L) != NULL) { return -2; }
|
||||
|
||||
LDT->Adresse_0_15 = (DWORD)Linear & 0x0000FFFFL;
|
||||
LDT->Adresse_16_23 = ((DWORD)Linear >> 16) & 0x000000FFL;
|
||||
LDT->Adresse_24_31 = ((DWORD)Linear >> 24) & 0x000000FFL;
|
||||
LDT->Limite_0_15 = Size & 0x0000FFFFL;
|
||||
LDT->Limite_16_19 = (Size >> 16) & 0x0000000FL;
|
||||
LDT->Granularite = Granularite;
|
||||
LDT->Type = Type;
|
||||
LDT->DPL = DPL;
|
||||
LDT->CPUMode = CPUMode;
|
||||
LDT->Present = 1;
|
||||
LDT->UserDefine = 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int LDT_load (T_LDT *LDT)
|
||||
{
|
||||
UWORD Boucle;
|
||||
T_LDT_Manager * * ptr_Manager = &LDT_Manager;
|
||||
T_LDT_Manager * Manager = LDT_Manager;
|
||||
|
||||
do
|
||||
{
|
||||
if (*ptr_Manager == NULL) { return -1; }
|
||||
for (Boucle = 0; Boucle < LDT_MANAGER_SIZE; Boucle++)
|
||||
{
|
||||
if (Manager->LDTdesc [Boucle].Adresse == LDT)
|
||||
{
|
||||
asm("lgdt %0\n" : : "m" (Manager->LDTdesc [Boucle]));
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
*ptr_Manager = Manager;
|
||||
Manager = Manager->Next;
|
||||
} while (1);
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,196 @@
|
|||
static pciclass old[] = {
|
||||
{0x0, "Pre-2.0 PCI Specification Device, Non-VGA"},
|
||||
{0x1, "Pre-2.0 PCI Specification Device, VGA Compatible"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass storage[] = {
|
||||
{0x00, "Mass Storage Controller, SCSI"},
|
||||
{0x01, "Mass Storage Controller, IDE"},
|
||||
{0x02, "Mass Storage Controller, Floppy"},
|
||||
{0x03, "Mass Storage Controller, IPI"},
|
||||
{0x04, "Mass Storage Controller, RAID"},
|
||||
{0x05, "Mass Storage Controller, ATA controller with single DMA"},
|
||||
{0x06, "Mass Storage Controller, SATA"},
|
||||
{0x07, "Mass Storage Controller, SAS"},
|
||||
{0x08, "Mass Storage Controller, NVM"},
|
||||
{0x80, "Mass Storage Controller, Other"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass network[] = {
|
||||
{0x00, "Network Controller, Ethernet"},
|
||||
{0x01, "Network Controller, Token Ring"},
|
||||
{0x02, "Network Controller, FDDI"},
|
||||
{0x03, "Network Controller, ATM"},
|
||||
{0x04, "Network Controller, ISDN"},
|
||||
{0x80, "Network Controller, Other"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass display[] = {
|
||||
{0x00, "Display Controller, VGA"},
|
||||
{0x01, "Display Controller, XGA"},
|
||||
{0x02, "Display Controller, 3D"},
|
||||
{0x80, "Display Controller, Other"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass multimedia[] = {
|
||||
{0x00, "Multimedia Device, Video"},
|
||||
{0x01, "Multimedia Device, Audio"},
|
||||
{0x02, "Multimedia Device, Telephony"},
|
||||
{0x03, "Multimedia Device, HDA"},
|
||||
{0x80, "Multimedia Device, Other"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass memory[] = {
|
||||
{0x00, "Memory Controller, RAM"},
|
||||
{0x01, "Memory Controller, Flash"},
|
||||
{0x80, "Memory Controller, Other"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass bridge[] = {
|
||||
{0x00, "Bridge Device, Host/PCI"},
|
||||
{0x01, "Bridge Device, PCI/ISA"},
|
||||
{0x02, "Bridge Device, PCI/EISA"},
|
||||
{0x03, "Bridge Device, PCI/Micro Channel"},
|
||||
{0x04, "Bridge Device, PCI/PCI"},
|
||||
{0x05, "Bridge Device, PCI/PCMCIA"},
|
||||
{0x06, "Bridge Device, PCI/NuBus"},
|
||||
{0x07, "Bridge Device, PCI/CardBus"},
|
||||
{0x08, "Bridge Device, PCI/RACEway"},
|
||||
{0x09, "Bridge Device, PCI/Transparent"},
|
||||
{0x0a, "Bridge Device, Infiniband"},
|
||||
{0x80, "Bridge Device, Other"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass simplecomm[] = {
|
||||
{0x00, "Simple Communications Controller, Serial"},
|
||||
{0x01, "Simple Communications Controller, Parallel"},
|
||||
{0x02, "Simple Communications Controller, Multiport"},
|
||||
{0x03, "Simple Communications Controller, Modem"},
|
||||
{0x04, "Simple Communications Controller, GPIB"},
|
||||
{0x05, "Simple Communications Controller, Smart Card"},
|
||||
{0x80, "Simple Communications Controller, Other"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass baseperiph[] = {
|
||||
{0x00, "Base Systems Peripheral, Interrupt Controller"},
|
||||
{0x01, "Base Systems Peripheral, DMA"},
|
||||
{0x02, "Base Systems Peripheral, System Timer"},
|
||||
{0x03, "Base Systems Peripheral, Real Time Clock"},
|
||||
{0x04, "Base Systems Peripheral, PCI Hot-plug"},
|
||||
{0x05, "Base Systems Peripheral, SD Host Controller"},
|
||||
{0x06, "Base Systems Peripheral, IOMMU"},
|
||||
{0x80, "Base Systems Peripheral, Other"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass input[] = {
|
||||
{0x00, "Input Device, Keyboard"},
|
||||
{0x01, "Input Device, Digitizer"},
|
||||
{0x02, "Input Device, Mouse"},
|
||||
{0x03, "Input Device, Scanner"},
|
||||
{0x04, "Input Device, Game Port"},
|
||||
{0x80, "Input Device, Other"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass docking[] = {
|
||||
{0x00, "Docking Station, Generic"},
|
||||
{0x80, "Docking Station, Other"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass processor[] = {
|
||||
{0x00, "Processor, i386"},
|
||||
{0x01, "Processor, i486"},
|
||||
{0x02, "Processor, Pentium"},
|
||||
{0x10, "Processor, Alpha"},
|
||||
{0x20, "Processor, Power PC"},
|
||||
{0x80, "Processor, Co-processor"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass serial[] = {
|
||||
{0x00, "Serial Bus Controller, Firewire"},
|
||||
{0x01, "Serial Bus Controller, ACCESS.bus"},
|
||||
{0x02, "Serial Bus Controller, SSA"},
|
||||
{0x03, "Serial Bus Controller, USB"},
|
||||
{0x04, "Serial Bus Controller, Fibre Channel"},
|
||||
{0x05, "Serial Bus Controller, SMBus"},
|
||||
{0x06, "Serial Bus Controller, Inifiniband"},
|
||||
{0x07, "Serial Bus Controller, IPMI"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass wireless[] = {
|
||||
{0x00, "Wireless Controller, iRDA"},
|
||||
{0x01, "Wireless Controller, IR"},
|
||||
{0x10, "Wireless Controller, RF"},
|
||||
{0x11, "Wireless Controller, Bluetooth"},
|
||||
{0x12, "Wireless Controller, Broadband"},
|
||||
{0x20, "Wireless Controller, 802.11a"},
|
||||
{0x21, "Wireless Controller, 802.11b"},
|
||||
{0x80, "Wireless Controller, Other"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass intelliio[] = {
|
||||
{0x00, "Intelligent IO Controller, I2O"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass satcomm[] = {
|
||||
{0x00, "Satellite Communication Controller, TV"},
|
||||
{0x01, "Satellite Communication Controller, Audio"},
|
||||
{0x02, "Satellite Communication Controller, Voice"},
|
||||
{0x03, "Satellite Communication Controller, Data"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass crypto[] = {
|
||||
{0x00, "Encryption/Decryption Controller, Network/computer"},
|
||||
{0x01, "Encryption/Decryption Controller, Entertainment"},
|
||||
{0x80, "Encryption/Decryption Controller, Other"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass dasp[] = {
|
||||
{0x00, "Data Acquisition and Signal Processing Controller, DPIO"},
|
||||
{0x01,
|
||||
"Data Acquisition and Signal Processing Controller, Performance Counter"},
|
||||
{0x10,
|
||||
"Data Acquisition and Signal Processing Controller, Communications Synchronization"},
|
||||
{0x20,
|
||||
"Data Acquisition and Signal Processing Controller, Management Card"},
|
||||
{0x80, "Data Acquisition and Signal Processing Controller, Other"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static pciclass *classcodes[] = {
|
||||
old,
|
||||
storage,
|
||||
network,
|
||||
display,
|
||||
multimedia,
|
||||
memory,
|
||||
bridge,
|
||||
simplecomm,
|
||||
baseperiph,
|
||||
input,
|
||||
docking,
|
||||
processor,
|
||||
serial,
|
||||
wireless,
|
||||
intelliio,
|
||||
satcomm,
|
||||
crypto,
|
||||
dasp,
|
||||
[255] = NULL
|
||||
};
|
|
@ -0,0 +1,673 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
|
||||
/* Police de caractère fine 8x16 */
|
||||
static u8 font8x16[4096] = {
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x7E, 0x81, 0xA5, 0x81, 0x81, 0xBD, 0x99, 0x81, 0x7E,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x7E, 0xFF, 0xDB, 0xFF, 0xFF, 0xC3, 0xE7, 0xFF,
|
||||
0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x36, 0x7F, 0x7F, 0x7F, 0x7F, 0x3E,
|
||||
0x1C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x08, 0x1C, 0x3E, 0x7F, 0x3E,
|
||||
0x1C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x3C, 0x3C, 0xE7, 0xE7,
|
||||
0xE7, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x3C, 0x7E, 0xFF,
|
||||
0xFF, 0x7E, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0xFF, 0xFF, 0xFF, 0xFF,
|
||||
0xFF, 0xE7, 0xC3, 0xC3, 0xE7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x66, 0x42, 0x42, 0x66, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0xFF, 0xFF,
|
||||
0xFF, 0xFF, 0xC3, 0x99, 0xBD, 0xBD, 0x99, 0xC3, 0xFF, 0xFF, 0xFF,
|
||||
0xFF, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x0F, 0x07, 0x0D, 0x19, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
|
||||
0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x18, 0x18,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x3F, 0x33, 0x3F, 0x30, 0x30, 0x30, 0x70, 0xF0, 0xE0,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x7F, 0x63, 0x7F, 0x63, 0x63, 0x63, 0x67, 0xE7, 0xE6,
|
||||
0xC0, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x18, 0xDB, 0x3C, 0xE7, 0x3C, 0xDB, 0x18, 0x18,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x40, 0x60, 0x70, 0x7C, 0x7F, 0x7C, 0x70, 0x60, 0x40,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x01, 0x03, 0x07, 0x1F, 0x7F, 0x1F, 0x07, 0x03,
|
||||
0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x3C, 0x7E, 0x18, 0x18, 0x18, 0x7E,
|
||||
0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
|
||||
0x00, 0x33, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x7F, 0xDB, 0xDB, 0xDB, 0x7B,
|
||||
0x1B, 0x1B, 0x1B, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3E, 0x63, 0x30, 0x1C, 0x36,
|
||||
0x63, 0x63, 0x36, 0x1C, 0x06, 0x63, 0x3E, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x7F, 0x7F, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x3C,
|
||||
0x7E, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x7E, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x18,
|
||||
0x3C, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x0C, 0x06, 0x7F, 0x06, 0x0C, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
|
||||
0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x7F, 0x30, 0x18, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60, 0x60, 0x7F, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x24, 0x66, 0xFF, 0x66, 0x24, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x08, 0x1C, 0x1C, 0x3E, 0x3E, 0x7F, 0x7F, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x7F, 0x7F, 0x3E, 0x3E, 0x1C, 0x1C, 0x08, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00,
|
||||
0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x24, 0x24, 0x24, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x42, 0x42, 0x42, 0xFF, 0x42, 0x42,
|
||||
0x42, 0xFF, 0x42, 0x42, 0x42, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x10, 0x7E, 0x90, 0x90, 0x90,
|
||||
0x7C, 0x12, 0x12, 0x12, 0xFC, 0x10, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x61, 0x91, 0x92,
|
||||
0x64, 0x08, 0x10, 0x26, 0x49, 0x89, 0x86, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x70, 0x88, 0x88,
|
||||
0x88, 0x50, 0x60, 0x91, 0x8A, 0x84, 0x4A, 0x31, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x18, 0x18,
|
||||
0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x06,
|
||||
0x18, 0x20, 0x40, 0x40, 0x40, 0x40, 0x40, 0x20, 0x18, 0x06, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x60, 0x18, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x04, 0x18, 0x60,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
|
||||
0x00, 0x00, 0x10, 0x92, 0x54, 0x38, 0xFE, 0x38, 0x54, 0x92, 0x10,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0xFE, 0x10, 0x10, 0x10, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
|
||||
0x18, 0x10,
|
||||
0x20, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
|
||||
0x18, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x01, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40,
|
||||
0x80, 0x80, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x83, 0x85, 0x89, 0x91, 0xA1, 0xC1,
|
||||
0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x10, 0x30, 0x50, 0x10, 0x10, 0x10, 0x10,
|
||||
0x10, 0x10, 0x10, 0x7C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x01, 0x02, 0x3C,
|
||||
0x40, 0x80, 0x80, 0x80, 0xFF, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x01, 0x02,
|
||||
0x3C, 0x02, 0x01, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x02, 0x06, 0x0A, 0x12,
|
||||
0x22, 0x42, 0x82, 0xFF, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFF, 0x80, 0x80,
|
||||
0x80, 0xFC, 0x02, 0x01, 0x01, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x3C, 0x42,
|
||||
0x81, 0x80, 0xBC, 0xC2, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0xFF,
|
||||
0x81, 0x01, 0x02, 0x04, 0x08, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x3C, 0x42, 0x81, 0x81, 0x42, 0x3C, 0x42, 0x81, 0x81, 0x42, 0x3C,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
|
||||
0x00, 0x3C, 0x42, 0x81, 0x81, 0x43, 0x3D, 0x01, 0x01, 0x81, 0x42,
|
||||
0x3C, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18,
|
||||
0x18, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18,
|
||||
0x18, 0x10,
|
||||
0x20, 0x00, 0x00,
|
||||
0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x20, 0x10, 0x08, 0x04,
|
||||
0x02,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x04, 0x08, 0x10,
|
||||
0x20, 0x40, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x38, 0x44, 0x82, 0x82, 0x04, 0x08, 0x10, 0x10,
|
||||
0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x99, 0xA5, 0xA5, 0xA5,
|
||||
0x9E, 0x80, 0x41, 0x3E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x18, 0x24, 0x42, 0x81, 0x81, 0xFF,
|
||||
0x81, 0x81, 0x81, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFC, 0x42, 0x41, 0x41, 0x42,
|
||||
0x7C, 0x42, 0x41, 0x41, 0x42, 0xFC, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x81,
|
||||
0x80, 0x80, 0x80, 0x80, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFC, 0x42, 0x41,
|
||||
0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x42, 0xFC, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0xFF, 0x80,
|
||||
0x80, 0x80, 0x80, 0xFC, 0x80, 0x80, 0x80, 0x80, 0xFF, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0xFF,
|
||||
0x80, 0x80, 0x80, 0x80, 0xFC, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x3C, 0x42, 0x81, 0x81, 0x80, 0x9F, 0x81, 0x81, 0x81, 0x42, 0x3C,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
|
||||
0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFF, 0x81, 0x81, 0x81, 0x81,
|
||||
0x81, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x38, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
|
||||
0x38, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x07, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x82, 0x82, 0x44,
|
||||
0x38, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x81, 0x82, 0x84, 0x88, 0x90, 0xE0, 0x90, 0x88, 0x84, 0x82,
|
||||
0x81,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
|
||||
0xFF, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x81, 0xC3, 0xA5, 0x99, 0x99, 0x81, 0x81, 0x81, 0x81,
|
||||
0x81, 0x81, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x81, 0xC1, 0xA1, 0x91, 0x89, 0x85, 0x83, 0x81,
|
||||
0x81, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x81, 0x81, 0x81, 0x81,
|
||||
0x81, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFC, 0x82, 0x81, 0x81, 0x82, 0xFC,
|
||||
0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81, 0x81, 0x81,
|
||||
0x81, 0x81, 0x89, 0x85, 0x42, 0x3D, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFC, 0x82, 0x81, 0x81,
|
||||
0x82, 0xFC, 0x90, 0x88, 0x84, 0x82, 0x81, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x42, 0x81,
|
||||
0x80, 0x40, 0x3C, 0x02, 0x01, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0xFE, 0x92,
|
||||
0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x81,
|
||||
0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x81, 0x81, 0x81, 0x81, 0x81, 0x42, 0x42, 0x24, 0x24, 0x18, 0x18,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
|
||||
0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x99, 0x99, 0xA5, 0xA5,
|
||||
0x42, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x81, 0x81, 0x81, 0x42, 0x24, 0x18, 0x24, 0x42, 0x81, 0x81,
|
||||
0x81, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x82, 0x82, 0x82, 0x82, 0x44, 0x28, 0x10, 0x10, 0x10, 0x10,
|
||||
0x10, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0xFF, 0x01, 0x01, 0x02, 0x04, 0x18, 0x20, 0x40, 0x80, 0x80,
|
||||
0xFF,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x7E, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
|
||||
0x7E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x80, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02,
|
||||
0x01, 0x01, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x7E, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
|
||||
0x02, 0x02, 0x7E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x18, 0x24, 0x42, 0x81, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
|
||||
0x00, 0x08, 0x04, 0x02, 0x01, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x7C, 0x02, 0x02, 0x7E, 0x82, 0x82, 0x7D, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x80, 0x80, 0x80,
|
||||
0x80, 0xBC, 0xC2, 0x81, 0x81, 0x81, 0xC2, 0xBC, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x3C, 0x42, 0x80, 0x80, 0x80, 0x42, 0x3C, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x01,
|
||||
0x01, 0x01, 0x01, 0x3D, 0x43, 0x81, 0x81, 0x81, 0x43, 0x3D, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x3C, 0x42, 0x81, 0xFF, 0x80, 0x40, 0x3E,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
|
||||
0x00, 0x0E, 0x11, 0x10, 0x10, 0xFE, 0x10, 0x10, 0x10, 0x10, 0x10,
|
||||
0x10, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x3D, 0x43, 0x81, 0x81, 0x43, 0x3D,
|
||||
0x01, 0x02, 0x7C,
|
||||
0x00, 0x00,
|
||||
0x00, 0x80, 0x80, 0x80, 0x80, 0xBC, 0xC2, 0x81, 0x81, 0x81, 0x81,
|
||||
0x81, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x08, 0x08, 0x00, 0x38, 0x08, 0x08, 0x08, 0x08, 0x08,
|
||||
0x3E,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x02, 0x02, 0x00, 0x06, 0x02, 0x02, 0x02, 0x02, 0x02,
|
||||
0x82, 0x44, 0x38, 0x00, 0x00,
|
||||
0x00, 0x80, 0x80, 0x80, 0x80, 0x82, 0x84, 0x88, 0x90, 0xA8,
|
||||
0xC4, 0x82, 0x00, 0x00, 0x00, 0x00,
|
||||
0x38, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
|
||||
0x08, 0x08, 0x3E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xEC, 0x92, 0x92,
|
||||
0x92, 0x92, 0x92, 0x92, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xB8, 0xC4,
|
||||
0x82, 0x82, 0x82, 0x82, 0x82, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x3C,
|
||||
0x42, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0xBC, 0xC2, 0x81, 0x81, 0x81, 0xC2, 0xBC, 0x80, 0x80, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3D, 0x43, 0x81, 0x81, 0x81, 0x43, 0x3D, 0x01, 0x01, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0xBE, 0xC1, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x7E, 0x81, 0x80, 0x7E, 0x01, 0x81, 0x7E, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x10,
|
||||
0x10, 0x10, 0x10, 0x10, 0xFE, 0x10, 0x10, 0x10, 0x10, 0x11, 0x0E,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0x43,
|
||||
0x3D, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x81, 0x81, 0x81, 0x42, 0x24,
|
||||
0x18, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x82, 0x92, 0x92, 0x92, 0xAA,
|
||||
0x44, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x42, 0x24, 0x18, 0x24, 0x42,
|
||||
0x81,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x81, 0x81, 0x81, 0x43, 0x3D,
|
||||
0x01, 0x02, 0x7C, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x02, 0x04, 0x18, 0x20,
|
||||
0x40, 0xFF, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x04, 0x08, 0x10, 0x10, 0x10, 0x20, 0x10, 0x10,
|
||||
0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x10,
|
||||
0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x40, 0x20, 0x10, 0x10, 0x10, 0x08,
|
||||
0x10, 0x10, 0x10, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x70, 0x99, 0x0E, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x08,
|
||||
0x1C, 0x36, 0x63, 0x63, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x1E, 0x33,
|
||||
0x61, 0x60, 0x60, 0x61, 0x33, 0x1E, 0x06, 0x03, 0x3E, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x66,
|
||||
0x66, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3B, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x06,
|
||||
0x0C, 0x18, 0x00, 0x3E, 0x63, 0x7F, 0x60, 0x63, 0x3E, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x08, 0x1C, 0x36, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
|
||||
0x00, 0x00, 0x66, 0x66, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x30, 0x18, 0x0C, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x1C, 0x36, 0x1C, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x3C, 0x66, 0x60, 0x66, 0x3C, 0x0C, 0x06,
|
||||
0x3C,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x08, 0x1C, 0x36, 0x00, 0x3E, 0x63, 0x7F, 0x60, 0x63, 0x3E,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x66, 0x66, 0x00, 0x3E, 0x63, 0x7F, 0x60, 0x63,
|
||||
0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x30, 0x18, 0x0C, 0x00, 0x3E, 0x63, 0x7F, 0x60,
|
||||
0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x66, 0x66, 0x00, 0x38, 0x18, 0x18,
|
||||
0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x18, 0x3C, 0x66, 0x00, 0x38, 0x18,
|
||||
0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x60, 0x30, 0x18, 0x00, 0x38,
|
||||
0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x63, 0x63, 0x08, 0x1C,
|
||||
0x36, 0x63, 0x63, 0x7F, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x1C, 0x36, 0x1C, 0x00,
|
||||
0x1C, 0x36, 0x63, 0x63, 0x7F, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x0C, 0x18, 0x30,
|
||||
0x00, 0x7F, 0x33, 0x30, 0x3E, 0x30, 0x33, 0x7F, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x6E, 0x3B, 0x1B, 0x7E, 0xD8, 0xDC, 0x77, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x1F, 0x36, 0x66, 0x66, 0x7F, 0x66, 0x66, 0x66, 0x67, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
|
||||
0x00, 0x08, 0x1C, 0x36, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x3E,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x63, 0x63, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x3E,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x30, 0x18, 0x0C, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x3E,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x18, 0x3C, 0x66, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3B,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x30, 0x18, 0x0C, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3B,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x63, 0x63, 0x00, 0x63, 0x63, 0x63, 0x63, 0x3F,
|
||||
0x03, 0x06, 0x3C, 0x00, 0x00, 0x00,
|
||||
0x00, 0x63, 0x63, 0x1C, 0x36, 0x63, 0x63, 0x63, 0x63,
|
||||
0x36, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x63, 0x63, 0x00, 0x63, 0x63, 0x63, 0x63,
|
||||
0x63, 0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x18, 0x18, 0x7E, 0xC3, 0xC0, 0xC0,
|
||||
0xC3, 0x7E, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x1C, 0x36, 0x32, 0x30, 0x78,
|
||||
0x30, 0x30, 0x30, 0x73, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0xC3, 0x66, 0x3C,
|
||||
0x18, 0xFF, 0x18, 0xFF, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFC, 0x66, 0x66,
|
||||
0x7C, 0x62, 0x66, 0x6F, 0x66, 0x66, 0xF3, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x0E, 0x1B,
|
||||
0x18, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x18, 0x18, 0xD8, 0x70, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x0C,
|
||||
0x18, 0x30, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x0C, 0x18, 0x30, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
|
||||
0x00, 0x0C, 0x18, 0x30, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x3E,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x0C, 0x18, 0x30, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3B,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x3B, 0x6E, 0x00, 0x6E, 0x33, 0x33, 0x33, 0x33, 0x33,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x3B, 0x6E, 0x00, 0x63, 0x73, 0x7B, 0x7F, 0x6F, 0x67, 0x63, 0x63,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x3C, 0x6C, 0x6C, 0x3E, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x38, 0x6C, 0x6C, 0x38, 0x00, 0x7C, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x30, 0x63,
|
||||
0x63, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x60,
|
||||
0x60, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F,
|
||||
0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x60, 0xE0, 0x63, 0x66, 0x6C,
|
||||
0x18, 0x30, 0x6E, 0xC3, 0x06, 0x0C, 0x1F, 0x00, 0x00, 0x00,
|
||||
0x00, 0x60, 0xE0, 0x63, 0x66,
|
||||
0x6C, 0x18, 0x33, 0x67, 0xCF, 0x1F, 0x03, 0x03, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x18,
|
||||
0x00, 0x18, 0x18, 0x3C, 0x3C, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x1B, 0x36, 0x6C, 0x36, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x6C, 0x36, 0x1B, 0x36, 0x6C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x11,
|
||||
0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44,
|
||||
0x11, 0x44, 0x00, 0x00,
|
||||
|
||||
0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55,
|
||||
0xAA, 0x55, 0xAA, 0x00,
|
||||
0x00,
|
||||
0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD,
|
||||
0x77, 0xDD, 0x77,
|
||||
0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
|
||||
0x18, 0x18,
|
||||
0x18, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xF8, 0x18, 0x18, 0x18,
|
||||
0x18,
|
||||
0x18, 0x18, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0xF8, 0x18, 0xF8, 0x18, 0x18, 0x18,
|
||||
0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xF6, 0x36, 0x36,
|
||||
0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x36,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x18, 0xF8,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0xF6, 0x06,
|
||||
0xF6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0xFE, 0x06, 0xF6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36,
|
||||
0x36, 0xF6, 0x06, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x36, 0x36, 0x36,
|
||||
0x36, 0x36, 0x36, 0x36, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x18, 0x18,
|
||||
0x18, 0x18, 0x18, 0xF8, 0x18, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x18, 0x18, 0x18, 0x18,
|
||||
0x18, 0x18, 0x00, 0x00,
|
||||
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x18, 0x18, 0x18,
|
||||
0x18, 0x18,
|
||||
0x18, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x18, 0x18,
|
||||
0x18,
|
||||
0x18, 0x18, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x18, 0x18,
|
||||
0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x1F, 0x18,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30,
|
||||
0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
|
||||
0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36,
|
||||
0xF7, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0xFF, 0x00, 0xF7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00,
|
||||
0x00,
|
||||
0x36, 0x36, 0x36,
|
||||
0x36, 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x36,
|
||||
0x36, 0x36, 0x36, 0x36, 0xF7, 0x00, 0xF7, 0x36, 0x36, 0x36, 0x36,
|
||||
0x36, 0x36, 0x00, 0x00,
|
||||
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xFF, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x18, 0x18, 0x18,
|
||||
0x18, 0x18,
|
||||
0x18, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x36, 0x36, 0x36,
|
||||
0x36,
|
||||
0x36, 0x36, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x3F, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x1F, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x18, 0x1F, 0x18,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
|
||||
0xFF, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0xFF,
|
||||
0x18, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18,
|
||||
0x18, 0x18, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00,
|
||||
0x00,
|
||||
0xFF, 0xFF, 0xFF,
|
||||
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
|
||||
0xFF, 0x00, 0x00,
|
||||
0xF0,
|
||||
0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
|
||||
0xF0, 0xF0, 0x00, 0x00,
|
||||
|
||||
0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
|
||||
0x0F, 0x0F, 0x0F, 0x00,
|
||||
0x00,
|
||||
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x3B, 0x6E, 0x6C, 0x6C, 0x6E, 0x3B,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x3E, 0x63, 0x7E, 0x63, 0x63, 0x7E, 0x60,
|
||||
0x60,
|
||||
0x20, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x7F, 0x63, 0x63, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x7F, 0x36, 0x36, 0x36, 0x36, 0x36,
|
||||
0x36, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x7F, 0x63, 0x30, 0x18, 0x0C, 0x18, 0x30,
|
||||
0x63, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x6C, 0x6C,
|
||||
0x6C, 0x6C, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x33, 0x33, 0x33,
|
||||
0x33, 0x3E, 0x30, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x3B, 0x6E,
|
||||
0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x7E, 0x18, 0x3C,
|
||||
0x66, 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x1C, 0x36,
|
||||
0x63, 0x63, 0x7F, 0x63, 0x63, 0x36, 0x1C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x1C,
|
||||
0x36, 0x63, 0x63, 0x63, 0x36, 0x36, 0x36, 0x77, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x1E, 0x30, 0x18, 0x0C, 0x3E, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x7E, 0xDB, 0xDB, 0x7E, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
|
||||
0x00, 0x00, 0x03, 0x06, 0x7E, 0xDB, 0xDB, 0xF3, 0x7E, 0x60, 0xC0,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x1C, 0x30, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x30, 0x1C,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x7F, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x18, 0x18, 0xFF, 0x18, 0x18, 0x18, 0x00, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x30, 0x18, 0x0C, 0x06, 0x0C, 0x18, 0x30, 0x00,
|
||||
0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x0C, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0C,
|
||||
0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x0E, 0x1B, 0x1B, 0x18, 0x18, 0x18,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00,
|
||||
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
|
||||
0x18, 0xD8, 0xD8, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x18, 0x18, 0x00, 0x00,
|
||||
0xFF, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x3B,
|
||||
0x6E, 0x00, 0x3B, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x38, 0x6C, 0x6C,
|
||||
0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x0F, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0xEC, 0x6C, 0x3C, 0x1C, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
|
||||
0x00, 0xD8, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x70, 0xD8, 0x30, 0x60, 0xC8, 0xF8, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x00,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x00
|
||||
};
|
|
@ -0,0 +1,336 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
|
||||
/* Police de caractère fine 8x8 */
|
||||
static u8 font8x8[2048] = {
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x81, 0xA5,
|
||||
0x81,
|
||||
0xBD, 0x99, 0x81, 0x7E,
|
||||
0x7E, 0xFF, 0xDB, 0xFF, 0xC3, 0xE7, 0xFF, 0x7E, 0x6C, 0xFE, 0xFE,
|
||||
0xFE, 0x7C, 0x38, 0x10, 0x00,
|
||||
0x10, 0x38, 0x7C, 0xFE, 0x7C, 0x38, 0x10, 0x00, 0x38, 0x7C,
|
||||
0x38, 0xFE, 0xFE, 0x7C, 0x38, 0x7C,
|
||||
0x10, 0x10, 0x38, 0x7C, 0xFE, 0x7C, 0x38, 0x7C, 0x00,
|
||||
0x00, 0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00,
|
||||
0xFF, 0xFF, 0xE7, 0xC3, 0xC3, 0xE7, 0xFF, 0xFF,
|
||||
0x00, 0x3C, 0x66, 0x42, 0x42, 0x66, 0x3C, 0x00,
|
||||
0xFF, 0xC3, 0x99, 0xBD, 0xBD, 0x99, 0xC3,
|
||||
0xFF, 0x0F, 0x07, 0x0F, 0x7D, 0xCC, 0xCC, 0xCC, 0x78,
|
||||
0x3C, 0x66, 0x66, 0x66, 0x3C, 0x18,
|
||||
0x7E, 0x18, 0x3F, 0x33, 0x3F, 0x30, 0x30, 0x70, 0xF0, 0xE0,
|
||||
0x7F, 0x63, 0x7F, 0x63, 0x63,
|
||||
0x67, 0xE6, 0xC0, 0x99, 0x5A, 0x3C, 0xE7, 0xE7, 0x3C, 0x5A, 0x99,
|
||||
0x80, 0xE0, 0xF8, 0xFE,
|
||||
0xF8, 0xE0, 0x80, 0x00, 0x02, 0x0E, 0x3E, 0xFE, 0x3E, 0x0E, 0x02,
|
||||
0x00,
|
||||
0x18, 0x3C, 0x7E,
|
||||
0x18, 0x18, 0x7E, 0x3C, 0x18, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00,
|
||||
0x66, 0x00,
|
||||
0x7F, 0xDB,
|
||||
0xDB, 0x7B, 0x1B, 0x1B, 0x1B, 0x00, 0x3E, 0x63, 0x38, 0x6C, 0x6C,
|
||||
0x38, 0xCC, 0x78,
|
||||
0x00,
|
||||
0x00, 0x00, 0x00, 0x7E, 0x7E, 0x7E, 0x00, 0x18, 0x3C, 0x7E, 0x18,
|
||||
0x7E, 0x3C, 0x18, 0xFF,
|
||||
|
||||
0x18, 0x3C, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18,
|
||||
0x18, 0x7E, 0x3C, 0x18,
|
||||
0x00,
|
||||
0x00, 0x18, 0x0C, 0xFE, 0x0C, 0x18, 0x00, 0x00, 0x00, 0x30, 0x60,
|
||||
0xFE, 0x60, 0x30,
|
||||
0x00, 0x00,
|
||||
0x00, 0x00, 0xC0, 0xC0, 0xC0, 0xFE, 0x00, 0x00, 0x00, 0x24, 0x66,
|
||||
0xFF, 0x66,
|
||||
0x24, 0x00, 0x00,
|
||||
0x00, 0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF,
|
||||
0x7E,
|
||||
0x3C, 0x18, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x40,
|
||||
0x40, 0x40, 0x00, 0x40, 0x00,
|
||||
0x90, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x50,
|
||||
0xF8, 0x50, 0xF8, 0x50, 0x50, 0x00,
|
||||
0x20, 0x78, 0xA0, 0x70, 0x28, 0xF0, 0x20, 0x00, 0xC8,
|
||||
0xC8, 0x10, 0x20, 0x40, 0x98, 0x98, 0x00,
|
||||
0x70, 0x88, 0x50, 0x20, 0x54, 0x88, 0x74, 0x00,
|
||||
0x60, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x20, 0x40, 0x80, 0x80, 0x80, 0x40, 0x20,
|
||||
0x00, 0x20, 0x10, 0x08, 0x08, 0x08, 0x10, 0x20, 0x00,
|
||||
0x00, 0x20, 0xA8, 0x70, 0x70, 0xA8,
|
||||
0x20, 0x00, 0x00, 0x00, 0x20, 0x20, 0xF8, 0x20, 0x20, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x60, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x60, 0x60, 0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
|
||||
0x00,
|
||||
0x70, 0x88, 0x98,
|
||||
0xA8, 0xC8, 0x88, 0x70, 0x00, 0x40, 0xC0, 0x40, 0x40, 0x40, 0x40,
|
||||
0xE0, 0x00,
|
||||
0x70, 0x88,
|
||||
0x08, 0x10, 0x20, 0x40, 0xF8, 0x00, 0x70, 0x88, 0x08, 0x10, 0x08,
|
||||
0x88, 0x70, 0x00,
|
||||
0x08,
|
||||
0x18, 0x28, 0x48, 0xFC, 0x08, 0x08, 0x00, 0xF8, 0x80, 0x80, 0xF0,
|
||||
0x08, 0x88, 0x70, 0x00,
|
||||
|
||||
0x20, 0x40, 0x80, 0xF0, 0x88, 0x88, 0x70, 0x00, 0xF8, 0x08, 0x10,
|
||||
0x20, 0x40, 0x40, 0x40,
|
||||
0x00,
|
||||
0x70, 0x88, 0x88, 0x70, 0x88, 0x88, 0x70, 0x00, 0x70, 0x88, 0x88,
|
||||
0x78, 0x08, 0x08,
|
||||
0x70, 0x00,
|
||||
0x00, 0x00, 0x60, 0x60, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00, 0x60,
|
||||
0x60, 0x00,
|
||||
0x60, 0x60, 0x20,
|
||||
0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x00, 0x00, 0x00, 0xF8,
|
||||
0x00,
|
||||
0xF8, 0x00, 0x00, 0x00,
|
||||
0x80, 0x40, 0x20, 0x10, 0x20, 0x40, 0x80, 0x00, 0x78, 0x84, 0x04,
|
||||
0x08, 0x10, 0x00, 0x10, 0x00,
|
||||
0x70, 0x88, 0x88, 0xA8, 0xB8, 0x80, 0x78, 0x00, 0x20, 0x50,
|
||||
0x88, 0x88, 0xF8, 0x88, 0x88, 0x00,
|
||||
0xF0, 0x88, 0x88, 0xF0, 0x88, 0x88, 0xF0, 0x00, 0x70,
|
||||
0x88, 0x80, 0x80, 0x80, 0x88, 0x70, 0x00,
|
||||
0xF0, 0x88, 0x88, 0x88, 0x88, 0x88, 0xF0, 0x00,
|
||||
0xF8, 0x80, 0x80, 0xE0, 0x80, 0x80, 0xF8, 0x00,
|
||||
0xF8, 0x80, 0x80, 0xE0, 0x80, 0x80, 0x80,
|
||||
0x00, 0x70, 0x88, 0x80, 0x80, 0x98, 0x88, 0x78, 0x00,
|
||||
0x88, 0x88, 0x88, 0xF8, 0x88, 0x88,
|
||||
0x88, 0x00, 0xE0, 0x40, 0x40, 0x40, 0x40, 0x40, 0xE0, 0x00,
|
||||
0x38, 0x10, 0x10, 0x10, 0x10,
|
||||
0x90, 0x60, 0x00, 0x88, 0x90, 0xA0, 0xC0, 0xA0, 0x90, 0x88, 0x00,
|
||||
0x80, 0x80, 0x80, 0x80,
|
||||
0x80, 0x80, 0xF8, 0x00, 0x82, 0xC6, 0xAA, 0x92, 0x82, 0x82, 0x82,
|
||||
0x00,
|
||||
0x84, 0xC4, 0xA4,
|
||||
0x94, 0x8C, 0x84, 0x84, 0x00, 0x70, 0x88, 0x88, 0x88, 0x88, 0x88,
|
||||
0x70, 0x00,
|
||||
0xF0, 0x88,
|
||||
0x88, 0xF0, 0x80, 0x80, 0x80, 0x00, 0x70, 0x88, 0x88, 0x88, 0xA8,
|
||||
0x90, 0x68, 0x00,
|
||||
0xF0,
|
||||
0x88, 0x88, 0xF0, 0xA0, 0x90, 0x88, 0x00, 0x70, 0x88, 0x80, 0x70,
|
||||
0x08, 0x88, 0x70, 0x00,
|
||||
|
||||
0xF8, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x88, 0x88, 0x88,
|
||||
0x88, 0x88, 0x88, 0x70,
|
||||
0x00,
|
||||
0x88, 0x88, 0x88, 0x50, 0x50, 0x20, 0x20, 0x00, 0x82, 0x82, 0x82,
|
||||
0x82, 0x92, 0x92,
|
||||
0x6C, 0x00,
|
||||
0x88, 0x88, 0x50, 0x20, 0x50, 0x88, 0x88, 0x00, 0x88, 0x88, 0x88,
|
||||
0x50, 0x20,
|
||||
0x20, 0x20, 0x00,
|
||||
0xF8, 0x08, 0x10, 0x20, 0x40, 0x80, 0xF8, 0x00, 0xE0, 0x80, 0x80,
|
||||
0x80,
|
||||
0x80, 0x80, 0xE0, 0x00,
|
||||
0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0xE0, 0x20, 0x20,
|
||||
0x20, 0x20, 0x20, 0xE0, 0x00,
|
||||
0x20, 0x50, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0xF8, 0x00,
|
||||
0x40, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x70, 0x08, 0x78, 0x88, 0x74, 0x00,
|
||||
0x80, 0x80, 0xB0, 0xC8, 0x88, 0xC8, 0xB0, 0x00,
|
||||
0x00, 0x00, 0x70, 0x88, 0x80, 0x88, 0x70, 0x00,
|
||||
0x08, 0x08, 0x68, 0x98, 0x88, 0x98, 0x68,
|
||||
0x00, 0x00, 0x00, 0x70, 0x88, 0xF8, 0x80, 0x70, 0x00,
|
||||
0x30, 0x48, 0x40, 0xE0, 0x40, 0x40,
|
||||
0x40, 0x00, 0x00, 0x00, 0x34, 0x48, 0x48, 0x38, 0x08, 0x30,
|
||||
0x80, 0x80, 0xB0, 0xC8, 0x88,
|
||||
0x88, 0x88, 0x00, 0x20, 0x00, 0x60, 0x20, 0x20, 0x20, 0x70, 0x00,
|
||||
0x10, 0x00, 0x30, 0x10,
|
||||
0x10, 0x10, 0x90, 0x60, 0x80, 0x80, 0x88, 0x90, 0xA0, 0xD0, 0x88,
|
||||
0x00,
|
||||
0xC0, 0x40, 0x40,
|
||||
0x40, 0x40, 0x40, 0xE0, 0x00, 0x00, 0x00, 0xEC, 0x92, 0x92, 0x92,
|
||||
0x92, 0x00,
|
||||
0x00, 0x00,
|
||||
0xB0, 0xC8, 0x88, 0x88, 0x88, 0x00, 0x00, 0x00, 0x70, 0x88, 0x88,
|
||||
0x88, 0x70, 0x00,
|
||||
0x00,
|
||||
0x00, 0xB0, 0xC8, 0xC8, 0xB0, 0x80, 0x80, 0x00, 0x00, 0x68, 0x98,
|
||||
0x98, 0x68, 0x08, 0x08,
|
||||
|
||||
0x00, 0x00, 0xB0, 0xC8, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x78,
|
||||
0x80, 0x70, 0x08, 0xF0,
|
||||
0x00,
|
||||
0x40, 0x40, 0xE0, 0x40, 0x40, 0x50, 0x20, 0x00, 0x00, 0x00, 0x88,
|
||||
0x88, 0x88, 0x98,
|
||||
0x68, 0x00,
|
||||
0x00, 0x00, 0x88, 0x88, 0x88, 0x50, 0x20, 0x00, 0x00, 0x00, 0x82,
|
||||
0x82, 0x92,
|
||||
0x92, 0x6C, 0x00,
|
||||
0x00, 0x00, 0x88, 0x50, 0x20, 0x50, 0x88, 0x00, 0x00, 0x00, 0x88,
|
||||
0x88,
|
||||
0x98, 0x68, 0x08, 0x70,
|
||||
0x00, 0x00, 0xF8, 0x10, 0x20, 0x40, 0xF8, 0x00, 0x10, 0x20, 0x20,
|
||||
0x40, 0x20, 0x20, 0x10, 0x00,
|
||||
0x40, 0x40, 0x40, 0x00, 0x40, 0x40, 0x40, 0x00, 0x40, 0x20,
|
||||
0x20, 0x10, 0x20, 0x20, 0x40, 0x00,
|
||||
0x76, 0xDC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00,
|
||||
0x3E, 0x60, 0xC0, 0x60, 0x3E, 0x08, 0x04, 0x18,
|
||||
0x00, 0x48, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x76,
|
||||
0x18, 0x20, 0x00, 0x78, 0xCC, 0xFC, 0xC0,
|
||||
0x78, 0x10, 0x28, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76,
|
||||
0x00, 0x48, 0x00, 0x78, 0x0C, 0x7C,
|
||||
0xCC, 0x76, 0x30, 0x08, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76,
|
||||
0x48, 0x30, 0x00, 0x78, 0x0C,
|
||||
0x7C, 0xCC, 0x76, 0x78, 0xCC, 0xC0, 0xCC, 0x78, 0x10, 0x08, 0x30,
|
||||
0x30, 0x48, 0x84, 0x78,
|
||||
0xCC, 0xFC, 0xC0, 0x78, 0x00, 0x48, 0x00, 0x78, 0xCC, 0xFC, 0xC0,
|
||||
0x78,
|
||||
0x30, 0x08, 0x00,
|
||||
0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x00, 0x48, 0x00, 0x30, 0x30, 0x30,
|
||||
0x30, 0x30,
|
||||
0x30, 0x48,
|
||||
0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x60, 0x10, 0x00, 0x30, 0x30,
|
||||
0x30, 0x30, 0x30,
|
||||
0x48,
|
||||
0x00, 0x30, 0x78, 0xCC, 0xCC, 0xFC, 0xCC, 0x30, 0x48, 0x30, 0x48,
|
||||
0x84, 0xFC, 0x84, 0x84,
|
||||
|
||||
0x18, 0x20, 0x00, 0xF8, 0x80, 0xF0, 0x80, 0xF8, 0x00, 0x00, 0x00,
|
||||
0x66, 0x19, 0x77, 0x88,
|
||||
0x77,
|
||||
0x00, 0x00, 0x00, 0x0F, 0x14, 0x3E, 0x44, 0x87, 0x30, 0x48, 0x84,
|
||||
0x78, 0xCC, 0xCC,
|
||||
0xCC, 0x78,
|
||||
0x00, 0x48, 0x00, 0x78, 0xCC, 0xCC, 0xCC, 0x78, 0x60, 0x10, 0x00,
|
||||
0x78, 0xCC,
|
||||
0xCC, 0xCC, 0x78,
|
||||
0x30, 0x48, 0x84, 0x00, 0xCC, 0xCC, 0xCC, 0x76, 0x60, 0x10, 0x00,
|
||||
0xCC,
|
||||
0xCC, 0xCC, 0xCC, 0x76,
|
||||
0x48, 0x00, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8, 0x44, 0x00, 0x38,
|
||||
0x6C, 0xC6, 0xC6, 0x6C, 0x38,
|
||||
0x24, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x08,
|
||||
0x1C, 0x28, 0x28, 0x1C, 0x08, 0x00,
|
||||
0x1C, 0x22, 0x20, 0x70, 0x20, 0x22, 0x5C, 0x00, 0x44,
|
||||
0x28, 0x10, 0x10, 0x38, 0x10, 0x38, 0x10,
|
||||
0xF0, 0x88, 0x8A, 0xF7, 0x82, 0x82, 0x83, 0x00,
|
||||
0x06, 0x08, 0x08, 0x3C, 0x10, 0x10, 0x60, 0x00,
|
||||
0x18, 0x20, 0x00, 0x78, 0x0C, 0x7C, 0xCC,
|
||||
0x76, 0x18, 0x20, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30,
|
||||
0x18, 0x20, 0x00, 0x78, 0xCC, 0xCC,
|
||||
0xCC, 0x78, 0x18, 0x20, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x76,
|
||||
0x80, 0x78, 0x04, 0xF8, 0xCC,
|
||||
0xCC, 0xCC, 0xCC, 0x80, 0x7E, 0x01, 0xC6, 0xE6, 0xD6, 0xCE, 0xC6,
|
||||
0x00, 0x78, 0x0C, 0x7C,
|
||||
0xCC, 0x76, 0x00, 0xFE, 0x00, 0x78, 0xCC, 0xCC, 0xCC, 0x78, 0x00,
|
||||
0xFC,
|
||||
0x00, 0x00, 0x18,
|
||||
0x18, 0x30, 0x60, 0x66, 0x3C, 0xFF, 0x80, 0x80, 0x80, 0x00, 0x00,
|
||||
0x00, 0x00,
|
||||
0xFF, 0x01,
|
||||
0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x40, 0xC4, 0x48, 0x50, 0x26,
|
||||
0x49, 0x82, 0x07,
|
||||
0x40,
|
||||
0xC4, 0x48, 0x50, 0x26, 0x4A, 0x9F, 0x02, 0x00, 0x30, 0x00, 0x30,
|
||||
0x30, 0x30, 0x30, 0x30,
|
||||
|
||||
0x00, 0x12, 0x24, 0x48, 0x90, 0x48, 0x24, 0x12, 0x00, 0x48, 0x24,
|
||||
0x12, 0x09, 0x12, 0x24,
|
||||
0x48,
|
||||
0x49, 0x00, 0x92, 0x00, 0x49, 0x00, 0x92, 0x00, 0x6D, 0x00, 0xB6,
|
||||
0x00, 0x6D, 0x00,
|
||||
0xB6, 0x00,
|
||||
0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0x10, 0x10, 0x10,
|
||||
0x10, 0x10,
|
||||
0x10, 0x10, 0x10,
|
||||
0x10, 0x10, 0x10, 0x10, 0xF0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
|
||||
0xF0,
|
||||
0x10, 0xF0, 0x10, 0x10,
|
||||
0x28, 0x28, 0x28, 0x28, 0xE8, 0x28, 0x28, 0x28, 0x00, 0x00, 0x00,
|
||||
0x00, 0xF8, 0x28, 0x28, 0x28,
|
||||
0x00, 0x00, 0x00, 0xF0, 0x10, 0xF0, 0x10, 0x10, 0x28, 0x28,
|
||||
0x28, 0xE8, 0x08, 0xE8, 0x28, 0x28,
|
||||
0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x00,
|
||||
0x00, 0x00, 0xF8, 0x08, 0xE8, 0x28, 0x28,
|
||||
0x28, 0x28, 0x28, 0xE8, 0x08, 0xF8, 0x00, 0x00,
|
||||
0x28, 0x28, 0x28, 0x28, 0xF8, 0x00, 0x00, 0x00,
|
||||
0x10, 0x10, 0x10, 0xF0, 0x10, 0xF0, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x10, 0x10, 0x10,
|
||||
0x10, 0x10, 0x10, 0x10, 0x1F, 0x00,
|
||||
0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0xFF,
|
||||
0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x10, 0x10, 0x10,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0xFF, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x10, 0x10,
|
||||
0x10,
|
||||
0x10, 0x10, 0x10,
|
||||
0x1F, 0x10, 0x1F, 0x10, 0x10, 0x28, 0x28, 0x28, 0x28, 0x3F, 0x28,
|
||||
0x28, 0x28,
|
||||
0x28, 0x28,
|
||||
0x28, 0x2F, 0x20, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x20,
|
||||
0x2F, 0x28, 0x28,
|
||||
0x28,
|
||||
0x28, 0x28, 0xEF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
|
||||
0x00, 0xEF, 0x28, 0x28,
|
||||
|
||||
0x28, 0x28, 0x28, 0x2F, 0x20, 0x2F, 0x28, 0x28, 0x00, 0x00, 0x00,
|
||||
0xFF, 0x00, 0xFF, 0x00,
|
||||
0x00,
|
||||
0x28, 0x28, 0x28, 0xEF, 0x00, 0xEF, 0x28, 0x28, 0x10, 0x10, 0x10,
|
||||
0xFF, 0x00, 0xFF,
|
||||
0x00, 0x00,
|
||||
0x28, 0x28, 0x28, 0x28, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0xFF, 0x00,
|
||||
0xFF, 0x10, 0x10,
|
||||
0x00, 0x00, 0x00, 0x00, 0xFF, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
|
||||
0x28,
|
||||
0x3F, 0x00, 0x00, 0x00,
|
||||
0x10, 0x10, 0x10, 0x1F, 0x10, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x1F, 0x10, 0x1F, 0x10, 0x10,
|
||||
0x00, 0x00, 0x00, 0x00, 0x3F, 0x28, 0x28, 0x28, 0x28, 0x28,
|
||||
0x28, 0x28, 0xFF, 0x28, 0x28, 0x28,
|
||||
0x10, 0x10, 0x10, 0xFF, 0x10, 0xFF, 0x10, 0x10, 0x10,
|
||||
0x10, 0x10, 0x10, 0xF0, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x1F, 0x10, 0x10, 0x10,
|
||||
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
|
||||
0x00, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,
|
||||
0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
|
||||
0x07, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x02, 0x34,
|
||||
0x4C, 0x4C, 0x32, 0x00, 0x5C, 0x22, 0x22, 0x3C, 0x44, 0x44, 0x78,
|
||||
0x7E, 0x42, 0x42, 0x40,
|
||||
0x40, 0x40, 0x40, 0x40, 0x00, 0x00, 0x02, 0x7C, 0xA8, 0x28, 0x28,
|
||||
0x44,
|
||||
0x00, 0x7E, 0x61,
|
||||
0x30, 0x18, 0x08, 0x10, 0x20, 0x00, 0x00, 0x08, 0x7F, 0x88, 0x88,
|
||||
0x88, 0x70,
|
||||
0x00, 0x00,
|
||||
0x00, 0x22, 0x44, 0x44, 0x7A, 0x80, 0x00, 0x00, 0x00, 0x7C, 0x10,
|
||||
0x10, 0x10, 0x10,
|
||||
0x00,
|
||||
0x1C, 0x08, 0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00, 0x00, 0x38, 0x44,
|
||||
0x44, 0x7C, 0x44, 0x44,
|
||||
|
||||
0x3C, 0x66, 0xC3, 0xC3, 0xC3, 0x66, 0x24, 0x66, 0x0C, 0x10, 0x08,
|
||||
0x1C, 0x22, 0x22, 0x22,
|
||||
0x1C,
|
||||
0x00, 0x00, 0x00, 0x00, 0x6C, 0x92, 0x92, 0x6C, 0x00, 0x01, 0x1A,
|
||||
0x26, 0x2A, 0x32,
|
||||
0x2C, 0x40,
|
||||
0x00, 0x18, 0x20, 0x20, 0x30, 0x20, 0x20, 0x18, 0x00, 0x3C, 0x42,
|
||||
0x42, 0x42,
|
||||
0x42, 0x42, 0x42,
|
||||
0x00, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x00, 0x08, 0x08,
|
||||
0x3E,
|
||||
0x08, 0x08, 0x00, 0x3E,
|
||||
0x00, 0x10, 0x08, 0x04, 0x08, 0x10, 0x00, 0x3E, 0x00, 0x04, 0x08,
|
||||
0x10, 0x08, 0x04, 0x00, 0x3E,
|
||||
0x00, 0x06, 0x09, 0x09, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00,
|
||||
0x08, 0x08, 0x08, 0x48, 0x48, 0x30,
|
||||
0x00, 0x00, 0x08, 0x00, 0x3E, 0x00, 0x08, 0x00, 0x00,
|
||||
0x60, 0x92, 0x0C, 0x60, 0x92, 0x0C, 0x00,
|
||||
0x60, 0x90, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x30, 0x78, 0x30, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
|
||||
0x00, 0x00, 0x03, 0x04, 0x04, 0xC8, 0x28, 0x10, 0x00,
|
||||
0x00, 0x00, 0x00, 0x7C, 0x42, 0x42,
|
||||
0x42, 0x00, 0x18, 0x24, 0x08, 0x10, 0x3C, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x3E, 0x3E,
|
||||
0x3E, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
};
|
|
@ -0,0 +1,33 @@
|
|||
static u8 ansilogo[] = "\
|
||||
\033[0m\033[1m\
|
||||
\xDA\033[0m\xC4\xC4\033[1;30m\xC4\033[0m\xC4\033[1;30m\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\033[37m \033[0;31mC\033[1;37m \033[31m\x4F\033[37m \033[33mS\033[37m \033[36m2\033[37m \033[0;36m0\033[1;37m \033[34m0\033[37m \033[0;34m0\033[1;37m \033[0mV2.2.1\033[1m \033[30m\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xBF\r\n\
|
||||
\033[0m\xB3\033[77C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m \033[1;36m\xDB\xDB\xDB\xDB\xDB\xDF\033[0;36m\xDF\033[1m\xDF\xDB\033[0;36m\xDF\033[1m\xDF\033[0;36m\xDF\xDF\xDF\xDF\xDF\033[1;37m\xDC\xDC\xDC\033[47m\xDF\033[0m\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\xDC\xDC\033[0;36m\xDF\xDF\xDF\033[1;37m\xDC\xDC\033[47m\xDF\033[0m\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\xDC\033[0;36m\xDF\xDF\033[37m \033[36m\xDF\xDF\033[1;37m\xDC\xDC\033[47m\xDF\033[0m\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\xDC\033[0m \033[36m\xDF\xDF\xDF\xDF\xDF\033[1m\xDF\033[0;36m\xDF\033[1m\xDB\xDF\033[0;36m\xDF\033[1m\xDF\xDB\xDB\xDB\xDB\033[0m \033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m \033[1;36m\xDB\xDB\xDF\033[0m\033[5C\033[1;36m\xFA \033[37m\xDC\033[47m\xDF\xDF\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\xDF\033[40m\xDC\033[37m\xDF\033[47m\xDC\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\033[0m \033[1;36m \033[37m\xDC\033[47m\xDF\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\033[0m\033[6C\033[1;36m\xDE \xDF\xDB\xDB\033[0m \033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m \033[1;36m\xDB\033[0m\033[7C\033[1;36m\xFE \033[37m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB \033[47;37m\xDB\033[0m\xDB\xDB\033[1;47m\xDC\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB \033[36m \033[37m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDE\033[40m\xDD \033[0m \033[1;30m \033[36m\xFE\033[0m\033[6C\033[1;36m\xDB\033[0m \033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m \033[1;36m\xDE\033[0m\033[10C\033[1m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDC\033[40m\xDF \033[37m\xDF\033[47m\xDC\033[0m\xDB\xDB\xDB\033[1;47;30m\xDC\033[40m\xDF\033[37m\xDC\033[47m\xDF\033[0m\xDB\033[1;47;30m\xDC\033[40m\xDF\033[37m\xDE\033[47m\xDD\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\033[0m \033[1m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDC\033[37m\xDF\033[47m\xDC\033[0m\xDB\xDB\xDB\xDB\033[1;47;30m\xDE\033[40m\xDD\033[0m\033[12C\033[1;36m\xDE\033[0m \033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m \033[1;36m\xFE\033[0m\033[9C\033[1m\xDE\033[47m\xDD\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB\033[0m\033[6C\033[1m\xDF\033[0m\xDF\033[1;30m\xDF\033[37m\xDC\033[47m\xDF\033[0m\xDB\xDB\xDB\033[1;30m\xDB \033[37m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB\033[0m \033[1m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\033[37m\xDF\033[47m\xDC\033[30m\xDC\033[40m\xDF\xDF\033[0m\033[13C\033[1;36m\xFA\033[0m \033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[13C\033[1m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDE\033[40m\xDD\033[0m\033[9C\033[1m\xDB\033[0m\xDB\xDB\xDB\xDB\033[1;30m\xDB \033[37m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB\033[0m \033[1;30m \033[37m\xDC\xDF\033[47m\xDC\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\033[0m\033[16C\033[1;36m\xFE\033[0m \033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[13C\033[1m\xDE\033[47m\xDD\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB\033[0m\033[6C\033[1m\xDC\033[0m\xDC\033[1;30m\xDC\033[37m\xDF\033[47m\xDC\033[0m\xDB\xDB\xDB\033[1;47;30m\xDE\033[40m\xDD \033[37m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB\033[37m\xDC\033[47m\xDF\033[0m\xDB\033[1;47;30m\xDF\033[40m\xDC\033[37m\xDF\033[47m\xDC\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\033[0m\033[17C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[14C\033[1m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC \033[37m\xDC\033[47m\xDF\033[0m\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\033[37m\xDF\033[47m\xDC\033[0m\xDB\033[1;47;30m\xDE\033[40m\xDD\033[37m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDC\033[40m\xDF\033[0m\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDF\033[40m\xDC\033[37m\xDF\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB\033[0m\033[16C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[15C\033[1m\xDB\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB \033[37m\xDB\033[0m\xDB\033[1;47;30m\xDF\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;30m\xDB \033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDE\033[40m\xDD\033[0m\033[15C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[16C\033[1m\xDF\033[47m\xDC\xDC\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDC\xDC\033[40m\xDF\033[37m\xDC\033[47m\xDF\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDC\033[40m\xDF\033[0m \033[1;47m\xDC\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDC\033[40m\xDF\033[0m\033[16C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[19C\033[1m\xDF\xDF\xDF\033[47m\xDC\033[0m\xDB\xDB\033[1;47;30m\xDC\033[40m\xDF\xDF\xDF\033[0m \033[1m\xDF\xDF\033[47m\xDC\033[0m\xDB\xDB\xDB\xDB\033[1;47;30m\xDC\033[40m\xDF\xDF\033[0m\033[5C\033[1m\xDF\xDF\033[47m\xDC\033[0m\xDB\xDB\xDB\xDB\xDB\xDB\033[1;47;30m\xDC\033[40m\xDF\xDF\033[0m\033[18C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[77C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[77C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[13C\033[1;30m\xDC\xDC\033[0m\xDC\033[1;30m\xDC\033[0m\xDC\xDC\xDC\033[1m\xDC\033[0m\xDC\033[1m\xDC\033[0m \033[1m\xDC\033[0m\xDC\033[1m\xDC\033[0m\xDC\xDC\xDC\033[1m\xDC\033[0m\xDC\033[1m\xDC \033[0m \033[1m\xDC\033[0m\xDC\033[1m\xDC\033[0m\xDC\xDC\xDC\033[1m\xDC\033[0m\xDC\033[1m\xDC \033[0m \033[1m\xDC\033[0m\xDC\033[1m\xDC\033[0m\xDC\xDC\xDC\033[1m\xDC\033[0m\xDC\033[1m\xDC \033[0m\033[14C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[19C\033[1;30m\xB1\xDB\033[37m\xDB\xDB\xDB\033[0m \033[1m\xDB\xDB\xDB\033[30m\xDB\xB1 \033[37m\xDB\xDB\xDB\033[0m \033[1m\xDB\xDB\xDB\033[30m\xDB\xB1 \033[37m\xDB\xDB\xDB\033[0m \033[1m\xDB\xDB\xDB\033[30m\xDB\xB1 \033[37m\xDB\xDB\xDB\033[0m\033[14C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[13C\033[1;30m\xB0\xB0\xB0\xB0\xB0 \xB0\xB2\033[47;37m\xB2\033[40m\xDB\xDB\033[0m \033[1m\xDB\xDB\xDB\033[30m\xB2\xB0 \xB0\xB0\033[37m\xDB\xDB\xDB\033[0m \033[1m\xDB\xDB\xDB\033[30m\xB2\xB0 \xB0\xB0\033[37m\xDB\xDB\xDB\033[0m \033[1m\xDB\xDB\xDB\033[30m\xB2\xB0 \xB0\xB0\033[37m\xDB\xDB\xDB\033[0m\033[14C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[13C\033[1;30m\xB0\xB0\xB0\xB0\xB0\xB0 \xB1\033[47;37m\xB1\xB2\033[40m\xDB\033[0m \033[1;30m \033[47;37m\xB2\033[40m\xDB\xDB\033[30m\xB1 \xB0\xB0\033[47;37m\xB2\033[40m\xDB\xDB\033[30m \033[47;37m\xB2\033[40m\xDB\xDB\033[30m\xB1 \xB0\xB0\033[47;37m\xB2\033[40m\xDB\xDB\033[30m \033[0m \033[1;47m\xB2\033[40m\xDB\xDB\033[30m\xB1 \xB0\xB0\033[47;37m\xB2\033[40m\xDB\xDB\033[30m \033[0m\033[13C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[20C\xDC\033[1;47m\xB0\xB1\xB2\033[0m \033[1;30m \033[47;37m\xB1\xB2\033[40m\xDB\033[30m\xB0 \xB0\xB0\xB0\033[47;37m\xB1\xB2\033[40m\xDB\033[30m \033[47;37m\xB1\xB2\033[40m\xDB\033[30m\xB0 \xB0\xB0\xB0\033[47;37m\xB1\xB2\033[40m\xDB\033[30m \033[0m \033[1;47m\xB1\xB2\033[40m\xDB\033[30m\xB0 \xB0\xB0\xB0\033[47;37m\xB1\xB2\033[40m\xDB\033[30m \033[0m\033[13C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[13C\xDC\033[1;47m\xB1\xB2\xB1\xB2\xDB\xB2\xB1\xB0\033[0m\xDF \033[1;30m\xB0\033[47;37m\xB0\xB1\xB2\033[0m \033[1;30m\xB0\xB0\xB0\033[47;37m\xB0\xB1\xB2\033[40;30m\xB0\xB0\033[47;37m\xB0\xB1\xB2\033[0m \033[1;30m\xB0\xB0\xB0\033[47;37m\xB0\xB1\xB2\033[40;30m\xB0\033[0m \033[1;47m\xB0\xB1\xB2\033[0m \033[1;30m\xB0\xB0\xB0\033[47;37m\xB0\xB1\xB2\033[40;30m\xB0\033[0m\033[13C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[13C\033[1;47m\xB1\xB2\033[40m\xDB\033[30m\xB1\033[0m\033[6C\033[1;30m\xB0\xB0\xB0\033[0m\xDB\033[1;47m\xB0\xB1\033[0m \033[1;30m\xB0\xB0\xB0\xB0\033[0m\xDB\033[1;47m\xB0\xB1\033[40;30m\xB0\xB0\033[0m\xDB\033[1;47m\xB0\xB1\033[0m \033[1;30m\xB0\xB0\xB0\xB0\033[0m\xDB\033[1;47m\xB0\xB1\033[40;30m\xB0\033[0m \xDB\033[1;47m\xB0\xB1\033[0m \033[1;30m\xB0\xB0\xB0\xB0\033[0m\xDB\033[1;47m\xB0\xB1\033[40;30m\xB0\033[0m\033[13C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m \033[1;36m\xDD\033[0m\033[9C\033[1;47m\xB2\033[40m\xDB\xDB\033[30m\xB2\xB0 \xB0\xB0\xB0\xB0\xB0\xB0\xB0\033[47m\xB0\033[0m\xDB\033[1;47m\xB0\033[0m \033[1;30m\xB0\xB0\xB0\xB0\033[47m\xB0\033[0m\xDB\033[1;47m\xB0\033[40;30m\xB0\xB0\033[47m\xB0\033[0m\xDB\033[1;47m\xB0\033[0m \033[1;30m\xB0\xB0\xB0\xB0\033[47m\xB0\033[0m\xDB\033[1;47m\xB0\033[40;30m\xB0\033[0m \033[1;47;30m\xB0\033[0m\xDB\033[1;47m\xB0\033[0m \033[1;30m\xB0\xB0\xB0\xB0\033[47m\xB0\033[0m\xDB\033[1;47m\xB0\033[40;30m\xB0\033[0m\033[13C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m \033[1;36m\xDB\033[0m\033[9C\033[1m\xDB\xDB\xDB\033[30m\xDB\xB1\033[0m\033[8C\033[1;47;30m\xB1\xB0\033[0m\xDB\033[5C\033[1;47;30m\xB1\xB0\033[0m\xDB \033[1;47;30m\xB1\xB0\033[0m\xDB\033[5C\033[1;47;30m\xB1\xB0\033[0m\xDB \033[1;47;30m\xB1\xB0\033[0m\xDB\033[5C\033[1;47;30m\xB1\xB0\033[0m\xDB\033[10C\033[1;36m\xDB\033[0m \033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m \033[1;36m\xDB\xDC\033[0m\033[9C\033[1m\xDF\033[0m\xDF\033[1m\xDF\033[0m\xDF\xDF\033[1;30m\xDF\033[0m\xDF\033[1;30m\xDF\xDF\xDF\033[0m \033[1m\xDF\033[0m\xDF\033[1m\xDF\033[0m\xDF\xDF\033[1m\xDF\033[0m\xDF\033[1m\xDF\xDF \033[0m \033[1m\xDF\033[0m\xDF\033[1m\xDF\033[0m\xDF\xDF\033[1m\xDF\033[0m\xDF\033[1m\xDF\xDF \033[0m \033[1m\xDF\033[0m\xDF\033[1m\xDF\033[0m\xDF\xDF\033[1m\xDF\033[0m\xDF\033[1m\xDF\xDF \033[0m\033[9C\033[1;36m\xDC\xDB\xDB\033[0m \033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m \033[1;36m\xDB\xDB\xDB\xDC\033[0;36m\xDC\033[1m\xDC\xDC\033[0;36m\xDC\033[1m\xDC\033[0;36m\xDC\xDC\xDC\xDC\xDC\xDC\xDC\033[37m \033[36m\xDC\xDC\xDC\033[37m\033[17C\033[36m\xDC\xDC\xDC\xDC\033[37m\033[13C\033[36m\xDC\xDC\xDC\033[1m\xDC\033[0;36m\xDC\033[1m\xDC\xDC\033[0;36m\xDC\033[1m\xDC\xDC\xDB\xDB\xDB\xDB\xDB\033[0m \033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[77C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[6C\033[1mF1-F8\033[30m Consoles virtuelles \033[37mF9\033[30m Debug \033[37mF10\033[30m Mode graphique \033[37mF11\033[30m Aide\033[0m\033[9C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m\033[77C\033[1;30m\xB3\r\n\
|
||||
\xB3\033[0m Developpe par \033[5;1;47mMrNop\033[0m\033[55C\xB3\r\n\
|
||||
\xC0\033[1;30m\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\xC4\033[0m\xC4\033[1;30m\xC4\033[0m\xC4\xC4\033[1m\xD9\033[0m\r\n\r\n";
|
|
@ -0,0 +1,130 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
|
||||
/* definition des registres de la carte VGA pour differents modes */
|
||||
|
||||
static capabilities vgacapabilities[] = {
|
||||
{0x00, 80, 25, false, 4, 0},
|
||||
{0x01, 80, 50, false, 4, 0},
|
||||
{0x80, 640, 480, true, 1, 0},
|
||||
{0x81, 320, 200, true, 2, 0},
|
||||
{0x82, 640, 480, true, 4, 0},
|
||||
{0x83, 320, 200, true, 8, 0},
|
||||
{0x84, 320, 400, true, 8, 0},
|
||||
{0x85, 320, 480, true, 8, 0},
|
||||
{0x86, 360, 480, true, 8, 0},
|
||||
{0xFF, 000, 000, false, 0, 0},
|
||||
};
|
||||
|
||||
|
||||
static vgamode modes[] = {
|
||||
|
||||
/*80*25 16 couleurs mode 0x00 */
|
||||
{{0x67},
|
||||
{0x03, 0x00, 0x03, 0x00, 0x02},
|
||||
{0x5F, 0x4F, 0x50, 0x82, 0x55, 0x81, 0xBF, 0x1F, 0x00,
|
||||
0x4F, 0x0D, 0x0E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x9C, 0x0E, 0x8F, 0x28, 0x1F, 0x96, 0xB9, 0xA3, 0xFF},
|
||||
{0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0xFF},
|
||||
{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A,
|
||||
0x3B,
|
||||
0x3C, 0x3D, 0x3E, 0x3F,
|
||||
0x0C, 0x00, 0x0F, 0x08, 0x00}},
|
||||
|
||||
/*80*50 16 couleurs mode 0x01 */
|
||||
{{0x63},
|
||||
{0x03, 0x01, 0x03, 0x05, 0x02},
|
||||
{0x5F, 0x4F, 0x50, 0x82, 0x55, 0x81, 0xBF, 0x1F, 0x00,
|
||||
0x47, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00,
|
||||
0x9C, 0x8E, 0x8F, 0x28, 0x1F, 0x96, 0xB9, 0xA3, 0xFF},
|
||||
{0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0xFF},
|
||||
{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A,
|
||||
0x3B,
|
||||
0x3C, 0x3D, 0x3E, 0x3F,
|
||||
0x0C, 0x00, 0x0F, 0x00, 0x00}},
|
||||
|
||||
/*640*480 n&b mode 0x80 */
|
||||
{{0xE3},
|
||||
{0x03, 0x01, 0x0F, 0x00, 0x06},
|
||||
{0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0x0B, 0x3E, 0x00,
|
||||
0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0xEA, 0x0C, 0xDF, 0x28, 0x00, 0xE7, 0x04, 0xE3, 0xFF},
|
||||
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0F, 0xFF},
|
||||
{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x3A,
|
||||
0x3B,
|
||||
0x3C, 0x3D, 0x3E, 0x3F,
|
||||
0x01, 0x00, 0x0F, 0x00, 0x00}},
|
||||
|
||||
/*320*200 4 couleurs mode 0x81 */
|
||||
{{0x63},
|
||||
{0x03, 0x09, 0x03, 0x00, 0x02},
|
||||
{0x2D, 0x27, 0x28, 0x90, 0x2B, 0x80, 0xBF, 0x1F, 0x00,
|
||||
0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x9C, 0x0E, 0x8F, 0x14, 0x00, 0x96, 0xB9, 0xA3, 0xFF},
|
||||
{0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x02, 0x00, 0xFF},
|
||||
{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x3A,
|
||||
0x3B,
|
||||
0x3C, 0x3D, 0x3E, 0x3F,
|
||||
0x01, 0x00, 0x03, 0x00, 0x00}},
|
||||
|
||||
/*640*480 16 couleurs mode 0x82 */
|
||||
{{0xE3},
|
||||
{0x03, 0x01, 0x0F, 0x00, 0x06},
|
||||
{0x5F, 0x4F, 0x50, 0x82, 0x53, 0x9F, 0x0B, 0x3E, 0x00,
|
||||
0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0xE9, 0x8B, 0xDF, 0x28, 0x00, 0xE7, 0x04, 0xE3, 0xFF},
|
||||
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0F, 0xFF},
|
||||
{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x3A,
|
||||
0x3B,
|
||||
0x3C, 0x3D, 0x3E, 0x3F,
|
||||
0x01, 0x00, 0x0F, 0x00, 0x00}},
|
||||
|
||||
/*320*200 256 couleurs RAPIDE mode 0x83 */
|
||||
{{0x63},
|
||||
{0x03, 0x01, 0x0F, 0x00, 0x0E},
|
||||
{0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0xBF, 0x1F, 0x00,
|
||||
0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x9C, 0x0E, 0x8F, 0x28, 0x40, 0x96, 0xB9, 0xA3, 0xFF},
|
||||
{0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF},
|
||||
{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
|
||||
0x0B,
|
||||
0x0C, 0x0D, 0x0E, 0x0F,
|
||||
0x41, 0x00, 0x0F, 0x00, 0x00}},
|
||||
|
||||
/*320*400 256 couleurs mode 0x84 */
|
||||
{{0x63},
|
||||
{0x03, 0x01, 0x0F, 0x00, 0x06},
|
||||
{0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0xBF, 0x1F, 0x00,
|
||||
0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x9C, 0x8E, 0x8F, 0x28, 0x00, 0x96, 0xB9, 0xE3, 0xFF},
|
||||
{0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF},
|
||||
{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
|
||||
0x0B,
|
||||
0x0C, 0x0D, 0x0E, 0x0F,
|
||||
0x41, 0x00, 0x0F, 0x00, 0x00}},
|
||||
|
||||
/*320*480 256 couleurs mode 0x85 */
|
||||
{{0xE3},
|
||||
{0x03, 0x01, 0x0F, 0x00, 0x06},
|
||||
{0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0x0B, 0x3E, 0x00,
|
||||
0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0xEA, 0xAC, 0xDF, 0x28, 0x00, 0xE7, 0x06, 0xE3, 0xFF},
|
||||
{0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF},
|
||||
{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
|
||||
0x0B,
|
||||
0x0C, 0x0D, 0x0E, 0x0F,
|
||||
0x41, 0x00, 0x0F, 0x00, 0x00}},
|
||||
|
||||
/*360*480 256 couleurs mode 0x86 */
|
||||
{{0xE7},
|
||||
{0x03, 0x01, 0x0F, 0x00, 0x06},
|
||||
{0x6B, 0x59, 0x5A, 0x8E, 0x5E, 0x8A, 0x0D, 0x3E, 0x00,
|
||||
0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0xEA, 0xAC, 0xDF, 0x2D, 0x00, 0xE7, 0x06, 0xE3, 0xFF},
|
||||
{0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF},
|
||||
{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
|
||||
0x0B,
|
||||
0x0C, 0x0D, 0x0E, 0x0F,
|
||||
0x41, 0x00, 0x0F, 0x00, 0x00}},
|
||||
};
|
|
@ -1,217 +1,337 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "types.h"
|
||||
#include "cpu.h"
|
||||
#include "cpuid.h"
|
||||
#include "memory.h"
|
||||
#include "string.h"
|
||||
#include "asm.h"
|
||||
#include "gdt.h"
|
||||
#include "process.h"
|
||||
|
||||
/* Technologies supportées */
|
||||
|
||||
|
||||
static u8 *msg[] =
|
||||
{
|
||||
"mmx",
|
||||
"mmx2",
|
||||
"sse",
|
||||
"sse2",
|
||||
"sse3",
|
||||
"fpu",
|
||||
"3dNow!",
|
||||
"3dNow Extended!",
|
||||
"HyperThreading",
|
||||
"apic",
|
||||
static u8 *msg[] = {
|
||||
"mmx",
|
||||
"mmx2",
|
||||
"sse",
|
||||
"sse2",
|
||||
"sse3",
|
||||
"fpu",
|
||||
"3dNow!",
|
||||
"3dNow Extended!",
|
||||
"HyperThreading",
|
||||
"apic",
|
||||
"64bits",
|
||||
"syscall",
|
||||
"msr",
|
||||
"sse4a",
|
||||
"vmx",
|
||||
"sse41",
|
||||
"sse42",
|
||||
"apic2"
|
||||
};
|
||||
|
||||
static u8 space[]=" ";
|
||||
static u8 space[] = " ";
|
||||
|
||||
bool cansetflag (u32 flag)
|
||||
/******************************************************************************/
|
||||
/* Affiche une erreur CPU et fige l'ordinateur */
|
||||
|
||||
void cpuerror(const u8 * src, const regs * dump, bool returnto)
|
||||
{
|
||||
u32 r1, r2;
|
||||
asm("pushfl\n"
|
||||
"popl %0\n"
|
||||
"movl %0, %1\n"
|
||||
"xorl %2, %0\n"
|
||||
"pushl %0\n"
|
||||
"popfl\n"
|
||||
"pushfl\n"
|
||||
"popl %0\n"
|
||||
"pushl %1\n"
|
||||
"popfl\n"
|
||||
: "=&r" (r1), "=&r" (r2)
|
||||
: "ir" (flag)
|
||||
);
|
||||
return ((r1 ^ r2) & flag) != 0;
|
||||
process *aprocess=findcurrentprocess();
|
||||
if (!aprocess->iskernel && !returnto)
|
||||
{
|
||||
printf("\033[31m*** ERREUR CPU, KILLING PROCESS %u : %s *** \r\n", aprocess->pid, src);
|
||||
deleteprocess(aprocess->pid);
|
||||
}
|
||||
else
|
||||
printf("\033[31m*** ERREUR CPU : %s *** \r\n", src);
|
||||
if (dump != NULL)
|
||||
show_cpu(dump);
|
||||
print("<Appuyer une touche pour continuer>\033[0m\r\n");
|
||||
sti();
|
||||
waitascii();
|
||||
if (!returnto)
|
||||
{
|
||||
print("Retour en force au SHELL\r\n");
|
||||
initselectors(getinitretry());
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
void cpuid(u32 op, u32 *eax, u32 *ebx,u32 *ecx, u32 *edx)
|
||||
/******************************************************************************/
|
||||
/* Annule les FLAGs CPU */
|
||||
|
||||
bool cansetflag(u32 flag)
|
||||
{
|
||||
asm("cpuid" : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx) : "a" (op) : "cc");
|
||||
u32 r1, r2;
|
||||
asm("pushfl\n" "popl %0\n" "movl %0, %1\n" "xorl %2, %0\n" "pushl %0\n" "popfl\n" "pushfl\n" "popl %0\n" "pushl %1\n" "popfl\n": "=&r"(r1), "=&r"(r2):"ir"(flag));
|
||||
return ((r1 ^ r2) & flag) != 0;
|
||||
}
|
||||
|
||||
u8 getcpuinfos(cpuinfo *proc)
|
||||
/******************************************************************************/
|
||||
/* Lance l'instruction CPUID */
|
||||
|
||||
void cpuid(u32 op, u32 * eax, u32 * ebx, u32 * ecx, u32 * edx)
|
||||
{
|
||||
u32 i,maxfunction,maxextended,unused,regeax,regebx,regecx,regedx;
|
||||
bool *boolean;
|
||||
|
||||
if (!cansetflag (0x00040000)) return 1; /*386 processor - no cpuid*/
|
||||
if (!cansetflag (0x00200000)) return 2; /*486 processor with no cpuid*/
|
||||
|
||||
cpuid(0, &maxfunction, &unused, &unused, &unused);
|
||||
maxfunction &= 0xffff;
|
||||
cpuid(0x80000000, &maxextended, &unused, &unused, &unused);
|
||||
maxextended &= 0xffff;
|
||||
if (maxfunction >= 1)
|
||||
{
|
||||
cpuid(1, ®eax, ®ebx, ®ecx, ®edx);
|
||||
proc->stepping = (regeax & 0x0000000F);
|
||||
proc->models = ((regeax>>4) & 0x0000000F);
|
||||
proc->family = ((regeax>>8) & 0x0000000F);
|
||||
proc->types = ((regeax>>12) & 0x00000003);
|
||||
proc->emodels = ((regeax>>16) & 0x0000000F);
|
||||
proc->efamily = ((regeax>>20) & 0x000000FF);
|
||||
|
||||
proc->brandid = (regeax & 0xF);
|
||||
proc->linesize = ((regeax>>8) & 0xF);
|
||||
proc->count = ((regeax>>16) & 0xF);
|
||||
proc->apicid = ((regeax>>24) & 0xF);
|
||||
|
||||
proc->mmx=((regedx>>23) & 0x00000001);
|
||||
proc->sse=((regedx>>25) & 0x00000001);
|
||||
proc->sse2=((regedx>>26) & 0x00000001);
|
||||
proc->sse3=(regecx & 0x00000001);
|
||||
proc->fpu=(regedx & 0x00000001);
|
||||
proc->htt=((regedx>>28) & 0x00000001);
|
||||
|
||||
}
|
||||
if (maxextended >= 1)
|
||||
{
|
||||
cpuid(0x80000001, ®eax, ®ebx, ®ecx, ®edx);
|
||||
proc->mmx2=((regedx>>22) & 0x00000001);
|
||||
proc->apic=((regedx>>9) & 0x00000001);
|
||||
proc->now3d=((regedx>>30) & 0x00000001);
|
||||
proc->now3d2=((regedx>>31) & 0x00000001);
|
||||
}
|
||||
if (maxextended >= 4)
|
||||
{
|
||||
int i;
|
||||
for(i=0;i<3;i++)
|
||||
{
|
||||
cpuid(0x80000002+i, ®eax, ®ebx, ®ecx, ®edx);
|
||||
memcpy(®eax,&proc->detectedname[0+i*16],4,1);
|
||||
memcpy(®ebx,&proc->detectedname[4+i*16],4,1);
|
||||
memcpy(®ecx,&proc->detectedname[8+i*16],4,1);
|
||||
memcpy(®edx,&proc->detectedname[12+i*16],4,1);
|
||||
}
|
||||
}
|
||||
boolean=&proc->mmx;
|
||||
i=0;
|
||||
|
||||
for(i=0;i<10;i++)
|
||||
if (*(boolean++)==1)
|
||||
{
|
||||
strcat(msg[i],&proc->techs);
|
||||
strcat(space,&proc->techs);
|
||||
}
|
||||
return 0;
|
||||
asm("cpuid": "=a"(*eax), "=b"(*ebx), "=c"(*ecx), "=d"(*edx): "a"(op):"cc");
|
||||
}
|
||||
|
||||
u32 viewstack(u32 number)
|
||||
/******************************************************************************/
|
||||
/* Retourne les informations sur le CPU dans une structure cpuinfo */
|
||||
|
||||
u8 getcpuinfos(cpuinfo * proc)
|
||||
{
|
||||
u32 stack = 0;
|
||||
asm (
|
||||
"movl %[a1],%%esi;"
|
||||
"addl %%esp,%%esi;"
|
||||
"movl (%%esi), %[a1] ;"
|
||||
:[result] "=r" (stack)
|
||||
:[a1] "r" (number)
|
||||
:"%esi"
|
||||
);
|
||||
return stack;
|
||||
u32 i, maxfunction, maxextended, unused, regeax, regebx,
|
||||
regecx, regedx;
|
||||
bool *boolean;
|
||||
|
||||
if (!cansetflag(0x00040000))
|
||||
return 1; /*386 processor - no cpuid */
|
||||
if (!cansetflag(0x00200000))
|
||||
return 2; /*486 processor with no cpuid */
|
||||
|
||||
cpuid(0, &maxfunction, &unused, &unused, &unused);
|
||||
maxfunction &= 0xffff;
|
||||
cpuid(0x80000000, &maxextended, &unused, &unused, &unused);
|
||||
maxextended &= 0xffff;
|
||||
if (maxfunction >= 1)
|
||||
{
|
||||
cpuid(1, ®eax, ®ebx, ®ecx, ®edx);
|
||||
proc->stepping = (regeax & 0x0000000F);
|
||||
proc->models = ((regeax >> 4) & 0x0000000F);
|
||||
proc->family = ((regeax >> 8) & 0x0000000F);
|
||||
proc->types = ((regeax >> 12) & 0x00000003);
|
||||
proc->emodels = ((regeax >> 16) & 0x0000000F);
|
||||
proc->efamily = ((regeax >> 20) & 0x000000FF);
|
||||
|
||||
proc->brandid = (regeax & 0xF);
|
||||
proc->linesize = ((regeax >> 8) & 0xF);
|
||||
proc->count = ((regeax >> 16) & 0xF);
|
||||
proc->apicid = ((regeax >> 24) & 0xF);
|
||||
|
||||
proc->mmx = ((regedx >> 23) & 0x00000001);
|
||||
proc->sse = ((regedx >> 25) & 0x00000001);
|
||||
proc->sse2 = ((regedx >> 26) & 0x00000001);
|
||||
proc->sse3 = (regecx & 0x00000001);
|
||||
proc->fpu = (regedx & 0x00000001);
|
||||
proc->htt = ((regedx >> 28) & 0x00000001);
|
||||
proc->vmx = ((regecx >> 5) & 0x00000001);
|
||||
proc->sse41 = ((regecx >> 19) & 0x00000001);
|
||||
proc->sse42 = ((regecx >> 20) & 0x00000001);
|
||||
proc->apic2 = ((regecx >> 21) & 0x00000001);
|
||||
}
|
||||
if (maxextended >= 1)
|
||||
{
|
||||
cpuid(0x80000001, ®eax, ®ebx, ®ecx, ®edx);
|
||||
proc->mmx2 = ((regedx >> 22) & 0x00000001);
|
||||
proc->apic = ((regedx >> 9) & 0x00000001);
|
||||
proc->now3d = ((regedx >> 30) & 0x00000001);
|
||||
proc->now3d2 = ((regedx >> 31) & 0x00000001);
|
||||
proc->bits64 = ((regedx >> 29) & 0x00000001);
|
||||
proc->syscall = ((regedx >> 11) & 0x00000001);
|
||||
proc->msr = ((regedx >> 5) & 0x00000001);
|
||||
proc->sse4a = ((regecx >> 6) & 0x00000001);
|
||||
}
|
||||
if (maxextended >= 4)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < 3; i++)
|
||||
{
|
||||
cpuid(0x80000002 + i, ®eax, ®ebx, ®ecx,
|
||||
®edx);
|
||||
memcpy(®eax, &proc->detectedname[0 + i * 16], 4,
|
||||
1);
|
||||
memcpy(®ebx, &proc->detectedname[4 + i * 16], 4,
|
||||
1);
|
||||
memcpy(®ecx, &proc->detectedname[8 + i * 16], 4,
|
||||
1);
|
||||
memcpy(®edx, &proc->detectedname[12 + i * 16],
|
||||
4, 1);
|
||||
}
|
||||
}
|
||||
boolean = &proc->mmx;
|
||||
i = 0;
|
||||
proc->techs[0] = '\000';
|
||||
for (i = 0; i < sizeof(msg); i++)
|
||||
if (*(boolean++) == 1)
|
||||
{
|
||||
strcat(msg[i], &proc->techs);
|
||||
strcat(space, &proc->techs);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void dump_regs()
|
||||
/******************************************************************************/
|
||||
/* Affiche les registres CPU */
|
||||
|
||||
void show_lightcpu(regs * stack)
|
||||
{
|
||||
u32 eax = 0;
|
||||
u32 ebx = 0;
|
||||
u32 ecx = 0;
|
||||
u32 edx = 0;
|
||||
u32 esi = 0;
|
||||
u32 edi = 0;
|
||||
u32 ebp = 0;
|
||||
u32 esp = 0;
|
||||
u16 cs = 0;
|
||||
u16 ds = 0;
|
||||
u16 es = 0;
|
||||
u16 fs = 0;
|
||||
u16 gs = 0;
|
||||
u16 ss = 0;
|
||||
u32 flags = 0;
|
||||
asm (
|
||||
"movl %%eax, %[a1] ;"
|
||||
"movl %%ebx, %[b1] ;"
|
||||
"movl %%ecx, %[c1] ;"
|
||||
"movl %%edx, %[d1] ;"
|
||||
"movl %%esi, %[e1] ;"
|
||||
"movl %%edi, %[f1] ;"
|
||||
"movl %%esp, %[g1] ;"
|
||||
"movl %%ebp, %[h1] ;"
|
||||
"movw %%cs, %[i1] ;"
|
||||
"movw %%ds, %[j1] ;"
|
||||
"movw %%es, %[k1] ;"
|
||||
"movw %%fs, %[l1] ;"
|
||||
"movw %%gs, %[m1] ;"
|
||||
"movw %%ss, %[n1] ;"
|
||||
:
|
||||
[a1] "=m" (eax), [b1] "=m" (ebx), [c1] "=m" (ecx), [d1] "=m" (edx), [e1] "=m" (esi), [f1] "=m" (edi),
|
||||
[g1] "=m" (ebp), [h1] "=m" (esp), [i1] "=m" (cs), [j1] "=m" (ds), [k1] "=m" (es), [l1] "=m" (fs), [m1] "=m" (gs), [n1] "=m" (ss)
|
||||
);
|
||||
|
||||
printf("eax=%x ebx=%x ecx=%x eax=%x\r\n", eax,ebx,ecx,edx);
|
||||
printf("esi=%x edi=%x\r\n", esi,edi);
|
||||
printf("cs=%x ds=%x es=%x fs=%x gs=%x\r\n", cs,ds,es,fs,gs);
|
||||
printf("ss=%x esp=%x ebp=%x\r\n",ss,esp,ebp);
|
||||
|
||||
asm (
|
||||
"pushf ;"
|
||||
"pop %[f1] ;"
|
||||
:
|
||||
[f1] "=m" (flags)
|
||||
);
|
||||
|
||||
printf("FLAGS");
|
||||
|
||||
if(flags & (1 << 0)) // Carry
|
||||
printf(" (C1");
|
||||
else
|
||||
printf(" (C0");
|
||||
|
||||
if(flags & (1 << 2)) // Parity
|
||||
printf(" P1");
|
||||
else
|
||||
printf(" P0");
|
||||
|
||||
if(flags & (1 << 4)) // Adjust
|
||||
printf(" A1");
|
||||
else
|
||||
printf(" A0");
|
||||
|
||||
if(flags & (1 << 6)) // Zero
|
||||
printf(" Z1");
|
||||
else
|
||||
printf(" Z0");
|
||||
|
||||
if(flags & (1 << 7)) // Sign
|
||||
printf(" S1");
|
||||
else
|
||||
printf(" S0");
|
||||
|
||||
if(flags & (1 << 11)) // Overflow
|
||||
printf(" O1)\n");
|
||||
else
|
||||
printf(" O0)\n");
|
||||
|
||||
printf("STACK\r\n");
|
||||
for(u8 i=0;i<25;i++)
|
||||
printf("+%d\t\t%x\r\n",i,viewstack(i*4));
|
||||
u32 i;
|
||||
printf("\33[0mEAX=%Y EBX=%Y ECX=%Y EDX=%Y\r\n", stack->eax,
|
||||
stack->ebx, stack->ecx, stack->edx);
|
||||
printf("ESI=%Y EDI=%Y ESP=%Y EBP=%Y\r\n", stack->esi, stack->edi,
|
||||
stack->esp, stack->ebp);
|
||||
printf("EIP=%Y EFL=%Y [%c%c%c%c%c%c%c%c%c]\r\n", stack->eip,
|
||||
stack->eflags, (stack->eflags & (1 << 11)) ? 'O' : '-',
|
||||
(stack->eflags & (1 << 10)) ? 'D' : '-',
|
||||
(stack->eflags & (1 << 9)) ? 'I' : '-',
|
||||
(stack->eflags & (1 << 8)) ? 'T' : '-',
|
||||
(stack->eflags & (1 << 7)) ? 'S' : '-',
|
||||
(stack->eflags & (1 << 6)) ? 'Z' : '-',
|
||||
(stack->eflags & (1 << 4)) ? 'A' : '-',
|
||||
(stack->eflags & (1 << 2)) ? 'P' : '-',
|
||||
(stack->eflags & (1 << 0)) ? 'C' : '-');
|
||||
printf("CS =%hY DS =%hY SS =%hY ES =%hY FS =%hY GS =%hY\r\n",
|
||||
stack->cs, stack->ds, stack->ss, stack->es, stack->fs,
|
||||
stack->gs);
|
||||
printf("CR0=%Y CR2=%Y CR3=%Y CR4=%Y\r\n\r\n\r\n", stack->cr0,
|
||||
stack->cr2, stack->cr3, stack->cr4);
|
||||
|
||||
u8 *size;
|
||||
u8 *pointer;
|
||||
for (i = 20; i < 50; i++)
|
||||
{
|
||||
pointer = stack->eip - i;
|
||||
size = pointer;
|
||||
size += 50;
|
||||
while (pointer < size)
|
||||
{
|
||||
pointer += disasm(pointer, NULL, false);
|
||||
if (pointer == stack->eip)
|
||||
break;
|
||||
}
|
||||
if (pointer == stack->eip)
|
||||
break;
|
||||
}
|
||||
if (pointer == stack->eip)
|
||||
pointer = stack->eip - i;
|
||||
else
|
||||
pointer = stack->eip;
|
||||
size = pointer;
|
||||
size += 50;
|
||||
while (pointer < size)
|
||||
{
|
||||
if (pointer == stack->eip)
|
||||
print("\33[41m\33[1m");
|
||||
else
|
||||
print("\33[40m\33[0m");
|
||||
pointer += disasm(pointer, NULL, true);
|
||||
}
|
||||
|
||||
printf("\33[0m\r\n\r\n\r\nSTACK\r\n");
|
||||
if (abs(KERNEL_STACK_ADDR - stack->esp) > 0x10000)
|
||||
printf("Pile invalide !");
|
||||
else
|
||||
{
|
||||
i = 0;
|
||||
for (u32 * pointer = stack->esp;
|
||||
pointer < KERNEL_STACK_ADDR; pointer++)
|
||||
{
|
||||
if (i > 0 && i % 10 == 0)
|
||||
print("\033[10A");
|
||||
if (i >= 10)
|
||||
print("\033[25C");
|
||||
printf("+%d:%Y - %Y\r\n", i++, pointer,
|
||||
(u32) (*pointer));
|
||||
}
|
||||
for (u32 j = 0; j < 10 - (i % 10); j++)
|
||||
print("\033[01B");
|
||||
}
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Affiche les registres CPU */
|
||||
|
||||
void show_cpu(regs * stack)
|
||||
{
|
||||
printf("EAX=%Y EBX=%Y ECX=%Y EDX=%Y\r\n", stack->eax, stack->ebx,
|
||||
stack->ecx, stack->edx);
|
||||
printf("ESI=%Y EDI=%Y ESP=%Y EBP=%Y\r\n", stack->esi, stack->edi,
|
||||
stack->esp, stack->ebp);
|
||||
printf("EIP=%Y EFL=%Y [%c%c%c%c%c%c%c%c%c]\r\n", stack->eip,
|
||||
stack->eflags, (stack->eflags & (1 << 11)) ? 'O' : '-',
|
||||
(stack->eflags & (1 << 10)) ? 'D' : '-',
|
||||
(stack->eflags & (1 << 9)) ? 'I' : '-',
|
||||
(stack->eflags & (1 << 8)) ? 'T' : '-',
|
||||
(stack->eflags & (1 << 7)) ? 'S' : '-',
|
||||
(stack->eflags & (1 << 6)) ? 'Z' : '-',
|
||||
(stack->eflags & (1 << 4)) ? 'A' : '-',
|
||||
(stack->eflags & (1 << 2)) ? 'P' : '-',
|
||||
(stack->eflags & (1 << 0)) ? 'C' : '-');
|
||||
printf("CS =%hY %Y %Y DPL=%d %cS%d [%c%c%c] %h ub\r\n", stack->cs,
|
||||
getdesbase(stack->cs), getdeslimit(stack->cs),
|
||||
getdesdpl(stack->cs), getdestype(stack->cs),
|
||||
getdessize(stack->cs), getdesbit3(stack->cs),
|
||||
getdesbit2(stack->cs), getdesbit1(stack->cs),
|
||||
getdesalign(stack->cs));
|
||||
printf("DS =%hY %Y %Y DPL=%d %cS%d [%c%c%c] %h ub\r\n", stack->ds,
|
||||
getdesbase(stack->ds), getdeslimit(stack->ds),
|
||||
getdesdpl(stack->ds), getdestype(stack->ds),
|
||||
getdessize(stack->ds), getdesbit3(stack->ds),
|
||||
getdesbit2(stack->ds), getdesbit1(stack->ds),
|
||||
getdesalign(stack->ds));
|
||||
printf("SS =%hY %Y %Y DPL=%d %cS%d [%c%c%c] %h ub\r\n", stack->ss,
|
||||
getdesbase(stack->ss), getdeslimit(stack->ss),
|
||||
getdesdpl(stack->ss), getdestype(stack->ss),
|
||||
getdessize(stack->ss), getdesbit3(stack->ss),
|
||||
getdesbit2(stack->ss), getdesbit1(stack->ss),
|
||||
getdesalign(stack->ss));
|
||||
printf("ES =%hY %Y %Y DPL=%d %cS%d [%c%c%c] %h ub\r\n", stack->es,
|
||||
getdesbase(stack->es), getdeslimit(stack->es),
|
||||
getdesdpl(stack->es), getdestype(stack->es),
|
||||
getdessize(stack->es), getdesbit3(stack->es),
|
||||
getdesbit2(stack->es), getdesbit1(stack->es),
|
||||
getdesalign(stack->es));
|
||||
printf("FS =%hY %Y %Y DPL=%d %cS%d [%c%c%c] %h ub\r\n", stack->fs,
|
||||
getdesbase(stack->fs), getdeslimit(stack->fs),
|
||||
getdesdpl(stack->fs), getdestype(stack->fs),
|
||||
getdessize(stack->fs), getdesbit3(stack->fs),
|
||||
getdesbit2(stack->fs), getdesbit1(stack->fs),
|
||||
getdesalign(stack->fs));
|
||||
printf("GS =%hY %Y %Y DPL=%d %cS%d [%c%c%c] %h ub\r\n", stack->gs,
|
||||
getdesbase(stack->gs), getdeslimit(stack->gs),
|
||||
getdesdpl(stack->gs), getdestype(stack->gs),
|
||||
getdessize(stack->gs), getdesbit3(stack->gs),
|
||||
getdesbit2(stack->gs), getdesbit1(stack->gs),
|
||||
getdesalign(stack->gs));
|
||||
u32 tss;
|
||||
str(tss);
|
||||
printf("TR =%hY %Y %Y DPL=%d %cS%d [%c%c%c] %h ub\r\n", stack->gs,
|
||||
getdesbase(tss), getdeslimit(tss), getdesdpl(tss),
|
||||
getdestype(tss), getdessize(tss), getdesbit3(tss),
|
||||
getdesbit2(tss), getdesbit1(tss), getdesalign(tss));
|
||||
struct gdtr gdtreg;
|
||||
sgdt(gdtreg);
|
||||
printf("GDT= %Y %Y\r\n", gdtreg.base, gdtreg.limite);
|
||||
struct idtr idtreg;
|
||||
sidt(idtreg);
|
||||
printf("IDT= %Y %Y\r\n", idtreg.base, idtreg.limite);
|
||||
printf("CR0=%Y CR2=%Y CR3=%Y CR4=%Y\r\n", stack->cr0, stack->cr2,
|
||||
stack->cr3, stack->cr4);
|
||||
printf("DR0=%Y DR1=%Y DR2=%Y DR3=%Y\r\n", stack->dr0, stack->dr1,
|
||||
stack->dr2, stack->dr3);
|
||||
printf("DR6=%Y DR7=%Y\r\n", stack->dr6, stack->dr7);
|
||||
printf("EFER=%lY\r\n", stack->efer);
|
||||
printf("STACK\r\n");
|
||||
if (abs(KERNEL_STACK_ADDR - stack->esp) > 0x10000)
|
||||
printf("Pile invalide !");
|
||||
else
|
||||
{
|
||||
u32 i = 0;
|
||||
for (u32 * pointer = stack->esp;
|
||||
pointer < KERNEL_STACK_ADDR; pointer++)
|
||||
{
|
||||
if (i > 0 && i % 10 == 0)
|
||||
print("\033[10A");
|
||||
if (i >= 10)
|
||||
print("\033[25C");
|
||||
printf("+%d:%Y - %Y\r\n", i++, pointer,
|
||||
(u32) (*pointer));
|
||||
}
|
||||
for (u32 j = 0; j < 10 - (i % 10); j++)
|
||||
print("\033[01B");
|
||||
}
|
||||
}
|
||||
/*******************************************************************************/
|
||||
|
|
|
@ -0,0 +1,325 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
/* Quelques portions modifiée proviennent de cramfsck - check a cramfs file system
|
||||
*
|
||||
* Copyright (C) 2000-2002 Transmeta Corporation
|
||||
*
|
||||
* 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; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* 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. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*
|
||||
* 1999/12/03: Linus Torvalds (cramfs tester and unarchive program)
|
||||
* 2000/06/03: Daniel Quinlan (CRC and length checking program)
|
||||
* 2000/06/04: Daniel Quinlan (merged programs, added options, support
|
||||
* for special files, preserve permissions and
|
||||
* ownership, cramfs superblock v2, bogus mode
|
||||
* test, pathname length test, etc.)
|
||||
* 2000/06/06: Daniel Quinlan (support for holes, pretty-printing,
|
||||
* symlink size test)
|
||||
* 2000/07/11: Daniel Quinlan (file length tests, start at offset 0 or 512,
|
||||
* fsck-compatible exit codes)
|
||||
* 2000/07/15: Daniel Quinlan (initial support for block devices)
|
||||
* 2002/01/10: Daniel Quinlan (additional checks, test more return codes,
|
||||
* use read if mmap fails, standardize messages)
|
||||
* 2015/06/09: Yves-Noel Weweler (support for ignoring errors, when
|
||||
* extracting obscure cramfs files) */
|
||||
|
||||
#include "types.h"
|
||||
#include "cramfs.h"
|
||||
#include "boot.h"
|
||||
#include "memory.h"
|
||||
|
||||
u8* initrambloc;
|
||||
u8 start;
|
||||
cramfs_super* super;
|
||||
extern bootparams* allparams;
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Copie l'initram CRAMFS vers un malloc */
|
||||
void remap_initram()
|
||||
{
|
||||
virtual_range_use_kernel(allparams->ramdiskaddr, allparams->ramdiskaddr, allparams->ramdisksize, PAGE_NOFLAG);
|
||||
initrambloc=vmalloc(allparams->ramdisksize);
|
||||
memcpy(allparams->ramdiskaddr,initrambloc,allparams->ramdisksize,0);
|
||||
virtual_range_free_kernel(allparams->ramdiskaddr,allparams->ramdisksize);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Lit l'inode et renvoie un pointeur grâce à vmalloc */
|
||||
|
||||
cramfs_inode *cramfs_iget(cramfs_inode * i)
|
||||
{
|
||||
cramfs_inode *inode = vmalloc(sizeof(cramfs_inode));
|
||||
if (!inode)
|
||||
return NULL;
|
||||
*inode = *i;
|
||||
return inode;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Lit l'inode principal */
|
||||
|
||||
cramfs_inode *read_super(void)
|
||||
{
|
||||
u32 offset = super.root.offset << 2;
|
||||
|
||||
if (!S_ISDIR(super.root.mode))
|
||||
return NULL; /* fichier */
|
||||
if (!(super.flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET) && ((offset != sizeof(cramfs_super)) &&
|
||||
(offset != PAD_SIZE + sizeof(cramfs_super))))
|
||||
return NULL ; /*offset erronée */
|
||||
return cramfs_iget(&super.root);
|
||||
}
|
||||
|
||||
|
||||
|
||||
static int uncompress_block(void *src, int len)
|
||||
{
|
||||
int err;
|
||||
|
||||
stream.next_in = src;
|
||||
stream.avail_in = len;
|
||||
|
||||
stream.next_out = (unsigned char *) outbuffer;
|
||||
stream.avail_out = PAGE_CACHE_SIZE*2;
|
||||
|
||||
inflateReset(&stream);
|
||||
|
||||
if (len > PAGE_CACHE_SIZE*2) {
|
||||
die(FSCK_UNCORRECTED, 0, "data block too large");
|
||||
}
|
||||
err = inflate(&stream, Z_FINISH);
|
||||
if (err != Z_STREAM_END) {
|
||||
die(FSCK_UNCORRECTED, 0, "decompression error %p(%d): %s",
|
||||
zError(err), src, len);
|
||||
}
|
||||
return stream.total_out;
|
||||
}
|
||||
|
||||
static void do_uncompress(char *path, int fd, unsigned long offset, unsigned long size)
|
||||
{
|
||||
unsigned long curr = offset + 4 * ((size + PAGE_CACHE_SIZE - 1) / PAGE_CACHE_SIZE);
|
||||
|
||||
do {
|
||||
unsigned long out = PAGE_CACHE_SIZE;
|
||||
unsigned long next = *(u32 *) romfs_read(offset);
|
||||
|
||||
if (next > end_data) {
|
||||
end_data = next;
|
||||
}
|
||||
|
||||
offset += 4;
|
||||
if (curr == next) {
|
||||
if (opt_verbose > 1) {
|
||||
printf(" hole at %ld (%d)\n", curr, PAGE_CACHE_SIZE);
|
||||
}
|
||||
if (size < PAGE_CACHE_SIZE)
|
||||
out = size;
|
||||
memset(outbuffer, 0x00, out);
|
||||
}
|
||||
else {
|
||||
if (opt_verbose > 1) {
|
||||
printf(" uncompressing block at %ld to %ld (%ld)\n", curr, next, next - curr);
|
||||
}
|
||||
out = uncompress_block(romfs_read(curr), next - curr);
|
||||
}
|
||||
if (size >= PAGE_CACHE_SIZE) {
|
||||
if (out != PAGE_CACHE_SIZE) {
|
||||
die(FSCK_UNCORRECTED, 0, "non-block (%ld) bytes", out);
|
||||
}
|
||||
} else {
|
||||
if (out != size) {
|
||||
die(FSCK_UNCORRECTED, 0, "non-size (%ld vs %ld) bytes", out, size);
|
||||
}
|
||||
}
|
||||
size -= out;
|
||||
if (opt_extract) {
|
||||
if (write(fd, outbuffer, out) < 0) {
|
||||
die(FSCK_ERROR, 1, "write failed: %s", path);
|
||||
}
|
||||
}
|
||||
curr = next;
|
||||
} while (size);
|
||||
}
|
||||
|
||||
tatic void change_file_status(char *path, struct cramfs_inode *i)
|
||||
{
|
||||
struct utimbuf epoch = { 0, 0 };
|
||||
|
||||
if (euid == 0) {
|
||||
if (lchown(path, i->uid, i->gid) < 0) {
|
||||
die(FSCK_ERROR, 1, "lchown failed: %s", path);
|
||||
}
|
||||
if (S_ISLNK(i->mode))
|
||||
return;
|
||||
if ((S_ISUID | S_ISGID) & i->mode) {
|
||||
if (chmod(path, i->mode) < 0) {
|
||||
die(FSCK_ERROR, 1, "chown failed: %s", path);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (S_ISLNK(i->mode))
|
||||
return;
|
||||
if (utime(path, &epoch) < 0) {
|
||||
die(FSCK_ERROR, 1, "utime failed: %s", path);
|
||||
}
|
||||
}
|
||||
|
||||
static void do_directory(char *path, struct cramfs_inode *i)
|
||||
{
|
||||
int pathlen = strlen(path);
|
||||
int count = i->size;
|
||||
unsigned long offset = i->offset << 2;
|
||||
char *newpath = malloc(pathlen + 256);
|
||||
|
||||
if (!newpath) {
|
||||
die(FSCK_ERROR, 1, "malloc failed");
|
||||
}
|
||||
if (offset == 0 && count != 0) {
|
||||
die(FSCK_UNCORRECTED, 0, "directory inode has zero offset and non-zero size: %s", path);
|
||||
}
|
||||
if (offset != 0 && offset < start_dir) {
|
||||
start_dir = offset;
|
||||
}
|
||||
/* TODO: Do we need to check end_dir for empty case? */
|
||||
memcpy(newpath, path, pathlen);
|
||||
newpath[pathlen] = '/';
|
||||
pathlen++;
|
||||
if (opt_verbose) {
|
||||
print_node('d', i, path);
|
||||
}
|
||||
if (opt_extract) {
|
||||
if (mkdir(path, i->mode) < 0) {
|
||||
die(FSCK_ERROR, 1, "mkdir failed: %s", path);
|
||||
}
|
||||
change_file_status(path, i);
|
||||
}
|
||||
while (count > 0) {
|
||||
struct cramfs_inode *child = iget(offset);
|
||||
int size;
|
||||
int newlen = child->namelen << 2;
|
||||
|
||||
size = sizeof(struct cramfs_inode) + newlen;
|
||||
count -= size;
|
||||
|
||||
offset += sizeof(struct cramfs_inode);
|
||||
|
||||
memcpy(newpath + pathlen, romfs_read(offset), newlen);
|
||||
newpath[pathlen + newlen] = 0;
|
||||
if (newlen == 0) {
|
||||
die(FSCK_UNCORRECTED, 0, "filename length is zero");
|
||||
}
|
||||
if ((pathlen + newlen) - strlen(newpath) > 3) {
|
||||
die(FSCK_UNCORRECTED, 0, "bad filename length");
|
||||
}
|
||||
expand_fs(newpath, child);
|
||||
|
||||
offset += newlen;
|
||||
|
||||
if (offset <= start_dir) {
|
||||
die(FSCK_UNCORRECTED, 0, "bad inode offset");
|
||||
}
|
||||
if (offset > end_dir) {
|
||||
end_dir = offset;
|
||||
}
|
||||
iput(child); /* free(child) */
|
||||
}
|
||||
free(newpath);
|
||||
}
|
||||
|
||||
void do_file(u8 *path, cramfs_inode *i)
|
||||
{
|
||||
u32 offset = i->offset << 2;
|
||||
if (offset == 0 && i->size != 0)
|
||||
return /*null de taille non nulle */
|
||||
if (i->size == 0 && offset != 0)
|
||||
return /*non null de taille nulle */
|
||||
if (offset != 0 && offset < start_data)
|
||||
start_data = offset;
|
||||
fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, i->mode);
|
||||
if (i->size)
|
||||
do_uncompress(path, fd, offset, i->size);
|
||||
close(fd);
|
||||
change_file_status(path, i);
|
||||
}
|
||||
|
||||
void expand_fs(u8 *path, cramfs_inode *inode)
|
||||
{
|
||||
if (S_ISDIR(inode->mode)) {
|
||||
do_directory(path, inode);
|
||||
}
|
||||
else if (S_ISREG(inode->mode)) {
|
||||
do_file(path, inode);
|
||||
}
|
||||
else if (S_ISLNK(inode->mode)) {
|
||||
/*do_symlink(path, inode);*/
|
||||
}
|
||||
else {
|
||||
/*do_special_inode(path, inode);*/
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Vérification d'une image cramfs */
|
||||
/* ERREURS :
|
||||
/* 1=taille du super bloc trop petite */
|
||||
/* 2=pas de magic */
|
||||
/* 3=pas géré */
|
||||
/* 4=superbloc trop petit */
|
||||
/* 5=aucune fichier */
|
||||
/* 6=taille entrée des fichiers trop petite */
|
||||
/* 7=taille entrée des fichiers trop grande */
|
||||
/* 8=version de cramfs non supportée */
|
||||
/* 9=crc erroné */
|
||||
|
||||
u32 test_super(u8 *src, u32 length) {
|
||||
super=(cramfs_super*)src;
|
||||
start = 0xFF;
|
||||
if (length < sizeof(cramfs_super)) {
|
||||
return 1;
|
||||
}
|
||||
if (super->magic == CRAMFS_MAGIC) {
|
||||
start = 0;
|
||||
}
|
||||
else if (length >= (PAD_SIZE + sizeof(super))) {
|
||||
if (super->magic == CRAMFS_MAGIC) {
|
||||
start = PAD_SIZE;
|
||||
}
|
||||
}
|
||||
else
|
||||
return 2;
|
||||
if (super->flags & ~CRAMFS_SUPPORTED_FLAGS)
|
||||
return 3;
|
||||
if (super->size < PAGE_CACHE_SIZE)
|
||||
return 4;
|
||||
if (super->flags & CRAMFS_FLAG_FSID_VERSION_2) {
|
||||
if (super->fsid.files == 0)
|
||||
return 5;
|
||||
if (length < super->size)
|
||||
return 6;
|
||||
else if (length > super->size)
|
||||
return 7;
|
||||
}
|
||||
else
|
||||
return 8;
|
||||
u32 oldcrc=super->fsid.crc;
|
||||
super->fsid.crc = crc32(0, 0, 0);
|
||||
u32 newcrc=crc32(0,src+*start,super->size-*start);
|
||||
super->fsid.crc = oldcrc;
|
||||
if (newcrc!=oldcrc)
|
||||
return 9;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,240 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "gdt.h"
|
||||
#include "asm.h"
|
||||
#include "types.h"
|
||||
#include "memory.h"
|
||||
|
||||
/* registre gdt */
|
||||
static struct gdtr gdtreg;
|
||||
|
||||
/* table de GDT */
|
||||
static gdtdes gdt[GDT_SIZE];
|
||||
|
||||
/* TSS */
|
||||
static struct tss tss0;
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Créé un descripteur GDT */
|
||||
|
||||
void makegdtdes(u32 base, u32 limite, u8 acces, u8 flags, gdtdes * desc)
|
||||
{
|
||||
desc->lim0_15 = (limite & 0xffff);
|
||||
desc->base0_15 = (base & 0xffff);
|
||||
desc->base16_23 = (base & 0xff0000) >> 16;
|
||||
desc->acces = acces;
|
||||
desc->lim16_19 = (limite & 0xf0000) >> 16;
|
||||
desc->flags = (flags & 0xf);
|
||||
desc->base24_31 = (base & 0xff000000) >> 24;
|
||||
return;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Initialise la GDT */
|
||||
|
||||
void initgdt(u32 offset)
|
||||
{
|
||||
makegdtdes(0x0, 0x00000, 0x00, 0x00, &gdt[0]); /* descripteur nul */
|
||||
makegdtdes(0x0, 0xFFFFF, SEG_PRESENT | SEG_NORMAL | SEG_CODE | SEG_RING0 | SEG_READ | SEG_ACCESSED, GRANULARITY_4K | OPSIZE_32B | SYS_AVAILABLE, &gdt[1]); /* code -> SEL_KERNEL_CODE */
|
||||
makegdtdes(0x0, 0x00000, SEG_PRESENT | SEG_NORMAL | SEG_DATA | SEG_RING0 | SEG_EXPAND_DOWN | SEG_READ_WRITE | SEG_ACCESSED, GRANULARITY_4K | OPSIZE_32B | SYS_AVAILABLE, &gdt[2]); /* pile -> SEL_KERNEL_STACK */
|
||||
makegdtdes(0x0, 0xFFFFF, SEG_PRESENT | SEG_NORMAL | SEG_CODE | SEG_RING3 | SEG_CONFORMING | SEG_READ | SEG_ACCESSED, GRANULARITY_4K | OPSIZE_32B | SYS_AVAILABLE, &gdt[3]); /* code -> SEL_USER_CODE */
|
||||
makegdtdes(0x0, 0x00000, SEG_PRESENT | SEG_NORMAL | SEG_DATA | SEG_RING3 | SEG_EXPAND_DOWN | SEG_READ_WRITE | SEG_ACCESSED, GRANULARITY_4K | OPSIZE_32B | SYS_AVAILABLE, &gdt[4]); /* pile -> SEL_USER_STACK */
|
||||
makegdtdes(0x0, 0xFFFFF, SEG_PRESENT | SEG_NORMAL | SEG_DATA | SEG_RING0 | SEG_READ_WRITE | SEG_ACCESSED, GRANULARITY_4K | OPSIZE_32B | SYS_AVAILABLE, &gdt[5]); /* data -> SEL_KERNEL_DATA */
|
||||
makegdtdes(0x0, 0xFFFFF, SEG_PRESENT | SEG_NORMAL | SEG_DATA | SEG_RING3 | SEG_READ_WRITE | SEG_ACCESSED, GRANULARITY_4K | OPSIZE_32B | SYS_AVAILABLE, &gdt[6]); /* data -> SEL_USER_DATA */
|
||||
|
||||
tss0.trapflag = 0x00;
|
||||
tss0.iomap = 0x00;
|
||||
tss0.esp0 = 0x6000;
|
||||
tss0.ss0 = SEL_TSS;
|
||||
|
||||
makegdtdes(&tss0, 0x67, SEG_PRESENT | SEG_CODE | SEG_RING3 | SEG_ACCESSED, 0x00, &gdt[7]); /* descripteur de tss */
|
||||
|
||||
/* initialise le registre gdt */
|
||||
gdtreg.limite = GDT_SIZE * sizeof(gdtdes);
|
||||
gdtreg.base = GDT_ADDR;
|
||||
/* recopie de la GDT a son adresse */
|
||||
memcpy(&gdt, (u8 *) gdtreg.base, gdtreg.limite, 1);
|
||||
/* chargement du registre GDT */
|
||||
lgdt(gdtreg);
|
||||
/* initialisation des segments */
|
||||
initselectors(offset);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Initialise les selecteurs avec la GDT */
|
||||
|
||||
void initselectors(u32 executingoffset)
|
||||
{
|
||||
asm(" movw %[data], %%ax \n \
|
||||
movw %%ax, %%ds \n \
|
||||
movw %%ax, %%es \n \
|
||||
movw %%ax, %%fs \n \
|
||||
movw %%ax, %%gs \n \
|
||||
movw %[stack], %%ax \n \
|
||||
movl %[offset], %%ebx \n \
|
||||
movw %%ax, %%ss \n \
|
||||
movl %[stackoff], %%esp \n \
|
||||
pushl %%ebx \n \
|
||||
ljmp %[code],$raz \n \
|
||||
raz:\n \
|
||||
xor %%eax,%%eax\n\
|
||||
xor %%ebx,%%ebx\n\
|
||||
xor %%ecx,%%ecx\n\
|
||||
xor %%edx,%%edx\n\
|
||||
xor %%esi,%%esi\n\
|
||||
xor %%edi,%%edi\n\
|
||||
xor %%ebp,%%ebp\n\
|
||||
ret"::[data] "i"(SEL_KERNEL_DATA),[code] "i"(SEL_KERNEL_CODE),[stack] "i"(SEL_KERNEL_STACK),[stackoff] "i"(KERNEL_STACK_ADDR),[offset] "m"(executingoffset));
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Change le TSS courant */
|
||||
|
||||
void setTSS(u32 ss, u32 sp)
|
||||
{
|
||||
|
||||
tss0.trapflag = 0x00;
|
||||
tss0.iomap = 0x00;
|
||||
tss0.ss0 = SEL_TSS;
|
||||
tss0.esp0 = sp;
|
||||
tss0.ss0 = ss;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Initialise le registre de tâche (TSR) */
|
||||
|
||||
void inittr(void)
|
||||
{
|
||||
ltr(SEL_TSS);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* récupère la base d'un descripteur GDT */
|
||||
|
||||
u32 getdesbase(u16 sel)
|
||||
{
|
||||
gdtdes *entry = GDT_ADDR;
|
||||
u8 index = sel / sizeof(gdtdes);
|
||||
return (entry[index].base0_15 + (entry[index].base16_23 << 16) +
|
||||
(entry[index].base24_31 << 24));
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* récupère la limite d'un descripteur GDT */
|
||||
|
||||
u32 getdeslimit(u16 sel)
|
||||
{
|
||||
gdtdes *entry = GDT_ADDR;
|
||||
u8 index = sel / sizeof(gdtdes);
|
||||
return (entry[index].lim0_15 + (entry[index].lim16_19 << 16));
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* récupère la limite d'un descripteur GDT */
|
||||
|
||||
u32 getdesdpl(u16 sel)
|
||||
{
|
||||
gdtdes *entry = GDT_ADDR;
|
||||
u8 index = sel / sizeof(gdtdes);
|
||||
return (entry[index].acces >> 5 & 0x03);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* récupère le type d'un descripteur GDT */
|
||||
|
||||
u8 getdestype(u16 sel)
|
||||
{
|
||||
gdtdes *entry = GDT_ADDR;
|
||||
u8 index = sel / sizeof(gdtdes);
|
||||
if (((entry[index].acces & 0x14) == 0)
|
||||
&& ((entry[index].acces & 0x08) > 0)
|
||||
&& ((entry[index].acces & 0x01) > 0)
|
||||
&& ((entry[index].flags & 0x06) == 0))
|
||||
return 'T';
|
||||
else
|
||||
return (((entry[index].acces & 0x08) > 0) ? 'C' : 'D');
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* récupère l'info 1 d'un descripteur GDT */
|
||||
|
||||
u8 getdesbit1(u16 sel)
|
||||
{
|
||||
gdtdes *entry = GDT_ADDR;
|
||||
u8 index = sel / sizeof(gdtdes);
|
||||
if (((entry[index].acces & 0x14) == 0)
|
||||
&& ((entry[index].acces & 0x08) > 0)
|
||||
&& ((entry[index].acces & 0x01) > 0)
|
||||
&& ((entry[index].flags & 0x06) == 0))
|
||||
return (((entry[index].acces & 0x04) > 0) ? 'B' : '-');
|
||||
else
|
||||
return (((entry[index].acces & 0x01) > 0) ? 'A' : '-');
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* récupère l'info 2 d'un descripteur GDT */
|
||||
|
||||
u8 getdesbit2(u16 sel)
|
||||
{
|
||||
gdtdes *entry = GDT_ADDR;
|
||||
u8 index = sel / sizeof(gdtdes);
|
||||
if (((entry[index].acces & 0x20) == 0)
|
||||
&& ((entry[index].acces & 0x08) > 0)
|
||||
&& ((entry[index].acces & 0x01) > 0)
|
||||
&& ((entry[index].flags & 0x06) == 0))
|
||||
return (((entry[index].flags & 0x01) > 0) ? 'U' : '-');
|
||||
else if ((entry[index].acces & 0x8) > 0)
|
||||
return (((entry[index].acces & 0x02) > 0) ? 'R' : '-');
|
||||
else
|
||||
return (((entry[index].acces & 0x02) > 0) ? 'W' : 'R');
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* récupère l'info 3 d'un descripteur GDT */
|
||||
|
||||
u8 getdesbit3(u16 sel)
|
||||
{
|
||||
gdtdes *entry = GDT_ADDR;
|
||||
u8 index = sel / sizeof(gdtdes);
|
||||
if ((entry[index].acces & 0x08) > 0)
|
||||
return (((entry[index].acces & 0x04) > 0) ? 'C' : '-');
|
||||
else
|
||||
return (((entry[index].acces & 0x04) > 0) ? 'D' : 'U');
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* récupère l'alignement d'un descripteur GDT */
|
||||
|
||||
u16 getdesalign(u16 sel)
|
||||
{
|
||||
gdtdes *entry = GDT_ADDR;
|
||||
u8 index = sel / sizeof(gdtdes);
|
||||
return (((entry[index].flags & 0x08) > 0) ? 4096 : 1);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* récupère si descripteur GDT est valide */
|
||||
|
||||
bool isdesvalid(u16 sel)
|
||||
{
|
||||
gdtdes *entry = GDT_ADDR;
|
||||
u8 index = sel / sizeof(gdtdes);
|
||||
return ((entry[index].acces & 0x80) > 0);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* récupère la dimension d'un descripteur GDT */
|
||||
|
||||
u32 getdessize(u16 sel)
|
||||
{
|
||||
gdtdes *entry = GDT_ADDR;
|
||||
u8 index = sel / sizeof(gdtdes);
|
||||
if (((entry[index].acces & 0x14) == 0)
|
||||
&& ((entry[index].acces & 0x08) > 0)
|
||||
&& ((entry[index].acces & 0x01) > 0)
|
||||
&& ((entry[index].flags & 0x06) == 0))
|
||||
return 32;
|
||||
else
|
||||
return (((entry[index].flags & 0x08) > 0) ? 32 : 16);
|
||||
}
|
58
lib/graph.c
58
lib/graph.c
|
@ -1,58 +0,0 @@
|
|||
#include "types.h"
|
||||
#include "vga.h"
|
||||
#include "video.h"
|
||||
#include "graph.h"
|
||||
#include "math.h"
|
||||
|
||||
/******************************************************************************/
|
||||
|
||||
/* Affiche une ligne entre les points spécifiés */
|
||||
|
||||
void line(u32 x1, u32 y1, u32 x2, u32 y2, u8 color)
|
||||
{
|
||||
s32 dx,dy,sdx,sdy;
|
||||
u32 i,dxabs,dyabs,x,y,px,py;
|
||||
|
||||
dx=x2-x1; /* distance horizontale de la line */
|
||||
dy=y2-y1; /* distance verticale de la line **/
|
||||
dxabs=abs(dx);
|
||||
dyabs=abs(dy);
|
||||
sdx=sgn(dx);
|
||||
sdy=sgn(dy);
|
||||
x=dyabs>>1;
|
||||
y=dxabs>>1;
|
||||
px=x1;
|
||||
py=y1;
|
||||
|
||||
writepxl(px,py,color);
|
||||
|
||||
if (dxabs>=dyabs) /* la ligne est plus horizontale que verticale */
|
||||
{
|
||||
for(i=0;i<dxabs;i++)
|
||||
{
|
||||
y+=dyabs;
|
||||
if (y>=dxabs)
|
||||
{
|
||||
y-=dxabs;
|
||||
py+=sdy;
|
||||
}
|
||||
px+=sdx;
|
||||
writepxl(px,py,color);
|
||||
}
|
||||
}
|
||||
else /* la ligne est plus verticale que horizontale */
|
||||
{
|
||||
for(i=0;i<dyabs;i++)
|
||||
{
|
||||
x+=dxabs;
|
||||
if (x>=dyabs)
|
||||
{
|
||||
x-=dyabs;
|
||||
px+=sdx;
|
||||
}
|
||||
py+=sdy;
|
||||
writepxl(px,py,color);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,341 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "interrupts.h"
|
||||
#include "types.h"
|
||||
#include "asm.h"
|
||||
#include "memory.h"
|
||||
#include "video.h"
|
||||
#include "gdt.h"
|
||||
#include "system.h"
|
||||
#include "debug.h"
|
||||
#include "process.h"
|
||||
|
||||
/******************************************************************************/
|
||||
/* Déclenché lors de l'appel d'une interruption */
|
||||
|
||||
__attribute__ ((noreturn)) void interruption_handler(regs *dump)
|
||||
{
|
||||
u32 interruption=dump->eip;
|
||||
exception_stack_noerror *caller = (exception_stack_noerror*) ((u32*)dump->esp+1);
|
||||
bool noerror,user;
|
||||
if ((caller->cs & 0xFFF8)==SEL_KERNEL_CODE || (caller->cs & 0xFFF8)==SEL_USER_CODE)
|
||||
{
|
||||
noerror=true;
|
||||
dump->eip = caller->eip;
|
||||
dump->cs = caller->cs;
|
||||
dump->eflags = caller->eflags;
|
||||
if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
|
||||
{
|
||||
dump->esp = (u32) caller + sizeof(exception_stack_noerror);
|
||||
user=false;
|
||||
}
|
||||
else
|
||||
{
|
||||
dump->esp = (u32) ((exception_stack_noerror_user*) caller)->esp;
|
||||
dump->ss = (u32) ((exception_stack_noerror_user*) caller)->ss;
|
||||
user=true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
noerror=false;
|
||||
dump->eip = ((exception_stack*)caller)->eip;
|
||||
dump->cs = ((exception_stack*)caller)->cs;
|
||||
if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
|
||||
{
|
||||
dump->esp = (u32) caller + sizeof(exception_stack);
|
||||
user=false;
|
||||
}
|
||||
else
|
||||
{
|
||||
dump->esp = (u32) ((exception_stack_user*) caller)->esp;
|
||||
dump->ss = (u32) ((exception_stack_user*) caller)->ss;
|
||||
user=true;
|
||||
}
|
||||
}
|
||||
switch (interruption)
|
||||
{
|
||||
case 20:
|
||||
show_lightcpu(dump);
|
||||
break;
|
||||
default:
|
||||
print("Appel d'une interruption\r\n");
|
||||
}
|
||||
if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
|
||||
{
|
||||
setESP(dump);
|
||||
restcpu_kernel();
|
||||
}
|
||||
else
|
||||
{
|
||||
setESP(dump);
|
||||
restcpu_user();
|
||||
iret();
|
||||
}
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Les expections */
|
||||
|
||||
static u8 ex14_errors1[] =
|
||||
"Supervisory process tried to read a non-present page entry";
|
||||
static u8 ex14_errors2[] =
|
||||
"Supervisory process tried to read a page and caused a protection fault";
|
||||
static u8 ex14_errors3[] =
|
||||
"Supervisory process tried to write to a non-present page entry";
|
||||
static u8 ex14_errors4[] =
|
||||
"Supervisory process tried to write a page and caused a protection fault";
|
||||
static u8 ex14_errors5[] =
|
||||
"User process tried to read a non-present page entry";
|
||||
static u8 ex14_errors6[] =
|
||||
"User process tried to read a page and caused a protection fault";
|
||||
static u8 ex14_errors7[] =
|
||||
"User process tried to write to a non-present page entry";
|
||||
static u8 ex14_errors8[] =
|
||||
"User process tried to write a page and caused a protection fault";
|
||||
static u8 *ex14_errors[] =
|
||||
{ &ex14_errors1, &ex14_errors2, &ex14_errors3, &ex14_errors4,
|
||||
&ex14_errors5, &ex14_errors6, &ex14_errors7, &ex14_errors8
|
||||
};
|
||||
|
||||
__attribute__ ((noreturn)) void exception_handler(regs *dump)
|
||||
{
|
||||
u32 exception=dump->eip;
|
||||
exception_stack_noerror *caller = (exception_stack_noerror*) ((u32*)dump->esp+1);
|
||||
bool noerror,user;
|
||||
if ((caller->cs & 0xFFF8)==SEL_KERNEL_CODE || (caller->cs & 0xFFF8)==SEL_USER_CODE)
|
||||
{
|
||||
noerror=true;
|
||||
dump->eip = caller->eip;
|
||||
dump->cs = caller->cs;
|
||||
dump->eflags = caller->eflags;
|
||||
if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
|
||||
{
|
||||
dump->esp = (u32) caller + sizeof(exception_stack_noerror);
|
||||
user=false;
|
||||
}
|
||||
else
|
||||
{
|
||||
dump->esp = (u32) ((exception_stack_noerror_user*) caller)->esp;
|
||||
dump->ss = (u32) ((exception_stack_noerror_user*) caller)->ss;
|
||||
user=true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
noerror=false;
|
||||
dump->eip = ((exception_stack*)caller)->eip;
|
||||
dump->cs = ((exception_stack*)caller)->cs;
|
||||
if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
|
||||
{
|
||||
dump->esp = (u32) caller + sizeof(exception_stack);
|
||||
user=false;
|
||||
}
|
||||
else
|
||||
{
|
||||
dump->esp = (u32) ((exception_stack_user*) caller)->esp;
|
||||
dump->ss = (u32) ((exception_stack_user*) caller)->ss;
|
||||
user=true;
|
||||
}
|
||||
}
|
||||
switch (exception)
|
||||
{
|
||||
case 0:
|
||||
cpuerror("#DE Divide error", dump, false);
|
||||
case 1:
|
||||
changevc(6);
|
||||
clearscreen();
|
||||
show_lightcpu(dump);
|
||||
printf("\r\n\033[7m[P]\033[0m PAS A PAS \033[7m D \033[0m PAS A PAS DETAILLE \033[7m C \033[0m CONTINUER \033[7m S \033[0m STOPPER \033[7m V \033[0m VOIR \033[7m S \033[0m SCINDER");
|
||||
sti();
|
||||
u8 ascii = waitascii();
|
||||
cli();
|
||||
if (ascii == 'P' || ascii == 'p')
|
||||
setdebugreg(0,
|
||||
caller->eip + disasm(caller->eip, NULL, false),
|
||||
DBG_EXEC);
|
||||
else if (ascii == 'D' || ascii == 'd')
|
||||
setdebugreg(0, 0, DBG_CLEAR);
|
||||
else if (ascii == 'C' || ascii == 'c')
|
||||
setdebugreg(0, 0, DBG_CLEAR);
|
||||
else if (ascii == 'S' || ascii == 's')
|
||||
{
|
||||
changevc(0);
|
||||
sti();
|
||||
initselectors(getinitretry());
|
||||
}
|
||||
changevc(0);
|
||||
goto endofexception;
|
||||
case 2:
|
||||
cpuerror("NMI Non-maskable hardware interrupt", dump, false);
|
||||
case 3:
|
||||
cpuerror("#BP INT3 instruction", dump, true);
|
||||
iret();
|
||||
case 4:
|
||||
cpuerror("#OF INTO instruction detected overflow", dump, false);
|
||||
case 5:
|
||||
cpuerror("#BR BOUND instruction detected overrange", dump, false);
|
||||
case 6:
|
||||
cpuerror("#UD Invalid instruction opcode", dump, false);
|
||||
case 7:
|
||||
cpuerror("#NM No coprocessor", dump, false);
|
||||
case 8:
|
||||
cpuerror("#DF Double fault", dump, false);
|
||||
case 9:
|
||||
cpuerror("Coprocessor segment overrun", dump, false);
|
||||
case 10:
|
||||
cpuerror("#TS Invalid task state segment (TSS)", dump, false);
|
||||
case 11:
|
||||
cpuerror("#NP Segment not present", dump, false);
|
||||
case 12:
|
||||
cpuerror("#SS Stack fault", dump, false);
|
||||
case 13:
|
||||
cpuerror("#GP General protection fault (GPF)", dump, false);
|
||||
case 14:
|
||||
if (dump->cr2 >= USER_CODE && dump->cr2 < USER_STACK)
|
||||
{
|
||||
virtual_range_new(findcurrentprocess()->pdd,
|
||||
(u8 *) (dump->cr2 & 0xFFFFF000),
|
||||
PAGESIZE, PAGE_ALL);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("Page fault - %s at adress %Y cs:eip - %Y:%Y\r\n",
|
||||
ex14_errors[((exception_stack*) caller)->error_code & 0xF], dump->cr2,
|
||||
dump->cs, dump->eip);
|
||||
cpuerror("#PGF Page fault", dump, false);
|
||||
}
|
||||
goto endofexception;
|
||||
case 15:
|
||||
cpuerror("(reserved)", dump, false);
|
||||
case 16:
|
||||
cpuerror("#MF Coprocessor error", dump, false);
|
||||
case 17:
|
||||
cpuerror("#AC Alignment check", dump, false);
|
||||
case 18:
|
||||
cpuerror("#MC Machine check", dump, false);
|
||||
}
|
||||
endofexception:
|
||||
if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
|
||||
{
|
||||
setESP(dump);
|
||||
restcpu_kernel();
|
||||
}
|
||||
else
|
||||
{
|
||||
setESP(dump);
|
||||
restcpu_user();
|
||||
iret();
|
||||
}
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Les IRQ par défaut */
|
||||
|
||||
__attribute__((interrupt)) void irq0(exception_stack_noerror *caller)
|
||||
{
|
||||
print("irq 0");
|
||||
irqendmaster();
|
||||
}
|
||||
|
||||
__attribute__((interrupt)) void irq1(exception_stack_noerror *caller)
|
||||
{
|
||||
print("irq 1");
|
||||
while ((inb(0x64) & 1) == 0);
|
||||
inb(0x60);
|
||||
irqendmaster();
|
||||
}
|
||||
|
||||
__attribute__((interrupt)) void irq2(exception_stack_noerror *caller)
|
||||
{ print("irq 2");
|
||||
irqendmaster();
|
||||
}
|
||||
|
||||
__attribute__((interrupt)) void irq3(exception_stack_noerror *caller)
|
||||
{
|
||||
print("irq 3");
|
||||
irqendmaster();
|
||||
}
|
||||
|
||||
__attribute__((interrupt)) void irq4(exception_stack_noerror *caller)
|
||||
{
|
||||
print("irq 4");
|
||||
irqendmaster();
|
||||
}
|
||||
|
||||
__attribute__((interrupt)) void irq5(exception_stack_noerror *caller)
|
||||
{
|
||||
print("irq 5");
|
||||
irqendmaster();
|
||||
}
|
||||
|
||||
__attribute__((interrupt)) void irq6(exception_stack_noerror *caller)
|
||||
{
|
||||
print("irq 6");
|
||||
irqendmaster();
|
||||
}
|
||||
|
||||
__attribute__((interrupt)) void irq7(exception_stack_noerror *caller)
|
||||
{
|
||||
print("irq 7");
|
||||
irqendmaster();
|
||||
}
|
||||
|
||||
__attribute__((interrupt)) void irq8(exception_stack_noerror *caller)
|
||||
{
|
||||
print("irq 8");
|
||||
irqendslave();
|
||||
irqendmaster();
|
||||
}
|
||||
|
||||
__attribute__((interrupt)) void irq9(exception_stack_noerror *caller)
|
||||
{
|
||||
print("irq 9");
|
||||
irqendslave();
|
||||
irqendmaster();
|
||||
}
|
||||
|
||||
__attribute__((interrupt)) void irq10(exception_stack_noerror *caller)
|
||||
{
|
||||
print("irq 10");
|
||||
irqendslave();
|
||||
irqendmaster();
|
||||
}
|
||||
|
||||
__attribute__((interrupt)) void irq11(exception_stack_noerror *caller)
|
||||
{
|
||||
print("irq 11");
|
||||
irqendslave();
|
||||
irqendmaster();
|
||||
}
|
||||
|
||||
__attribute__((interrupt)) void irq12(exception_stack_noerror *caller)
|
||||
{
|
||||
print("irq 12");
|
||||
while ((inb(0x64) & 1) == 0);
|
||||
inb(0x60);
|
||||
irqendslave();
|
||||
irqendmaster();
|
||||
}
|
||||
|
||||
__attribute__((interrupt)) void irq13(exception_stack_noerror *caller)
|
||||
{
|
||||
print("irq 13");
|
||||
irqendslave();
|
||||
irqendmaster();
|
||||
}
|
||||
|
||||
__attribute__((interrupt)) void irq14(exception_stack_noerror *caller)
|
||||
{
|
||||
print("irq 14");
|
||||
irqendslave();
|
||||
irqendmaster();
|
||||
}
|
||||
|
||||
__attribute__((interrupt)) void irq15(exception_stack_noerror *caller)
|
||||
{
|
||||
print("irq 15");
|
||||
irqendslave();
|
||||
irqendmaster();
|
||||
}
|
|
@ -0,0 +1,120 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
|
||||
.section .text
|
||||
|
||||
.macro exception num
|
||||
.global wrapper_exception\num
|
||||
wrapper_exception\num:
|
||||
pushl %ss
|
||||
pushl %esp
|
||||
pushf
|
||||
pushl %cs
|
||||
pushl $\num
|
||||
jmp exception_suite
|
||||
.endm
|
||||
|
||||
.macro semidumpcpu
|
||||
cli
|
||||
pushl %ds
|
||||
pushl %es
|
||||
pushl %fs
|
||||
pushl %gs
|
||||
pushl %eax
|
||||
pushl %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
pushl %esi
|
||||
pushl %edi
|
||||
pushl %ebp
|
||||
mov %cr0, %eax
|
||||
pushl %eax
|
||||
mov %cr2, %eax
|
||||
pushl %eax
|
||||
mov %cr3, %eax
|
||||
pushl %eax
|
||||
mov %cr4, %eax
|
||||
pushl %eax
|
||||
mov %dr0, %eax
|
||||
pushl %eax
|
||||
mov %dr1, %eax
|
||||
pushl %eax
|
||||
mov %dr2, %eax
|
||||
pushl %eax
|
||||
mov %dr3, %eax
|
||||
pushl %eax
|
||||
mov %dr6, %eax
|
||||
pushl %eax
|
||||
mov %dr7, %eax
|
||||
pushl %eax
|
||||
mov $0xC0000080, %ecx
|
||||
rdmsr
|
||||
pushl %edx
|
||||
pushl %eax
|
||||
pushl %esp
|
||||
.endm
|
||||
|
||||
exception 0
|
||||
exception 1
|
||||
exception 2
|
||||
exception 3
|
||||
exception 4
|
||||
exception 5
|
||||
exception 6
|
||||
exception 7
|
||||
exception 8
|
||||
exception 9
|
||||
exception 10
|
||||
exception 11
|
||||
exception 12
|
||||
exception 13
|
||||
exception 14
|
||||
exception 15
|
||||
exception 16
|
||||
exception 17
|
||||
exception 18
|
||||
|
||||
exception_suite:
|
||||
semidumpcpu
|
||||
call exception_handler
|
||||
|
||||
.global wrapper_sysenter
|
||||
wrapper_sysenter:
|
||||
pushl %ss
|
||||
pushl %esp
|
||||
pushf
|
||||
pushl %cs
|
||||
pushl $0x00
|
||||
semidumpcpu
|
||||
call sysenter_handler
|
||||
|
||||
.global wrapper_interruption20
|
||||
wrapper_interruption20:
|
||||
pushl %ss
|
||||
pushl %esp
|
||||
pushf
|
||||
pushl %cs
|
||||
pushl $0x14
|
||||
semidumpcpu
|
||||
call interruption_handler
|
||||
|
||||
.global wrapper_interruption
|
||||
wrapper_interruption:
|
||||
pushl %ss
|
||||
pushl %esp
|
||||
pushf
|
||||
pushl %cs
|
||||
pushl $0x00
|
||||
semidumpcpu
|
||||
call interruption_handler
|
||||
|
||||
.global wrapper_timer
|
||||
wrapper_timer:
|
||||
pushl %ss
|
||||
pushl %esp
|
||||
pushf
|
||||
pushl %cs
|
||||
pushl $0x00
|
||||
semidumpcpu
|
||||
call timer_handler
|
511
lib/idt.c
511
lib/idt.c
|
@ -1,511 +0,0 @@
|
|||
#include "idt.h"
|
||||
#include "types.h"
|
||||
#include "asm.h"
|
||||
#include "memory.h"
|
||||
#include "video.h"
|
||||
|
||||
/* registre idt */
|
||||
static struct dtr idtreg;
|
||||
|
||||
/* table de IDT */
|
||||
static idtdes idt[256];
|
||||
|
||||
|
||||
void initpic(void)
|
||||
{
|
||||
/* MASTER */
|
||||
/* Initialisation de ICW1 */
|
||||
outb(0x20,0x11);
|
||||
nop();
|
||||
/* Initialisation de ICW2 - vecteur de depart = 32 */
|
||||
outb(0x21,0x20);
|
||||
nop();
|
||||
/* Initialisation de ICW3 */
|
||||
outb(0x21,0x04);
|
||||
nop();
|
||||
/* Initialisation de ICW4 */
|
||||
outb(0x21,0x01);
|
||||
nop();
|
||||
/* masquage des interruptions */
|
||||
outb(0x21,0xFF);
|
||||
nop();
|
||||
/* SLAVE */
|
||||
/* Initialisation de ICW1 */
|
||||
outb(0xA0,0x11);
|
||||
nop();
|
||||
/* Initialisation de ICW2 - vecteur de depart = 96 */
|
||||
outb(0xA1,0x60);
|
||||
nop();
|
||||
/* Initialisation de ICW3 */
|
||||
outb(0xA1,0x02);
|
||||
nop();
|
||||
/* Initialisation de ICW4 */
|
||||
outb(0xA1,0x01);
|
||||
nop();
|
||||
/* masquage des interruptions */
|
||||
outb(0xA1,0xFF);
|
||||
nop();
|
||||
/* Demasquage des irqs sauf clavier
|
||||
outb(0x21,0xFD);
|
||||
nop();
|
||||
*/
|
||||
}
|
||||
|
||||
void enableirq(u8 irq)
|
||||
{
|
||||
u16 port;
|
||||
cli();
|
||||
port = (((irq & 0x08) << 4) + 0x21);
|
||||
outb(port,inb(port) & ~(1 << (irq & 7)));
|
||||
sti();
|
||||
}
|
||||
|
||||
void disableirq(u8 irq)
|
||||
{
|
||||
u16 port;
|
||||
cli();
|
||||
port = (((irq & 0x08) << 4) + 0x21);
|
||||
outb(port,inb(port) | (1 << (irq & 7)));
|
||||
sti();
|
||||
}
|
||||
|
||||
void makeidtdes(u32 offset, u16 select, u16 type, idtdes* desc)
|
||||
{
|
||||
desc->offset0_15 = (offset & 0xffff);
|
||||
desc->select = select;
|
||||
desc->type = type;
|
||||
desc->offset16_31 = (offset & 0xffff0000) >> 16;
|
||||
return;
|
||||
}
|
||||
|
||||
void setidt(u32 offset, u16 select, u16 type,u16 index)
|
||||
{
|
||||
cli();
|
||||
idtdes *desc;
|
||||
desc=idtreg.base;
|
||||
desc[index].offset0_15 = (offset & 0xffff);
|
||||
desc[index].select = select;
|
||||
desc[index].type = type;
|
||||
desc[index].offset16_31 = (offset & 0xffff0000) >> 16;
|
||||
sti();
|
||||
}
|
||||
|
||||
void putidt(u32 offset, u16 select, u16 type,u16 index)
|
||||
{
|
||||
idtdes temp;
|
||||
makeidtdes(offset,select,type,&temp);
|
||||
idt[index]=temp;
|
||||
}
|
||||
|
||||
void cpuerror(const u8 *src)
|
||||
{
|
||||
print("\033[31m***** ERREUR CPU ****\r\n -");
|
||||
print(src);
|
||||
dump_regs();
|
||||
while(1)
|
||||
{
|
||||
nop();
|
||||
}
|
||||
}
|
||||
|
||||
void interruption()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
print("Appel d'une interruption\r\n");
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
iret();
|
||||
}
|
||||
|
||||
void exception0()
|
||||
{
|
||||
print("divide error\r\n");
|
||||
}
|
||||
|
||||
void exception1()
|
||||
{
|
||||
cpuerror("debug exception\r\n");
|
||||
}
|
||||
|
||||
void exception2()
|
||||
{
|
||||
cpuerror("non-maskable hardware interrupt\r\n");
|
||||
}
|
||||
|
||||
void exception3()
|
||||
{
|
||||
cpuerror("INT3 instruction\r\n");
|
||||
}
|
||||
|
||||
void exception4()
|
||||
{
|
||||
cpuerror("INTO instruction detected overflow\r\n");
|
||||
}
|
||||
|
||||
void exception5()
|
||||
{
|
||||
print("BOUND instruction detected overrange\r\n");
|
||||
}
|
||||
|
||||
void exception6()
|
||||
{
|
||||
cpuerror("invalid instruction opcode\r\n");
|
||||
}
|
||||
|
||||
void exception7()
|
||||
{
|
||||
cpuerror("no coprocessor\r\n");
|
||||
}
|
||||
|
||||
void exception8()
|
||||
{
|
||||
cpuerror("double fault\r\n");
|
||||
}
|
||||
|
||||
void exception9()
|
||||
{
|
||||
cpuerror("coprocessor segment overrun\r\n");
|
||||
}
|
||||
|
||||
void exception10()
|
||||
{
|
||||
cpuerror("invalid task state segment (TSS)\r\n");
|
||||
}
|
||||
|
||||
void exception11()
|
||||
{
|
||||
cpuerror("segment not present\r\n");
|
||||
}
|
||||
|
||||
void exception12()
|
||||
{
|
||||
cpuerror("stack fault");
|
||||
}
|
||||
|
||||
void exception13()
|
||||
{
|
||||
cpuerror("general protection fault (GPF)\r\n");
|
||||
}
|
||||
|
||||
void exception14()
|
||||
{
|
||||
cpuerror("page fault\r\n");
|
||||
}
|
||||
|
||||
void exception15()
|
||||
{
|
||||
cpuerror("(reserved)\r\n");
|
||||
}
|
||||
|
||||
void exception16()
|
||||
{
|
||||
cpuerror("coprocessor error\r\n");
|
||||
}
|
||||
|
||||
void exception17()
|
||||
{
|
||||
cpuerror("alignment check\r\n");
|
||||
}
|
||||
|
||||
void exception18()
|
||||
{
|
||||
cpuerror("machine check");
|
||||
}
|
||||
|
||||
void irq0()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
print("irq 0");
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
void irq1()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
print("irq 1");
|
||||
while ((inb(0x64)&1)==0);
|
||||
inb(0x60);
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
void irq2()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
print("irq 2");
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
void irq3()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
print("irq 3");
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
void irq4()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
print("irq 4");
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
void irq5()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
print("irq 5");
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
void irq6()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
print("irq 6");
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
void irq7()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
print("irq 7");
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
void irq8()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
print("irq 8");
|
||||
irqendslave();
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
void irq9()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
print("irq 9");
|
||||
irqendslave();
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
void irq10()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
print("irq 10");
|
||||
irqendslave();
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
void irq11()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
print("irq 11");
|
||||
irqendslave();
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
void irq12()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
print("irq 12");
|
||||
while ((inb(0x64)&1)==0);
|
||||
inb(0x60);
|
||||
irqendslave();
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
void irq13()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
print("irq 13");
|
||||
irqendslave();
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
void irq14()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
print("irq 14");
|
||||
irqendslave();
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
void irq15()
|
||||
{
|
||||
cli();
|
||||
print("irq 15");
|
||||
irqendslave();
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
void initidt(void)
|
||||
{
|
||||
u16 i;
|
||||
putidt((u32)exception0, 0x20, INTGATE, 0);
|
||||
putidt((u32)exception1, 0x20, INTGATE, 1);
|
||||
putidt((u32)exception2, 0x20, INTGATE, 2);
|
||||
putidt((u32)exception3, 0x20, INTGATE, 3);
|
||||
putidt((u32)exception4, 0x20, INTGATE, 4);
|
||||
putidt((u32)exception5, 0x20, INTGATE, 5);
|
||||
putidt((u32)exception6, 0x20, INTGATE, 6);
|
||||
putidt((u32)exception7, 0x20, INTGATE, 7);
|
||||
putidt((u32)exception8, 0x20, INTGATE, 8);
|
||||
putidt((u32)exception9, 0x20, INTGATE, 9);
|
||||
putidt((u32)exception10, 0x20, INTGATE, 10);
|
||||
putidt((u32)exception11, 0x20, INTGATE, 11);
|
||||
putidt((u32)exception12, 0x20, INTGATE, 12);
|
||||
putidt((u32)exception13, 0x20, INTGATE, 13);
|
||||
putidt((u32)exception14, 0x20, INTGATE, 14);
|
||||
putidt((u32)exception15, 0x20, INTGATE, 15);
|
||||
putidt((u32)exception16, 0x20, INTGATE, 16);
|
||||
putidt((u32)exception17, 0x20, INTGATE, 17);
|
||||
putidt((u32)exception18, 0x20, INTGATE, 18);
|
||||
for(i=19;i<32;i++)
|
||||
{
|
||||
putidt((u32)interruption, 0x20, INTGATE, i);
|
||||
}
|
||||
putidt((u32)irq0, 0x20, INTGATE, 32);
|
||||
putidt((u32)irq1, 0x20, INTGATE, 33);
|
||||
putidt((u32)irq2, 0x20, INTGATE, 34);
|
||||
putidt((u32)irq3, 0x20, INTGATE, 35);
|
||||
putidt((u32)irq4, 0x20, INTGATE, 36);
|
||||
putidt((u32)irq5, 0x20, INTGATE, 37);
|
||||
putidt((u32)irq6, 0x20, INTGATE, 38);
|
||||
putidt((u32)irq7, 0x20, INTGATE, 39);
|
||||
for(i=40;i<96;i++)
|
||||
{
|
||||
putidt((u32)interruption, 0x20, INTGATE, i);
|
||||
}
|
||||
putidt((u32)irq8, 0x20, INTGATE, 96);
|
||||
putidt((u32)irq9, 0x20, INTGATE, 97);
|
||||
putidt((u32)irq10, 0x20, INTGATE, 98);
|
||||
putidt((u32)irq11, 0x20, INTGATE, 99);
|
||||
putidt((u32)irq12, 0x20, INTGATE, 100);
|
||||
putidt((u32)irq13, 0x20, INTGATE, 101);
|
||||
putidt((u32)irq14, 0x20, INTGATE, 102);
|
||||
putidt((u32)irq15, 0x20, INTGATE, 103);
|
||||
for(i=104;i<255;i++)
|
||||
{
|
||||
putidt((u32)interruption, 0x20, INTGATE, i);
|
||||
}
|
||||
/* initialise le registre idt */
|
||||
idtreg.limite = 256*8;
|
||||
idtreg.base = 0x0000000;
|
||||
/* recopie de la IDT a son adresse */
|
||||
memcpy(&idt, (u8*)idtreg.base, idtreg.limite,1);
|
||||
/* chargement du registre IDTR */
|
||||
lidt(&idtreg);
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,276 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "interrupts.h"
|
||||
#include "types.h"
|
||||
#include "asm.h"
|
||||
#include "memory.h"
|
||||
#include "video.h"
|
||||
#include "gdt.h"
|
||||
#include "system.h"
|
||||
#include "debug.h"
|
||||
#include "process.h"
|
||||
#include "handlers.h"
|
||||
|
||||
#define IDT_SIZE 256 /* nombre de descripteurs */
|
||||
|
||||
/* registre idt */
|
||||
static struct idtr idtreg;
|
||||
|
||||
/* table de IDT */
|
||||
static idtdes idt[IDT_SIZE];
|
||||
|
||||
static u32 retry_address;
|
||||
|
||||
extern wrapper_exception0;
|
||||
extern wrapper_exception1;
|
||||
extern wrapper_exception2;
|
||||
extern wrapper_exception3;
|
||||
extern wrapper_exception4;
|
||||
extern wrapper_exception5;
|
||||
extern wrapper_exception6;
|
||||
extern wrapper_exception7;
|
||||
extern wrapper_exception8;
|
||||
extern wrapper_exception9;
|
||||
extern wrapper_exception10;
|
||||
extern wrapper_exception11;
|
||||
extern wrapper_exception12;
|
||||
extern wrapper_exception13;
|
||||
extern wrapper_exception14;
|
||||
extern wrapper_exception15;
|
||||
extern wrapper_exception16;
|
||||
extern wrapper_exception17;
|
||||
extern wrapper_exception18;
|
||||
extern wrapper_interruption;
|
||||
/******************************************************************************/
|
||||
/* Initialise la reprise après erreur */
|
||||
|
||||
void initretry(u32 address)
|
||||
{
|
||||
retry_address = address;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Récupère l'adresse de reprise après erreur */
|
||||
|
||||
u32 getinitretry(void)
|
||||
{
|
||||
return retry_address;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Initialise le controleur d'interruption 8259A */
|
||||
|
||||
void initpic(void)
|
||||
{
|
||||
/* MASTER */
|
||||
/* Initialisation de ICW1 */
|
||||
outb(PIC1_CMD, ICW1_INIT + ICW1_ICW4);
|
||||
nop();
|
||||
/* Initialisation de ICW2 - vecteur de depart = 32 */
|
||||
outb(PIC1_DATA, 0x20);
|
||||
nop();
|
||||
/* Initialisation de ICW3 */
|
||||
outb(PIC1_DATA, 0x04);
|
||||
nop();
|
||||
/* Initialisation de ICW4 */
|
||||
outb(PIC1_DATA, ICW4_8086);
|
||||
nop();
|
||||
/* masquage des interruptions */
|
||||
outb(PIC1_DATA, 0xFF);
|
||||
nop();
|
||||
/* SLAVE */
|
||||
/* Initialisation de ICW1 */
|
||||
outb(PIC2_CMD, ICW1_INIT + ICW1_ICW4);
|
||||
nop();
|
||||
/* Initialisation de ICW2 - vecteur de depart = 96 */
|
||||
outb(PIC2_DATA, 0x60);
|
||||
nop();
|
||||
/* Initialisation de ICW3 */
|
||||
outb(PIC2_DATA, 0x02);
|
||||
nop();
|
||||
/* Initialisation de ICW4 */
|
||||
outb(PIC2_DATA, ICW4_8086);
|
||||
nop();
|
||||
/* masquage des interruptions */
|
||||
outb(PIC2_DATA, 0xFF);
|
||||
nop();
|
||||
/* Demasquage des irqs sauf clavier
|
||||
outb(PIC1_DATA,0xFD);
|
||||
nop();
|
||||
*/
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Active une IRQ */
|
||||
|
||||
void enableirq(u8 irq)
|
||||
{
|
||||
u16 port;
|
||||
cli();
|
||||
port = (((irq & 0x08) << 4) + PIC1_DATA);
|
||||
outb(port, inb(port) & ~(1 << (irq & 7)));
|
||||
sti();
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Désactive une IRQ */
|
||||
|
||||
void disableirq(u8 irq)
|
||||
{
|
||||
u16 port;
|
||||
cli();
|
||||
port = (((irq & 0x08) << 4) + PIC1_DATA);
|
||||
outb(port, inb(port) | (1 << (irq & 7)));
|
||||
sti();
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
|
||||
/* Créé un descripteur pour l'IDT */
|
||||
|
||||
void makeidtdes(u32 offset, u16 select, u16 type, idtdes * desc)
|
||||
{
|
||||
desc->offset0_15 = (offset & 0xffff);
|
||||
desc->select = select;
|
||||
desc->type = type;
|
||||
desc->offset16_31 = (offset & 0xffff0000) >> 16;
|
||||
return;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Change une entrée dans l'IDT */
|
||||
|
||||
void setidt(u32 offset, u16 select, u16 type, u16 index)
|
||||
{
|
||||
cli();
|
||||
idtdes *desc;
|
||||
desc = idtreg.base;
|
||||
desc[index].offset0_15 = (offset & 0xffff);
|
||||
desc[index].select = select;
|
||||
desc[index].type = type;
|
||||
desc[index].offset16_31 = (offset & 0xffff0000) >> 16;
|
||||
sti();
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Met une entrée dans l'IDT */
|
||||
|
||||
void putidt(u32 offset, u16 select, u16 type, u16 index)
|
||||
{
|
||||
idtdes temp;
|
||||
makeidtdes(offset, select, type, &temp);
|
||||
idt[index] = temp;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Initialise une IDT */
|
||||
|
||||
void initidt(void)
|
||||
{
|
||||
u16 i;
|
||||
putidt((u32) &wrapper_exception0, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 0);
|
||||
putidt((u32) &wrapper_exception1, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 1);
|
||||
putidt((u32) &wrapper_exception2, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 2);
|
||||
putidt((u32) &wrapper_exception3, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 3);
|
||||
putidt((u32) &wrapper_exception4, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 4);
|
||||
putidt((u32) &wrapper_exception5, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 5);
|
||||
putidt((u32) &wrapper_exception6, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 6);
|
||||
putidt((u32) &wrapper_exception7, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 7);
|
||||
putidt((u32) &wrapper_exception8, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 8);
|
||||
putidt((u32) &wrapper_exception9, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 9);
|
||||
putidt((u32) &wrapper_exception10, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 10);
|
||||
putidt((u32) &wrapper_exception11, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 11);
|
||||
putidt((u32) &wrapper_exception12, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 12);
|
||||
putidt((u32) &wrapper_exception13, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 13);
|
||||
putidt((u32) &wrapper_exception14, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 14);
|
||||
putidt((u32) &wrapper_exception15, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 15);
|
||||
putidt((u32) &wrapper_exception16, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 16);
|
||||
putidt((u32) &wrapper_exception17, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 17);
|
||||
putidt((u32) &wrapper_exception18, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 18);
|
||||
for (i = 19; i < 32; i++)
|
||||
{
|
||||
putidt((u32) &wrapper_interruption, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING3 | TRAPGATE, i);
|
||||
}
|
||||
putidt((u32) irq0, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 32);
|
||||
putidt((u32) irq1, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 33);
|
||||
putidt((u32) irq2, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 34);
|
||||
putidt((u32) irq3, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 35);
|
||||
putidt((u32) irq4, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 36);
|
||||
putidt((u32) irq5, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 37);
|
||||
putidt((u32) irq6, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 38);
|
||||
putidt((u32) irq7, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 39);
|
||||
for (i = 40; i < 96; i++)
|
||||
{
|
||||
putidt((u32) &wrapper_interruption, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING3 | TRAPGATE, i);
|
||||
}
|
||||
putidt((u32) irq8, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 96);
|
||||
putidt((u32) irq9, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 97);
|
||||
putidt((u32) irq10, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 98);
|
||||
putidt((u32) irq11, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 99);
|
||||
putidt((u32) irq12, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 100);
|
||||
putidt((u32) irq13, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 101);
|
||||
putidt((u32) irq14, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 102);
|
||||
putidt((u32) irq15, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | INTGATE, 103);
|
||||
for (i = 104; i < IDT_SIZE; i++)
|
||||
{
|
||||
putidt((u32) &wrapper_interruption, SEL_KERNEL_CODE,
|
||||
ENTRY_PRESENT | ENTRY_RING0 | TRAPGATE, i);
|
||||
}
|
||||
/* initialise le registre idt */
|
||||
idtreg.limite = IDT_SIZE * sizeof(idtdes);
|
||||
idtreg.base = IDT_ADDR;
|
||||
/* recopie de la IDT a son adresse */
|
||||
memcpy(&idt, (u8 *) idtreg.base, idtreg.limite, 1);
|
||||
/* chargement du registre IDTR */
|
||||
lidt(idtreg);
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* 8253/8254 PIT (Programmable Interval Timer) Timer ajustable */
|
||||
|
||||
void inittimer(void)
|
||||
{
|
||||
u32 divisor = TIMER_FREQ / HZ;
|
||||
outb(TIMER_MODE, RATE_GENERATOR);
|
||||
outb(TIMER0, (u8) divisor);
|
||||
outb(TIMER0, (u8) (divisor >> 8));
|
||||
}
|
||||
/*******************************************************************************/
|
|
@ -1,310 +1,381 @@
|
|||
#include "idt.h"
|
||||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "interrupts.h"
|
||||
#include "types.h"
|
||||
#include "asm.h"
|
||||
#include "memory.h"
|
||||
#include "keyboard.h"
|
||||
|
||||
#include "vga.h"
|
||||
#include "video.h"
|
||||
|
||||
static u8 bufferscan[256]={0};
|
||||
static u8 bufferascii[256]={0};
|
||||
static u8 ptrscan=0;
|
||||
static u8 ptrascii=0;
|
||||
static u16 kbdstatus,breakcode ;
|
||||
|
||||
static const u8 set1_normal[] =
|
||||
{
|
||||
0, 0x1B, '&', 'é', '\"', '\'', '(', '-',
|
||||
'è', '_', 'ç', 'à', ')', '=', '\b', '\t',
|
||||
'a', 'z', 'e', 'r', 't', 'y', 'u', 'i',
|
||||
'o', 'p', '^', '$', '\r', 0, 'q', 's',
|
||||
'd', 'f', 'g', 'h', 'j', 'k', 'l', 'm',
|
||||
'ù', '²', 0, '*', 'w', 'x', 'c', 'v',
|
||||
'b', 'n', ',', ';', ':', '!', 0, '*',
|
||||
0, ' ', 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, '7',
|
||||
'8', '9','-', '4','5','6', '+', '1',
|
||||
'2', '3','0','.',0, 0, '<', 0,
|
||||
0
|
||||
static u8 bufferscan[256] = { 0 };
|
||||
static u8 bufferascii[256] = { 0 };
|
||||
|
||||
static u8 ptrscan = 0;
|
||||
static u8 ptrascii = 0;
|
||||
static u16 kbdstatus, breakcode;
|
||||
|
||||
/******************************************************************************/
|
||||
/* Tables clavier */
|
||||
|
||||
static const u8 set1_normal[] = {
|
||||
0, 0x1B, '&', 'é', '\"', '\'', '(', '-',
|
||||
'è', '_', 'ç', 'à', ')', '=', '\b', '\t',
|
||||
'a', 'z', 'e', 'r', 't', 'y', 'u', 'i',
|
||||
'o', 'p', '^', '$', '\r', 0, 'q', 's',
|
||||
'd', 'f', 'g', 'h', 'j', 'k', 'l', 'm',
|
||||
'ù', '²', 0, '*', 'w', 'x', 'c', 'v',
|
||||
'b', 'n', ',', ';', ':', '!', 0, '*',
|
||||
0, ' ', 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, '7',
|
||||
'8', '9', '-', '4', '5', '6', '+', '1',
|
||||
'2', '3', '0', '.', 0, 0, '<', 0,
|
||||
0
|
||||
};
|
||||
|
||||
static const u8 set1_shift[] =
|
||||
{
|
||||
0, 0x1B, '1', '2', '3', '4', '5', '6',
|
||||
'7', '8', '9', '0', '°', '+', '\b', '\t',
|
||||
'A', 'Z', 'E', 'R', 'T', 'Y', 'U', 'I',
|
||||
'O', 'P', '¨', '£', '\r', 0, 'Q', 'S',
|
||||
'D', 'F', 'G', 'H', 'J', 'K', 'L', 'M',
|
||||
'%', 0, 0, 'µ', 'W', 'X', 'C', 'V',
|
||||
'B', 'N', '?', '.', '/', '§', 0, '*',
|
||||
0, ' ', 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0,0, 0, '7',
|
||||
'8', '9','-', '4','5','6', '+', '1',
|
||||
'2', '3','0','.',0, 0, '>', 0,
|
||||
0
|
||||
static const u8 set1_shift[] = {
|
||||
0, 0x1B, '1', '2', '3', '4', '5', '6',
|
||||
'7', '8', '9', '0', '°', '+', '\b', '\t',
|
||||
'A', 'Z', 'E', 'R', 'T', 'Y', 'U', 'I',
|
||||
'O', 'P', '¨', '£', '\r', 0, 'Q', 'S',
|
||||
'D', 'F', 'G', 'H', 'J', 'K', 'L', 'M',
|
||||
'%', 0, 0, 'µ', 'W', 'X', 'C', 'V',
|
||||
'B', 'N', '?', '.', '/', '§', 0, '*',
|
||||
0, ' ', 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, '7',
|
||||
'8', '9', '-', '4', '5', '6', '+', '1',
|
||||
'2', '3', '0', '.', 0, 0, '>', 0,
|
||||
0
|
||||
};
|
||||
|
||||
static const u8 set1_alt[] =
|
||||
{
|
||||
0, 0x1B, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, '\r', 0, 0, 0,
|
||||
0, 0, 0,0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, '*',
|
||||
0, ' ', 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0,0, 0, '7',
|
||||
'8', '9','-', '4','5','6', '+', '1',
|
||||
'2', '3','0','.',0, 0, 0, 0,
|
||||
0
|
||||
static const u8 set1_alt[] = {
|
||||
0, 0x1B, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, '\r', 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, '*',
|
||||
0, ' ', 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, '7',
|
||||
'8', '9', '-', '4', '5', '6', '+', '1',
|
||||
'2', '3', '0', '.', 0, 0, 0, 0,
|
||||
0
|
||||
};
|
||||
|
||||
|
||||
static const u8 set1_altgr[] =
|
||||
{
|
||||
0, 0x1B, 0, '~', '#', '{', '[', '|',
|
||||
'`', '\\', '^', '@', ']', '}', '\b', '\t',
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, '¤', '\r', 0, 0, 0,
|
||||
0, 0, 0,0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, '*',
|
||||
0, ' ', 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0,0, 0, '7',
|
||||
'8', '9','-', '4','5','6', '+', '1',
|
||||
'2', '3','0','.',0, 0, 0, 0,
|
||||
0
|
||||
static const u8 set1_altgr[] = {
|
||||
0, 0x1B, 0, '~', '#', '{', '[', '|',
|
||||
'`', '\\', '^', '@', ']', '}', '\b', '\t',
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, '¤', '\r', 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, '*',
|
||||
0, ' ', 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, '7',
|
||||
'8', '9', '-', '4', '5', '6', '+', '1',
|
||||
'2', '3', '0', '.', 0, 0, 0, 0,
|
||||
0
|
||||
};
|
||||
|
||||
static const u8 set1_ctrl[] =
|
||||
{
|
||||
0, 0x1B, 0, 0,0, 0, 0x1B, 0,
|
||||
0, 0x1C, 0, 0, 0x1D, 0, 0, 0x1F,
|
||||
0x01, 0x1A, 0x05, 0x012, 0x14, 0x19, 0x15, 0x09,
|
||||
0x0F, 0x10, 0x1E, 0, 0, 0, 0x11, 0x13,
|
||||
0x04, 0x06, 0x07,0x08, 0x0A, 0x0B, 0x0C, 0x0D,
|
||||
0, 0, 0, 0, 0x17, 0x18, 0x03, 0x16,
|
||||
0x02, 0x0E, 0, 0, 0, 0, 0, '*',
|
||||
0, ' ', 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0,0, 0, '7',
|
||||
'8', '9','-', '4','5','6', '+', '1',
|
||||
'2', '3','0','.',0, 0, 0, 0,
|
||||
0
|
||||
static const u8 set1_ctrl[] = {
|
||||
0, 0x1B, 0, 0, 0, 0, 0x1B, 0,
|
||||
0, 0x1C, 0, 0, 0x1D, 0, 0, 0x1F,
|
||||
0x01, 0x1A, 0x05, 0x012, 0x14, 0x19, 0x15, 0x09,
|
||||
0x0F, 0x10, 0x1E, 0, 0, 0, 0x11, 0x13,
|
||||
0x04, 0x06, 0x07, 0x08, 0x0A, 0x0B, 0x0C, 0x0D,
|
||||
0, 0, 0, 0, 0x17, 0x18, 0x03, 0x16,
|
||||
0x02, 0x0E, 0, 0, 0, 0, 0, '*',
|
||||
0, ' ', 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, '7',
|
||||
'8', '9', '-', '4', '5', '6', '+', '1',
|
||||
'2', '3', '0', '.', 0, 0, 0, 0,
|
||||
0
|
||||
};
|
||||
/******************************************************************************/
|
||||
|
||||
u8 waitascii()
|
||||
{
|
||||
u8 oldptrscan=ptrscan;
|
||||
u8 oldptrascii=ptrascii;
|
||||
while((oldptrascii==ptrascii));/*(oldptrscan==ptrscan)&&*/
|
||||
return bufferascii[ptrascii];
|
||||
/******************************************************************************/
|
||||
|
||||
/* Attend une chaine de caractère de taille max */
|
||||
|
||||
u8 *getstring(u8 * temp)
|
||||
{
|
||||
u8 maxwidth = strlen(temp);
|
||||
u8 *pointer = temp;
|
||||
u8 ascii = 0;
|
||||
while (ascii != '\r')
|
||||
{
|
||||
ascii = waitascii();
|
||||
if (ascii == '\b' && pointer > temp)
|
||||
{
|
||||
pointer--;
|
||||
putchar(ascii);
|
||||
}
|
||||
else if (ascii > 31 && pointer <= temp + 80)
|
||||
{
|
||||
*pointer++ = ascii;
|
||||
putchar(ascii);
|
||||
}
|
||||
}
|
||||
*pointer = '\000';
|
||||
return temp;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/******************************************************************************/
|
||||
/* Fonction qui attend l'appuie d'une touche générant un code ASCII puis le retourne */
|
||||
/* SYSCALL
|
||||
{
|
||||
"ID":1,
|
||||
"LIBRARY":"libsys",
|
||||
"NAME":"waitkey",
|
||||
"INTERNALNAME":"waitascii",
|
||||
"DESCRIPTION":"Wait for user to press a key and return the ascii code pressed",
|
||||
"ARGS": [],
|
||||
"RETURN":"u8"
|
||||
}
|
||||
END-SYSCALL */
|
||||
|
||||
u8 waitascii(void)
|
||||
{
|
||||
u8 oldptrascii = ptrascii;
|
||||
while ((oldptrascii == ptrascii));
|
||||
return bufferascii[ptrascii];
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Envoi d'une commande vers le contrôleur de clavier */
|
||||
|
||||
void outkbd(u8 port, u8 data)
|
||||
{
|
||||
u32 timeout;
|
||||
u8 state;
|
||||
u32 timeout;
|
||||
u8 state;
|
||||
|
||||
/* timeout */
|
||||
for(timeout = 500000L; timeout != 0; timeout--)
|
||||
for (timeout = 500000L; timeout != 0; timeout--)
|
||||
{
|
||||
state = inb(0x64);
|
||||
/* vide le buffer du 8042 */
|
||||
if((state & 0x02) == 0) break;
|
||||
if ((state & 0x02) == 0)
|
||||
break;
|
||||
}
|
||||
if(timeout != 0)
|
||||
if (timeout != 0)
|
||||
outb(port, data);
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
static void reboot(void)
|
||||
/* Redemarre l'ordinateur */
|
||||
|
||||
void reboot(void)
|
||||
{
|
||||
u8 temp;
|
||||
u8 temp;
|
||||
cli();
|
||||
/* vide le 8042 */
|
||||
do
|
||||
{
|
||||
temp = inb(0x64);
|
||||
if((temp & 0x01) != 0)
|
||||
if ((temp & 0x01) != 0)
|
||||
{
|
||||
(void)inb(0x60);
|
||||
(void) inb(0x60);
|
||||
continue;
|
||||
}
|
||||
} while((temp & 0x02) != 0);
|
||||
}
|
||||
while ((temp & 0x02) != 0);
|
||||
/* active le reset CPU */
|
||||
outb(0x64, 0xFE);
|
||||
while(1)
|
||||
/* boucle infinie */;
|
||||
while (1)
|
||||
/* boucle infinie */ ;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Converti un scancode vers une code ASCII */
|
||||
|
||||
unsigned convert(u32 keypressed)
|
||||
{
|
||||
u8 temp,key,lastscan;
|
||||
u8 temp, key, lastscan;
|
||||
/* garde le dernier pointeur du buffer scan */
|
||||
lastscan=ptrscan;
|
||||
lastscan = ptrscan;
|
||||
/* incrémente le pointeur est assigne au buffer le dernier scancode */
|
||||
ptrscan++;
|
||||
if (ptrscan==255) ptrscan==0;
|
||||
bufferscan[ptrscan]=keypressed;
|
||||
ptrscan++;
|
||||
if (ptrscan == 255)
|
||||
ptrscan == 0;
|
||||
bufferscan[ptrscan] = keypressed;
|
||||
/* break key (touche relaché) ? */
|
||||
if(keypressed >= 0x80) breakcode = 1;
|
||||
key = (keypressed&0x7F);
|
||||
if (keypressed >= 0x80)
|
||||
breakcode = 1;
|
||||
key = (keypressed & 0x7F);
|
||||
/* Mise a jour des flags lors du relachement de touches de controle */
|
||||
if(breakcode)
|
||||
if (breakcode)
|
||||
{
|
||||
if(key == SCAN_ALT)
|
||||
{
|
||||
if (key == SCAN_ALT)
|
||||
{
|
||||
kbdstatus &= ~STATUS_ALT;
|
||||
/* si ALT GR (E01D) alors activer aussi control */
|
||||
if (bufferscan[lastscan]==0xE0) kbdstatus &= ~STATUS_CTRL;
|
||||
}
|
||||
else if(key == SCAN_CTRL)
|
||||
if (bufferscan[lastscan] == 0xE0)
|
||||
kbdstatus &= ~STATUS_CTRL;
|
||||
}
|
||||
else if (key == SCAN_CTRL)
|
||||
kbdstatus &= ~STATUS_CTRL;
|
||||
else if(key == SCAN_LEFTSHIFT || key == SCAN_RIGHTSHIFT)
|
||||
else if (key == SCAN_LEFTSHIFT || key == SCAN_RIGHTSHIFT)
|
||||
kbdstatus &= ~STATUS_SHIFT;
|
||||
breakcode = 0;
|
||||
return 0;
|
||||
}
|
||||
/* Mise a jour des flags lors de l'appuie de touches de controle */
|
||||
if(key == SCAN_ALT)
|
||||
if (key == SCAN_ALT)
|
||||
{
|
||||
kbdstatus |= STATUS_ALT;
|
||||
/* si ALT GR (E01D) alors desactiver aussi control */
|
||||
if (bufferscan[lastscan]==0xE0) kbdstatus |= STATUS_CTRL;
|
||||
return 0;
|
||||
/* si ALT GR (E01D) alors desactiver aussi control */
|
||||
if (bufferscan[lastscan] == 0xE0)
|
||||
kbdstatus |= STATUS_CTRL;
|
||||
return 0;
|
||||
}
|
||||
if(key == SCAN_CTRL)
|
||||
else if (key == SCAN_CTRL)
|
||||
{
|
||||
kbdstatus |= STATUS_CTRL;
|
||||
return 0;
|
||||
}
|
||||
if(key == SCAN_LEFTSHIFT || key == SCAN_RIGHTSHIFT)
|
||||
else if (key == SCAN_LEFTSHIFT || key == SCAN_RIGHTSHIFT)
|
||||
{
|
||||
kbdstatus |= STATUS_SHIFT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if ((key >= SCAN_F1) && (key <= SCAN_F8))
|
||||
|
||||
else if ((key >= SCAN_F1) && (key <= SCAN_F8))
|
||||
{
|
||||
changevc(key-SCAN_F1);
|
||||
}
|
||||
|
||||
changevc(key - SCAN_F1);
|
||||
}
|
||||
|
||||
else if (key == SCAN_F9)
|
||||
{
|
||||
int20;
|
||||
}
|
||||
|
||||
else if (key == SCAN_F10)
|
||||
{
|
||||
apply_nextvideomode();
|
||||
}
|
||||
|
||||
/* Scroll Lock, Num Lock, and Caps Lock mise a jour des leds */
|
||||
if(key == SCAN_SCROLLLOCK)
|
||||
else if (key == SCAN_SCROLLLOCK)
|
||||
{
|
||||
kbdstatus ^= STATUS_SCRL;
|
||||
goto LEDS;
|
||||
}
|
||||
if(key == SCAN_NUMLOCK)
|
||||
else if (key == SCAN_NUMLOCK)
|
||||
{
|
||||
kbdstatus ^= STATUS_NUM;
|
||||
goto LEDS;
|
||||
}
|
||||
if(key == SCAN_CAPSLOCK)
|
||||
else if (key == SCAN_CAPSLOCK)
|
||||
{
|
||||
kbdstatus ^= STATUS_CAPS;
|
||||
LEDS:
|
||||
outkbd(0x60, 0xED); /* "mise a jour des LEDS */
|
||||
temp = 0;
|
||||
if(kbdstatus & STATUS_SCRL)
|
||||
LEDS:
|
||||
outkbd(0x60, 0xED); /* "mise a jour des LEDS */
|
||||
temp = 0;
|
||||
if (kbdstatus & STATUS_SCRL)
|
||||
temp |= 1;
|
||||
if(kbdstatus & STATUS_NUM)
|
||||
if (kbdstatus & STATUS_NUM)
|
||||
temp |= 2;
|
||||
if(kbdstatus & STATUS_CAPS)
|
||||
if (kbdstatus & STATUS_CAPS)
|
||||
temp |= 4;
|
||||
outkbd(0x60, temp); /* 3 bits de poids faible pour les LEDs */
|
||||
return 0;
|
||||
}
|
||||
/* est ce un code etendu */
|
||||
if ((bufferscan[lastscan]==0xE0)||((kbdstatus & STATUS_NUM)&&(key>=0x47)&&(key<=0x53)&&(key!=0x4A)&&(key!=0x4e)))
|
||||
/* exceptions */
|
||||
{
|
||||
/* '/' (E035) */
|
||||
if (key==0x35) return '/';
|
||||
/* '\r' (E01C) 2ème enter numérique*/
|
||||
if (key==0x1C) return '\r';
|
||||
/* 0x11 (E048) device control 1)*/
|
||||
if (key==0x48) return 0x11;
|
||||
/* 0x12 (E050) device control 2)*/
|
||||
if (key==0x50) return 0x12;
|
||||
/* 0x13 (E04b) device control 3)*/
|
||||
if (key==0x4b) return 0x13;
|
||||
/* 0x14 (E04d) device control 4)*/
|
||||
if (key==0x4d) return 0x14;
|
||||
/* 0x02 (E049) start of text)*/
|
||||
if (key==0x49) return 0x2;
|
||||
/* 0x03 (E051) end of text)*/
|
||||
if (key==0x51) return 0x3;
|
||||
/* 0x10 (E047) Line feed)*/
|
||||
if (key==0x47) return '\n';
|
||||
/* 0x1A (E052) Substitution)*/
|
||||
if (key==0x52) return 0x1A;
|
||||
/* 0x18 (E053) Cancel)*/
|
||||
if (key==0x53) return 0x18;
|
||||
/* 0x19 (E04f) End of medium)*/
|
||||
if (key==0x4f) return 0x19;
|
||||
return 0x00;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* detecte les SCANCODES invalides */
|
||||
if(key >= sizeof(set1_normal) / sizeof(set1_normal[0])) return 0;
|
||||
/* converti le scancode en code ASCII en fonction du statut*/
|
||||
if (kbdstatus & STATUS_SHIFT||kbdstatus & STATUS_CAPS)
|
||||
temp = set1_shift[key];
|
||||
else if ((kbdstatus & STATUS_ALT)&&(kbdstatus & STATUS_CTRL))
|
||||
temp = set1_altgr[key];
|
||||
else if (kbdstatus & STATUS_CTRL)
|
||||
temp = set1_ctrl[key];
|
||||
else if (kbdstatus & STATUS_ALT)
|
||||
temp = set1_alt[key];
|
||||
else
|
||||
temp = set1_normal[key];
|
||||
}
|
||||
|
||||
/* si scancode non reconnu fin de fonction */
|
||||
if(temp == 0) return temp;
|
||||
/* Appuie de CRTL + ALT + SUPR ? */
|
||||
if((kbdstatus & STATUS_CTRL) && (kbdstatus & STATUS_ALT) &&
|
||||
(key == 76))
|
||||
if ((kbdstatus & STATUS_CTRL) && (kbdstatus & STATUS_ALT)
|
||||
&& (key == 73))
|
||||
{
|
||||
print("redemarrage du systeme");
|
||||
reboot();
|
||||
}
|
||||
/* est ce un code etendu */
|
||||
if ((bufferscan[lastscan] == 0xE0)
|
||||
|| ((kbdstatus & STATUS_NUM) && (key >= 0x47) && (key <= 0x53)
|
||||
&& (key != 0x4A) && (key != 0x4e)))
|
||||
/* exceptions */
|
||||
{
|
||||
/* '/' (E035) */
|
||||
if (key == 0x35)
|
||||
return '/';
|
||||
/* '\r' (E01C) 2ème enter numérique */
|
||||
if (key == 0x1C)
|
||||
return '\r';
|
||||
/* 0x11 (E048) device control 1) */
|
||||
if (key == 0x48)
|
||||
return 0x11;
|
||||
/* 0x12 (E050) device control 2) */
|
||||
if (key == 0x50)
|
||||
return 0x12;
|
||||
/* 0x13 (E04b) device control 3) */
|
||||
if (key == 0x4b)
|
||||
return 0x13;
|
||||
/* 0x14 (E04d) device control 4) */
|
||||
if (key == 0x4d)
|
||||
return 0x14;
|
||||
/* 0x02 (E049) start of text) */
|
||||
if (key == 0x49)
|
||||
return 0x2;
|
||||
/* 0x03 (E051) end of text) */
|
||||
if (key == 0x51)
|
||||
return 0x3;
|
||||
/* 0x10 (E047) Line feed) */
|
||||
if (key == 0x47)
|
||||
return '\n';
|
||||
/* 0x1A (E052) Substitution) */
|
||||
if (key == 0x52)
|
||||
return 0x1A;
|
||||
/* 0x18 (E053) Cancel) */
|
||||
if (key == 0x53)
|
||||
return 0x18;
|
||||
/* 0x19 (E04f) End of medium) */
|
||||
if (key == 0x4f)
|
||||
return 0x19;
|
||||
return 0x00;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* detecte les SCANCODES invalides */
|
||||
if (key >= sizeof(set1_normal) / sizeof(set1_normal[0]))
|
||||
return 0;
|
||||
/* converti le scancode en code ASCII en fonction du statut*/
|
||||
if (kbdstatus & STATUS_SHIFT || kbdstatus & STATUS_CAPS)
|
||||
temp = set1_shift[key];
|
||||
else if ((kbdstatus & STATUS_ALT)
|
||||
&& (kbdstatus & STATUS_CTRL))
|
||||
temp = set1_altgr[key];
|
||||
else if (kbdstatus & STATUS_CTRL)
|
||||
temp = set1_ctrl[key];
|
||||
else if (kbdstatus & STATUS_ALT)
|
||||
temp = set1_alt[key];
|
||||
else
|
||||
temp = set1_normal[key];
|
||||
}
|
||||
/* si scancode non reconnu fin de fonction */
|
||||
if (temp == 0)
|
||||
return temp;
|
||||
/* Renvoie le Code ascii */
|
||||
return temp;
|
||||
}
|
||||
|
||||
|
||||
/******************************************************************************/
|
||||
/* Handler d'interruption IRQ 1 pour le clavier */
|
||||
|
||||
void keyboard()
|
||||
{
|
||||
cli();
|
||||
pushf();
|
||||
pushad();
|
||||
u8 scancode,ascii;
|
||||
cli();
|
||||
while ((inb(0x64)&1)==0);
|
||||
scancode=inb(0x60);
|
||||
ascii = convert(scancode);
|
||||
if(ascii != 0)
|
||||
__attribute__((interrupt)) void keyboard_handler(exception_stack_noerror *caller)
|
||||
{
|
||||
ptrascii++;
|
||||
if (ptrascii==255) ptrascii==0;
|
||||
bufferascii[ptrascii]=ascii;
|
||||
}
|
||||
irqendmaster();
|
||||
popad();
|
||||
popf();
|
||||
cli();
|
||||
u8 scancode, ascii;
|
||||
while ((inb(0x64) & 1) == 0);
|
||||
scancode = inb(0x60);
|
||||
ascii = convert(scancode);
|
||||
if (ascii != 0)
|
||||
{
|
||||
ptrascii++;
|
||||
if (ptrascii == 255)
|
||||
ptrascii == 0;
|
||||
bufferascii[ptrascii] = ascii;
|
||||
}
|
||||
irqendmaster();
|
||||
sti();
|
||||
asm("addl $0x01C, %esp;");
|
||||
iret();
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
|
|
61
lib/makefile
61
lib/makefile
|
@ -1,16 +1,61 @@
|
|||
CC=gcc -O0 -g -nostdinc -ffreestanding -fno-builtin -fomit-frame-pointer -Wall -w -m32 -F pe-i386 -I ../include
|
||||
CC=gcc -O0 -g -nostdinc -ffreestanding -fno-builtin -Wall -w -m32 -F elf_i386 -fno-pie -no-pie -I ../include -c
|
||||
ASM=gcc -nostdinc -ffreestanding -fno-builtin -m32 -c -fno-pie -no-pie
|
||||
LINK=ld -m elf_i386 -r -o
|
||||
OBJS=memory.o vga.o port.o video.o mouse.o idt.o timer.o keyboard.o types.o string.o graph.o 3d.o math.o cpu.o
|
||||
SRCS= $(wildcard *.c)
|
||||
OBJS= $(SRCS:.c=.o)
|
||||
SRCASM= $(wildcard *.S)
|
||||
OBJASM= $(SRCASM:.S=.o)
|
||||
CONVERT=dos2unix
|
||||
INDENT=indent -nhnl -l75 -ppi3 -ts8 -bls -nbc -di8 -nbad -nbap -nsob -i8 -bl -bli0 -ncdw -nce -cli8 -cbi0 -npcs -cs -saf -sai -saw -nprs -lp -npsl
|
||||
REMOVE=rm -f
|
||||
CHANGEPERM=chmod 644
|
||||
SYNC=sync
|
||||
|
||||
all: makeall
|
||||
all: libs.o
|
||||
$(SYNC)
|
||||
|
||||
makeall: libs.o
|
||||
togit: clean indent
|
||||
|
||||
libs.o:$(OBJS)
|
||||
$(LINK) libs.o $(OBJS)
|
||||
libs.o:$(OBJS) $(OBJASM)
|
||||
$(LINK) libs.o $(OBJS) $(OBJASM)
|
||||
|
||||
.o: .S
|
||||
$(ASM) $^
|
||||
|
||||
handlers.o:handlers.c
|
||||
$(CC) -mgeneral-regs-only $^
|
||||
|
||||
keyboard.o:keyboard.c
|
||||
$(CC) -mgeneral-regs-only $^
|
||||
|
||||
mouse.o:mouse.c
|
||||
$(CC) -mgeneral-regs-only $^
|
||||
|
||||
syscall.o:syscall.c
|
||||
$(CC) -fomit-frame-pointer $^
|
||||
.o: .c
|
||||
$(CC) $^
|
||||
clean:
|
||||
rm -f *.o
|
||||
|
||||
clean:
|
||||
$(REMOVE) *.o
|
||||
$(REMOVE) *.c~
|
||||
$(REMOVE) */*.c~
|
||||
$(REMOVE) ../include/*.h~
|
||||
$(REMOVE) ./TEST/*.c
|
||||
$(SYNC)
|
||||
|
||||
indent:
|
||||
$(CHANGEPERM) *.c
|
||||
$(CONVERT) *.c
|
||||
$(INDENT) *.c
|
||||
$(REMOVE) *.c~
|
||||
$(CHANGEPERM) ./*/*.c
|
||||
$(CONVERT) ./*/*.c
|
||||
$(INDENT) ./*/*.c
|
||||
$(REMOVE) */*.c~
|
||||
$(CHANGEPERM) ../include/*.h
|
||||
$(CONVERT) ../include/*.h
|
||||
$(INDENT) ../include/*.h
|
||||
$(REMOVE) ../include/*.h~
|
||||
$(SYNC)
|
||||
|
||||
|
|
|
@ -1,7 +1,312 @@
|
|||
#include "types.h"
|
||||
|
||||
u32 abs(int x)
|
||||
{
|
||||
if (x<0) x=-x;
|
||||
return (u32)x;
|
||||
}
|
||||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "types.h"
|
||||
#include "timer.h"
|
||||
#include "math.h"
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Calcule un checksum 32 bits */
|
||||
|
||||
u32 crc32(u32 inCrc32, u8 *buf, u32 size)
|
||||
{
|
||||
static const u32 crcTable[256] = {
|
||||
0x00000000,0x77073096,0xEE0E612C,0x990951BA,0x076DC419,0x706AF48F,0xE963A535,
|
||||
0x9E6495A3,0x0EDB8832,0x79DCB8A4,0xE0D5E91E,0x97D2D988,0x09B64C2B,0x7EB17CBD,
|
||||
0xE7B82D07,0x90BF1D91,0x1DB71064,0x6AB020F2,0xF3B97148,0x84BE41DE,0x1ADAD47D,
|
||||
0x6DDDE4EB,0xF4D4B551,0x83D385C7,0x136C9856,0x646BA8C0,0xFD62F97A,0x8A65C9EC,
|
||||
0x14015C4F,0x63066CD9,0xFA0F3D63,0x8D080DF5,0x3B6E20C8,0x4C69105E,0xD56041E4,
|
||||
0xA2677172,0x3C03E4D1,0x4B04D447,0xD20D85FD,0xA50AB56B,0x35B5A8FA,0x42B2986C,
|
||||
0xDBBBC9D6,0xACBCF940,0x32D86CE3,0x45DF5C75,0xDCD60DCF,0xABD13D59,0x26D930AC,
|
||||
0x51DE003A,0xC8D75180,0xBFD06116,0x21B4F4B5,0x56B3C423,0xCFBA9599,0xB8BDA50F,
|
||||
0x2802B89E,0x5F058808,0xC60CD9B2,0xB10BE924,0x2F6F7C87,0x58684C11,0xC1611DAB,
|
||||
0xB6662D3D,0x76DC4190,0x01DB7106,0x98D220BC,0xEFD5102A,0x71B18589,0x06B6B51F,
|
||||
0x9FBFE4A5,0xE8B8D433,0x7807C9A2,0x0F00F934,0x9609A88E,0xE10E9818,0x7F6A0DBB,
|
||||
0x086D3D2D,0x91646C97,0xE6635C01,0x6B6B51F4,0x1C6C6162,0x856530D8,0xF262004E,
|
||||
0x6C0695ED,0x1B01A57B,0x8208F4C1,0xF50FC457,0x65B0D9C6,0x12B7E950,0x8BBEB8EA,
|
||||
0xFCB9887C,0x62DD1DDF,0x15DA2D49,0x8CD37CF3,0xFBD44C65,0x4DB26158,0x3AB551CE,
|
||||
0xA3BC0074,0xD4BB30E2,0x4ADFA541,0x3DD895D7,0xA4D1C46D,0xD3D6F4FB,0x4369E96A,
|
||||
0x346ED9FC,0xAD678846,0xDA60B8D0,0x44042D73,0x33031DE5,0xAA0A4C5F,0xDD0D7CC9,
|
||||
0x5005713C,0x270241AA,0xBE0B1010,0xC90C2086,0x5768B525,0x206F85B3,0xB966D409,
|
||||
0xCE61E49F,0x5EDEF90E,0x29D9C998,0xB0D09822,0xC7D7A8B4,0x59B33D17,0x2EB40D81,
|
||||
0xB7BD5C3B,0xC0BA6CAD,0xEDB88320,0x9ABFB3B6,0x03B6E20C,0x74B1D29A,0xEAD54739,
|
||||
0x9DD277AF,0x04DB2615,0x73DC1683,0xE3630B12,0x94643B84,0x0D6D6A3E,0x7A6A5AA8,
|
||||
0xE40ECF0B,0x9309FF9D,0x0A00AE27,0x7D079EB1,0xF00F9344,0x8708A3D2,0x1E01F268,
|
||||
0x6906C2FE,0xF762575D,0x806567CB,0x196C3671,0x6E6B06E7,0xFED41B76,0x89D32BE0,
|
||||
0x10DA7A5A,0x67DD4ACC,0xF9B9DF6F,0x8EBEEFF9,0x17B7BE43,0x60B08ED5,0xD6D6A3E8,
|
||||
0xA1D1937E,0x38D8C2C4,0x4FDFF252,0xD1BB67F1,0xA6BC5767,0x3FB506DD,0x48B2364B,
|
||||
0xD80D2BDA,0xAF0A1B4C,0x36034AF6,0x41047A60,0xDF60EFC3,0xA867DF55,0x316E8EEF,
|
||||
0x4669BE79,0xCB61B38C,0xBC66831A,0x256FD2A0,0x5268E236,0xCC0C7795,0xBB0B4703,
|
||||
0x220216B9,0x5505262F,0xC5BA3BBE,0xB2BD0B28,0x2BB45A92,0x5CB36A04,0xC2D7FFA7,
|
||||
0xB5D0CF31,0x2CD99E8B,0x5BDEAE1D,0x9B64C2B0,0xEC63F226,0x756AA39C,0x026D930A,
|
||||
0x9C0906A9,0xEB0E363F,0x72076785,0x05005713,0x95BF4A82,0xE2B87A14,0x7BB12BAE,
|
||||
0x0CB61B38,0x92D28E9B,0xE5D5BE0D,0x7CDCEFB7,0x0BDBDF21,0x86D3D2D4,0xF1D4E242,
|
||||
0x68DDB3F8,0x1FDA836E,0x81BE16CD,0xF6B9265B,0x6FB077E1,0x18B74777,0x88085AE6,
|
||||
0xFF0F6A70,0x66063BCA,0x11010B5C,0x8F659EFF,0xF862AE69,0x616BFFD3,0x166CCF45,
|
||||
0xA00AE278,0xD70DD2EE,0x4E048354,0x3903B3C2,0xA7672661,0xD06016F7,0x4969474D,
|
||||
0x3E6E77DB,0xAED16A4A,0xD9D65ADC,0x40DF0B66,0x37D83BF0,0xA9BCAE53,0xDEBB9EC5,
|
||||
0x47B2CF7F,0x30B5FFE9,0xBDBDF21C,0xCABAC28A,0x53B39330,0x24B4A3A6,0xBAD03605,
|
||||
0xCDD70693,0x54DE5729,0x23D967BF,0xB3667A2E,0xC4614AB8,0x5D681B02,0x2A6F2B94,
|
||||
0xB40BBE37,0xC30C8EA1,0x5A05DF1B,0x2D02EF8D };
|
||||
u32 crc32;
|
||||
u8 *byteBuf;
|
||||
u32 i;
|
||||
crc32 = inCrc32 ^ 0xFFFFFFFF;
|
||||
byteBuf = (u8*) buf;
|
||||
for (i=0; i < size; i++) {
|
||||
crc32 = (crc32 >> 8) ^ crcTable[ (crc32 ^ byteBuf[i]) & 0xFF ];
|
||||
}
|
||||
return( crc32 ^ 0xFFFFFFFF );
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Arithmétique 64 bits */
|
||||
|
||||
unsigned long long __udivdi3(unsigned long long num,
|
||||
unsigned long long den)
|
||||
{
|
||||
unsigned long long quot, qbit;
|
||||
quot = 0;
|
||||
qbit = 1;
|
||||
if (den == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
while ((long long) den >= 0)
|
||||
{
|
||||
den <<= 1;
|
||||
qbit <<= 1;
|
||||
}
|
||||
while (qbit)
|
||||
{
|
||||
if (den <= num)
|
||||
{
|
||||
num -= den;
|
||||
quot += qbit;
|
||||
}
|
||||
den >>= 1;
|
||||
qbit >>= 1;
|
||||
}
|
||||
return quot;
|
||||
}
|
||||
|
||||
unsigned long long __umoddi3(unsigned long long n, unsigned long long d)
|
||||
{
|
||||
return n - d * __udivdi3(n, d);
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Fonctions qui retournent le sinus et cosinus */
|
||||
|
||||
double cos(double x)
|
||||
{
|
||||
if (x < 0.0)
|
||||
x = -x;
|
||||
while (M_PI < x)
|
||||
x -= M_2_PI;
|
||||
double result =
|
||||
1.0 - (x * x / 2.0) * (1.0 -
|
||||
(x * x / 12.0) * (1.0 -
|
||||
(x * x / 30.0) *
|
||||
(1.0 -
|
||||
x * x / 56.0)));
|
||||
return result;
|
||||
}
|
||||
|
||||
double sin(double x)
|
||||
{
|
||||
return cos(x - M_PI_2);
|
||||
}
|
||||
|
||||
float cosf(float x)
|
||||
{
|
||||
if (x < 0.0f)
|
||||
x = -x;
|
||||
while (M_PI < x)
|
||||
x -= M_2_PI;
|
||||
float result =
|
||||
1.0f - (x * x / 2.0f) * (1.0f -
|
||||
(x * x / 12.0f) * (1.0f -
|
||||
(x * x /
|
||||
30.0f) *
|
||||
(1.0f -
|
||||
x * x /
|
||||
56.0f)));
|
||||
return result;
|
||||
}
|
||||
|
||||
float sinf(float x)
|
||||
{
|
||||
return cosf(x - M_PI_2);
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Fonction qui retourne la valeur absolue */
|
||||
|
||||
float fabsf(float n)
|
||||
{
|
||||
return (*((int *) &n) &= 0x7fffffff);
|
||||
}
|
||||
|
||||
double fabs(double n)
|
||||
{
|
||||
return (*(((int *) &n) + 1) &= 0x7fffffff);
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Fonction qui retourne la racine */
|
||||
|
||||
float sqrtf(float n)
|
||||
{
|
||||
float x = n;
|
||||
float y = 1;
|
||||
double e = 0.000001;
|
||||
while (x - y > e)
|
||||
{
|
||||
x = (x + y) / 2;
|
||||
y = n / x;
|
||||
}
|
||||
return x;
|
||||
}
|
||||
|
||||
double sqrt(double n)
|
||||
{
|
||||
double x = n;
|
||||
double y = 1;
|
||||
double e = 0.000001;
|
||||
while (x - y > e)
|
||||
{
|
||||
x = (x + y) / 2;
|
||||
y = n / x;
|
||||
}
|
||||
return x;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Fonction qui retourne l'inverse de la racine */
|
||||
|
||||
float rsqrtf(float n)
|
||||
{
|
||||
return 1 / sqrt(n);
|
||||
}
|
||||
|
||||
double rsqrt(double n)
|
||||
{
|
||||
return 1 / sqrt(n);
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Fonction qui retourne la puissance n de a */
|
||||
|
||||
u32 pow(u32 a, u8 n)
|
||||
{
|
||||
u32 r = 1;
|
||||
while (n > 0)
|
||||
{
|
||||
if (n & 1)
|
||||
r *= a;
|
||||
a *= a;
|
||||
n >>= 1;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Fonction qui retourne le logarithme 2 */
|
||||
|
||||
u8 log2(u64 n)
|
||||
{
|
||||
if (n == 0)
|
||||
return 0;
|
||||
int logValue = -1;
|
||||
while (n)
|
||||
{
|
||||
|
||||
logValue++;
|
||||
|
||||
n >>= 1;
|
||||
|
||||
}
|
||||
return logValue + 1;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Fonction qui retourne le logarithme 10 */
|
||||
|
||||
u8 log10(u64 n)
|
||||
{
|
||||
|
||||
return (n >= 10000000000000000000u) ? 19 : (n >=
|
||||
100000000000000000u) ?
|
||||
18 : (n >= 100000000000000000u) ? 17 : (n >=
|
||||
10000000000000000u)
|
||||
? 16 : (n >= 1000000000000000u) ? 15 : (n >=
|
||||
100000000000000u) ?
|
||||
14 : (n >= 10000000000000u) ? 13 : (n >=
|
||||
1000000000000u) ? 12
|
||||
: (n >= 100000000000u) ? 11 : (n >=
|
||||
10000000000u) ? 10 : (n >=
|
||||
1000000000u)
|
||||
? 9 : (n >= 100000000u) ? 8 : (n >= 10000000u) ? 7 : (n >=
|
||||
1000000u)
|
||||
? 6 : (n >= 100000u) ? 5 : (n >= 10000u) ? 4 : (n >=
|
||||
1000u) ? 3
|
||||
: (n >= 100u) ? 2 : (n >= 10u) ? 1u : 0u;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/******************************************************************************/
|
||||
/* Fonction qui retourne la valeur absolue */
|
||||
|
||||
u32 abs(int x)
|
||||
{
|
||||
if (x < 0)
|
||||
|
||||
x = -x;
|
||||
|
||||
return (u32) x;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Fonction qui initialise le générateur de nombre aléatoire */
|
||||
|
||||
static u32 seed = 0x12341234;
|
||||
|
||||
void randomize(void)
|
||||
{
|
||||
seed = gettimer();
|
||||
}
|
||||
|
||||
|
||||
/******************************************************************************/
|
||||
/* Fonction qui renvoie un nombre aléatoire */
|
||||
|
||||
u32 rand(void)
|
||||
{
|
||||
u32 next = seed;
|
||||
int result;
|
||||
next *= 1103515245;
|
||||
next += 12345;
|
||||
result = (unsigned int) (next / 65536) % 2048;
|
||||
next *= 1103515245;
|
||||
next += 12345;
|
||||
result <<= 10;
|
||||
result ^= (unsigned int) (next / 65536) % 1024;
|
||||
next *= 1103515245;
|
||||
next += 12345;
|
||||
result <<= 10;
|
||||
result ^= (unsigned int) (next / 65536) % 1024;
|
||||
seed = next;
|
||||
return result;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Fonction qui renvoie un nombre aléatoire borné */
|
||||
|
||||
u32 random(u32 lower, u32 upper)
|
||||
{
|
||||
return (rand() % (upper - lower + 1)) + lower;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
|
|
|
@ -0,0 +1,653 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "matrix.h"
|
||||
#include "types.h"
|
||||
#include "math.h"
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Affiche un vecteur de 4 composantes */
|
||||
|
||||
void vector4_show(vector4 src)
|
||||
{
|
||||
printf("vecteur: X=%f Y=%f Z=%f W=%f \r\n", src.x, src.y, src.z,
|
||||
src.w);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Créé un vecteur de 4 composantes */
|
||||
|
||||
void vector4_create(float x, float y, float z, float w, vector4 * dst)
|
||||
{
|
||||
dst->x = x;
|
||||
dst->y = y;
|
||||
dst->z = z;
|
||||
dst->w = w;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Copie un vecteur de 4 composantes */
|
||||
|
||||
void vector4_copy(vector4 src, vector4 * dst)
|
||||
{
|
||||
vector4_create(src.x, src.y, src.z, src.w, dst);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Ajoute deux vecteurs de 4 composantes */
|
||||
|
||||
void vector4_add(vector4 v1, vector4 v2, vector4 * dst)
|
||||
{
|
||||
dst->x = v1.x + v2.x;
|
||||
dst->y = v1.y + v2.y;
|
||||
dst->z = v1.z + v2.z;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Soustrait un vecteur de 4 composantes depuis un autre*/
|
||||
|
||||
void vector4_sub(vector4 v1, vector4 v2, vector4 * dst)
|
||||
{
|
||||
dst->x = v1.x - v2.x;
|
||||
dst->y = v1.y - v2.y;
|
||||
dst->z = v1.z - v2.z;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Redimensionne un vecteur de 4 composantes */
|
||||
|
||||
void vector4_scale(vector4 * dst, float factor)
|
||||
{
|
||||
dst->x *= factor;
|
||||
dst->y *= factor;
|
||||
dst->z *= factor;
|
||||
dst->w *= factor;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Calcule le produit vectoriel de deux vecteurs de 4 composantes */
|
||||
|
||||
void vector4_crossproduct(vector4 v1, vector4 v2, vector4 * dst)
|
||||
{
|
||||
dst->x = v1.y * v2.z - v1.z * v2.y;
|
||||
dst->y = v1.z * v2.x - v1.x * v2.z;
|
||||
dst->z = v1.x * v2.y - v1.y * v2.x;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Normalise un vecteur de 4 composantes */
|
||||
|
||||
void vector4_normalize(vector4 * dst)
|
||||
{
|
||||
float len;
|
||||
float norm;
|
||||
norm = vector4_norm(*dst);
|
||||
if (norm != 0)
|
||||
{
|
||||
len = 1 / norm;
|
||||
dst->x = dst->x * len;
|
||||
dst->y = dst->y * len;
|
||||
dst->z = dst->z * len;
|
||||
dst->w = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Divise un vecteur de 4 composantes depuis un autre*/
|
||||
|
||||
void vector4_divide(vector4 * v1, vector4 v2, vector4 * dst)
|
||||
{
|
||||
dst->x = v1->x / v2.x;
|
||||
dst->y = v1->y / v2.y;
|
||||
dst->z = v1->z / v2.z;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Détermine le 3ème vecteur perpendiculaire au 2 autres */
|
||||
|
||||
void vector4_perpendicular(vector4 v1, vector4 v2, vector4 * dst)
|
||||
{
|
||||
float dot = vector4_dotproduct(v1, v2);
|
||||
dst->x = v1.x - dot * v2.x;
|
||||
dst->y = v1.y - dot * v2.y;
|
||||
dst->z = v1.z - dot * v2.z;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Tourne un vecteur à 4 composantes autour de X */
|
||||
|
||||
void vector4_rotate_x(vector4 * dst, float angle)
|
||||
{
|
||||
vector4 origin;
|
||||
float sinus, cosinus;
|
||||
sinus = sinf(angle);
|
||||
cosinus = cosf(angle);
|
||||
origin.x = dst->x;
|
||||
origin.y = dst->y;
|
||||
origin.z = dst->z;
|
||||
dst->y = cosinus * origin.y + sinus * origin.z;
|
||||
dst->z = cosinus * origin.z - sinus * origin.y;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Tourne un vecteur à 4 composantes autour de Y */
|
||||
|
||||
void vector4_rotate_y(vector4 * dst, float angle)
|
||||
{
|
||||
vector4 origin;
|
||||
float sinus, cosinus;
|
||||
sinus = sinf(angle);
|
||||
cosinus = cosf(angle);
|
||||
origin.x = dst->x;
|
||||
origin.y = dst->y;
|
||||
origin.z = dst->z;
|
||||
dst->x = cosinus * origin.x + sinus * origin.z;
|
||||
dst->z = cosinus * origin.z - sinus * origin.x;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Tourne un vecteur à 4 composantes autour de Z */
|
||||
|
||||
void vector4_rotate_z(vector4 * dst, float angle)
|
||||
{
|
||||
vector4 origin;
|
||||
float sinus, cosinus;
|
||||
sinus = sinf(angle);
|
||||
cosinus = cosf(angle);
|
||||
origin.x = dst->x;
|
||||
origin.y = dst->y;
|
||||
origin.z = dst->z;
|
||||
dst->x = cosinus * origin.x + sinus * origin.y;
|
||||
dst->y = cosinus * origin.y - sinus * origin.x;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Donne la longueur d'un vecteur à 4 composantes */
|
||||
|
||||
float vector4_len(vector4 src)
|
||||
{
|
||||
return sqrtf((src.x * src.x) + (src.y * src.y) + (src.z * src.z));
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Retourne le produit scalaire de deux vecteurs à 4 composantes */
|
||||
|
||||
float vector4_dotproduct(vector4 v1, vector4 v2)
|
||||
{
|
||||
return (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Retourne la norme d'un vecteur à 4 composantes */
|
||||
|
||||
float vector4_norm(vector4 src)
|
||||
{
|
||||
return sqrtf((src.x * src.x) + (src.y * src.y) + (src.z * src.z));
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Retourne la distance de deux vecteurs à 4 composantes */
|
||||
|
||||
float vector4_distance(vector4 v1, vector4 v2)
|
||||
{
|
||||
return sqrt(pow(v2.x - v1.x, 2) + pow(v2.y - v1.y, 2) +
|
||||
pow(v2.z - v1.z, 2));
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Compare deux vecteurs à 4 composantes */
|
||||
|
||||
int vector4_isequals(vector4 v1, vector4 v2)
|
||||
{
|
||||
float x, y, z;
|
||||
x = fabsf(v1.x - v2.x);
|
||||
y = fabsf(v1.y - v2.y);
|
||||
z = fabsf(v1.z - v2.z);
|
||||
return (x < 0.000001 && y < 0.000001 && z < 0.000001);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Définie le plan normal à 3 vecteurs à 4 composantes */
|
||||
|
||||
void vector4_planenormal(vector4 v1, vector4 v2, vector4 v3, vector4 * dst)
|
||||
{
|
||||
vector4 temp1, temp2;
|
||||
vector4_sub(v2, v1, &temp1);
|
||||
vector4_sub(v3, v1, &temp2);
|
||||
vector4_crossproduct(temp1, temp2, dst);
|
||||
vector4_normalize(dst);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Créé une matrice d'identité */
|
||||
|
||||
void matrix44_homogen(matrix44 * matrix)
|
||||
{
|
||||
vector4_create(1, 0, 0, 0, &matrix->V[0]);
|
||||
vector4_create(0, 1, 0, 0, &matrix->V[1]);
|
||||
vector4_create(0, 0, 1, 0, &matrix->V[2]);
|
||||
vector4_create(0, 0, 0, 1, &matrix->V[3]);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Créé une matrice vide */
|
||||
|
||||
void matrix44_empty(matrix44 * matrix)
|
||||
{
|
||||
vector4_create(0, 0, 0, 0, &matrix->V[0]);
|
||||
vector4_create(0, 0, 0, 0, &matrix->V[1]);
|
||||
vector4_create(0, 0, 0, 0, &matrix->V[2]);
|
||||
vector4_create(0, 0, 0, 0, &matrix->V[3]);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Créé une matrice de redimensionnement (par un vecteur) */
|
||||
|
||||
void matrix44_scaling(vector4 v, matrix44 * dst)
|
||||
{
|
||||
matrix44_homogen(dst);
|
||||
dst->V[0].x = v.x;
|
||||
dst->V[1].y = v.y;
|
||||
dst->V[2].z = v.z;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Créé une matrice de déplacement */
|
||||
|
||||
void matrix44_translation(vector4 v, matrix44 * dst)
|
||||
{
|
||||
matrix44_homogen(dst);
|
||||
dst->V[0].x = v.x;
|
||||
dst->V[1].y = v.y;
|
||||
dst->V[2].z = v.z;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Créé une matrice de redimensionnement (par un facteur) */
|
||||
|
||||
void matrix44_scale(matrix44 * dst, float factor)
|
||||
{
|
||||
vector4_scale(&dst->V[0], factor);
|
||||
vector4_scale(&dst->V[1], factor);
|
||||
vector4_scale(&dst->V[2], factor);
|
||||
vector4_scale(&dst->V[3], factor);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Créé une matrice de redimensionnement et de déplacement */
|
||||
|
||||
void matrix44_scale_translation(vector4 scale, vector4 translation,
|
||||
matrix44 * dst)
|
||||
{
|
||||
matrix44_homogen(dst);
|
||||
dst->V[0].x = scale.x;
|
||||
dst->V[1].y = scale.y;
|
||||
dst->V[2].z = scale.z;
|
||||
dst->V[3].x = translation.x;
|
||||
dst->V[3].y = translation.y;
|
||||
dst->V[3].z = translation.z;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Créé une matrice de rotation autour de X */
|
||||
|
||||
void matrix44_rotation_x(float angle, matrix44 * dst)
|
||||
{
|
||||
float sinus, cosinus;
|
||||
cosinus = cosf(angle);
|
||||
sinus = sinf(angle);
|
||||
matrix44_empty(dst);
|
||||
dst->V[0].x = 1;
|
||||
dst->V[1].y = cosinus;
|
||||
dst->V[1].z = sinus;
|
||||
dst->V[2].y = -1 * sinus;
|
||||
dst->V[2].z = cosinus;
|
||||
dst->V[3].w = 1;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Créé une matrice de rotation autour de Y */
|
||||
|
||||
void matrix44_rotation_y(float angle, matrix44 * dst)
|
||||
{
|
||||
float sinus, cosinus;
|
||||
cosinus = cosf(angle);
|
||||
sinus = sinf(angle);
|
||||
matrix44_empty(dst);
|
||||
dst->V[0].x = cosinus;
|
||||
dst->V[0].z = -1 * sinus;
|
||||
dst->V[1].y = 1;
|
||||
dst->V[2].x = sinus;
|
||||
dst->V[2].z = cosinus;
|
||||
dst->V[3].w = 1;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Créé une matrice de rotation autour de Z */
|
||||
|
||||
void matrix44_rotation_z(float angle, matrix44 * dst)
|
||||
{
|
||||
float sinus, cosinus;
|
||||
cosinus = cosf(angle);
|
||||
sinus = sinf(angle);
|
||||
matrix44_empty(dst);
|
||||
dst->V[0].x = cosinus;
|
||||
dst->V[0].y = sinus;
|
||||
dst->V[1].x = -1 * sinus;
|
||||
dst->V[1].y = cosinus;
|
||||
dst->V[2].z = 1;
|
||||
dst->V[3].w = 1;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Créé une matrice de rotation multiple */
|
||||
|
||||
void matrix44_rotation(vector4 axis, float angle, matrix44 * dst)
|
||||
{
|
||||
float cosinus, sinus, minuscos;
|
||||
sinus = sinf(angle);
|
||||
cosinus = cosf(angle);
|
||||
vector4_normalize(&axis);
|
||||
minuscos = 1 - cosinus;
|
||||
|
||||
dst->V[0].x = (minuscos * axis.x * axis.x) + cosinus;
|
||||
dst->V[0].y = (minuscos * axis.x * axis.y) - (axis.z * sinus);
|
||||
dst->V[0].z = (minuscos * axis.z * axis.x) + (axis.y * sinus);
|
||||
dst->V[0].w = 0;
|
||||
|
||||
dst->V[1].x = (minuscos * axis.x * axis.y) + (axis.z * sinus);
|
||||
dst->V[1].y = (minuscos * axis.y * axis.y) + cosinus;
|
||||
dst->V[1].z = (minuscos * axis.y * axis.z) - (axis.x * sinus);
|
||||
dst->V[1].w = 0;
|
||||
|
||||
dst->V[2].x = (minuscos * axis.z * axis.x) - (axis.y * sinus);
|
||||
dst->V[2].y = (minuscos * axis.y * axis.z) + (axis.x * sinus);
|
||||
dst->V[2].z = (minuscos * axis.z * axis.z) + cosinus;
|
||||
dst->V[2].w = 0;
|
||||
|
||||
dst->V[3].x = 0;
|
||||
dst->V[3].y = 0;
|
||||
dst->V[3].z = 0;
|
||||
dst->V[3].w = 1;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Multiplie deux matrices */
|
||||
|
||||
void matrix44_multiply(matrix44 * m1, matrix44 * m2, matrix44 * dst)
|
||||
{
|
||||
dst->V[0].x =
|
||||
(m1->V[0].x * m2->V[0].x + m1->V[0].y * m2->V[1].x +
|
||||
m1->V[0].z * m2->V[2].x + m1->V[0].w * m2->V[3].x);
|
||||
dst->V[0].y =
|
||||
(m1->V[0].x * m2->V[0].y + m1->V[0].y * m2->V[1].y +
|
||||
m1->V[0].z * m2->V[2].y + m1->V[0].w * m2->V[3].y);
|
||||
dst->V[0].z =
|
||||
(m1->V[0].x * m2->V[0].z + m1->V[0].y * m2->V[1].z +
|
||||
m1->V[0].z * m2->V[2].z + m1->V[0].w * m2->V[3].z);
|
||||
dst->V[0].w =
|
||||
(m1->V[0].x * m2->V[0].w + m1->V[0].y * m2->V[1].w +
|
||||
m1->V[0].z * m2->V[2].w + m1->V[0].w * m2->V[3].w);
|
||||
dst->V[1].x =
|
||||
(m1->V[1].x * m2->V[0].x + m1->V[1].y * m2->V[1].x +
|
||||
m1->V[1].z * m2->V[2].x + m1->V[1].w * m2->V[3].x);
|
||||
dst->V[1].y =
|
||||
(m1->V[1].x * m2->V[0].y + m1->V[1].y * m2->V[1].y +
|
||||
m1->V[1].z * m2->V[2].y + m1->V[1].w * m2->V[3].y);
|
||||
dst->V[1].z =
|
||||
(m1->V[1].x * m2->V[0].z + m1->V[1].y * m2->V[1].z +
|
||||
m1->V[1].z * m2->V[2].z + m1->V[1].w * m2->V[3].z);
|
||||
dst->V[1].w =
|
||||
(m1->V[1].x * m2->V[0].w + m1->V[1].y * m2->V[1].w +
|
||||
m1->V[1].z * m2->V[2].w + m1->V[1].w * m2->V[3].w);
|
||||
dst->V[2].x =
|
||||
(m1->V[2].x * m2->V[0].x + m1->V[2].y * m2->V[1].x +
|
||||
m1->V[2].z * m2->V[2].x + m1->V[2].w * m2->V[3].x);
|
||||
dst->V[2].y =
|
||||
(m1->V[2].x * m2->V[0].y + m1->V[2].y * m2->V[1].y +
|
||||
m1->V[2].z * m2->V[2].y + m1->V[2].w * m2->V[3].y);
|
||||
dst->V[2].z =
|
||||
(m1->V[2].x * m2->V[0].z + m1->V[2].y * m2->V[1].z +
|
||||
m1->V[2].z * m2->V[2].z + m1->V[2].w * m2->V[3].z);
|
||||
dst->V[2].w =
|
||||
(m1->V[2].x * m2->V[0].w + m1->V[2].y * m2->V[1].w +
|
||||
m1->V[2].z * m2->V[2].w + m1->V[2].w * m2->V[3].w);
|
||||
dst->V[3].x =
|
||||
(m1->V[3].x * m2->V[0].x + m1->V[3].y * m2->V[1].x +
|
||||
m1->V[3].z * m2->V[2].x + m1->V[3].w * m2->V[3].x);
|
||||
dst->V[3].y =
|
||||
(m1->V[3].x * m2->V[0].y + m1->V[3].y * m2->V[1].y +
|
||||
m1->V[3].z * m2->V[2].y + m1->V[3].w * m2->V[3].y);
|
||||
dst->V[3].z =
|
||||
(m1->V[3].x * m2->V[0].z + m1->V[3].y * m2->V[1].z +
|
||||
m1->V[3].z * m2->V[2].z + m1->V[3].w * m2->V[3].z);
|
||||
dst->V[3].w =
|
||||
(m1->V[3].x * m2->V[0].w + m1->V[3].y * m2->V[1].w +
|
||||
m1->V[3].z * m2->V[2].w + m1->V[3].w * m2->V[3].w);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Transforme une matrice avec un vecteur à 4 composantes */
|
||||
|
||||
void matrix44_transform(matrix44 * matrix, vector4 * dst)
|
||||
{
|
||||
vector4 origin;
|
||||
origin.x = dst->x;
|
||||
origin.y = dst->y;
|
||||
origin.z = dst->z;
|
||||
origin.w = dst->w;
|
||||
dst->x = origin.x * matrix->V[0].x + origin.y * matrix->V[1].x +
|
||||
origin.z * matrix->V[2].x + origin.w * matrix->V[3].x;
|
||||
dst->y = origin.x * matrix->V[0].y + origin.y * matrix->V[1].y +
|
||||
origin.z * matrix->V[2].y + origin.w * matrix->V[3].y;
|
||||
dst->z = origin.x * matrix->V[0].z + origin.y * matrix->V[1].z +
|
||||
origin.z * matrix->V[2].z + origin.w * matrix->V[3].z;
|
||||
dst->w = origin.x * matrix->V[0].w + origin.y * matrix->V[1].w +
|
||||
origin.z * matrix->V[2].w + origin.w * matrix->V[3].w;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Calcule le déterminant d'une matrice */
|
||||
|
||||
float matrix44_determinant(matrix44 * matrix)
|
||||
{
|
||||
float a, b, c, d;
|
||||
a = matrix->V[0].x * todeterminant(matrix->V[1].y, matrix->V[2].y,
|
||||
matrix->V[3].y, matrix->V[1].z,
|
||||
matrix->V[2].z, matrix->V[3].z,
|
||||
matrix->V[1].w, matrix->V[2].w,
|
||||
matrix->V[3].w);
|
||||
b = matrix->V[0].y * todeterminant(matrix->V[1].x, matrix->V[2].x,
|
||||
matrix->V[3].x, matrix->V[1].z,
|
||||
matrix->V[2].z, matrix->V[3].z,
|
||||
matrix->V[1].w, matrix->V[2].w,
|
||||
matrix->V[3].w);
|
||||
c = matrix->V[0].z * todeterminant(matrix->V[1].x, matrix->V[2].x,
|
||||
matrix->V[3].x, matrix->V[1].y,
|
||||
matrix->V[2].y, matrix->V[3].y,
|
||||
matrix->V[1].w, matrix->V[2].w,
|
||||
matrix->V[3].w);
|
||||
d = matrix->V[0].w * todeterminant(matrix->V[1].x, matrix->V[2].x,
|
||||
matrix->V[3].x, matrix->V[1].y,
|
||||
matrix->V[2].y, matrix->V[3].y,
|
||||
matrix->V[1].z, matrix->V[2].z,
|
||||
matrix->V[3].z);
|
||||
return a - b + c - d;
|
||||
}
|
||||
|
||||
float todeterminant(float a1, float a2, float a3, float b1, float b2,
|
||||
float b3, float c1, float c2, float c3)
|
||||
{
|
||||
return (a1 * ((b2 * c3) - (b3 * c2))) -
|
||||
(b1 * ((a2 * c3) - (a3 * c2))) +
|
||||
(c1 * ((a2 * b3) - (a3 * b2)));
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Crée une matrice adjointe */
|
||||
|
||||
void matrix44_adjoint(matrix44 * matrix)
|
||||
{
|
||||
float a1, a2, a3, a4, b1, b2, b3, b4, c1, c2, c3, c4, d1, d2, d3,
|
||||
d4;
|
||||
a1 = matrix->V[0].x;
|
||||
b1 = matrix->V[0].y;
|
||||
c1 = matrix->V[0].z;
|
||||
d1 = matrix->V[0].w;
|
||||
|
||||
a2 = matrix->V[1].x;
|
||||
b2 = matrix->V[1].y;
|
||||
c2 = matrix->V[1].z;
|
||||
d2 = matrix->V[1].w;
|
||||
|
||||
a3 = matrix->V[2].x;
|
||||
b3 = matrix->V[2].y;
|
||||
c3 = matrix->V[2].z;
|
||||
d3 = matrix->V[2].w;
|
||||
|
||||
a4 = matrix->V[3].x;
|
||||
b4 = matrix->V[3].y;
|
||||
c4 = matrix->V[3].z;
|
||||
d4 = matrix->V[3].w;
|
||||
|
||||
matrix->V[0].x = todeterminant(b2, b3, b4, c2, c3, c4, d2, d3, d4);
|
||||
matrix->V[1].x =
|
||||
-todeterminant(a2, a3, a4, c2, c3, c4, d2, d3, d4);
|
||||
matrix->V[2].x = todeterminant(a2, a3, a4, b2, b3, b4, d2, d3, d4);
|
||||
matrix->V[3].x =
|
||||
-todeterminant(a2, a3, a4, b2, b3, b4, c2, c3, c4);
|
||||
|
||||
matrix->V[0].y =
|
||||
-todeterminant(b1, b3, b4, c1, c3, c4, d1, d3, d4);
|
||||
matrix->V[1].y = todeterminant(a1, a3, a4, c1, c3, c4, d1, d3, d4);
|
||||
matrix->V[2].y =
|
||||
-todeterminant(a1, a3, a4, b1, b3, b4, d1, d3, d4);
|
||||
matrix->V[3].y = todeterminant(a1, a3, a4, b1, b3, b4, c1, c3, c4);
|
||||
|
||||
matrix->V[0].z = todeterminant(b1, b2, b4, c1, c2, c4, d1, d2, d4);
|
||||
matrix->V[1].z =
|
||||
-todeterminant(a1, a2, a4, c1, c2, c4, d1, d2, d4);
|
||||
matrix->V[2].z = todeterminant(a1, a2, a4, b1, b2, b4, d1, d2, d4);
|
||||
matrix->V[3].z =
|
||||
-todeterminant(a1, a2, a4, b1, b2, b4, c1, c2, c4);
|
||||
|
||||
matrix->V[0].w =
|
||||
-todeterminant(b1, b2, b3, c1, c2, c3, d1, d2, d3);
|
||||
matrix->V[1].w = todeterminant(a1, a2, a3, c1, c2, c3, d1, d2, d3);
|
||||
matrix->V[2].w =
|
||||
-todeterminant(a1, a2, a3, b1, b2, b3, d1, d2, d3);
|
||||
matrix->V[3].w = todeterminant(a1, a2, a3, b1, b2, b3, c1, c2, c3);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Affiche une matrice */
|
||||
|
||||
void matrix44_show(matrix44 * matrix)
|
||||
{
|
||||
printf("Matrice: X=%f Y=%f Z=%f W=%f \r\n", matrix->V[0].x,
|
||||
matrix->V[1].y, matrix->V[2].z, matrix->V[3].w);
|
||||
printf(" X=%f Y=%f Z=%f W=%f \r\n", matrix->V[0].x,
|
||||
matrix->V[1].y, matrix->V[2].z, matrix->V[3].w);
|
||||
printf(" X=%f Y=%f Z=%f W=%f \r\n", matrix->V[0].x,
|
||||
matrix->V[1].y, matrix->V[2].z, matrix->V[3].w);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Inverse une matrice */
|
||||
|
||||
void matrix44_invert(matrix44 * matrix)
|
||||
{
|
||||
float det;
|
||||
det = matrix44_determinant(matrix);
|
||||
if (fabs(det) < EPSILON)
|
||||
{
|
||||
matrix44_homogen(matrix);
|
||||
}
|
||||
else
|
||||
{
|
||||
matrix44_adjoint(matrix);
|
||||
matrix44_scale(matrix, 1.0 / det);
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Transpose une matrice */
|
||||
|
||||
void matrix44_transpose(matrix44 * matrix)
|
||||
{
|
||||
float f;
|
||||
f = matrix->V[0].y;
|
||||
matrix->V[0].y = matrix->V[1].x;
|
||||
matrix->V[1].x = f;
|
||||
|
||||
f = matrix->V[0].z;
|
||||
matrix->V[0].z = matrix->V[2].x;
|
||||
matrix->V[2].x = f;
|
||||
|
||||
f = matrix->V[0].w;
|
||||
matrix->V[0].w = matrix->V[3].x;
|
||||
matrix->V[3].x = f;
|
||||
|
||||
f = matrix->V[1].z;
|
||||
matrix->V[1].z = matrix->V[2].y;
|
||||
matrix->V[2].y = f;
|
||||
|
||||
f = matrix->V[1].w;
|
||||
matrix->V[1].w = matrix->V[3].y;
|
||||
matrix->V[3].y = f;
|
||||
|
||||
f = matrix->V[2].w;
|
||||
matrix->V[2].w = matrix->V[3].z;
|
||||
matrix->V[3].z = f;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Crée une matrice de camera */
|
||||
|
||||
void matrix44_lookat(vector4 eye, vector4 dst, vector4 up,
|
||||
matrix44 * matrix)
|
||||
{
|
||||
vector4 xaxis, yaxis, zaxis, negeye;
|
||||
vector4_sub(dst, eye, &zaxis);
|
||||
vector4_normalize(&zaxis);
|
||||
|
||||
vector4_crossproduct(zaxis, up, &xaxis);
|
||||
vector4_normalize(&xaxis);
|
||||
|
||||
vector4_crossproduct(xaxis, zaxis, &yaxis);
|
||||
|
||||
vector4_copy(xaxis, &matrix->V[0]);
|
||||
vector4_copy(yaxis, &matrix->V[1]);
|
||||
vector4_copy(zaxis, &matrix->V[2]);
|
||||
|
||||
matrix->V[2].x = -matrix->V[2].x;
|
||||
matrix->V[2].y = -matrix->V[2].y;
|
||||
matrix->V[2].z = -matrix->V[2].z;
|
||||
|
||||
vector4_create(0, 0, 0, 1, &matrix->V[3]);
|
||||
|
||||
matrix44_transpose(matrix);
|
||||
vector4_create(-eye.x, -eye.y, -eye.z, 1, &negeye);
|
||||
|
||||
matrix44_transform(matrix, &negeye);
|
||||
vector4_copy(negeye, &matrix->V[3]);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Vérifie que deux matrices sont égales */
|
||||
|
||||
int matrix44_isequals(matrix44 * m1, matrix44 * m2)
|
||||
{
|
||||
return vector4_isequals(m1->V[0], m2->V[0])
|
||||
&& vector4_isequals(m1->V[1], m2->V[1])
|
||||
&& vector4_isequals(m1->V[2], m2->V[2])
|
||||
&& vector4_isequals(m1->V[3], m2->V[3]);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Transforme une matrice en tableau */
|
||||
|
||||
float *toarray(matrix44 * m)
|
||||
{
|
||||
return &m->v;
|
||||
}
|
|
@ -1,46 +1,719 @@
|
|||
#include "types.h"
|
||||
|
||||
/*******************************************************************************/
|
||||
|
||||
/* Copie un octet une ou plusieurs fois en mémoire */
|
||||
void memset(void *dst, u8 val, u32 count,u32 size)
|
||||
{
|
||||
u8 *temp;
|
||||
for(temp = (u8 *)dst; count != 0; count--)
|
||||
{
|
||||
temp+=size;
|
||||
*temp = val;
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
|
||||
/* Copie une portion de mémoire vers une autre */
|
||||
void memcpy(void *src, void *dst, u32 count, u32 size)
|
||||
{
|
||||
char *s, *d;
|
||||
u32 i;
|
||||
s = (u8*) src;
|
||||
d = (u8*) dst;
|
||||
for(i=0;i<count;i++){
|
||||
*(d+i*size) = *(s+i);
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
|
||||
/* Compare 2 portions de mémoire */
|
||||
u32 memcmp(void *src, void *dst, u32 count, u32 size)
|
||||
{
|
||||
const u8 *mem1 = (const u8 *)src;
|
||||
const u8 *mem2 = (const u8 *)dst;
|
||||
for(; count != 0; count--)
|
||||
{
|
||||
if(*mem1 != *mem2)
|
||||
return *mem1 - *mem2;
|
||||
mem1+=size;
|
||||
mem2+=size;
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "types.h"
|
||||
#include "memory.h"
|
||||
#include "queue.h"
|
||||
#include "asm.h"
|
||||
#include "boot.h"
|
||||
|
||||
static u8 *kernelcurrentheap = NULL; /* pointeur vers le heap noyau */
|
||||
static u8 bitmap[MAXMEMPAGE / 8]; /* bitmap */
|
||||
static vrange_t vrange_head;
|
||||
static u64 memorysize=0;
|
||||
|
||||
extern bootparams* allparams;
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Erreur fatale */
|
||||
|
||||
void panic(u8 * string)
|
||||
{
|
||||
printf("KERNEL PANIC: %s\r\nSysteme arrete...\n");
|
||||
halt();
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Alloue plusieurs pages virtuelles (size) pour le heap du noyau */
|
||||
|
||||
tmalloc *mallocpage(u64 size)
|
||||
{
|
||||
tmalloc *chunk;
|
||||
u8 *paddr;
|
||||
u16 nbpages = size / PAGESIZE;
|
||||
u64 realsize = nbpages * PAGESIZE;
|
||||
if (size % PAGESIZE != 0)
|
||||
realsize += PAGESIZE;
|
||||
if ((kernelcurrentheap - KERNEL_HEAP + realsize) > MAXHEAPSIZE)
|
||||
panic("Plus de memoire noyau heap disponible a allouer !\n");
|
||||
chunk = (tmalloc *) kernelcurrentheap;
|
||||
virtual_range_new_kernel(kernelcurrentheap, realsize);
|
||||
kernelcurrentheap += realsize;
|
||||
chunk->size = realsize;
|
||||
chunk->used = 0;
|
||||
return chunk;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Retourne le nombre de blocs dynamiques (heap) */
|
||||
|
||||
u32 getmallocnb(void)
|
||||
{
|
||||
u32 realsize = 0;
|
||||
tmalloc *chunk;
|
||||
chunk = KERNEL_HEAP;
|
||||
while (chunk < (tmalloc *) kernelcurrentheap)
|
||||
{
|
||||
realsize++;
|
||||
chunk = (tmalloc *) ((u8 *) chunk + chunk->size);
|
||||
}
|
||||
return realsize;
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Retourne la mémoire virtuelle utilisée de façon dynamique (heap) */
|
||||
|
||||
u32 getmallocused(void)
|
||||
{
|
||||
u32 realsize = 0;
|
||||
tmalloc *chunk;
|
||||
chunk = KERNEL_HEAP;
|
||||
while (chunk < (tmalloc *) kernelcurrentheap)
|
||||
{
|
||||
if (chunk->used)
|
||||
realsize += chunk->size;
|
||||
chunk = (tmalloc *) ((u8 *) chunk + chunk->size);
|
||||
}
|
||||
return realsize;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Retourne la mémoire virtuelle libre de façon dynamique (heap) */
|
||||
|
||||
u32 getmallocfree(void)
|
||||
{
|
||||
u32 realsize = 0;
|
||||
tmalloc *chunk;
|
||||
chunk = KERNEL_HEAP;
|
||||
while (chunk < (tmalloc *) kernelcurrentheap)
|
||||
{
|
||||
if (!chunk->used)
|
||||
realsize += chunk->size;
|
||||
chunk = (tmalloc *) ((u8 *) chunk + chunk->size);
|
||||
}
|
||||
return realsize;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Retourne la mémoire virtuelle non allouée de façon dynamique (heap) */
|
||||
|
||||
u32 getmallocnonallocated(void)
|
||||
{
|
||||
return VESA_FBMEM - ((u32) kernelcurrentheap);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Alloue de la mémoire virtuelle au noyau de façon dynamique (heap) */
|
||||
|
||||
void *vmalloc(u32 size)
|
||||
{
|
||||
u32 realsize;
|
||||
tmalloc *chunk, *new;
|
||||
realsize = sizeof(tmalloc) + size;
|
||||
if (realsize < MALLOC_MINIMUM)
|
||||
realsize = MALLOC_MINIMUM;
|
||||
chunk = KERNEL_HEAP;
|
||||
while (chunk->used || chunk->size < realsize)
|
||||
{
|
||||
if (chunk->size == 0)
|
||||
panic(sprintf
|
||||
("Element du heap %x defectueux avec une taille nulle (heap %x) !",
|
||||
chunk, kernelcurrentheap));
|
||||
chunk = (tmalloc *) ((u8 *) chunk + chunk->size);
|
||||
if (chunk == (tmalloc *) kernelcurrentheap)
|
||||
mallocpage(realsize);
|
||||
else if (chunk > (tmalloc *) kernelcurrentheap)
|
||||
panic(sprintf
|
||||
("Element du heap %x depassant la limite %x !",
|
||||
chunk, kernelcurrentheap));
|
||||
}
|
||||
if (chunk->size - realsize < MALLOC_MINIMUM)
|
||||
chunk->used = 1;
|
||||
else
|
||||
{
|
||||
new = (tmalloc *) ((u8 *) chunk + realsize);
|
||||
new->size = chunk->size - realsize;
|
||||
new->used = 0;
|
||||
chunk->size = realsize;
|
||||
chunk->used = 1;
|
||||
}
|
||||
return (u8 *) chunk + sizeof(tmalloc);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Libère de la mémoire virtuelle depuis le heap noyau */
|
||||
|
||||
void vfree(void *vaddr)
|
||||
{
|
||||
tmalloc *chunk, *new;
|
||||
chunk = (tmalloc *) (vaddr - sizeof(tmalloc));
|
||||
chunk->used = 0;
|
||||
while ((new = (tmalloc *) ((u8 *) chunk + chunk->size))
|
||||
&& new < (tmalloc *) kernelcurrentheap && new->used == 0)
|
||||
chunk->size += new->size;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Retourne la taille de la mémoire physique (selon grub) */
|
||||
|
||||
u64 physical_getmemorysize()
|
||||
{
|
||||
return memorysize;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Retourne que la page physique actuelle est occupée */
|
||||
|
||||
void physical_page_use(u32 page)
|
||||
{
|
||||
bitmap[(page / 8)] |= (1 << (page % 8));
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Retourne que la page physique actuelle est libre */
|
||||
|
||||
void physical_page_free(u32 page)
|
||||
{
|
||||
bitmap[(page / 8)] &= ~(1 << (page % 8));
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Reserve un espace mémoire physique dans le bitmap */
|
||||
|
||||
void physical_range_use(u64 addr, u64 len)
|
||||
{
|
||||
u32 nbpage = TOPAGE(len);
|
||||
u32 pagesrc = TOPAGE(addr);
|
||||
if (len & 0x3FF > 0)
|
||||
nbpage++;
|
||||
if (addr >= MAXMEMSIZE)
|
||||
return;
|
||||
if (addr + len >= MAXMEMSIZE)
|
||||
len = MAXMEMSIZE - addr - 1;
|
||||
for (u32 page = pagesrc; page < pagesrc + nbpage; page++)
|
||||
physical_page_use(page);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Libère un espace mémoire physique dans le bitmap */
|
||||
|
||||
void physical_range_free(u64 addr, u64 len)
|
||||
{
|
||||
u32 nbpage = TOPAGE(len);
|
||||
u32 pagesrc = TOPAGE(addr);
|
||||
if (len & 0x3FF > 0)
|
||||
nbpage++;
|
||||
if (addr >= MAXMEMSIZE)
|
||||
return;
|
||||
if (addr + len >= MAXMEMSIZE)
|
||||
len = MAXMEMSIZE - addr - 1;
|
||||
for (u32 page = pagesrc; page < pagesrc + nbpage; page++)
|
||||
physical_page_free(page);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Retourne une page physique libre */
|
||||
|
||||
u8 *physical_page_getfree(void)
|
||||
{
|
||||
u32 byte;
|
||||
u8 bit;
|
||||
u32 page = 0;
|
||||
for (byte = 0; byte < sizeof(bitmap); byte++)
|
||||
if (bitmap[byte] != 0xFF)
|
||||
for (bit = 0; bit < 8; bit++)
|
||||
if (!(bitmap[byte] & (1 << bit)))
|
||||
{
|
||||
page = 8 * byte + bit;
|
||||
physical_page_use(page);
|
||||
return (u8 *) (page * PAGESIZE);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Retourne l'espace libre */
|
||||
|
||||
u64 getmemoryfree(void)
|
||||
{
|
||||
u32 byte, bit;
|
||||
u64 free = 0;
|
||||
for (byte = 0; byte < sizeof(bitmap); byte++)
|
||||
if (bitmap[byte] != 0xFF)
|
||||
for (bit = 0; bit < 8; bit++)
|
||||
if (!(bitmap[byte] & (1 << bit)))
|
||||
free += PAGESIZE;
|
||||
return free;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Initialisation du bitmap pour la gestion physique de la mémoire */
|
||||
|
||||
void physical_init()
|
||||
{
|
||||
for (u64 page = 0; page < sizeof(bitmap); page++)
|
||||
bitmap[page] = 0xFF;
|
||||
for (u8 i=0;i<allparams->e820_numbers;i++)
|
||||
{
|
||||
if (allparams->e820_table[i].type == E820_TYPE_RAM)
|
||||
physical_range_free(allparams->e820_table[i].addr, allparams->e820_table[i].size);
|
||||
else
|
||||
physical_range_use(allparams->e820_table[i].addr, allparams->e820_table[i].size);
|
||||
if ((allparams->e820_table[i].addr + allparams->e820_table[i].size > memorysize) && allparams->e820_table[i].type == E820_TYPE_RAM)
|
||||
memorysize = allparams->e820_table[i].addr + allparams->e820_table[i].size;
|
||||
if (memorysize >= MAXMEMSIZE)
|
||||
memorysize = MAXMEMSIZE - 1;
|
||||
}
|
||||
physical_range_use(0x0, KERNELSIZE);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Retourne une page virtuelle de mémoire */
|
||||
|
||||
page *virtual_page_getfree(void)
|
||||
{
|
||||
page *pg;
|
||||
vrange *vpages;
|
||||
u8 *vaddr, *paddr;
|
||||
paddr = physical_page_getfree();
|
||||
if (paddr == NULL)
|
||||
panic("Plus de memoire physique disponible !\n");
|
||||
if (TAILQ_EMPTY(&vrange_head))
|
||||
panic("Plus de place disponible dans la reserve de page !\n");
|
||||
vpages = TAILQ_FIRST(&vrange_head);
|
||||
vaddr = vpages->vaddrlow;
|
||||
vpages->vaddrlow += PAGESIZE;
|
||||
if (vpages->vaddrlow == vpages->vaddrhigh)
|
||||
{
|
||||
TAILQ_REMOVE(&vrange_head, vpages, tailq);
|
||||
vfree(vpages);
|
||||
}
|
||||
virtual_pd_page_add(NULL, vaddr, paddr, 0);
|
||||
pg = (page *) vmalloc(sizeof(page));
|
||||
pg->vaddr = vaddr;
|
||||
pg->paddr = paddr;
|
||||
return pg;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Création d'un directory pour la gestion virtuelle de la mémoire */
|
||||
|
||||
pd *virtual_pd_create()
|
||||
{
|
||||
pd *new;
|
||||
u32 *pdir, *pd0;
|
||||
u32 i;
|
||||
new = (pd *) vmalloc(sizeof(pd));
|
||||
new->addr = virtual_page_getfree();
|
||||
pdir = (u32 *) new->addr->vaddr;
|
||||
pd0 = (u32 *) KERNEL_PD_ADDR;
|
||||
for (i = 0; i < 256; i++)
|
||||
pdir[i] = pd0[i];
|
||||
for (i = 256; i < 1023; i++)
|
||||
pdir[i] = 0;
|
||||
pdir[1023] =
|
||||
((u32) new->addr->paddr | (PAGE_PRESENT | PAGE_WRITE));
|
||||
TAILQ_INIT(&new->page_head);
|
||||
return new;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Attache une page virtuelle de la mémoire dans le directory spécifié */
|
||||
|
||||
void virtual_pd_page_add(pd * dst, u8 * vaddr, u8 * paddr, u32 flags)
|
||||
{
|
||||
u32 *pdir;
|
||||
u32 *ptable;
|
||||
u32 *pt;
|
||||
page *pg;
|
||||
int i;
|
||||
if (dst == NULL)
|
||||
if (vaddr > (u8 *) USER_CODE)
|
||||
{
|
||||
printf("ERREUR: Adresse %X n'est pas dans l'espace noyau !\n", vaddr);
|
||||
return;
|
||||
}
|
||||
pdir = (u32 *) (0xFFFFF000 | (((u32) vaddr & 0xFFC00000) >> 20));
|
||||
if ((*pdir & PAGE_PRESENT) == 0)
|
||||
{
|
||||
if (dst == NULL)
|
||||
panic(sprintf
|
||||
("Page table introuvable pour l'adresse %x !\r\n",
|
||||
vaddr));
|
||||
pg = virtual_page_getfree();
|
||||
pt = (u32 *) pg->vaddr;
|
||||
for (i = 1; i < 1024; i++)
|
||||
pt[i] = 0;
|
||||
*pdir = (u32) pg->paddr | (PAGE_PRESENT | PAGE_WRITE |
|
||||
flags);
|
||||
if (dst)
|
||||
TAILQ_INSERT_TAIL(&dst->page_head, pg, tailq);
|
||||
}
|
||||
ptable = (u32 *) (0xFFC00000 | (((u32) vaddr & 0xFFFFF000) >> 10));
|
||||
*ptable = ((u32) paddr) | (PAGE_PRESENT | PAGE_WRITE | flags);
|
||||
return;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Retire une page virtuelle de la mémoire dans le directory spécifié */
|
||||
|
||||
void virtual_pd_page_remove(u8 * vaddr)
|
||||
{
|
||||
u32 *ptable;
|
||||
if (virtual_to_physical(vaddr))
|
||||
{
|
||||
ptable = (u32 *) (0xFFC00000 |
|
||||
(((u32) vaddr & 0xFFFFF000) >> 10));
|
||||
*ptable = (*ptable & (~PAGE_PRESENT));
|
||||
asm("invlpg %0"::"m"(vaddr));
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Renvoie l'adresse physique de la page virtuel */
|
||||
|
||||
u8 *virtual_to_physical(u8 * vaddr)
|
||||
{
|
||||
u32 *pdir;
|
||||
u32 *ptable;
|
||||
|
||||
pdir = (u32 *) (0xFFFFF000 | (((u32) vaddr & 0xFFC00000) >> 20));
|
||||
if ((*pdir & PAGE_PRESENT))
|
||||
{
|
||||
ptable = (u32 *) (0xFFC00000 |
|
||||
(((u32) vaddr & 0xFFFFF000) >> 10));
|
||||
if ((*ptable & PAGE_PRESENT))
|
||||
return (u8 *) ((*ptable & 0xFFFFF000) +
|
||||
(TOPG((u32) vaddr)));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Détermine une plage virtuelle de mémoire comme étant mappé aux adresses physiques spécifiées GENERIQUE*/
|
||||
|
||||
void virtual_range_use(pd * dst, u8 * vaddr, u8 * paddr, u64 len,
|
||||
u32 flags)
|
||||
{
|
||||
u64 i;
|
||||
u32 realen = len / PAGESIZE;
|
||||
page *pg;
|
||||
if (len % PAGESIZE != 0)
|
||||
realen++;
|
||||
for (i = 0; i < realen; i++)
|
||||
{
|
||||
if (dst == NULL)
|
||||
{
|
||||
virtual_pd_page_add(dst, vaddr + i * PAGESIZE,
|
||||
paddr + i * PAGESIZE, flags);
|
||||
}
|
||||
else
|
||||
{
|
||||
pg = (page *) vmalloc(sizeof(page));
|
||||
pg->paddr = paddr + i * PAGESIZE;
|
||||
pg->vaddr = vaddr + i * PAGESIZE;
|
||||
TAILQ_INSERT_TAIL(&dst->page_head, pg, tailq);
|
||||
virtual_pd_page_add(dst, pg->vaddr, pg->paddr,
|
||||
flags);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Supprime une plage virtuelle de mémoire GENERIQUE */
|
||||
|
||||
void virtual_range_free(pd * dst, u8 * vaddr, u64 len)
|
||||
{
|
||||
u64 i;
|
||||
u32 realen = len / PAGESIZE;
|
||||
if (len % PAGESIZE != 0)
|
||||
realen++;
|
||||
for (i = 0; i < realen; i++)
|
||||
{
|
||||
virtual_pd_page_remove(vaddr + i * PAGESIZE);
|
||||
virtual_page_free(vaddr);
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Détermine une plage virtuelle de mémoire en attribuant de la mémoire physique GENERIQUE */
|
||||
|
||||
void virtual_range_new(pd * dst, u8 * vaddr, u64 len, u32 flags)
|
||||
{
|
||||
u64 i;
|
||||
u32 realen = len / PAGESIZE;
|
||||
page *pg;
|
||||
if (len % PAGESIZE != 0)
|
||||
realen++;
|
||||
for (i = 0; i < realen; i++)
|
||||
{
|
||||
if (dst == NULL)
|
||||
{
|
||||
virtual_pd_page_add(dst, vaddr + i * PAGESIZE,
|
||||
physical_page_getfree(),
|
||||
flags);
|
||||
}
|
||||
else
|
||||
{
|
||||
pg = (page *) vmalloc(sizeof(page));
|
||||
pg->paddr = physical_page_getfree();
|
||||
pg->vaddr = vaddr + i * PAGESIZE;
|
||||
TAILQ_INSERT_TAIL(&dst->page_head, pg, tailq);
|
||||
virtual_pd_page_add(dst, pg->vaddr, pg->paddr,
|
||||
flags);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Détermine une plage virtuelle de mémoire comme étant mappé aux adresses physiques spécifiées pour le noyau*/
|
||||
|
||||
void virtual_range_use_kernel(u8 * vaddr, u8 * paddr, u64 * len, u32 flags)
|
||||
{
|
||||
virtual_range_use(NULL, vaddr, paddr, len, flags);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Supprime une plage virtuelle de mémoire pour le noyau */
|
||||
|
||||
void virtual_range_free_kernel(u8 * vaddr, u64 len)
|
||||
{
|
||||
virtual_range_free(NULL, vaddr, len);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Détermine une plage virtuelle de mémoire en attribuant de la mémoire physique pour le noyau */
|
||||
|
||||
void virtual_range_new_kernel(u8 * vaddr, u64 len, u32 flags)
|
||||
{
|
||||
virtual_range_new(NULL, vaddr, len, flags);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Renvoie le nombre de pages virtuelles occupées */
|
||||
|
||||
u32 virtual_getpagesused()
|
||||
{
|
||||
u32 maxpage = ((u32) MAXPAGESSIZE) / ((u16) PAGESIZE);
|
||||
return maxpage - virtual_getpagesfree();
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Renvoie le nombre de pages virtuelles libres */
|
||||
|
||||
u32 virtual_getpagesfree()
|
||||
{
|
||||
vrange *next;
|
||||
u32 realsize = 0;
|
||||
TAILQ_FOREACH(next, &vrange_head, tailq) realsize +=
|
||||
(next->vaddrhigh - next->vaddrlow) / PAGESIZE;
|
||||
return realsize;
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Libère une page virtuelle de la mémoire */
|
||||
|
||||
void virtual_page_free(u8 * vaddr)
|
||||
{
|
||||
vrange *next, *prev, *new;
|
||||
u8 *paddr;
|
||||
paddr = virtual_to_physical(vaddr);
|
||||
if (paddr)
|
||||
physical_page_free(TOPAGE((u32) paddr));
|
||||
else
|
||||
{
|
||||
printf("Aucune page associee a l'adresse virtuelle %x\n",
|
||||
vaddr);
|
||||
return;
|
||||
}
|
||||
virtual_pd_page_remove(vaddr);
|
||||
TAILQ_FOREACH(next, &vrange_head, tailq)
|
||||
{
|
||||
if (next->vaddrlow > vaddr)
|
||||
break;
|
||||
}
|
||||
prev = TAILQ_PREV(next, vrange_s, tailq);
|
||||
if (prev->vaddrhigh == vaddr)
|
||||
{
|
||||
prev->vaddrhigh += PAGESIZE;
|
||||
if (prev->vaddrhigh == next->vaddrlow)
|
||||
{
|
||||
prev->vaddrhigh = next->vaddrhigh;
|
||||
TAILQ_REMOVE(&vrange_head, next, tailq);
|
||||
vfree(next);
|
||||
}
|
||||
}
|
||||
else if (next->vaddrlow == vaddr + PAGESIZE)
|
||||
{
|
||||
next->vaddrlow = vaddr;
|
||||
}
|
||||
else if (next->vaddrlow > vaddr + PAGESIZE)
|
||||
{
|
||||
new = (vrange *) vmalloc(sizeof(vrange));
|
||||
new->vaddrlow = vaddr;
|
||||
new->vaddrhigh = vaddr + PAGESIZE;
|
||||
TAILQ_INSERT_BEFORE(prev, new, tailq);
|
||||
}
|
||||
else
|
||||
panic("Liste chainee corrompue !\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Destruction d'un directory pour la gestion virtuelle de la mémoire */
|
||||
|
||||
void virtual_pd_destroy(pd * dst)
|
||||
{
|
||||
page *pg;
|
||||
TAILQ_FOREACH(pg, &dst->page_head, tailq)
|
||||
{
|
||||
virtual_page_free(pg->vaddr);
|
||||
TAILQ_REMOVE(&dst->page_head, pg, tailq);
|
||||
vfree(pg);
|
||||
}
|
||||
virtual_page_free(dst->addr->vaddr);
|
||||
vfree(dst);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Affiche toutes les page du directory */
|
||||
|
||||
void virtual_pd_show(pd *dst)
|
||||
{
|
||||
page *pg;
|
||||
bool first=true;
|
||||
TAILQ_FOREACH(pg, &dst->page_head, tailq)
|
||||
{
|
||||
if (!first)
|
||||
print(",");
|
||||
else
|
||||
first=false;
|
||||
printf("%Y",(u32)pg->vaddr);
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Initialise une pages virtuelles (size) pour le heap du noyau */
|
||||
|
||||
void malloc_init(void)
|
||||
{
|
||||
tmalloc *chunk;
|
||||
chunk = (tmalloc *) KERNEL_HEAP;
|
||||
virtual_pd_page_add(NULL, KERNEL_HEAP, physical_page_getfree(),
|
||||
PAGE_NOFLAG);
|
||||
kernelcurrentheap = KERNEL_HEAP + PAGESIZE;
|
||||
chunk->size = PAGESIZE;
|
||||
chunk->used = 0;
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Initialisation d'une STAILQ pour la gestion virtuelle de la mémoire */
|
||||
|
||||
void virtual_init(void)
|
||||
{
|
||||
vrange *vpages = (vrange *) vmalloc(sizeof(vrange));
|
||||
vpages->vaddrlow = (u8 *) KERNEL_PAGES + PAGESIZE;
|
||||
vpages->vaddrhigh = (u8 *) KERNEL_PAGES + MAXPAGESSIZE;
|
||||
TAILQ_INIT(&vrange_head);
|
||||
TAILQ_INSERT_TAIL(&vrange_head, vpages, tailq);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Initialisation des 8 premiers MB de la mémoire en identity mapping */
|
||||
|
||||
void identity_init(void)
|
||||
{
|
||||
u32 i;
|
||||
u32 *pd0 = KERNEL_PD_ADDR;
|
||||
u8 *pg0 = (u8 *) 0;
|
||||
u8 *pg1 = (u8 *) (PAGESIZE * PAGENUMBER);
|
||||
pd0[0] = ((u32) pg0 | (PAGE_PRESENT | PAGE_WRITE | PAGE_4MB));
|
||||
pd0[1] = ((u32) pg1 | (PAGE_PRESENT | PAGE_WRITE | PAGE_4MB));
|
||||
for (i = 2; i < 1023; i++)
|
||||
pd0[i] = ((u32) pg1 +
|
||||
PAGESIZE * i) | (PAGE_PRESENT | PAGE_WRITE);
|
||||
pd0[1023] = ((u32) pd0 | (PAGE_PRESENT | PAGE_WRITE));
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Initialisation des registres CR0, CR3, CR4 */
|
||||
|
||||
void registry_init(void)
|
||||
{
|
||||
asm("mov %[directory_addr], %%eax \n \
|
||||
mov %%eax, %%cr3 \n \
|
||||
mov %%cr4, %%eax \n \
|
||||
or $0x00000010, %%eax \n \
|
||||
mov %%eax, %%cr4 \n \
|
||||
mov %%cr0, %%eax \n \
|
||||
or $0x80000001, %%eax \n \
|
||||
mov %%eax, %%cr0"::[directory_addr] "i"(KERNEL_PD_ADDR));
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Initialisation de la mémoire paginée */
|
||||
|
||||
void initpaging()
|
||||
{
|
||||
identity_init();
|
||||
registry_init();
|
||||
physical_init();
|
||||
malloc_init();
|
||||
virtual_init();
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Copie un octet une ou plusieurs fois en mémoire */
|
||||
|
||||
void memset(void *dst, u8 val, u32 count, u32 size)
|
||||
{
|
||||
u8 *d = (u8 *) dst;
|
||||
if (size > 0)
|
||||
size--;
|
||||
for (; count != 0; count--)
|
||||
{
|
||||
*(d++) = val;
|
||||
d += size;
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Copie une portion de mémoire vers une autre */
|
||||
|
||||
void memcpy(void *src, void *dst, u32 count, u32 size)
|
||||
{
|
||||
u8 *s = (u8 *) src;
|
||||
u8 *d = (u8 *) dst;
|
||||
if (size > 0)
|
||||
size--;
|
||||
for (; count != 0; count--)
|
||||
{
|
||||
*(d++) = *(s++);
|
||||
d += size;
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Compare 2 portions de mémoire */
|
||||
|
||||
u32 memcmp(void *src, void *dst, u32 count, u32 size)
|
||||
{
|
||||
u8 *s = (u8 *) src;
|
||||
u8 *d = (u8 *) dst;
|
||||
if (size > 0)
|
||||
size--;
|
||||
for (; count != 0; count--)
|
||||
{
|
||||
if (*(s++) != *(d++))
|
||||
return *d - *s;
|
||||
s += size;
|
||||
d += size;
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
|
|
225
lib/modes.c
225
lib/modes.c
|
@ -1,225 +0,0 @@
|
|||
/* definition des registres de la carte VGA pour differents modes */
|
||||
|
||||
#define maxgraphmode 11
|
||||
#define maxtextmode 5
|
||||
|
||||
|
||||
static mode_def textmodes[maxtextmode] = {
|
||||
|
||||
|
||||
/*40*25 16 couleurs mode 0x00*/
|
||||
{
|
||||
0x67,
|
||||
0x03, 0x08, 0x03, 0x00, 0x02,
|
||||
0x2D, 0x27, 0x28, 0x90, 0x2B, 0xA0, 0xBF, 0x1F, 0x00,
|
||||
0x4F, 0x0D, 0x0E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x9C, 0x8E, 0x8F, 0x14, 0x1F, 0x96, 0xB9, 0xA3, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0xFF,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
|
||||
0x0C, 0x00, 0x0F, 0x08, 0x00,
|
||||
45, 25, 4
|
||||
},
|
||||
|
||||
|
||||
/*80*25 16 couleurs mode 0x01*/
|
||||
{
|
||||
0x67,
|
||||
0x03, 0x00, 0x03, 0x00, 0x02,
|
||||
0x5F, 0x4F, 0x50, 0x82, 0x55, 0x81, 0xBF, 0x1F, 0x00,
|
||||
0x4F, 0x0D, 0x0E, 0x00, 0x00, 0x00, 0x00,
|
||||
0x9C, 0x0E, 0x8F, 0x28, 0x1F, 0x96, 0xB9, 0xA3, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0xFF,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
|
||||
0x0C, 0x00, 0x0F, 0x08, 0x00,
|
||||
80, 25, 4
|
||||
},
|
||||
|
||||
|
||||
/*80*50 16 couleurs mode 0x02*/
|
||||
{
|
||||
0x63,
|
||||
0x03, 0x01, 0x03, 0x05, 0x02,
|
||||
0x5F, 0x4F, 0x50, 0x82, 0x55, 0x81, 0xBF, 0x1F, 0x00,
|
||||
0x47, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00,
|
||||
0x9C, 0x8E, 0x8F, 0x28, 0x1F, 0x96, 0xB9, 0xA3, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0xFF,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
|
||||
0x0C, 0x00, 0x0F, 0x00, 0x00,
|
||||
80, 50, 4
|
||||
},
|
||||
|
||||
|
||||
/*100*50 16 couleurs mode 0x03*/
|
||||
{
|
||||
0x67,
|
||||
0x03, 0x01, 0x03, 0x05, 0x02,
|
||||
0x70, 0x63, 0x64, 0x85, 0x68, 0x84, 0xBF, 0x1F, 0x00,
|
||||
0x47, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00,
|
||||
0x9C, 0x8E, 0x8F, 0x32, 0x1F, 0x96, 0xB9, 0xA3, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0xFF,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
|
||||
0x0C, 0x00, 0x0F, 0x00, 0x00,
|
||||
100, 50, 4
|
||||
},
|
||||
|
||||
|
||||
/*100*60 16 couleurs mode 0x04*/
|
||||
{
|
||||
0xA7,
|
||||
0x03, 0x01, 0x03, 0x05, 0x02,
|
||||
0x70, 0x63, 0x64, 0x85, 0x68, 0x84, 0xFF, 0x1F, 0x00,
|
||||
0x47, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00,
|
||||
0xE7, 0x8E, 0xDF, 0x32, 0x1F, 0xDF, 0xE5, 0xA3, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0xFF,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
|
||||
0x0C, 0x00, 0x0F, 0x00, 0x00,
|
||||
100, 60, 4
|
||||
}
|
||||
};
|
||||
|
||||
static mode_def graphmodes[maxgraphmode] = {
|
||||
|
||||
/*640*480 n&b mode 0x80*/
|
||||
{
|
||||
0xE3,
|
||||
0x03, 0x01, 0x0F, 0x00, 0x06,
|
||||
0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0x0B, 0x3E, 0x00,
|
||||
0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0xEA, 0x0C, 0xDF, 0x28, 0x00, 0xE7, 0x04, 0xE3, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0F, 0xFF,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
|
||||
0x01, 0x00, 0x0F, 0x00, 0x00,
|
||||
80, 60, 1
|
||||
},
|
||||
|
||||
/*320*200 4 couleurs mode 0x81*/
|
||||
{
|
||||
0x63,
|
||||
0x03, 0x09, 0x03, 0x00, 0x02,
|
||||
0x2D, 0x27, 0x28, 0x90, 0x2B, 0x80, 0xBF, 0x1F, 0x00,
|
||||
0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x9C, 0x0E, 0x8F, 0x14, 0x00, 0x96, 0xB9, 0xA3, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x02, 0x00, 0xFF,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
|
||||
0x01, 0x00, 0x03, 0x00, 0x00,
|
||||
40, 25,
|
||||
},
|
||||
|
||||
/*640*480 16 couleurs mode 0x82*/
|
||||
{
|
||||
0xE3,
|
||||
0x03, 0x01, 0x0F, 0x00, 0x06,
|
||||
0x5F, 0x4F, 0x50, 0x82, 0x53, 0x9F, 0x0B, 0x3E, 0x00,
|
||||
0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0xE9, 0x8B, 0xDF, 0x28, 0x00, 0xE7, 0x04, 0xE3, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0F, 0xFF,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
|
||||
0x01, 0x00, 0x0F, 0x00, 0x00,
|
||||
80, 60, 4
|
||||
},
|
||||
|
||||
/*720*480 16 couleurs mode 0x83*/
|
||||
{
|
||||
0xE7,
|
||||
0x03, 0x01, 0x08, 0x00, 0x06,
|
||||
0x6B, 0x59, 0x5A, 0x82, 0x60, 0x8D, 0x0B, 0x3E, 0x00,
|
||||
0x40, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00,
|
||||
0xEA, 0x0C, 0xDF, 0x2D, 0x08, 0xE8, 0x05, 0xE3, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x05, 0x0F, 0xFF,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
|
||||
0x01, 0x00, 0x0F, 0x00, 0x00,
|
||||
90, 60, 4
|
||||
},
|
||||
|
||||
/*800*600 16 couleurs mode 0x84*/
|
||||
{
|
||||
0xE7,
|
||||
0x03, 0x01, 0x0F, 0x00, 0x06,
|
||||
0x70, 0x63, 0x64, 0x92, 0x65, 0x82, 0x70, 0xF0, 0x00,
|
||||
0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x5B, 0x8C, 0x57, 0x32, 0x00, 0x58, 0x70, 0xE3, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0F, 0xFF,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
|
||||
0x01, 0x00, 0x0F, 0x00, 0x00,
|
||||
100, 75, 4
|
||||
},
|
||||
|
||||
/*320*200 256 couleurs RAPIDE mode 0x85*/
|
||||
{
|
||||
0x63,
|
||||
0x03, 0x01, 0x0F, 0x00, 0x0E,
|
||||
0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0xBF, 0x1F, 0x00,
|
||||
0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x9C, 0x0E, 0x8F, 0x28, 0x40, 0x96, 0xB9, 0xA3, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
||||
0x41, 0x00, 0x0F, 0x00, 0x00,
|
||||
40, 25, 8
|
||||
},
|
||||
|
||||
/*320*200 256 couleurs mode 0x86*/
|
||||
{
|
||||
0x63,
|
||||
0x03, 0x01, 0x0F, 0x00, 0x06,
|
||||
0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0xBF, 0x1F, 0x00,
|
||||
0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x9C, 0x0E, 0x8F, 0x28, 0x00, 0x96, 0xB9, 0xE3, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
||||
0x41, 0x00, 0x0F, 0x00, 0x00,
|
||||
40, 25, 8
|
||||
},
|
||||
|
||||
/*320*400 256 couleurs mode 0x87*/
|
||||
{
|
||||
0x63,
|
||||
0x03, 0x01, 0x0F, 0x00, 0x06,
|
||||
0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0xBF, 0x1F, 0x00,
|
||||
0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x9C, 0x8E, 0x8F, 0x28, 0x00, 0x96, 0xB9, 0xE3, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
||||
0x41, 0x00, 0x0F, 0x00, 0x00,
|
||||
40, 50, 8
|
||||
},
|
||||
|
||||
/*320*480 256 couleurs mode 0x88*/
|
||||
{
|
||||
0xE3,
|
||||
0x03, 0x01, 0x0F, 0x00, 0x06,
|
||||
0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0x0B, 0x3E, 0x00,
|
||||
0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0xEA, 0xAC, 0xDF, 0x28, 0x00, 0xE7, 0x06, 0xE3, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
||||
0x41, 0x00, 0x0F, 0x00, 0x00,
|
||||
40, 60, 8
|
||||
},
|
||||
|
||||
/*360*480 256 couleurs mode 0x89*/
|
||||
{
|
||||
0xE7,
|
||||
0x03, 0x01, 0x0F, 0x00, 0x06,
|
||||
0x6B, 0x59, 0x5A, 0x8E, 0x5E, 0x8A, 0x0D, 0x3E, 0x00,
|
||||
0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0xEA, 0xAC, 0xDF, 0x2D, 0x00, 0xE7, 0x06, 0xE3, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
||||
0x41, 0x00, 0x0F, 0x00, 0x00,
|
||||
45, 60, 8
|
||||
},
|
||||
|
||||
/*400*600 256 couleurs mode 0x8A*/
|
||||
{
|
||||
0xE7,
|
||||
0x03, 0x01, 0x0F, 0x00, 0x06,
|
||||
0x74, 0x63, 0x64, 0x97, 0x68, 0x95, 0x86, 0xF0, 0x00,
|
||||
0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x5B, 0x8D, 0x57, 0x32, 0x00, 0x60, 0x80, 0xE3, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
||||
0x41, 0x00, 0x0F, 0x00, 0x00,
|
||||
50, 75, 8
|
||||
}
|
||||
};
|
||||
|
|
@ -1,3 +1,6 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "types.h"
|
||||
#include "asm.h"
|
||||
#include "mouse.h"
|
||||
|
@ -5,134 +8,142 @@
|
|||
#include "vga.h"
|
||||
#include "video.h"
|
||||
|
||||
bool initmouse()
|
||||
/******************************************************************************/
|
||||
/* initialise la souris */
|
||||
|
||||
bool initmouse(void)
|
||||
{
|
||||
u16 i=1024;
|
||||
u16 i = 1024;
|
||||
|
||||
outkbd(0x64,0xA8); /* autorisé Aux */
|
||||
outkbd(0x64, 0xA8); /* autorisé Aux */
|
||||
|
||||
outmseack(0xf3); /*sample*/
|
||||
outmseack(100); /*sample donnée*/
|
||||
outmseack(0xf3); /*sample */
|
||||
outmseack(100); /*sample donnée */
|
||||
|
||||
outmseack(0xe8); /*resolution*/
|
||||
outmseack(3); /*resolution donnée*/
|
||||
outmseack(0xe8); /*resolution */
|
||||
outmseack(3); /*resolution donnée */
|
||||
|
||||
outmseack(0xe7); /* echelle 2:1*/
|
||||
outmseack(0xe7); /* echelle 2:1 */
|
||||
|
||||
outmseack(0xf4); /* Autorise peripherique */
|
||||
outmseack(0xf4); /* Autorise peripherique */
|
||||
|
||||
outmsecmd(0x47); /* Autorise interruption */
|
||||
outmsecmd(0x47); /* Autorise interruption */
|
||||
|
||||
while(i-->0) if (inb(0x60)==250) return 1;
|
||||
return 0;
|
||||
while (i-- > 0)
|
||||
if (inb(0x60) == 250)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static u8 bytepos=0,mousereplies=0;
|
||||
static u8 mpacket[3];
|
||||
static s32 mousex=40, mousey=12;
|
||||
static u16 oldx=0, oldy=0;
|
||||
static u8 oldchar=0x00,oldattr=0x07;
|
||||
static bool mousebut1=0,mousebut2=0,mousebut3=0;
|
||||
static u8 speed=6;
|
||||
static u8 bytepos = 0, mousereplies = 0;
|
||||
static u8 mpacket[3];
|
||||
static s32 mousex = 40, mousey = 12;
|
||||
static u16 oldx = 0, oldy = 0;
|
||||
static u8 oldchar = 0x00, oldattr = 0x07;
|
||||
static bool mousebut1 = 0, mousebut2 = 0, mousebut3 = 0;
|
||||
static u8 speed = 6;
|
||||
|
||||
/******************************************************************************/
|
||||
/* ecriture vers souris */
|
||||
|
||||
void outmseack(u8 value)
|
||||
{
|
||||
outkbd(0x64,0xD4); /* ecriture vers souris */
|
||||
outb(0x60,value);
|
||||
mousereplies++;
|
||||
outkbd(0x64, 0xD4);
|
||||
outb(0x60, value);
|
||||
mousereplies++;
|
||||
}
|
||||
|
||||
/* ecriture vers mode */
|
||||
|
||||
void outmsecmd(u8 command)
|
||||
{
|
||||
outkbd(0x64,0x60); /* ecriture vers mode */
|
||||
outb(0x60,command);
|
||||
outkbd(0x64, 0x60);
|
||||
outb(0x60, command);
|
||||
}
|
||||
|
||||
void mouse()
|
||||
/******************************************************************************/
|
||||
/* Handler d'interruption de la souris IRQ 12 */
|
||||
|
||||
__attribute__((interrupt)) void mouse_handler(exception_stack_noerror *caller)
|
||||
{
|
||||
u8 mbyte=inb(0x60);
|
||||
s8 changex,changey;
|
||||
cli();
|
||||
cli();
|
||||
u8 mbyte = inb(0x60);
|
||||
s8 changex, changey;
|
||||
|
||||
if (mousereplies > 0)
|
||||
{
|
||||
if (mbyte == 0xFA)
|
||||
{
|
||||
mousereplies--;
|
||||
goto endofint;
|
||||
}
|
||||
mousereplies = 0;
|
||||
}
|
||||
if (mousereplies > 0)
|
||||
{
|
||||
if (mbyte == 0xFA)
|
||||
{
|
||||
mousereplies--;
|
||||
goto endofint;
|
||||
}
|
||||
mousereplies = 0;
|
||||
}
|
||||
|
||||
mpacket[bytepos]=mbyte;
|
||||
bytepos++;
|
||||
|
||||
if(bytepos==3) {
|
||||
bytepos=0;
|
||||
if ( mpacket[1] == 0)
|
||||
{
|
||||
changex = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
changex = (mpacket[0] & 0x10) ?
|
||||
mpacket[1] - 256 :
|
||||
mpacket[1];
|
||||
}
|
||||
if (mpacket[2] == 0)
|
||||
{
|
||||
changey = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
changey = -((mpacket[0] & 0x20) ?
|
||||
mpacket[2] - 256 :
|
||||
mpacket[2]);
|
||||
}
|
||||
mpacket[bytepos] = mbyte;
|
||||
bytepos++;
|
||||
|
||||
mousex+= (changex<<speed);
|
||||
mousey+= (changey<<speed);
|
||||
|
||||
if(mousex<0) { mousex=0; }
|
||||
if(mousex>=65535) { mousex=65535; }
|
||||
if(mousey<0) { mousey=0; }
|
||||
if(mousey>=65535) { mousey=65535; }
|
||||
|
||||
u16 newx=(u32)mousex*getxres()/65536;
|
||||
u16 newy=(u32)mousey*getyres()/65536;
|
||||
if (bytepos == 3)
|
||||
{
|
||||
bytepos = 0;
|
||||
if (mpacket[1] == 0)
|
||||
{
|
||||
changex = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
changex =
|
||||
(mpacket[0] & 0x10) ? mpacket[1] -
|
||||
256 : mpacket[1];
|
||||
}
|
||||
if (mpacket[2] == 0)
|
||||
{
|
||||
changey = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
changey =
|
||||
-((mpacket[0] & 0x20) ? mpacket[2] -
|
||||
256 : mpacket[2]);
|
||||
}
|
||||
|
||||
mousex += (changex << speed);
|
||||
mousey += (changey << speed);
|
||||
|
||||
if (mousex < 0)
|
||||
{
|
||||
mousex = 0;
|
||||
}
|
||||
if (mousex >= 65535)
|
||||
{
|
||||
mousex = 65535;
|
||||
}
|
||||
if (mousey < 0)
|
||||
{
|
||||
mousey = 0;
|
||||
}
|
||||
if (mousey >= 65535)
|
||||
{
|
||||
mousey = 65535;
|
||||
}
|
||||
videoinfos *info = getvideo_info();
|
||||
u16 newx = (u32) mousex * info->currentwidth / 65536;
|
||||
u16 newy = (u32) mousey * info->currentheight / 65536;
|
||||
|
||||
// Retrieve mouse button status from packet
|
||||
mousebut1 = mpacket[0] & 1;
|
||||
mousebut2 = mpacket[0] & 2;
|
||||
mousebut3 = mpacket[0] & 4;
|
||||
|
||||
// Retrieve mouse button status from packet
|
||||
mousebut1=mpacket[0] & 1;
|
||||
mousebut2=mpacket[0] & 2;
|
||||
mousebut3=mpacket[0] & 4;
|
||||
|
||||
// printf("RX:%d\tRY:%d\tX:%d\tY:%d\tB1:%d\tB2:%d\tB3:%d\t\r\n",changex,changey,mousex,mousey,mousebut1,mousebut2,mousebut3);
|
||||
|
||||
if ((newx!=oldx)||(newy!=oldy))
|
||||
{
|
||||
showchar(oldx,oldy,oldchar,oldattr);
|
||||
oldx=newx;
|
||||
oldy=newy;
|
||||
oldchar=getchar(oldx,oldy);
|
||||
oldattr=getattrib(oldx,oldy);
|
||||
showchar(newx,newy,0xDB,0x0F);
|
||||
}
|
||||
}
|
||||
endofint:
|
||||
irqendmaster();
|
||||
irqendslave();
|
||||
sti();
|
||||
//asm("movl 0x2C(%esp), %ebx;movl 0x30(%esp), %esi;movl 0x34(%esp), %edi;movl 0x38(%esp), %ebp;addl $0x3C, %esp;iret;");
|
||||
asm(
|
||||
"addl $0x18,%esp;\
|
||||
popl %bx;\
|
||||
iret;");
|
||||
if (!info->isgraphic)
|
||||
showchar(newx, newy, 0xDB, 0x0F);
|
||||
}
|
||||
endofint:
|
||||
irqendmaster();
|
||||
irqendslave();
|
||||
sti();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************/
|
||||
|
|
|
@ -0,0 +1,147 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
|
||||
#include "asm.h"
|
||||
#include "types.h"
|
||||
#include "pci.h"
|
||||
#include "PCI/class.c"
|
||||
|
||||
#define MAX_BUS_SCAN 256
|
||||
#define MAX_DEVICE_SCAN 32
|
||||
#define MAX_FUNCTION_SCAN 8
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Retourne une chaine correspondant à l'ID class/subclass PCI */
|
||||
|
||||
u8 *pcigetclassname(const pcidev * device)
|
||||
{
|
||||
pciclass *class = NULL;
|
||||
if (device == NULL)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
if (device->base_class == 0xff)
|
||||
{
|
||||
return "Unassigned class";
|
||||
}
|
||||
class = classcodes[device->base_class];
|
||||
if (!class)
|
||||
{
|
||||
return "Unknowned class";
|
||||
}
|
||||
while (class->name != NULL)
|
||||
{
|
||||
if (class->number == device->sub_class)
|
||||
{
|
||||
return class->name;
|
||||
}
|
||||
class++;
|
||||
}
|
||||
|
||||
return "Unknowned class";
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Récupère les identifiants vendeur / periphérique du periphérique PCI donnée */
|
||||
|
||||
pcidevmini getPCImininfo(const u8 bus, const u8 dev, const u8 function)
|
||||
{
|
||||
pcidevmini result;
|
||||
if ((result.vendor_id =
|
||||
pciConfigReadWord(bus, dev, function, 0x0)) != 0xFFFF)
|
||||
{
|
||||
result.device_id =
|
||||
pciConfigReadWord(bus, dev, function, 0x2);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Récupère toutes les informations du periphérique PCI donnée */
|
||||
|
||||
bool getPCInfo(pcidev * device, const u8 bus, const u8 dev,
|
||||
const u8 function)
|
||||
{
|
||||
if ((device->vendor_id =
|
||||
pciConfigReadWord(bus, dev, function, 0x0)) != 0xFFFF)
|
||||
{
|
||||
u16 temp;
|
||||
device->device_id =
|
||||
pciConfigReadWord(bus, dev, function, 0x2);
|
||||
device->command =
|
||||
pciConfigReadWord(bus, dev, function, 0x4);
|
||||
device->status =
|
||||
pciConfigReadWord(bus, dev, function, 0x6);
|
||||
temp = pciConfigReadWord(bus, dev, function, 0x8);
|
||||
device->revision_id = temp & 0xFF;
|
||||
device->interface = temp >> 8;
|
||||
temp = pciConfigReadWord(bus, dev, function, 0xA);
|
||||
device->sub_class = temp & 0xFF;
|
||||
device->base_class = temp >> 8;
|
||||
temp = pciConfigReadWord(bus, dev, function, 0xC);
|
||||
device->cache_line_size = temp & 0xFF;
|
||||
device->latency_timer = temp >> 8;
|
||||
temp = pciConfigReadWord(bus, dev, function, 0xE);
|
||||
device->header_type = temp & 0xFF;
|
||||
device->bist = temp >> 8;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Récupère les informations sur le periphérique PCI donnée */
|
||||
|
||||
u16 pciConfigReadWord(const u8 bus, const u8 dev, const u8 function,
|
||||
const u8 offset)
|
||||
{
|
||||
u16 tmp = 0;
|
||||
u32 addr =
|
||||
(0x80000000 | (bus << 16) | (dev << 11) | (function << 8) |
|
||||
(offset & 0xFC));
|
||||
outd(0xCF8, addr);
|
||||
tmp = (u16) ((ind(0xCFC) >> ((offset & 2) * 8)) & 0xffff);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Scan le bus PCI et affiche les périphériques */
|
||||
|
||||
void scanPCImini(void)
|
||||
{
|
||||
u16 bus, device, function;
|
||||
pcidevmini result;
|
||||
for (bus = 0; bus < MAX_BUS_SCAN; ++bus)
|
||||
for (device = 0; device < MAX_DEVICE_SCAN; ++device)
|
||||
for (function = 0; function < MAX_FUNCTION_SCAN;
|
||||
++function)
|
||||
{
|
||||
result = getPCImininfo(bus, device,
|
||||
function);
|
||||
if (result.vendor_id != 0xFFFF)
|
||||
printf("Bus:%hx Dev:%hx Func:%hx %hx:%hx\r\n", bus, device, function, result.vendor_id, result.device_id);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
|
||||
/* Scan le bus PCI et affiche les périphériques */
|
||||
|
||||
void scanPCI(void)
|
||||
{
|
||||
u16 bus, device, function;
|
||||
pcidev result;
|
||||
for (bus = 0; bus < MAX_BUS_SCAN; ++bus)
|
||||
for (device = 0; device < MAX_DEVICE_SCAN; ++device)
|
||||
for (function = 0; function < MAX_FUNCTION_SCAN;
|
||||
++function)
|
||||
if (getPCInfo
|
||||
(&result, bus, device, function))
|
||||
printf("Bus:%hx Dev:%hx Func:%hx %hx:%hx ->%s\r\n", bus, device, function, result.vendor_id, result.device_id, pcigetclassname(&result));
|
||||
return;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
68
lib/port.c
68
lib/port.c
|
@ -1,68 +0,0 @@
|
|||
#include "types.h"
|
||||
#include "asm.h"
|
||||
|
||||
/*******************************************************************************/
|
||||
|
||||
/* Envoie une série d'octet a destination d'une portion de mémoire
|
||||
vers le registre video spécifié */
|
||||
|
||||
void outreg(u16 port,u8 *src,u16 num)
|
||||
{
|
||||
int i;
|
||||
for(i=0;i<num;i++)
|
||||
{
|
||||
outb(port,i);
|
||||
outb(port+1,*src++);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************/
|
||||
|
||||
/* Envoie une série d'octet a destination d'une portion de mémoire
|
||||
vers le registre video spécifié (accés data et index confondu) */
|
||||
|
||||
void outregsame(u16 port,u8 *src,u16 num)
|
||||
{
|
||||
int i;
|
||||
for(i=0;i<num;i++)
|
||||
{
|
||||
inb(port);
|
||||
outb(port,i);
|
||||
outb(port,*src++);
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
|
||||
/* Récupère une série d'octet en provenance d'un registre video spécifié
|
||||
vers portion de mémoire */
|
||||
|
||||
void inreg(u16 port,u8 *src,u16 num)
|
||||
{
|
||||
int i;
|
||||
for(i=0;i<num;i++)
|
||||
{
|
||||
outb(port,i);
|
||||
*src++=inb(port+1);
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
|
||||
/* Récupère une série d'octet en provenance d'un registre video spécifié
|
||||
vers portion de mémoire (accés data et index confondu) */
|
||||
|
||||
void inregsame(u16 port,u8 *src,u16 num)
|
||||
{
|
||||
int i;
|
||||
for(i=0;i<num;i++)
|
||||
{
|
||||
inb(port);
|
||||
outb(port,i);
|
||||
*src++=inb(port);
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
|
|
@ -0,0 +1,568 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
|
||||
#include "types.h"
|
||||
#include "process.h"
|
||||
#include "memory.h"
|
||||
#include "gdt.h"
|
||||
|
||||
process *processes;
|
||||
tid_t current;
|
||||
pid_t lastpid;
|
||||
|
||||
|
||||
static u8 elf_errors1[] = "Aucune signature ELF";
|
||||
static u8 elf_errors2[] = "Fichier au format ELF mais non 32 bits";
|
||||
static u8 elf_errors3[] = "ELF non LSB";
|
||||
static u8 elf_errors4[] = "ELF mauvaise version";
|
||||
static u8 elf_errors5[] = "ELF pour OS ne correspondant pas";
|
||||
static u8 elf_errors6[] = "Mauvais type de machine";
|
||||
static u8 *elf_errors[] =
|
||||
{ &elf_errors1, &elf_errors2, &elf_errors3, &elf_errors4,
|
||||
&elf_errors5, &elf_errors6
|
||||
};
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Vérifie la signature ELF
|
||||
0 - RAS
|
||||
1 - Pas la signature ELF
|
||||
2 - pas ELF32
|
||||
3 - pas bon organisation LSB/MSB
|
||||
4 - pas bonne version ELF
|
||||
5 - pas bon OS
|
||||
6 - pas bon type machine */
|
||||
|
||||
u32 iself(u8 * src)
|
||||
{
|
||||
elf32 *header = (elf32 *) src;
|
||||
if (header->e_ident[EI_MAG0] == ELFMAG0
|
||||
&& header->e_ident[EI_MAG1] == ELFMAG1
|
||||
&& header->e_ident[EI_MAG2] == ELFMAG2
|
||||
&& header->e_ident[EI_MAG3] == ELFMAG3)
|
||||
{
|
||||
if (header->e_ident[EI_CLASS] != ELFCLASS32)
|
||||
return 2;
|
||||
if (header->e_ident[EI_DATA] != ELFDATA2LSB)
|
||||
return 3;
|
||||
if (header->e_ident[EI_VERSION] != EV_CURRENT
|
||||
|| header->e_version != EV_CURRENT)
|
||||
return 4;
|
||||
if (header->e_ident[EI_OSABI] != ELFOSABI_COS2000)
|
||||
return 5;
|
||||
if (header->e_machine != EM_386)
|
||||
return 6;
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Met fin à une tâche */
|
||||
/* SYSCALL
|
||||
{
|
||||
"ID":5,
|
||||
"LIBRARY":"libsys",
|
||||
"NAME":"exit",
|
||||
"INTERNALNAME":"processexit",
|
||||
"DESCRIPTION":"End a task for user or kernel domain",
|
||||
"ARGS": [
|
||||
{"TYPE":"u32","NAME":"resultcode","DESCRIPTION":"Code result of the execution"}
|
||||
],
|
||||
"RETURN":"u32"
|
||||
}
|
||||
END-SYSCALL */
|
||||
|
||||
void processexit(void)
|
||||
{
|
||||
cli();
|
||||
deleteprocess(getcurrentpid());
|
||||
switchtask(maketid(1,1));
|
||||
sti();
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Charge le fichier ELF en mémoire et mets à jour les informations sur le processus */
|
||||
|
||||
u32 loadelf(u8 * src, pid_t pid)
|
||||
{
|
||||
u8 *ptr;
|
||||
u8 code;
|
||||
u32 v_begin, v_end;
|
||||
elf32 *header;
|
||||
elf32p *program;
|
||||
u32 i;
|
||||
|
||||
header = (elf32 *) src;
|
||||
program = (elf32p *) (src + header->e_phoff);
|
||||
code = iself(src);
|
||||
process *aprocess=findprocess(pid);
|
||||
if (aprocess==NULL) return NULL;
|
||||
if (code != 0)
|
||||
{
|
||||
printf("Erreur de chargement ELF, %s !\r\n",
|
||||
elf_errors[code - 1]);
|
||||
return NULL;
|
||||
}
|
||||
for (i = 0; i < header->e_phnum; i++, program++)
|
||||
{
|
||||
if (program->p_type == PT_LOAD)
|
||||
{
|
||||
v_begin = program->p_vaddr;
|
||||
v_end = program->p_vaddr + program->p_memsz;
|
||||
if (v_begin < USER_CODE)
|
||||
{
|
||||
printf("Ne peut charger l'executable en desssous de l'adresse %X\r\n", USER_CODE);
|
||||
return 0;
|
||||
}
|
||||
if (v_end > USER_STACK)
|
||||
{
|
||||
printf("Ne peut charger l'executable au desssus de l'adresse %X\r\n", USER_STACK);
|
||||
return 0;
|
||||
}
|
||||
if (program->p_flags == PF_X + PF_R)
|
||||
{
|
||||
aprocess->exec_low = (u8 *) v_begin;
|
||||
aprocess->exec_high = (u8 *) v_end;
|
||||
}
|
||||
if (program->p_flags == PF_W + PF_R)
|
||||
{
|
||||
aprocess->bss_low = (u8 *) v_begin;
|
||||
aprocess->bss_high = (u8 *) v_end;
|
||||
}
|
||||
memcpy((u8 *) (src + program->p_offset),
|
||||
(u8 *) v_begin, program->p_filesz, 0);
|
||||
if (program->p_memsz > program->p_filesz)
|
||||
for (i = program->p_filesz, ptr =
|
||||
(u8 *) program->p_vaddr;
|
||||
i < program->p_memsz; i++)
|
||||
ptr[i] = 0;
|
||||
}
|
||||
}
|
||||
return header->e_entry;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Initialise la liste des processus */
|
||||
|
||||
void initprocesses(void)
|
||||
{
|
||||
u32 i = 0;
|
||||
processes = (process *) vmalloc(sizeof(process) * MAXNUMPROCESS);
|
||||
while (i < MAXNUMPROCESS)
|
||||
{
|
||||
processes[i].pid = i+1;
|
||||
processes[i++].status = PROCESS_STATUS_FREE;
|
||||
}
|
||||
pid_t pid=(pid_t)1;
|
||||
process *aprocess=findprocess(pid);
|
||||
if (aprocess==NULL) return NULL;
|
||||
aprocess->pid = pid;
|
||||
aprocess->result = 0;
|
||||
aprocess->pdd = NULL;
|
||||
aprocess->status = PROCESS_STATUS_RUN;
|
||||
aprocess->iskernel = true;
|
||||
TAILQ_INIT(&aprocess->task_head);
|
||||
current=createtask(pid,getinitretry(),true);
|
||||
task *atask = findtask(current);
|
||||
atask->status = TASK_STATUS_RUN;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Récupère un emplacement dans la liste des processus */
|
||||
|
||||
pid_t getfreepid(void)
|
||||
{
|
||||
if ((u32)lastpid==0 || lastpid>MAXNUMPROCESS)
|
||||
lastpid=(pid_t)1;
|
||||
process* aprocess=findprocess(lastpid);
|
||||
aprocess=getnextprocess(aprocess, PROCESS_STATUS_FREE);
|
||||
if (aprocess == NULL)
|
||||
{
|
||||
printf("PANIC: plus d'emplacement disponible pour un novueau processus\n");
|
||||
return NULL;
|
||||
}
|
||||
lastpid=aprocess->pid;
|
||||
return lastpid;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Récupère un emplacement dans la liste des tâche du processus donné */
|
||||
|
||||
tid_t getfreeptid(pid_t pid)
|
||||
{
|
||||
process *aprocess=findprocess(pid);
|
||||
if (aprocess==NULL) return maketid(0,0);
|
||||
u32 number=0;
|
||||
task *next;
|
||||
TAILQ_FOREACH(next, &aprocess->task_head, tailq)
|
||||
if (next->tid.number>number)
|
||||
number=next->tid.number;
|
||||
number++;
|
||||
return maketid(pid,number);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Récupère le PID du processus courant */
|
||||
|
||||
pid_t getcurrentpid(void)
|
||||
{
|
||||
return current.pid;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Récupère le TID de la tâche courante */
|
||||
|
||||
tid_t getcurrenttid(void)
|
||||
{
|
||||
return current;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Change la tâche désigné dans le TID */
|
||||
|
||||
tid_t maketid(pid_t pid, u32 number)
|
||||
{
|
||||
tid_t newtid;
|
||||
newtid.pid=pid;
|
||||
newtid.number=number;
|
||||
return newtid;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Récupère l'adresse d'un processus */
|
||||
|
||||
process* findprocess(pid_t pid)
|
||||
{
|
||||
if ((u32)pid>0)
|
||||
return &processes[(u32)pid-1];
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Récupère l'adresse du processus courant */
|
||||
|
||||
process* findcurrentprocess(void)
|
||||
{
|
||||
return &processes[(u32)getcurrentpid()-1];
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Bascule vers une tâche */
|
||||
|
||||
void switchtask(tid_t tid)
|
||||
{
|
||||
cli();
|
||||
tid_t previous = current;
|
||||
task *atask = findtask(tid);
|
||||
if (atask==NULL) return;
|
||||
process *aprocess=findprocess(tid.pid);
|
||||
if (aprocess==NULL) return;
|
||||
current = tid;
|
||||
if (!aprocess->iskernel)
|
||||
{
|
||||
setTSS(atask->kernel_stack.ss0, atask->kernel_stack.esp0);
|
||||
wrmsr(0x175, atask->syscall_stack.esp0, 0x0);
|
||||
}
|
||||
else
|
||||
{
|
||||
setTSS(0x0, 0x0);
|
||||
wrmsr(0x175, 0x0, 0x0);
|
||||
}
|
||||
if (((atask->dump.cs & 0xFFF8) !=SEL_KERNEL_CODE) && ((atask->dump.cs & 0xFFF8) !=SEL_USER_CODE))
|
||||
cpuerror("SWITCH ERROR", &atask->dump, false);
|
||||
//printf("%Y\r\n",atask->tid.pid);
|
||||
atask->dump.eflags = (atask->dump.eflags | 0x200) & 0xFFFFBFFF;
|
||||
createdump(atask->dump);
|
||||
if ((atask->dump.cs & 0xFFF8)==SEL_KERNEL_CODE)
|
||||
restcpu_kernel();
|
||||
else
|
||||
restcpu_user();
|
||||
iret();
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Cherche le prochain processus */
|
||||
|
||||
process* getnextprocess(process* aprocess, u32 status)
|
||||
{
|
||||
u32 i = (u32) aprocess->pid;
|
||||
u32 parsed = 0;
|
||||
while (parsed++ < MAXNUMPROCESS && ((status != PROCESS_STATUS_ALL && processes[i++].status != status) ||
|
||||
(status == PROCESS_STATUS_ALL && processes[i++].status == PROCESS_STATUS_FREE)))
|
||||
{
|
||||
if (i >= MAXNUMPROCESS)
|
||||
i = 0;
|
||||
}
|
||||
if (parsed > MAXNUMPROCESS)
|
||||
return NULL;
|
||||
else
|
||||
return &processes[i-1];
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Cherche la prochaine tâche du processus */
|
||||
|
||||
task* getnexttask(task *atask, u32 status)
|
||||
{
|
||||
task *next=atask;
|
||||
while (next!=NULL)
|
||||
{
|
||||
next=TAILQ_NEXT(next, tailq);
|
||||
if (next!=NULL && (status == TASK_STATUS_ALL || next->status == status))
|
||||
return next;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Cherche la prochaine tâche */
|
||||
|
||||
task* getschedule(void)
|
||||
{
|
||||
process *aprocess=findcurrentprocess();
|
||||
task *next=findcurrenttask();
|
||||
u32 flag=0;
|
||||
while(flag<2) {
|
||||
if (aprocess==NULL) return NULL;
|
||||
if (next==NULL)
|
||||
next=findfirsttask(aprocess);
|
||||
while(true)
|
||||
{
|
||||
if (next!=NULL)
|
||||
if (current.pid==next->tid.pid && current.number==next->tid.number)
|
||||
flag++;
|
||||
else
|
||||
return next;
|
||||
else
|
||||
break;
|
||||
next=getnexttask(next,TASK_STATUS_RUN);
|
||||
}
|
||||
aprocess=getnextprocess(aprocess,PROCESS_STATUS_RUN);
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Cherche la première tâche du processeur */
|
||||
|
||||
task* findfirsttask(process* aprocess)
|
||||
{
|
||||
task *first;
|
||||
return TAILQ_FIRST(&aprocess->task_head);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Cherche l'adresse d'une tâche */
|
||||
|
||||
task* findtask(tid_t tid)
|
||||
{
|
||||
process *aprocess=findprocess(tid.pid);
|
||||
if (aprocess==NULL) return NULL;
|
||||
task *next;
|
||||
TAILQ_FOREACH(next, &aprocess->task_head, tailq)
|
||||
if (next->tid.number==tid.number)
|
||||
return next;
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Cherche l'adresse de la tâche courante */
|
||||
|
||||
task* findcurrenttask(void)
|
||||
{
|
||||
return findtask(getcurrenttid());
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Détruit une tâche */
|
||||
|
||||
void deletetask(tid_t tid)
|
||||
{
|
||||
cli();
|
||||
stoptask(tid);
|
||||
process* aprocess=findprocess(tid.pid);
|
||||
if (aprocess==NULL) return;
|
||||
if (current.pid=tid.pid && current.number==tid.number)
|
||||
current=maketid(1,1);
|
||||
task *atask=findtask(tid);
|
||||
if (atask==NULL) return;
|
||||
TAILQ_REMOVE(&aprocess->task_head, atask, tailq);
|
||||
vfree(atask);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Execute une tâche */
|
||||
|
||||
void runtask(tid_t tid)
|
||||
{
|
||||
task *atask=findtask(tid);
|
||||
if (atask==NULL) return;
|
||||
if (atask->status == TASK_STATUS_READY)
|
||||
atask->status = TASK_STATUS_RUN;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Initialise une tâche */
|
||||
|
||||
tid_t createtask(pid_t pid,u8 *entry, bool kerneltask)
|
||||
{
|
||||
cli();
|
||||
tid_t tid;
|
||||
tid.pid=pid;
|
||||
process* aprocess=findprocess(pid);
|
||||
if (aprocess==NULL) return maketid(0,0);
|
||||
task *new = (task *) vmalloc(sizeof(task));
|
||||
TAILQ_INSERT_TAIL(&aprocess->task_head, new, tailq);
|
||||
page *apage = virtual_page_getfree();
|
||||
if (kerneltask)
|
||||
{
|
||||
new->dump.ss = SEL_KERNEL_STACK;
|
||||
if (pid!=1)
|
||||
new->dump.esp =
|
||||
(u32) apage->vaddr + PAGESIZE - 16;
|
||||
new->dump.esp = KERNEL_STACK_ADDR;
|
||||
new->dump.eflags = 0x0;
|
||||
new->dump.cs = SEL_KERNEL_CODE;
|
||||
new->dump.ds = SEL_KERNEL_DATA;
|
||||
new->dump.es = SEL_KERNEL_DATA;
|
||||
new->dump.fs = SEL_KERNEL_DATA;
|
||||
new->dump.gs = SEL_KERNEL_DATA;
|
||||
new->dump.cr3 = KERNEL_PD_ADDR;
|
||||
}
|
||||
else
|
||||
{
|
||||
TAILQ_INSERT_TAIL(&aprocess->pdd->page_head, apage, tailq);
|
||||
new->kernel_stack.ss0 = SEL_KERNEL_STACK;
|
||||
new->kernel_stack.esp0 =
|
||||
(u32) apage->vaddr + PAGESIZE - 16;
|
||||
page *apage = virtual_page_getfree();
|
||||
TAILQ_INSERT_TAIL(&aprocess->pdd->page_head, apage, tailq);
|
||||
new->syscall_stack.ss0 = SEL_KERNEL_STACK;
|
||||
new->syscall_stack.esp0 =
|
||||
(u32) apage->vaddr + PAGESIZE - 16;
|
||||
new->dump.ss = SEL_USER_STACK | RPL_RING3;
|
||||
new->dump.esp = USER_STACK - 16;
|
||||
new->dump.eflags = 0x0;
|
||||
new->dump.cs = SEL_USER_CODE | RPL_RING3;
|
||||
new->dump.ds = SEL_USER_DATA | RPL_RING3;
|
||||
new->dump.es = SEL_USER_DATA | RPL_RING3;
|
||||
new->dump.fs = SEL_USER_DATA | RPL_RING3;
|
||||
new->dump.gs = SEL_USER_DATA | RPL_RING3;
|
||||
new->dump.cr3 = aprocess->pdd->addr->paddr;
|
||||
}
|
||||
new->tid=getfreeptid(pid);
|
||||
if (entry==NULL)
|
||||
new->dump.eip = aprocess->entry;
|
||||
else
|
||||
new->dump.eip = entry;
|
||||
new->dump.eax = 0;
|
||||
new->dump.ecx = 0;
|
||||
new->dump.edx = 0;
|
||||
new->dump.ebx = 0;
|
||||
new->dump.ebp = 0;
|
||||
new->dump.esi = 0;
|
||||
new->dump.edi = 0;
|
||||
new->status = TASK_STATUS_READY;
|
||||
return new->tid;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Arrête une tâche */
|
||||
|
||||
void stoptask(tid_t tid)
|
||||
{
|
||||
task *atask=findtask(tid);
|
||||
if (atask==NULL) return;
|
||||
atask->status=TASK_STATUS_STOP;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Initialise un processus */
|
||||
|
||||
pid_t createprocess(u8 *src, bool kerneltask)
|
||||
{
|
||||
cli();
|
||||
tid_t previous = current;
|
||||
process* oldprocess=findcurrentprocess();
|
||||
current.pid = getfreepid();
|
||||
current.number = 0;
|
||||
process* new=findcurrentprocess();
|
||||
if (new==NULL) return NULL;
|
||||
new->parent=oldprocess->pid;
|
||||
new->pdd = virtual_pd_create();
|
||||
new->iskernel=kerneltask;
|
||||
TAILQ_INIT(&new->page_head);
|
||||
TAILQ_INIT(&new->task_head);
|
||||
setCR3(new->pdd->addr->paddr);
|
||||
new->entry = loadelf(src, new->pid);
|
||||
createtask(new->pid,new->entry, new->iskernel);
|
||||
current = previous;
|
||||
process* old=findcurrentprocess();
|
||||
if (old==NULL) return NULL;
|
||||
u32 cr3=KERNEL_PD_ADDR;
|
||||
if (old->pdd!=NULL)
|
||||
cr3=old->pdd->addr->paddr;
|
||||
setCR3(cr3);
|
||||
new->status=PROCESS_STATUS_READY;
|
||||
return new->pid;
|
||||
sti();
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Détruit un processus */
|
||||
|
||||
void deleteprocess(pid_t pid)
|
||||
{
|
||||
cli();
|
||||
stopprocess(pid);
|
||||
process* aprocess=findprocess(pid);
|
||||
if (aprocess==NULL) return;
|
||||
task *next;
|
||||
TAILQ_FOREACH(next, &aprocess->task_head, tailq)
|
||||
deletetask(next->tid);
|
||||
virtual_pd_destroy(aprocess->pdd);
|
||||
if (current.pid==pid)
|
||||
current=maketid(1,1);
|
||||
aprocess->status = PROCESS_STATUS_FREE;
|
||||
sti();
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Execute un processus */
|
||||
|
||||
void runprocess(pid_t pid)
|
||||
{
|
||||
cli();
|
||||
process* aprocess=findprocess(pid);
|
||||
if (aprocess==NULL) return;
|
||||
if (aprocess->status == PROCESS_STATUS_READY)
|
||||
{
|
||||
aprocess->status = PROCESS_STATUS_RUN;
|
||||
tid_t tid=maketid(pid,1);
|
||||
task *atask=findtask(tid);
|
||||
if (atask==NULL) return;
|
||||
atask->status=TASK_STATUS_RUN;
|
||||
}
|
||||
sti();
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Arrête un processus */
|
||||
|
||||
void stopprocess(pid_t pid)
|
||||
{
|
||||
process* aprocess=findprocess(pid);
|
||||
if (aprocess==NULL) return;
|
||||
if (aprocess->status == PROCESS_STATUS_RUN)
|
||||
{
|
||||
aprocess->status = PROCESS_STATUS_READY;
|
||||
task *next;
|
||||
TAILQ_FOREACH(next, &aprocess->task_head, tailq)
|
||||
next->status=TASK_STATUS_READY;
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
|
@ -0,0 +1,105 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "interrupts.h"
|
||||
#include "types.h"
|
||||
#include "asm.h"
|
||||
#include "memory.h"
|
||||
#include "timer.h"
|
||||
#include "vga.h"
|
||||
#include "gdt.h"
|
||||
#include "process.h"
|
||||
|
||||
static u8 curs[4] = { "-\\|/" };
|
||||
|
||||
static u8 curspos = 0;
|
||||
|
||||
static u32 time = 0;
|
||||
|
||||
/******************************************************************************/
|
||||
/* Récupère la valeur du timer */
|
||||
/* SYSCALL
|
||||
{
|
||||
"ID":4,
|
||||
"NAME":"getticks",
|
||||
"LIBRARY":"libsys",
|
||||
"INTERNALNAME":"gettimer",
|
||||
"DESCRIPTION":"Return the internal value of the timer",
|
||||
"ARGS": [],
|
||||
"RETURN":"u32"
|
||||
}
|
||||
END-SYSCALL */
|
||||
|
||||
u32 gettimer(void)
|
||||
{
|
||||
return time;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Handler d'interruption du timer IRQ 0 */
|
||||
|
||||
__attribute__ ((noreturn)) void timer_handler(regs *dump)
|
||||
{
|
||||
exception_stack_noerror *caller = (exception_stack_noerror*) ((u32*)dump->esp+1);
|
||||
bool noerror,user;
|
||||
if ((caller->cs & 0xFFF8)==SEL_KERNEL_CODE || (caller->cs & 0xFFF8)==SEL_USER_CODE)
|
||||
{
|
||||
noerror=true;
|
||||
dump->eip = caller->eip;
|
||||
dump->cs = caller->cs;
|
||||
dump->eflags = caller->eflags;
|
||||
if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
|
||||
{
|
||||
dump->esp = (u32) caller + sizeof(exception_stack_noerror);
|
||||
user=false;
|
||||
}
|
||||
else
|
||||
{
|
||||
dump->esp = (u32) ((exception_stack_noerror_user*) caller)->esp;
|
||||
dump->ss = (u32) ((exception_stack_noerror_user*) caller)->ss;
|
||||
user=true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
noerror=false;
|
||||
dump->eip = ((exception_stack*)caller)->eip;
|
||||
dump->cs = ((exception_stack*)caller)->cs;
|
||||
if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
|
||||
{
|
||||
dump->esp = (u32) caller + sizeof(exception_stack);
|
||||
user=false;
|
||||
}
|
||||
else
|
||||
{
|
||||
dump->esp = (u32) ((exception_stack_user*) caller)->esp;
|
||||
dump->ss = (u32) ((exception_stack_user*) caller)->ss;
|
||||
user=true;
|
||||
}
|
||||
}
|
||||
irqendmaster();
|
||||
showchar(0, 0, curs[curspos], 7);
|
||||
curspos = (curspos + 1) & 0x3;
|
||||
time++;
|
||||
task *new=getschedule();
|
||||
if (new!=NULL)
|
||||
{
|
||||
task *old=findcurrenttask();
|
||||
memcpy(dump, &old->dump, sizeof(regs), 0);
|
||||
switchtask(new->tid);
|
||||
}
|
||||
if ((dump->cs & 0xFFF8)==SEL_KERNEL_CODE)
|
||||
{
|
||||
setESP(dump);
|
||||
restcpu_kernel();
|
||||
}
|
||||
else
|
||||
{
|
||||
setESP(dump);
|
||||
restcpu_user();
|
||||
iret();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************/
|
|
@ -0,0 +1,747 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include "vga.h"
|
||||
#include "3d.h"
|
||||
#include "matrix.h"
|
||||
#include "video.h"
|
||||
#include "interrupts.h"
|
||||
#include "asm.h"
|
||||
#include "cpu.h"
|
||||
#include "string.h"
|
||||
#include "gdt.h"
|
||||
#include "shell.h"
|
||||
#include "math.h"
|
||||
#include "debug.h"
|
||||
#include "VGA/ansi.c"
|
||||
#include "3D/sphere.c"
|
||||
#include "3D/man.c"
|
||||
#include "memory.h"
|
||||
#include "syscall.h"
|
||||
#include "process.h"
|
||||
|
||||
static command commands[] = {
|
||||
{"reboot", "", &rebootnow},
|
||||
{"clear", "", &clear},
|
||||
{"mode", "", &mode},
|
||||
{"detectcpu", "", &detectcpu},
|
||||
{"test2d", "", &test2d},
|
||||
{"regs", "", &showregs},
|
||||
{"gdt", "", &showgdt},
|
||||
{"idt", "", &showidt},
|
||||
{"info", "", &showinfo},
|
||||
{"err", "", &err},
|
||||
{"test", "", &test},
|
||||
{"view", "", &view},
|
||||
{"disasm", "", &disas},
|
||||
{"bpset", "", &bpset},
|
||||
{"bpclr", "", &bpclr},
|
||||
{"help", "", &help},
|
||||
{"logo", "", &logo},
|
||||
{"font", "", &sfont},
|
||||
{"test3d", "", &test3d},
|
||||
{"detectpci", "", &detectpci},
|
||||
{"mem", "", &showmem},
|
||||
{"testmem", "", &testmem},
|
||||
{"testtask", "", &testtask},
|
||||
{"ps", "", &ps},
|
||||
};
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Shell, traite les commandes */
|
||||
|
||||
void shell()
|
||||
{
|
||||
static u8 field[] =
|
||||
" \000";
|
||||
static u8 item[] = " \000";
|
||||
int i;
|
||||
bool found;
|
||||
while (true)
|
||||
{
|
||||
print("\r\n# ");
|
||||
getstring(&field);
|
||||
print("\r\n");
|
||||
if (strgetnbitems(&field, ' ') < 1)
|
||||
continue;
|
||||
strgetitem(&field, &item, ' ', 0);
|
||||
strtolower(&item);
|
||||
found = false;
|
||||
for (i = 0; i < sizeof(commands) / sizeof(commands[0]);
|
||||
i++)
|
||||
{
|
||||
if (strcmp(&item, &commands[i].name) == 0)
|
||||
{
|
||||
(*commands[i].function) (&field);
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!found)
|
||||
printf("Commande inconnue !\r\n\000");
|
||||
}
|
||||
}
|
||||
|
||||
int test(void)
|
||||
{
|
||||
print("Fonction de test !\r\n");
|
||||
return;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Afiche les processus */
|
||||
|
||||
static u8* processstatus[] = {"LIBRE","PRET ","EXEC.","PAUSE"};
|
||||
static u8* taskstatus[] = {"PRET ","EXEC.","PAUSE"};
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Affiche les tâches et processus */
|
||||
|
||||
int ps()
|
||||
{
|
||||
print("*** Processus en memoire\r\n| PID | Parent|Status|K|P.|Directo.|Pages...\r\n");
|
||||
process* aprocess=findprocess((pid_t)1);
|
||||
while(true)
|
||||
{
|
||||
printf("|%Y|%Y| %s|%c|%hh u|%Y|",(u32)aprocess->pid,(u32)aprocess->parent,processstatus[aprocess->status],(aprocess->iskernel?'X':' '),aprocess->priority,(u32)aprocess->pdd);
|
||||
if (aprocess->pdd!=NULL) virtual_pd_show(aprocess->pdd);
|
||||
print("\r\n");
|
||||
aprocess=getnextprocess(aprocess,PROCESS_STATUS_ALL);
|
||||
if (aprocess==NULL || aprocess->pid==(pid_t)1) break;
|
||||
}
|
||||
print("\r\n\r\n*** Taches en memoire\r\n| TID | PID |Status| CS | EIP | SS | ESP |\r\n");
|
||||
aprocess=findprocess((pid_t)1);
|
||||
task* atask;
|
||||
while(true)
|
||||
{
|
||||
atask=findfirsttask(aprocess);
|
||||
while(true)
|
||||
{
|
||||
printf("|%Y|%Y| %s|%hY|%Y|%hY|%Y|\r\n",(u32)atask->tid.number,(u32)atask->tid.pid,taskstatus[atask->status],atask->dump.cs,atask->dump.eip,atask->dump.ss,atask->dump.esp);
|
||||
atask=getnexttask(atask,TASK_STATUS_ALL);
|
||||
if (atask==NULL || (atask->tid.number==1 && atask->tid.pid==1)) break;
|
||||
}
|
||||
aprocess=getnextprocess(aprocess,PROCESS_STATUS_ALL);
|
||||
if (aprocess==NULL || aprocess->pid==(pid_t)1) break;
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Test l'usage de création de tâche */
|
||||
|
||||
int testtask()
|
||||
{
|
||||
print("*** Creation d'une tache\r\n");
|
||||
pid_t pid;
|
||||
pid = createprocess(NULL, false);
|
||||
runprocess(pid);
|
||||
pid = createprocess(NULL, false);
|
||||
runprocess(pid);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Test la memoire */
|
||||
|
||||
int testmem()
|
||||
{
|
||||
u8 *test;
|
||||
print("**** AVANT ALLOCATION\r\n");
|
||||
showmem();
|
||||
test = vmalloc(150 * 1024 * 1024); /* 10 pages */
|
||||
print("**** APRES ALLOCATION\r\n");
|
||||
showmem();
|
||||
vfree(test);
|
||||
print("**** APRES LIBERATION\r\n");
|
||||
showmem();
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Affiche des informations sur la mémoire */
|
||||
|
||||
int showmem()
|
||||
{
|
||||
u32 libre = getmemoryfree();
|
||||
u32 total = physical_getmemorysize();
|
||||
printf("Memoire physique (TOTAL)\r\n -libre \33[40D\33[15C%H (%.2f%%)\r\n -occupee \33[40D\33[15C%H\r\n -total \33[40D\33[15C%H\r\n\r\n", libre, ((float) libre / total * 100.0f), total - libre, total);
|
||||
printf("Memoire HEAP (NOYAU) - % u blocs\r\n -libre \33[40D\33[15C%H\r\n -occupee \33[40D\33[15C%H\r\n -allouables \33[40D\33[15C%H\r\n\r\n", getmallocnb(), getmallocfree(), getmallocused(), getmallocnonallocated());
|
||||
printf("Plan de memoire (NOYAU)\r\n -IDT \33[40D\33[15C%X\r\n -GDT \33[40D\33[15C%X\r\n -PGD \33[40D\33[15C%X\r\n -STACK \33[40D\33[15C%X\r\n -CODE \33[40D\33[15C%X\r\n -PAGES \33[40D\33[15C%X\r\n -HEAP \33[40D\33[15C%X\r\n -VESAFB \33[40D\33[15C%X\r\n\r\n", IDT_ADDR, GDT_ADDR, KERNEL_PD_ADDR, KERNEL_STACK_ADDR, KERNEL_CODE_ADDR, KERNEL_PAGES, KERNEL_HEAP, VESA_FBMEM);
|
||||
printf("Memoire Virtuelle (NOYAU)\r\n -pages libres \33[40D\33[16C% u\r\n -pages occupees \33[40D\33[16C% u\r\n", virtual_getpagesfree(), virtual_getpagesused());
|
||||
return;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Affiche les périphériques PCI */
|
||||
|
||||
int detectpci()
|
||||
{
|
||||
scanPCI();
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Change la police courante */
|
||||
|
||||
int sfont(u8 * commandline)
|
||||
{
|
||||
if (strgetnbitems(commandline, ' ') < 2)
|
||||
{
|
||||
print("Syntaxe de la commande FONT\r\nfont \33[32mpolice\r\n\r\n \33[32mpolice\33[0m\33[0m\33[25D\33[10C - \33[Nom de la police de caractere\r\n");
|
||||
return;
|
||||
}
|
||||
setfont(strgetpointeritem(commandline, ' ', 1));
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Affiche le logo */
|
||||
|
||||
int logo()
|
||||
{
|
||||
print(ansilogo);
|
||||
return;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Renvoie les commandes disponibles */
|
||||
|
||||
int help()
|
||||
{
|
||||
print("Commandes disponibles :\r\n\r\n");
|
||||
for (u32 i = 0; i < sizeof(commands) / sizeof(commands[0]); i++)
|
||||
{
|
||||
printf("%s \r\n", &commands[i].name);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
/*******************************************************************************/
|
||||
/* Met un breakpoint */
|
||||
|
||||
int bpset(u8 * commandline)
|
||||
{
|
||||
u8 arg[] = " \000";
|
||||
u8 *numero;
|
||||
u8 *pointer;
|
||||
u8 type = DBG_EXEC;
|
||||
if (strgetnbitems(commandline, ' ') < 3)
|
||||
{
|
||||
print("Syntaxe de la commande BPSET\r\nbpset \33[32mnumero address [type]\r\n\r\n \33[32mnumero\33[0m\33[0m\33[25D\33[10C - numero du breakpoint (0-3)\r\n \33[32madresse\33[0m\33[25D\33[10C - adresse du breakpoint\r\n \33[32mtype\33[0m\33[25D\33[10C - type de breakpoint (0-3)\r\n");
|
||||
return;
|
||||
}
|
||||
strgetitem(commandline, &arg, ' ', 1);
|
||||
numero = strtoint(&arg);
|
||||
if (numero > 3)
|
||||
{
|
||||
print("numero incorrect");
|
||||
return;
|
||||
}
|
||||
strgetitem(commandline, &arg, ' ', 2);
|
||||
pointer = strtoint(&arg);
|
||||
if (strgetnbitems(commandline, ' ') == 4)
|
||||
{
|
||||
strgetitem(commandline, &arg, ' ', 3);
|
||||
type = strtoint(&arg);
|
||||
}
|
||||
if (type > DBG_READWRITE)
|
||||
{
|
||||
print("type incorrect");
|
||||
return;
|
||||
}
|
||||
setdebugreg(numero, pointer, type);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Retire un breakpoint */
|
||||
|
||||
int bpclr(u8 * commandline)
|
||||
{
|
||||
u8 arg[] = " \000";
|
||||
u8 *numero;
|
||||
|
||||
if (strgetnbitems(commandline, ' ') < 2)
|
||||
{
|
||||
print("Syntaxe de la commande BPCLR\r\nbpclr \33[32mnumero\r\n\r\n \33[32mnumero\33[0m\33[0m\33[25D\33[10C - numero du breakpoint (0-3)\r\n");
|
||||
return;
|
||||
}
|
||||
strgetitem(commandline, &arg, ' ', 1);
|
||||
numero = strtoint(&arg);
|
||||
if (numero > 3)
|
||||
{
|
||||
print("numero incorrect");
|
||||
return;
|
||||
}
|
||||
setdebugreg(numero, 0x0, DBG_CLEAR);
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Desassemble une zone de mémoire donnée */
|
||||
|
||||
int disas(u8 * commandline)
|
||||
{
|
||||
u8 arg[] = " \000";
|
||||
u8 *size;
|
||||
u8 *pointer;
|
||||
|
||||
if (strgetnbitems(commandline, ' ') < 3)
|
||||
{
|
||||
print("Syntaxe de la commande DISASM\r\ndisasm \33[32madresse taille\r\n\r\n \33[32madresse\33[0m\33[0m\33[25D\33[10C - Adresse a visualiser\r\n \33[32mtaille\33[0m\33[25D\33[10C - nombre d'octets a desassembler <256\r\n");
|
||||
return;
|
||||
}
|
||||
strgetitem(commandline, &arg, ' ', 1);
|
||||
pointer = strtoint(&arg);
|
||||
size = pointer;
|
||||
strgetitem(commandline, &arg, ' ', 2);
|
||||
size += strtoint(&arg);
|
||||
while (pointer < size)
|
||||
{
|
||||
pointer += disasm(pointer, NULL, true);
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Génère des exceptions */
|
||||
|
||||
int view(u8 * commandline)
|
||||
{
|
||||
u8 arg[] = " \000";
|
||||
u32 address;
|
||||
u8 size;
|
||||
u8 *pointerb;
|
||||
u16 *pointerw;
|
||||
u32 *pointerd;
|
||||
u8 format;
|
||||
u8 nbligne;
|
||||
if (strgetnbitems(commandline, ' ') < 3)
|
||||
{
|
||||
print("Syntaxe de la commande VIEW\r\nview \33[32madresse taille [size] [nbligne]\r\n\r\n \33[32madresse\33[0m\33[0m\33[25D\33[10C - Adresse a visualiser\r\n \33[32mtaille\33[0m\33[25D\33[10C - nombre d'octets a visualiser <256\r\n \33[32mformat\33[0m\33[25D\33[10C - c (ascii) b (octet) w (mot) d (double mot)\r\n \33[32mnbligne\33[0m\33[25D\33[10C - nombre d'octets a visualiser par ligne\r\n");
|
||||
return;
|
||||
}
|
||||
strgetitem(commandline, &arg, ' ', 1);
|
||||
address = strtoint(&arg);
|
||||
strgetitem(commandline, &arg, ' ', 2);
|
||||
size = strtoint(&arg);
|
||||
if (strgetnbitems(commandline, ' ') < 4)
|
||||
format = 'b';
|
||||
else
|
||||
{
|
||||
strgetitem(commandline, &arg, ' ', 3);
|
||||
format = arg[0];
|
||||
}
|
||||
switch (format)
|
||||
{
|
||||
case 'c':
|
||||
pointerb = address;
|
||||
nbligne = 12;
|
||||
break;
|
||||
case 'b':
|
||||
pointerb = address;
|
||||
nbligne = 22;
|
||||
break;
|
||||
case 'w':
|
||||
pointerw = address;
|
||||
nbligne = 13;
|
||||
break;
|
||||
case 'd':
|
||||
pointerd = address;
|
||||
nbligne = 7;
|
||||
break;
|
||||
}
|
||||
if (strgetnbitems(commandline, ' ') == 5)
|
||||
{
|
||||
strgetitem(commandline, &arg, ' ', 4);
|
||||
nbligne = strtoint(&arg);
|
||||
}
|
||||
printf("Adresse %Y - % hhu", address, size);
|
||||
for (u32 i = 0; i < size; i++)
|
||||
switch (format)
|
||||
{
|
||||
case 'c':
|
||||
if (i % nbligne == 0)
|
||||
printf("\r\n:%Y - ", pointerb);
|
||||
printf("%hhY \33[40C%c\33[41D",
|
||||
*(pointerb), *(pointerb++));
|
||||
break;
|
||||
case 'b':
|
||||
if (i % nbligne == 0)
|
||||
printf("\r\n:%Y - ", pointerb);
|
||||
printf("%hhY ", *(pointerb++));
|
||||
break;
|
||||
case 'w':
|
||||
if (i % nbligne == 0)
|
||||
printf("\r\n:%Y - ", pointerw);
|
||||
printf("%hY ", *(pointerw++));
|
||||
break;
|
||||
case 'd':
|
||||
if (i % nbligne == 0)
|
||||
printf("\r\n:%Y - ", pointerd);
|
||||
printf("%Y ", *(pointerd++));
|
||||
break;
|
||||
}
|
||||
}
|
||||
/*******************************************************************************/
|
||||
/* Génère des exceptions */
|
||||
|
||||
int err(u8 * commandline)
|
||||
{
|
||||
u8 arg[] = " \000";
|
||||
u32 argint;
|
||||
if (strgetnbitems(commandline, ' ') < 2)
|
||||
{
|
||||
print("Syntaxe de la commande ERR\r\nerr \33[32mexception\r\n\r\n exception\33[0m\33[25D\33[10C - code de l'exception\r\n");
|
||||
return;
|
||||
}
|
||||
strgetitem(commandline, &arg, ' ', 1);
|
||||
argint = strtoint(&arg);
|
||||
switch (argint)
|
||||
{
|
||||
case 0:
|
||||
print("Creation d'une erreur de division par 0 !\r\n");
|
||||
asm("movl $0x0,%ecx; divl %ecx");
|
||||
break;
|
||||
case 1:
|
||||
print("Creation d'un breakpoint !\r\n");
|
||||
setdebugreg(0, &test, DBG_EXEC);
|
||||
test();
|
||||
break;
|
||||
case 2:
|
||||
print("NON GERE!\r\n");
|
||||
break;
|
||||
case 3:
|
||||
print("Creation d'une erreur interruption 3 !\r\n");
|
||||
asm("int $0x3");
|
||||
break;
|
||||
case 4:
|
||||
print("NON GERE!\r\n");
|
||||
break;
|
||||
case 5:
|
||||
print("NON GERE!\r\n");
|
||||
break;
|
||||
case 6:
|
||||
print("Creation d'une erreur d'opcode invalide !\r\n");
|
||||
asm("mov %cr7, %eax");
|
||||
break;
|
||||
case 7:
|
||||
print("NON GERE!\r\n");
|
||||
break;
|
||||
case 8:
|
||||
print("NON GERE!\r\n");
|
||||
break;
|
||||
case 9:
|
||||
print("NON GERE!\r\n");
|
||||
break;
|
||||
case 10:
|
||||
print("NON GERE!\r\n");
|
||||
break;
|
||||
case 11:
|
||||
print("Creation d'une erreur segment non present !\r\n");
|
||||
setidt(&err, SEL_KERNEL_CODE, INTGATE, 104);
|
||||
asm("int $0x68");
|
||||
break;
|
||||
case 12:
|
||||
print("NON GERE!\r\n");
|
||||
break;
|
||||
case 13:
|
||||
print("Creation d'une erreur general fault !\r\n");
|
||||
asm("mov $0x666, %ax; ltr %ax");
|
||||
break;
|
||||
case 14:
|
||||
if (random(0, 100) > 50)
|
||||
{
|
||||
print("Creation d'une erreur de page en ecriture !\r\n");
|
||||
asm("movl $0x66666666,(0xE0000000)");
|
||||
}
|
||||
else
|
||||
{
|
||||
print("Creation d'une erreur de page en lecture !\r\n");
|
||||
asm("movl (0xD0000000),%eax");
|
||||
}
|
||||
break;
|
||||
case 15:
|
||||
print("NON GERE!\r\n");
|
||||
break;
|
||||
case 16:
|
||||
print("NON GERE!\r\n");
|
||||
break;
|
||||
case 17:
|
||||
print("NON GERE!\r\n");
|
||||
break;
|
||||
case 18:
|
||||
print("NON GERE!\r\n");
|
||||
break;
|
||||
default:
|
||||
print("Exception qui n'existe pas !!!\r\n");
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Information sur le démarrage */
|
||||
int showinfo()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Affiche les registres */
|
||||
|
||||
int showregs()
|
||||
{
|
||||
int20;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Change le mode */
|
||||
int mode(u8 * commandline)
|
||||
{
|
||||
u8 arg[] = " \000";
|
||||
u32 argint;
|
||||
if (strgetnbitems(commandline, ' ') < 2)
|
||||
{
|
||||
print("Syntaxe de la commande MODE\r\nmode \33[32mmodevideo\r\n\r\n modevideo\33[0m\33[25D\33[10C - mode video a initialiser (>0x80 = graphique)\r\n");
|
||||
return;
|
||||
}
|
||||
strgetitem(commandline, &arg, ' ', 1);
|
||||
argint = strtoint(&arg);
|
||||
changemode(argint);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Efface l'écran */
|
||||
|
||||
int clear()
|
||||
{
|
||||
clearscreen();
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Redemarre */
|
||||
|
||||
int rebootnow()
|
||||
{
|
||||
print("<Appuyer sur une touche pour redemarrer>");
|
||||
waitascii();
|
||||
reboot();
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Teste les fonctionnalités 3D */
|
||||
|
||||
int test3d()
|
||||
{
|
||||
videoinfos *vinfo = getvideo_info();
|
||||
if (!vinfo->isgraphic)
|
||||
{
|
||||
print("Mode graphique necessaire afin de lancer ce programme\r\n");
|
||||
return 1;
|
||||
}
|
||||
model3d model;
|
||||
float factor = 100.0f;
|
||||
type3D type = TYPE3D_POINTS;
|
||||
matrix44 rotatex, rotatey, rotatez, mrotatex, mrotatey, mrotatez,
|
||||
identity;
|
||||
matrix44_homogen(&identity);
|
||||
matrix44_rotation_x(0.1f, &rotatex);
|
||||
matrix44_rotation_y(0.1f, &rotatey);
|
||||
matrix44_rotation_z(0.1f, &rotatez);
|
||||
matrix44_rotation_x(-0.1f, &mrotatex);
|
||||
matrix44_rotation_y(-0.1f, &mrotatey);
|
||||
matrix44_rotation_z(-0.1f, &mrotatez);
|
||||
matrix44 *transformation = &identity;
|
||||
vector4 origin = { 0.0f, 0.0f, 0.0f, 0.0f };
|
||||
vector4 cubeorigin = { 0.0f, 0.0f, 0.0f, 0.0f };
|
||||
origin.x = vinfo->currentwidth / 2.0f;
|
||||
origin.y = vinfo->currentheight / 2.0f;
|
||||
origin.z = 70.0f;
|
||||
cube(&model, &cubeorigin, 35.0f);
|
||||
u8 achar = ' ';
|
||||
u8 i;
|
||||
while (achar != 'q' && achar != 'Q')
|
||||
{
|
||||
clearscreen();
|
||||
show3dmodel(&model, transformation, &origin, factor, type);
|
||||
achar = waitascii();
|
||||
switch (achar)
|
||||
{
|
||||
case '1':
|
||||
load3ds(&man, sizeof(man), &model);
|
||||
break;
|
||||
case '2':
|
||||
load3ds(&sphere, sizeof(sphere), &model);
|
||||
break;
|
||||
case 17:
|
||||
transformation = &rotatex;
|
||||
break;
|
||||
case 18:
|
||||
transformation = &mrotatex;
|
||||
break;
|
||||
case 19:
|
||||
transformation = &rotatey;
|
||||
break;
|
||||
case 20:
|
||||
transformation = &mrotatey;
|
||||
break;
|
||||
case 2:
|
||||
transformation = &rotatez;
|
||||
break;
|
||||
case 3:
|
||||
transformation = &mrotatez;
|
||||
break;
|
||||
case '-':
|
||||
factor -= 10.0;
|
||||
break;
|
||||
case '+':
|
||||
factor += 10.0;
|
||||
break;
|
||||
case '*':
|
||||
switch (type)
|
||||
{
|
||||
case TYPE3D_POINTS:
|
||||
type = TYPE3D_LINES;
|
||||
break;
|
||||
case TYPE3D_LINES:
|
||||
type = TYPE3D_POINTS;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Teste les fonctionnalités 2D graphiques */
|
||||
|
||||
int test2d()
|
||||
{
|
||||
videoinfos *vinfo = getvideo_info();
|
||||
if (!vinfo->isgraphic)
|
||||
{
|
||||
print("Mode graphique necessaire afin de lancer ce programme\r\n");
|
||||
return 1;
|
||||
}
|
||||
struct vertex2d a, b, c;
|
||||
randomize();
|
||||
u32 color;
|
||||
for (int i = 0; i < 2000; i++)
|
||||
{
|
||||
a.x = random(0, vinfo->currentwidth);
|
||||
a.y = random(0, vinfo->currentheight);
|
||||
b.x = random(0, vinfo->currentwidth);
|
||||
b.y = random(0, vinfo->currentheight);
|
||||
if (vinfo->currentdepth > 24)
|
||||
color = egatorgb(random(0, 16));
|
||||
else if (vinfo->currentdepth == 8)
|
||||
color = random(0, 63);
|
||||
else
|
||||
color = random(0, 16);
|
||||
v_line(&a, &b, color);
|
||||
}
|
||||
waitascii();
|
||||
for (int i = 0; i < 2000; i++)
|
||||
{
|
||||
a.x = random(0, vinfo->currentwidth);
|
||||
a.y = random(0, vinfo->currentheight);
|
||||
b.x = random(0, vinfo->currentwidth);
|
||||
b.y = random(0, vinfo->currentheight);
|
||||
c.x = random(0, vinfo->currentwidth);
|
||||
c.y = random(0, vinfo->currentheight);
|
||||
if (vinfo->currentdepth > 24)
|
||||
color = egatorgb(random(0, 16));
|
||||
else if (vinfo->currentdepth == 8)
|
||||
color = random(0, 63);
|
||||
else
|
||||
color = random(0, 16);
|
||||
trianglefilled(&a, &b, &c, color);
|
||||
triangle(&a, &b, &c, egatorgb(4));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Lit l'IDT et l'affiche */
|
||||
|
||||
int showidt()
|
||||
{
|
||||
u32 index, i = 0;
|
||||
idtdes *desc;
|
||||
struct idtr idtreg;
|
||||
sidt(idtreg);
|
||||
printf("Information sur l'IDT\r\nAdresse:%X Limite:%hX\r\n",
|
||||
idtreg.base, (u32) idtreg.limite);
|
||||
desc = idtreg.base;
|
||||
for (index = 0; index < idtreg.limite / sizeof(idtdes); index++)
|
||||
{
|
||||
u32 select = desc[index].select;
|
||||
u32 offset =
|
||||
desc[index].offset0_15 +
|
||||
(desc[index].offset16_31 << 16);
|
||||
u32 type = desc[index].type & 0x0F00;
|
||||
u8 *typestr1, *typestr2;
|
||||
if (i >= 32 & i <= 39)
|
||||
typestr1 = "IRQ master";
|
||||
else if (i >= 96 & i <= 103)
|
||||
typestr1 = "IRQ slave ";
|
||||
else if (i < 19)
|
||||
typestr1 = "EXCEPTION ";
|
||||
else
|
||||
typestr1 = "INTERRUPT ";
|
||||
if (type == INTGATE)
|
||||
typestr2 = "INTGATE";
|
||||
else if (type == TRAPGATE)
|
||||
typestr2 = "TRAPGATE";
|
||||
else if (type == TASKGATE)
|
||||
typestr2 = "TASKGATE";
|
||||
else if (type == CALLGATE)
|
||||
typestr2 = "CALLGATE";
|
||||
else if (type == LDTDES)
|
||||
typestr2 = "LDTDES";
|
||||
else
|
||||
print("inconnu");
|
||||
printf("%s % hu %hY:%Y - %s\r\n", typestr1, i++, select,
|
||||
offset, typestr2);
|
||||
|
||||
if (i % 32 == 0)
|
||||
{
|
||||
print("\r\n<Appuyez sur une touche>\r\n");
|
||||
waitascii();
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Lit les descripteurs GDT et les affiche */
|
||||
|
||||
int showgdt()
|
||||
{
|
||||
u32 index;
|
||||
struct gdtr gdtreg;
|
||||
sgdt(gdtreg);
|
||||
printf("Information sur la GDT\r\nAdresse:%X Limite:%hX\r\n",
|
||||
gdtreg.base, gdtreg.limite);
|
||||
for (index = 0; index < gdtreg.limite; index += sizeof(gdtdes))
|
||||
{
|
||||
if (!isdesvalid(index))
|
||||
printf("\033[31m");
|
||||
printf("SEL =%hY %Y %Y DPL=%d %cS%d [%c%c%c] %h ub\033[0m\r\n", index, getdesbase(index), getdeslimit(index), getdesdpl(index), getdestype(index), getdessize(index), getdesbit3(index), getdesbit2(index), getdesbit1(index), getdesalign(index));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Detecte et affiche les information sur le CPU */
|
||||
|
||||
int detectcpu()
|
||||
{
|
||||
cpuinfo cpu;
|
||||
u8 noproc[] = "\033[31mInconnu\033[0m\000";
|
||||
strcpy(&noproc, &cpu.detectedname);
|
||||
getcpuinfos(&cpu);
|
||||
printf("\r\nDetection du processeur\r\033[1m Revision \t:%d\r Modele \t:%d\r Famille \t:%d\r Nom cpuid\t:%s\rJeux d'instruction\t:%s\033[0m\r\n\000", cpu.stepping, cpu.models, cpu.family, &cpu.detectedname, &cpu.techs);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
|
@ -1,65 +1,412 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
|
||||
/* */
|
||||
#include <string.h>
|
||||
|
||||
/******************************************************************************/
|
||||
/* Compare 2 chaines de caractère et renvoie la premiere distance (diff) */
|
||||
s8 strcmp(const u8 *src,const u8 *des)
|
||||
|
||||
s8 strcmp(const u8 * src, const u8 * dest)
|
||||
{
|
||||
register s8 result;
|
||||
do
|
||||
{
|
||||
if ((result = *src - *des++) != 0) break;
|
||||
if ((result = *src - *dest++) != 0)
|
||||
break;
|
||||
}
|
||||
while (*src++!=0);
|
||||
return result;
|
||||
while (*src++ != 0);
|
||||
return result;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Trouve la premiere occurence d'un caractère dans une chaine et renvoie un pointeur */
|
||||
|
||||
/* Trouve la premiere occurence d'un caractère dans une chaine */
|
||||
|
||||
u8 * strchr(const u8 *src, u8 achar)
|
||||
u8 *strchr(const u8 * src, u8 achar)
|
||||
{
|
||||
for(; *src!= achar; ++src)
|
||||
if (*src == 0) return 0;
|
||||
return (u8*)src;
|
||||
for (; *src != achar; ++src)
|
||||
if (*src == 0)
|
||||
return 0;
|
||||
return (u8 *) src;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Trouve la premiere occurence d'un caractère dans une chaine */
|
||||
|
||||
u32 strchrpos(const u8 * src, u8 achar)
|
||||
{
|
||||
u32 i;
|
||||
for (i = 0; *(src + i) != achar; ++i)
|
||||
if (*(src + i) == 0)
|
||||
return 0;
|
||||
return i;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Renvoie la taille de la chaine */
|
||||
|
||||
u32 strlen(const u8 *src)
|
||||
{
|
||||
u32 size;
|
||||
|
||||
for (size = 0; *(src+size) != 0; size++);
|
||||
u32 strlen(const u8 * src)
|
||||
{
|
||||
u32 size;
|
||||
|
||||
for (size = 0; *(src + size) != 0; size++);
|
||||
return size;
|
||||
}
|
||||
|
||||
|
||||
/******************************************************************************/
|
||||
/* copie une chaine dans une autre */
|
||||
u8* strcpy(const u8 *src, u8 *des)
|
||||
u8 *strcpy(const u8 * src, u8 * dest)
|
||||
{
|
||||
u8 *temp = des;
|
||||
while ((*des++ = *src++) != 0);
|
||||
u8 *temp = dest;
|
||||
while ((*dest++ = *src++) != 0);
|
||||
return temp;
|
||||
}
|
||||
|
||||
|
||||
/******************************************************************************/
|
||||
/* copie une portion limité d'une chaine asciiZ*/
|
||||
|
||||
u8 *strncpy(const u8 *src,u8 *des,u32 count)
|
||||
u8 *strncpy(const u8 * src, u8 * dest, u32 count)
|
||||
{
|
||||
u8 *temp = des;
|
||||
while (count) {
|
||||
if ((*temp = *src) != 0) src++;
|
||||
u8 *temp = dest;
|
||||
while (count)
|
||||
{
|
||||
if ((*temp = *src) != 0)
|
||||
src++;
|
||||
temp++;
|
||||
count--;
|
||||
}
|
||||
return des;
|
||||
return dest;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* concatene 2 chaines de caractère */
|
||||
u8 *strcat( const u8 *src,u8 *des)
|
||||
|
||||
u8 *strcat(const u8 * src, u8 * dest)
|
||||
{
|
||||
u8 *temp = des;
|
||||
while (*des!=0) des++;
|
||||
while ((*des++ = *src++) != 0);
|
||||
u8 *temp = dest;
|
||||
while (*dest != 0)
|
||||
dest++;
|
||||
while ((*dest++ = *src++) != 0);
|
||||
return temp;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Met en minuscule */
|
||||
|
||||
void strtolower(u8 * src)
|
||||
{
|
||||
while (*src != 0)
|
||||
{
|
||||
if ((*src >= 'A') && (*src <= 'Z'))
|
||||
*src = *src + 'a' - 'A';
|
||||
src++;
|
||||
}
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Met en majuscule */
|
||||
|
||||
void strtoupper(u8 * src)
|
||||
{
|
||||
while (*src != 0)
|
||||
{
|
||||
if ((*src >= 'a') && (*src <= 'z'))
|
||||
*src = *src - ('a' - 'A');
|
||||
src++;
|
||||
}
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* inverse la casse */
|
||||
|
||||
void strinvertcase(u8 * src)
|
||||
{
|
||||
while (*src != 0)
|
||||
{
|
||||
if ((*src >= 'A') && (*src <= 'Z'))
|
||||
*src = *src + 'a' - 'A';
|
||||
else if ((*src >= 'a') && (*src <= 'z'))
|
||||
*src = *src - ('a' - 'A');
|
||||
src++;
|
||||
}
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Met une majuscule et met le reste en minuscule */
|
||||
|
||||
void stronecase(u8 * src)
|
||||
{
|
||||
if ((*src >= 'a') && (*src <= 'z'))
|
||||
*src = *src - ('a' - 'A');
|
||||
while (*src != 0)
|
||||
{
|
||||
src++;
|
||||
if ((*src >= 'A') && (*src <= 'Z'))
|
||||
*src = *src + 'a' - 'A';
|
||||
}
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Fixe la taille de la chaine */
|
||||
|
||||
void strsetlen(u8 * src, u32 size)
|
||||
{
|
||||
*(src + size) = '\000';
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Inverse la chaine */
|
||||
|
||||
void strinvert(u8 * src)
|
||||
{
|
||||
u8 *dst = src + strlen(src) - 1;
|
||||
while (src < dst)
|
||||
{
|
||||
u8 char1 = *dst;
|
||||
u8 char2 = *src;
|
||||
*dst = char2;
|
||||
*src = char1;
|
||||
src++;
|
||||
dst--;
|
||||
}
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Remplace tout les caractères rechercher par un autre */
|
||||
|
||||
void strreplace(u8 * src, u8 search, u8 replaced)
|
||||
{
|
||||
u8 *pos = strchr(src, search);
|
||||
while (pos != 0)
|
||||
{
|
||||
*pos = replaced;
|
||||
pos = strchr(src, search);
|
||||
}
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Rempli de caractère */
|
||||
|
||||
u8 *strfill(u8 * dst, u8 pattern, u32 size)
|
||||
{
|
||||
u32 i;
|
||||
for (i = 0; i <= size; i++)
|
||||
*(dst + i) = pattern;
|
||||
*(dst + i + 1) = '\000';
|
||||
return dst;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Renvoie la partie gauche d'une chaine */
|
||||
|
||||
void strleft(u8 * src, u8 * dest, u32 size)
|
||||
{
|
||||
u32 i;
|
||||
for (i = 0; (*(src + i) != 0) && (i < size); i++)
|
||||
*dest++ = *(src + i);
|
||||
*dest++ = '\000';
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Renvoie la partie droite d'une chaine */
|
||||
|
||||
void strright(u8 * src, u8 * dest, u32 size)
|
||||
{
|
||||
u32 i;
|
||||
u32 begin = strlen(src) - size;
|
||||
for (i = 0; (*(src + i + begin) != 0) && (i < size); i++)
|
||||
*dest++ = *(src + i + begin);
|
||||
*dest++ = '\000';
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Supprime une portion de chaine */
|
||||
|
||||
void strdelete(u8 * src, u32 index, u32 size)
|
||||
{
|
||||
u32 i;
|
||||
u32 realsize = strlen(src) - index - size;
|
||||
for (i = 0; (*(src + index + size + i) != 0) && (i < realsize);
|
||||
i++)
|
||||
*(src + index + i) = *(src + index + size + i);
|
||||
*(src + index + i) = '\000';
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Insert une portion dans la chaine */
|
||||
|
||||
void strinsert(u8 * src, u8 * dest, u32 index)
|
||||
{
|
||||
u32 i;
|
||||
u32 realsize = strlen(src);
|
||||
u32 copysize = strlen(dest) - index;
|
||||
for (i = 0; i <= copysize; i++)
|
||||
*(dest + index + realsize + copysize - i) =
|
||||
*(dest + index + copysize - i);
|
||||
for (i = 0; (*(src + i) != 0); i++)
|
||||
*(dest + index + i) = *(src + i);
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Supprime les délimiteurs consécutifs */
|
||||
|
||||
void strcompressdelimiter(u8 * src, u8 delim)
|
||||
{
|
||||
u8 *pos = strchr(src, delim);
|
||||
while (pos != 0)
|
||||
{
|
||||
u8 i;
|
||||
for (i = 0; (*(pos + i) != 0) && (*(pos + i) == delim);
|
||||
i++);
|
||||
if (i > 1)
|
||||
strdelete(pos, 1, i - 1);
|
||||
pos = strchr(pos + 1, delim);
|
||||
}
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Récupérère l'élément N d'une liste utilisant un délimiteur */
|
||||
|
||||
u8 *strgetitem(u8 * src, u8 * dest, u8 delim, u32 index)
|
||||
{
|
||||
u32 i;
|
||||
u8 *pos = strgetpointeritem(src, delim, index);
|
||||
for (i = 0; (*(pos + i) != 0) && (*(pos + i) != delim); i++)
|
||||
*(dest + i) = *(pos + i);
|
||||
*(dest + i) = '\000';
|
||||
return dest;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Récupérère un pointeur sur l'élément N d'une liste utilisant un délimiteur */
|
||||
|
||||
u8 *strgetpointeritem(u8 * src, u8 delim, u32 index)
|
||||
{
|
||||
u32 i;
|
||||
u8 *pos = src;
|
||||
for (i = 0; i < index; i++)
|
||||
pos = strchr(pos + 1, delim);
|
||||
if (*pos == delim)
|
||||
pos++;
|
||||
return pos;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Récupérère le nombre d'éléments d'une liste utilisant un délimiteur */
|
||||
|
||||
u32 strgetnbitems(u8 * src, u8 delim)
|
||||
{
|
||||
u32 number = 0;
|
||||
if (*src == 0)
|
||||
return 0;
|
||||
number++;
|
||||
u8 *pos = strchr(src, delim);
|
||||
while (pos != 0)
|
||||
{
|
||||
pos = strchr(pos + 1, delim);
|
||||
number++;
|
||||
}
|
||||
return number;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Renvoie la base minimum du nombre */
|
||||
|
||||
u8 base[] = " 0123456789ABCDEF\000";
|
||||
|
||||
u8 strgetminbase(u8 * src)
|
||||
{
|
||||
u8 temp[] = " \000";
|
||||
u8 *dst = &temp;
|
||||
strtoupper(strcpy(src, &temp));
|
||||
u8 max = 0;
|
||||
while (*dst != 0)
|
||||
{
|
||||
u32 result = strchrpos(&base, *dst++);
|
||||
if (result == 0)
|
||||
return 0;
|
||||
if (result > max)
|
||||
max = result;
|
||||
}
|
||||
if (max > 10)
|
||||
return 16;
|
||||
else if (max > 8)
|
||||
return 10;
|
||||
else if (max > 2)
|
||||
return 8;
|
||||
else
|
||||
return 2;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Renvoie la base du nombre */
|
||||
|
||||
u8 hexa[] = "0x\000";
|
||||
u8 bases[] = " bodh\000";
|
||||
u8 basesnum[] = { 0, 2, 8, 10, 16 };
|
||||
|
||||
u8 declaredbase = 10;
|
||||
u8 minbase = 0;
|
||||
u8 strgetbase(u8 * src)
|
||||
{
|
||||
u8 temp[] = " \000";
|
||||
strleft(src, &temp, 2);
|
||||
if (strcmp(&temp, &hexa) == 0)
|
||||
{
|
||||
declaredbase = 16;
|
||||
u8 size = strlen(src);
|
||||
strright(src, &temp, size - 2);
|
||||
minbase = strgetminbase(&temp);
|
||||
}
|
||||
else
|
||||
{
|
||||
strright(src, &temp, 1);
|
||||
declaredbase = basesnum[strchrpos(&bases, temp[0])];
|
||||
if (declaredbase > 0)
|
||||
{
|
||||
u8 size = strlen(src);
|
||||
strleft(src, &temp, size - 1);
|
||||
minbase = strgetminbase(&temp);
|
||||
}
|
||||
else
|
||||
{
|
||||
minbase = strgetminbase(src);
|
||||
declaredbase = minbase;
|
||||
}
|
||||
}
|
||||
if (declaredbase >= minbase && minbase != 0)
|
||||
return declaredbase;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
/* Transforme une chaine en nombre */
|
||||
|
||||
u32 strtoint(u8 * src)
|
||||
{
|
||||
u8 *temp = src;
|
||||
u32 result = 0;
|
||||
u8 thebase = strgetbase(src);
|
||||
u32 multi = 1;
|
||||
u8 shorter = 0;
|
||||
|
||||
if (thebase == 0)
|
||||
return 0;
|
||||
if (*(src + 1) == 'x')
|
||||
shorter = 2;
|
||||
while (*++temp != 0);
|
||||
while (*temp == 0 || *temp == 'b' || *temp == 'o' || *temp == 'd'
|
||||
|| *temp == 'h')
|
||||
temp--;
|
||||
while (src + shorter <= temp)
|
||||
{
|
||||
u8 achar = *temp--;
|
||||
if ((achar >= 'a') && (achar <= 'z'))
|
||||
achar = achar - ('a' - 'A');
|
||||
result = result + multi * (strchrpos(&base, achar) - 1);
|
||||
multi = multi * thebase;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
|
|
|
@ -0,0 +1,93 @@
|
|||
/*******************************************************************************/
|
||||
/* COS2000 - Compatible Operating System - LGPL v3 - Horde Nicolas */
|
||||
/* */
|
||||
#include <types.h>
|
||||
#include <gdt.h>
|
||||
#include <asm.h>
|
||||
#include <memory.h>
|
||||
#include <interrupts.h>
|
||||
#include <syscall.h>
|
||||
#include <process.h>
|
||||
|
||||
/* 32bit SYSENTER instruction entry.
|
||||
*
|
||||
* Arguments:
|
||||
* %eax System call number.
|
||||
* %ebx Arg1
|
||||
* %esi Arg2
|
||||
* %edi Arg3*/
|
||||
|
||||
extern wrapper_sysenter;
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Initialise les appels système par SYSENTER/SYSEXIT */
|
||||
|
||||
void initsyscall(void)
|
||||
{
|
||||
wrmsr(0x174, SEL_KERNEL_CODE, 0x0);
|
||||
wrmsr(0x175, NULL, 0x0);
|
||||
wrmsr(0x176, &wrapper_sysenter, 0x0);
|
||||
return;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Fonction permettant de tester le fonctionnement de SYSENTER */
|
||||
/* SYSCALL
|
||||
{
|
||||
"ID":0,
|
||||
"LIBRARY":"libsys",
|
||||
"NAME":"testapi",
|
||||
"INTERNALNAME":"testapi",
|
||||
"DESCRIPTION":"Simple function to test if SYSCALL API is correctly running",
|
||||
"ARGS": [
|
||||
{"TYPE":"u32","NAME":"arg1","DESCRIPTION":"first argument of your choice"},
|
||||
{"TYPE":"u32","NAME":"arg2","DESCRIPTION":"second argument of your choice"},
|
||||
{"TYPE":"u32","NAME":"arg3","DESCRIPTION":"third argument of your choice"}
|
||||
],
|
||||
"RETURN":"u32",
|
||||
"DUMP":"yes"
|
||||
}
|
||||
END-SYSCALL */
|
||||
|
||||
u32 testapi(u32 arg1, u32 arg2, u32 arg3, regs* dump)
|
||||
{
|
||||
printf("Appel syscall %u depuis %Y:%Y avec arguments => ARG1:%Y ARG2:%Y ARG3:%Y\r\n", dump->eax, (u32) dump->cs, dump->eip, arg1, arg2, arg3);
|
||||
return;
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
/* Entrée pour les appels système SYSENTER */
|
||||
__attribute__ ((noreturn)) void sysenter_handler(regs *dump)
|
||||
{
|
||||
sti();
|
||||
switch (dump->eax)
|
||||
{
|
||||
case 5:
|
||||
dump->eax=(u32) processexit(dump->ebx);
|
||||
break;
|
||||
case 4:
|
||||
dump->eax=(u32) gettimer();
|
||||
break;
|
||||
case 2:
|
||||
dump->eax=(u32) print(dump->ebx);
|
||||
break;
|
||||
case 1:
|
||||
dump->eax=(u32) waitascii();
|
||||
break;
|
||||
case 0:
|
||||
dump->eax=(u32) testapi(dump->ebx, dump->esi, dump->edi, dump);
|
||||
break;
|
||||
|
||||
default:
|
||||
printf("Appel syscall vers fonction inexistante en %Y:%Y", dump->cs, dump->eip);
|
||||
break;
|
||||
}
|
||||
//dump->eflags &= ~(1 << 6);
|
||||
dump->eflags |= (1 << 6);
|
||||
setESP(dump);
|
||||
restcpu_user();
|
||||
sysexit();
|
||||
}
|
||||
|
||||
/*******************************************************************************/
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue