| /* |
| * vl53l0x_i2c_platform.h - Linux kernel modules for |
| * STM VL53L0 FlightSense TOF sensor |
| * |
| * Copyright (C) 2016 STMicroelectronics Imaging Division. |
| * Copyright (c) 2018, The Linux Foundation. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| */ |
| |
| /** |
| * @file VL_i2c_platform.h |
| * @brief Function prototype definitions for EWOK Platform layer. |
| * |
| */ |
| |
| |
| #ifndef _VL_I2C_PLATFORM_H_ |
| #define _VL_I2C_PLATFORM_H_ |
| |
| #include "vl53l0x_def.h" |
| |
| |
| /** Maximum buffer size to be used in i2c */ |
| #define VL_MAX_I2C_XFER_SIZE 64 |
| |
| /** |
| * @brief Typedef defining .\n |
| * The developer should modify this to suit the platform being deployed. |
| * |
| */ |
| |
| /** |
| * @brief Typedef defining 8 bit unsigned char type.\n |
| * The developer should modify this to suit the platform being deployed. |
| * |
| */ |
| #define I2C 0x01 |
| #define SPI 0x00 |
| |
| #define COMMS_BUFFER_SIZE 64 |
| /*MUST be the same size as the SV task buffer */ |
| |
| #define BYTES_PER_WORD 2 |
| #define BYTES_PER_DWORD 4 |
| |
| #define VL_MAX_STRING_LENGTH_PLT 256 |
| |
| /** |
| * @brief Initialise platform comms. |
| * |
| * @param comms_type - selects between I2C and SPI |
| * @param comms_speed_khz - unsigned short containing the I2C speed in kHz |
| * |
| * @return status - status 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_comms_initialise(uint8_t comms_type, |
| uint16_t comms_speed_khz); |
| |
| /** |
| * @brief Close platform comms. |
| * |
| * @return status - status 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_comms_close(void); |
| |
| /** |
| * @brief Cycle Power to Device |
| * |
| * @return status - status 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_cycle_power(void); |
| |
| int32_t VL_set_page(struct vl_data *dev, uint8_t page_data); |
| |
| /** |
| * @brief Writes the supplied byte buffer to the device |
| * |
| * Wrapper for SystemVerilog Write Multi task |
| * |
| * @code |
| * |
| * Example: |
| * |
| * uint8_t *spad_enables; |
| * |
| * int status = VL_write_multi(RET_SPAD_EN_0, spad_enables, 36); |
| * |
| * @endcode |
| * |
| * @param address - uint8_t device address value |
| * @param index - uint8_t register index value |
| * @param pdata - pointer to uint8_t buffer containing the data to be written |
| * @param count - number of bytes in the supplied byte buffer |
| * |
| * @return status - SystemVerilog status 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_write_multi(struct vl_data *dev, uint8_t index, uint8_t *pdata, |
| int32_t count); |
| |
| |
| /** |
| * @brief Reads the requested number of bytes from the device |
| * |
| * Wrapper for SystemVerilog Read Multi task |
| * |
| * @code |
| * |
| * Example: |
| * |
| * uint8_t buffer[COMMS_BUFFER_SIZE]; |
| * |
| * int status = status = VL_read_multi(DEVICE_ID, buffer, 2) |
| * |
| * @endcode |
| * |
| * @param address - uint8_t device address value |
| * @param index - uint8_t register index value |
| * @param pdata - pointer to the uint8_t buffer to store read data |
| * @param count - number of uint8_t's to read |
| * |
| * @return status - SystemVerilog status 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_read_multi(struct vl_data *dev, uint8_t index, uint8_t *pdata, |
| int32_t count); |
| |
| |
| /** |
| * @brief Writes a single byte to the device |
| * |
| * Wrapper for SystemVerilog Write Byte task |
| * |
| * @code |
| * |
| * Example: |
| * |
| * uint8_t page_number = MAIN_SELECT_PAGE; |
| * |
| * int status = VL_write_byte(PAGE_SELECT, page_number); |
| * |
| * @endcode |
| * |
| * @param address - uint8_t device address value |
| * @param index - uint8_t register index value |
| * @param data - uint8_t data value to write |
| * |
| * @return status - SystemVerilog status 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_write_byte(struct vl_data *dev, uint8_t index, uint8_t data); |
| |
| |
| /** |
| * @brief Writes a single word (16-bit unsigned) to the device |
| * |
| * Manages the big-endian nature of the device (first byte written is the |
| * MS byte). |
| * Uses SystemVerilog Write Multi task. |
| * |
| * @code |
| * |
| * Example: |
| * |
| * uint16_t nvm_ctrl_pulse_width = 0x0004; |
| * |
| * int status = VL_write_word(NVM_CTRL__PULSE_WIDTH_MSB, |
| * nvm_ctrl_pulse_width); |
| * |
| * @endcode |
| * |
| * @param address - uint8_t device address value |
| * @param index - uint8_t register index value |
| * @param data - uin16_t data value write |
| * |
| * @return status - SystemVerilog status 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_write_word(struct vl_data *dev, uint8_t index, uint16_t data); |
| |
| |
| /** |
| * @brief Writes a single dword (32-bit unsigned) to the device |
| * |
| * Manages the big-endian nature of the device (first byte written is the |
| * MS byte). |
| * Uses SystemVerilog Write Multi task. |
| * |
| * @code |
| * |
| * Example: |
| * |
| * uint32_t nvm_data = 0x0004; |
| * |
| * int status = VL_write_dword(NVM_CTRL__DATAIN_MMM, nvm_data); |
| * |
| * @endcode |
| * |
| * @param address - uint8_t device address value |
| * @param index - uint8_t register index value |
| * @param data - uint32_t data value to write |
| * |
| * @return status - SystemVerilog status 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_write_dword(struct vl_data *dev, uint8_t index, uint32_t data); |
| |
| |
| |
| /** |
| * @brief Reads a single byte from the device |
| * |
| * Uses SystemVerilog Read Byte task. |
| * |
| * @code |
| * |
| * Example: |
| * |
| * uint8_t device_status = 0; |
| * |
| * int status = VL_read_byte(STATUS, &device_status); |
| * |
| * @endcode |
| * |
| * @param address - uint8_t device address value |
| * @param index - uint8_t register index value |
| * @param pdata - pointer to uint8_t data value |
| * |
| * @return status - SystemVerilog status 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_read_byte(struct vl_data *dev, uint8_t index, uint8_t *pdata); |
| |
| |
| /** |
| * @brief Reads a single word (16-bit unsigned) from the device |
| * |
| * Manages the big-endian nature of the device (first byte read is the MS byte). |
| * Uses SystemVerilog Read Multi task. |
| * |
| * @code |
| * |
| * Example: |
| * |
| * uint16_t timeout = 0; |
| * |
| * int status = VL_read_word(TIMEOUT_OVERALL_PERIODS_MSB, &timeout); |
| * |
| * @endcode |
| * |
| * @param address - uint8_t device address value |
| * @param index - uint8_t register index value |
| * @param pdata - pointer to uint16_t data value |
| * |
| * @return status - SystemVerilog status 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_read_word(struct vl_data *dev, uint8_t index, uint16_t *pdata); |
| |
| |
| /** |
| * @brief Reads a single dword (32-bit unsigned) from the device |
| * |
| * Manages the big-endian nature of the device (first byte read is the MS byte). |
| * Uses SystemVerilog Read Multi task. |
| * |
| * @code |
| * |
| * Example: |
| * |
| * uint32_t range_1 = 0; |
| * |
| * int status = VL_read_dword(RANGE_1_MMM, &range_1); |
| * |
| * @endcode |
| * |
| * @param address - uint8_t device address value |
| * @param index - uint8_t register index value |
| * @param pdata - pointer to uint32_t data value |
| * |
| * @return status - SystemVerilog status 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_read_dword(struct vl_data *dev, uint8_t index, uint32_t *pdata); |
| |
| |
| /** |
| * @brief Implements a programmable wait in us |
| * |
| * Wrapper for SystemVerilog Wait in micro seconds task |
| * |
| * @param wait_us - integer wait in micro seconds |
| * |
| * @return status - SystemVerilog status 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_platform_wait_us(int32_t wait_us); |
| |
| |
| /** |
| * @brief Implements a programmable wait in ms |
| * |
| * Wrapper for SystemVerilog Wait in milli seconds task |
| * |
| * @param wait_ms - integer wait in milli seconds |
| * |
| * @return status - SystemVerilog status 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_wait_ms(int32_t wait_ms); |
| |
| |
| /** |
| * @brief Set GPIO value |
| * |
| * @param level - input level - either 0 or 1 |
| * |
| * @return status - SystemVerilog status 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_set_gpio(uint8_t level); |
| |
| |
| /** |
| * @brief Get GPIO value |
| * |
| * @param plevel - uint8_t pointer to store GPIO level (0 or 1) |
| * |
| * @return status - SystemVerilog status 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_get_gpio(uint8_t *plevel); |
| |
| /** |
| * @brief Release force on GPIO |
| * |
| * @return status - SystemVerilog status 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_release_gpio(void); |
| |
| |
| /** |
| * @brief Get the frequency of the timer used for ranging results time stamps |
| * |
| * @param[out] ptimer_freq_hz : pointer for timer frequency |
| * |
| * @return status : 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_get_timer_frequency(int32_t *ptimer_freq_hz); |
| |
| /** |
| * @brief Get the timer value in units of timer_freq_hz |
| * (see VL_get_timestamp_frequency()) |
| * |
| * @param[out] ptimer_count : pointer for timer count value |
| * |
| * @return status : 0 = ok, 1 = error |
| * |
| */ |
| |
| int32_t VL_get_timer_value(int32_t *ptimer_count); |
| int VL_I2CWrite(struct vl_data *dev, uint8_t *buff, uint8_t len); |
| int VL_I2CRead(struct vl_data *dev, uint8_t *buff, uint8_t len); |
| |
| #endif /* _VL_I2C_PLATFORM_H_ */ |
| |