mirror of
https://github.com/ByteWelder/Tactility.git
synced 2026-06-19 04:15:06 +00:00
280 lines
11 KiB
C++
280 lines
11 KiB
C++
#include "devices/Display.h"
|
|
#include "devices/SdCard.h"
|
|
#include "devices/Power.h"
|
|
|
|
#include <tactility/drivers/gpio_controller.h>
|
|
#include <tactility/drivers/i2c_controller.h>
|
|
|
|
#include <Tactility/hal/Configuration.h>
|
|
#include <Tactility/hal/i2c/I2c.h>
|
|
|
|
using namespace tt::hal;
|
|
|
|
static constexpr auto* TAG = "Tab5";
|
|
|
|
static DeviceVector createDevices() {
|
|
return {
|
|
createPower(),
|
|
createDisplay(),
|
|
createSdCard(),
|
|
};
|
|
}
|
|
|
|
/*
|
|
PI4IOE5V6408-0 (0x43)
|
|
- Bit 0: RF internal/external switch
|
|
- Bit 1: Speaker enable
|
|
- Bit 2: External 5V bus enable
|
|
- Bit 3: /
|
|
- Bit 4: LCD reset
|
|
- Bit 5: Touch reset
|
|
- Bit 6: Camera reset
|
|
- Bit 7: Headphone detect
|
|
*/
|
|
constexpr auto GPIO_EXP0_PIN_RF_INTERNAL_EXTERNAL = 0;
|
|
constexpr auto GPIO_EXP0_PIN_SPEAKER_ENABLE = 1;
|
|
constexpr auto GPIO_EXP0_PIN_EXTERNAL_5V_BUS_ENABLE = 2;
|
|
constexpr auto GPIO_EXP0_PIN_LCD_RESET = 4;
|
|
constexpr auto GPIO_EXP0_PIN_TOUCH_RESET = 5;
|
|
constexpr auto GPIO_EXP0_PIN_CAMERA_RESET = 6;
|
|
constexpr auto GPIO_EXP0_PIN_HEADPHONE_DETECT = 7;
|
|
|
|
/*
|
|
PI4IOE5V6408-1 (0x44)
|
|
- Bit 0: C6 WLAN enable
|
|
- Bit 1: /
|
|
- Bit 2: /
|
|
- Bit 3: USB-A 5V enable
|
|
- Bit 4: Device power: PWROFF_PLUSE
|
|
- Bit 5: IP2326: nCHG_QC_EN
|
|
- Bit 6: IP2326: CHG_STAT_LED
|
|
- Bit 7: IP2326: CHG_EN
|
|
*/
|
|
constexpr auto GPIO_EXP1_PIN_C6_WLAN_ENABLE = 0;
|
|
constexpr auto GPIO_EXP1_PIN_USB_A_5V_ENABLE = 3;
|
|
constexpr auto GPIO_EXP1_PIN_DEVICE_POWER = 4;
|
|
constexpr auto GPIO_EXP1_PIN_IP2326_NCHG_QC_EN = 5;
|
|
constexpr auto GPIO_EXP1_PIN_IP2326_CHG_STAT_LED = 6;
|
|
constexpr auto GPIO_EXP1_PIN_IP2326_CHG_EN = 7;
|
|
|
|
static void initExpander0(::Device* io_expander0) {
|
|
auto* rf_pin = gpio_descriptor_acquire(io_expander0, GPIO_EXP0_PIN_RF_INTERNAL_EXTERNAL, GPIO_OWNER_GPIO);
|
|
check(rf_pin);
|
|
auto* speaker_enable_pin = gpio_descriptor_acquire(io_expander0, GPIO_EXP0_PIN_SPEAKER_ENABLE, GPIO_OWNER_GPIO);
|
|
check(speaker_enable_pin);
|
|
auto* external_5v_bus_enable_pin = gpio_descriptor_acquire(io_expander0, GPIO_EXP0_PIN_EXTERNAL_5V_BUS_ENABLE, GPIO_OWNER_GPIO);
|
|
check(external_5v_bus_enable_pin);
|
|
auto* lcd_reset_pin = gpio_descriptor_acquire(io_expander0, GPIO_EXP0_PIN_LCD_RESET, GPIO_OWNER_GPIO);
|
|
check(lcd_reset_pin);
|
|
auto* touch_reset_pin = gpio_descriptor_acquire(io_expander0, GPIO_EXP0_PIN_TOUCH_RESET, GPIO_OWNER_GPIO);
|
|
check(touch_reset_pin);
|
|
auto* camera_reset_pin = gpio_descriptor_acquire(io_expander0, GPIO_EXP0_PIN_CAMERA_RESET, GPIO_OWNER_GPIO);
|
|
check(camera_reset_pin);
|
|
auto* headphone_detect_pin = gpio_descriptor_acquire(io_expander0, GPIO_EXP0_PIN_HEADPHONE_DETECT, GPIO_OWNER_GPIO);
|
|
check(headphone_detect_pin);
|
|
|
|
gpio_descriptor_set_flags(rf_pin, GPIO_FLAG_DIRECTION_OUTPUT);
|
|
gpio_descriptor_set_flags(speaker_enable_pin, GPIO_FLAG_DIRECTION_OUTPUT);
|
|
gpio_descriptor_set_flags(external_5v_bus_enable_pin, GPIO_FLAG_DIRECTION_OUTPUT);
|
|
gpio_descriptor_set_flags(lcd_reset_pin, GPIO_FLAG_DIRECTION_OUTPUT);
|
|
gpio_descriptor_set_flags(touch_reset_pin, GPIO_FLAG_DIRECTION_OUTPUT);
|
|
gpio_descriptor_set_flags(camera_reset_pin, GPIO_FLAG_DIRECTION_OUTPUT);
|
|
gpio_descriptor_set_flags(headphone_detect_pin, GPIO_FLAG_DIRECTION_INPUT);
|
|
|
|
gpio_descriptor_set_level(rf_pin, false);
|
|
gpio_descriptor_set_level(speaker_enable_pin, false);
|
|
gpio_descriptor_set_level(external_5v_bus_enable_pin, true);
|
|
gpio_descriptor_set_level(lcd_reset_pin, false);
|
|
gpio_descriptor_set_level(touch_reset_pin, false);
|
|
gpio_descriptor_set_level(camera_reset_pin, true);
|
|
vTaskDelay(pdMS_TO_TICKS(10));
|
|
// Enable touch and lcd, but not the camera
|
|
gpio_descriptor_set_level(lcd_reset_pin, true);
|
|
gpio_descriptor_set_level(touch_reset_pin, true);
|
|
|
|
gpio_descriptor_release(rf_pin);
|
|
gpio_descriptor_release(speaker_enable_pin);
|
|
gpio_descriptor_release(external_5v_bus_enable_pin);
|
|
gpio_descriptor_release(lcd_reset_pin);
|
|
gpio_descriptor_release(touch_reset_pin);
|
|
gpio_descriptor_release(camera_reset_pin);
|
|
gpio_descriptor_release(headphone_detect_pin);
|
|
}
|
|
|
|
static void initExpander1(::Device* io_expander1) {
|
|
|
|
auto* c6_wlan_enable_pin = gpio_descriptor_acquire(io_expander1, GPIO_EXP1_PIN_C6_WLAN_ENABLE, GPIO_OWNER_GPIO);
|
|
check(c6_wlan_enable_pin);
|
|
auto* usb_a_5v_enable_pin = gpio_descriptor_acquire(io_expander1, GPIO_EXP1_PIN_USB_A_5V_ENABLE, GPIO_OWNER_GPIO);
|
|
check(usb_a_5v_enable_pin);
|
|
auto* device_power_pin = gpio_descriptor_acquire(io_expander1, GPIO_EXP1_PIN_DEVICE_POWER, GPIO_OWNER_GPIO);
|
|
check(device_power_pin);
|
|
auto* ip2326_ncharge_qc_enable_pin = gpio_descriptor_acquire(io_expander1, GPIO_EXP1_PIN_IP2326_NCHG_QC_EN, GPIO_OWNER_GPIO);
|
|
check(ip2326_ncharge_qc_enable_pin);
|
|
auto* ip2326_charge_state_led_pin = gpio_descriptor_acquire(io_expander1, GPIO_EXP1_PIN_IP2326_CHG_STAT_LED, GPIO_OWNER_GPIO);
|
|
check(ip2326_charge_state_led_pin);
|
|
auto* ip2326_charge_enable_pin = gpio_descriptor_acquire(io_expander1, GPIO_EXP1_PIN_IP2326_CHG_EN, GPIO_OWNER_GPIO);
|
|
check(ip2326_charge_enable_pin);
|
|
|
|
gpio_descriptor_set_flags(c6_wlan_enable_pin, GPIO_FLAG_DIRECTION_OUTPUT);
|
|
gpio_descriptor_set_flags(usb_a_5v_enable_pin, GPIO_FLAG_DIRECTION_OUTPUT);
|
|
gpio_descriptor_set_flags(device_power_pin, GPIO_FLAG_DIRECTION_OUTPUT);
|
|
gpio_descriptor_set_flags(ip2326_ncharge_qc_enable_pin, GPIO_FLAG_DIRECTION_OUTPUT);
|
|
gpio_descriptor_set_flags(ip2326_charge_state_led_pin, GPIO_FLAG_DIRECTION_OUTPUT);
|
|
gpio_descriptor_set_flags(ip2326_charge_enable_pin, GPIO_FLAG_DIRECTION_INPUT | GPIO_FLAG_PULL_UP);
|
|
|
|
gpio_descriptor_set_level(c6_wlan_enable_pin, true);
|
|
gpio_descriptor_set_level(usb_a_5v_enable_pin, true);
|
|
gpio_descriptor_set_level(device_power_pin, false);
|
|
gpio_descriptor_set_level(ip2326_ncharge_qc_enable_pin, false);
|
|
gpio_descriptor_set_level(ip2326_charge_state_led_pin, false);
|
|
|
|
gpio_descriptor_release(c6_wlan_enable_pin);
|
|
gpio_descriptor_release(usb_a_5v_enable_pin);
|
|
gpio_descriptor_release(device_power_pin);
|
|
gpio_descriptor_release(ip2326_ncharge_qc_enable_pin);
|
|
gpio_descriptor_release(ip2326_charge_state_led_pin);
|
|
gpio_descriptor_release(ip2326_charge_enable_pin);
|
|
}
|
|
|
|
static error_t initSound(::Device* i2c_controller, ::Device* io_expander0 = nullptr) {
|
|
// Init data from M5Unified:
|
|
// https://github.com/m5stack/M5Unified/blob/master/src/M5Unified.cpp
|
|
static constexpr uint8_t ES8388_I2C_ADDR = 0x10;
|
|
static constexpr uint8_t ENABLED_BULK_DATA[] = {
|
|
0, 0x80, // RESET/ CSM POWER ON
|
|
0, 0x00,
|
|
0, 0x00,
|
|
0, 0x0E,
|
|
1, 0x00,
|
|
2, 0x0A, // CHIP POWER: power up all
|
|
3, 0xFF, // ADC POWER: power down all
|
|
4, 0x3C, // DAC POWER: power up and LOUT1/ROUT1/LOUT2/ROUT2 enable
|
|
5, 0x00, // ChipLowPower1
|
|
6, 0x00, // ChipLowPower2
|
|
7, 0x7C, // VSEL
|
|
8, 0x00, // set I2S slave mode
|
|
// reg9-22 == adc
|
|
23, 0x18, // I2S format (16bit)
|
|
24, 0x00, // I2S MCLK ratio (128)
|
|
25, 0x20, // DAC unmute
|
|
26, 0x00, // LDACVOL 0x00~0xC0
|
|
27, 0x00, // RDACVOL 0x00~0xC0
|
|
28, 0x08, // enable digital click free power up and down
|
|
29, 0x00,
|
|
38, 0x00, // DAC CTRL16
|
|
39, 0xB8, // LEFT Ch MIX
|
|
42, 0xB8, // RIGHTCh MIX
|
|
43, 0x08, // ADC and DAC separate
|
|
45, 0x00, // 0x00=1.5k VREF analog output / 0x10=40kVREF analog output
|
|
46, 0x21,
|
|
47, 0x21,
|
|
48, 0x21,
|
|
49, 0x21
|
|
};
|
|
|
|
error_t error = i2c_controller_write_register_array(
|
|
i2c_controller,
|
|
ES8388_I2C_ADDR,
|
|
ENABLED_BULK_DATA,
|
|
sizeof(ENABLED_BULK_DATA),
|
|
pdMS_TO_TICKS(1000)
|
|
);
|
|
if (error != ERROR_NONE) {
|
|
LOG_E(TAG, "Failed to enable ES8388: %s", error_to_string(error));
|
|
return error;
|
|
}
|
|
|
|
auto* speaker_enable_pin = gpio_descriptor_acquire(io_expander0, GPIO_EXP0_PIN_SPEAKER_ENABLE, GPIO_OWNER_GPIO);
|
|
check(speaker_enable_pin, "Failed to acquire speaker enable pin");
|
|
error = gpio_descriptor_set_level(speaker_enable_pin, true);
|
|
gpio_descriptor_release(speaker_enable_pin);
|
|
if (error != ERROR_NONE) {
|
|
LOG_E(TAG, "Failed to enable amplifier: %s", error_to_string(error));
|
|
return ERROR_RESOURCE;
|
|
}
|
|
|
|
return ERROR_NONE;
|
|
}
|
|
|
|
static error_t initMicrophone(::Device* i2c_controller) {
|
|
// ES7210 quad-channel microphone ADC at 0x40.
|
|
// Register sequence from M5Unified (M5Unified.cpp, _microphone_enabled_cb_tab5).
|
|
// Configures 4-slot TDM output at 48kHz/16-bit with MIC1+MIC2 active and MICBIAS enabled.
|
|
static constexpr uint8_t ES7210_I2C_ADDR = 0x40;
|
|
static constexpr uint8_t INIT_DATA[] = {
|
|
0x00, 0xFF, // RESET_CTL: full reset
|
|
0x00, 0x41, // RESET_CTL: release reset, keep CSM active
|
|
0x01, 0x1F, // CLK_ON_OFF: enable all clocks
|
|
0x06, 0x00, // DIGITAL_PDN: power up all digital blocks
|
|
0x07, 0x20, // ADC_OSR: OSR=256
|
|
0x08, 0x10, // MODE_CFG: I2S slave, TDM mode
|
|
0x09, 0x30, // TCT0_CHPINI: chopper init period
|
|
0x0A, 0x30, // TCT1_CHPINI
|
|
0x20, 0x0A, // ADC34_HPF2
|
|
0x21, 0x2A, // ADC34_HPF1
|
|
0x22, 0x0A, // ADC12_HPF2
|
|
0x23, 0x2A, // ADC12_HPF1
|
|
0x02, 0xC1, // CLK_CTRL: MCLK from I2S, PLL off
|
|
0x04, 0x01, // SDPOUT_CTL1: TDM output enable
|
|
0x05, 0x00, // SDPOUT_CTL0
|
|
0x11, 0x60, // DBIAS: adjust reference voltage for P4
|
|
0x40, 0x42, // ANALOG_SYS: enable analog supply
|
|
0x41, 0x70, // MICBIAS12: enable MICBIAS for MIC1+MIC2
|
|
0x42, 0x70, // MICBIAS34: enable MICBIAS for MIC3+MIC4
|
|
0x43, 0x1B, // MIC1_GAIN: +30 dB
|
|
0x44, 0x1B, // MIC2_GAIN: +30 dB
|
|
0x45, 0x00, // MIC3_GAIN: AEC ref, no gain
|
|
0x46, 0x00, // MIC4_GAIN: AEC ref, no gain
|
|
0x47, 0x00, // MIC1_LP
|
|
0x48, 0x00, // MIC2_LP
|
|
0x49, 0x00, // MIC3_LP
|
|
0x4A, 0x00, // MIC4_LP
|
|
0x4B, 0x00, // MIC12_PDN: power up MIC1+MIC2
|
|
0x4C, 0xFF, // MIC34_PDN: keep MIC3+MIC4 in power-down (AEC ref not needed)
|
|
0x01, 0x14, // CLK_ON_OFF: final clock config
|
|
};
|
|
|
|
error_t error = i2c_controller_write_register_array(
|
|
i2c_controller,
|
|
ES7210_I2C_ADDR,
|
|
INIT_DATA,
|
|
sizeof(INIT_DATA),
|
|
pdMS_TO_TICKS(1000)
|
|
);
|
|
if (error != ERROR_NONE) {
|
|
LOG_E(TAG, "Failed to init ES7210: %s", error_to_string(error));
|
|
}
|
|
return error;
|
|
}
|
|
|
|
static bool initBoot() {
|
|
auto* i2c0 = device_find_by_name("i2c0");
|
|
check(i2c0, "i2c0 not found");
|
|
|
|
auto* io_expander0 = device_find_by_name("io_expander0");
|
|
check(io_expander0, "io_expander0 not found");
|
|
auto* io_expander1 = device_find_by_name("io_expander1");
|
|
check(io_expander1, "io_expander1 not found");
|
|
|
|
initExpander0(io_expander0);
|
|
initExpander1(io_expander1);
|
|
|
|
error_t error = initSound(i2c0, io_expander0);
|
|
if (error != ERROR_NONE) {
|
|
LOG_E(TAG, "Failed to enable ES8388");
|
|
}
|
|
|
|
error = initMicrophone(i2c0);
|
|
if (error != ERROR_NONE) {
|
|
LOG_E(TAG, "Failed to init ES7210");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
extern const Configuration hardwareConfiguration = {
|
|
.initBoot = initBoot,
|
|
.createDevices = createDevices
|
|
};
|