feat: ajustement des fonctions multiboot

include/cpu.h

@@ -7,8 +7,8 @@ typedef struct cpuinfo
 {	
 u8 vendor[13];
 u8 names[32];
-u8 detectedname[48];
+u8 detectedname[256];
-u8 techs[48];
+u8 techs[256];
 u8 stepping;
 u8 models;
 u8 family;

include/multiboot2.h

@@ -4,7 +4,7 @@
 #include "types.h"
      
 #ifndef MULTIBOOT
-# define ALLTYMULTIBOOTPES
+#define MULTIBOOT
 
      /*  How many bytes from the start of the file we search for the header. */
      #define MULTIBOOT_SEARCH                        32768
@@ -389,8 +389,12 @@
        u32 load_base_addr;
      };
 
-void getbootinfo(void);
+u32 getgrubinfo(u8 type);
-u32 getblockinfo(void);
+u8 *getgrubinfo_cmdline(void);
+u32 getgrubinfo_ram(void);
+struct multiboot_memory_map_t *getgrubinfo_mem(void);
+struct multiboot_tag_framebuffer *getgrubinfo_fb(void);
+void getgrubinfo_all(void);
 void initmultiboot(const u32 addr);
      
 #endif

lib/interrupts.c

@@ -758,8 +758,9 @@ void initidt(void)
 
 void inittimer(void)
 {
+    u32 divisor = TIMER_FREQ / HZ;
 	outb(TIMER_MODE, RATE_GENERATOR);
-	outb(TIMER0, (u8) (TIMER_FREQ / HZ));
+	outb(TIMER0, (u8) divisor);
-	outb(TIMER0, (u8) ((TIMER_FREQ / HZ) >> 8));
+	outb(TIMER0, (u8) (divisor >> 8));
 }
 /*******************************************************************************/

lib/multiboot.c

@@ -15,24 +15,64 @@ void initmultiboot(const u32 addr)
 }
 
 /*******************************************************************************/
-/* Renvoie l'adresse du bloc multiboot2 */
+/* Renvoie les informations souhaitées multiboot2 */
 
-u32 getblockinfo(void)
+u32 getgrubinfo(u8 type)
 {
-    return infobloc;
+struct multiboot_tag *tag;
+unsigned size = *(unsigned *) infobloc;
+for (tag = (struct multiboot_tag *) (infobloc + 8);
+            tag->type != MULTIBOOT_TAG_TYPE_END;
+            tag = (struct multiboot_tag *) ((u8 *) tag + ((tag->size + 7) & ~7)))
+         if (tag->type==type) return tag;
 }
 
 /*******************************************************************************/
-/* Affiche les informations multiboot2 */
+/* Renvoie la ligne de commande */
 
-void getbootinfo(void)
+u8 *getgrubinfo_cmdline(void)
+{
+    struct multiboot_tag_string *tag=getgrubinfo(MULTIBOOT_TAG_TYPE_CMDLINE);
+    return tag->string;
+}
+
+/*******************************************************************************/
+/* Renvoie la quantité de mémoire */
+
+u32 getgrubinfo_ram(void)
+{
+    struct multiboot_tag_basic_meminfo *tag=getgrubinfo(MULTIBOOT_TAG_TYPE_BASIC_MEMINFO);
+    return tag->mem_upper;
+}
+
+/*******************************************************************************/
+/* Renvoie le plan de la mémoire */
+
+struct multiboot_memory_map_t *getgrubinfo_mem(void)
+{
+    struct multiboot_memory_map_t *tag=getgrubinfo(MULTIBOOT_TAG_TYPE_MMAP);
+    return tag;
+}
+
+/*******************************************************************************/
+/* Renvoie les information sur le framebuffer */
+
+struct multiboot_tag_framebuffer *getgrubinfo_fb(void)
+{
+    struct multiboot_tag_framebuffer *tag=getgrubinfo(MULTIBOOT_TAG_TYPE_FRAMEBUFFER);
+    return tag;
+}
+
+/*******************************************************************************/
+/* Affiche les informations multiboot2 ;*/
+
+void getgrubinfo_all(void)
 {
-u32 addr=infobloc;
 struct multiboot_tag *tag;
-unsigned size = *(unsigned *) addr;
+u32 size = *(unsigned *) infobloc;
-if (addr & 7) print("Non aligne...");
+if (infobloc & 7) print("Attention : Bloc non aligne...");
 printf(" Taille :% 4u\r\n", (u32)size);
-for (tag = (struct multiboot_tag *) (addr + 8);
+for (tag = (struct multiboot_tag *) (infobloc + 8);
             tag->type != MULTIBOOT_TAG_TYPE_END;
             tag = (struct multiboot_tag *) ((u8 *) tag + ((tag->size + 7) & ~7)))
          {
@@ -40,7 +80,7 @@ for (tag = (struct multiboot_tag *) (addr + 8);
            switch (tag->type)
              {
              case MULTIBOOT_TAG_TYPE_CMDLINE:
-               printf ("line de lancement : %s\r\n",
+               printf (" Ligne de lancement : %s\r\n",
                        ((struct multiboot_tag_string *) tag)->string);
                break;
              case MULTIBOOT_TAG_TYPE_BOOT_LOADER_NAME:
@@ -59,7 +99,7 @@ for (tag = (struct multiboot_tag *) (addr + 8);
                        ((u64)((struct multiboot_tag_basic_meminfo *) tag)->mem_upper)<<10);
                break;
              case MULTIBOOT_TAG_TYPE_BOOTDEV:
-               printf ("Peripherique de demarrage : %X,%u,%u\r\n\r\n",
+               printf (" Peripherique de demarrage : %Y,%u,%u\r\n\r\n",
                        ((struct multiboot_tag_bootdev *) tag)->biosdev,
                        ((struct multiboot_tag_bootdev *) tag)->slice,
                        ((struct multiboot_tag_bootdev *) tag)->part);
@@ -70,101 +110,35 @@ for (tag = (struct multiboot_tag *) (addr + 8);
                  printf ("*** Plan de memoire ***\r\n");
                  for (mmap = ((struct multiboot_tag_mmap *) tag)->entries;(u8 *) mmap < (u8 *) tag + tag->size; mmap = (multiboot_memory_map_t *)
                         ((unsigned long) mmap + ((struct multiboot_tag_mmap *) tag)->entry_size))
-                   printf (" adresse: %lX,"" taille:%lX, type:%X\r\n",
+                   printf (" adresse: %lY, taille:%lY, type:%Y\r\n",
                            (u64) (mmap->addr),
                            (u64) (mmap->len),
                            (u32) (mmap->type));
-               }
                break;
+             }
              case MULTIBOOT_TAG_TYPE_FRAMEBUFFER:
              {
-                 u32 color;
+                 struct multiboot_tag_framebuffer *tagfb = (struct multiboot_tag_framebuffer *) tag;
-                 unsigned i;
+                 printf (" Framebuffer, resolution %d*%d*%d adresse: %X, ",tagfb->common.framebuffer_width,tagfb->common.framebuffer_height,tagfb->common.framebuffer_bpp,tagfb->common.framebuffer_addr);
-                 struct multiboot_tag_framebuffer *tagfb
-                   = (struct multiboot_tag_framebuffer *) tag;
-                 void *fb = (void *) (unsigned long) tagfb->common.framebuffer_addr;
-     
                  switch (tagfb->common.framebuffer_type)
                  {
                    case MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED:
-                     {
+                     printf ("mode graphique indexé\r\n");
-                       unsigned best_distance, distance;
-                       struct multiboot_color *palette;
-     
-                       palette = tagfb->framebuffer_palette;
-     
-                       color = 0;
-                       best_distance = 4*256*256;
-     
-                       for (i = 0; i < tagfb->framebuffer_palette_num_colors; i++)
-                         {
-                           distance = (0xff - palette[i].blue)
-                             * (0xff - palette[i].blue)
-                             + palette[i].red * palette[i].red
-                             + palette[i].green * palette[i].green;
-                           if (distance < best_distance)
-                             {
-                               color = i;
-                               best_distance = distance;
-                             }
-                         }
-                     }
                      break;
-     
                    case MULTIBOOT_FRAMEBUFFER_TYPE_RGB:
-                     color = ((1 << tagfb->framebuffer_blue_mask_size) - 1)
+                     printf ("mode graphique RGB\r\n");
-                       << tagfb->framebuffer_blue_field_position;
                      break;
-     
                    case MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT:
-                     color = '\\' | 0x0100;
+                     printf ("mode texte EGA\r\n");
-                     break;
-     
-                   default:
-                     color = 0xffffffff;
                      break;
                  }
-     
+                 break;
-                 for (i = 0; i < tagfb->common.framebuffer_width
+            }
-                        && i < tagfb->common.framebuffer_height; i++)
+            case MULTIBOOT_TAG_TYPE_VBE:
             {
-                     switch (tagfb->common.framebuffer_bpp)
+                struct multiboot_tag_vbe *tagvbe = (struct multiboot_tag_framebuffer *) tag;
-                       {
+                 printf (" VBE 2.0, mode %Y, adresse %hY:%hY-%hY\r\n", tagvbe->vbe_mode,tagvbe->vbe_interface_seg,tagvbe->vbe_interface_off,tagvbe->vbe_interface_len);
-                       case 8:
-                         {
-                           u8 *pixel = fb
-                             + tagfb->common.framebuffer_pitch * i + i;
-                           *pixel = color;
              }
-                         break;
-                       case 15:
-                       case 16:
-                         {
-                           u16 *pixel
-                             = fb + tagfb->common.framebuffer_pitch * i + 2 * i;
-                           *pixel = color;
-                         }
-                         break;
-                       case 24:
-                         {
-                           u32 *pixel
-                             = fb + tagfb->common.framebuffer_pitch * i + 3 * i;
-                           *pixel = (color & 0xffffff) | (*pixel & 0xff000000);
-                         }
-                         break;
-     
-                       case 32:
-                         {
-                           u32 *pixel
-                             = fb + tagfb->common.framebuffer_pitch * i + 4 * i;
-                           *pixel = color;
-                         }
-                         break;
-                       }
-                   }
-                 break;
-               }
-     
         }
      } 
 }

lib/shell.c

@@ -375,7 +375,7 @@ int err(u8* commandline)
 /* Information sur le démarrage */
 int info()
 {
-    getbootinfo();
+    getgrubinfo_all();
     return 0;
 }
 

lib/vesa.c

@@ -18,19 +18,7 @@ static capabilities vesacapabilities[] = {
 /*******************************************************************************/
 /* Detecte si le hardware est disponible, return NULL ou pointeur sur le type de pilote */
 u8 *VESA_detect_hardware(void) {
-    u32 addr=getblockinfo();
+    struct multiboot_tag_framebuffer *tagfb = getgrubinfo_fb();
-    struct multiboot_tag *tag;
-    unsigned size = *(unsigned *) addr;
-    for (tag = (struct multiboot_tag *) (addr + 8);
-            tag->type != MULTIBOOT_TAG_TYPE_END;
-            tag = (struct multiboot_tag *) ((u8 *) tag + ((tag->size + 7) & ~7)))
-            {
-           switch (tag->type)
-             {
-             case MULTIBOOT_TAG_TYPE_FRAMEBUFFER:
-               {
-                 struct multiboot_tag_framebuffer *tagfb = (struct multiboot_tag_framebuffer *) tag;
-     
     switch (tagfb->common.framebuffer_type)
     {
         case MULTIBOOT_FRAMEBUFFER_TYPE_RGB:
@@ -44,19 +32,12 @@ u8 *VESA_detect_hardware(void) {
             infos.currentpitch=tagfb->common.framebuffer_pitch;
             return "LEGACY";
             break;
-
         default:
         case MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED:
         case MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT:
             return NULL;
             break;
      }
-     
-                 break;
-               }
-     
-             }
-        }
 }
 
 /*******************************************************************************/