int peripheral_bus_gpio_open(gint pin, pb_data_h *handle, gpointer user_data);
int peripheral_bus_gpio_close(pb_data_h handle);
-int peripheral_bus_gpio_set_direction(pb_data_h handle, gint direction);
-int peripheral_bus_gpio_set_edge(pb_data_h handle, gint edge);
-int peripheral_bus_gpio_set_interrupted_cb(pb_data_h handle);
-int peripheral_bus_gpio_unset_interrupted_cb(pb_data_h handle);
-int peripheral_bus_gpio_read(pb_data_h handle, gint *value);
-int peripheral_bus_gpio_write(pb_data_h handle, gint value);
#endif /* __PERIPHERAL_BUS_GPIO_H__ */
int peripheral_bus_i2c_open(int bus, int address, pb_data_h *handle, gpointer user_data);
int peripheral_bus_i2c_close(pb_data_h handle);
-int peripheral_bus_i2c_read(pb_data_h handle, int length, GVariant **data_array);
-int peripheral_bus_i2c_write(pb_data_h handle, int length, GVariant *data_array);
-int peripheral_bus_i2c_smbus_ioctl(pb_data_h handle, uint8_t read_write, uint8_t command, uint32_t size, uint16_t data_in, uint16_t *data_out);
#endif /* __PERIPHERAL_BUS_I2C_H__ */
int peripheral_bus_pwm_open(int chip, int pin, pb_data_h *handle, gpointer user_data);
int peripheral_bus_pwm_close(pb_data_h handle);
-int peripheral_bus_pwm_set_period(pb_data_h handle, int period);
-int peripheral_bus_pwm_set_duty_cycle(pb_data_h handle, int duty_cycle);
-int peripheral_bus_pwm_set_polarity(pb_data_h handle, int polarity);
-int peripheral_bus_pwm_set_enable(pb_data_h handle, bool enable);
#endif /* __PERIPHERAL_BUS_PWM_H__ */
int peripheral_bus_spi_open(int bus, int cs, pb_data_h *handle, gpointer user_data);
int peripheral_bus_spi_close(pb_data_h handle);
-int peripheral_bus_spi_set_mode(pb_data_h handle, unsigned char mode);
-int peripheral_bus_spi_set_bit_order(pb_data_h handle, gboolean lsb);
-int peripheral_bus_spi_set_bits_per_word(pb_data_h handle, unsigned char bits);
-int peripheral_bus_spi_set_frequency(pb_data_h handle, unsigned int freq);
-int peripheral_bus_spi_read(pb_data_h handle, GVariant **data_array, int length);
-int peripheral_bus_spi_write(pb_data_h handle, GVariant *data_array, int length);
-int peripheral_bus_spi_transfer(pb_data_h handle, GVariant *tx_data_array, GVariant **rx_data_array, int length);
#endif /* __PERIPHERAL_BUS_SPI_H__ */
int peripheral_bus_uart_open(int port, pb_data_h *handle, gpointer user_data);
int peripheral_bus_uart_close(pb_data_h handle);
-int peripheral_bus_uart_set_baud_rate(pb_data_h handle, int baud_rate);
-int peripheral_bus_uart_set_byte_size(pb_data_h handle, int byte_size);
-int peripheral_bus_uart_set_parity(pb_data_h handle, int parity);
-int peripheral_bus_uart_set_stop_bits(pb_data_h handle, int stop_bits);
-int peripheral_bus_uart_set_flow_control(pb_data_h handle, int xonxoff, int rtscts);
-int peripheral_bus_uart_read(pb_data_h handle, GVariant **data_array, int length);
-int peripheral_bus_uart_write(pb_data_h handle, GVariant *data_array, int length);
#endif /* __PERIPHERAL_BUS_UART_H__ */
{
peripheral_bus_s *pb_data = (peripheral_bus_s*)user_data;
pb_data_h gpio_handle;
- int edge, direction;
int ret;
if (!peripheral_bus_gpio_is_available(pin, pb_data)) {
goto open_err;
}
- if ((ret = gpio_get_edge_mode(pin, (gpio_edge_e*)&edge)) < 0) {
- _E("gpio_get_edge_mode error (%d)", ret);
- goto err;
- }
-
- if ((ret = gpio_get_direction(pin, (gpio_direction_e*)&direction)) < 0) {
- _E("gpio_get_direction error (%d)", ret);
- goto err;
- }
-
gpio_handle = peripheral_bus_data_new(&pb_data->gpio_list);
if (!gpio_handle) {
_E("peripheral_bus_data_new error");
gpio_handle->type = PERIPHERAL_BUS_TYPE_GPIO;
gpio_handle->list = &pb_data->gpio_list;
gpio_handle->dev.gpio.pin = pin;
- gpio_handle->dev.gpio.edge = edge;
- gpio_handle->dev.gpio.direction = direction;
gpio_handle->dev.gpio.gpio_skeleton = pb_data->gpio_skeleton;
*handle = gpio_handle;
return ret;;
}
-
-// TODO : This function will be removed.
-int peripheral_bus_gpio_set_direction(pb_data_h handle, gint direction)
-{
- peripheral_bus_gpio_s *gpio = &handle->dev.gpio;
- int ret;
-
- gpio->direction = direction;
-
- if ((ret = gpio_set_direction(gpio->pin, (gpio_direction_e)direction)) < 0) {
- _E("gpio_set_direction error (%d)", ret);
- return ret;
- }
-
- return PERIPHERAL_ERROR_NONE;
-}
-
-// TODO : This function will be removed.
-int peripheral_bus_gpio_set_edge(pb_data_h handle, gint edge)
-{
- peripheral_bus_gpio_s *gpio = &handle->dev.gpio;
- int ret;
-
- if ((ret = gpio_set_edge_mode(gpio->pin, (gpio_edge_e)edge)) < 0) {
- _E("gpio_set_edge_mode error (%d)", ret);
- return ret;
- }
-
- gpio->edge = edge;
-
- return PERIPHERAL_ERROR_NONE;
-}
-
-// TODO : This function will be removed.
-static gboolean peripheral_bus_interrupted_cb(GIOChannel *io, GIOCondition condition, gpointer data)
-{
- peripheral_bus_gpio_s *gpio_data = (peripheral_bus_gpio_s *)data;
- struct timeval time;
- // unsigned long long timestamp;
- GIOStatus status;
- gchar* strval;
- int value;
-
- if (!gpio_data->irq_en)
- return TRUE;
-
- if (gpio_data->direction != PERIPHERAL_GPIO_DIRECTION_IN
- || gpio_data->edge == PERIPHERAL_GPIO_EDGE_NONE)
- return TRUE;
-
- gettimeofday(&time, NULL);
-
- g_io_channel_seek_position(io, 0, G_SEEK_SET, NULL);
- status = g_io_channel_read_line(io, &strval, NULL, NULL, NULL);
- if (status != G_IO_STATUS_NORMAL) {
- _E("Unable to read gpio value (%d)", status);
- return FALSE;
- }
- g_strstrip(strval);
-
- _D("gpio = %d, data = %s", gpio_data->pin, strval);
-
- if (g_ascii_strcasecmp(strval, "1") == 0)
- value = 1;
- else if (g_ascii_strcasecmp(strval, "0") == 0)
- value = 0;
- else {
- g_free(strval);
- _E("Error: gpio value is error");
- return FALSE;
- }
- g_free(strval);
-
- if (gpio_data->edge == PERIPHERAL_GPIO_EDGE_RISING && value == 0)
- return TRUE;
- else if (gpio_data->edge == PERIPHERAL_GPIO_EDGE_FALLING && value == 1)
- return TRUE;
-
- //timestamp = (unsigned long long)time.tv_sec * 1000000 + time.tv_usec;
- //peripheral_bus_emit_interrupted_cb(gpio_data->gpio_skeleton, gpio_data->pin, value, timestamp);
-
- return TRUE;
-}
-
-// TODO : This function will be removed.
-int peripheral_bus_gpio_set_interrupted_cb(pb_data_h handle)
-{
- peripheral_bus_gpio_s *gpio = &handle->dev.gpio;
- GIOStatus status;
- gchar* strval;
-
- if ((gpio->value_fd = gpio_open_isr(gpio->pin)) < 0)
- goto err_open_isr;
-
- gpio->io = g_io_channel_unix_new(gpio->value_fd);
- if (gpio->io == NULL) {
- _E("g_io_channel_unix_new error (%d)", gpio->value_fd);
- goto err_io_channel_new;
- }
-
- g_io_channel_seek_position(gpio->io, 0, G_SEEK_SET, NULL);
- status = g_io_channel_read_line(gpio->io, &strval, NULL, NULL, NULL);
- if (status != G_IO_STATUS_NORMAL) {
- _E("Unable to read gpio value (%d)", status);
- goto err_io_channel_read;
- }
- g_free(strval);
-
- gpio->io_id = g_io_add_watch(gpio->io, G_IO_PRI, peripheral_bus_interrupted_cb, gpio);
- if (gpio->io_id == 0) {
- _E("g_io_add_watch error (%d)", gpio->io);
- goto err_io_add_watch;
- }
- g_io_channel_unref(gpio->io);
- gpio->irq_en = 1;
-
- return PERIPHERAL_ERROR_NONE;
-
-err_io_add_watch:
-err_io_channel_read:
- g_io_channel_unref(gpio->io);
- gpio->io_id = 0;
-err_io_channel_new:
- gpio_close_isr(gpio->value_fd);
- gpio->io = 0;
-err_open_isr:
- gpio->value_fd = 0;
-
- return PERIPHERAL_ERROR_UNKNOWN;
-}
-
-// TODO : This function will be removed.
-int peripheral_bus_gpio_unset_interrupted_cb(pb_data_h handle)
-{
- peripheral_bus_gpio_s *gpio = &handle->dev.gpio;
-
- if (gpio->io) {
- gpio->irq_en = 0;
- g_source_remove(gpio->io_id);
- gpio->io_id = 0;
- g_io_channel_unref(gpio->io);
- gpio->io = 0;
- gpio_close_isr(gpio->value_fd);
- gpio->value_fd = 0;
- }
-
- return PERIPHERAL_ERROR_NONE;
-}
-
-// TODO : This function will be removed.
-int peripheral_bus_gpio_read(pb_data_h handle, gint *value)
-{
- peripheral_bus_gpio_s *gpio = &handle->dev.gpio;
- int ret;
-
- if ((ret = gpio_read(gpio->pin, value)) < 0) {
- _E("gpio_read error (%d)", ret);
- return ret;
- }
-
- return PERIPHERAL_ERROR_NONE;
-}
-
-// TODO : This function will be removed.
-int peripheral_bus_gpio_write(pb_data_h handle, gint value)
-{
- peripheral_bus_gpio_s *gpio = &handle->dev.gpio;
- int ret;
-
- /* Return error if direction of the pin is input mode */
- if (gpio->direction == GPIO_DIRECTION_IN) {
- _E("The direction of the pin is INPUT mode, Cannot write");
- return PERIPHERAL_ERROR_IO_ERROR;
- }
-
- if ((ret = gpio_write(gpio->pin, value)) < 0) {
- _E("gpio_write error (%d)", ret);
- return ret;
- }
- /* Update direction state along with the value */
- gpio->direction = GPIO_DIRECTION_OUT_LOW + ((value > 0) ? 1 : 0);
-
- return PERIPHERAL_ERROR_NONE;
-}
return ret;
}
-
-int peripheral_bus_i2c_smbus_ioctl(pb_data_h handle, uint8_t read_write, uint8_t command, uint32_t size, uint16_t data_in, uint16_t *data_out)
-{
- peripheral_bus_i2c_s *i2c = &handle->dev.i2c;
- struct i2c_smbus_ioctl_data data_arg;
- union i2c_smbus_data data;
- int ret;
-
- memset(&data, 0x0, sizeof(data.block));
-
- data_arg.read_write = read_write;
- data_arg.size = size;
- data_arg.data = &data;
-
- RETV_IF(size < I2C_SMBUS_BYTE || size > I2C_SMBUS_WORD_DATA, PERIPHERAL_ERROR_INVALID_PARAMETER);
- RETV_IF(read_write > I2C_SMBUS_READ, PERIPHERAL_ERROR_INVALID_PARAMETER);
-
- if (read_write == I2C_SMBUS_WRITE) {
- data_arg.command = command;
- if (size == I2C_SMBUS_BYTE_DATA)
- data.byte = (uint8_t)data_in;
- else if (size == I2C_SMBUS_WORD_DATA)
- data.word = data_in;
- else if (size == I2C_SMBUS_BYTE)
- data_arg.command = (uint8_t)data_in; // Data should be set to command.
- } else if (read_write == I2C_SMBUS_READ && size != I2C_SMBUS_BYTE) {
- data_arg.command = command;
- }
-
- ret = i2c_smbus_ioctl(i2c->fd, &data_arg);
- if (ret < 0)
- _E("Ioctl failed, bus : %d, address : 0x%x", i2c->bus, i2c->address);
-
- if (ret == 0 && read_write == I2C_SMBUS_READ) {
- if (size == I2C_SMBUS_BYTE_DATA || size == I2C_SMBUS_BYTE)
- *data_out = (uint8_t)data.byte;
- else if (size == I2C_SMBUS_WORD_DATA)
- *data_out = data.word;
- }
-
- return ret;
-}
-
-int peripheral_bus_i2c_read(pb_data_h handle, int length, GVariant **data_array)
-{
- peripheral_bus_i2c_s *i2c = &handle->dev.i2c;
- uint8_t err_buf[2] = {0, };
- int ret;
-
- /* Limit maximum length */
- if (length > MAX_BUFFER_SIZE) length = MAX_BUFFER_SIZE;
-
- /* Increase buffer if needed */
- if (length > i2c->buffer_size) {
- uint8_t *new;
- new = (uint8_t*)realloc(i2c->buffer, length);
-
- if (!new) {
- ret = PERIPHERAL_ERROR_OUT_OF_MEMORY;
- _E("Failed to realloc buffer");
- goto out;
- }
- i2c->buffer = new;
- i2c->buffer_size = length;
- }
-
- ret = i2c_read(i2c->fd, i2c->buffer, length);
-
- /* If read() is failed, try to call ioctl with SMBus */
- if (ret < 0) {
- _D("Try to call ioctl() instead of read(), bus : %d, address : 0x%x",
- i2c->bus, i2c->address);
- ret = peripheral_bus_i2c_smbus_ioctl(handle, I2C_SMBUS_READ,
- 0x0, I2C_SMBUS_BYTE, 0x0, (uint16_t *)&i2c->buffer[0]);
- if (ret < 0)
- _E("Read Failed, bus : %d, address : 0x%x", i2c->bus, i2c->address);
- }
-
- *data_array = peripheral_bus_build_variant_ay(i2c->buffer, I2C_SMBUS_BYTE);
-
- return ret;
-
-out:
- *data_array = peripheral_bus_build_variant_ay(err_buf, sizeof(err_buf));
-
- return ret;
-}
-
-int peripheral_bus_i2c_write(pb_data_h handle, int length, GVariant *data_array)
-{
- peripheral_bus_i2c_s *i2c = &handle->dev.i2c;
- GVariantIter *iter;
- guchar str;
- int ret, i = 0;
-
- /* Limit maximum length */
- if (length > MAX_BUFFER_SIZE) length = MAX_BUFFER_SIZE;
-
- /* Increase buffer if needed */
- if (length > i2c->buffer_size) {
- uint8_t *new;
- new = (uint8_t*)realloc(i2c->buffer, length);
-
- RETVM_IF(new == NULL, PERIPHERAL_ERROR_OUT_OF_MEMORY, "Failed to realloc buffer");
- i2c->buffer = new;
- i2c->buffer_size = length;
- }
-
- g_variant_get(data_array, "a(y)", &iter);
- while (g_variant_iter_loop(iter, "(y)", &str) && i < length)
- i2c->buffer[i++] = str;
- g_variant_iter_free(iter);
-
- ret = i2c_write(i2c->fd, i2c->buffer, length);
-
- /* If write() is failed, try to call ioctl with SMBus */
- if (ret < 0) {
- _D("Try to call ioctl() instead of write(), bus : %d, address : 0x%x",
- i2c->bus, i2c->address);
- ret = peripheral_bus_i2c_smbus_ioctl(handle, I2C_SMBUS_WRITE,
- 0x0, I2C_SMBUS_BYTE, i2c->buffer[0], NULL);
- if (ret < 0)
- _E("Write Failed, bus : %d, address : 0x%x", i2c->bus, i2c->address);
- }
-
- return ret;
-}
-
return ret;
}
-
-int peripheral_bus_pwm_set_period(pb_data_h handle, int period)
-{
- peripheral_bus_pwm_s *pwm = &handle->dev.pwm;
-
- return pwm_set_period(pwm->chip, pwm->pin, period);
-}
-
-
-int peripheral_bus_pwm_set_duty_cycle(pb_data_h handle, int duty_cycle)
-{
- peripheral_bus_pwm_s *pwm = &handle->dev.pwm;
-
- return pwm_set_duty_cycle(pwm->chip, pwm->pin, duty_cycle);
-}
-
-
-int peripheral_bus_pwm_set_polarity(pb_data_h handle, int polarity)
-{
- peripheral_bus_pwm_s *pwm = &handle->dev.pwm;
-
- return pwm_set_polarity(pwm->chip, pwm->pin, (pwm_polarity_e)polarity);
-}
-
-
-int peripheral_bus_pwm_set_enable(pb_data_h handle, bool enable)
-{
- peripheral_bus_pwm_s *pwm = &handle->dev.pwm;
-
- return pwm_set_enable(pwm->chip, pwm->pin, enable);
-}
\ No newline at end of file
#include "peripheral_common.h"
#include "peripheral_bus_util.h"
-static int initial_buffer_size = 128;
-static int max_buffer_size = 4096;
-
static bool __peripheral_bus_spi_is_available(int bus, int cs, peripheral_bus_s *pb_data)
{
pb_board_dev_s *spi = NULL;
peripheral_bus_s *pb_data = (peripheral_bus_s*)user_data;
pb_data_h spi_handle;
int ret = PERIPHERAL_ERROR_NONE;
- int fd, bufsiz;
+ int fd;
if (!__peripheral_bus_spi_is_available(bus, cs, pb_data)) {
_E("spi %d.%d is not available", bus, cs);
spi_handle->dev.spi.bus = bus;
spi_handle->dev.spi.cs = cs;
- if (!spi_get_buffer_size(&bufsiz)) {
- if (bufsiz <= 0) {
- _E("Buffer size is less than or equal to zero");
- goto err_buf_size;
- }
- if (initial_buffer_size > bufsiz) initial_buffer_size = bufsiz;
- if (max_buffer_size > bufsiz) max_buffer_size = bufsiz;
- }
-
- spi_handle->dev.spi.rx_buf = (uint8_t*)calloc(1, initial_buffer_size);
- if (!spi_handle->dev.spi.rx_buf) {
- _E("Failed to allocate rx buffer");
- ret = PERIPHERAL_ERROR_OUT_OF_MEMORY;
- goto err_rx_buf;
- }
- spi_handle->dev.spi.tx_buf = (uint8_t*)calloc(1, initial_buffer_size);
- if (!spi_handle->dev.spi.tx_buf) {
- _E("Failed to allocate tx buffer");
- ret = PERIPHERAL_ERROR_OUT_OF_MEMORY;
- goto err_tx_buf;
- }
-
- spi_handle->dev.spi.rx_buf_size = initial_buffer_size;
- spi_handle->dev.spi.tx_buf_size = initial_buffer_size;
*handle = spi_handle;
return PERIPHERAL_ERROR_NONE;
-err_tx_buf:
- if (spi_handle->dev.spi.rx_buf)
- free(spi_handle->dev.spi.rx_buf);
- spi_handle->dev.spi.rx_buf_size = 0;
-
-err_rx_buf:
-err_buf_size:
- peripheral_bus_data_free(spi_handle);
-
err_spi_data:
spi_close(fd);
}
return ret;
-}
-
-int peripheral_bus_spi_set_mode(pb_data_h handle, unsigned char mode)
-{
- peripheral_bus_spi_s *spi = &handle->dev.spi;
-
- return spi_set_mode(spi->fd, mode);
-}
-
-int peripheral_bus_spi_set_bit_order(pb_data_h handle, gboolean lsb)
-{
- peripheral_bus_spi_s *spi = &handle->dev.spi;
-
- return spi_set_bit_order(spi->fd, (unsigned char)lsb);
-}
-
-int peripheral_bus_spi_set_bits_per_word(pb_data_h handle, unsigned char bits)
-{
- peripheral_bus_spi_s *spi = &handle->dev.spi;
-
- return spi_set_bits_per_word(spi->fd, bits);
-}
-
-int peripheral_bus_spi_set_frequency(pb_data_h handle, unsigned int freq)
-{
- peripheral_bus_spi_s *spi = &handle->dev.spi;
-
- return spi_set_frequency(spi->fd, freq);
-}
-
-int peripheral_bus_spi_read(pb_data_h handle, GVariant **data_array, int length)
-{
- peripheral_bus_spi_s *spi = &handle->dev.spi;
- uint8_t err_buf[2] = {0, };
- int ret;
-
- /* Limit maximum length */
- if (length > max_buffer_size) length = max_buffer_size;
-
- /* Increase buffer if needed */
- if (length > spi->rx_buf_size) {
- uint8_t *buffer;
-
- buffer = (uint8_t*)realloc(spi->rx_buf, length);
- if (!buffer) {
- ret = PERIPHERAL_ERROR_OUT_OF_MEMORY;
- _E("Failed to realloc buffer");
- goto out;
- }
- spi->rx_buf = buffer;
- spi->rx_buf_size = length;
- }
-
- ret = spi_read(spi->fd, spi->rx_buf, length);
- *data_array = peripheral_bus_build_variant_ay(spi->rx_buf, length);
-
- return ret;
-
-out:
- *data_array = peripheral_bus_build_variant_ay(err_buf, sizeof(err_buf));
-
- return ret;
-}
-
-int peripheral_bus_spi_write(pb_data_h handle, GVariant *data_array, int length)
-{
- peripheral_bus_spi_s *spi = &handle->dev.spi;
- GVariantIter *iter;
- guchar str;
- int i = 0;
-
- /* Limit maximum length */
- if (length > max_buffer_size) length = max_buffer_size;
-
- /* Increase buffer if needed */
- if (length > spi->tx_buf_size) {
- uint8_t *buffer;
-
- buffer = (uint8_t*)realloc(spi->tx_buf, length);
- RETVM_IF(buffer == NULL, PERIPHERAL_ERROR_OUT_OF_MEMORY, "Failed to realloc tx buffer");
-
- spi->tx_buf = buffer;
- spi->tx_buf_size = length;
- }
-
- g_variant_get(data_array, "a(y)", &iter);
- while (g_variant_iter_loop(iter, "(y)", &str) && i < length)
- spi->tx_buf[i++] = str;
- g_variant_iter_free(iter);
-
- return spi_write(spi->fd, spi->tx_buf, length);
-}
-
-int peripheral_bus_spi_transfer(pb_data_h handle, GVariant *tx_data_array, GVariant **rx_data_array, int length)
-{
- peripheral_bus_spi_s *spi = &handle->dev.spi;
- uint8_t err_buf[2] = {0, };
- GVariantIter *iter;
- guchar str;
- int i = 0;
- int ret;
-
- /* Limit maximum length */
- if (length > max_buffer_size) length = max_buffer_size;
-
- /* Increase rx buffer if needed */
- if (length > spi->rx_buf_size) {
- uint8_t *buffer;
-
- buffer = (uint8_t*)realloc(spi->rx_buf, length);
- if (!buffer) {
- ret = PERIPHERAL_ERROR_OUT_OF_MEMORY;
- _E("Failed to realloc rx buffer");
- goto out;
- }
- spi->rx_buf = buffer;
- spi->rx_buf_size = length;
- }
-
- /* Increase tx buffer if needed */
- if (length > spi->tx_buf_size) {
- uint8_t *buffer;
-
- buffer = (uint8_t*)realloc(spi->tx_buf, length);
- if (!buffer) {
- ret = PERIPHERAL_ERROR_OUT_OF_MEMORY;
- _E("Failed to realloc tx buffer");
- goto out;
- }
-
- spi->tx_buf = buffer;
- spi->tx_buf_size = length;
- }
- g_variant_get(tx_data_array, "a(y)", &iter);
- while (g_variant_iter_loop(iter, "(y)", &str) && i < length)
- spi->tx_buf[i++] = str;
- g_variant_iter_free(iter);
-
- ret = spi_transfer(spi->fd, spi->tx_buf, spi->rx_buf, length);
- *rx_data_array = peripheral_bus_build_variant_ay(spi->rx_buf, length);
-
- return ret;
-
-out:
- *rx_data_array = peripheral_bus_build_variant_ay(err_buf, sizeof(err_buf));
-
- return ret;
-}
+}
\ No newline at end of file
}
return ret;
-}
-
-int peripheral_bus_uart_set_baud_rate(pb_data_h handle, int baud_rate)
-{
- peripheral_bus_uart_s *uart = &handle->dev.uart;
-
- return uart_set_baud_rate(uart->fd, baud_rate);
-}
-
-int peripheral_bus_uart_set_byte_size(pb_data_h handle, int byte_size)
-{
- peripheral_bus_uart_s *uart = &handle->dev.uart;
-
- return uart_set_byte_size(uart->fd, byte_size);
-}
-
-int peripheral_bus_uart_set_parity(pb_data_h handle, int parity)
-{
- peripheral_bus_uart_s *uart = &handle->dev.uart;
-
- return uart_set_parity(uart->fd, parity);
-}
-int peripheral_bus_uart_set_stop_bits(pb_data_h handle, int stop_bits)
-{
- peripheral_bus_uart_s *uart = &handle->dev.uart;
-
- return uart_set_stop_bits(uart->fd, stop_bits);
-}
-
-int peripheral_bus_uart_set_flow_control(pb_data_h handle, bool xonxoff, bool rtscts)
-{
- peripheral_bus_uart_s *uart = &handle->dev.uart;
-
- return uart_set_flow_control(uart->fd, xonxoff, rtscts);
-}
-
-int peripheral_bus_uart_read(pb_data_h handle, GVariant **data_array, int length)
-{
- peripheral_bus_uart_s *uart = &handle->dev.uart;
- int ret;
-
- /* Limit maximum length */
- if (length > MAX_BUFFER_SIZE) length = MAX_BUFFER_SIZE;
-
- /* Increase buffer if needed */
- if (length > uart->buffer_size) {
- uint8_t *buffer;
-
- buffer = (uint8_t*)realloc(uart->buffer, length);
- RETVM_IF(buffer == NULL, PERIPHERAL_ERROR_OUT_OF_MEMORY, "Failed to realloc buffer");
-
- uart->buffer = buffer;
- uart->buffer_size = length;
- }
-
- ret = uart_read(uart->fd, uart->buffer, length);
- if (ret > 0)
- *data_array = peripheral_bus_build_variant_ay(uart->buffer, ret);
-
- return ret;
-}
-
-int peripheral_bus_uart_write(pb_data_h handle, GVariant *data_array, int length)
-{
- peripheral_bus_uart_s *uart = &handle->dev.uart;
- GVariantIter *iter;
- guchar str;
- int i = 0;
-
- /* Limit maximum length */
- if (length > MAX_BUFFER_SIZE) length = MAX_BUFFER_SIZE;
-
- /* Increase buffer if needed */
- if (length > uart->buffer_size) {
- uint8_t *buffer;
-
- buffer = (uint8_t*)realloc(uart->buffer, length);
- RETVM_IF(buffer == NULL, PERIPHERAL_ERROR_OUT_OF_MEMORY, "Failed to realloc buffer");
-
- uart->buffer = buffer;
- uart->buffer_size = length;
- }
-
- g_variant_get(data_array, "a(y)", &iter);
- while (g_variant_iter_loop(iter, "(y)", &str) && i < length)
- uart->buffer[i++] = str;
- g_variant_iter_free(iter);
-
- return uart_write(uart->fd, uart->buffer, length);
-}
+}
\ No newline at end of file
return 0;
}
-int gpio_set_direction(int gpiopin, gpio_direction_e dir)
-{
- int fd, status;
- char gpio_dev[GPIO_BUFFER_MAX] = {0, };
-
- _D("gpiopin : %d, dir : %d", gpiopin, dir);
-
- snprintf(gpio_dev, GPIO_BUFFER_MAX, SYSFS_GPIO_DIR"/gpio%d/direction", gpiopin);
- fd = open(gpio_dev, O_WRONLY);
- if (fd < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Can't Open /sys/class/gpio/gpio%d/direction: %s\n", gpiopin, errmsg);
- return -ENXIO;
- }
-
- if (dir == GPIO_DIRECTION_IN)
- status = write(fd, "in", strlen("in")+1);
- else if (dir == GPIO_DIRECTION_OUT_HIGH)
- status = write(fd, "high", strlen("high")+1);
- else if (dir == GPIO_DIRECTION_OUT_LOW)
- status = write(fd, "low", strlen("low")+1);
- else {
- close(fd);
- _E("Error: gpio direction is wrong\n");
- return -EIO;
- }
-
- if (status <= 0) {
- close(fd);
- _E("Error: gpio direction set error\n");
- return -EIO;
- }
-
- close(fd);
-
- return 0;
-}
-
-int gpio_get_direction(int gpiopin, gpio_direction_e *dir)
-{
- int fd, len;
- char gpio_dev[GPIO_BUFFER_MAX] = {0, };
- char gpio_buf[GPIO_BUFFER_MAX] = {0, };
-
- snprintf(gpio_dev, GPIO_BUFFER_MAX, SYSFS_GPIO_DIR"/gpio%d/direction", gpiopin);
- fd = open(gpio_dev, O_RDONLY);
-
- if (fd < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Can't Open /sys/class/gpio/gpio%d/direction: %s\n", gpiopin, errmsg);
- return -ENXIO;
- }
-
- len = read(fd, &gpio_buf, GPIO_BUFFER_MAX);
- if (len <= 0) {
- close(fd);
- _E("Error: gpio direction read error\n");
- return -EIO;
- }
-
- if (0 == strncmp(gpio_buf, "in", strlen("in")))
- *dir = GPIO_DIRECTION_IN;
- else if (0 == strncmp(gpio_buf, "out", strlen("out")))
- *dir = GPIO_DIRECTION_OUT_LOW;
- else {
- close(fd);
- _E("Error: gpio direction is wrong\n");
- return -EIO;
- }
-
- close(fd);
-
- return 0;
-}
-
-int gpio_set_edge_mode(int gpiopin, gpio_edge_e edge)
-{
- int fd, status;
- char gpio_dev[GPIO_BUFFER_MAX] = {0, };
-
- _D("gpiopin : %d, edge : %d", gpiopin, edge);
-
- snprintf(gpio_dev, GPIO_BUFFER_MAX, SYSFS_GPIO_DIR"/gpio%d/edge", gpiopin);
- fd = open(gpio_dev, O_WRONLY);
- if (fd < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Can't Open /sys/class/gpio/gpio%d/edge: %s\n", gpiopin, errmsg);
- return -ENXIO;
- }
-
- if (edge == GPIO_EDGE_NONE)
- status = write(fd, "none", strlen("none")+1);
- else if (edge == GPIO_EDGE_RISING)
- status = write(fd, "rising", strlen("rising")+1);
- else if (edge == GPIO_EDGE_FALLING)
- status = write(fd, "falling", strlen("falling")+1);
- else if (edge == GPIO_EDGE_BOTH)
- status = write(fd, "both", strlen("both")+1);
- else {
- close(fd);
- _E("Error: gpio edge is wrong\n");
- return -EIO;
- }
-
- if (status <= 0) {
- close(fd);
- _E("Error: gpio edge set error\n");
- return -EIO;
- }
-
- close(fd);
-
- return 0;
-}
-
-int gpio_get_edge_mode(int gpiopin, gpio_edge_e *edge)
-{
- int fd, len;
- char gpio_dev[GPIO_BUFFER_MAX] = {0, };
- char gpio_buf[GPIO_BUFFER_MAX] = {0, };
-
- snprintf(gpio_dev, GPIO_BUFFER_MAX, SYSFS_GPIO_DIR"/gpio%d/edge", gpiopin);
- fd = open(gpio_dev, O_RDONLY);
-
- if (fd < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Can't Open /sys/class/gpio/gpio%d/edge: %s\n", gpiopin, errmsg);
- return -ENXIO;
- }
-
- len = read(fd, &gpio_buf, GPIO_BUFFER_MAX);
- if (len <= 0) {
- close(fd);
- _E("Error: gpio edge read error\n");
- return -EIO;
- }
-
- if (0 == strncmp(gpio_buf, "none", strlen("none")))
- *edge = GPIO_EDGE_NONE;
- else if (0 == strncmp(gpio_buf, "both", strlen("both")))
- *edge = GPIO_EDGE_BOTH;
- else if (0 == strncmp(gpio_buf, "rising", strlen("rising")))
- *edge = GPIO_EDGE_RISING;
- else if (0 == strncmp(gpio_buf, "falling", strlen("falling")))
- *edge = GPIO_EDGE_FALLING;
- else {
- close(fd);
- _E("Error: gpio edge is wrong\n");
- return -EIO;
- }
-
- close(fd);
-
- return 0;
-}
-
-int gpio_write(int gpiopin, int value)
-{
- int fd, status;
- char gpio_dev[GPIO_BUFFER_MAX] = {0, };
-
- snprintf(gpio_dev, GPIO_BUFFER_MAX, SYSFS_GPIO_DIR"/gpio%d/value", gpiopin);
- fd = open(gpio_dev, O_WRONLY);
-
- if (fd < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Can't Open /sys/class/gpio/gpio%d/value: %s\n", gpiopin, errmsg);
- return -ENXIO;
- }
-
- if (value == 1)
- status = write(fd, "1", strlen("1")+1);
- else if (value == 0)
- status = write(fd, "0", strlen("0")+1);
- else {
- close(fd);
- _E("Error: gpio write value error \n");
- return -EIO;
- }
-
- if (status <= 0) {
- close(fd);
- _E("Error: gpio write error\n");
- return -EIO;
- }
-
- close(fd);
-
- return 0;
-}
-
-int gpio_read(int gpiopin, int *value)
-{
- int fd, len;
- char gpio_dev[GPIO_BUFFER_MAX] = {0, };
- char gpio_buf[GPIO_BUFFER_MAX] = {0, };
-
- snprintf(gpio_dev, GPIO_BUFFER_MAX, SYSFS_GPIO_DIR"/gpio%d/value", gpiopin);
- fd = open(gpio_dev, O_RDONLY);
- if (fd < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Can't Open /sys/class/gpio/gpio%d pin value: %s\n", gpiopin, errmsg);
- return -ENXIO;
- }
-
- len = read(fd, &gpio_buf, 1);
- close(fd);
-
- if (len <= 0) {
- _E("Error: gpio read error \n");
- return -EIO;
- }
-
- if (0 == strncmp(gpio_buf, "1", strlen("1")))
- *value = 1;
- else if (0 == strncmp(gpio_buf, "0", strlen("0")))
- *value = 0;
- else {
- _E("Error: gpio value is error \n");
- return -EIO;
- }
-
- return 0;
-}
-
int gpio_close(int gpiopin)
{
int fd, len, status;
return 0;
}
-
-int gpio_open_isr(int gpiopin)
-{
- int fd;
- char gpio_dev[GPIO_BUFFER_MAX] = {0, };
-
- snprintf(gpio_dev, sizeof(gpio_dev)-1, SYSFS_GPIO_DIR"/gpio%d/value", gpiopin);
-
- _D("open isr string [%s]", gpio_dev);
-
- fd = open(gpio_dev, O_RDONLY);
- if (fd < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Can't Open /sys/class/gpio/gpio%d pin value: %s\n", gpiopin, errmsg);
- return -ENXIO;
- }
-
- return fd;
-}
-
-int gpio_close_isr(int fd)
-{
- if (fd <= 0) return -EINVAL;
-
- close(fd);
-
- return 0;
-}
-
-int gpio_read_isr(void *fdset, char *rev_buf, int length)
-{
- int poll_state = 0;
- int len;
- struct pollfd poll_events;
-
- poll_events.fd = ((struct pollfd*)fdset)->fd;
- poll_events.events = POLLPRI;
- poll_events.revents = ((struct pollfd*)fdset)->revents;
-
- poll_state = poll((struct pollfd*)&poll_events, 1, -1); // 0 is going to return directly.
-
- if (poll_state < 0) {
- _E("poll() failed!\n");
- return -EIO;
- }
-
- if (poll_events.revents & POLLPRI) {
- lseek(poll_events.fd, 0, SEEK_SET);
- len = read(poll_events.fd, rev_buf, length);
- if (len == -1)
- return -EIO;
- }
-
- return poll_state;
-}
}
return 0;
-}
-
-int i2c_read(int fd, unsigned char *data, int length)
-{
- int status;
-
- RETVM_IF(fd < 0, -EINVAL, "Invalid fd : %d", fd);
-
- status = read(fd, data, length);
- if (status != length) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("i2c read failed, fd : %d, errmsg : %s", fd, errmsg);
- return -EIO;
- }
-
- return 0;
-}
-
-int i2c_write(int fd, const unsigned char *data, int length)
-{
- int status;
-
- RETVM_IF(fd < 0, -EINVAL, "Invalid fd : %d", fd);
-
- status = write(fd, data, length);
- if (status != length) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("i2c write failed fd : %d, errmsg : %s", fd, errmsg);
- return -EIO;
- }
-
- return 0;
-}
-
-int i2c_smbus_ioctl(int fd, struct i2c_smbus_ioctl_data *data)
-{
- int status;
-
- RETVM_IF(fd < 0, -EINVAL, "Invalid fd : %d", fd);
-
- status = ioctl(fd, I2C_SMBUS, data);
- if (status < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("i2c transaction failed fd : %d, errmsg : %s", fd, errmsg);
- return -EIO;
- }
-
- return 0;
-}
+}
\ No newline at end of file
#define SYSFS_GPIO_DIR "/sys/class/gpio"
#define GPIO_BUFFER_MAX 64
-typedef enum {
- GPIO_DIRECTION_IN = 0,
- GPIO_DIRECTION_OUT_HIGH = 1,
- GPIO_DIRECTION_OUT_LOW = 2,
-} gpio_direction_e;
-
-typedef enum {
- GPIO_EDGE_NONE = 0,
- GPIO_EDGE_RISING = 1,
- GPIO_EDGE_FALLING = 2,
- GPIO_EDGE_BOTH = 3,
-} gpio_edge_e;
-
int gpio_open(int gpiopin);
int gpio_close(int gpiopin);
-int gpio_set_edge_mode(int gpiopin, gpio_edge_e edge);
-int gpio_get_edge_mode(int gpiopin, gpio_edge_e *edge);
-int gpio_set_direction(int gpiopin, gpio_direction_e dir);
-int gpio_get_direction(int gpiopin, gpio_direction_e *dir);
-int gpio_write(int gpiopin, int value);
-int gpio_read(int gpiopin, int *value);
-int gpio_open_isr(int gpiopin);
-int gpio_close_isr(int file_hndl);
-int gpio_read_isr(void *fdset, char *rev_buf, int length);
#endif/*__GPIO_H__*/
#define I2C_SLAVE 0x0703 /* Use this slave address */
#define I2C_SMBUS 0x0720 /* SMBus transfer */
-/* i2c_smbus_xfer read or write markers */
-#define I2C_SMBUS_READ 1
-#define I2C_SMBUS_WRITE 0
-
-/* SMBus transaction types */
-#define I2C_SMBUS_QUICK 0
-#define I2C_SMBUS_BYTE 1
-#define I2C_SMBUS_BYTE_DATA 2
-#define I2C_SMBUS_WORD_DATA 3
-
-/*
- * Data for SMBus Messages
- */
-#define I2C_SMBUS_BLOCK_MAX 32 /* As specified in SMBus standard */
-
-union i2c_smbus_data {
- uint8_t byte;
- uint16_t word;
- uint8_t block[I2C_SMBUS_BLOCK_MAX + 2]; /* block[0] is used for length */
- /* and one more for user-space compatibility */
-};
-
-/* This is the structure as used in the I2C_SMBUS ioctl call */
-struct i2c_smbus_ioctl_data {
- uint8_t read_write;
- uint8_t command;
- uint32_t size;
- union i2c_smbus_data *data;
-};
-
int i2c_open(int bus, int *fd);
int i2c_close(int fd);
int i2c_set_address(int fd, int address);
-int i2c_read(int fd, unsigned char *data, int length);
-int i2c_write(int fd, const unsigned char *data, int length);
-int i2c_smbus_ioctl(int fd, struct i2c_smbus_ioctl_data *data);
#endif/* __I2C_H__ */
#define __PWM_H__
/**
- * @brief Enumeration for Polarity
- */
-typedef enum {
- PWM_POLARITY_NORMAL = 0,
- PWM_POLARITY_INVERSED,
-} pwm_polarity_e;
-
-/**
* @brief pwm_open() init pwm pin.
*
* @param[in] chip pwm chip number
*/
int pwm_close(int chip, int pin);
-/**
-* @brief pwm_set_period() sets the pwm period.
-*
-* @param[in] chip pwm chip number
-* @param[in] pin pwm pin number
-* @param[in] period pwm period
-* @return On success, 0 is returned. On failure, a negative value is returned.
-*/
-int pwm_set_period(int chip, int pin, int period);
-
-/**
-* @brief pwm_get_period() gets the pwm period.
-*
-* @param[in] chip pwm chip number
-* @param[in] pin pwm pin number
-* @param[out] period pwm period
-* @return On success, 0 is returned. On failure, a negative value is returned.
-*/
-int pwm_get_period(int chip, int pin, int *period);
-
-/**
-* @brief pwm_set_duty_cycle() sets the pwm duty cycle.
-*
-* @param[in] chip pwm chip number
-* @param[in] pin pwm pin number
-* @param[in] duty_cycle pwm duty cycle
-* @return On success, 0 is returned. On failure, a negative value is returned.
-*/
-int pwm_set_duty_cycle(int chip, int pin, int duty_cycle);
-
-/**
-* @brief pwm_get_duty_cycle() gets the pwm duty cycle.
-*
-* @param[in] chip pwm chip number
-* @param[in] pin pwm pin number
-* @param[out] duty_cycle pwm duty cycle
-* @return On success, 0 is returned. On failure, a negative value is returned.
-*/
-int pwm_get_duty_cycle(int chip, int pin, int *duty_cycle);
-
-/**
-* @brief pwm_set_polarity() sets the pwm polarity.
-*
-* @param[in] chip pwm chip number
-* @param[in] pin pwm pin number
-* @param[in] polarity pwm polarity
-* @return On success, 0 is returned. On failure, a negative value is returned.
-*/
-int pwm_set_polarity(int chip, int pin, pwm_polarity_e polarity);
-/**
-* @brief pwm_get_polarity() gets the pwm polarity.
-*
-* @param[in] chip pwm chip number
-* @param[in] pin pwm pin number
-* @param[out] polarity pwm polarity
-* @return On success, 0 is returned. On failure, a negative value is returned.
-*/
-int pwm_get_polarity(int chip, int pin, pwm_polarity_e *polarity);
-
-/**
-* @brief pwm_set_enable() sets the pwm state.
-*
-* @param[in] chip pwm chip number
-* @param[in] pin pwm pin number
-* @param[in] enable pwm enable/disabled state value
-* @return On success, 0 is returned. On failure, a negative value is returned.
-*/
-int pwm_set_enable(int chip, int pin, bool enable);
-
-/**
-* @brief pwm_get_enable() checks if pwm state is enabled.
-*
-* @param[in] chip pwm chip number
-* @param[in] pin pwm pin number
-* @param[out] enable pwm enable/disabled state value
-* @return On success, 0 is returned. On failure, a negative value is returned.
-*/
-int pwm_get_enable(int chip, int pin, bool *enable);
-
#endif /* __PWM_H__ */
int spi_open(int bus, int cs, int *fd);
int spi_close(int fd);
-int spi_set_mode(int fd, unsigned char mode);
-int spi_set_bit_order(int fd, unsigned char lsb);
-int spi_set_bits_per_word(int fd, unsigned char bits);
-int spi_set_frequency(int fd, unsigned int freq);
-int spi_get_buffer_size(int *bufsiz);
-int spi_read(int fd, unsigned char *rxbuf, int length);
-int spi_write(int fd, unsigned char *txbuf, int length);
-int spi_transfer(int fd, unsigned char *txbuf, unsigned char *rxbuf, int length);
#endif /* __SPI_H__ */
#include <stdint.h>
/**
- * @brief Enumeration for Baud Rate
- */
-typedef enum {
- UART_BAUD_RATE_0 = 0,
- UART_BAUD_RATE_50,
- UART_BAUD_RATE_75,
- UART_BAUD_RATE_110,
- UART_BAUD_RATE_134,
- UART_BAUD_RATE_150,
- UART_BAUD_RATE_200,
- UART_BAUD_RATE_300,
- UART_BAUD_RATE_600,
- UART_BAUD_RATE_1200,
- UART_BAUD_RATE_1800,
- UART_BAUD_RATE_2400,
- UART_BAUD_RATE_4800,
- UART_BAUD_RATE_9600,
- UART_BAUD_RATE_19200,
- UART_BAUD_RATE_38400,
- UART_BAUD_RATE_57600,
- UART_BAUD_RATE_115200,
- UART_BAUD_RATE_230400
-} uart_baud_rate_e;
-
-/**
- * @brief Enumeration for Byte Size
- */
-typedef enum {
- UART_BYTE_SIZE_5BIT = 0,
- UART_BYTE_SIZE_6BIT,
- UART_BYTE_SIZE_7BIT,
- UART_BYTE_SIZE_8BIT
-} uart_byte_size_e;
-
-/**
- * @brief Enumeration of Parity Bit
- */
-typedef enum {
- UART_PARITY_NONE = 0,
- UART_PARITY_EVEN,
- UART_PARITY_ODD
-} uart_parity_e;
-
-/**
- * @brief Enumeration for Stop Bits
- */
-typedef enum {
- UART_STOP_BITS_1BIT = 0,
- UART_STOP_BITS_2BIT
-} uart_stop_bits_e;
-
-/**
-* @brief uart_valid_baudrate() validation check of input baudrate
-*
-* @param[in] baudrate baudrate for uart
-* @return On success, valid input. On failure, NULL is returned.
-*/
-int uart_valid_baud_rate(unsigned int baud_rate);
-
-/**
* @brief uart_open() initializes uart port.
*
* @param[in] port uart port
*/
int uart_flush(int file_hndl);
-/**
-* @brief uart_set_baudrate() sets uart baud rate.
-*
-* @param[in] file_hndl handle of uart_context
-* @param[in] baud uart baud rate
-* @return On success, 0 is returned. On failure, a negative value is returned.
-*/
-int uart_set_baud_rate(int file_hndl, uart_baud_rate_e baud);
-
-/**
-* @brief uart_set_mode() sets byte size, parity bit and stop bits.
-*
-* @param[in] file_hndl handle of uart_context
-* @param[in] byte_size uart byte size
-* @param[in] parity uart parity type (even/odd/none)
-* @param[in] stop_bits uart stop bits
-* @return On success, 0 is returned. On failure, a negative value is returned.
-*/
-int uart_set_mode(int file_hndl, uart_byte_size_e byte_size, uart_parity_e parity, uart_stop_bits_e stop_bits);
-
-/**
-* @brief peripheral_bus_uart_set_byte_size() set byte size.
-*
-* @param[in] file_hndl handle of uart_context
-* @param[in] byte_size uart byte size
-* @return On success, 0 is returned. On failure, a negative value is returned.
-*/
-int uart_set_byte_size(int file_hndl, uart_byte_size_e byte_size);
-
-/**
-* @brief peripheral_bus_uart_set_parity() set parity bit.
-*
-* @param[in] file_hndl handle of uart_context
-* @param[in] parity uart parity type (even/odd/none)
-* @return On success, 0 is returned. On failure, a negative value is returned.
-*/
-int uart_set_parity(int file_hndl, uart_parity_e parity);
-
-/**
-* @brief peripheral_bus_uart_set_stop_bits() set stop bits.
-*
-* @param[in] file_hndl handle of uart_context
-* @param[in] stop_bits uart stop bits
-* @return On success, 0 is returned. On failure, a negative value is returned.
-*/
-int uart_set_stop_bits(int file_hndl, uart_stop_bits_e stop_bits);
-
-/**
-* @brief uart_set_flow_control() set flow control settings.
-*
-* @param[in] file_hndl handle of uart_context
-* @param[in] xonxoff ixon/ixoff
-* @param[in] rtscts rts/cts
-* @return On success, 0 is returned. On failure, a negative value is returned.
-*/
-int uart_set_flow_control(int file_hndl, bool xonxoff, bool rtscts);
-
-/**
-* @brief uart_read() reads data over uart bus.
-*
-* @param[in] file_hndl handle of uart_context
-* @param[in] buf the pointer of data buffer
-* @param[in] length size to read
-* @return On success, 0 is returned. On failure, a negative value is returned.
-*/
-int uart_read(int file_hndl, uint8_t *buf, unsigned int length);
-
-/**
-* @brief uart_write() writes data over uart bus.
-*
-* @param[in] file_hndl handle of uart_context
-* @param[in] buf the pointer of data buffer
-* @param[in] length size to write
-* @return On success, 0 is returned. On failure, a negative value is returned.
-*/
-int uart_write(int file_hndl, uint8_t *buf, unsigned int length);
-
#endif /* __UART_H__ */
return 0;
}
-
-int pwm_set_period(int chip, int pin, int period)
-{
- int fd, len, status;
- char pwm_buf[PWM_BUF_MAX] = {0};
- char pwm_dev[PATH_BUF_MAX] = {0};
-
- _D("chip : %d, pin : %d, period : %d", chip, pin, period);
-
- snprintf(pwm_dev, PATH_BUF_MAX, SYSFS_PWM_PATH "/pwmchip%d/pwm%d/period", chip, pin);
- fd = open(pwm_dev, O_WRONLY);
- if (fd < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Can't Open %s, errmsg : %s", pwm_dev, errmsg);
- return -ENXIO;
- }
-
- len = snprintf(pwm_buf, sizeof(pwm_buf), "%d", period);
- status = write(fd, pwm_buf, len);
- if (status < 0) {
- close(fd);
- _E("Failed to set period, path : %s", pwm_dev);
- return -EIO;
- }
- close(fd);
-
- return 0;
-}
-
-int pwm_get_period(int chip, int pin, int *period)
-{
- int fd, result, status;
- char pwm_buf[PWM_BUF_MAX] = {0};
- char pwm_dev[PATH_BUF_MAX] = {0};
-
- snprintf(pwm_dev, PATH_BUF_MAX, SYSFS_PWM_PATH "/pwmchip%d/pwm%d/period", chip, pin);
- fd = open(pwm_dev, O_RDONLY);
- if (fd < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Can't Open %s, errmsg : %s", pwm_dev, errmsg);
- return -ENXIO;
- }
-
- status = read(fd, pwm_buf, PWM_BUF_MAX);
- if (status < 0) {
- close(fd);
- _E("Failed to get period, path : %s", pwm_dev);
- return -EIO;
- }
- result = atoi(pwm_buf);
- *period = result;
- close(fd);
-
- return 0;
-}
-
-int pwm_set_duty_cycle(int chip, int pin, int duty_cycle)
-{
- int fd, len, status;
- char pwm_buf[PWM_BUF_MAX] = {0};
- char pwm_dev[PATH_BUF_MAX] = {0};
-
- _D("chip : %d, pin : %d, duty_cycle : %d", chip, pin, duty_cycle);
-
- snprintf(pwm_dev, PATH_BUF_MAX, SYSFS_PWM_PATH "/pwmchip%d/pwm%d/duty_cycle", chip, pin);
- fd = open(pwm_dev, O_WRONLY);
- if (fd < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Can't Open %s, errmsg : %s", pwm_dev, errmsg);
- return -ENXIO;
- }
-
- len = snprintf(pwm_buf, sizeof(pwm_buf), "%d", duty_cycle);
- status = write(fd, pwm_buf, len);
- if (status < 0) {
- close(fd);
- _E("Failed to set duty cycle, path : %s", pwm_dev);
- return -EIO;
- }
- close(fd);
-
- return 0;
-}
-
-int pwm_get_duty_cycle(int chip, int pin, int *duty_cycle)
-{
- int fd, result, status;
- char pwm_buf[PWM_BUF_MAX] = {0};
- char pwm_dev[PATH_BUF_MAX] = {0};
-
- snprintf(pwm_dev, PATH_BUF_MAX, SYSFS_PWM_PATH "/pwmchip%d/pwm%d/duty_cycle", chip, pin);
- fd = open(pwm_dev, O_RDONLY);
- if (fd < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Can't Open %s, errmsg : %s", pwm_dev, errmsg);
- return -ENXIO;
- }
-
- status = read(fd, pwm_buf, PWM_BUF_MAX);
- if (status < 0) {
- close(fd);
- _E("Failed to get duty cycle, path : %s", pwm_dev);
- return -EIO;
- }
- result = atoi(pwm_buf);
- *duty_cycle = result;
- close(fd);
-
- return 0;
-}
-
-int pwm_set_polarity(int chip, int pin, pwm_polarity_e polarity)
-{
- int fd, status;
- char pwm_dev[PATH_BUF_MAX] = {0};
-
- _D("chip : %d, pin : %d, polarity : %d", chip, pin, polarity);
-
- snprintf(pwm_dev, PATH_BUF_MAX, SYSFS_PWM_PATH "/pwmchip%d/pwm%d/polarity", chip, pin);
- fd = open(pwm_dev, O_WRONLY);
- if (fd < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Can't Open %s, errmsg : %s", pwm_dev, errmsg);
- return -ENXIO;
- }
-
- if (polarity == PWM_POLARITY_NORMAL)
- status = write(fd, "normal", strlen("normal")+1);
- else if (polarity == PWM_POLARITY_INVERSED)
- status = write(fd, "inversed", strlen("inversed")+1);
- else {
- _E("Invalid pwm polarity : %d", polarity);
- close(fd);
- return -EINVAL;
- }
-
- if (status <= 0) {
- close(fd);
- _E("Failed to set polarity, path : %s", pwm_dev);
- return -EIO;
- }
- close(fd);
-
- return 0;
-}
-
-int pwm_get_polarity(int chip, int pin, pwm_polarity_e *polarity)
-{
- int fd, status;
- char pwm_buf[PWM_BUF_MAX] = {0};
- char pwm_dev[PATH_BUF_MAX] = {0};
-
- snprintf(pwm_dev, PATH_BUF_MAX, SYSFS_PWM_PATH "/pwmchip%d/pwm%d/polarity", chip, pin);
- fd = open(pwm_dev, O_RDONLY);
- if (fd < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Can't Open %s, errmsg : %s", pwm_dev, errmsg);
- return -ENXIO;
- }
-
- status = read(fd, pwm_buf, PWM_BUF_MAX);
- if (status < 0) {
- _E("Failed to get polarity, path : %s", pwm_dev);
- close(fd);
- return -EIO;
- }
-
- if (0 == strncmp(pwm_buf, "normal", strlen("normal")))
- *polarity = PWM_POLARITY_NORMAL;
- else if (0 == strncmp(pwm_buf, "inversed", strlen("inversed")))
- *polarity = PWM_POLARITY_INVERSED;
- else {
- close(fd);
- _E("Invalid pwm polarity : %d", pwm_buf);
- return -EIO;
- }
- close(fd);
-
- return 0;
-}
-
-int pwm_set_enable(int chip, int pin, bool enable)
-{
- int fd, len, status;
- char pwm_buf[PWM_BUF_MAX] = {0};
- char pwm_dev[PATH_BUF_MAX] = {0};
-
- _D("chip : %d, pin : %d, enable : %d", chip, pin, enable);
-
- snprintf(pwm_dev, PATH_BUF_MAX, SYSFS_PWM_PATH "/pwmchip%d/pwm%d/enable", chip, pin);
- fd = open(pwm_dev, O_WRONLY);
- if (fd < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Can't Open %s, errmsg : %s", pwm_dev, errmsg);
- return -ENXIO;
- }
-
- len = snprintf(pwm_buf, sizeof(pwm_buf), "%d", enable);
- status = write(fd, pwm_buf, len);
- if (status < 0) {
- close(fd);
- _E("Failed to set enable, path : %s", pwm_dev);
- return -EIO;
- }
- close(fd);
-
- return 0;
-}
-
-int pwm_get_enable(int chip, int pin, bool *enable)
-{
- int fd, result, status;
- char pwm_buf[PWM_BUF_MAX] = {0};
- char pwm_dev[PATH_BUF_MAX] = {0};
-
- snprintf(pwm_dev, PATH_BUF_MAX, SYSFS_PWM_PATH "/pwmchip%d/pwm%d/enable", chip, pin);
- fd = open(pwm_dev, O_RDONLY);
- if (fd < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Can't Open %s, errmsg : %s", pwm_dev, errmsg);
- return -ENXIO;
- }
-
- status = read(fd, pwm_buf, PWM_BUF_MAX);
- if (status < 0) {
- close(fd);
- _E("Failed to get enable, path : %s", pwm_dev);
- return -EIO;
- }
- result = atoi(pwm_buf);
- *enable = !!result;
- close(fd);
-
- return 0;
-}
-
#include "peripheral_common.h"
#define SYSFS_SPI_DIR "/dev/spidev"
-#define SYSFS_SPI_BUFSIZ "/sys/module/spidev/parameters/bufsiz"
#define SPI_BUFFER_MAX 64
#define MAX_ERR_LEN 255
return 0;
}
-
-int spi_set_mode(int fd, unsigned char mode)
-{
- int status;
-
- _D("fd : %d, mode : %d", fd, mode);
- RETVM_IF(fd < 0, -EINVAL, "Invalid fd");
-
- status = ioctl(fd, SPI_IOC_WR_MODE, &mode);
- if (status < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Failed to set mode(%d) : %s", mode, errmsg);
- return -EIO;
- }
-
- return 0;
-}
-
-int spi_set_bit_order(int fd, unsigned char lsb)
-{
- int status;
-
- _D("fd : %d, lsb : %d", fd, lsb);
- RETVM_IF(fd < 0, -EINVAL, "Invalid fd");
-
- status = ioctl(fd, SPI_IOC_WR_LSB_FIRST, &lsb);
- if (status < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Failed to set lsb first(%d), fd : %d, errmsg : %s", lsb, fd, errmsg);
- return -EIO;
- }
-
- return 0;
-}
-
-int spi_set_bits_per_word(int fd, unsigned char bits)
-{
- int status;
-
- _D("fd : %d, bits : %d", fd, bits);
- RETVM_IF(fd < 0, -EINVAL, "Invalid fd");
-
- status = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
- if (status < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Failed to set bits(%d), fd : %d, errmsg : %s", bits, fd, errmsg);
- return -EIO;
- }
-
- return 0;
-}
-
-int spi_set_frequency(int fd, unsigned int freq)
-{
- int status;
-
- _D("fd : %d, freq : %d", fd, freq);
- RETVM_IF(fd < 0, -EINVAL, "Invalid fd");
-
- status = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &freq);
- if (status < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Failed to set frequency(%d), fd : %d, errmsg : %s", freq, fd, errmsg);
- return -EIO;
- }
-
- return 0;
-}
-
-int spi_get_buffer_size(int *bufsiz)
-{
- int fd, result, status;
- char spi_buf[SPI_BUFFER_MAX] = {0,};
-
- fd = open(SYSFS_SPI_BUFSIZ, O_RDONLY);
- if (fd < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Can't Open %s, errmsg : %s", SYSFS_SPI_BUFSIZ, errmsg);
- return -ENXIO;
- }
-
- status = read(fd, spi_buf, SPI_BUFFER_MAX);
- if (status < 0) {
- _E("Failed to get buffer size, path : %s", SYSFS_SPI_BUFSIZ);
- close(fd);
- return -EIO;
- }
- result = atoi(spi_buf);
- *bufsiz = result;
- close(fd);
-
- return 0;
-}
-
-int spi_read(int fd, unsigned char *rxbuf, int length)
-{
- int status;
- struct spi_ioc_transfer xfer;
-
- RETVM_IF(fd < 0, -EINVAL, "Invalid fd : %d", fd);
-
- memset(&xfer, 0, sizeof(struct spi_ioc_transfer));
- xfer.rx_buf = (unsigned long)rxbuf;
- xfer.len = length;
-
- status = ioctl(fd, SPI_IOC_MESSAGE(1), &xfer);
- if (status < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Failed to read data, fd : %d, length : %d, errmsg : %s", fd, length, errmsg);
- return -EIO;
- }
-
- return 0;
-}
-
-int spi_write(int fd, unsigned char *txbuf, int length)
-{
- int status;
- struct spi_ioc_transfer xfer;
-
- RETVM_IF(fd < 0, -EINVAL, "Invalid fd : %d", fd);
-
- memset(&xfer, 0, sizeof(struct spi_ioc_transfer));
- xfer.tx_buf = (unsigned long)txbuf;
- xfer.len = length;
-
- status = ioctl(fd, SPI_IOC_MESSAGE(1), &xfer);
- if (status < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Failed to write data(%d) : %s", length, errmsg);
- return -EIO;
- }
-
- return 0;
-}
-
-int spi_transfer(int fd, unsigned char *txbuf, unsigned char *rxbuf, int length)
-{
- int status;
- struct spi_ioc_transfer xfer;
-
- RETVM_IF(fd < 0, -EINVAL, "Invalid fd : %d", fd);
-
- if (!txbuf || !rxbuf || length < 0) return -EINVAL;
-
- memset(&xfer, 0, sizeof(xfer));
- xfer.tx_buf = (unsigned long)txbuf;
- xfer.rx_buf = (unsigned long)rxbuf;
- xfer.len = length;
-
- status = ioctl(fd, SPI_IOC_MESSAGE(1), &xfer);
- if (status < 0) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("Failed to exchange data(%d) : %s", length, errmsg);
- return -EIO;
- }
-
- return 0;
-}
#include "uart.h"
#include "peripheral_common.h"
-#define PATH_BUF_MAX 64
-#define UART_BUF_MAX 16
-
-#define UART_BAUDRATE_SIZE 19
+#define PATH_BUF_MAX 64
#ifndef ARRAY_SIZE
#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
"/dev/ttySAC",
};
-static const int peripheral_uart_br[UART_BAUDRATE_SIZE] = {
- B0, B50, B75, B110, B134,
- B150, B200, B300, B600, B1200,
- B1800, B2400, B4800, B9600, B19200,
- B38400, B57600, B115200, B230400
-};
-
-static const int byteinfo[4] = {CS5, CS6, CS7, CS8};
-
int uart_open(int port, int *file_hndl)
{
int i, fd;
return 0;
}
-
-int uart_set_baud_rate(int file_hndl, uart_baud_rate_e baud)
-{
- int ret;
- struct termios tio;
-
- _D("file_hndl : %d, baud : %d", file_hndl, baud);
-
- memset(&tio, 0, sizeof(tio));
- if (!file_hndl) {
- _E("Invalid NULL parameter");
- return -EINVAL;
- }
-
- if (baud > UART_BAUD_RATE_230400) {
- _E("Invalid parameter");
- return -EINVAL;
- }
-
- ret = tcgetattr(file_hndl, &tio);
- if (ret) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("tcgetattr failed, errmsg : %s", errmsg);
- return -1;
- }
- tio.c_cflag = peripheral_uart_br[baud];
- tio.c_iflag = IGNPAR;
- tio.c_oflag = 0;
- tio.c_lflag = 0;
- tio.c_cc[VMIN] = 1;
- tio.c_cc[VTIME] = 0;
-
- uart_flush(file_hndl);
- ret = tcsetattr(file_hndl, TCSANOW, &tio);
- if (ret) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("tcsetattr failed, errmsg: %s", errmsg);
- return -1;
- }
-
- return 0;
-}
-
-int uart_set_mode(int file_hndl, uart_byte_size_e byte_size, uart_parity_e parity, uart_stop_bits_e stop_bits)
-{
- int ret;
- struct termios tio;
-
- _D("file_hndl : %d, bytesize : %d, parity : %d, stopbits : %d", file_hndl, byte_size, parity, stop_bits);
-
- if (!file_hndl) {
- _E("Invalid NULL parameter");
- return -EINVAL;
- }
-
- if (byte_size > UART_BYTE_SIZE_8BIT) {
- _E("Invalid bytesize parameter");
- return -EINVAL;
- }
-
- ret = tcgetattr(file_hndl, &tio);
- if (ret) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("tcgetattr failed, errmsg: %s", errmsg);
- return -1;
- }
-
- /* set byte size */
- tio.c_cflag &= ~CSIZE;
- tio.c_cflag |= byteinfo[byte_size];
- tio.c_cflag |= (CLOCAL | CREAD);
-
- /* set parity info */
- switch (parity) {
- case UART_PARITY_EVEN:
- tio.c_cflag |= PARENB;
- tio.c_cflag &= ~PARODD;
- break;
- case UART_PARITY_ODD:
- tio.c_cflag |= PARENB;
- tio.c_cflag |= PARODD;
- break;
- case UART_PARITY_NONE:
- default:
- tio.c_cflag &= ~PARENB;
- tio.c_cflag &= ~PARODD;
- break;
- }
-
- /* set stop bit */
- switch (stop_bits) {
- case UART_STOP_BITS_1BIT:
- tio.c_cflag &= ~CSTOPB;
- break;
- case UART_STOP_BITS_2BIT:
- tio.c_cflag |= CSTOPB;
- break;
- default:
- _E("Invalid parameter stop_bits");
- return -EINVAL;
- }
-
- uart_flush(file_hndl);
- ret = tcsetattr(file_hndl, TCSANOW, &tio);
- if (ret) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("tcsetattr failed, errmsg : %s", errmsg);
- return -1;
- }
-
- return 0;
-}
-
-int uart_set_byte_size(int file_hndl, uart_byte_size_e byte_size)
-{
- int ret;
- struct termios tio;
-
- _D("file_hndl : %d, bytesize : %d", file_hndl, byte_size);
-
- if (!file_hndl) {
- _E("Invalid NULL parameter");
- return -EINVAL;
- }
-
- if (byte_size > UART_BYTE_SIZE_8BIT) {
- _E("Invalid bytesize parameter");
- return -EINVAL;
- }
-
- ret = tcgetattr(file_hndl, &tio);
- if (ret) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("tcgetattr failed, errmsg: %s", errmsg);
- return -1;
- }
-
- /* set byte size */
- tio.c_cflag &= ~CSIZE;
- tio.c_cflag |= byteinfo[byte_size];
- tio.c_cflag |= (CLOCAL | CREAD);
-
- uart_flush(file_hndl);
- ret = tcsetattr(file_hndl, TCSANOW, &tio);
- if (ret) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("tcsetattr failed, errmsg : %s", errmsg);
- return -1;
- }
-
- return 0;
-}
-
-int uart_set_parity(int file_hndl, uart_parity_e parity)
-{
- int ret;
- struct termios tio;
-
- _D("file_hndl : %d, parity : %d", file_hndl, parity);
-
- if (!file_hndl) {
- _E("Invalid NULL parameter");
- return -EINVAL;
- }
-
- ret = tcgetattr(file_hndl, &tio);
- if (ret) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("tcgetattr failed, errmsg: %s", errmsg);
- return -1;
- }
-
- /* set parity info */
- switch (parity) {
- case UART_PARITY_EVEN:
- tio.c_cflag |= PARENB;
- tio.c_cflag &= ~PARODD;
- break;
- case UART_PARITY_ODD:
- tio.c_cflag |= PARENB;
- tio.c_cflag |= PARODD;
- break;
- case UART_PARITY_NONE:
- default:
- tio.c_cflag &= ~PARENB;
- tio.c_cflag &= ~PARODD;
- break;
- }
-
- uart_flush(file_hndl);
- ret = tcsetattr(file_hndl, TCSANOW, &tio);
- if (ret) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("tcsetattr failed, errmsg : %s", errmsg);
- return -1;
- }
-
- return 0;
-}
-
-int uart_set_stop_bits(int file_hndl, uart_stop_bits_e stop_bits)
-{
- int ret;
- struct termios tio;
-
- _D("file_hndl : %d, stopbits : %d", file_hndl, stop_bits);
-
- if (!file_hndl) {
- _E("Invalid NULL parameter");
- return -EINVAL;
- }
-
- ret = tcgetattr(file_hndl, &tio);
- if (ret) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("tcgetattr failed, errmsg: %s", errmsg);
- return -1;
- }
-
- /* set stop bit */
- switch (stop_bits) {
- case UART_STOP_BITS_1BIT:
- tio.c_cflag &= ~CSTOPB;
- break;
- case UART_STOP_BITS_2BIT:
- tio.c_cflag |= CSTOPB;
- break;
- default:
- _E("Invalid parameter stop_bits");
- return -EINVAL;
- }
-
- uart_flush(file_hndl);
- ret = tcsetattr(file_hndl, TCSANOW, &tio);
- if (ret) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("tcsetattr failed, errmsg : %s", errmsg);
- return -1;
- }
-
- return 0;
-}
-
-int uart_set_flow_control(int file_hndl, bool xonxoff, bool rtscts)
-{
- int ret;
- struct termios tio;
-
- _D("file_hndl : %d, xonxoff : %d, rtscts : %d", file_hndl, xonxoff, rtscts);
-
- if (!file_hndl) {
- _E("Invalid NULL parameter");
- return -EINVAL;
- }
-
- ret = tcgetattr(file_hndl, &tio);
- if (ret) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("tcgetattr failed, errmsg : %s", errmsg);
- return -1;
- }
-
- /* rtscts => 1: rts/cts on, 0: off */
- if (rtscts)
- tio.c_cflag |= CRTSCTS;
- else
- tio.c_cflag &= ~CRTSCTS;
-
- /* xonxoff => 1: xon/xoff on, 0: off */
- if (xonxoff)
- tio.c_iflag |= (IXON | IXOFF | IXANY);
- else
- tio.c_iflag &= ~(IXON | IXOFF | IXANY);
-
- ret = tcsetattr(file_hndl, TCSANOW, &tio);
- if (ret) {
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("tcsetattr failed, errmsg : %s", errmsg);
- return -1;
- }
-
- return 0;
-}
-
-int uart_read(int file_hndl, uint8_t *buf, unsigned int length)
-{
- int ret;
-
- if (!file_hndl) {
- _E("Invalid NULL parameter");
- return -EINVAL;
- }
-
- ret = read(file_hndl, (void *)buf, length);
- if (ret <= 0) {
- if (errno == EAGAIN)
- return -EAGAIN;
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("read failed, errmsg : %s", errmsg);
- return -EIO;
- }
-
- return ret;
-}
-
-int uart_write(int file_hndl, uint8_t *buf, unsigned int length)
-{
- int ret;
-
- if (!file_hndl) {
- _E("Invalid NULL parameter");
- return -EINVAL;
- }
-
- ret = write(file_hndl, buf, length);
- if (ret <= 0) {
- if (errno == EAGAIN)
- return -EAGAIN;
- char errmsg[MAX_ERR_LEN];
- strerror_r(errno, errmsg, MAX_ERR_LEN);
- _E("write failed, errmsg : %s", errmsg);
- return -EIO;
- }
-
- return ret;
-}
projects / platform / core / system / peripheral-bus.git / commitdiff