Porting generic C driver with function pointer

Question

I am trying to port a generic C driver available for a IMU to my embedded platform based on a nordic module. the most optimal way would be to correctly modify the interface functions to adapt it to my system. So the driver available on github here, has this interface for write/read register:

typedef int32_t (*lsm6dso_write_ptr)(void *, uint8_t, uint8_t*, uint16_t);
typedef int32_t (*lsm6dso_read_ptr) (void *, uint8_t, uint8_t*, uint16_t);

typedef struct {
  /** Component mandatory fields **/
  lsm6dso_write_ptr  write_reg;
  lsm6dso_read_ptr   read_reg;
  /** Customizable optional pointer **/
  void *handle;
} lsm6dso_ctx_t;

My read/write register functions are:

void write_i2c_data(nrf_drv_twi_t const *m_twi, uint8_t reg, uint8_t val)
{
    uint8_t cmd[2] = {0, 0};
    cmd[0] = reg;
    cmd[1] = val;
    nrf_drv_twi_tx(m_twi, ADDR, cmd, 2, true);
    nrf_delay_ms(1);
}

void read_i2c_data(nrf_drv_twi_t const *m_twi, uint8_t reg, uint8_t *val)
{
    nrf_drv_twi_tx(m_twi, ADDR, &reg, 1, true);
    nrf_delay_ms(1);

    nrf_drv_twi_rx(m_twi, ADDR, val, 1);
    nrf_delay_ms(1);
}

Questions -

1 - I am not sure how to pass along the m_twi driver instance function along to the lsm6dso_ctx_t struct. It says the struct is customizable, but I am not sure how to augment it.

2 - The function pointer kind of got me too - how can I point my function to the lsm6dso_write_ptr pointer. I know will need to modify my function to provide for multiple byte read/write, which I think is doable.

Answer 1

You should implement two functions:

static int32_t your_callback_lsm6dso_read_reg(void *ctx, uint8_t reg, uint8_t* data,
                         uint16_t len) {
      // read from register ret
      // len length of data to data pointer
      // return 0 on success

      // something like: (I have no idea about nrf_* interface)
      nrf_drv_twi_t const *m_twi = ctx;
      nrf_drv_twi_rx(m_twi, reg, data, len);

      return 0;
}

static int32_t your_callback_lsm6dso_write_reg(void *ctx, uint8_t reg, uint8_t* data,
                          uint16_t len)
       // write to register ret  len length od data from data pointer
       // return 0 on success

       // something like: (I have no idea about nrf* interface)
       nrf_drv_twi_t const *m_twi = ctx;
       nrf_drv_twi_tx(m_twi, reg, data, len);

       return 0;
 }

Then instantiate the structure:

 lsm6dso_ctx_t lsm6dso_ctx = { your_callback_lsm6dso_write_reg, your_callback_lsm6dso_read_reg, m_twi };

and use it like:

lsm6dso_some_function_from_the_library(&lsm6dso_ctx, ...)

The function from the library will call the function pointers from lsm6dso_ctx with the first argument as the void* pointer from the structure. The void* pointer from the structure is used to pass your custom data along. You can then cast the handle from void* pointer into a custom pointer and call the appropriate functions.

how can I point my function to the lsm6dso_write_ptr pointer.

I think your confusion comes from it, that's it's the other way round. The function pointers inside lsm6dso_ctx_t should point to your functions.

Then you have just an instance of lsm6dso_ctx_t structure you use with all functions from the driver. The driver has some logic and it calls your functions as passed with the structure to do input/output operations.