Initial commit.

Author: nschurando

.clang-format

@@ -0,0 +1,6 @@
+Standard: Cpp11
+BasedOnStyle: Google
+IndentWidth: 4
+ColumnLimit: 0
+KeepEmptyLinesAtTheStartOfBlocks: true
+AllowShortIfStatementsOnASingleLine: Always

.github/FUNDING.yml

@@ -0,0 +1 @@
+patreon: sitronlabs

LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Sitron Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

doc/Pericom PI3USB9281C Datasheet.pdf

@@ -0,0 +1,9 @@
+pi3usb9281c	KEYWORD1
+setup	KEYWORD2
+detect	KEYWORD2
+reset	KEYWORD2
+device_attach_wait	KEYWORD2
+device_type_get	KEYWORD2
+switch_state_set	KEYWORD2
+register_read	KEYWORD2
+register_write	KEYWORD2

keywords.txt

@@ -0,0 +1,16 @@
+{
+    "name": "Sitron_Labs_PI3USB9281C_Arduino_Library",
+    "version": "0.1.0",
+    "description": "Arduino library for the Diodes Incorporated (previously Pericom) PI3USB9281C USB device detection IC.",
+    "keywords": "sitron labs,sitron,labs,arduino,library,i2c,interface,usb,device,charger,detection,pericom,diodes,diodes incorporated,pi3usb9281,pi3usb9281a,pi3usb9281c",
+    "repository": {
+        "type": "git",
+        "url": "https:\/\/github.com\/sitronlabs\/SitronLabs_Diodes_PI3USB9281C_Arduino_Library.git"
+    },
+    "frameworks": "arduino",
+    "platforms": "*",
+    "dependencies": [],
+    "build": {
+        "includeDir": "src"
+    }
+}

library.json

@@ -0,0 +1,10 @@
+name=Sitron Labs PI3USB9281C Arduino Library
+version=0.1.0
+author=Sitron Labs
+maintainer=Sitron Labs <[email protected]>
+sentence=Arduino library for the Diodes Incorporated (previously Pericom) PI3USB9281C USB device detection IC.
+paragraph=
+category=Other
+url=https://github.com/sitronlabs/SitronLabs_Diodes_PI3USB9281C_Arduino_Library
+architectures=*
+depends=

library.properties

@@ -0,0 +1,218 @@
+/* Self header */
+#include "pi3usb9281c.h"
+
+/* Config */
+#ifndef CONFIG_PI3USB9281C_LOG_FUNCTION
+#define CONFIG_PI3USB9281C_LOG_FUNCTION(...) (void)0  //!< Replace by { Serial.printf(__VA_ARGS__); Serial.println(); } to output on serial port
+#endif
+
+/**
+ *
+ * @param[in] i2c_library
+ * @param[in] i2c_address
+ * @param[in] pin_enb
+ */
+int pi3usb9281c::setup(TwoWire& i2c_library, const uint8_t i2c_address, const int pin_enb) {
+
+    /* Ensure i2c address is valid */
+    if (i2c_address != 0x25) {
+        return -EINVAL;
+    }
+
+    /* Save parameters */
+    m_i2c_library = &i2c_library;
+    m_i2c_address = i2c_address;
+
+    /* Enable */
+    pinMode(pin_enb, OUTPUT);
+    digitalWrite(pin_enb, LOW);
+
+    /* Return success */
+    return 0;
+}
+
+/**
+ *
+ */
+bool pi3usb9281c::detect(void) {
+    uint8_t reg_id;
+    if (register_read(PI3USB9281C_REGISTER_ID, &reg_id) < 0 || reg_id != 0b00011000) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+/**
+ *
+ */
+int pi3usb9281c::reset(void) {
+
+    /* */
+    uint8_t reg_reset = 0x01;
+    if (register_write(PI3USB9281C_REGISTER_RESET, reg_reset) < 0) {
+        return -EIO;
+    }
+
+    /* Return success */
+    return 0;
+}
+
+/**
+ * @param[in] timeout_ms
+ * @return
+ */
+int pi3usb9281c::device_attach_wait(const uint32_t timeout_ms) {
+
+    /* While timeout has not expired */
+    for (uint32_t time_start = millis();;) {
+
+        /* Watch for timeout */
+        if (millis() - time_start >= timeout_ms) {
+            return -ETIMEDOUT;
+        }
+
+        /* Read interrupt flags */
+        uint8_t reg_interrupt = 0;
+        if (register_read(PI3USB9281C_REGISTER_INTERRUPT, &reg_interrupt) < 0) {
+            return -EIO;
+        }
+
+        /* Check accessory attached interrupt flag */
+        if (reg_interrupt & 0b1) {
+
+            /* Clear interrupt flag */
+            reg_interrupt = 0b1;
+            if (register_write(PI3USB9281C_REGISTER_INTERRUPT, reg_interrupt) < 0) {
+                return -EIO;
+            }
+
+            /* Return success */
+            return 0;
+        }
+    }
+}
+
+/**
+ *
+ */
+int pi3usb9281c::device_type_get(enum pi3usb9281c_device_type* const type) {
+
+    /* Read registers */
+    uint8_t reg_device_type = 0;
+    uint8_t reg_charger_type = 0;
+    if ((register_read(PI3USB9281C_REGISTER_DEVICE_TYPE, &reg_device_type) < 0) ||
+        (register_read(PI3USB9281C_REGISTER_CHARGER_STATUS, &reg_charger_type) < 0)) {
+        CONFIG_PI3USB9281C_LOG_FUNCTION("Failed to read device type!");
+        return -EIO;
+    }
+
+    /*  */
+    if (reg_charger_type & (1 << 4)) {
+        *type = PI3USB9281C_DEVICE_TYPE_CHARGER_2_4A;
+    } else if (reg_charger_type & (1 << 3)) {
+        *type = PI3USB9281C_DEVICE_TYPE_CHARGER_2A;
+    } else if (reg_charger_type & (1 << 2)) {
+        *type = PI3USB9281C_DEVICE_TYPE_CHARGER_1A;
+    } else if ((reg_charger_type & 0b11) == 0b11) {
+        *type = PI3USB9281C_DEVICE_TYPE_CARKIT2;
+    } else if ((reg_charger_type & 0b11) == 0b10) {
+        *type = PI3USB9281C_DEVICE_TYPE_CARKIT1;
+    } else if (reg_device_type & (1 << 6)) {
+        *type = PI3USB9281C_DEVICE_TYPE_USB_DCP;
+    } else if (reg_device_type & (1 << 5)) {
+        *type = PI3USB9281C_DEVICE_TYPE_USB_CDP;
+    } else if (reg_device_type & (1 << 2)) {
+        *type = PI3USB9281C_DEVICE_TYPE_USB_SDP;
+    } else {
+        *type = PI3USB9281C_DEVICE_TYPE_UNKNOWN;
+    }
+
+    /* Return success */
+    return 0;
+}
+
+/**
+ *
+ */
+int pi3usb9281c::switch_state_set(const enum pi3usb9281c_switch_state state) {
+
+    /* Ensure state is valid */
+    if (state != PI3USB9281C_SWITCH_STATE_AUTO &&
+        state != PI3USB9281C_SWITCH_STATE_MANUAL_OPEN &&
+        state != PI3USB9281C_SWITCH_STATE_MANUAL_CLOSED) {
+        return -EINVAL;
+    }
+
+    /* Write registers */
+    uint8_t reg_control = 0b00011011 | (state == PI3USB9281C_SWITCH_STATE_AUTO ? 1 << 2 : 0);
+    uint8_t reg_manual_switch = 0b00000000 | (state == PI3USB9281C_SWITCH_STATE_MANUAL_CLOSED ? 0b00100111 : 0);
+    if (register_write(PI3USB9281C_REGISTER_CONTROL, reg_control) < 0 ||
+        register_write(PI3USB9281C_REGISTER_MANUAL_SWITCH, reg_manual_switch) < 0) {
+        return -EIO;
+    }
+
+    /* Return success */
+    return 0;
+}
+
+/**
+ * Reads the contents of the given register.
+ * @param[in] reg_address The address of the register.
+ * @param[out] reg_content A pointer to a variable that will be updated with the contents of the register.
+ * @return 0 in case of success, or a negative error code otherwise.
+ */
+int pi3usb9281c::register_read(const enum pi3usb9281c_register reg_address, uint8_t* const reg_content) {
+    int res;
+
+    /* Ensure library has been configured */
+    if (m_i2c_library == NULL) {
+        return -EINVAL;
+    }
+
+    /* Send register address */
+    m_i2c_library->beginTransmission(m_i2c_address);
+    m_i2c_library->write(reg_address);
+    res = m_i2c_library->endTransmission(false);
+    if (res != 0) {
+        return -EIO;
+    }
+
+    /* Read data */
+    m_i2c_library->requestFrom(m_i2c_address, (uint8_t)1, (uint8_t) true);
+    res = m_i2c_library->available();
+    if (res == 0) {
+        return -EIO;
+    }
+    *reg_content = m_i2c_library->read();
+
+    /* Return success */
+    return 0;
+}
+
+/**
+ * Updates the content of the given register.
+ * @param[in] reg_address The address of the register.
+ * @param[in] reg_content The new content of the register.
+ * @return 0 in case of success, or a negative error code otherwise.
+ */
+int pi3usb9281c::register_write(const enum pi3usb9281c_register reg_address, const uint8_t reg_content) {
+    int res;
+
+    /* Ensure library has been configured */
+    if (m_i2c_library == NULL) {
+        return -EINVAL;
+    }
+
+    /* Send register address and data */
+    m_i2c_library->beginTransmission(m_i2c_address);
+    m_i2c_library->write(reg_address);
+    m_i2c_library->write(reg_content);
+    res = m_i2c_library->endTransmission(true);
+    if (res != 0) {
+        return -EIO;
+    }
+
+    /* Return success */
+    return 0;
+}

src/pi3usb9281c.cpp

@@ -0,0 +1,72 @@
+#ifndef PI3USB9281C_H
+#define PI3USB9281C_H
+
+/* Arduino libraries */
+#include <Arduino.h>
+#include <Wire.h>
+
+/* C/C++ libraries */
+#include <errno.h>
+#include <stddef.h>
+#include <stdint.h>
+
+/**
+ *
+ */
+enum pi3usb9281c_register {
+    PI3USB9281C_REGISTER_ID = 0x01,
+    PI3USB9281C_REGISTER_CONTROL = 0x02,
+    PI3USB9281C_REGISTER_INTERRUPT = 0x03,
+    PI3USB9281C_REGISTER_INTERRUPT_MASK = 0x05,
+    PI3USB9281C_REGISTER_DEVICE_TYPE = 0x0A,
+    PI3USB9281C_REGISTER_VBUS_DETECT = 0x0B,
+    PI3USB9281C_REGISTER_CHARGER_STATUS = 0x0E,
+    PI3USB9281C_REGISTER_MANUAL_SWITCH = 0x13,
+    PI3USB9281C_REGISTER_RESET = 0x1B,
+    PI3USB9281C_REGISTER_VBUS = 0x1D,
+};
+
+/**
+ * List of different switch states for the D+ and D- signals
+ */
+enum pi3usb9281c_switch_state {
+    PI3USB9281C_SWITCH_STATE_AUTO,
+    PI3USB9281C_SWITCH_STATE_MANUAL_OPEN,
+    PI3USB9281C_SWITCH_STATE_MANUAL_CLOSED,
+};
+
+/**
+ * List of different USB devices the IC can detect
+ */
+enum pi3usb9281c_device_type {
+    PI3USB9281C_DEVICE_TYPE_UNKNOWN,
+    PI3USB9281C_DEVICE_TYPE_USB_SDP,       //!< Standard Downstream Port, up to 500mA
+    PI3USB9281C_DEVICE_TYPE_USB_CDP,       //!< Charging Downstream Port, up to 1.5A
+    PI3USB9281C_DEVICE_TYPE_USB_DCP,       //!< Dedicated Charging Port, beyond 1.5A
+    PI3USB9281C_DEVICE_TYPE_CHARGER_1A,    //!< 1.0 Amps charger
+    PI3USB9281C_DEVICE_TYPE_CHARGER_2A,    //!< 2.0 Amps charger
+    PI3USB9281C_DEVICE_TYPE_CHARGER_2_4A,  //!< 2.4 Amps charger
+    PI3USB9281C_DEVICE_TYPE_CARKIT1,       //!<
+    PI3USB9281C_DEVICE_TYPE_CARKIT2,       //!<
+};
+
+/**
+ *
+ */
+class pi3usb9281c {
+   public:
+    int setup(TwoWire &i2c_library, const uint8_t i2c_address, const int pin_res);
+    bool detect(void);
+    int reset(void);
+    int device_attach_wait(const uint32_t timeout_ms);
+    int device_type_get(enum pi3usb9281c_device_type *const type);
+    int switch_state_set(const enum pi3usb9281c_switch_state state);
+    int register_read(const enum pi3usb9281c_register reg_address, uint8_t *const reg_content);
+    int register_write(const enum pi3usb9281c_register reg_address, const uint8_t reg_content);
+
+   protected:
+    TwoWire *m_i2c_library = NULL;
+    uint8_t m_i2c_address = 0;
+};
+
+#endif