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"

typedef struct {
    io_ports_detail_t *ports;
    char port_names[50];
    ioport_bus_t enabled;
} 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 analog, digital;
static int16_t digital_in = -1, digital_out = -1, analog_in = -1, analog_out = -1;

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

    // determine how many ports, including claimed ports, that are available
    do {
        if((port = hal.port.get_pin_info(type, dir, n_ports)))
            n_ports++;
    } while(port != NULL);

    return n_ports;
}

/*! \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 including claimed ports if the API implementation supports that.
*/
uint8_t ioports_available (io_port_type_t type, io_port_direction_t dir)
{
    uint8_t ports = 0;

    if(hal.port.get_pin_info) {

        if(type == Port_Digital) {
            if(dir == Port_Input)
                ports = digital_in == -1 ? (digital_in = ioports_count(type, dir)) : (uint8_t)digital_in;
            else
                ports = digital_out == -1 ? (digital_out = ioports_count(type, dir)) : (uint8_t)digital_out;
        } else {
            if(dir == Port_Input)
                ports = analog_in == -1 ? (analog_in = ioports_count(type, dir)) : (uint8_t)analog_in;
            else
                ports = analog_out == -1 ? (analog_out = ioports_count(type, dir)) : (uint8_t)analog_out;
        }
    } else {
        if(type == Port_Digital)
            ports = dir == Port_Input ? hal.port.num_digital_in : hal.port.num_digital_out;
        else
            ports = dir == Port_Input ? hal.port.num_analog_in : hal.port.num_analog_out;
    }

    return ports;
}

/*! \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)
{
    xbar_t *port;
    uint8_t idx = 0, n_ports = 0;

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

    return n_ports;
}

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 = 0xFF;
    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.
*/
xbar_t *ioport_get_info (io_port_type_t type, io_port_direction_t dir, uint8_t port)
{
    bool ok = false;
    uint8_t n_ports = ioports_available(type, dir);
    uint8_t base = type == Port_Digital
                    ? (dir == Port_Input ? Input_Aux0 : Output_Aux0)
                    : (dir == Port_Input ? Input_Analog_Aux0 : Output_Analog_Aux0);
    xbar_t *portinfo = NULL;

    if(hal.port.get_pin_info && n_ports) do {
        ok = (portinfo = hal.port.get_pin_info(type, dir, --n_ports)) && (portinfo->function - base) == port;
    } while(n_ports && !ok);

    return ok ? portinfo : NULL;
}

/*! \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;

    if(hal.port.claim) {

        xbar_t *portinfo;

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

    } else {

        uint_fast8_t count;
        get_pin_info_ptr get_pin_info = hal.port.get_pin_info;

        hal.port.get_pin_info = NULL; // Force count of unclaimed ports only.

        if((ok = (count = ioports_available(type, dir)) > 0 && *port == count - 1 )) {
            if(type == Port_Digital)
                *port = dir == Port_Input ? --hal.port.num_digital_in : --hal.port.num_digital_out;
            else
                *port = dir == Port_Input ? --hal.port.num_analog_in : --hal.port.num_analog_out;

            if(hal.port.set_pin_description)
                hal.port.set_pin_description(type, dir, *port, description);
        }

        hal.port.get_pin_info = get_pin_info;
    }

    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);
        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);

        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 claimed ports are allocated by the API.
*/
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;
    uint8_t n_ports = ioports_available(type, dir),
            base = type == Port_Digital
                    ? (dir == Port_Input ? Input_Aux0 : Output_Aux0)
                    : (dir == Port_Input ? Input_Analog_Aux0 : Output_Analog_Aux0);
    xbar_t *portinfo;

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

    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;
}

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) {
            ports->in.n_start = ioports_available(Port_Digital, Port_Input);
            hal.port.num_digital_in += (ports->in.n_ports = n_in);
            ports->in.map = malloc(ports->in.n_ports * sizeof(ports->in.n_ports));
            digital.in.ports = &ports->in;
            digital_in = -1;
        }

        if(n_out) {
            ports->out.n_start = ioports_available(Port_Digital, Port_Output);
            hal.port.num_digital_out += (ports->out.n_ports = n_out);
            ports->out.map = malloc(ports->out.n_ports * sizeof(ports->out.n_ports));
            digital.out.ports = &ports->out;
            digital_out = -1;
        }

    } else {

        cfg = &analog;

        if(n_in) {
            ports->in.n_start = ioports_available(Port_Analog, Port_Input);
            hal.port.num_analog_in += (ports->in.n_ports = n_in);
            ports->in.map = malloc(ports->in.n_ports * sizeof(ports->in.n_ports));
            analog.in.ports = &ports->in;
            analog_in = -1;
        }

        if(n_out) {
            ports->out.n_start = ioports_available(Port_Analog, Port_Output);
            hal.port.num_analog_out += (ports->out.n_ports = n_out);
            ports->out.map = malloc(ports->out.n_ports * sizeof(ports->out.n_ports));
            analog.out.ports = &ports->out;
            analog_out = -1;
        }
    }

    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 < 8) {
                    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 < 8) {
                    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;
}

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);
}