File content as of revision 19:1a13f0c067b1:

#include "mbed.h"
#include "rtos.h"

#include "gpio_api.h"
#include "max32625pico.h"
#include "pwrman_regs.h"

#include "USBSerial.h"
USBSerial serial;

static DigitalOut rLED(LED1);
static DigitalOut gLED(LED2);
static DigitalOut bLED(LED3);

int gpioAlternatePullup(PinName name) {
    // Enable high resistance pullups per AN6350 section 5.2.4.1
    int result = E_NO_ERROR;
    unsigned int port = PINNAME_TO_PORT(name);
    unsigned int pin = PINNAME_TO_PIN(name);
    MXC_IOMAN->wud_req0 |= ((1 << pin) << (port << 3));  // pinmask
    if (MXC_IOMAN->wud_ack0 != MXC_IOMAN->wud_req0) {
        result = E_BUSY;
    }
    if (result == E_NO_ERROR) {
        MXC_PWRMAN->wud_ctrl = MXC_F_PWRMAN_WUD_CTRL_CTRL_ENABLE;
        MXC_PWRMAN->wud_ctrl |= (port << 3) + pin;  // Pad select
        MXC_PWRMAN->wud_ctrl &= ~(MXC_F_PWRMAN_WUD_CTRL_PAD_MODE);
        MXC_PWRMAN->wud_ctrl |= (MXC_E_PWRMAN_PAD_MODE_WEAK_HI_LO <<
                                 MXC_F_PWRMAN_WUD_CTRL_PAD_MODE_POS);
        MXC_PWRMAN->wud_pulse0 = 1;
    }
    MXC_PWRMAN->wud_ctrl = 0;
    MXC_IOMAN->wud_req0 = 0;
    return result;
}

typedef enum {
    UNKNOWN,
    MAX14720A,
    MAX14720B,
    MAX14720C,
    MAX14720D,
    MAX14750A,
    MAX14750B,
    MAX14750C
} chip_t;

void showRegisters(char* regs) {
    // Datasheet table 28 "Register Default Values"
    int i;
    for (i = 0; i < 0x20; i++) {
        serial.printf("%02X ", regs[i]);
    }
    serial.printf("\r\n");
    if (regs[0] != 0x01) return;
    chip_t chipType = UNKNOWN;
    // regs[6] BoostCfg
    if (regs[6] == 0xC0) {
        // regs[7] BuckVSet
        switch(regs[7]) {
        case 0x08: chipType = MAX14750A; break;
        case 0x20: chipType = MAX14750B; break;
        case 0x0A: chipType = MAX14750C; break;
        default: break;
        }
    } else if (regs[6] == 0xE0) {
        bool aOrB = false;
        // regs[9] BuckISet
        switch(regs[9]) {
        case 0xA7: aOrB = true; break;
        case 0x07: chipType = MAX14720C; break;
        case 0x47: chipType = MAX14720D; break;
        default: break;
        }
        if (aOrB) {
            // regs[B] LDOCfg
            if (regs[0x0B] == 0x80) {
                chipType = MAX14720A;
            } else if (regs[0x0B] == 0xE1) {
                chipType = MAX14720B;
            }
        }
    }
    switch(chipType) {
    case MAX14750A: serial.printf("MAX14750A\r\n"); break;
    case MAX14750B: serial.printf("MAX14750B\r\n"); break;
    case MAX14750C: serial.printf("MAX14750C\r\n"); break;
    case MAX14720A: serial.printf("MAX14720A\r\n"); break;
    case MAX14720B: serial.printf("MAX14720B\r\n"); break;
    case MAX14720C: serial.printf("MAX14720C\r\n"); break;
    case MAX14720D: serial.printf("MAX14720D\r\n"); break;
    }
    if ((chipType == MAX14750A) || (chipType == MAX14750B) ||
        (chipType == MAX14750C)) {
        serial.printf("SWIN: %s\r\n", regs[0x1B] & 8? "high": "low");
        serial.printf("HVEN: %s\r\n", regs[0x1B] & 4? "high": "low");
        serial.printf("BEN:  %s\r\n", regs[0x1B] & 2? "high": "low");
        serial.printf("LEN:  %s\r\n", regs[0x1B] & 1? "high": "low");
    }
}

void readMax14750Regs(I2C* i2c) {
    const int addr = 0x54;
    char buf[0x20] = {};
    // Request register 0.
    buf[0] = 0x00;
    bool writeFailed = i2c->write(addr, (char*)&buf, 1, false);
    if (writeFailed) {
        serial.printf("i2c write 0x54 failed\r\n");
        return;
    }
    // Read 32 register values.
    if (i2c->read(addr + 1, (char*)(&buf[0]), 0x20, false) != 0) {
        serial.printf("i2c read 0x55 failed\r\n");
        return;
    }
    showRegisters(buf);
}

int main()
{
    rLED = LED_ON;
    gLED = LED_ON;
    bLED = LED_OFF;

    MAX32625PICO pico(
        MAX32625PICO::IOH_3V3, MAX32625PICO::VIO_IOH, MAX32625PICO::VIO_IOH);

    gpioAlternatePullup(P3_4);
    gpioAlternatePullup(P3_5);

    I2C i2c(P3_4, P3_5);
    i2c.frequency(100000);

    rLED = LED_OFF;
    gLED = LED_OFF;

    while(1) {
        char c = serial.getc();
        serial.printf("%c\r\n", c);
        readMax14750Regs(&i2c);
    }
}