ioports.c

/*
  ioports.c - some wrapper functions for the ioports HAL API

  Part of grblHAL

  Copyright (c) 2021-2025 Terje Io

  grblHAL is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  grblHAL is distributed in the hope that 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 grblHAL. If not, see <http://www.gnu.org/licenses/>.
*/

/**
 * @file
 *
 * Some wrapper functions for the #io_port_t API.
 * They perform the necessary checks for both availability of ports
 * and advanced functionality simplifying plugin code that uses them.
 */

#include <math.h>

#include "hal.h"
#include "settings.h"

#define MAX_PORTS 16

typedef struct {
    io_ports_detail_t *ports;
    char port_names[8 * 6 + (MAX_PORTS - 8) * 7];
    ioport_bus_t enabled;
    int16_t count;
    int16_t free;
    pin_function_t min_fn;
    pin_function_t max_fn;
    uint8_t map[MAX_PORTS];
} io_ports_private_t;

typedef struct {
    io_ports_private_t in;
    io_ports_private_t out;
    ioport_bus_t inx;
    ioport_bus_t outx;
} io_ports_cfg_t;

static driver_settings_load_ptr on_settings_loaded = NULL;
static setting_changed_ptr on_setting_changed = NULL;
static io_ports_cfg_t digital = {
                          .in.count = -1,
                          .in.free = -1,
                          .in.min_fn = Input_Aux0, .in.max_fn = Input_AuxMax,
                          .out.count = -1,
                          .out.free = -1,
                          .out.min_fn = Output_Aux0, .out.max_fn = Output_AuxMax
                      },
                      analog = {
                          .in.count = -1,
                          .in.free = -1,
                          .in.min_fn = Input_Analog_Aux0, .in.max_fn = Input_Analog_AuxMax,
                          .out.count = -1,
                          .out.free = -1,
                          .out.min_fn = Output_Analog_Aux0, .out.max_fn = Output_Analog_AuxMax
                      };

static inline io_ports_private_t *get_port_data (io_port_type_t type, io_port_direction_t dir)
{
    return type == Port_Digital ? (dir == Port_Input ? &digital.in : &digital.out) : (dir == Port_Input ? &analog.in : &analog.out);
}

// TODO: change to always use ioports_map_reverse()? add range check?
static inline uint8_t resolve_portnum (io_ports_private_t *p_data, xbar_t *port)
{
    return port->function >= p_data->min_fn && port->function <= p_data->max_fn ? (port->function - p_data->min_fn) : ioports_map_reverse(p_data->ports, port->id);
}

static uint8_t ioports_count (io_port_type_t type, io_port_direction_t dir, io_ports_private_t *p_data)
{
    xbar_t *port;
    uint8_t n_ports = 0, n_remapped = 0;

    // determine how many ports, including claimed ports, that are available. remapped ports may be excluded.
    if(hal.port.get_pin_info) do {
        if((port = hal.port.get_pin_info(type, dir, n_ports))) {
            n_ports++;
            if(p_data && (port->function < p_data->min_fn || port->function > p_data->max_fn))
                n_remapped++;
        }
    } while(port != NULL);

    return n_ports - n_remapped;
}

/*! \brief Get number of digital or analog ports available.
\param type as an \a #io_port_type_t enum value.
\param dir as an \a #io_port_direction_t enum value.
\returns number of ports available excluding remapped ports but including claimed ports if the API implementation supports that.
*/
uint8_t ioports_available (io_port_type_t type, io_port_direction_t dir)
{
    io_ports_private_t *p_data = get_port_data(type, dir);

    if(p_data->count == -1)
        p_data->count = ioports_count(type, dir, get_port_data(type, dir));

    return p_data->count;
}

/*! \brief Get number of unclaimed digital or analog ports available.
\param type as an \a #io_port_type_t enum value.
\param dir as an \a #io_port_direction_t enum value.
\returns number of ports available.
*/
uint8_t ioports_unclaimed (io_port_type_t type, io_port_direction_t dir)
{
    io_ports_private_t *p_data = get_port_data(type, dir);

    if(p_data->free == -1) {

        xbar_t *port;
        uint8_t idx = 0;

        p_data->free = 0;

        if(hal.port.get_pin_info) do {
            if((port = hal.port.get_pin_info(type, dir, idx++)) && !port->mode.claimed)
                p_data->free++;
        } while(port);
    }

    return p_data->free;
}

static struct ff_data {
    uint8_t port;
    const char *description;
} ff_data;

static bool match_port (xbar_t *properties, uint8_t port, void *data)
{
    if(((struct ff_data *)data)->description && (!properties->description || strcmp(properties->description, ((struct ff_data *)data)->description)))
        return false;

    ((struct ff_data *)data)->port = port;

    return true;
}

/*! \brief find first free or claimed digital or analog port.
\param type as an \a #io_port_type_t enum value.
\param dir as an \a #io_port_direction_t enum value.
\param description pointer to a \a char constant for the pin description of a previousely claimed port or NULL if searching for the first free port.
\returns the port number if successful, 0xFF (255) if not.
*/
uint8_t ioport_find_free (io_port_type_t type, io_port_direction_t dir, pin_cap_t filter, const char *description)
{
    ff_data.port = IOPORT_UNASSIGNED;
    ff_data.description = (description && *description) ? description : NULL;

    // TODO: pass modified filter with .claimable off when looking for description match?
    if(ff_data.description && !ioports_enumerate(type, dir, (pin_cap_t){}, match_port, (void *)&ff_data)) {
        ff_data.description = NULL;
        ioports_enumerate(type, dir, filter, match_port, (void *)&ff_data);
    }

    return ff_data.port;
}

/*! \brief Return information about a digital or analog port.
\param type as an \a #io_port_type_t enum value.
\param dir as an \a #io_port_direction_t enum value.
\param port the port aux number.
\returns pointer to \a xbar_t struct if successful, NULL if not.
*/
static xbar_t *get_info (io_port_type_t type, io_port_direction_t dir, uint8_t port, bool claim)
{
    bool ok = false;
    xbar_t *portinfo = NULL;
    io_ports_private_t *p_data = get_port_data(type, dir);
    uint8_t n_ports = p_data->ports ? p_data->ports->n_ports : 0;

    if(hal.port.get_pin_info && n_ports) do {
        ok = (portinfo = hal.port.get_pin_info(type, dir, --n_ports)) && !(claim && portinfo->mode.claimed) && resolve_portnum(p_data, portinfo) == port;
    } while(n_ports && !ok);

    return ok ? portinfo : NULL;
}

/*! \brief Return information about a digital or analog port.
\param type as an \a #io_port_type_t enum value.
\param dir as an \a #io_port_direction_t enum value.
\param port the port aux number.
\returns pointer to \a xbar_t struct if successful, NULL if not.
*/
xbar_t *ioport_get_info (io_port_type_t type, io_port_direction_t dir, uint8_t port)
{
    return get_info(type, dir, port, false);
}


/* code to keep deprecated data updated, to be removed */

static inline uint8_t get_hcount (io_port_type_t type, io_port_direction_t dir)
{
    return type == Port_Digital
            ? (dir == Port_Input ? hal.port.num_digital_in : hal.port.num_digital_out)
            : (dir == Port_Input ? hal.port.num_analog_in : hal.port.num_analog_out);
}

static inline void dec_hcount (io_port_type_t type, io_port_direction_t dir)
{
    if(type == Port_Digital) {
        if(dir == Port_Input)
            hal.port.num_digital_in--;
        else
            hal.port.num_digital_out--;
    } else if(dir == Port_Input)
        hal.port.num_analog_in--;
    else
        hal.port.num_analog_out--;
}

/* end deprecated */

/*! \brief Claim a digital or analog port for exclusive use.
\param type as an \a #io_port_type_t enum value.
\param dir as an \a #io_port_direction_t enum value.
\param port pointer to a \a uint8_t holding the ports aux number, returns the actual port number to use if successful.
\param description pointer to a \a char constant for the pin description.
\returns true if successful, false if not.
*/
bool ioport_claim (io_port_type_t type, io_port_direction_t dir, uint8_t *port, const char *description)
{
    bool ok = false;

    if(hal.port.claim) {

        xbar_t *portinfo;
        uint8_t hcnt = get_hcount(type, dir);

        if((ok = (portinfo = get_info(type, dir, *port, true)) &&
    //             portinfo->cap.claimable && TODO: add?
                    !portinfo->mode.claimed &&
                      hal.port.claim(type, dir, port, description))) {

            get_port_data(type, dir)->free = -1;

            if(get_hcount(type, dir) == hcnt)
                dec_hcount(type, dir);
        }
    }

    return ok;
}

/*! \brief Reassign pin function.
\param port pointer to an \a aux_ctrl_t structure with a valid port number.
\param function pointer to a \a #pin_function_t enum value to be updated.
*/
void ioport_assign_function (aux_ctrl_t *aux_ctrl, pin_function_t *function)
{
    xbar_t *input;

    if((input = hal.port.get_pin_info(Port_Digital, Port_Input, aux_ctrl->aux_port))) {

        *function = aux_ctrl->function;
        digital.inx.mask &= ~(1 << input->id);
        digital.in.count = digital.in.free = -1;
        hal.signals_cap.mask |= aux_ctrl->cap.mask;

        if(aux_ctrl->function == Input_Probe || xbar_fn_to_signals_mask(aux_ctrl->function).mask)
            setting_remove_elements(Settings_IoPort_InvertIn, digital.inx.mask);
    }
}

void ioport_assign_out_function (aux_ctrl_out_t *aux_ctrl, pin_function_t *function)
{
    xbar_t *output;

    if((output = hal.port.get_pin_info(Port_Digital, Port_Output, aux_ctrl->aux_port))) {

        *function = aux_ctrl->function;
        digital.outx.mask &= ~(1 << output->id);
        digital.out.count = digital.out.free = -1;

        setting_remove_elements(Settings_IoPort_InvertOut, digital.outx.mask);
    }
}

/*! \brief Check if ports can be claimed by aux number or not.
\returns true if ports can be claimed by aux number, false if not.
*/
bool ioport_can_claim_explicit (void)
{
    return !!hal.port.claim && !!hal.port.get_pin_info;
}

bool ioports_enumerate (io_port_type_t type, io_port_direction_t dir, pin_cap_t filter, ioports_enumerate_callback_ptr callback, void *data)
{
    bool ok = false;
    io_ports_private_t *p_data = get_port_data(type, dir);

    if(p_data->ports && p_data->ports->n_ports && ioport_can_claim_explicit()) {

       xbar_t *portinfo;
       uint_fast16_t n_ports;

       if(filter.mask) {

           uint_fast16_t n_ports = p_data->ports->n_ports;

           do {
                if((portinfo = hal.port.get_pin_info(type, dir, --n_ports)) && (portinfo->cap.mask & filter.mask) == filter.mask) {
                    if((ok = callback(portinfo, resolve_portnum(p_data, portinfo), data)))
                        break;
                }
            } while(n_ports);

       } else for(n_ports = 0; n_ports < p_data->ports->n_ports; n_ports++) {
           if((portinfo = hal.port.get_pin_info(type, dir, n_ports))) {
               if((ok = callback(portinfo, resolve_portnum(p_data, portinfo), data)))
                   break;
           }
       }
    }

    return ok;
}

bool ioport_analog_out_config (uint8_t port, pwm_config_t *config)
{
    xbar_t *pin;
    bool ok = (pin = hal.port.get_pin_info(Port_Analog, Port_Output, port)) && pin->config;

    return ok && pin->config(pin, config, false);
}

bool ioport_digital_in_config (uint8_t port, gpio_in_config_t *config)
{
    xbar_t *pin;
    bool ok = (pin = hal.port.get_pin_info(Port_Digital, Port_Input, port)) && pin->config;

    return ok && pin->config(pin, config, false);
}

bool ioport_enable_irq (uint8_t port, pin_irq_mode_t irq_mode, ioport_interrupt_callback_ptr handler)
{
    return hal.port.register_interrupt_handler && hal.port.register_interrupt_handler(port, irq_mode, handler);
}

bool ioport_digital_out_config (uint8_t port, gpio_out_config_t *config)
{
    xbar_t *pin;
    bool ok = (pin = hal.port.get_pin_info(Port_Digital, Port_Output, port)) && pin->config && !(pin->mode.pwm || pin->mode.servo_pwm);

    return ok && pin->config(pin, config, false);
}

bool ioport_digital_pwm_config (uint8_t port, pwm_config_t *config)
{
    xbar_t *pin;
    bool ok = (pin = hal.port.get_pin_info(Port_Digital, Port_Output, port)) && pin->config && pin->mode.claimed && pin->cap.pwm;

    return ok && pin->config(pin, config, false);
}

/* experimental code follows */

static char *get_pnum (io_ports_data_t *ports, uint8_t port)
{
    return ports->pnum ? (ports->pnum + (port * 3) + (port > 9 ? port - 10 : 0)) : NULL;
}

static uint8_t add_ports (io_ports_detail_t *ports, uint8_t *map, io_port_type_t type, io_port_direction_t dir, uint8_t n_ports)
{
    io_ports_private_t *p_data = get_port_data(type, dir);

    ports->n_start = ioports_count(type, dir, NULL);

    if(ports->n_start + n_ports > MAX_PORTS)
        n_ports = MAX_PORTS - ports->n_start;

    ports->n_ports = n_ports;
    ports->idx_last += n_ports;
    ports->map = map;
    if(p_data->ports == NULL) // for now...
        p_data->ports = ports;
    p_data->count = -1;

    return n_ports;
}

bool ioports_add (io_ports_data_t *ports, io_port_type_t type, uint8_t n_in, uint8_t n_out)
{
    uint_fast8_t n_ports;
    io_ports_cfg_t *cfg;

    ports->get_pnum = get_pnum;

    if(type == Port_Digital) {

        cfg = &digital;

        if(n_in)
            hal.port.num_digital_in += add_ports(&ports->in, digital.in.map, type, Port_Input, n_in);

        if(n_out)
            hal.port.num_digital_out += add_ports(&ports->out, digital.out.map, type, Port_Output, n_out);

    } else {

        cfg = &analog;

        if(n_in)
            hal.port.num_analog_in += add_ports(&ports->in, analog.in.map, type, Port_Input, n_in);

        if(n_out)
            hal.port.num_analog_out += add_ports(&ports->out, analog.out.map, type, Port_Output, n_out);
    }

    if((n_ports = max(ports->in.n_ports, ports->out.n_ports)) > 0)  {

        char *pn;
        uint_fast8_t i;

        if((ports->pnum = pn = malloc((3 * n_ports + (n_ports > 9 ? n_ports - 10 : 0)) + 1)))
          for(i = 0; i < n_ports; i++) {

            if(pn) {
                *pn = type == Port_Digital ? 'P' : 'E';
                strcpy(pn + 1, uitoa(i));
            }

            if(ports->in.n_ports && i < ports->in.n_ports) {
                if(ports->in.map)
                    ports->in.map[i] = i;
                if(hal.port.set_pin_description)
                    hal.port.set_pin_description(type, Port_Input, i, get_pnum(ports, i));
                if(i < MAX_PORTS) {
                    cfg->inx.mask = (cfg->inx.mask << 1) + 1;
                    strcat(cfg->in.port_names, i == 0 ? "Aux " : ",Aux ");
                    strcat(cfg->in.port_names, uitoa(i));
                }
            }

            if(ports->out.n_ports && i < ports->out.n_ports) {
                if(ports->out.map)
                    ports->out.map[i] = i;
                if(hal.port.set_pin_description)
                    hal.port.set_pin_description(type, Port_Output, i, get_pnum(ports, i));
                if(i < MAX_PORTS) {
                    cfg->outx.mask = (cfg->outx.mask << 1) + 1;
                    strcat(cfg->out.port_names, i == 0 ? "Aux " : ",Aux ");
                    strcat(cfg->out.port_names, uitoa(i));
                }
            }

            if(pn)
                pn += i > 9 ? 4 : 3;
        }

        cfg->in.enabled.mask = cfg->inx.mask;
        cfg->out.enabled.mask = cfg->outx.mask;
    }

    return n_ports > 0;
}
/*
bool ioports_add_digital (io_digital_t *digital)
{
    if(ioports_add(&digital, Port_Digital, digital->ports->in.n_ports, digital->ports->out.n_ports))  {

        if(digital->ports->in.n_ports) {
            hal.port.wait_on_input = digital->wait_on_input;
            hal.port.register_interrupt_handler = digital->register_interrupt_handler;
        }

        if(digital->ports->out.n_ports)
            hal.port.digital_out = digital->digital_out;

        hal.port.claim = digital->claim;
        hal.port.get_pin_info = digital->get_pin_info;
    }
}
*/

ISR_CODE uint8_t ISR_FUNC(ioports_map_reverse)(io_ports_detail_t *type, uint8_t port)
{
    if(type->map) {
        uint_fast8_t idx = type->n_ports;
        do {
            if(type->map[--idx] == port) {
                port = idx;
                break;
            }
        } while(idx);
    }

    return port;
}

/*! \brief calculate inverted pwm value if configured
\param pwm_data pointer t a \a spindle_pwm_t structure.
\param pwm_value non inverted PWM value.
\returns the inverted PWM value to use.
*/
static inline uint_fast16_t invert_pwm (ioports_pwm_t *pwm_data, uint_fast16_t pwm_value)
{
    return pwm_data->invert_pwm ? pwm_data->period - pwm_value - 1 : pwm_value;
}

/*! \brief Precompute PWM values for faster conversion.
\param config pointer to a \ref pwm_config_t structure.
\param pwm_data pointer to a \a ioports_pwm_t structure, to hold the precomputed values.
\param clock_hz timer clock frequency used for PWM generation.
\returns \a true if successful, \a false if no PWM range possible - driver should then revert to simple on/off control.
*/
bool ioports_precompute_pwm_values (pwm_config_t *config, ioports_pwm_t *pwm_data, uint32_t clock_hz)
{
    pwm_data->f_clock = clock_hz;

    if(config->max > config->min) {
        pwm_data->min = config->min;
        pwm_data->period = (uint_fast16_t)((float)clock_hz / config->freq_hz);
        pwm_data->min_value = (uint_fast16_t)(pwm_data->period * config->min_value / 100.0f);
        pwm_data->max_value = (uint_fast16_t)(pwm_data->period * config->max_value / 100.0f); // + pwm_data->offset;
        pwm_data->pwm_gradient = (float)(pwm_data->max_value - pwm_data->min_value) / (config->max - config->min);
        if(!(pwm_data->always_on = config->off_value != 0.0f))
            pwm_data->off_value = pwm_data->invert_pwm ? pwm_data->period : 0;
        else if(!config->servo_mode && config->off_value > 0.0f)
            pwm_data->off_value = invert_pwm(pwm_data, (uint_fast16_t)(pwm_data->period * config->off_value / 100.0f));
        else
            pwm_data->off_value = pwm_data->min_value;
    }

    return config->max > config->min;
}

/*! \brief Analog value to PWM conversion.
\param pwm_data pointer to a \a ioports_pwm_t structure.
\param value analog value to be converted.
\returns the PWM value to use.

__NOTE:__ \a ioports_precompute_pwm_values() must be called to precompute values before this function is called.
Typically this is done by the ioports initialization code.
*/
uint_fast16_t ioports_compute_pwm_value (ioports_pwm_t *pwm_data, float value)
{
    uint_fast16_t pwm_value;

    if(value > pwm_data->min) {

        pwm_value = (uint_fast16_t)floorf((value - pwm_data->min) * pwm_data->pwm_gradient) + pwm_data->min_value;

        if(pwm_value >= pwm_data->max_value)
            pwm_value = pwm_data->max_value;
        else if(pwm_value < pwm_data->min_value)
            pwm_value = pwm_data->min_value;

        pwm_value = invert_pwm(pwm_data, pwm_value);
    } else
        pwm_value = value == 0.0f ? pwm_data->off_value : invert_pwm(pwm_data, pwm_data->min_value);

    return pwm_value;
}

void ioport_save_input_settings (xbar_t *xbar, gpio_in_config_t *config)
{
    if(digital.inx.mask & (1 << xbar->id)) {
        if(config->inverted)
            settings.ioport.invert_in.mask |= (1 << xbar->id);
        else
            settings.ioport.invert_in.mask &= ~(1 << xbar->id);
    }

    if(xbar->function == Input_Probe)
        settings.probe.invert_probe_pin = config->inverted;
    else if(xbar->function < Input_Probe) {
        control_signals_t ctrl;
        if((ctrl = xbar_fn_to_signals_mask(xbar->function)).mask) {
            if(config->inverted)
                settings.control_invert.mask |= ctrl.mask;
            else
                settings.control_invert.mask &= ~ctrl.mask;
        }
    }

    settings_write_global();
}

void ioport_save_output_settings (xbar_t *xbar, gpio_out_config_t *config)
{
    if(digital.outx.mask & (1 << xbar->id)) {
        if(config->inverted)
            settings.ioport.invert_out.mask |= (1 << xbar->id);
        else
            settings.ioport.invert_out.mask &= ~(1 << xbar->id);
    }

    settings_write_global();
}

static bool is_setting_available (const setting_detail_t *setting, uint_fast16_t offset)
{
    bool available = false;

    switch(setting->id) {

        case Settings_IoPort_InvertIn:
        case Settings_IoPort_Pullup_Disable:
            available = digital.in.ports && digital.inx.mask;
            break;

        case Settings_IoPort_InvertOut:
        case Settings_IoPort_OD_Enable:
            available = digital.out.ports && digital.outx.mask;
            break;

        default:
            break;
    }

    return available;
}

static status_code_t aux_set_value (setting_id_t id, uint_fast16_t value)
{
    xbar_t *xbar;
    uint8_t port = 0;
    ioport_bus_t change, changed;

    switch(id) {

        case Settings_IoPort_InvertIn:

            change.mask = value & digital.inx.mask;

            if((changed.mask = settings.ioport.invert_in.mask ^ change.mask)) {

                gpio_in_config_t config = {0};

                do {
                    if((changed.mask & 0x01) && (xbar = hal.port.get_pin_info(Port_Digital, Port_Input, ioports_map_reverse(digital.in.ports, port)))) {
                        if(xbar->config) {
                            config.pull_mode = (pull_mode_t)xbar->mode.pull_mode;
                            config.inverted = !!(change.mask & (1 << xbar->id));
                            xbar->config(xbar, &config, false);
                        }
                    }
                    port++;
                } while(changed.mask >>= 1);
            }

            settings.ioport.invert_in.mask = change.mask;

            if(on_setting_changed)
                on_setting_changed(id);
            break;

        case Settings_IoPort_Pullup_Disable:

            change.mask = value & digital.inx.mask;

            if((changed.mask = settings.ioport.pullup_disable_in.mask ^ change.mask)) {

                gpio_in_config_t config = {0};

                do {
                    if((changed.mask & 0x01) && (xbar = hal.port.get_pin_info(Port_Digital, Port_Input, ioports_map_reverse(digital.in.ports, port)))) {
                        if(xbar->config) {
                            config.pull_mode = change.mask & (1 << xbar->id)  ? PullMode_Down : PullMode_Up;
                            config.inverted = xbar->mode.inverted;
                            config.debounce = xbar->mode.inverted;
                            xbar->config(xbar, &config, false);
                        }
                    }
                    port++;
                } while(changed.mask >>= 1);
            }

            settings.ioport.pullup_disable_in.mask = change.mask;

            if(on_setting_changed)
                on_setting_changed(id);
            break;

        case Settings_IoPort_InvertOut:

            change.mask = value & digital.outx.mask;

            if((changed.mask = settings.ioport.invert_out.mask ^ change.mask)) {

                gpio_out_config_t config = {0};

                do {
                    if((changed.mask & 0x01) && (xbar = hal.port.get_pin_info(Port_Digital, Port_Output, ioports_map_reverse(digital.out.ports, port)))) {
                        if(xbar->config && !(xbar->mode.pwm || xbar->mode.servo_pwm)) {
                            config.inverted = !!(change.mask & (1 << xbar->id));
                            config.open_drain = xbar->mode.open_drain;
                            xbar->config(xbar, &config, false);
                        }
                    }
                    port++;
                } while(changed.mask >>= 1);

                settings.ioport.invert_out.mask = change.mask;

                if(on_setting_changed)
                    on_setting_changed(id);
            }
            break;

        case Settings_IoPort_OD_Enable:

            change.mask = value & digital.outx.mask;

            if((changed.mask = settings.ioport.od_enable_out.mask ^ change.mask)) {

                gpio_out_config_t config = {0};

                do {
                    if((changed.mask & 0x01) && (xbar = hal.port.get_pin_info(Port_Digital, Port_Output, ioports_map_reverse(digital.out.ports, port)))) {
                        if(xbar->config && !(xbar->mode.pwm || xbar->mode.servo_pwm)) {
                            config.inverted = xbar->mode.inverted;
                            config.open_drain = !!(change.mask & (1 << xbar->id));
                            xbar->config(xbar, &config, false);
                        }
                    }
                    port++;
                } while(changed.mask >>= 1);

                settings.ioport.od_enable_out.mask = change.mask;

                if(on_setting_changed)
                    on_setting_changed(id);
            }
            break;

        default:
            break;
    }

    return Status_OK;
}

static uint32_t aux_get_value (setting_id_t id)
{
    uint32_t value = 0;

    switch(id) {

        case Settings_IoPort_InvertIn:
            value = settings.ioport.invert_in.mask & digital.in.enabled.mask;
            break;

        case Settings_IoPort_Pullup_Disable:
            value = settings.ioport.pullup_disable_in.mask & digital.in.enabled.mask;
            break;

        case Settings_IoPort_InvertOut:
            value = settings.ioport.invert_out.mask & digital.out.enabled.mask;
            break;

        case Settings_IoPort_OD_Enable:
            value = settings.ioport.od_enable_out.mask & digital.out.enabled.mask;
            break;

        default:
            break;
    }

    return value;
}

static const setting_group_detail_t ioport_groups[] = {
    { Group_Root, Group_AuxPorts, "Aux ports"}
};

static const setting_detail_t ioport_settings[] = {
    { Settings_IoPort_InvertIn, Group_AuxPorts, "Invert I/O Port inputs", NULL, Format_Bitfield, digital.in.port_names, NULL, NULL, Setting_NonCoreFn, aux_set_value, aux_get_value, is_setting_available },
#ifdef AUX_SETTINGS_PULLUP
    { Settings_IoPort_Pullup_Disable, Group_AuxPorts, "I/O Port inputs pullup disable", NULL, Format_Bitfield, digital.in.port_names, NULL, NULL, Setting_NonCoreFn, aux_set_value, aux_get_value, is_setting_available },
#endif
    { Settings_IoPort_InvertOut, Group_AuxPorts, "Invert I/O Port outputs", NULL, Format_Bitfield, digital.out.port_names, NULL, NULL, Setting_NonCoreFn, aux_set_value, aux_get_value, is_setting_available },
//    { Settings_IoPort_OD_Enable, Group_AuxPorts, "I/O Port outputs as open drain", NULL, Format_Bitfield, digital.out.port_names, NULL, NULL, Setting_NonCoreFn, aux_set_value, aux_get_value, is_setting_available }
};

#ifndef NO_SETTINGS_DESCRIPTIONS

static const setting_descr_t ioport_settings_descr[] = {
    { Settings_IoPort_InvertIn, "Invert IOPort inputs." },
//    { Settings_IoPort_Pullup_Disable, "Disable IOPort input pullups." },
    { Settings_IoPort_InvertOut, "Invert IOPort output." },
//    { Settings_IoPort_OD_Enable, "Set IOPort outputs as open drain (OD)." }
};

#endif

static void ioport_settings_load (void)
{
    uint8_t port;
    xbar_t *xbar;
    gpio_in_config_t in_config = {0};
    gpio_out_config_t out_config = {0};

    settings.ioport.invert_in.mask &= digital.inx.mask;
    settings.ioport.pullup_disable_in.mask &= digital.inx.mask;
    settings.ioport.invert_out.mask &= digital.outx.mask;
    settings.ioport.od_enable_out.mask &= digital.outx.mask;

    if(digital.in.ports && (port = digital.in.ports->n_ports)) do {
        if((xbar = hal.port.get_pin_info(Port_Digital, Port_Input, ioports_map_reverse(digital.in.ports, --port)))) {
            if(xbar->config) {

                in_config.debounce = xbar->mode.debounce;
#ifdef AUX_SETTINGS_PULLUP
                in_config.pull_mode = settings.ioport.pullup_disable_in.mask & (1 << xbar->id) ? PullMode_None : PullMode_Up;
#else
                in_config.pull_mode = (pull_mode_t)xbar->mode.pull_mode;
#endif
                in_config.inverted = !!(settings.ioport.invert_in.mask & (1 << xbar->id));

                // For probe and control signals higher level config takes priority
                if(xbar->function == Input_Probe)
                    in_config.inverted = settings.probe.invert_probe_pin;
                else if(xbar->function < Input_Probe) {
                    control_signals_t ctrl;
                    if((ctrl = xbar_fn_to_signals_mask(xbar->function)).mask)
                        in_config.inverted = !!(settings.control_invert.mask & ctrl.mask);
                }

                if(in_config.inverted)
                    settings.ioport.invert_in.mask |= (1 << xbar->id);
                else
                    settings.ioport.invert_in.mask &= ~(1 << xbar->id);

                xbar->config(xbar, &in_config, false);
            }
        }
    } while(port);

    if(digital.out.ports && (port = digital.out.ports->n_ports)) do {
        if((xbar = hal.port.get_pin_info(Port_Digital, Port_Output, ioports_map_reverse(digital.out.ports, --port)))) {
            if(xbar->config && !(xbar->mode.pwm || xbar->mode.servo_pwm)) {
                out_config.inverted = !!(settings.ioport.invert_out.mask & (1 << xbar->id));
                out_config.open_drain = !!(settings.ioport.od_enable_out.mask & (1 << xbar->id));
                xbar->config(xbar, &out_config, false);
            }
        }
    } while(port);

    if(on_settings_loaded)
        on_settings_loaded();
}

void ioport_setting_changed (setting_id_t id)
{
    if(on_setting_changed)
        on_setting_changed(id);

    else if(digital.in.ports && digital.in.ports->n_ports) switch(id) {

        case Setting_InvertProbePin:
        case Setting_ProbePullUpDisable:
            {
                xbar_t *xbar;
                gpio_in_config_t in_config = {0};
                uint8_t port = digital.in.ports->n_ports;

                do {
                    if((xbar = hal.port.get_pin_info(Port_Digital, Port_Input, ioports_map_reverse(digital.in.ports, --port)))) {
                        if(xbar->config && xbar->function == Input_Probe) {

                            in_config.debounce  = Off;
                            in_config.inverted  = settings.probe.invert_probe_pin;
                            in_config.pull_mode = settings.probe.disable_probe_pullup ? PullMode_None : PullMode_Up;

                            if(in_config.inverted)
                                settings.ioport.invert_in.mask |= (1 << xbar->id);
                            else
                                settings.ioport.invert_in.mask &= ~(1 << xbar->id);

                            xbar->config(xbar, &in_config, false);
                        } else if(xbar->config && xbar->function == Input_Toolsetter) {

                            in_config.debounce  = Off;
                            in_config.inverted  = settings.probe.invert_toolsetter_input;
                            in_config.pull_mode = settings.probe.disable_toolsetter_pullup ? PullMode_None : PullMode_Up;

                            if(in_config.inverted)
                                settings.ioport.invert_in.mask |= (1 << xbar->id);
                            else
                                settings.ioport.invert_in.mask &= ~(1 << xbar->id);

                            xbar->config(xbar, &in_config, false);
                        }
                    }
                } while(port);
            }
            break;

        case Setting_ControlInvertMask:
        case Setting_ControlPullUpDisableMask:
            {
                xbar_t *xbar;
                gpio_in_config_t in_config = {0};
                control_signals_t ctrl;
                uint8_t port = digital.in.ports->n_ports;

                do {
                    if((xbar = hal.port.get_pin_info(Port_Digital, Port_Input, ioports_map_reverse(digital.in.ports, --port)))) {
                        if(xbar->config && xbar->function < Input_Probe) {

                            in_config.debounce = xbar->mode.debounce;
                            in_config.inverted = !!(settings.ioport.invert_in.mask & (1 << xbar->id));
                            in_config.pull_mode = (pull_mode_t)xbar->mode.pull_mode;

                            if((ctrl = xbar_fn_to_signals_mask(xbar->function)).mask) {
                                in_config.inverted = !!(settings.control_invert.mask & ctrl.mask);
                                in_config.pull_mode = (settings.control_disable_pullup.mask & ctrl.mask) ? PullMode_None : PullMode_Up;
                            }

                            if(in_config.inverted)
                                settings.ioport.invert_in.mask |= (1 << xbar->id);
                            else
                                settings.ioport.invert_in.mask &= ~(1 << xbar->id);

                            xbar->config(xbar, &in_config, false);
                        }
                    }
                } while(port);
            }
            break;

        default:
            break;
    }
}

void ioports_add_settings (driver_settings_load_ptr settings_loaded, setting_changed_ptr setting_changed)
{
    static setting_details_t setting_details = {
        .is_core = true,
        .groups = ioport_groups,
        .n_groups = sizeof(ioport_groups) / sizeof(setting_group_detail_t),
        .settings = ioport_settings,
        .n_settings = sizeof(ioport_settings) / sizeof(setting_detail_t),
    #ifndef NO_SETTINGS_DESCRIPTIONS
        .descriptions = ioport_settings_descr,
        .n_descriptions = sizeof(ioport_settings_descr) / sizeof(setting_descr_t),
    #endif
        .load = ioport_settings_load,
        .save = settings_write_global
    };

    if(settings_loaded)
        on_settings_loaded = settings_loaded;

    if(setting_changed)
        on_setting_changed = setting_changed;

    settings_register(&setting_details);
}