From 4ef7b83e34548e9e66a6b8b5a654672462beac0a Mon Sep 17 00:00:00 2001 From: Michael Scire Date: Fri, 3 May 2019 06:20:50 -0700 Subject: [PATCH] boot: implement ConfigurePinmux --- stratosphere/boot/source/boot_functions.hpp | 12 + stratosphere/boot/source/boot_gpio_utils.cpp | 36 +- stratosphere/boot/source/boot_main.cpp | 42 +- .../boot/source/boot_pinmux_configuration.cpp | 90 ++++ ...ot_pinmux_initial_configuration_copper.hpp | 186 +++++++ ...boot_pinmux_initial_configuration_hoag.hpp | 186 +++++++ ...oot_pinmux_initial_configuration_icosa.hpp | 186 +++++++ ...boot_pinmux_initial_configuration_iowa.hpp | 199 +++++++ ...pinmux_initial_drive_pad_configuration.hpp | 72 +++ stratosphere/boot/source/boot_pinmux_map.hpp | 364 +++++++++++++ .../boot/source/boot_pinmux_utils.cpp | 487 ++++++++++++++++++ stratosphere/boot/source/boot_types.hpp | 6 + 12 files changed, 1829 insertions(+), 37 deletions(-) create mode 100644 stratosphere/boot/source/boot_pinmux_configuration.cpp create mode 100644 stratosphere/boot/source/boot_pinmux_initial_configuration_copper.hpp create mode 100644 stratosphere/boot/source/boot_pinmux_initial_configuration_hoag.hpp create mode 100644 stratosphere/boot/source/boot_pinmux_initial_configuration_icosa.hpp create mode 100644 stratosphere/boot/source/boot_pinmux_initial_configuration_iowa.hpp create mode 100644 stratosphere/boot/source/boot_pinmux_initial_drive_pad_configuration.hpp create mode 100644 stratosphere/boot/source/boot_pinmux_map.hpp create mode 100644 stratosphere/boot/source/boot_pinmux_utils.cpp diff --git a/stratosphere/boot/source/boot_functions.hpp b/stratosphere/boot/source/boot_functions.hpp index c48d64e2d..5d88663fa 100644 --- a/stratosphere/boot/source/boot_functions.hpp +++ b/stratosphere/boot/source/boot_functions.hpp @@ -24,6 +24,7 @@ class Boot { public: static constexpr u32 GpioPhysicalBase = 0x6000D000; + static constexpr u32 ApbMiscPhysicalBase = 0x70000000; public: /* Functions for actually booting. */ static void ChangeGpioVoltageTo1_8v(); @@ -31,7 +32,11 @@ class Boot { static void CheckClock(); static void DetectBootReason(); static void ShowSplashScreen(); + static void CheckBatteryCharge(); static void SetInitialClockConfiguration(); + static void ConfigurePinmux(); + static void SetInitialWakePinConfiguration(); + static void CheckAndRepairBootImages(); /* Power utilities. */ static void RebootSystem(); @@ -46,6 +51,13 @@ class Boot { static u32 GpioSetDirection(u32 gpio_pad_name, GpioDirection dir); static u32 GpioSetValue(u32 gpio_pad_name, GpioValue val); + /* Pinmux Utilities. */ + static u32 PinmuxUpdatePark(u32 pinmux_name); + static u32 PinmuxUpdatePad(u32 pinmux_name, u32 config_val, u32 config_mask); + static u32 PinmuxUpdateDrivePad(u32 pinmux_drivepad_name, u32 config_val, u32 config_mask); + static void ConfigurePinmuxInitialPads(); + static void ConfigurePinmuxInitialDrivePads(); + /* SPL Utilities. */ static HardwareType GetHardwareType(); static u32 GetBootReason(); diff --git a/stratosphere/boot/source/boot_gpio_utils.cpp b/stratosphere/boot/source/boot_gpio_utils.cpp index 5c8cbaf39..d578ad0fc 100644 --- a/stratosphere/boot/source/boot_gpio_utils.cpp +++ b/stratosphere/boot/source/boot_gpio_utils.cpp @@ -13,7 +13,7 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - + #include "boot_functions.hpp" #include "boot_gpio_map.hpp" @@ -24,7 +24,7 @@ static inline u32 GetGpioPadDescriptor(u32 gpio_pad_name) { if (gpio_pad_name >= GpioPadNameMax) { std::abort(); } - + return GpioMap[gpio_pad_name]; } @@ -53,16 +53,16 @@ u32 Boot::GpioConfigure(u32 gpio_pad_name) { /* Convert the GPIO pad descriptor into its register offset */ u32 gpio_reg_offset = (((gpio_pad_desc << 0x03) & 0xFFFFFF00) | ((gpio_pad_desc >> 0x01) & 0x0C)); - + /* Extract the bit and lock values from the GPIO pad descriptor */ u32 gpio_cnf_val = ((0x01 << ((gpio_pad_desc & 0x07) | 0x08)) | (0x01 << (gpio_pad_desc & 0x07))); - + /* Write to the appropriate GPIO_CNF_x register (upper offset) */ *(reinterpret_cast(gpio_base_vaddr + gpio_reg_offset + 0x80)) = gpio_cnf_val; - + /* Do a dummy read from GPIO_CNF_x register (lower offset) */ gpio_cnf_val = *(reinterpret_cast(gpio_base_vaddr + gpio_reg_offset)); - + return gpio_cnf_val; } @@ -71,24 +71,24 @@ u32 Boot::GpioSetDirection(u32 gpio_pad_name, GpioDirection dir) { /* Fetch this GPIO's pad descriptor */ const u32 gpio_pad_desc = GetGpioPadDescriptor(gpio_pad_name); - + /* Discard invalid GPIOs */ if (gpio_pad_desc == GpioInvalid) { return GpioInvalid; } - + /* Convert the GPIO pad descriptor into its register offset */ u32 gpio_reg_offset = (((gpio_pad_desc << 0x03) & 0xFFFFFF00) | ((gpio_pad_desc >> 0x01) & 0x0C)); - + /* Set the direction bit and lock values */ u32 gpio_oe_val = ((0x01 << ((gpio_pad_desc & 0x07) | 0x08)) | (static_cast(dir) << (gpio_pad_desc & 0x07))); - + /* Write to the appropriate GPIO_OE_x register (upper offset) */ *(reinterpret_cast(gpio_base_vaddr + gpio_reg_offset + 0x90)) = gpio_oe_val; - + /* Do a dummy read from GPIO_OE_x register (lower offset) */ gpio_oe_val = *(reinterpret_cast(gpio_base_vaddr + gpio_reg_offset)); - + return gpio_oe_val; } @@ -97,23 +97,23 @@ u32 Boot::GpioSetValue(u32 gpio_pad_name, GpioValue val) { /* Fetch this GPIO's pad descriptor */ const u32 gpio_pad_desc = GetGpioPadDescriptor(gpio_pad_name); - + /* Discard invalid GPIOs */ if (gpio_pad_desc == GpioInvalid) { return GpioInvalid; } - + /* Convert the GPIO pad descriptor into its register offset */ u32 gpio_reg_offset = (((gpio_pad_desc << 0x03) & 0xFFFFFF00) | ((gpio_pad_desc >> 0x01) & 0x0C)); - + /* Set the output bit and lock values */ u32 gpio_out_val = ((0x01 << ((gpio_pad_desc & 0x07) | 0x08)) | (static_cast(val) << (gpio_pad_desc & 0x07))); - + /* Write to the appropriate GPIO_OUT_x register (upper offset) */ *(reinterpret_cast(gpio_base_vaddr + gpio_reg_offset + 0xA0)) = gpio_out_val; - + /* Do a dummy read from GPIO_OUT_x register (lower offset) */ gpio_out_val = *(reinterpret_cast(gpio_base_vaddr + gpio_reg_offset)); - + return gpio_out_val; } diff --git a/stratosphere/boot/source/boot_main.cpp b/stratosphere/boot/source/boot_main.cpp index 83d64b829..c1746f687 100644 --- a/stratosphere/boot/source/boot_main.cpp +++ b/stratosphere/boot/source/boot_main.cpp @@ -13,7 +13,7 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - + #include #include #include @@ -34,7 +34,7 @@ extern "C" { #define INNER_HEAP_SIZE 0x200000 size_t nx_inner_heap_size = INNER_HEAP_SIZE; char nx_inner_heap[INNER_HEAP_SIZE]; - + void __libnx_initheap(void); void __appInit(void); void __appExit(void); @@ -70,7 +70,7 @@ void __libnx_initheap(void) { void __appInit(void) { Result rc; - + SetFirmwareVersionForLibnx(); /* Initialize services we need (TODO: NCM) */ @@ -79,25 +79,25 @@ void __appInit(void) { if (R_FAILED(rc)) { std::abort(); } - + rc = splInitialize(); if (R_FAILED(rc)) { std::abort(); } - + rc = pmshellInitialize(); if (R_FAILED(rc)) { std::abort(); } }); - + CheckAtmosphereVersion(CURRENT_ATMOSPHERE_VERSION); } void __appExit(void) { /* Cleanup services. */ fsdevUnmountAll(); - pmshellExit(); + pmshellExit(); splExit(); fsExit(); } @@ -105,36 +105,40 @@ void __appExit(void) { int main(int argc, char **argv) { consoleDebugInit(debugDevice_SVC); - + /* TODO: Implement the boot sysmodule -- boot_old to be broadly rewritten. */ /* Change voltage from 3.3v to 1.8v for select devices. */ Boot::ChangeGpioVoltageTo1_8v(); - + /* Setup GPIO. */ Boot::SetInitialGpioConfiguration(); - + /* Check USB PLL/UTMIP clock. */ Boot::CheckClock(); - + /* Talk to PMIC/RTC, set boot reason with SPL. */ Boot::DetectBootReason(); - + /* Display splash screen for two seconds. */ Boot::ShowSplashScreen(); - - /* TODO: ConfigurePinmux(); */ - + + /* Check that the battery has enough to boot. */ + /* TODO: Boot::CheckBatteryCharge(); */ + + /* Configure pinmux + drive pads. */ + Boot::ConfigurePinmux(); + /* TODO: SetInitialWakePinConfiguration(); */ - + Boot::SetInitialClockConfiguration(); - + /* TODO: CheckAndRepairBootImages(); */ - + /* Tell PM to start boot2. */ if (R_FAILED(pmshellNotifyBootFinished())) { std::abort(); } - + return 0; } diff --git a/stratosphere/boot/source/boot_pinmux_configuration.cpp b/stratosphere/boot/source/boot_pinmux_configuration.cpp new file mode 100644 index 000000000..6ee7da492 --- /dev/null +++ b/stratosphere/boot/source/boot_pinmux_configuration.cpp @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2018-2019 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope 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, see . + */ + +#include "boot_functions.hpp" +#include "boot_pinmux_map.hpp" +#include "boot_pinmux_initial_configuration_icosa.hpp" +#include "boot_pinmux_initial_configuration_copper.hpp" +#include "boot_pinmux_initial_configuration_hoag.hpp" +#include "boot_pinmux_initial_configuration_iowa.hpp" +#include "boot_pinmux_initial_drive_pad_configuration.hpp" + +void Boot::ConfigurePinmux() { + /* Update parks. */ + for (size_t i = 0; i < PinmuxPadNameMax; i++) { + Boot::PinmuxUpdatePark(static_cast(i)); + } + + /* Set initial pad configs. */ + Boot::ConfigurePinmuxInitialPads(); + + /* Set initial drive pad configs. */ + Boot::ConfigurePinmuxInitialDrivePads(); +} + +void Boot::ConfigurePinmuxInitialPads() { + const PinmuxInitialConfig *configs = nullptr; + size_t num_configs = 0; + const HardwareType hw_type = Boot::GetHardwareType(); + + switch (hw_type) { + case HardwareType_Icosa: + configs = PinmuxInitialConfigsIcosa; + num_configs = PinmuxNumInitialConfigsIcosa; + break; + case HardwareType_Copper: + configs = PinmuxInitialConfigsCopper; + num_configs = PinmuxNumInitialConfigsCopper; + break; + case HardwareType_Hoag: + configs = PinmuxInitialConfigsHoag; + num_configs = PinmuxNumInitialConfigsHoag; + break; + case HardwareType_Iowa: + configs = PinmuxInitialConfigsIowa; + num_configs = PinmuxNumInitialConfigsIowa; + break; + default: + /* Unknown hardware type, we can't proceed. */ + std::abort(); + } + + /* Ensure we found an appropriate config. */ + if (configs == nullptr) { + std::abort(); + } + + for (size_t i = 0; i < num_configs - 1; i++) { + Boot::PinmuxUpdatePad(configs[i].name, configs[i].val, configs[i].mask); + } + + /* Extra configs for iowa only. */ + if (hw_type == HardwareType_Iowa) { + static constexpr u32 ExtraIowaPinmuxPadNames[] = { + 0xAA, 0xAC, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9 + }; + for (size_t i = 0; i < sizeof(ExtraIowaPinmuxPadNames) / sizeof(ExtraIowaPinmuxPadNames[0]); i++) { + Boot::PinmuxUpdatePad(ExtraIowaPinmuxPadNames[i], 0x2000, 0x2000); + } + } +} + +void Boot::ConfigurePinmuxInitialDrivePads() { + const PinmuxInitialConfig *configs = PinmuxInitialDrivePadConfigs; + for (size_t i = 0; i < PinmuxNumInitialDrivePadConfigs; i++) { + Boot::PinmuxUpdateDrivePad(configs[i].name, configs[i].val, configs[i].mask); + } +} diff --git a/stratosphere/boot/source/boot_pinmux_initial_configuration_copper.hpp b/stratosphere/boot/source/boot_pinmux_initial_configuration_copper.hpp new file mode 100644 index 000000000..34bf26aba --- /dev/null +++ b/stratosphere/boot/source/boot_pinmux_initial_configuration_copper.hpp @@ -0,0 +1,186 @@ +/* + * Copyright (c) 2018-2019 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope 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, see . + */ + +#pragma once +#include + +#include "boot_types.hpp" + +static constexpr PinmuxInitialConfig PinmuxInitialConfigsCopper[] = { + {0x10, 0x20, 0x27F}, + {0x0F, 0x00, 0x267}, + {0x0E, 0x20, 0x27F}, + {0x5B, 0x00, 0x00}, + {0x80, 0x01, 0x7F}, + {0x34, 0x40, 0x267}, + {0x35, 0x40, 0x267}, + {0x55, 0x00, 0x18}, + {0x56, 0x01, 0x67}, + {0x5C, 0x00, 0x00}, + {0x59, 0x00, 0x00}, + {0x5A, 0x10, 0x18}, + {0x2C, 0x40, 0x267}, + {0x2D, 0x40, 0x267}, + {0x2E, 0x40, 0x267}, + {0x2F, 0x40, 0x267}, + {0x36, 0x00, 0x67}, + {0x37, 0x30, 0x7F}, + {0x38, 0x00, 0x67}, + {0x39, 0x28, 0x7F}, + {0x54, 0x00, 0x67}, + {0x9B, 0x30, 0x7F}, + {0x42, 0x00, 0x67}, + {0x43, 0x28, 0x7F}, + {0x44, 0x00, 0x67}, + {0x45, 0x28, 0x7F}, + {0x4B, 0x28, 0x7F}, + {0x4C, 0x00, 0x67}, + {0x4A, 0x00, 0x67}, + {0x4D, 0x00, 0x67}, + {0x64, 0x20, 0x27F}, + {0x63, 0x40, 0x267}, + {0x5E, 0x04, 0x67}, + {0x60, 0x04, 0x67}, + {0x17, 0x24, 0x7F}, + {0x18, 0x24, 0x7F}, + {0x27, 0x04, 0x67}, + {0x2A, 0x04, 0x67}, + {0x2B, 0x04, 0x67}, + {0x90, 0x24, 0x7F}, + {0x32, 0x24, 0x27F}, + {0x33, 0x34, 0x27F}, + {0x76, 0x04, 0x67}, + {0x79, 0x04, 0x67}, + {0x08, 0x24, 0x7F}, + {0x09, 0x24, 0x7F}, + {0x0A, 0x24, 0x7F}, + {0x0B, 0x24, 0x7F}, + {0x88, 0x34, 0x7F}, + {0x89, 0x24, 0x7F}, + {0x8A, 0x34, 0x7F}, + {0x8B, 0x34, 0x7F}, + {0x8D, 0x34, 0x7F}, + {0x81, 0x04, 0x67}, + {0x9D, 0x34, 0x7F}, + {0x9F, 0x34, 0x7F}, + {0xA1, 0x34, 0x7F}, + {0x92, 0x4C, 0x7F}, + {0x93, 0x4C, 0x7F}, + {0x94, 0x44, 0x7F}, + {0x96, 0x34, 0x7F}, + {0x98, 0x34, 0x7F}, + {0x99, 0x34, 0x7F}, + {0x12, 0x04, 0x7F}, + {0x13, 0x04, 0x67}, + {0x14, 0x04, 0x7F}, + {0x6A, 0x04, 0x67}, + {0x6B, 0x04, 0x67}, + {0x6C, 0x2C, 0x7F}, + {0x6D, 0x04, 0x67}, + {0x6E, 0x04, 0x67}, + {0x6F, 0x24, 0x7F}, + {0x70, 0x04, 0x7F}, + {0x73, 0x04, 0x67}, + {0x69, 0x24, 0x7F}, + {0x5D, 0x05, 0x07}, + {0x5F, 0x05, 0x07}, + {0x61, 0x05, 0x07}, + {0x47, 0x05, 0x07}, + {0x48, 0x05, 0x07}, + {0x46, 0x05, 0x07}, + {0x49, 0x05, 0x07}, + {0x19, 0x05, 0x07}, + {0x1A, 0x05, 0x07}, + {0x1B, 0x05, 0x07}, + {0x26, 0x05, 0x07}, + {0x28, 0x05, 0x07}, + {0x29, 0x05, 0x07}, + {0x8F, 0x05, 0x07}, + {0x30, 0x05, 0x07}, + {0x31, 0x05, 0x07}, + {0x52, 0x05, 0x07}, + {0x53, 0x05, 0x07}, + {0x75, 0x05, 0x07}, + {0x77, 0x05, 0x07}, + {0x78, 0x05, 0x07}, + {0x7A, 0x05, 0x07}, + {0x0D, 0x05, 0x07}, + {0x0C, 0x05, 0x07}, + {0x11, 0x05, 0x07}, + {0x8E, 0x05, 0x07}, + {0x00, 0x05, 0x07}, + {0x01, 0x05, 0x07}, + {0x05, 0x05, 0x07}, + {0x04, 0x05, 0x07}, + {0x03, 0x05, 0x07}, + {0x02, 0x05, 0x07}, + {0x06, 0x05, 0x07}, + {0x07, 0x05, 0x07}, + {0x87, 0x05, 0x07}, + {0x86, 0x05, 0x07}, + {0x82, 0x05, 0x07}, + {0x83, 0x05, 0x07}, + {0x85, 0x05, 0x07}, + {0x84, 0x05, 0x07}, + {0x8C, 0x05, 0x07}, + {0x7B, 0x05, 0x07}, + {0x7C, 0x05, 0x07}, + {0x7D, 0x05, 0x07}, + {0x7E, 0x05, 0x07}, + {0x7F, 0x05, 0x07}, + {0x9C, 0x05, 0x07}, + {0x9E, 0x05, 0x07}, + {0xA0, 0x05, 0x07}, + {0x58, 0x00, 0x00}, + {0x4F, 0x05, 0x07}, + {0x50, 0x05, 0x07}, + {0x4E, 0x05, 0x07}, + {0x51, 0x05, 0x07}, + {0x3A, 0x05, 0x07}, + {0x3B, 0x05, 0x07}, + {0x3C, 0x05, 0x07}, + {0x3D, 0x05, 0x07}, + {0x95, 0x05, 0x07}, + {0x97, 0x05, 0x07}, + {0x9A, 0x05, 0x07}, + {0x15, 0x05, 0x07}, + {0x16, 0x05, 0x07}, + {0x1C, 0x05, 0x07}, + {0x1D, 0x05, 0x07}, + {0x1E, 0x05, 0x07}, + {0x1F, 0x05, 0x07}, + {0x3E, 0x05, 0x07}, + {0x3F, 0x05, 0x07}, + {0x40, 0x05, 0x07}, + {0x41, 0x05, 0x07}, + {0x91, 0x05, 0x07}, + {0x71, 0x05, 0x07}, + {0x72, 0x05, 0x07}, + {0x74, 0x05, 0x07}, + {0x22, 0x05, 0x07}, + {0x23, 0x05, 0x07}, + {0x20, 0x05, 0x07}, + {0x21, 0x05, 0x07}, + {0x24, 0x05, 0x07}, + {0x25, 0x05, 0x07}, + {0x62, 0x05, 0x07}, + {0x65, 0x05, 0x07}, + {0x66, 0x05, 0x07}, + {0x67, 0x05, 0x07}, + {0x68, 0x05, 0x07}, +}; + +static constexpr u32 PinmuxNumInitialConfigsCopper = (sizeof(PinmuxInitialConfigsCopper) / sizeof(PinmuxInitialConfigsCopper[0])); diff --git a/stratosphere/boot/source/boot_pinmux_initial_configuration_hoag.hpp b/stratosphere/boot/source/boot_pinmux_initial_configuration_hoag.hpp new file mode 100644 index 000000000..27b800d31 --- /dev/null +++ b/stratosphere/boot/source/boot_pinmux_initial_configuration_hoag.hpp @@ -0,0 +1,186 @@ +/* + * Copyright (c) 2018-2019 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope 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, see . + */ + +#pragma once +#include + +#include "boot_types.hpp" + +static constexpr PinmuxInitialConfig PinmuxInitialConfigsHoag[] = { + {0x5D, 0x00, 0x67}, + {0x47, 0x28, 0x7F}, + {0x48, 0x00, 0x67}, + {0x46, 0x00, 0x67}, + {0x49, 0x00, 0x67}, + {0x30, 0x40, 0x27F}, + {0x31, 0x40, 0x27F}, + {0x0D, 0x20, 0x27F}, + {0x0C, 0x00, 0x267}, + {0x10, 0x20, 0x27F}, + {0x0F, 0x00, 0x267}, + {0x0E, 0x20, 0x27F}, + {0x00, 0x48, 0x7F}, + {0x01, 0x50, 0x7F}, + {0x05, 0x50, 0x7F}, + {0x04, 0x50, 0x7F}, + {0x03, 0x50, 0x7F}, + {0x02, 0x50, 0x7F}, + {0x5B, 0x00, 0x78}, + {0x7C, 0x01, 0x67}, + {0x80, 0x01, 0x7F}, + {0x34, 0x40, 0x27F}, + {0x35, 0x40, 0x27F}, + {0x55, 0x20, 0x78}, + {0x56, 0x20, 0x7F}, + {0xA1, 0x30, 0x7F}, + {0x5C, 0x00, 0x78}, + {0x59, 0x00, 0x60}, + {0x5A, 0x30, 0x78}, + {0x2C, 0x40, 0x27F}, + {0x2D, 0x40, 0x27F}, + {0x2E, 0x40, 0x27F}, + {0x2F, 0x40, 0x27F}, + {0x3B, 0x20, 0x7F}, + {0x3C, 0x00, 0x67}, + {0x3D, 0x20, 0x7F}, + {0x36, 0x00, 0x67}, + {0x37, 0x30, 0x7F}, + {0x38, 0x00, 0x67}, + {0x39, 0x28, 0x7F}, + {0x54, 0x00, 0x67}, + {0x9B, 0x30, 0x7F}, + {0x1C, 0x00, 0x67}, + {0x1D, 0x30, 0x7F}, + {0x1E, 0x00, 0x67}, + {0x1F, 0x00, 0x67}, + {0x3F, 0x20, 0x7F}, + {0x40, 0x00, 0x67}, + {0x41, 0x20, 0x7F}, + {0x42, 0x00, 0x67}, + {0x43, 0x28, 0x7F}, + {0x44, 0x00, 0x67}, + {0x45, 0x28, 0x7F}, + {0x22, 0x00, 0x67}, + {0x23, 0x28, 0x7F}, + {0x20, 0x00, 0x67}, + {0x21, 0x00, 0x67}, + {0x4B, 0x28, 0x7F}, + {0x4C, 0x00, 0x67}, + {0x4A, 0x00, 0x67}, + {0x4D, 0x00, 0x67}, + {0x64, 0x20, 0x27F}, + {0x5F, 0x34, 0x7F}, + {0x60, 0x04, 0x67}, + {0x61, 0x2C, 0x7F}, + {0x2A, 0x04, 0x67}, + {0x2B, 0x04, 0x67}, + {0x8F, 0x24, 0x7F}, + {0x33, 0x34, 0x27F}, + {0x52, 0x2C, 0x7F}, + {0x53, 0x24, 0x7F}, + {0x77, 0x04, 0x67}, + {0x78, 0x34, 0x7F}, + {0x11, 0x04, 0x67}, + {0x06, 0x2C, 0x7F}, + {0x08, 0x24, 0x7F}, + {0x09, 0x24, 0x7F}, + {0x0A, 0x24, 0x7F}, + {0x0B, 0x24, 0x7F}, + {0x88, 0x34, 0x7F}, + {0x86, 0x2C, 0x7F}, + {0x82, 0x24, 0x7F}, + {0x85, 0x34, 0x7F}, + {0x89, 0x24, 0x7F}, + {0x8A, 0x34, 0x7F}, + {0x8B, 0x34, 0x7F}, + {0x8C, 0x34, 0x7F}, + {0x8D, 0x24, 0x7F}, + {0x7D, 0x04, 0x67}, + {0x7E, 0x04, 0x67}, + {0x81, 0x04, 0x67}, + {0x9C, 0x34, 0x7F}, + {0x9D, 0x34, 0x7F}, + {0x9E, 0x2C, 0x7F}, + {0x9F, 0x34, 0x7F}, + {0xA0, 0x04, 0x67}, + {0x4F, 0x04, 0x67}, + {0x51, 0x04, 0x67}, + {0x3A, 0x24, 0x7F}, + {0x92, 0x4C, 0x7F}, + {0x93, 0x4C, 0x7F}, + {0x94, 0x44, 0x7F}, + {0x95, 0x04, 0x67}, + {0x96, 0x34, 0x7F}, + {0x97, 0x04, 0x67}, + {0x98, 0x34, 0x7F}, + {0x99, 0x34, 0x7F}, + {0x9A, 0x04, 0x67}, + {0x3E, 0x24, 0x7F}, + {0x6A, 0x04, 0x67}, + {0x6B, 0x04, 0x67}, + {0x6C, 0x2C, 0x7F}, + {0x6D, 0x04, 0x67}, + {0x6E, 0x04, 0x67}, + {0x6F, 0x24, 0x7F}, + {0x91, 0x24, 0x7F}, + {0x70, 0x04, 0x7F}, + {0x71, 0x04, 0x67}, + {0x72, 0x04, 0x67}, + {0x65, 0x34, 0x7F}, + {0x66, 0x04, 0x67}, + {0x67, 0x04, 0x267}, + {0x5E, 0x05, 0x07}, + {0x17, 0x05, 0x07}, + {0x18, 0x05, 0x07}, + {0x19, 0x05, 0x07}, + {0x1A, 0x05, 0x07}, + {0x1B, 0x05, 0x07}, + {0x26, 0x05, 0x07}, + {0x27, 0x05, 0x07}, + {0x28, 0x05, 0x07}, + {0x29, 0x05, 0x07}, + {0x90, 0x05, 0x07}, + {0x32, 0x05, 0x07}, + {0x75, 0x05, 0x07}, + {0x76, 0x05, 0x07}, + {0x79, 0x05, 0x07}, + {0x7A, 0x05, 0x07}, + {0x8E, 0x05, 0x07}, + {0x07, 0x05, 0x07}, + {0x87, 0x05, 0x07}, + {0x83, 0x05, 0x07}, + {0x84, 0x05, 0x07}, + {0x7B, 0x05, 0x07}, + {0x7F, 0x05, 0x07}, + {0x58, 0x00, 0x00}, + {0x50, 0x05, 0x07}, + {0x4E, 0x05, 0x07}, + {0x12, 0x05, 0x07}, + {0x13, 0x05, 0x07}, + {0x14, 0x05, 0x07}, + {0x15, 0x05, 0x07}, + {0x16, 0x05, 0x07}, + {0x73, 0x05, 0x07}, + {0x74, 0x05, 0x07}, + {0x24, 0x05, 0x07}, + {0x25, 0x05, 0x07}, + {0x62, 0x05, 0x07}, + {0x68, 0x05, 0x07}, + {0x69, 0x05, 0x07}, + {0x63, 0x05, 0x07}, +}; + +static constexpr u32 PinmuxNumInitialConfigsHoag = (sizeof(PinmuxInitialConfigsHoag) / sizeof(PinmuxInitialConfigsHoag[0])); diff --git a/stratosphere/boot/source/boot_pinmux_initial_configuration_icosa.hpp b/stratosphere/boot/source/boot_pinmux_initial_configuration_icosa.hpp new file mode 100644 index 000000000..2bb351377 --- /dev/null +++ b/stratosphere/boot/source/boot_pinmux_initial_configuration_icosa.hpp @@ -0,0 +1,186 @@ +/* + * Copyright (c) 2018-2019 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope 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, see . + */ + +#pragma once +#include + +#include "boot_types.hpp" + +static constexpr PinmuxInitialConfig PinmuxInitialConfigsIcosa[] = { + {0x5D, 0x00, 0x67}, + {0x47, 0x28, 0x7F}, + {0x48, 0x00, 0x67}, + {0x46, 0x00, 0x67}, + {0x49, 0x00, 0x67}, + {0x30, 0x40, 0x27F}, + {0x31, 0x40, 0x27F}, + {0x0D, 0x20, 0x27F}, + {0x0C, 0x00, 0x267}, + {0x10, 0x20, 0x27F}, + {0x0F, 0x00, 0x267}, + {0x0E, 0x20, 0x27F}, + {0x00, 0x48, 0x7F}, + {0x01, 0x50, 0x7F}, + {0x05, 0x50, 0x7F}, + {0x04, 0x50, 0x7F}, + {0x03, 0x50, 0x7F}, + {0x02, 0x50, 0x7F}, + {0x5B, 0x00, 0x78}, + {0x7C, 0x01, 0x67}, + {0x80, 0x01, 0x7F}, + {0x34, 0x40, 0x27F}, + {0x35, 0x40, 0x27F}, + {0x55, 0x20, 0x78}, + {0x56, 0x20, 0x7F}, + {0xA1, 0x30, 0x7F}, + {0x5C, 0x00, 0x78}, + {0x59, 0x00, 0x60}, + {0x5A, 0x30, 0x78}, + {0x2C, 0x40, 0x27F}, + {0x2D, 0x40, 0x27F}, + {0x2E, 0x40, 0x27F}, + {0x2F, 0x40, 0x27F}, + {0x3B, 0x20, 0x7F}, + {0x3C, 0x00, 0x67}, + {0x3D, 0x20, 0x7F}, + {0x36, 0x00, 0x67}, + {0x37, 0x30, 0x7F}, + {0x38, 0x00, 0x67}, + {0x39, 0x28, 0x7F}, + {0x54, 0x00, 0x67}, + {0x9B, 0x30, 0x7F}, + {0x1C, 0x00, 0x67}, + {0x1D, 0x30, 0x7F}, + {0x1E, 0x00, 0x67}, + {0x1F, 0x00, 0x67}, + {0x3F, 0x20, 0x7F}, + {0x40, 0x00, 0x67}, + {0x41, 0x20, 0x7F}, + {0x42, 0x00, 0x67}, + {0x43, 0x28, 0x7F}, + {0x44, 0x00, 0x67}, + {0x45, 0x28, 0x7F}, + {0x22, 0x00, 0x67}, + {0x23, 0x28, 0x7F}, + {0x20, 0x00, 0x67}, + {0x21, 0x00, 0x67}, + {0x4B, 0x28, 0x7F}, + {0x4C, 0x00, 0x67}, + {0x4A, 0x00, 0x67}, + {0x4D, 0x00, 0x67}, + {0x64, 0x20, 0x27F}, + {0x5F, 0x34, 0x7F}, + {0x60, 0x04, 0x67}, + {0x61, 0x2C, 0x7F}, + {0x2A, 0x04, 0x67}, + {0x2B, 0x04, 0x67}, + {0x8F, 0x24, 0x7F}, + {0x33, 0x34, 0x27F}, + {0x52, 0x2C, 0x7F}, + {0x53, 0x24, 0x7F}, + {0x77, 0x04, 0x67}, + {0x78, 0x34, 0x7F}, + {0x11, 0x04, 0x67}, + {0x06, 0x2C, 0x7F}, + {0x08, 0x24, 0x7F}, + {0x09, 0x24, 0x7F}, + {0x0A, 0x24, 0x7F}, + {0x0B, 0x24, 0x7F}, + {0x88, 0x34, 0x7F}, + {0x86, 0x2C, 0x7F}, + {0x82, 0x24, 0x7F}, + {0x85, 0x34, 0x7F}, + {0x89, 0x24, 0x7F}, + {0x8A, 0x34, 0x7F}, + {0x8B, 0x34, 0x7F}, + {0x8C, 0x34, 0x7F}, + {0x8D, 0x24, 0x7F}, + {0x7D, 0x04, 0x67}, + {0x7E, 0x04, 0x67}, + {0x81, 0x04, 0x67}, + {0x9C, 0x34, 0x7F}, + {0x9D, 0x34, 0x7F}, + {0x9E, 0x2C, 0x7F}, + {0x9F, 0x34, 0x7F}, + {0xA0, 0x04, 0x67}, + {0x4F, 0x04, 0x67}, + {0x51, 0x04, 0x67}, + {0x3A, 0x24, 0x7F}, + {0x92, 0x4C, 0x7F}, + {0x93, 0x4C, 0x7F}, + {0x94, 0x44, 0x7F}, + {0x95, 0x04, 0x67}, + {0x96, 0x34, 0x7F}, + {0x97, 0x04, 0x67}, + {0x98, 0x34, 0x7F}, + {0x99, 0x34, 0x7F}, + {0x9A, 0x04, 0x67}, + {0x3E, 0x24, 0x7F}, + {0x6A, 0x04, 0x67}, + {0x6B, 0x04, 0x67}, + {0x6C, 0x2C, 0x7F}, + {0x6D, 0x04, 0x67}, + {0x6E, 0x04, 0x67}, + {0x6F, 0x24, 0x7F}, + {0x91, 0x24, 0x7F}, + {0x70, 0x04, 0x7F}, + {0x71, 0x04, 0x67}, + {0x72, 0x04, 0x67}, + {0x65, 0x34, 0x7F}, + {0x66, 0x04, 0x67}, + {0x67, 0x04, 0x267}, + {0x5E, 0x05, 0x07}, + {0x17, 0x05, 0x07}, + {0x18, 0x05, 0x07}, + {0x19, 0x05, 0x07}, + {0x1A, 0x05, 0x07}, + {0x1B, 0x05, 0x07}, + {0x26, 0x05, 0x07}, + {0x27, 0x05, 0x07}, + {0x28, 0x05, 0x07}, + {0x29, 0x05, 0x07}, + {0x90, 0x05, 0x07}, + {0x32, 0x05, 0x07}, + {0x75, 0x05, 0x07}, + {0x76, 0x05, 0x07}, + {0x79, 0x05, 0x07}, + {0x7A, 0x05, 0x07}, + {0x8E, 0x05, 0x07}, + {0x07, 0x05, 0x07}, + {0x87, 0x05, 0x07}, + {0x83, 0x05, 0x07}, + {0x84, 0x05, 0x07}, + {0x7B, 0x05, 0x07}, + {0x7F, 0x05, 0x07}, + {0x58, 0x00, 0x00}, + {0x50, 0x05, 0x07}, + {0x4E, 0x05, 0x07}, + {0x12, 0x05, 0x07}, + {0x13, 0x05, 0x07}, + {0x14, 0x05, 0x07}, + {0x15, 0x05, 0x07}, + {0x16, 0x05, 0x07}, + {0x73, 0x05, 0x07}, + {0x74, 0x05, 0x07}, + {0x24, 0x05, 0x07}, + {0x25, 0x05, 0x07}, + {0x62, 0x05, 0x07}, + {0x68, 0x05, 0x07}, + {0x69, 0x05, 0x07}, + {0x63, 0x05, 0x07}, +}; + +static constexpr u32 PinmuxNumInitialConfigsIcosa = (sizeof(PinmuxInitialConfigsIcosa) / sizeof(PinmuxInitialConfigsIcosa[0])); diff --git a/stratosphere/boot/source/boot_pinmux_initial_configuration_iowa.hpp b/stratosphere/boot/source/boot_pinmux_initial_configuration_iowa.hpp new file mode 100644 index 000000000..3f5e5ae5c --- /dev/null +++ b/stratosphere/boot/source/boot_pinmux_initial_configuration_iowa.hpp @@ -0,0 +1,199 @@ +/* + * Copyright (c) 2018-2019 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope 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, see . + */ + +#pragma once +#include + +#include "boot_types.hpp" + +static constexpr PinmuxInitialConfig PinmuxInitialConfigsIowa[] = { + {0x5D, 0x00, 0x7F}, + {0x47, 0x28, 0x7F}, + {0x48, 0x00, 0x7F}, + {0x46, 0x00, 0x7F}, + {0x49, 0x00, 0x7F}, + {0x30, 0x40, 0x27F}, + {0x31, 0x40, 0x27F}, + {0x0D, 0x20, 0x27F}, + {0x0C, 0x00, 0x27F}, + {0x10, 0x40, 0x27F}, + {0x0F, 0x00, 0x27F}, + {0x0E, 0x20, 0x27F}, + {0x00, 0x40, 0x7F}, + {0x01, 0x50, 0x7F}, + {0x05, 0x50, 0x7F}, + {0x04, 0x50, 0x7F}, + {0x03, 0x50, 0x7F}, + {0x02, 0x50, 0x7F}, + {0xAA, 0x40, 0x7F}, + {0xAC, 0x40, 0x7F}, + {0xA2, 0x50, 0x7F}, + {0xA3, 0x50, 0x7F}, + {0xA4, 0x50, 0x7F}, + {0xA5, 0x50, 0x7F}, + {0xA6, 0x50, 0x7F}, + {0xA7, 0x50, 0x7F}, + {0xA8, 0x50, 0x7F}, + {0xA9, 0x50, 0x7F}, + {0x5B, 0x00, 0x78}, + {0x7C, 0x01, 0x67}, + {0x80, 0x01, 0x7F}, + {0x34, 0x40, 0x27F}, + {0x35, 0x40, 0x27F}, + {0x55, 0x20, 0x78}, + {0x56, 0x20, 0x7F}, + {0xA1, 0x30, 0x7F}, + {0x5C, 0x00, 0x78}, + {0x5A, 0x20, 0x78}, + {0x2C, 0x40, 0x27F}, + {0x2D, 0x40, 0x27F}, + {0x2E, 0x40, 0x27F}, + {0x2F, 0x40, 0x27F}, + {0x3B, 0x20, 0x7F}, + {0x3C, 0x00, 0x7F}, + {0x3D, 0x20, 0x7F}, + {0x36, 0x00, 0x7F}, + {0x37, 0x30, 0x7F}, + {0x38, 0x00, 0x7F}, + {0x39, 0x28, 0x7F}, + {0x54, 0x00, 0x67}, + {0x9B, 0x30, 0x7F}, + {0x1C, 0x00, 0x7F}, + {0x1D, 0x30, 0x7F}, + {0x1E, 0x00, 0x7F}, + {0x1F, 0x00, 0x7F}, + {0x3F, 0x20, 0x7F}, + {0x40, 0x00, 0x7F}, + {0x41, 0x20, 0x7F}, + {0x42, 0x00, 0x7F}, + {0x43, 0x28, 0x7F}, + {0x44, 0x00, 0x7F}, + {0x45, 0x28, 0x7F}, + {0x4B, 0x28, 0x7F}, + {0x4C, 0x00, 0x7F}, + {0x4A, 0x00, 0x7F}, + {0x4D, 0x00, 0x7F}, + {0x64, 0x20, 0x27F}, + {0x5F, 0x34, 0x7F}, + {0x60, 0x04, 0x67}, + {0x61, 0x2C, 0x7F}, + {0x2A, 0x04, 0x67}, + {0x8F, 0x24, 0x7F}, + {0x33, 0x34, 0x27F}, + {0x52, 0x2C, 0x7F}, + {0x53, 0x24, 0x7F}, + {0x77, 0x04, 0x67}, + {0x78, 0x24, 0x7F}, + {0x11, 0x04, 0x67}, + {0x06, 0x2C, 0x7F}, + {0x08, 0x24, 0x7F}, + {0x09, 0x24, 0x7F}, + {0x0A, 0x24, 0x7F}, + {0x0B, 0x24, 0x7F}, + {0x88, 0x34, 0x7F}, + {0x86, 0x2C, 0x7F}, + {0x82, 0x24, 0x7F}, + {0x85, 0x34, 0x7F}, + {0x89, 0x24, 0x7F}, + {0x8A, 0x34, 0x7F}, + {0x8B, 0x34, 0x7F}, + {0x8C, 0x24, 0x7F}, + {0x8D, 0x24, 0x7F}, + {0x7D, 0x04, 0x67}, + {0x7E, 0x04, 0x67}, + {0x81, 0x04, 0x67}, + {0x9C, 0x24, 0x7F}, + {0x9D, 0x34, 0x7F}, + {0x9E, 0x2C, 0x7F}, + {0x9F, 0x34, 0x7F}, + {0xA0, 0x04, 0x67}, + {0x4F, 0x04, 0x67}, + {0x51, 0x04, 0x67}, + {0x3A, 0x24, 0x7F}, + {0x92, 0x4C, 0x7F}, + {0x93, 0x4C, 0x7F}, + {0x94, 0x44, 0x7F}, + {0x95, 0x04, 0x67}, + {0x96, 0x34, 0x7F}, + {0x97, 0x04, 0x67}, + {0x98, 0x34, 0x7F}, + {0x9A, 0x04, 0x67}, + {0x3E, 0x24, 0x7F}, + {0x6A, 0x04, 0x67}, + {0x6B, 0x04, 0x67}, + {0x6C, 0x2C, 0x7F}, + {0x6D, 0x04, 0x67}, + {0x6E, 0x04, 0x67}, + {0x6F, 0x24, 0x7F}, + {0x91, 0x24, 0x7F}, + {0x70, 0x04, 0x7F}, + {0x71, 0x04, 0x67}, + {0x72, 0x04, 0x67}, + {0x65, 0x34, 0x7F}, + {0x66, 0x04, 0x67}, + {0x67, 0x04, 0x267}, + {0x5E, 0x05, 0x07}, + {0x17, 0x05, 0x07}, + {0x18, 0x05, 0x07}, + {0x19, 0x05, 0x07}, + {0x1A, 0x05, 0x07}, + {0x1B, 0x05, 0x07}, + {0x26, 0x05, 0x07}, + {0x27, 0x05, 0x07}, + {0x28, 0x05, 0x07}, + {0x29, 0x05, 0x07}, + {0x2B, 0x05, 0x07}, + {0x90, 0x05, 0x07}, + {0x32, 0x05, 0x07}, + {0x75, 0x05, 0x07}, + {0x76, 0x05, 0x07}, + {0x79, 0x05, 0x07}, + {0x7A, 0x05, 0x07}, + {0x8E, 0x05, 0x07}, + {0xAB, 0x05, 0x07}, + {0xAD, 0x05, 0x07}, + {0xAE, 0x05, 0x07}, + {0x07, 0x05, 0x07}, + {0x87, 0x05, 0x07}, + {0x83, 0x05, 0x07}, + {0x84, 0x05, 0x07}, + {0x7B, 0x05, 0x07}, + {0x7F, 0x05, 0x07}, + {0x58, 0x00, 0x00}, + {0x59, 0x00, 0x00}, + {0x50, 0x05, 0x07}, + {0x4E, 0x05, 0x07}, + {0x99, 0x05, 0x07}, + {0x12, 0x05, 0x07}, + {0x13, 0x05, 0x07}, + {0x14, 0x05, 0x07}, + {0x15, 0x05, 0x07}, + {0x16, 0x05, 0x07}, + {0x73, 0x05, 0x07}, + {0x74, 0x05, 0x07}, + {0x22, 0x05, 0x07}, + {0x23, 0x05, 0x07}, + {0x20, 0x05, 0x07}, + {0x21, 0x05, 0x07}, + {0x24, 0x05, 0x07}, + {0x25, 0x05, 0x07}, + {0x62, 0x05, 0x07}, + {0x68, 0x05, 0x07}, + {0x69, 0x05, 0x07}, + {0x63, 0x05, 0x07}, +}; + +static constexpr u32 PinmuxNumInitialConfigsIowa = (sizeof(PinmuxInitialConfigsIowa) / sizeof(PinmuxInitialConfigsIowa[0])); diff --git a/stratosphere/boot/source/boot_pinmux_initial_drive_pad_configuration.hpp b/stratosphere/boot/source/boot_pinmux_initial_drive_pad_configuration.hpp new file mode 100644 index 000000000..70d1b4e30 --- /dev/null +++ b/stratosphere/boot/source/boot_pinmux_initial_drive_pad_configuration.hpp @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2018-2019 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope 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, see . + */ + +#pragma once +#include + +#include "boot_types.hpp" + +static constexpr PinmuxInitialConfig PinmuxInitialDrivePadConfigs[] = { + {0x04, 0x01010000, 0x01F1F000}, + {0x0D, 0x01010000, 0x01F1F000}, + {0x10, 0x01010000, 0x01F1F000}, + {0x12, 0x01010000, 0x01F1F000}, + {0x13, 0x01010000, 0x01F1F000}, + {0x14, 0x0001F000, 0x01F1F000}, + {0x15, 0x0001F000, 0x01F1F000}, + {0x24, 0x01010000, 0x01F1F000}, + {0x25, 0x01010000, 0x01F1F000}, + {0x26, 0x01010000, 0x01F1F000}, + {0x27, 0x01010000, 0x01F1F000}, + {0x28, 0x01010000, 0x01F1F000}, + {0x29, 0x01010000, 0x01F1F000}, + {0x2A, 0x01010000, 0x01F1F000}, + {0x2B, 0x01010000, 0x01F1F000}, + {0x2C, 0x01F1F000, 0x01F1F000}, + {0x2D, 0x01F1F000, 0x01F1F000}, + {0x2F, 0x01F1F000, 0x01F1F000}, + {0x30, 0x01404000, 0x01F1F000}, + {0x31, 0x0001F000, 0x01F1F000}, + {0x32, 0x0001F000, 0x01F1F000}, + {0x33, 0x0001F000, 0x01F1F000}, + {0x34, 0x0001F000, 0x01F1F000}, + {0x35, 0x00007000, 0x01F1F000}, + {0x36, 0x00007000, 0x01F1F000}, + {0x46, 0x01010000, 0x01F1F000}, + {0x47, 0x01010000, 0x01F1F000}, + {0x4C, 0x01404000, 0x01F1F000}, + {0x4D, 0x01404000, 0x01F1F000}, + {0x62, 0x0001F000, 0x01F1F000}, + {0x63, 0x0001F000, 0x01F1F000}, + {0x7C, 0x01414000, 0x01F1F000}, + {0x87, 0x01404000, 0x01F1F000}, + {0x88, 0x01404000, 0x01F1F000}, + {0x89, 0x01404000, 0x01F1F000}, + {0x8A, 0x01404000, 0x01F1F000}, + {0x6D, 0x00000000, 0xF0000000}, + {0x6E, 0x00000000, 0xF0000000}, + {0x6F, 0x00000000, 0xF0000000}, + {0x70, 0x00000000, 0xF0000000}, + {0x71, 0x00000000, 0xF0000000}, + {0x72, 0x00000000, 0xF0000000}, + {0x73, 0x00000000, 0xF0000000}, + {0x74, 0x00000000, 0xF0000000}, + {0x75, 0x00000000, 0xF0000000}, + {0x76, 0x00000000, 0xF0000000}, + {0x69, 0x51212000, 0xF1F1F000}, +}; + +static constexpr u32 PinmuxNumInitialDrivePadConfigs = (sizeof(PinmuxInitialDrivePadConfigs) / sizeof(PinmuxInitialDrivePadConfigs[0])); diff --git a/stratosphere/boot/source/boot_pinmux_map.hpp b/stratosphere/boot/source/boot_pinmux_map.hpp new file mode 100644 index 000000000..67c4a5c82 --- /dev/null +++ b/stratosphere/boot/source/boot_pinmux_map.hpp @@ -0,0 +1,364 @@ +/* + * Copyright (c) 2018-2019 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope 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, see . + */ + +#pragma once +#include + +struct PinmuxDefinition { + u32 reg_offset; + u32 mask_val; + u32 pm_val; +}; + +struct PinmuxDrivePadDefinition { + u32 reg_offset; + u32 mask_val; +}; + +static constexpr PinmuxDefinition PinmuxMap[] = { + {0x00003000, 0x72FF, 0x01}, /* Sdmmc1Clk */ + {0x00003004, 0x72FF, 0x02}, /* Sdmmc1Cmd */ + {0x00003008, 0x72FF, 0x02}, /* Sdmmc1Dat3 */ + {0x0000300C, 0x72FF, 0x02}, /* Sdmmc1Dat2 */ + {0x00003010, 0x72FF, 0x02}, /* Sdmmc1Dat1 */ + {0x00003014, 0x72FF, 0x01}, /* Sdmmc1Dat0 */ + {0x0000301C, 0x72FF, 0x01}, /* Sdmmc3Clk */ + {0x00003020, 0x72FF, 0x01}, /* Sdmmc3Cmd */ + {0x00003024, 0x72FF, 0x01}, /* Sdmmc3Dat0 */ + {0x00003028, 0x72FF, 0x01}, /* Sdmmc3Dat1 */ + {0x0000302C, 0x72FF, 0x01}, /* Sdmmc3Dat2 */ + {0x00003030, 0x72FF, 0x01}, /* Sdmmc3Dat3 */ + {0x00003038, 0x1DFF, 0x01}, /* PexL0RstN */ + {0x0000303C, 0x1DFF, 0x01}, /* PexL0ClkreqN */ + {0x00003040, 0x1DFF, 0x01}, /* PexWakeN */ + {0x00003044, 0x1DFF, 0x01}, /* PexL1RstN */ + {0x00003048, 0x1DFF, 0x01}, /* PexL1ClkreqN */ + {0x0000304C, 0x19FF, 0x01}, /* SataLedActive */ + {0x00003050, 0x1F2FF, 0x01}, /* Spi1Mosi */ + {0x00003054, 0x1F2FF, 0x01}, /* Spi1Miso */ + {0x00003058, 0x1F2FF, 0x01}, /* Spi1Sck */ + {0x0000305C, 0x1F2FF, 0x01}, /* Spi1Cs0 */ + {0x00003060, 0x1F2FF, 0x01}, /* Spi1Cs1 */ + {0x00003064, 0x72FF, 0x02}, /* Spi2Mosi */ + {0x00003068, 0x72FF, 0x02}, /* Spi2Miso */ + {0x0000306C, 0x72FF, 0x02}, /* Spi2Sck */ + {0x00003070, 0x72FF, 0x02}, /* Spi2Cs0 */ + {0x00003074, 0x72FF, 0x01}, /* Spi2Cs1 */ + {0x00003078, 0x1F2FF, 0x01}, /* Spi4Mosi */ + {0x0000307C, 0x1F2FF, 0x01}, /* Spi4Miso */ + {0x00003080, 0x1F2FF, 0x01}, /* Spi4Sck */ + {0x00003084, 0x1F2FF, 0x01}, /* Spi4Cs0 */ + {0x00003088, 0x72FF, 0x01}, /* QspiSck */ + {0x0000308C, 0x72FF, 0x01}, /* QspiCsN */ + {0x00003090, 0x72FF, 0x01}, /* QspiIo0 */ + {0x00003094, 0x72FF, 0x01}, /* QspiIo1 */ + {0x00003098, 0x72FF, 0x01}, /* QspiIo2 */ + {0x0000309C, 0x72FF, 0x01}, /* QspiIo3 */ + {0x000030A4, 0x19FF, 0x02}, /* Dmic1Clk */ + {0x000030A8, 0x19FF, 0x02}, /* Dmic1Dat */ + {0x000030AC, 0x19FF, 0x02}, /* Dmic2Clk */ + {0x000030B0, 0x19FF, 0x02}, /* Dmic2Dat */ + {0x000030B4, 0x19FF, 0x02}, /* Dmic3Clk */ + {0x000030B8, 0x19FF, 0x02}, /* Dmic3Dat */ + {0x000030BC, 0x1DFF, 0x01}, /* Gen1I2cScl */ + {0x000030C0, 0x1DFF, 0x01}, /* Gen1I2cSda */ + {0x000030C4, 0x1DFF, 0x01}, /* Gen2I2cScl */ + {0x000030C8, 0x1DFF, 0x01}, /* Gen2I2cSda */ + {0x000030CC, 0x1DFF, 0x01}, /* Gen3I2cScl */ + {0x000030D0, 0x1DFF, 0x01}, /* Gen3I2cSda */ + {0x000030D4, 0x1DFF, 0x02}, /* CamI2cScl */ + {0x000030D8, 0x1DFF, 0x02}, /* CamI2cSda */ + {0x000030DC, 0x1DFF, 0x01}, /* PwrI2cScl */ + {0x000030E0, 0x1DFF, 0x01}, /* PwrI2cSda */ + {0x000030E4, 0x19FF, 0x01}, /* Uart1Tx */ + {0x000030E8, 0x19FF, 0x01}, /* Uart1Rx */ + {0x000030EC, 0x19FF, 0x01}, /* Uart1Rts */ + {0x000030F0, 0x19FF, 0x01}, /* Uart1Cts */ + {0x000030F4, 0x19FF, 0x00}, /* Uart2Tx */ + {0x000030F8, 0x19FF, 0x00}, /* Uart2Rx */ + {0x000030FC, 0x19FF, 0x02}, /* Uart2Rts */ + {0x00003100, 0x19FF, 0x02}, /* Uart2Cts */ + {0x00003104, 0x19FF, 0x02}, /* Uart3Tx */ + {0x00003108, 0x19FF, 0x02}, /* Uart3Rx */ + {0x0000310C, 0x19FF, 0x02}, /* Uart3Rts */ + {0x00003110, 0x19FF, 0x02}, /* Uart3Cts */ + {0x00003114, 0x19FF, 0x02}, /* Uart4Tx */ + {0x00003118, 0x19FF, 0x02}, /* Uart4Rx */ + {0x0000311C, 0x19FF, 0x02}, /* Uart4Rts */ + {0x00003120, 0x19FF, 0x02}, /* Uart4Cts */ + {0x00003124, 0x72FF, 0x01}, /* Dap1Fs */ + {0x00003128, 0x72FF, 0x01}, /* Dap1Din */ + {0x0000312C, 0x72FF, 0x01}, /* Dap1Dout */ + {0x00003130, 0x72FF, 0x01}, /* Dap1Sclk */ + {0x00003134, 0x72FF, 0x01}, /* Dap2Fs */ + {0x00003138, 0x72FF, 0x01}, /* Dap2Din */ + {0x0000313C, 0x72FF, 0x01}, /* Dap2Dout */ + {0x00003140, 0x72FF, 0x01}, /* Dap2Sclk */ + {0x00003144, 0x72FF, 0x01}, /* Dap4Fs */ + {0x00003148, 0x72FF, 0x01}, /* Dap4Din */ + {0x0000314C, 0x72FF, 0x01}, /* Dap4Dout */ + {0x00003150, 0x72FF, 0x01}, /* Dap4Sclk */ + {0x00003154, 0x72FF, 0x01}, /* Cam1Mclk */ + {0x00003158, 0x72FF, 0x01}, /* Cam2Mclk */ + {0x0000315C, 0x72FF, 0x01}, /* JtagRtck */ + {0x00003160, 0x118C, 0xFF}, /* Clk32kIn */ + {0x00003164, 0x72FF, 0x02}, /* Clk32kOut */ + {0x00003168, 0x1DFF, 0x01}, /* BattBcl */ + {0x0000316C, 0x11CC, 0xFF}, /* ClkReq */ + {0x00003170, 0x11CC, 0xFF}, /* CpuPwrReq */ + {0x00003174, 0x11CC, 0xFF}, /* PwrIntN */ + {0x00003178, 0x11CC, 0xFF}, /* Shutdown */ + {0x0000317C, 0x11CC, 0xFF}, /* CorePwrReq */ + {0x00003180, 0x19FF, 0x01}, /* AudMclk */ + {0x00003184, 0x19FF, 0x00}, /* DvfsPwm */ + {0x00003188, 0x19FF, 0x00}, /* DvfsClk */ + {0x0000318C, 0x19FF, 0x00}, /* GpioX1Aud */ + {0x00003190, 0x19FF, 0x00}, /* GpioX3Aud */ + {0x00003194, 0x1DFF, 0x00}, /* GpioPcc7 */ + {0x00003198, 0x1DFF, 0x01}, /* HdmiCec */ + {0x0000319C, 0x1DFF, 0x01}, /* HdmiIntDpHpd */ + {0x000031A0, 0x19FF, 0x01}, /* SpdifOut */ + {0x000031A4, 0x19FF, 0x01}, /* SpdifIn */ + {0x000031A8, 0x1DFF, 0x01}, /* UsbVbusEn0 */ + {0x000031AC, 0x1DFF, 0x01}, /* UsbVbusEn1 */ + {0x000031B0, 0x19FF, 0x01}, /* DpHpd0 */ + {0x000031B4, 0x19FF, 0x00}, /* WifiEn */ + {0x000031B8, 0x19FF, 0x00}, /* WifiRst */ + {0x000031BC, 0x19FF, 0x00}, /* WifiWakeAp */ + {0x000031C0, 0x19FF, 0x00}, /* ApWakeBt */ + {0x000031C4, 0x19FF, 0x00}, /* BtRst */ + {0x000031C8, 0x19FF, 0x00}, /* BtWakeAp */ + {0x000031CC, 0x19FF, 0x00}, /* ApWakeNfc */ + {0x000031D0, 0x19FF, 0x00}, /* NfcEn */ + {0x000031D4, 0x19FF, 0x00}, /* NfcInt */ + {0x000031D8, 0x19FF, 0x00}, /* GpsEn */ + {0x000031DC, 0x19FF, 0x00}, /* GpsRst */ + {0x000031E0, 0x19FF, 0x01}, /* CamRst */ + {0x000031E4, 0x19FF, 0x02}, /* CamAfEn */ + {0x000031E8, 0x19FF, 0x02}, /* CamFlashEn */ + {0x000031EC, 0x19FF, 0x01}, /* Cam1Pwdn */ + {0x000031F0, 0x19FF, 0x01}, /* Cam2Pwdn */ + {0x000031F4, 0x19FF, 0x01}, /* Cam1Strobe */ + {0x000031F8, 0x19FF, 0x01}, /* LcdTe */ + {0x000031FC, 0x19FF, 0x03}, /* LcdBlPwm */ + {0x00003200, 0x19FF, 0x00}, /* LcdBlEn */ + {0x00003204, 0x19FF, 0x00}, /* LcdRst */ + {0x00003208, 0x19FF, 0x01}, /* LcdGpio1 */ + {0x0000320C, 0x19FF, 0x02}, /* LcdGpio2 */ + {0x00003210, 0x19FF, 0x00}, /* ApReady */ + {0x00003214, 0x19FF, 0x00}, /* TouchRst */ + {0x00003218, 0x19FF, 0x01}, /* TouchClk */ + {0x0000321C, 0x19FF, 0x00}, /* ModemWakeAp */ + {0x00003220, 0x19FF, 0x00}, /* TouchInt */ + {0x00003224, 0x19FF, 0x00}, /* MotionInt */ + {0x00003228, 0x19FF, 0x00}, /* AlsProxInt */ + {0x0000322C, 0x19FF, 0x00}, /* TempAlert */ + {0x00003230, 0x19FF, 0x00}, /* ButtonPowerOn */ + {0x00003234, 0x19FF, 0x00}, /* ButtonVolUp */ + {0x00003238, 0x19FF, 0x00}, /* ButtonVolDown */ + {0x0000323C, 0x19FF, 0x00}, /* ButtonSlideSw */ + {0x00003240, 0x19FF, 0x00}, /* ButtonHome */ + {0x00003244, 0x19FF, 0x01}, /* GpioPa6 */ + {0x00003248, 0x19FF, 0x00}, /* GpioPe6 */ + {0x0000324C, 0x19FF, 0x00}, /* GpioPe7 */ + {0x00003250, 0x19FF, 0x00}, /* GpioPh6 */ + {0x00003254, 0x72FF, 0x02}, /* GpioPk0 */ + {0x00003258, 0x72FF, 0x02}, /* GpioPk1 */ + {0x0000325C, 0x72FF, 0x02}, /* GpioPk2 */ + {0x00003260, 0x72FF, 0x02}, /* GpioPk3 */ + {0x00003264, 0x72FF, 0x01}, /* GpioPk4 */ + {0x00003268, 0x72FF, 0x01}, /* GpioPk5 */ + {0x0000326C, 0x72FF, 0x01}, /* GpioPk6 */ + {0x00003270, 0x72FF, 0x01}, /* GpioPk7 */ + {0x00003274, 0x72FF, 0x00}, /* GpioPl0 */ + {0x00003278, 0x72FF, 0x01}, /* GpioPl1 */ + {0x0000327C, 0x72FF, 0x01}, /* GpioPz0 */ + {0x00003280, 0x72FF, 0x02}, /* GpioPz1 */ + {0x00003284, 0x72FF, 0x02}, /* GpioPz2 */ + {0x00003288, 0x72FF, 0x01}, /* GpioPz3 */ + {0x0000328C, 0x72FF, 0x01}, /* GpioPz4 */ + {0x00003290, 0x72FF, 0x01}, /* GpioPz5 */ + + /* 5.0.0+ only */ + {0x00003294, 0x1F2FF, 0x02}, /* Sdmmc2Dat0 */ + {0x00003298, 0x1F2FF, 0x02}, /* Sdmmc2Dat1 */ + {0x0000329C, 0x1F2FF, 0x02}, /* Sdmmc2Dat2 */ + {0x000032A0, 0x1F2FF, 0x02}, /* Sdmmc2Dat3 */ + {0x000032A4, 0x1F2FF, 0x02}, /* Sdmmc2Dat4 */ + {0x000032A8, 0x1F2FF, 0x02}, /* Sdmmc2Dat5 */ + {0x000032AC, 0x1F2FF, 0x02}, /* Sdmmc2Dat6 */ + {0x000032B0, 0x1F2FF, 0x02}, /* Sdmmc2Dat7 */ + {0x000032B4, 0x1F2FF, 0x02}, /* Sdmmc2Clk */ + {0x000032B8, 0x1F2FF, 0x00}, /* Sdmmc2Clkb */ + {0x000032BC, 0x1F2FF, 0x02}, /* Sdmmc2Cmd */ + {0x000032C0, 0x1F2FF, 0x00}, /* Sdmmc2Dqs */ + {0x000032C4, 0x1F2FF, 0x00}, /* Sdmmc2Dqsb */ +}; + +static constexpr u32 PinmuxPadNameMax = (sizeof(PinmuxMap) / sizeof(PinmuxMap[0])); + +static constexpr PinmuxDrivePadDefinition PinmuxDrivePadMap[] = { + {0x000008E4, 0x01F1F000}, /* AlsProxInt */ + {0x000008E8, 0x01F1F000}, /* ApReady */ + {0x000008EC, 0x01F1F000}, /* ApWakeBt */ + {0x000008F0, 0x01F1F000}, /* ApWakeNfc */ + {0x000008F4, 0x01F1F000}, /* AudMclk */ + {0x000008F8, 0x01F1F000}, /* BattBcl */ + {0x000008FC, 0x01F1F000}, /* BtRst */ + {0x00000900, 0x01F1F000}, /* BtWakeAp */ + {0x00000904, 0x01F1F000}, /* ButtonHome */ + {0x00000908, 0x01F1F000}, /* ButtonPowerOn */ + {0x0000090C, 0x01F1F000}, /* ButtonSlideSw */ + {0x00000910, 0x01F1F000}, /* ButtonVolDown */ + {0x00000914, 0x01F1F000}, /* ButtonVolUp */ + {0x00000918, 0x01F1F000}, /* Cam1Mclk */ + {0x0000091C, 0x01F1F000}, /* Cam1Pwdn */ + {0x00000920, 0x01F1F000}, /* Cam1Strobe */ + {0x00000924, 0x01F1F000}, /* Cam2Mclk */ + {0x00000928, 0x01F1F000}, /* Cam2Pwdn */ + {0x0000092C, 0x01F1F000}, /* CamAfEn */ + {0x00000930, 0x01F1F000}, /* CamFlashEn */ + {0x00000934, 0x01F1F000}, /* CamI2cScl */ + {0x00000938, 0x01F1F000}, /* CamI2cSda */ + {0x0000093C, 0x01F1F000}, /* CamRst */ + {0x00000940, 0x01F1F000}, /* Clk32kIn */ + {0x00000944, 0x01F1F000}, /* Clk32kOut */ + {0x00000948, 0x01F1F000}, /* ClkReq */ + {0x0000094C, 0x01F1F000}, /* CorePwrReq */ + {0x00000950, 0x01F1F000}, /* CpuPwrReq */ + {0x00000954, 0xF0000000}, /* Dap1Din */ + {0x00000958, 0xF0000000}, /* Dap1Dout */ + {0x0000095C, 0xF0000000}, /* Dap1Fs */ + {0x00000960, 0xF0000000}, /* Dap1Sclk */ + {0x00000964, 0xF0000000}, /* Dap2Din */ + {0x00000968, 0xF0000000}, /* Dap2Dout */ + {0x0000096C, 0xF0000000}, /* Dap2Fs */ + {0x00000970, 0xF0000000}, /* Dap2Sclk */ + {0x00000974, 0x01F1F000}, /* Dap4Din */ + {0x00000978, 0x01F1F000}, /* Dap4Dout */ + {0x0000097C, 0x01F1F000}, /* Dap4Fs */ + {0x00000980, 0x01F1F000}, /* Dap4Sclk */ + {0x00000984, 0x01F1F000}, /* Dmic1Clk */ + {0x00000988, 0x01F1F000}, /* Dmic1Dat */ + {0x0000098C, 0x01F1F000}, /* Dmic2Clk */ + {0x00000990, 0x01F1F000}, /* Dmic2Dat */ + {0x00000994, 0x01F1F000}, /* Dmic3Clk */ + {0x00000998, 0x01F1F000}, /* Dmic3Dat */ + {0x0000099C, 0x01F1F000}, /* DpHpd */ + {0x000009A0, 0x01F1F000}, /* DvfsClk */ + {0x000009A4, 0x01F1F000}, /* DvfsPwm */ + {0x000009A8, 0x01F1F000}, /* Gen1I2cScl */ + {0x000009AC, 0x01F1F000}, /* Gen1I2cSda */ + {0x000009B0, 0x01F1F000}, /* Gen2I2cScl */ + {0x000009B4, 0x01F1F000}, /* Gen2I2cSda */ + {0x000009B8, 0x01F1F000}, /* Gen3I2cScl */ + {0x000009BC, 0x01F1F000}, /* Gen3I2cSda */ + {0x000009C0, 0x01F1F000}, /* GpioPa6 */ + {0x000009C4, 0x01F1F000}, /* GpioPcc7 */ + {0x000009C8, 0x01F1F000}, /* GpioPe6 */ + {0x000009CC, 0x01F1F000}, /* GpioPe7 */ + {0x000009D0, 0x01F1F000}, /* GpioPh6 */ + {0x000009D4, 0xF0000000}, /* GpioPk0 */ + {0x000009D8, 0xF0000000}, /* GpioPk1 */ + {0x000009DC, 0xF0000000}, /* GpioPk2 */ + {0x000009E0, 0xF0000000}, /* GpioPk3 */ + {0x000009E4, 0xF0000000}, /* GpioPk4 */ + {0x000009E8, 0xF0000000}, /* GpioPk5 */ + {0x000009EC, 0xF0000000}, /* GpioPk6 */ + {0x000009F0, 0xF0000000}, /* GpioPk7 */ + {0x000009F4, 0xF0000000}, /* GpioPl0 */ + {0x000009F8, 0xF0000000}, /* GpioPl1 */ + {0x000009FC, 0x07F7F000}, /* GpioPz0 */ + {0x00000A00, 0x07F7F000}, /* GpioPz1 */ + {0x00000A04, 0x07F7F000}, /* GpioPz2 */ + {0x00000A08, 0x07F7F000}, /* GpioPz3 */ + {0x00000A0C, 0x07F7F000}, /* GpioPz4 */ + {0x00000A10, 0x07F7F000}, /* GpioPz5 */ + {0x00000A14, 0x01F1F000}, /* GpioX1Aud */ + {0x00000A18, 0x01F1F000}, /* GpioX3Aud */ + {0x00000A1C, 0x01F1F000}, /* GpsEn */ + {0x00000A20, 0x01F1F000}, /* GpsRst */ + {0x00000A24, 0x01F1F000}, /* HdmiCec */ + {0x00000A28, 0x01F1F000}, /* HdmiIntDpHpd */ + {0x00000A2C, 0x01F1F000}, /* JtagRtck */ + {0x00000A30, 0x01F1F000}, /* LcdBlEn */ + {0x00000A34, 0x01F1F000}, /* LcdBlPwm */ + {0x00000A38, 0x01F1F000}, /* LcdGpio1 */ + {0x00000A3C, 0x01F1F000}, /* LcdGpio2 */ + {0x00000A40, 0x01F1F000}, /* LcdRst */ + {0x00000A44, 0x01F1F000}, /* LcdTe */ + {0x00000A48, 0x01F1F000}, /* ModemWakeAp */ + {0x00000A4C, 0x01F1F000}, /* MotionInt */ + {0x00000A50, 0x01F1F000}, /* NfcEn */ + {0x00000A54, 0x01F1F000}, /* NfcInt */ + {0x00000A58, 0x01F1F000}, /* PexL0ClkReqN */ + {0x00000A5C, 0x01F1F000}, /* PexL0RstN */ + {0x00000A60, 0x01F1F000}, /* PexL1ClkreqN */ + {0x00000A64, 0x01F1F000}, /* PexL1RstN */ + {0x00000A68, 0x01F1F000}, /* PexWakeN */ + {0x00000A6C, 0x01F1F000}, /* PwrI2cScl */ + {0x00000A70, 0x01F1F000}, /* PwrI2cSda */ + {0x00000A74, 0x01F1F000}, /* PwrIntN */ + {0x00000A78, 0x07F7F000}, /* QspiComp */ + {0x00000A90, 0xF0000000}, /* QspiSck */ + {0x00000A94, 0x01F1F000}, /* SataLedActive */ + {0x00000A98, 0xF7F7F000}, /* Sdmmc1Pad */ + {0x00000AB0, 0xF7F7F000}, /* Sdmmc3Pad */ + {0x00000AC8, 0x01F1F000}, /* Shutdown */ + {0x00000ACC, 0x01F1F000}, /* SpdifIn */ + {0x00000AD0, 0x01F1F000}, /* SpdifOut */ + {0x00000AD4, 0xF0000000}, /* Spi1Cs0 */ + {0x00000AD8, 0xF0000000}, /* Spi1Cs1 */ + {0x00000ADC, 0xF0000000}, /* Spi1Miso */ + {0x00000AE0, 0xF0000000}, /* Spi1Mosi */ + {0x00000AE4, 0xF0000000}, /* Spi1Sck */ + {0x00000AE8, 0xF0000000}, /* Spi2Cs0 */ + {0x00000AEC, 0xF0000000}, /* Spi2Cs1 */ + {0x00000AF0, 0xF0000000}, /* Spi2Miso */ + {0x00000AF4, 0xF0000000}, /* Spi2Mosi */ + {0x00000AF8, 0xF0000000}, /* Spi2Sck */ + {0x00000AFC, 0xF0000000}, /* Spi4Cs0 */ + {0x00000B00, 0xF0000000}, /* Spi4Miso */ + {0x00000B04, 0xF0000000}, /* Spi4Mosi */ + {0x00000B08, 0xF0000000}, /* Spi4Sck */ + {0x00000B0C, 0x01F1F000}, /* TempAlert */ + {0x00000B10, 0x01F1F000}, /* TouchClk */ + {0x00000B14, 0x01F1F000}, /* TouchInt */ + {0x00000B18, 0x01F1F000}, /* TouchRst */ + {0x00000B1C, 0x01F1F000}, /* Uart1Cts */ + {0x00000B20, 0x01F1F000}, /* Uart1Rts */ + {0x00000B24, 0x01F1F000}, /* Uart1Rx */ + {0x00000B28, 0x01F1F000}, /* Uart1Tx */ + {0x00000B2C, 0x01F1F000}, /* Uart2Cts */ + {0x00000B30, 0x01F1F000}, /* Uart2Rts */ + {0x00000B34, 0x01F1F000}, /* Uart2Rx */ + {0x00000B38, 0x01F1F000}, /* Uart2Tx */ + {0x00000B3C, 0x01F1F000}, /* Uart3Cts */ + {0x00000B40, 0x01F1F000}, /* Uart3Rts */ + {0x00000B44, 0x01F1F000}, /* Uart3Rx */ + {0x00000B48, 0x01F1F000}, /* Uart3Tx */ + {0x00000B4C, 0x01F1F000}, /* Uart4Cts */ + {0x00000B50, 0x01F1F000}, /* Uart4Rts */ + {0x00000B54, 0x01F1F000}, /* Uart4Rx */ + {0x00000B58, 0x01F1F000}, /* Uart4Tx */ + {0x00000B5C, 0x01F1F000}, /* UsbVbusEn0 */ + {0x00000B60, 0x01F1F000}, /* UsbVbusEn1 */ + {0x00000B64, 0x01F1F000}, /* WifiEn */ + {0x00000B68, 0x01F1F000}, /* WifiRst */ + {0x00000B6C, 0x01F1F000}, /* WifiWakeAp */ +}; + +static constexpr u32 PinmuxDrivePadNameMax = (sizeof(PinmuxDrivePadMap) / sizeof(PinmuxDrivePadMap[0])); \ No newline at end of file diff --git a/stratosphere/boot/source/boot_pinmux_utils.cpp b/stratosphere/boot/source/boot_pinmux_utils.cpp new file mode 100644 index 000000000..4a20edbf5 --- /dev/null +++ b/stratosphere/boot/source/boot_pinmux_utils.cpp @@ -0,0 +1,487 @@ +/* + * Copyright (c) 2018-2019 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope 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, see . + */ + +#include "boot_functions.hpp" +#include "boot_pinmux_map.hpp" + +static bool g_initialized_pinmux_vaddr = false; +static uintptr_t g_pinmux_vaddr = 0; + +static inline const PinmuxDefinition *GetPinmuxDefinition(u32 pinmux_name) { + if (pinmux_name >= PinmuxPadNameMax) { + std::abort(); + } + + return &PinmuxMap[pinmux_name]; +} + +static inline const PinmuxDrivePadDefinition *GetPinmuxDrivePadDefinition(u32 pinmux_name) { + if (pinmux_name >= PinmuxDrivePadNameMax) { + std::abort(); + } + + return &PinmuxDrivePadMap[pinmux_name]; +} + +static uintptr_t GetPinmuxBaseAddress() { + if (!g_initialized_pinmux_vaddr) { + u64 vaddr; + if (R_FAILED(svcQueryIoMapping(&vaddr, Boot::ApbMiscPhysicalBase, 0x4000))) { + std::abort(); + } + g_pinmux_vaddr = vaddr; + g_initialized_pinmux_vaddr = true; + } + return g_pinmux_vaddr; +} + +u32 Boot::PinmuxUpdatePark(u32 pinmux_name) { + const uintptr_t pinmux_base_vaddr = GetPinmuxBaseAddress(); + const PinmuxDefinition *pinmux_def = GetPinmuxDefinition(pinmux_name); + + /* Fetch this PINMUX's register offset */ + u32 pinmux_reg_offset = pinmux_def->reg_offset; + + /* Fetch this PINMUX's mask value */ + u32 pinmux_mask_val = pinmux_def->mask_val; + + /* Get current register ptr. */ + volatile u32 *pinmux_reg = reinterpret_cast(pinmux_base_vaddr + pinmux_reg_offset); + + /* Read from the PINMUX register */ + u32 pinmux_val = *pinmux_reg; + + /* This PINMUX supports park change */ + if (pinmux_mask_val & 0x20) { + /* Clear park status if set */ + if (pinmux_val & 0x20) { + pinmux_val &= ~(0x20); + } + } + + /* Write to the appropriate PINMUX register */ + *pinmux_reg = pinmux_val; + + /* Do a dummy read from the PINMUX register */ + pinmux_val = *pinmux_reg; + + return pinmux_val; +} + +u32 Boot::PinmuxUpdatePad(u32 pinmux_name, u32 pinmux_config_val, u32 pinmux_config_mask_val) { + const uintptr_t pinmux_base_vaddr = GetPinmuxBaseAddress(); + const PinmuxDefinition *pinmux_def = GetPinmuxDefinition(pinmux_name); + + /* Fetch this PINMUX's register offset */ + u32 pinmux_reg_offset = pinmux_def->reg_offset; + + /* Fetch this PINMUX's mask value */ + u32 pinmux_mask_val = pinmux_def->mask_val; + + /* Get current register ptr. */ + volatile u32 *pinmux_reg = reinterpret_cast(pinmux_base_vaddr + pinmux_reg_offset); + + /* Read from the PINMUX register */ + u32 pinmux_val = *pinmux_reg; + + /* This PINMUX register is locked */ + if (pinmux_val & 0x80) + return pinmux_val; + + u32 pm_config_val = (pinmux_config_val & 0x07); + u32 pm_val = pm_config_val; + + /* Adjust PM */ + if (pinmux_config_mask_val & 0x07) { + /* Default to safe value */ + if (pm_config_val >= 0x06) + pm_val = 0x04; + + /* Apply additional changes first */ + if (pm_config_val == 0x05) { + /* This pin supports PUPD change */ + if (pinmux_mask_val & 0x0C) { + /* Change PUPD */ + if ((pinmux_val & 0x0C) != 0x04) { + pinmux_val &= 0xFFFFFFF3; + pinmux_val |= 0x04; + } + } + + /* This pin supports Tristate change */ + if (pinmux_mask_val & 0x10) { + /* Change Tristate */ + if (!(pinmux_val & 0x10)) { + pinmux_val |= 0x10; + } + } + + /* This pin supports EInput change */ + if (pinmux_mask_val & 0x40) { + /* Change EInput */ + if (pinmux_val & 0x40) { + pinmux_val &= 0xFFFFFFBF; + } + } + + /* Default to safe value */ + pm_val = 0x04; + } + + /* Translate PM value if necessary */ + if ((pm_val & 0xFF) == 0x04) + pm_val = pinmux_def->pm_val; + + /* This pin supports PM change */ + if (pinmux_mask_val & 0x03) { + /* Change PM */ + if ((pinmux_val & 0x03) != (pm_val & 0x03)) { + pinmux_val &= 0xFFFFFFFC; + pinmux_val |= (pm_val & 0x03); + } + } + } + + u32 pupd_config_val = (pinmux_config_val & 0x18); + + /* Adjust PUPD */ + if (pinmux_config_mask_val & 0x18) { + if (pupd_config_val < 0x11) { + /* This pin supports PUPD change */ + if (pinmux_mask_val & 0x0C) { + /* Change PUPD */ + if ((pinmux_val & 0x0C) != (pupd_config_val >> 0x03)) { + pinmux_val &= 0xFFFFFFF3; + pinmux_val |= (pupd_config_val >> 0x01); + } + } + } + } + + u32 eod_config_val = (pinmux_config_val & 0x60); + + /* Adjust EOd field */ + if (pinmux_config_mask_val & 0x60) { + if (eod_config_val == 0x20) { + /* This pin supports Tristate change */ + if (pinmux_mask_val & 0x10) { + /* Change Tristate */ + if (!(pinmux_val & 0x10)) { + pinmux_val |= 0x10; + } + } + + /* This pin supports EInput change */ + if (pinmux_mask_val & 0x40) { + /* Change EInput */ + if (!(pinmux_val & 0x40)) { + pinmux_val |= 0x40; + } + } + + /* This pin supports EOd change */ + if (pinmux_mask_val & 0x800) { + /* Change EOd */ + if (pinmux_val & 0x800) { + pinmux_val &= 0xFFFFF7FF; + } + } + } else if (eod_config_val == 0x40) { + /* This pin supports Tristate change */ + if (pinmux_mask_val & 0x10) { + /* Change Tristate */ + if (pinmux_val & 0x10) { + pinmux_val &= 0xFFFFFFEF; + } + } + + /* This pin supports EInput change */ + if (pinmux_mask_val & 0x40) { + /* Change EInput */ + if (!(pinmux_val & 0x40)) { + pinmux_val |= 0x40; + } + } + + /* This pin supports EOd change */ + if (pinmux_mask_val & 0x800) { + /* Change EOd */ + if (pinmux_val & 0x800) { + pinmux_val &= 0xFFFFF7FF; + } + } + } else if (eod_config_val == 0x60) { + /* This pin supports Tristate change */ + if (pinmux_mask_val & 0x10) { + /* Change Tristate */ + if (pinmux_val & 0x10) { + pinmux_val &= 0xFFFFFFEF; + } + } + + /* This pin supports EInput change */ + if (pinmux_mask_val & 0x40) { + /* Change EInput */ + if (!(pinmux_val & 0x40)) { + pinmux_val |= 0x40; + } + } + + /* This pin supports EOd change */ + if (pinmux_mask_val & 0x800) { + /* Change EOd */ + if (!(pinmux_val & 0x800)) { + pinmux_val |= 0x800; + } + } + } else { + /* This pin supports Tristate change */ + if (pinmux_mask_val & 0x10) { + /* Change Tristate */ + if (pinmux_val & 0x10) { + pinmux_val &= 0xFFFFFFEF; + } + } + + /* This pin supports EInput change */ + if (pinmux_mask_val & 0x40) { + /* Change EInput */ + if (pinmux_val & 0x40) { + pinmux_val &= 0xFFFFFFBF; + } + } + + /* This pin supports EOd change */ + if (pinmux_mask_val & 0x800) { + /* Change EOd */ + if (pinmux_val & 0x800) { + pinmux_val &= 0xFFFFF7FF; + } + } + } + } + + u32 lock_config_val = (pinmux_config_val & 0x80); + + /* Adjust Lock */ + if (pinmux_config_mask_val & 0x80) { + /* This pin supports Lock change */ + if (pinmux_mask_val & 0x80) { + /* Change Lock */ + if ((pinmux_val ^ pinmux_config_val) & 0x80) { + pinmux_val &= 0xFFFFFF7F; + pinmux_val |= lock_config_val; + } + } + } + + u32 ioreset_config_val = ((pinmux_config_val >> 0x08) & 0x10000); + + /* Adjust IoReset */ + if (pinmux_config_mask_val & 0x100) { + /* This pin supports IoReset change */ + if (pinmux_mask_val & 0x10000) { + /* Change IoReset */ + if (((pinmux_val >> 0x10) ^ (pinmux_config_val >> 0x08)) & 0x01) { + pinmux_val |= ioreset_config_val; + } + } + } + + u32 park_config_val = ((pinmux_config_val >> 0x0A) & 0x20); + + /* Adjust Park */ + if (pinmux_config_mask_val & 0x400) { + /* This pin supports Park change */ + if (pinmux_mask_val & 0x20) { + /* Change Park */ + if (((pinmux_val >> 0x05) ^ (pinmux_config_val >> 0x0A)) & 0x01) { + pinmux_val |= park_config_val; + } + } + } + + u32 elpdr_config_val = ((pinmux_config_val >> 0x0B) & 0x100); + + /* Adjust ELpdr */ + if (pinmux_config_mask_val & 0x800) { + /* This pin supports ELpdr change */ + if (pinmux_mask_val & 0x100) { + /* Change ELpdr */ + if (((pinmux_val >> 0x08) ^ (pinmux_config_val >> 0x0B)) & 0x01) { + pinmux_val |= elpdr_config_val; + } + } + } + + u32 ehsm_config_val = ((pinmux_config_val >> 0x0C) & 0x200); + + /* Adjust EHsm */ + if (pinmux_config_mask_val & 0x1000) { + /* This pin supports EHsm change */ + if (pinmux_mask_val & 0x200) { + /* Change EHsm */ + if (((pinmux_val >> 0x09) ^ (pinmux_config_val >> 0x0C)) & 0x01) { + pinmux_val |= ehsm_config_val; + } + } + } + + u32 eiohv_config_val = ((pinmux_config_val >> 0x09) & 0x400); + + /* Adjust EIoHv */ + if (pinmux_config_mask_val & 0x200) { + /* This pin supports EIoHv change */ + if (pinmux_mask_val & 0x400) { + /* Change EIoHv */ + if (((pinmux_val >> 0x0A) ^ (pinmux_config_val >> 0x09)) & 0x01) { + pinmux_val |= eiohv_config_val; + } + } + } + + u32 eschmt_config_val = ((pinmux_config_val >> 0x0D) & 0x1000); + + /* Adjust ESchmt */ + if (pinmux_config_mask_val & 0x2000) { + /* This pin supports ESchmt change */ + if (pinmux_mask_val & 0x1000) { + /* Change ESchmt */ + if (((pinmux_val >> 0x0C) ^ (pinmux_config_val >> 0x0D)) & 0x01) { + pinmux_val |= eschmt_config_val; + } + } + } + + u32 preemp_config_val = ((pinmux_config_val >> 0x0D) & 0x8000); + + /* Adjust Preemp */ + if (pinmux_config_mask_val & 0x10000) { + /* This pin supports Preemp change */ + if (pinmux_mask_val & 0x8000) { + /* Change Preemp */ + if (((pinmux_val >> 0x0F) ^ (pinmux_config_val >> 0x10)) & 0x01) { + pinmux_val |= preemp_config_val; + } + } + } + + u32 drvtype_config_val = ((pinmux_config_val >> 0x0E) & 0x6000); + + /* Adjust DrvType */ + if (pinmux_config_mask_val & 0xC000) { + /* This pin supports DrvType change */ + if (pinmux_mask_val & 0x6000) { + /* Change DrvType */ + if (((pinmux_val >> 0x0D) ^ (pinmux_config_val >> 0x0E)) & 0x03) { + pinmux_val |= drvtype_config_val; + } + } + } + + /* Write to the appropriate PINMUX register */ + *pinmux_reg = pinmux_val; + + /* Do a dummy read from the PINMUX register */ + pinmux_val = *pinmux_reg; + + return pinmux_val; +} + +u32 Boot::PinmuxUpdateDrivePad(u32 pinmux_drivepad_name, u32 pinmux_drivepad_config_val, u32 pinmux_drivepad_config_mask_val) { + const uintptr_t pinmux_base_vaddr = GetPinmuxBaseAddress(); + const PinmuxDrivePadDefinition *pinmux_drivepad_def = GetPinmuxDrivePadDefinition(pinmux_drivepad_name); + + /* Fetch this PINMUX drive group's register offset */ + u32 pinmux_drivepad_reg_offset = pinmux_drivepad_def->reg_offset; + + /* Fetch this PINMUX drive group's mask value */ + u32 pinmux_drivepad_mask_val = pinmux_drivepad_def->mask_val; + + /* Get current register ptr. */ + volatile u32 *pinmux_drivepad_reg = reinterpret_cast(pinmux_base_vaddr + pinmux_drivepad_reg_offset); + + /* Read from the PINMUX drive group register */ + u32 pinmux_drivepad_val = *pinmux_drivepad_reg; + + /* Adjust DriveDownStrength */ + if (pinmux_drivepad_config_mask_val & 0x1F000) { + u32 mask_val = 0x7F000; + + /* Adjust mask value */ + if ((pinmux_drivepad_mask_val & 0x7F000) != 0x7F000) + mask_val = 0x1F000; + + /* This drive group supports DriveDownStrength change */ + if (pinmux_drivepad_mask_val & mask_val) { + /* Change DriveDownStrength */ + if (((pinmux_drivepad_config_val & 0x7F000) & mask_val) != (pinmux_drivepad_val & mask_val)) { + pinmux_drivepad_val &= ~(mask_val); + pinmux_drivepad_val |= ((pinmux_drivepad_config_val & 0x7F000) & mask_val); + } + } + } + + /* Adjust DriveUpStrength */ + if (pinmux_drivepad_config_mask_val & 0x1F00000) { + u32 mask_val = 0x7F00000; + + /* Adjust mask value */ + if ((pinmux_drivepad_mask_val & 0x7F00000) != 0x7F00000) + mask_val = 0x1F00000; + + /* This drive group supports DriveUpStrength change */ + if (pinmux_drivepad_mask_val & mask_val) { + /* Change DriveUpStrength */ + if (((pinmux_drivepad_config_val & 0x7F00000) & mask_val) != (pinmux_drivepad_val & mask_val)) { + pinmux_drivepad_val &= ~(mask_val); + pinmux_drivepad_val |= ((pinmux_drivepad_config_val & 0x7F00000) & mask_val); + } + } + } + + /* Adjust DriveDownSlew */ + if (pinmux_drivepad_config_mask_val & 0x30000000) { + /* This drive group supports DriveDownSlew change */ + if (pinmux_drivepad_mask_val & 0x30000000) { + /* Change DriveDownSlew */ + if ((pinmux_drivepad_val ^ pinmux_drivepad_config_val) & 0x30000000) { + pinmux_drivepad_val &= 0xCFFFFFFF; + pinmux_drivepad_val |= (pinmux_drivepad_config_val & 0x30000000); + } + } + } + + /* Adjust DriveUpSlew */ + if (pinmux_drivepad_config_mask_val & 0xC0000000) { + /* This drive group supports DriveUpSlew change */ + if (pinmux_drivepad_mask_val & 0xC0000000) { + /* Change DriveUpSlew */ + if ((pinmux_drivepad_val ^ pinmux_drivepad_config_val) & 0xC0000000) { + pinmux_drivepad_val &= 0x3FFFFFFF; + pinmux_drivepad_val |= (pinmux_drivepad_config_val & 0xC0000000); + } + } + } + + /* Write to the appropriate PINMUX drive group register */ + *pinmux_drivepad_reg = pinmux_drivepad_val; + + /* Do a dummy read from the PINMUX drive group register */ + pinmux_drivepad_val = *pinmux_drivepad_reg; + + return pinmux_drivepad_val; +} \ No newline at end of file diff --git a/stratosphere/boot/source/boot_types.hpp b/stratosphere/boot/source/boot_types.hpp index 2e5608055..b62f22add 100644 --- a/stratosphere/boot/source/boot_types.hpp +++ b/stratosphere/boot/source/boot_types.hpp @@ -30,3 +30,9 @@ struct GpioInitialConfig { GpioDirection direction; GpioValue value; }; + +struct PinmuxInitialConfig { + u32 name; + u32 val; + u32 mask; +}; \ No newline at end of file