diff --git a/internal_filesystem/lib/drivers/__init__.py b/internal_filesystem/lib/drivers/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/internal_filesystem/lib/drivers/display/st7701s/__init__.py b/internal_filesystem/lib/drivers/display/st7701s/__init__.py
new file mode 100644
index 00000000..dd3173fd
--- /dev/null
+++ b/internal_filesystem/lib/drivers/display/st7701s/__init__.py
@@ -0,0 +1,16 @@
+import sys
+from . import st7701s
+from . import _st7701s_init
+
+# Register _st7701s_init in sys.modules so __import__('_st7701s_init') can find it
+# This is needed because display_driver_framework.py uses __import__('_st7701s_init')
+# expecting a top-level module, but _st7701s_init is in the st7701s package subdirectory
+sys.modules['_st7701s_init'] = _st7701s_init
+
+# Explicitly define __all__ and re-export public symbols from st7701s module
+__all__ = [
+    'ST7701S',
+]
+
+# Re-export the public symbols
+ST7701S = st7701s.ST7701S
diff --git a/internal_filesystem/lib/drivers/display/st7701s/_st7701s_init.py b/internal_filesystem/lib/drivers/display/st7701s/_st7701s_init.py
new file mode 100644
index 00000000..59bd1571
--- /dev/null
+++ b/internal_filesystem/lib/drivers/display/st7701s/_st7701s_init.py
@@ -0,0 +1,89 @@
+# ST7701S initialization
+
+import time
+from micropython import const
+
+_SWRESET = const(0x01)
+_SLPOUT = const(0x11)
+_DISPON = const(0x29)
+_MADCTL = const(0x36)
+_COLMOD = const(0x3A)
+_LCD_DELAY = const(0xFF)
+_CASET = const(0x2A)
+_RASET = const(0x2B)
+_INVOFF = const(0x20)
+_INVON = const(0x21)
+
+
+def init(self):
+    print("_st7701s_init.py Send initialization commands to ST7701S...")
+
+    # ST7701S init sequence
+    seq = [
+        # (cmd, data) or (None, ms) for delay
+        (_SWRESET, None),
+        (None, 150),
+        (_SLPOUT, None),
+        (None, 100),
+        (0xFF, [0x77, 0x01, 0x00, 0x00, 0x10]),
+        (0xC0, [0x3B, 0x00]),
+        (0xC1, [0x0D, 0x02]),
+        (0xC2, [0x21, 0x08]),
+        (0xCD, [0x08]),
+        (0xB0, [0x00, 0x11, 0x18, 0x0E, 0x11, 0x06, 0x07, 0x08, 0x07, 0x22, 0x04, 0x12, 0x0F, 0xAA, 0x31, 0x18]),
+        (0xB1, [0x00, 0x11, 0x19, 0x0E, 0x12, 0x07, 0x08, 0x08, 0x08, 0x22, 0x04, 0x11, 0x11, 0xA9, 0x32, 0x18]),
+        (0xFF, [0x77, 0x01, 0x00, 0x00, 0x11]),
+        (0xB0, [0x60]),
+        (0xB1, [0x30]),
+        (0xB2, [0x87]),
+        (0xB3, [0x80]),
+        (0xB5, [0x49]),
+        (0xB7, [0x85]),
+        (0xB8, [0x21]),
+        (0xC1, [0x78]),
+        (0xC2, [0x78]),
+        (None, 20),
+        (0xE0, [0x00, 0x1B, 0x02]),
+        (0xE1, [0x08, 0xA0, 0x00, 0x00, 0x07, 0xA0, 0x00, 0x00, 0x00, 0x44, 0x44]),
+        (0xE2, [0x11, 0x11, 0x44, 0x44, 0xA0, 0x00, 0x00, 0xEC, 0xA0, 0x00, 0x00]),
+        (0xE3, [0x00, 0x00, 0x11, 0x11]),
+        (0xE4, [0x44, 0x44]),
+        (0xE5, [0x0A, 0xE9, 0xD8, 0xA0, 0x0C, 0xEB, 0xD8, 0xA0, 0x0E, 0xED, 0xD8, 0xA0, 0x10, 0xEF, 0xD8, 0xA0]),
+        (0xE6, [0x00, 0x00, 0x11, 0x11]),
+        (0xE7, [0x44, 0x44]),
+        (0xE8, [0x09, 0xE8, 0xD8, 0xA0, 0x0B, 0xEA, 0xD8, 0xA0, 0x0D, 0xEC, 0xD8, 0xA0, 0x0F, 0xEE, 0xD8, 0xA0]),
+        (0xEB, [0x02, 0x00, 0xE4, 0xE4, 0x88, 0x00, 0x40]),
+        (0xEC, [0x3C, 0x00]),
+        (0xED, [0xAB, 0x89, 0x76, 0x54, 0x02, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x20, 0x45, 0x67, 0x98, 0xBA]),
+        (0xFF, [0x77, 0x01, 0x00, 0x00, 0x00]),
+        (_MADCTL, [0x00]),
+        (_COLMOD, [0x66]),
+        (0x21, None),
+        (None, 120),
+        (None, 120),
+        # Column address set (CASET):
+        (_CASET, [0x00, 0x00, (self.display_width >> 8) & 0xFF, self.display_width & 0xFF]),
+        # Page address set (RASET):
+        (_RASET, [0x00, 0x00, (self.display_height >> 8) & 0xFF, self.display_height & 0xFF]),
+        (_DISPON, None),
+        (None, 120),
+        (_INVOFF, None),
+    ]
+
+    if self.set_params_func:
+        print("Using custom set_params_func for initialization")
+        set_params = self.set_params_func
+    else:
+        print("Using default set_params method for initialization")
+        set_params = self.set_params
+
+    for cmd, data in seq:
+        if cmd is None:
+            time.sleep_ms(data)
+        else:
+            if data is None:
+                set_params(cmd)
+            else:
+                set_params(cmd, bytearray(data))
+
+    print("_st7701s_init.py initialization complete")
diff --git a/internal_filesystem/lib/drivers/display/st7701s/st7701s.py b/internal_filesystem/lib/drivers/display/st7701s/st7701s.py
new file mode 100644
index 00000000..c695d025
--- /dev/null
+++ b/internal_filesystem/lib/drivers/display/st7701s/st7701s.py
@@ -0,0 +1,53 @@
+import lvgl as lv
+import rgb_display_framework
+
+
+class ST7701S(rgb_display_framework.RGBDisplayDriver):
+    def __init__(
+        self,
+        data_bus,
+        display_width,
+        display_height,
+        frame_buffer1=None,
+        frame_buffer2=None,
+        reset_pin=None,
+        reset_state=rgb_display_framework.STATE_HIGH,
+        power_pin=None,
+        power_on_state=rgb_display_framework.STATE_HIGH,
+        backlight_pin=None,
+        backlight_on_state=rgb_display_framework.STATE_HIGH,
+        offset_x=0,
+        offset_y=0,
+        color_byte_order=rgb_display_framework.BYTE_ORDER_RGB,
+        color_space=lv.COLOR_FORMAT.RGB888,
+        set_params_func=None,
+    ):
+        super().__init__(
+            data_bus=data_bus,
+            display_width=display_width,
+            display_height=display_height,
+            frame_buffer1=frame_buffer1,
+            frame_buffer2=frame_buffer2,
+            reset_pin=reset_pin,
+            reset_state=reset_state,
+            power_pin=power_pin,
+            power_on_state=power_on_state,
+            backlight_pin=backlight_pin,
+            backlight_on_state=backlight_on_state,
+            offset_x=offset_x,
+            offset_y=offset_y,
+            color_byte_order=color_byte_order,
+            color_space=color_space,
+            rgb565_byte_swap=False,
+        )
+        self.set_params_func = set_params_func
+
+        mod_name = f'_st7701s_init'
+        mod = __import__(mod_name)
+        mod.init(self)
+
+    def set_params(self, cmd, params=None):
+        if self.set_params_func:
+            self.set_params_func(cmd, params)
+        else:
+            super().set_params(cmd, params)
diff --git a/internal_filesystem/lib/drivers/io_expander/__init__.py b/internal_filesystem/lib/drivers/io_expander/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/internal_filesystem/lib/drivers/io_expander/tca9555.py b/internal_filesystem/lib/drivers/io_expander/tca9555.py
new file mode 100644
index 00000000..5030ef9c
--- /dev/null
+++ b/internal_filesystem/lib/drivers/io_expander/tca9555.py
@@ -0,0 +1,81 @@
+import struct
+
+import i2c
+import machine
+from micropython import const
+
+
+class TCA9555:
+    """
+    LCA9555 / TCA9555 IO expansion chip
+    (LCA9555 is register-compatible with TCA9555)
+    """
+
+    # Register addresses
+    REG_INPUT = const(0x00)
+    REG_OUTPUT = const(0x02)
+    REG_CONFIG = const(0x06)
+
+    def __init__(self, i2c_bus: i2c.I2C.Bus, dev_id: int):
+        self.tca_dev = i2c.I2C.Device(bus=i2c_bus, dev_id=dev_id)
+        self.directions = 0xFFFF  # All inputs by default
+        self.output_states = 0x0000  # All low by default
+
+        # Set IO expander initially as all inputs
+        self._write_word(0x06, self.directions)
+
+        # Read current directions and states
+        self.directions = self._read_word(0x06)
+        self.output_states = self._read_word(0x02)
+
+    def _write_word(self, reg, value):
+        print(f"Writing to TCA9555: reg={reg:#02x}, value={value:#04x}")
+        self.tca_dev.write(bytes([reg, value & 0xFF, (value >> 8) & 0xFF]))
+
+    def _read_word(self, reg):
+        self.tca_dev.write(bytes([reg]))
+        data = self.tca_dev.read(2)
+        return struct.unpack("<H", data)[0]
+
+    def pin_mode(self, pin, mode):
+        if pin & 0x40:  # Pins with 0x40 bit set are controlled by TCA9555
+            pin &= 0xBF  # Mask out high bit
+            if mode == machine.Pin.OUT:
+                self.directions &= ~(1 << pin)
+            else:
+                self.directions |= 1 << pin
+            self._write_word(self.REG_OUTPUT, self.directions)
+        else:
+            # Handle standard ESP32 pin
+            machine.Pin(pin, mode)
+
+    def digital_write(self, pin, value):
+        if pin & 0x40:  # Pins with 0x40 bit set are controlled by TCA9555
+            pin &= 0xBF
+            if value:
+                self.output_states |= 1 << pin
+            else:
+                self.output_states &= ~(1 << pin)
+            self._write_word(self.REG_OUTPUT, self.output_states)
+
+            # Ensure pin is set to output
+            self.directions &= ~(1 << pin)
+            self._write_word(self.REG_CONFIG, self.directions)
+        else:
+            # Handle standard ESP32 pin
+            p = machine.Pin(pin, machine.Pin.OUT)
+            p.value(value)
+
+    def digital_read(self, pin):
+        if pin & 0x40:  # Pins with 0x40 bit set are controlled by TCA9555
+            pin &= 0xBF
+            # Ensure pin is set to input
+            self.directions |= 1 << pin
+            self._write_word(self.REG_CONFIG, self.directions)
+
+            inputs = self._read_word(self.REG_INPUT)
+            return 1 if (inputs & (1 << pin)) else 0
+        else:
+            # Handle standard ESP32 pin
+            p = machine.Pin(pin, machine.Pin.IN)
+            return p.value()
diff --git a/internal_filesystem/lib/mpos/board/squixl.py b/internal_filesystem/lib/mpos/board/squixl.py
new file mode 100644
index 00000000..5f68ccbe
--- /dev/null
+++ b/internal_filesystem/lib/mpos/board/squixl.py
@@ -0,0 +1,479 @@
+print("squixl.py initialization")
+"""
+Hardware initialization for the SQUiXL device by "Unexpected Maker"
+https://unexpectedmaker.com/shop.html#!/SQUiXL/p/743870537
+
+https://github.com/UnexpectedMaker/SQUiXL-DevOS
+https://github.com/UnexpectedMaker/SQUiXL-DevOS/blob/main/platformio/src/squixl.h
+
+https://github.com/UnexpectedMaker/SQUiXL
+https://github.com/UnexpectedMaker/SQUiXL/blob/main/examples/micropython/lib/squixl.py
+https://github.com/UnexpectedMaker/SQUiXL/blob/main/esphome/readme.md
+
+* ESP32-S3 - 32Bit Dual Core 240MHz
+* ST7701S - 4 Inch 480x480 RGB Display
+* GT911 - Capacitive Touch controller
+* LCA9555 IO expander (register-compatible with the TCA9555)
+* TMUX1574RSVR - IO MUX
+* MAX98357A - I2S Audio Amplifier (8 Ohm, 2W Speaker)
+* DRV2605L - Haptic feedback motor
+* RV-3028-C7 - I2C Low Power RTC
+* MAX1704X - I2C Battery Fuel Gauge
+
+Before you can install MicroPython, you need to erase the Flash on your SQUiXL.
+
+Power it up and put it into download mode by following these steps:
+
+    Press and hold the [BOOT] button
+    Press and release the [RESET] button
+    Release the [BOOT] button
+
+Now the board is in download mode and the native USB will have enumerated as a serial device.
+
+The SQUiXL display uses an ST7701S controller with a standard ESP32-S3 RGB parallel bus for pixel
+data. However, the display's SPI init lines (CS, CLK, MOSI, Reset) are wired through an LCA9555
+IO expander over I2C instead of native GPIO.
+
+This component handles that by bit-banging the SPI init sequence through the IO expander during
+startup, then handing off to ESPHome's standard RGB display driver for all pixel operations.
+
+The GT911 capacitive touch controller's reset pin is also on the IO expander (pin 5).
+This component handles the GT911 reset with the correct INT pin state for I2C address selection.
+
+The LCA9555 is register-compatible with the TCA9555.
+
+
+Original author: https://github.com/jedie
+"""
+
+"""
+| ESP32-S3 | GENERAl IO    |
+| -------- | ------------- |
+| IO0      | BOOT          |
+| IO1      | I2C SDA       |
+| IO2      | I2C SCL       |
+| IO3      | Touch IC INT  |
+| IO40     | Backlight PWM |
+| IO41     | IOMUX 1       |
+| IO42     | IOMUX 2       |
+| IO43     | FG Interrupt  |
+| IO44     | RTC Interrupt |
+| IO45     | IOMUX 3       |
+| IO46     | IOMUX 4       |
+
+
+| IO Expander |           |
+| ----------- | --------- |
+| IO0  | Backlight Enable |
+| I01  | LCD Reset        |
+| IO2  | LCD Data         |
+| IO3  | LCD SCK          |
+| IO4  | LCD CS           |
+| IO5  | Touch IC Reset   |
+| IO7  | uSD Card Detect  |
+| IO8  | IOMUX SEL        |
+| IO9  | IOMUX Enable     |
+| IO10 | Haptics Enable   |
+| IO11 | VBUS Sense       |
+
+| IOMUX | FUNC 1  | FUNC 2    |
+| ----- | ------- | --------  |
+| IO1   | SD MISO | I2S SD    |
+| IO2   | SD CS   | I2S LRCLK |
+| IO3   | SD CLK  | I2S DATA  |
+| IO4   | SD MOSI | I2S BCLK  |
+
+| RGB Peripheral |       |
+| -------------- | ----- |
+| ESP32-S3       | FUNC  |
+| IO4            | R5    |
+| IO5            | R4    |
+| IO6            | R3    |
+| IO7            | R2    |
+| IO8            | R1    |
+| IO9            | G5    |
+| IO10           | G4    |
+| IO11           | G3    |
+| IO12           | G2    |
+| IO13           | G1    |
+| IO14           | G0    |
+| IO15           | B5    |
+| IO16           | B4    |
+| IO17           | B3    |
+| IO18           | B2    |
+| IO21           | B1    |
+| IO38           | DE    |
+| IO39           | PCLK  |
+| IO47           | VSYNC |
+| IO48           | HSYNC |
+"""
+
+import sys
+import time
+
+for i in range(2, 0, -1):
+    print(f"squixl.py starting in {i}...")
+    time.sleep(1)
+
+import i2c
+import lcd_bus
+import lvgl as lv
+import machine
+import mpos.ui
+from drivers.display.st7701s.st7701s import ST7701S
+from drivers.io_expander.tca9555 import TCA9555
+from micropython import const
+
+# S3 IO
+SPI_HOST = const(0)
+I2C_BUS = const(0)
+I2C_FREQ = const(400_000)
+SDA = const(1)
+SCL = const(2)
+
+DE = const(38)
+PCLK = const(39)
+BL_PWM = const(40)
+VSYNC = const(47)
+HSYNC = const(48)
+
+# IOconst( MUX)
+IOMUX_OFF = const(0)
+IOMUX_SD = const(1)
+IOMUX_I2S = const(2)
+
+IOMUX_D1 = const(41)
+IOMUX_D2 = const(42)
+IOMUX_D3 = const(45)
+IOMUX_D4 = const(46)
+
+# GT911 touch pins:
+TP_I2C_IRQ = const(3)
+TP_I2C_RESET = const(5)
+
+# ======= AUDIO CONFIGURATION =======
+I2S_ID = 0
+I2S_BUFFER_LENGTH_IN_BYTES = 2000
+SAMPLE_SIZE_IN_BITS = 16
+# FORMAT = I2S.MONO  # only MONO supported in this example
+SAMPLE_RATE_IN_HZ = 22_050
+# ======= AUDIO CONFIGURATION =======
+
+# IOMUX default state, which is off
+current_iomux_state = IOMUX_OFF
+
+# Data pins in R0–R4, G0–G5, B0–B4 order
+RGB_IO = [
+    # B0–B4
+    21, 18, 17, 16, 15,
+    # G0–G5
+    14, 13, 12, 11, 10, 9,
+    # R0–R4
+    8, 7, 6, 5, 4,
+]
+
+# Macro for the delay value
+LCD_DELAY = 0xFF
+
+
+# LCD and AUDIO vars
+lcd = None
+audio_out = None
+
+# BACKLIGHT control - wil be functional soon
+# back_light = PWM(BL_PWM, freq=6000, duty_u16=8192)
+# back_light.duty_u16(32768)
+
+
+try:
+    print(f"squixl.py init i2c Bus with: scl={SCL}, sda={SDA}...")
+    i2c_bus = i2c.I2C.Bus(
+        host=I2C_BUS, scl=SCL, sda=SDA, freq=I2C_FREQ, use_locks=False
+    )
+except Exception as e:
+    sys.print_exception(e)
+    print("Attempting hard reset in 3sec...")
+    time.sleep(3)
+    machine.reset()
+else:
+    print("Scanning I2C bus for devices...")
+    for dev in i2c_bus.scan():
+        print(f"Found I2C device at address: {dev} (${dev:#02X})")
+    # Typical output here is:
+    # Found I2C device at address: 32 ($0X20) - TCA9555 IO Expander
+    # Found I2C device at address: 54 ($0X36)
+    # Found I2C device at address: 82 ($0X52)
+    # Found I2C device at address: 90 ($0X5A)
+    # Found I2C device at address: 93 ($0X5D)
+
+
+# # Create an instance of the MAX17048 class
+# max17048 = MAX17048(i2c)
+#
+
+
+class SQUiXL:
+    TCA9555_I2C_DEV_ID = const(32)  # 0x20 - TI TCA9555's I²C addr
+
+    # Expander pins (0-15)
+    BL_EN = const(0)  # Backlight Enable
+    LCD_RST = const(1)  # LCD Reset
+
+    MOSI = const(2)  # CD SPI Data
+    CLK = const(3)  # CD SPI Clock
+    CS = const(4)  # CD SPI CS
+
+    TP_RST = const(5)  # Touch IC Reset
+    SOFT_PWR = const(6)  # SD Card Detect
+    MUX_SEL = const(8)  # IOMUX Select
+    MUX_EN = const(9)  # IOMUX Enable
+    HAPTICS_EN = const(10)  # Haptics Enable
+    VBUS_SENSE = const(11)  # VBUS Sense
+    SD_DETECT = const(15)
+
+    def __init__(self, i2c: i2c.I2C.Bus):
+        self.i2c = i2c
+        self.tca = TCA9555(self.i2c, dev_id=self.TCA9555_I2C_DEV_ID)
+
+        self.lcd_reset()
+        self.set_lcd_backlight(on=True)
+
+        print("Screen soft power EN")
+        self.tca.pin_mode(self.SOFT_PWR, machine.Pin.OUT)
+
+        print("5V presense sense IO")
+        self.tca.pin_mode(self.VBUS_SENSE, machine.Pin.IN)
+
+        print("IO MUX - EN is Active LOW, so start it off")
+        self.tca.pin_mode(self.MUX_EN, machine.Pin.OUT)
+
+        print("IO MUX - Set default to I2S - LOW is SD")
+        self.tca.pin_mode(self.MUX_SEL, machine.Pin.OUT)
+
+        print("Haptic EN")
+        self.tca.pin_mode(self.HAPTICS_EN, machine.Pin.OUT)
+
+    def set_params(self, cmd, params=None):
+        """
+        Send a command and optional data bytes to the display via bit-banged SPI over the IO expander.
+        :param cmd: Command byte to send
+        :param params: Optional list/tuple of data bytes to send after the command
+        """
+        print(f"set_params: cmd=0x{cmd:02X}", end=" ")
+        if params:
+            print("params:", " ".join(f"{b:02X}" for b in params))
+        else:
+            print("no params")
+
+        # Start transaction
+        self.tca.pin_mode(self.CS, machine.Pin.PULL_DOWN)
+        # DC bit = 0 for command
+        self.tca.pin_mode(self.CLK, machine.Pin.PULL_DOWN)
+        self.tca.pin_mode(self.MOSI, 0)
+        self.tca.pin_mode(self.CLK, machine.Pin.PULL_UP)
+        # Send 8-bit command
+        for bit in range(7, -1, -1):
+            self.tca.pin_mode(self.CLK, machine.Pin.PULL_DOWN)
+            self.tca.pin_mode(self.MOSI, (cmd >> bit) & 1)
+            self.tca.pin_mode(self.CLK, machine.Pin.PULL_UP)
+        # Send data bytes if any
+        if params:
+            for data_byte in params:
+                # DC bit = 1 for data
+                self.tca.pin_mode(self.CLK, machine.Pin.PULL_DOWN)
+                self.tca.pin_mode(self.MOSI, 1)
+                self.tca.pin_mode(self.CLK, machine.Pin.PULL_UP)
+                for bit in range(7, -1, -1):
+                    self.tca.pin_mode(self.CLK, machine.Pin.PULL_DOWN)
+                    self.tca.pin_mode(self.MOSI, (data_byte >> bit) & 1)
+                    self.tca.pin_mode(self.CLK, machine.Pin.PULL_UP)
+        # End transaction
+        self.tca.pin_mode(self.CS, machine.Pin.PULL_UP)
+
+    def get_vbus_present(self):
+        print("Detect if VBUS (5V) power source is present:", end=" ")
+        # return self.tca.read(VBUS_SENSE) == 1
+        raw_value = self.tca.digital_read(self.VBUS_SENSE)
+        print(f"{raw_value=}")
+        return raw_value == 1
+
+    def set_lcd_backlight(self, *, on: bool):
+        """
+        Enable or disable the LCD backlight via IO expander BL_EN pin.
+        :param enable: True to turn on, False to turn off
+        """
+        self.tca.pin_mode(self.BL_EN, machine.Pin.OUT)
+        print(f"Setting LCD backlight {'ON' if on else 'OFF'} (BL_EN={self.BL_EN})")
+        self.tca.digital_write(self.BL_EN, 1 if on else 0)
+
+    def lcd_reset(self):
+        print("Resetting LCD...")
+        self.tca.pin_mode(self.LCD_RST, machine.Pin.OUT)
+
+        self.tca.digital_write(self.LCD_RST, 0)  # Assert reset
+        time.sleep_ms(100)  # Hold reset for 100ms
+        self.tca.digital_write(self.LCD_RST, 1)  # Deassert reset
+        time.sleep_ms(100)  # Wait for LCD to come out of reset
+
+
+print("Create instance of the LCA9555 IO Expander...")
+squixl = SQUiXL(i2c=i2c_bus)
+squixl.set_lcd_backlight(on=False)
+time.sleep(0.5)
+squixl.set_lcd_backlight(on=True)
+
+
+# TODO: Initialise the GT911 touch IC
+# touch = GT911(i2c, irq_pin=TP_I2C_IRQ, reset_pin=TP_I2C_RESET, ioex=ioex)
+
+# TODO: Initialise the DRV2605 haptic engine
+# drv = DRV2605(i2c)
+
+
+try:
+    print("squixl.py RGB parallel bus display initialization")
+    display_bus = lcd_bus.RGBBus(
+        hsync=HSYNC,
+        vsync=VSYNC,
+        de=DE,
+        pclk=PCLK,
+        data0=RGB_IO[0],
+        data1=RGB_IO[1],
+        data2=RGB_IO[2],
+        data3=RGB_IO[3],
+        data4=RGB_IO[4],
+        data5=RGB_IO[5],
+        data6=RGB_IO[6],
+        data7=RGB_IO[7],
+        data8=RGB_IO[8],
+        data9=RGB_IO[9],
+        data10=RGB_IO[10],
+        data11=RGB_IO[11],
+        data12=RGB_IO[12],
+        data13=RGB_IO[13],
+        data14=RGB_IO[14],
+        data15=RGB_IO[15],
+        freq=6_000_000,  # 6 MHz
+        hsync_front_porch=50,
+        hsync_back_porch=10,
+        hsync_pulse_width=8,
+        hsync_idle_low=False,
+        vsync_front_porch=8,
+        vsync_back_porch=8,
+        vsync_pulse_width=3,
+        vsync_idle_low=False,
+        de_idle_high=False,  # ???
+        pclk_idle_high=False,  # ???
+        pclk_active_low=False,  # ???
+        rgb565_dither=False,
+    )
+    print("squixl.py ST7701S() display initialization")
+    mpos.ui.main_display = ST7701S(
+        data_bus=display_bus,
+        display_width=480,
+        display_height=480,
+        set_params_func=squixl.set_params,
+    )
+except Exception as e:
+    sys.print_exception(e)
+    print("Attempting hard reset in 3sec...")
+    time.sleep(3)
+    machine.reset()
+
+
+print("squixl.py display.init()")
+mpos.ui.main_display.init()
+
+time.sleep_ms(200)  # Short delay to help things settle
+startup_rotation = lv.DISPLAY_ROTATION._0
+print("squixl.py display.set_rotation() initialization")
+mpos.ui.main_display.set_rotation(
+    startup_rotation
+)  # must be done after initializing display and creating the touch drivers, to ensure proper handling
+
+print("squixl.py lv.init() initialization")
+lv.init()
+
+group = lv.group_create()
+group.set_default()
+
+# Create and set up the input device
+indev = lv.indev_create()
+indev.set_type(lv.INDEV_TYPE.KEYPAD)
+# indev.set_read_cb(input_callback)
+indev.set_group(
+    group
+)  # is this needed? maybe better to move the default group creation to main.py so it's available everywhere...
+disp = lv.display_get_default()  # NOQA
+indev.set_display(disp)  # different from display
+indev.enable(True)  # NOQA
+# InputManager.register_indev(indev)
+
+
+# CHnage teh state of the IOMUX from Off, to I2S or uSD
+def set_iomux(state=IOMUX_OFF):
+    """Set the state of the IOMUX - for I2S Amp or SD Card or OFF"""
+    global current_iomux_state
+    global audio_out
+
+    if current_iomux_state == state:
+        return
+
+    if current_iomux_state == IOMUX_I2S:
+        audio_out.deinit()
+
+    # IO MUX - Set default to I2S - machine.Pin.PULL_DOWN is SD
+
+    if state == IOMUX_OFF:
+        self.tca.pin_mode(self.MUX_EN, machine.Pin.PULL_UP)
+        print("SQUiXL IOMUX is OFF")
+    elif state == IOMUX_SD:
+        self.tca.pin_mode(self.MUX_EN, machine.Pin.PULL_DOWN)
+        self.tca.pin_mode(self.MUX_SEL, machine.Pin.PULL_DOWN)
+        print("SQUiXL IOMUX is uSD")
+    elif state == IOMUX_I2S:
+        self.tca.pin_mode(self.MUX_EN, machine.Pin.PULL_DOWN)
+        self.tca.pin_mode(self.MUX_SEL, machine.Pin.PULL_UP)
+
+        sd_mode = machine.Pin(IOMUX_D1, machine.Pin.OUT)
+        sd_mode.value(1)
+
+        audio_out = I2S(
+            1,
+            sck=machine.Pin(IOMUX_D4),
+            ws=machine.Pin(IOMUX_D2),
+            sd=machine.Pin(IOMUX_D3),
+            mode=I2S.TX,
+            bits=SAMPLE_SIZE_IN_BITS,
+            format=FORMAT,
+            rate=SAMPLE_RATE_IN_HZ,
+            ibuf=I2S_BUFFER_LENGTH_IN_BYTES,
+        )
+        print("SQUiXL IOMUX is I2S")
+
+    current_iomux_state = state
+
+
+# General Helper Functions
+
+
+# Battery voltage
+def get_bat_voltage():
+    """Read the battery voltage from the fuel gauge"""
+    voltage = max17048.cell_voltage
+    print(f"Bat Voltage: {voltage}V")
+    return voltage
+
+
+# Battery charge state
+def get_state_of_charge():
+    """Read the battery state of charge from the fuel gauge"""
+    soc = max17048.state_of_charge
+    print(f"State of Charge: {soc}%")
+    return soc
+
+
+print(f"{squixl.get_vbus_present()=}")
+
+
+print("squixl.py initialization complete")
diff --git a/internal_filesystem/lib/mpos/board/unphone.py b/internal_filesystem/lib/mpos/board/unphone.py
index 299afda0..cee34937 100644
--- a/internal_filesystem/lib/mpos/board/unphone.py
+++ b/internal_filesystem/lib/mpos/board/unphone.py
@@ -15,7 +15,6 @@
 Original author: https://github.com/jedie
 """
 
-import struct
 import sys
 import time
 
@@ -27,6 +26,7 @@
 import mpos.ui
 from drivers.display.hx8357d import hx8357d
 from drivers.indev.xpt2046 import XPT2046
+from drivers.io_expander.tca9555 import TCA9555
 from machine import Pin
 from micropython import const
 from mpos import InputManager
@@ -68,6 +68,7 @@
 # SPI_TOUCH_FREQ = const(500_000)
 # SPI_TOUCH_FREQ = const(100_000)
 
+TCA9555_I2C_DEV_ID = const(38)  # 0x26 - TI TCA9555's I²C addr
 EXPANDER_POWER = const(0x40)
 LED_GREEN = const(0x49)
 LED_BLUE = const(0x4D)  # 13 | 0x40
@@ -95,83 +96,6 @@
 print("unphone.py init...")
 
 
-class UnPhoneTCA:
-    """
-    unPhone spin 9 - TCA9555 IO expansion chip
-    """
-
-    I2C_DEV_ID = const(38)  # 0x26 - TI TCA9555's I²C addr
-
-    # Register addresses
-    REG_INPUT = const(0x00)
-    REG_OUTPUT = const(0x02)
-    REG_CONFIG = const(0x06)
-
-    def __init__(self, i2c_bus: i2c.I2C.Bus):
-        self.tca_dev = i2c.I2C.Device(bus=i2c_bus, dev_id=self.I2C_DEV_ID)
-        self.directions = 0xFFFF  # All inputs by default
-        self.output_states = 0x0000  # All low by default
-
-        # Set IO expander initially as all inputs
-        self._write_word(0x06, self.directions)
-
-        # Read current directions and states
-        self.directions = self._read_word(0x06)
-        self.output_states = self._read_word(0x02)
-
-    def _write_word(self, reg, value):
-        print(f"Writing to TCA9555: reg={reg:#02x}, value={value:#04x}")
-        self.tca_dev.write(bytes([reg, value & 0xFF, (value >> 8) & 0xFF]))
-
-    def _read_word(self, reg):
-        self.tca_dev.write(bytes([reg]))
-        data = self.tca_dev.read(2)
-        return struct.unpack("<H", data)[0]
-
-    def pin_mode(self, pin, mode):
-        if pin & 0x40:  # Pins with 0x40 bit set are controlled by TCA9555
-            pin &= 0xBF  # Mask out high bit
-            if mode == machine.Pin.OUT:
-                self.directions &= ~(1 << pin)
-            else:
-                self.directions |= 1 << pin
-            self._write_word(self.REG_OUTPUT, self.directions)
-        else:
-            # Handle standard ESP32 pin
-            machine.Pin(pin, mode)
-
-    def digital_write(self, pin, value):
-        if pin & 0x40:  # Pins with 0x40 bit set are controlled by TCA9555
-            pin &= 0xBF
-            if value:
-                self.output_states |= 1 << pin
-            else:
-                self.output_states &= ~(1 << pin)
-            self._write_word(self.REG_OUTPUT, self.output_states)
-
-            # Ensure pin is set to output
-            self.directions &= ~(1 << pin)
-            self._write_word(self.REG_CONFIG, self.directions)
-        else:
-            # Handle standard ESP32 pin
-            p = machine.Pin(pin, machine.Pin.OUT)
-            p.value(value)
-
-    def digital_read(self, pin):
-        if pin & 0x40:  # Pins with 0x40 bit set are controlled by TCA9555
-            pin &= 0xBF
-            # Ensure pin is set to input
-            self.directions |= 1 << pin
-            self._write_word(self.REG_CONFIG, self.directions)
-
-            inputs = self._read_word(self.REG_INPUT)
-            return 1 if (inputs & (1 << pin)) else 0
-        else:
-            # Handle standard ESP32 pin
-            p = machine.Pin(pin, machine.Pin.IN)
-            return p.value()
-
-
 class UnPhone:
     # Power management chip API
     BM_I2CADD = const(0x6B)
@@ -183,7 +107,7 @@ class UnPhone:
 
     def __init__(self, i2c: i2c.I2C.Bus):
         self.i2c = i2c
-        self.tca = UnPhoneTCA(self.i2c)
+        self.tca = TCA9555(self.i2c, dev_id=TCA9555_I2C_DEV_ID)
 
         # TODO: Persistent Store
         # # https://docs.micropython.org/en/latest/library/esp32.html#esp32.NVS
diff --git a/internal_filesystem/lib/mpos/main.py b/internal_filesystem/lib/mpos/main.py
index 6178bc84..f16dba8b 100644
--- a/internal_filesystem/lib/mpos/main.py
+++ b/internal_filesystem/lib/mpos/main.py
@@ -109,6 +109,10 @@ def detect_board():
             # or: if single_address_i2c_scan(i2c0, 0x6A): # IMU currently not installed on prototype board
             return "fri3d_2026"
 
+        print("SQUiXL ?")
+        if unique_id_prefixes == b'\xb8\xf8b':
+            return "squixl"
+
         print("lilygo_t_watch_s3_plus ?")
         if i2c0 := fail_save_i2c(sda=10, scl=11):
             if single_address_i2c_scan(i2c0, 0x19): # IMU on 0x19, vibrator on 0x5A and scan also shows: [52, 81]