text: /*
   * Copyright (c) 2020 SparkFun Electronics
   * SPDX-License-Identifier: MIT
   *
   * 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.
   */
  
  #if DEVICE_I2C
  
  #include "i2c_api.h"
  #include "iom_api.h"
  #include "PeripheralPins.h"
  #include "mbed_assert.h"
  
  #define DEFAULT_CLK_FREQ (AM_HAL_IOM_400KHZ)
  
  static am_hal_iom_transfer_t xfer = {0};
  
  I2CName i2c_get_peripheral_name(PinName sda, PinName scl)
  {
      uint32_t iom_sda = pinmap_peripheral(sda, i2c_master_sda_pinmap());
      uint32_t iom_scl = pinmap_peripheral(scl, i2c_master_scl_pinmap());
  
      uint32_t iom = pinmap_merge(iom_sda, iom_scl);
  
      if ((int)iom == NC) {
          return IOM_NUM;
      }
  
      return (I2CName)iom;
  }
  
  void i2c_init(i2c_t *obj, PinName sda, PinName scl)
  {
      MBED_ASSERT(obj);
  
      // iom determination
      I2CName iom = i2c_get_peripheral_name(sda, scl);
      MBED_ASSERT((int)iom != IOM_NUM);
  
      // iom configuration
      obj->i2c.iom_obj.iom.inst = (uint32_t)iom;
      obj->i2c.iom_obj.iom.cfg.eInterfaceMode = AM_HAL_IOM_I2C_MODE;
      obj->i2c.iom_obj.iom.cfg.ui32ClockFreq = DEFAULT_CLK_FREQ;
      obj->i2c.iom_obj.iom.cfg.pNBTxnBuf = NULL;
      obj->i2c.iom_obj.iom.cfg.ui32NBTxnBufLength = 0;
  
      // pin configuration
      if ((int)sda != NC) {
          pinmap_config(sda, i2c_master_sda_pinmap());
      }
      if ((int)scl != NC) {
          pinmap_config(scl, i2c_master_scl_pinmap());
      }
  
      // invariant xfer settings
      xfer.ui32InstrLen = 0;
      xfer.ui32Instr = 0;
      xfer.ui8RepeatCount = 0;
      xfer.ui8Priority = 1;
      xfer.ui32PauseCondition = 0;
      xfer.ui32StatusSetClr = 0;
  
      // initialization
      iom_init(&obj->i2c.iom_obj);
  }
  
  void i2c_free(i2c_t *obj)
  {
      MBED_ASSERT(obj);
      iom_deinit(&obj->i2c.iom_obj);
  }
  
  void i2c_frequency(i2c_t *obj, int hz)
  {
      MBED_ASSERT(obj);
      if (hz > AM_HAL_IOM_MAX_FREQ) {
          hz = AM_HAL_IOM_MAX_FREQ;
      }
      obj->i2c.iom_obj.iom.cfg.ui32ClockFreq = hz;
      iom_init(&obj->i2c.iom_obj);
  }
  
  int  i2c_start(i2c_t *obj)
  {
      MBED_ASSERT(obj);
      MBED_ASSERT(0);
      return I2C_ERROR_NO_SLAVE;
  }
  
  int  i2c_stop(i2c_t *obj)
  {
      MBED_ASSERT(obj);
      MBED_ASSERT(0);
      return I2C_ERROR_NO_SLAVE;
  }
  
  int i2c_read(i2c_t *obj, int address8bit, char *data, int length, int stop)
  {
      MBED_ASSERT(obj);
  
      int handled_chars = 0;
  
      xfer.uPeerInfo.ui32I2CDevAddr = (address8bit >> 1);
      xfer.eDirection = AM_HAL_IOM_RX;
      xfer.ui32NumBytes = length;
      xfer.pui32RxBuffer = (uint32_t *)data;
      xfer.pui32TxBuffer = NULL;
      xfer.bContinue = (stop) ? false : true;
      uint32_t status = am_hal_iom_blocking_transfer(obj->i2c.iom_obj.iom.handle, &xfer);
      if (AM_HAL_STATUS_SUCCESS != status) {
          return I2C_ERROR_NO_SLAVE;
      }
      handled_chars += xfer.ui32NumBytes;
  
      return handled_chars;
  }
  
  int i2c_write(i2c_t *obj, int address8bit, const char *data, int length, int stop)
  {
      MBED_ASSERT(obj);
  
      int handled_chars = 0;
  
      xfer.uPeerInfo.ui32I2CDevAddr = (address8bit >> 1);
      xfer.eDirection = AM_HAL_IOM_TX;
      xfer.ui32NumBytes = length;
      xfer.pui32TxBuffer = (uint32_t *)data;
      xfer.pui32RxBuffer = NULL;
      xfer.bContinue = (stop) ? false : true;
      uint32_t status = am_hal_iom_blocking_transfer(obj->i2c.iom_obj.iom.handle, &xfer);
      if (AM_HAL_STATUS_SUCCESS != status) {
          return I2C_ERROR_NO_SLAVE;
      }
      handled_chars += xfer.ui32NumBytes;
  
      return handled_chars;
  }
  
  void i2c_reset(i2c_t *obj)
  {
      MBED_ASSERT(obj);
      MBED_ASSERT(0);
  }
  
  int i2c_byte_read(i2c_t *obj, int last)
  {
      MBED_ASSERT(obj);
      MBED_ASSERT(0);
      return I2C_ERROR_NO_SLAVE;
  }
  
  int i2c_byte_write(i2c_t *obj, int data)
  {
      MBED_ASSERT(obj);
      MBED_ASSERT(0);
      return I2C_ERROR_NO_SLAVE;
  }
  
  const PinMap *i2c_master_sda_pinmap(void)
  {
      return PinMap_I2C_SDA;
  }
  
  const PinMap *i2c_master_scl_pinmap(void)
  {
      return PinMap_I2C_SCL;
  }
  
  const PinMap *i2c_slave_sda_pinmap(void)
  {
      return PinMap_I2C_SDA;
  }
  
  const PinMap *i2c_slave_scl_pinmap(void)
  {
      return PinMap_I2C_SCL;
  }
  
  #endif // DEVICE_I2C
  