Apply formatting

Author: renzenicolai

bsp/audio.h

@@ -1,9 +1,8 @@
 #pragma once
 
-#include "esp_err.h"
-
 #include <stdbool.h>
 #include <stdint.h>
+#include "esp_err.h"
 
 // Badge BSP
 // Audio APIs
@@ -14,7 +13,7 @@ esp_err_t bsp_audio_initialize(void);
 
 /// @brief BSP audio get volume
 /// @return ESP-IDF error code
-esp_err_t bsp_audio_get_volume(float *out_percentage);
+esp_err_t bsp_audio_get_volume(float* out_percentage);
 
 /// @brief BSP audio set volume
 /// @return ESP-IDF error code

bsp/battery.h

@@ -9,8 +9,8 @@
 
 /// @brief Get whether or not the battery is charging
 /// @return ESP-IDF error code
-esp_err_t bsp_battery_is_charging(bool *charging);
+esp_err_t bsp_battery_is_charging(bool* charging);
 
 /// @brief Get the battery voltage in mV
 /// @return ESP-IDF error code
-esp_err_t bsp_battery_get_voltage(uint16_t *bat_mv);
+esp_err_t bsp_battery_get_voltage(uint16_t* bat_mv);

bsp/device.h

@@ -1,9 +1,8 @@
 #pragma once
 
-#include "esp_err.h"
-
 #include <stdbool.h>
 #include <stdint.h>
+#include "esp_err.h"
 
 // Badge BSP
 // Device related APIs
@@ -22,7 +21,7 @@ esp_err_t bsp_device_initialize(void);
 /// @return ESP-IDF error code
 ///          - ESP_OK if the output string fits in the buffer
 ///          - ESP_ERR_INVALID_ARG if the output pointer is NULL
-esp_err_t bsp_device_get_name(char *output, uint8_t buffer_length);
+esp_err_t bsp_device_get_name(char* output, uint8_t buffer_length);
 
 /// @brief Get the name of the manufacturer as a string
 /// @details Returns the name as a null terminated string
@@ -31,7 +30,7 @@ esp_err_t bsp_device_get_name(char *output, uint8_t buffer_length);
 /// @return ESP-IDF error code
 ///          - ESP_OK if the output string fits in the buffer
 ///          - ESP_ERR_INVALID_ARG if the output pointer is NULL
-esp_err_t bsp_device_get_manufacturer(char *output, uint8_t buffer_length);
+esp_err_t bsp_device_get_manufacturer(char* output, uint8_t buffer_length);
 
 /// @brief Initialized without coprocessor status flag
 /// @return Boolean, true when initialized without coprocessor available

bsp/display.h

@@ -1,10 +1,9 @@
 #pragma once
 
-#include "esp_err.h"
-#include "esp_lcd_types.h"
-
 #include <stdbool.h>
 #include <stdint.h>
+#include "esp_err.h"
+#include "esp_lcd_types.h"
 
 // Badge BSP
 // Display related APIs
@@ -18,7 +17,6 @@ typedef enum {
     BSP_DISPLAY_ROTATION_270,
 } bsp_display_rotation_t;
 
-
 /// @brief Initialize the display
 /// @details Initialize the display
 /// @return ESP-IDF error code
@@ -31,29 +29,29 @@ esp_err_t bsp_display_initialize(void);
 /// @return ESP-IDF error code
 ///          - ESP_OK if succesful
 ///          - ESP_FAIL if not initialized
-esp_err_t bsp_display_get_parameters(size_t *h_res, size_t *v_res, lcd_color_rgb_pixel_format_t *color_fmt);
+esp_err_t bsp_display_get_parameters(size_t* h_res, size_t* v_res, lcd_color_rgb_pixel_format_t* color_fmt);
 
 /// @brief Get display panel
 /// @details Get display panel
 /// @return ESP-IDF error code
 ///          - ESP_OK if succesful
 ///          - ESP_FAIL if not initialized
-esp_err_t bsp_display_get_panel(esp_lcd_panel_handle_t *panel);
+esp_err_t bsp_display_get_panel(esp_lcd_panel_handle_t* panel);
 
 /// @brief Get display panel IO
 /// @details Get display panel IO
 /// @return ESP-IDF error code
 ///          - ESP_OK if succesful
 ///          - ESP_FAIL if not initialized
-esp_err_t bsp_display_get_panel_io(esp_lcd_panel_io_handle_t *io);
+esp_err_t bsp_display_get_panel_io(esp_lcd_panel_io_handle_t* io);
 
 /// @brief Get the default display rotation
 /// @return The default display rotation
 bsp_display_rotation_t bsp_display_get_default_rotation();
 
 /// @brief Get display brightness
 /// @return ESP-IDF error code
-esp_err_t bsp_display_get_backlight_brightness(uint8_t *out_percentage);
+esp_err_t bsp_display_get_backlight_brightness(uint8_t* out_percentage);
 
 /// @brief Set display brightness
 /// @return ESP-IDF error code

bsp/i2c.h

@@ -1,13 +1,12 @@
 #pragma once
 
+#include <stdbool.h>
+#include <stdint.h>
 #include "driver/i2c_master.h"
 #include "esp_err.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/semphr.h"
 
-#include <stdbool.h>
-#include <stdint.h>
-
 // Badge BSP
 // I2C APIs
 
@@ -17,11 +16,11 @@ esp_err_t bsp_i2c_primary_bus_initialize(void);
 
 /// @brief Get the primary I2C bus handle
 /// @return ESP-IDF error code
-esp_err_t bsp_i2c_primary_bus_get_handle(i2c_master_bus_handle_t *handle);
+esp_err_t bsp_i2c_primary_bus_get_handle(i2c_master_bus_handle_t* handle);
 
 /// @brief Get the primary I2C bus concurrency semaphore handle
 /// @return ESP-IDF error code
-esp_err_t bsp_i2c_primary_bus_get_semaphore(SemaphoreHandle_t *semaphore);
+esp_err_t bsp_i2c_primary_bus_get_semaphore(SemaphoreHandle_t* semaphore);
 
 /// @brief Claim private access to the primary I2C bus
 /// @return ESP-IDF error code

bsp/input.h

@@ -1,12 +1,11 @@
 #pragma once
 
+#include <stdbool.h>
+#include <stdint.h>
 #include "esp_err.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/queue.h"
 
-#include <stdbool.h>
-#include <stdint.h>
-
 typedef enum _bsp_input_event_type {
     INPUT_EVENT_TYPE_NONE       = 0,
     INPUT_EVENT_TYPE_NAVIGATION = 1,
@@ -34,7 +33,6 @@ typedef enum _bsp_input_navigation_key {
     BSP_INPUT_NAVIGATION_KEY_TAB,
     BSP_INPUT_NAVIGATION_KEY_BACKSPACE,
 
-
     // Function keys
     BSP_INPUT_NAVIGATION_KEY_F1,
     BSP_INPUT_NAVIGATION_KEY_F2,
@@ -92,7 +90,7 @@ typedef struct _bsp_input_event_args_navigation {
 
 typedef struct _bsp_input_event_args_keyboard {
     char        ascii;
-    char const *utf8;
+    char const* utf8;
     uint32_t    modifiers;
 } bsp_input_event_args_keyboard_t;
 
@@ -116,15 +114,15 @@ esp_err_t bsp_input_initialize(void);
 
 /// @brief Get the queue handle for the input event queue
 /// @return ESP-IDF error code
-esp_err_t bsp_input_get_queue(QueueHandle_t *out_queue);
+esp_err_t bsp_input_get_queue(QueueHandle_t* out_queue);
 
 /// @brief Get whether or not the device needs an on-screen keyboard
 /// @return true if the device needs an on-screen keyboard and false if it does not
 bool needs_on_screen_keyboard();
 
 /// @brief Get keyboard backlight brightness
 /// @return ESP-IDF error code
-esp_err_t bsp_input_get_backlight_brightness(uint8_t *out_percentage);
+esp_err_t bsp_input_get_backlight_brightness(uint8_t* out_percentage);
 
 /// @brief Set keyboard backlight brightness
 /// @return ESP-IDF error code

bsp/led.h

@@ -1,9 +1,8 @@
 #pragma once
 
-#include "esp_err.h"
-
 #include <stdbool.h>
 #include <stdint.h>
+#include "esp_err.h"
 
 // Badge BSP
 // LED APIs
@@ -14,4 +13,4 @@ esp_err_t bsp_led_initialize(void);
 
 /// @brief Write data to LEDs
 /// @return ESP-IDF error code
-esp_err_t bsp_led_write(uint8_t *data, uint32_t length);
+esp_err_t bsp_led_write(uint8_t* data, uint32_t length);

bsp/mch2022.h

@@ -9,11 +9,11 @@
 
 /// @brief Get coprocessor handle
 /// @return ESP-IDF error code
-esp_err_t bsp_mch2022_coprocessor_get_handle(RP2040 *handle);
+esp_err_t bsp_mch2022_coprocessor_get_handle(RP2040* handle);
 
 /// @brief Get coprocessor input queue
 /// @return ESP-IDF error code
-esp_err_t bsp_mch2022_coprocessor_get_queue(QueueHandle_t *queue);
+esp_err_t bsp_mch2022_coprocessor_get_queue(QueueHandle_t* queue);
 
 /// @brief Coprocessor input callback
 void bsp_mch2022_coprocessor_input_callback(rp2040_input_t input, bool state);

bsp/power.h

@@ -1,9 +1,8 @@
 #pragma once
 
-#include "esp_err.h"
-
 #include <stdbool.h>
 #include <stdint.h>
+#include "esp_err.h"
 
 typedef enum {
     BSP_POWER_CHARGING_FAULT_NONE        = 0,
@@ -13,16 +12,16 @@ typedef enum {
 } bsp_power_charging_fault_t;
 
 typedef struct _bsp_power_battery_information {
-    char const *type;                     // Battery type (string)
-    bool        power_supply_available;   // Is a power supply attached
-    bool        battery_available;        // Is a battery installed
-    bool        charging_disabled;        // Is battery charging disabled
-    bool        battery_charging;         // Is the battery being charged
-    uint16_t    maximum_charging_current; // Maximum charging current (mA)
-    uint16_t    current_charging_current; // Maximum charging current (mA)
-    uint16_t    voltage;                  // Current battery voltage
-    uint16_t    charging_target_voltage;  // Target voltage when full
-    double      remaining_percentage;     // Remaining capacity (%)
+    char const* type;                      // Battery type (string)
+    bool        power_supply_available;    // Is a power supply attached
+    bool        battery_available;         // Is a battery installed
+    bool        charging_disabled;         // Is battery charging disabled
+    bool        battery_charging;          // Is the battery being charged
+    uint16_t    maximum_charging_current;  // Maximum charging current (mA)
+    uint16_t    current_charging_current;  // Maximum charging current (mA)
+    uint16_t    voltage;                   // Current battery voltage
+    uint16_t    charging_target_voltage;   // Target voltage when full
+    double      remaining_percentage;      // Remaining capacity (%)
 } bsp_power_battery_information_t;
 
 typedef enum {
@@ -37,39 +36,39 @@ esp_err_t bsp_power_initialize(void);
 
 /// @brief Get battery information
 /// @return ESP-IDF error code
-esp_err_t bsp_power_get_battery_information(bsp_power_battery_information_t *out_information);
+esp_err_t bsp_power_get_battery_information(bsp_power_battery_information_t* out_information);
 
 /// @brief Get battery voltage
 /// @return ESP-IDF error code
-esp_err_t bsp_power_get_battery_voltage(uint16_t *out_millivolt);
+esp_err_t bsp_power_get_battery_voltage(uint16_t* out_millivolt);
 
 /// @brief Get system voltage
 /// @return ESP-IDF error code
-esp_err_t bsp_power_get_system_voltage(uint16_t *out_millivolt);
+esp_err_t bsp_power_get_system_voltage(uint16_t* out_millivolt);
 
 /// @brief Get charger input voltage
 /// @return ESP-IDF error code
-esp_err_t bsp_power_get_input_voltage(uint16_t *out_millivolt);
+esp_err_t bsp_power_get_input_voltage(uint16_t* out_millivolt);
 
 /// @brief Get battery charger configuration
 /// @return ESP-IDF error code
-esp_err_t bsp_power_get_charging_configuration(bool *out_disabled, uint16_t *out_current);
+esp_err_t bsp_power_get_charging_configuration(bool* out_disabled, uint16_t* out_current);
 
 /// @brief Configure battery charger
 /// @return ESP-IDF error code
 esp_err_t bsp_power_configure_charging(bool disable, uint16_t current);
 
 /// @brief Get USB host port boost enabled
 /// @return ESP-IDF error code
-esp_err_t bsp_power_get_usb_host_boost_enabled(bool *out_enabled);
+esp_err_t bsp_power_get_usb_host_boost_enabled(bool* out_enabled);
 
 /// @brief Set USB host port boost enabled
 /// @return ESP-IDF error code
 esp_err_t bsp_power_set_usb_host_boost_enabled(bool enable);
 
 /// @brief Get radio enabled
 /// @return ESP-IDF error code
-esp_err_t bsp_power_get_radio_state(bsp_radio_state_t *out_state);
+esp_err_t bsp_power_get_radio_state(bsp_radio_state_t* out_state);
 
 /// @brief Set radio enabled
 /// @return ESP-IDF error code

bsp/rtc.h

@@ -1,16 +1,15 @@
 #pragma once
 
-#include "esp_err.h"
-
 #include <stdbool.h>
 #include <stdint.h>
+#include "esp_err.h"
 
 // Badge BSP
 // Real Time Clock APIs
 
 /// @brief Get time
 /// @return ESP-IDF error code
-esp_err_t bsp_rtc_get_time(uint32_t *value);
+esp_err_t bsp_rtc_get_time(uint32_t* value);
 
 /// @brief Set time
 /// @return ESP-IDF error code
@@ -22,7 +21,7 @@ esp_err_t bsp_rtc_update_time(void);
 
 /// @brief Get alarm
 /// @return ESP-IDF error code
-esp_err_t bsp_rtc_get_alarm(uint32_t *value);
+esp_err_t bsp_rtc_get_alarm(uint32_t* value);
 
 /// @brief Set alarm
 /// @return ESP-IDF error code