Drivers: change all relevant types to stdint

src/drivers/Graphics.cpp

@@ -5,17 +5,16 @@
 #define GRAPHICS WalrusRPG::Graphics
 
 #define LCD_CONTROLLER 0xC0000000
-volatile unsigned *lcd_base = (unsigned *) (LCD_CONTROLLER + 0x10);
-volatile unsigned *lcd_ris = (unsigned *) (LCD_CONTROLLER + 0x20);
-volatile unsigned *lcd_icr = (unsigned *) (LCD_CONTROLLER + 0x28);
-volatile unsigned *lcd_control = (unsigned *) (LCD_CONTROLLER + 0x18);
-unsigned lcd_control_bkp;
-volatile unsigned *lcd_imsc = (unsigned *) (LCD_CONTROLLER + 0x1C);
-unsigned lcd_imsc_bkp;
+volatile uint32_t *lcd_base = (uint32_t *) (LCD_CONTROLLER + 0x10);
+volatile uint32_t *lcd_ris = (uint32_t *) (LCD_CONTROLLER + 0x20);
+volatile uint32_t *lcd_icr = (uint32_t *) (LCD_CONTROLLER + 0x28);
+volatile uint32_t *lcd_control = (uint32_t *) (LCD_CONTROLLER + 0x18);
+uint32_t lcd_control_bkp;
+volatile uint32_t *lcd_imsc = (uint32_t *) (LCD_CONTROLLER + 0x1C);
+uint32_t lcd_imsc_bkp;
 
 #define BUFFER_SIZE 320 * 240 * 2
-unsigned short *buffer_screen = NULL, *buffer_render = NULL, *buffer_ready = NULL,
-               *buffer_os;
+uint16_t *buffer_screen = NULL, *buffer_render = NULL, *buffer_ready = NULL, *buffer_os;
 bool buffer_swap_ready;
 
 /*
@@ -24,9 +23,9 @@ bool buffer_swap_ready;
 
 void GRAPHICS::buffer_allocate()
 {
-    buffer_screen = (unsigned short *) malloc(BUFFER_SIZE);
-    buffer_render = (unsigned short *) malloc(BUFFER_SIZE);
-    buffer_ready = (unsigned short *) malloc(BUFFER_SIZE);
+    buffer_screen = (uint16_t *) malloc(BUFFER_SIZE);
+    buffer_render = (uint16_t *) malloc(BUFFER_SIZE);
+    buffer_ready = (uint16_t *) malloc(BUFFER_SIZE);
 
     if (buffer_screen == NULL || buffer_render == NULL || buffer_ready == NULL)
     {
@@ -38,8 +37,8 @@ void GRAPHICS::buffer_allocate()
 
     memset(buffer_screen, 0, BUFFER_SIZE);
 
-    buffer_os = (unsigned short *) *lcd_base;
-    *lcd_base = (unsigned) buffer_screen;
+    buffer_os = (uint16_t *) *lcd_base;
+    *lcd_base = (uint32_t) buffer_screen;
     buffer_swap_ready = false;
 
     // Set up the controller in order to use vsync signals
@@ -56,7 +55,7 @@ void GRAPHICS::buffer_free()
     free(buffer_render);
     free(buffer_ready);
 
-    *lcd_base = (unsigned) buffer_os;
+    *lcd_base = (uint32_t) buffer_os;
 
     *lcd_control = lcd_control_bkp;
     *lcd_imsc = lcd_imsc_bkp;
@@ -66,29 +65,29 @@ void GRAPHICS::buffer_swap_screen()
 {
     if (buffer_swap_ready)
     {
-        unsigned short *buffer_screen_tmp = buffer_screen;
+        uint16_t *buffer_screen_tmp = buffer_screen;
         buffer_screen = buffer_ready;
         buffer_ready = buffer_screen_tmp;
 
-        *lcd_base = (unsigned) buffer_screen;
+        *lcd_base = (uint32_t) buffer_screen;
         buffer_swap_ready = false;
     }
 }
 
 void GRAPHICS::buffer_swap_render()
 {
-    unsigned short *buffer_ready_tmp = buffer_ready;
+    uint16_t *buffer_ready_tmp = buffer_ready;
     buffer_ready = buffer_render;
     buffer_render = buffer_ready_tmp;
     buffer_swap_ready = true;
 }
 
-void GRAPHICS::buffer_fill(unsigned color)
+void GRAPHICS::buffer_fill(uint16_t color)
 {
-    unsigned *buffer_render_32 = (unsigned *) buffer_render;
-    color |= color << 16; // To avoid stupid overflows
-    for (unsigned i = 0; i < (BUFFER_SIZE / 4); i++)
-        buffer_render_32[i] = color;
+    uint32_t *buffer_render_32 = (uint32_t *) buffer_render;
+    uint32_t color_32 = color << 16 | color; // To avoid stupid overflows
+    for (uint32_t i = 0; i < (BUFFER_SIZE / 4); i++)
+        buffer_render_32[i] = color_32;
 }
 
 
@@ -114,15 +113,15 @@ void GRAPHICS::vsync_isr()
  * Drawing
  */
 
-void GRAPHICS::draw_pixel(unsigned x, unsigned y, unsigned short color)
+void GRAPHICS::draw_pixel(int x, int y, uint16_t color)
 {
     buffer_render[x + (y * 320)] = color;
 }
 
-void GRAPHICS::draw_sprite_sheet(const unsigned short *sheet, int x, int y,
+void GRAPHICS::draw_sprite_sheet(const uint16_t *sheet, int x, int y,
                                  const WalrusRPG::Utils::Rect &window)
 {
-    unsigned short color;
+    uint16_t color;
     int w = min(window.width + x, 320);
     int h = min(window.height + y, 240);
 
@@ -142,8 +141,7 @@ void GRAPHICS::draw_sprite_sheet(const unsigned short *sheet, int x, int y,
  * Sprite manipulation
  */
 
-unsigned short GRAPHICS::sprite_pixel_get(const unsigned short *sprite, unsigned x,
-                                          unsigned y)
+uint16_t GRAPHICS::sprite_pixel_get(const uint16_t *sprite, uint32_t x, uint32_t y)
 {
     if (x < sprite[0] && y < sprite[1])
         return sprite[x + (y * sprite[0]) + 3];

src/drivers/Graphics.h

@@ -1,6 +1,7 @@
 #ifndef INCLUDE_GRAPHICS_H
 #define INCLUDE_GRAPHICS_H
 
+#include <cstdint>
 #include "utility/Rect.h"
 
 namespace WalrusRPG
@@ -15,7 +16,7 @@ namespace WalrusRPG
         void buffer_free();
         void buffer_swap_screen();
         void buffer_swap_render();
-        void buffer_fill(unsigned color);
+        void buffer_fill(uint16_t color);
 
 
         /*
@@ -30,8 +31,8 @@ namespace WalrusRPG
          * Drawing
          */
 
-        void draw_pixel(unsigned x, unsigned y, unsigned short color);
-        void draw_sprite_sheet(const unsigned short *sheet, int x, int y,
+        void draw_pixel(int x, int y, uint16_t color);
+        void draw_sprite_sheet(const uint16_t *sheet, int x, int y,
                                const WalrusRPG::Utils::Rect &window);
 
 
@@ -39,8 +40,7 @@ namespace WalrusRPG
          * Sprite manipulation
          */
 
-        unsigned short sprite_pixel_get(const unsigned short *sprite, unsigned x,
-                                        unsigned y);
+        uint16_t sprite_pixel_get(const uint16_t *sprite, uint32_t x, uint32_t y);
     }
 }
 

src/drivers/Interrupts.cpp

@@ -4,15 +4,15 @@
 #define INTERRUPTS WalrusRPG::Interrupts
 
 #define INTERRUPT_CONTROLLER 0xDC000000
-volatile unsigned *irq_status = (unsigned *) (INTERRUPT_CONTROLLER + 0x0);
-volatile unsigned *interrupt_select = (unsigned *) (INTERRUPT_CONTROLLER + 0xC);
-unsigned interrupt_select_bkp;
-volatile unsigned *interrupt_enable = (unsigned *) (INTERRUPT_CONTROLLER + 0x10);
-volatile unsigned *interrupt_enable_clear = (unsigned *) (INTERRUPT_CONTROLLER + 0x14);
-unsigned interrupt_enable_bkp;
+volatile uint32_t *irq_status = (uint32_t *) (INTERRUPT_CONTROLLER + 0x0);
+volatile uint32_t *interrupt_select = (uint32_t *) (INTERRUPT_CONTROLLER + 0xC);
+uint32_t interrupt_select_bkp;
+volatile uint32_t *interrupt_enable = (uint32_t *) (INTERRUPT_CONTROLLER + 0x10);
+volatile uint32_t *interrupt_enable_clear = (uint32_t *) (INTERRUPT_CONTROLLER + 0x14);
+uint32_t interrupt_enable_bkp;
 
-volatile unsigned *interrupt_pointer = (unsigned *) 0x38;
-unsigned interrupt_pointer_bkp;
+volatile uint32_t *interrupt_pointer = (uint32_t *) 0x38;
+uint32_t interrupt_pointer_bkp;
 
 // Interrupt source 21 is the LCD
 #define INTERRUPT_MASK (1 << 21)
@@ -27,7 +27,7 @@ void INTERRUPTS::init()
     *interrupt_enable_clear = ~(INTERRUPT_MASK);
 
     interrupt_pointer_bkp = *interrupt_pointer;
-    *interrupt_pointer = (unsigned) &isr;
+    *interrupt_pointer = (uint32_t) &isr;
 
     // Enable IRQ in the CPU
     asm("mrs r1, cpsr \n\t"

src/drivers/Timers.cpp

@@ -2,20 +2,20 @@
 #include "Timers.h"
 
 #define TIMER 0x900D0000
-volatile unsigned *timer_ctl = (unsigned *) (TIMER + 0x08);
-volatile unsigned *timer_load = (unsigned *) (TIMER);
-volatile unsigned *timer_value = (unsigned *) (TIMER + 0x04);
-unsigned timer_ctl_bkp[2], timer_load_bkp[2];
+volatile uint32_t *timer_ctl = (uint32_t *) (TIMER + 0x08);
+volatile uint32_t *timer_load = (uint32_t *) (TIMER);
+volatile uint32_t *timer_value = (uint32_t *) (TIMER + 0x04);
+uint32_t timer_ctl_bkp[2], timer_load_bkp[2];
 
 #define TIMERS WalrusRPG::Timers
 
-void TIMERS::init(unsigned timer)
+void TIMERS::init(uint32_t timer)
 {
     timer_ctl_bkp[timer] = timer_ctl[8 * timer];
     timer_load_bkp[timer] = timer_load[8 * timer];
 }
 
-void TIMERS::restore(unsigned timer)
+void TIMERS::restore(uint32_t timer)
 {
     timer_ctl[8 * timer] &= ~(1 << 7);
     timer_ctl[8 * timer] = timer_ctl_bkp[timer] & ~(1 << 7);
@@ -23,10 +23,10 @@ void TIMERS::restore(unsigned timer)
     timer_ctl[8 * timer] = timer_ctl_bkp[timer];
 }
 
-void TIMERS::mode(unsigned timer, bool free_run, bool oneshot, bool interrupt,
-                  unsigned div, bool full_width_counter)
+void TIMERS::mode(uint32_t timer, bool free_run, bool oneshot, bool interrupt,
+                  uint32_t div, bool full_width_counter)
 {
-    unsigned mode = 0;
+    uint32_t mode = 0;
 
     if (!free_run)
         mode |= (1 << 6);
@@ -56,12 +56,12 @@ void TIMERS::mode(unsigned timer, bool free_run, bool oneshot, bool interrupt,
     timer_ctl[8 * timer] |= (1 << 7);
 }
 
-void TIMERS::load(unsigned timer, unsigned value)
+void TIMERS::load(uint32_t timer, uint32_t value)
 {
     timer_load[8 * timer] = value;
 }
 
-unsigned TIMERS::read(unsigned timer)
+uint32_t TIMERS::read(uint32_t timer)
 {
     return timer_value[8 * timer];
 }

src/drivers/Timers.h

@@ -1,16 +1,18 @@
 #ifndef INCLUDE_TIMERS_H
 #define INCLUDE_TIMERS_H
 
+#include <cstdint>
+
 namespace WalrusRPG
 {
     namespace Timers
     {
-        void init(unsigned timer);
-        void restore(unsigned timer);
-        void mode(unsigned timer, bool free_run, bool oneshot, bool interrupt,
-                  unsigned div, bool full_width_counter);
-        void load(unsigned timer, unsigned value);
-        unsigned read(unsigned timer);
+        void init(uint32_t timer);
+        void restore(uint32_t timer);
+        void mode(uint32_t timer, bool free_run, bool oneshot, bool interrupt,
+                  uint32_t div, bool full_width_counter);
+        void load(uint32_t timer, uint32_t value);
+        uint32_t read(uint32_t timer);
     }
 }