mb85rc1mt.c

Go to the documentation of this file.

 
#include "mb85rc1mt.h"
 
#include <libtock/peripherals/i2c_master.h>
#include <string.h>
 
#include "fram.h"
 
static const uint8_t g_base_addr = 0b10100000;
 
static const int mb85rc1mt_pages = 1;
 
static const int mb85rc1mt_seg_size = 1 << 17;
 
typedef struct {
  uint8_t dev;
  uint16_t mem;
} mb85rc1mt_address;
 
fram_status mb85rc1mt_wakeup(mb85rc1mt_address addr);
 
fram_status mb85rc1mt_sleep(mb85rc1mt_address addr);
 
static mb85rc1mt_address convert_address(fram_addr addr) {
  mb85rc1mt_address i2c_addr;
 
  // Upper address bits go into device address.
  // Shift right by 15 to get bit 16 into position, mask to keep only
  // relevant bits, OR with base address.
  i2c_addr.dev = g_base_addr | ((addr >> 15) & 0x0E);
  i2c_addr.mem = addr & 0xFFFF;
 
  return i2c_addr;
}
 
fram_status mb85rc1mt_write(fram_addr addr, const uint8_t* data, size_t len) {
  fram_status status = FRAM_OK;
 
  while (len > 0) {
    // convert fram address to i2c address
    mb85rc1mt_address i2c_addr = convert_address(addr);
 
    // wakeup device
    status = mb85rc1mt_wakeup(i2c_addr);
    if (status != FRAM_OK) {
      return status;
    }
 
    // number of bytes that can be written without changing address
    size_t write_len = 0;
    if ((size_t)addr + len > mb85rc1mt_seg_size) {
      write_len = mb85rc1mt_seg_size - addr;
    } else {
      write_len = len;
    }
 
    // transmit data
    int tock_status = RETURNCODE_SUCCESS;
 
    // NOTE: There is an internal 32 bytes buffer on I2C communication
    // See below in read for additional details.
 
    size_t written = 0;
    while (written < write_len) {
      // Add address header to chunk
      uint8_t buffer[32] = {};
      buffer[0] = (uint8_t)(i2c_addr.mem >> 8);
      buffer[1] = (uint8_t)(i2c_addr.mem & 0xFF);
 
      // Calculate remaining bytes
      size_t remaining = write_len - written;
      size_t chunk_size = 0;
      if (remaining > 30) {
        chunk_size = 30;
      } else {
        chunk_size = remaining;
      }
 
      // copy chunk into buffer
      memcpy(buffer + 2, data + written, chunk_size);
      // write chunk
      tock_status = i2c_master_write_sync(i2c_addr.dev, buffer, chunk_size + 2);
      if (tock_status < 0) {
        return FRAM_ERROR;
      }
 
      // update written with total number of bytes
      written += chunk_size;
      // get the address for the next chunk
      i2c_addr = convert_address(addr + written);
    }
 
    // Old Implementation
 
    // uint8_t buffer[write_len + 2] = {};
    // buffer[0] = (uint8_t)(i2c_addr.mem >> 8);
    // buffer[1] = (uint8_t)(i2c_addr.mem & 0xFF);
    // memcpy(buffer+2, data, write_len);
    // tock_status = i2c_master_write_sync(i2c_addr.dev, buffer, write_len + 2);
 
    // if (tock_status < 0) {
    //   return FRAM_ERROR;
    // }
 
    // update address and length
    addr += write_len;
    len -= write_len;
    data += write_len;
 
    // sleep device
    status = mb85rc1mt_sleep(i2c_addr);
    if (status != FRAM_OK) {
      return status;
    }
  }
 
  return status;
}
 
fram_status mb85rc1mt_read(fram_addr addr, size_t len, uint8_t* data) {
  fram_status status = FRAM_OK;
 
  while (len > 0) {
    // convert fram address to i2c address
    mb85rc1mt_address i2c_addr = convert_address(addr);
 
    // wakeup device
    status = mb85rc1mt_wakeup(i2c_addr);
    if (status != FRAM_OK) {
      return status;
    }
 
    size_t read_len = 0;
    if ((size_t)addr + len > mb85rc1mt_seg_size) {
      read_len = mb85rc1mt_seg_size - addr;
    } else {
      read_len = len;
    }
 
    // transmit data
    int tock_status = RETURNCODE_SUCCESS;
 
    uint8_t mem_addr[2] = {};
    mem_addr[0] = (uint8_t)(i2c_addr.mem >> 8);
    mem_addr[1] = (uint8_t)(i2c_addr.mem & 0xFF);
 
    // set read address
    tock_status = i2c_master_write_sync(i2c_addr.dev, mem_addr, 2);
    if (tock_status < 0) {
      return FRAM_ERROR;
    }
 
    // NOTE: This is a temporary workaround for reading more than the 32 byte
    // interal buffer. We write a single byte at at time.
    // In the kernal see, `capsules/core/i2c_master.rs`.
 
    for (size_t i = 0; i < read_len; i++) {
      tock_status = i2c_master_read_sync(i2c_addr.dev, data + i, 1);
      if (tock_status < 0) {
        return FRAM_ERROR;
      }
    }
 
    // read from memory
    // tock_status = i2c_master_read_sync(i2c_addr.dev, data, read_len);
    // if (tock_status < 0) {
    //  return FRAM_ERROR;
    //}
 
    // update read params
    addr += read_len;
    len -= read_len;
    data += read_len;
 
    // sleep device
    status = mb85rc1mt_sleep(i2c_addr);
    if (status != FRAM_OK) {
      return status;
    }
  }
 
  // return status
  return status;
}
 
fram_status mb85rc1mt_wakeup(mb85rc1mt_address addr) {
  // TODO: Implement wakeup
 
  (void)addr;
 
  return FRAM_OK;
}
 
fram_status mb85rc1mt_sleep(mb85rc1mt_address addr) {
  // TODO: Implement sleep
 
  (void)addr;
 
  return FRAM_OK;
}
 
fram_addr mb85rc1mt_size(void) { return mb85rc1mt_pages * mb85rc1mt_seg_size; }