From: Segwon Date: Tue, 14 Nov 2017 03:26:22 +0000 (+0900) Subject: interface: add prefix 'peripheral_interface' to file and function name. X-Git-Tag: submit/tizen_4.0/20171220.125806^2~37 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=8c6dae8d1ae8a7e9741603539f30b99cdf0b2670;p=platform%2Fcore%2Fapi%2Fperipheral-io.git interface: add prefix 'peripheral_interface' to file and function name. Change-Id: I23b6fe4aa850e4a713aa6e419ab334681e596d39 Signed-off-by: Segwon --- diff --git a/CMakeLists.txt b/CMakeLists.txt index 714f3d0..335e42a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -48,11 +48,11 @@ SET(SOURCES src/peripheral_gpio.c src/peripheral_pwm.c src/peripheral_uart.c src/peripheral_spi.c - src/interface/gpio.c - src/interface/i2c.c - src/interface/pwm.c - src/interface/spi.c - src/interface/uart.c + src/interface/peripheral_interface_gpio.c + src/interface/peripheral_interface_i2c.c + src/interface/peripheral_interface_pwm.c + src/interface/peripheral_interface_spi.c + src/interface/peripheral_interface_uart.c src/peripheral_gdbus_gpio.c src/peripheral_gdbus_i2c.c src/peripheral_gdbus_pwm.c diff --git a/include/interface/gpio.h b/include/interface/gpio.h deleted file mode 100644 index b4d6ccc..0000000 --- a/include/interface/gpio.h +++ /dev/null @@ -1,46 +0,0 @@ -/* - * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef __GPIO_H__ -#define __GPIO_H__ - -#include "peripheral_io.h" - -#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_close(peripheral_gpio_h gpio); -int gpio_set_edge_mode(peripheral_gpio_h gpio, gpio_edge_e edge); -int gpio_set_direction(peripheral_gpio_h gpio, gpio_direction_e dir); -int gpio_write(peripheral_gpio_h gpio, int value); -int gpio_read(peripheral_gpio_h gpio, int *value); - -int gpio_open_isr(peripheral_gpio_h gpio); -int gpio_close_isr(peripheral_gpio_h gpio); -#endif/*__GPIO_H__*/ diff --git a/include/interface/i2c.h b/include/interface/i2c.h deleted file mode 100644 index 6846649..0000000 --- a/include/interface/i2c.h +++ /dev/null @@ -1,66 +0,0 @@ -/* - * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef __I2C_H__ -#define __I2C_H__ - -#include - -#include "peripheral_io.h" - -#define SYSFS_I2C_DIR "/dev/i2c" -#define I2C_BUFFER_MAX 64 - -#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_close(peripheral_i2c_h i2c); -int i2c_set_address(peripheral_i2c_h i2c, int address); -int i2c_read(peripheral_i2c_h i2c, unsigned char *data, int length); -int i2c_write(peripheral_i2c_h i2c, const unsigned char *data, int length); -int i2c_smbus_ioctl(peripheral_i2c_h i2c, struct i2c_smbus_ioctl_data *data); - -#endif/* __I2C_H__ */ diff --git a/include/interface/peripheral_interface_gpio.h b/include/interface/peripheral_interface_gpio.h new file mode 100644 index 0000000..cf5d76c --- /dev/null +++ b/include/interface/peripheral_interface_gpio.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __PERIPHERAL_INTERFACE_GPIO_H__ +#define __PERIPHERAL_INTERFACE_GPIO_H__ + +#include "peripheral_io.h" + +#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 peripheral_interface_gpio_close(peripheral_gpio_h gpio); +int peripheral_interface_gpio_set_edge_mode(peripheral_gpio_h gpio, gpio_edge_e edge); +int peripheral_interface_gpio_set_direction(peripheral_gpio_h gpio, gpio_direction_e dir); +int peripheral_interface_gpio_write(peripheral_gpio_h gpio, int value); +int peripheral_interface_gpio_read(peripheral_gpio_h gpio, int *value); + +int peripheral_interface_gpio_open_isr(peripheral_gpio_h gpio); +int peripheral_interface_gpio_close_isr(peripheral_gpio_h gpio); + +#endif/*__PERIPHERAL_INTERFACE_GPIO_H__*/ \ No newline at end of file diff --git a/include/interface/peripheral_interface_i2c.h b/include/interface/peripheral_interface_i2c.h new file mode 100644 index 0000000..b41c555 --- /dev/null +++ b/include/interface/peripheral_interface_i2c.h @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __PERIPHERAL_INTERFACE_I2C_H__ +#define __PERIPHERAL_INTERFACE_I2C_H__ + +#include + +#include "peripheral_io.h" + +#define SYSFS_I2C_DIR "/dev/i2c" +#define I2C_BUFFER_MAX 64 + +#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 peripheral_interface_i2c_close(peripheral_i2c_h i2c); +int peripheral_interface_i2c_set_address(peripheral_i2c_h i2c, int address); +int peripheral_interface_i2c_read(peripheral_i2c_h i2c, unsigned char *data, int length); +int peripheral_interface_i2c_write(peripheral_i2c_h i2c, const unsigned char *data, int length); +int peripheral_interface_i2c_smbus_ioctl(peripheral_i2c_h i2c, struct i2c_smbus_ioctl_data *data); + +#endif/* __PERIPHERAL_INTERFACE_I2C_H__ */ diff --git a/include/interface/peripheral_interface_pwm.h b/include/interface/peripheral_interface_pwm.h new file mode 100644 index 0000000..833de2b --- /dev/null +++ b/include/interface/peripheral_interface_pwm.h @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __PERIPHERAL_INTERFACE_PWM_H__ +#define __PERIPHERAL_INTERFACE_PWM_H__ + +#include "peripheral_io.h" + +/** + * @brief Enumeration for Polarity + */ +typedef enum { + PWM_POLARITY_NORMAL = 0, + PWM_POLARITY_INVERSED, +} pwm_polarity_e; + + +/** +* @brief pwm_close() deinit pwm pin. +* +* @param[in] chip pwm chip number +* @param[in] pin pwm pin number +* @return On success, 0 is returned. On failure, a negative value is returned. +*/ +int peripheral_interface_pwm_close(peripheral_pwm_h pwm); + +/** +* @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 peripheral_interface_pwm_set_period(peripheral_pwm_h pwm, 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 peripheral_interface_pwm_set_duty_cycle(peripheral_pwm_h pwm, 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 peripheral_interface_pwm_set_polarity(peripheral_pwm_h pwm, 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 peripheral_interface_pwm_set_enable(peripheral_pwm_h pwm, bool enable); + +#endif /* __PERIPHERAL_INTERFACE_PWM_H__ */ diff --git a/include/interface/peripheral_interface_spi.h b/include/interface/peripheral_interface_spi.h new file mode 100644 index 0000000..937caa7 --- /dev/null +++ b/include/interface/peripheral_interface_spi.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __PERIPHERAL_INTERFACE_SPI_H__ +#define __PERIPHERAL_INTERFACE_SPI_H__ + +#include "peripheral_io.h" + +int peripheral_interface_spi_close(peripheral_spi_h spi); +int peripheral_interface_spi_set_mode(peripheral_spi_h spi, unsigned char mode); +int peripheral_interface_spi_set_bit_order(peripheral_spi_h spi, unsigned char lsb); +int peripheral_interface_spi_set_bits_per_word(peripheral_spi_h spi, unsigned char bits); +int peripheral_interface_spi_set_frequency(peripheral_spi_h spi, unsigned int freq); +int peripheral_interface_spi_read(peripheral_spi_h spi, unsigned char *rxbuf, int length); +int peripheral_interface_spi_write(peripheral_spi_h spi, unsigned char *txbuf, int length); +int peripheral_interface_spi_transfer(peripheral_spi_h spi, unsigned char *txbuf, unsigned char *rxbuf, int length); + +#endif /* __PERIPHERAL_INTERFACE_SPI_H__ */ diff --git a/include/interface/peripheral_interface_uart.h b/include/interface/peripheral_interface_uart.h new file mode 100644 index 0000000..f5273fe --- /dev/null +++ b/include/interface/peripheral_interface_uart.h @@ -0,0 +1,170 @@ +/* + * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __PERIPHERAL_INTERFACE_UART_H__ +#define __PERIPHERAL_INTERFACE_UART_H__ + +#include "peripheral_io.h" + +#include + +/** + * @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_close() closes uart port. +* +* @param[in] file_hndl handle of uart_context +* @return On success, 0 is returned. On failure, a negative value is returned. +*/ +int peripheral_interface_uart_close(peripheral_uart_h uart); + +/** +* @brief uart_flush() flushes uart buffer. +* +* @param[in] file_hndl handle of uart_context +* @return On success, 0 is returned. On failure, a negative value is returned. +*/ +int peripheral_interface_uart_flush(peripheral_uart_h uart); + +/** +* @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 peripheral_interface_uart_set_baud_rate(peripheral_uart_h uart, 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 peripheral_interface_uart_set_mode(peripheral_uart_h uart, 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 peripheral_interface_uart_set_byte_size(peripheral_uart_h uart, 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 peripheral_interface_uart_set_parity(peripheral_uart_h uart, 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 peripheral_interface_uart_set_stop_bits(peripheral_uart_h uart, 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 peripheral_interface_uart_set_flow_control(peripheral_uart_h uart, 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 peripheral_interface_uart_read(peripheral_uart_h uart, 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 peripheral_interface_uart_write(peripheral_uart_h uart, uint8_t *buf, unsigned int length); + +#endif /* __PERIPHERAL_INTERFACE_UART_H__ */ + diff --git a/include/interface/pwm.h b/include/interface/pwm.h deleted file mode 100644 index 7a9f0d0..0000000 --- a/include/interface/pwm.h +++ /dev/null @@ -1,80 +0,0 @@ -/* - * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef __PWM_H__ -#define __PWM_H__ - -#include "peripheral_io.h" - -/** - * @brief Enumeration for Polarity - */ -typedef enum { - PWM_POLARITY_NORMAL = 0, - PWM_POLARITY_INVERSED, -} pwm_polarity_e; - - -/** -* @brief pwm_close() deinit pwm pin. -* -* @param[in] chip pwm chip number -* @param[in] pin pwm pin number -* @return On success, 0 is returned. On failure, a negative value is returned. -*/ -int pwm_close(peripheral_pwm_h pwm); - -/** -* @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(peripheral_pwm_h pwm, 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(peripheral_pwm_h pwm, 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(peripheral_pwm_h pwm, 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(peripheral_pwm_h pwm, bool enable); - -#endif /* __PWM_H__ */ diff --git a/include/interface/spi.h b/include/interface/spi.h deleted file mode 100644 index 3708363..0000000 --- a/include/interface/spi.h +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef __SPI_H__ -#define __SPI_H__ - -#include "peripheral_io.h" - -int spi_close(peripheral_spi_h spi); -int spi_set_mode(peripheral_spi_h spi, unsigned char mode); -int spi_set_bit_order(peripheral_spi_h spi, unsigned char lsb); -int spi_set_bits_per_word(peripheral_spi_h spi, unsigned char bits); -int spi_set_frequency(peripheral_spi_h spi, unsigned int freq); -int spi_read(peripheral_spi_h spi, unsigned char *rxbuf, int length); -int spi_write(peripheral_spi_h spi, unsigned char *txbuf, int length); -int spi_transfer(peripheral_spi_h spi, unsigned char *txbuf, unsigned char *rxbuf, int length); - -#endif /* __SPI_H__ */ diff --git a/include/interface/uart.h b/include/interface/uart.h deleted file mode 100644 index a0505ee..0000000 --- a/include/interface/uart.h +++ /dev/null @@ -1,170 +0,0 @@ -/* - * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef __UART_H__ -#define __UART_H__ - -#include "peripheral_io.h" - -#include - -/** - * @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_close() closes uart port. -* -* @param[in] file_hndl handle of uart_context -* @return On success, 0 is returned. On failure, a negative value is returned. -*/ -int uart_close(peripheral_uart_h uart); - -/** -* @brief uart_flush() flushes uart buffer. -* -* @param[in] file_hndl handle of uart_context -* @return On success, 0 is returned. On failure, a negative value is returned. -*/ -int uart_flush(peripheral_uart_h uart); - -/** -* @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(peripheral_uart_h uart, 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(peripheral_uart_h uart, 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(peripheral_uart_h uart, 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(peripheral_uart_h uart, 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(peripheral_uart_h uart, 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(peripheral_uart_h uart, 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(peripheral_uart_h uart, 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(peripheral_uart_h uart, uint8_t *buf, unsigned int length); - -#endif /* __UART_H__ */ - diff --git a/src/interface/gpio.c b/src/interface/gpio.c deleted file mode 100644 index 352e8c9..0000000 --- a/src/interface/gpio.c +++ /dev/null @@ -1,177 +0,0 @@ -/* - * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include -#include -#include -#include -#include -#include - -#include "gpio.h" -#include "peripheral_common.h" -#include "peripheral_internal.h" - -#define MAX_ERR_LEN 255 - -int gpio_set_direction(peripheral_gpio_h gpio, gpio_direction_e dir) -{ - int status; - - if (dir == GPIO_DIRECTION_IN) - status = write(gpio->fd_direction, "in", strlen("in")+1); - else if (dir == GPIO_DIRECTION_OUT_HIGH) - status = write(gpio->fd_direction, "high", strlen("high")+1); - else if (dir == GPIO_DIRECTION_OUT_LOW) - status = write(gpio->fd_direction, "low", strlen("low")+1); - else { - _E("Error: gpio direction is wrong\n"); - return -EIO; - } - - if (status <= 0) { - _E("Error: gpio direction set error\n"); - return -EIO; - } - - return 0; -} - -int gpio_set_edge_mode(peripheral_gpio_h gpio, gpio_edge_e edge) -{ - int status; - - if (edge == GPIO_EDGE_NONE) - status = write(gpio->fd_edge, "none", strlen("none")+1); - else if (edge == GPIO_EDGE_RISING) - status = write(gpio->fd_edge, "rising", strlen("rising")+1); - else if (edge == GPIO_EDGE_FALLING) - status = write(gpio->fd_edge, "falling", strlen("falling")+1); - else if (edge == GPIO_EDGE_BOTH) - status = write(gpio->fd_edge, "both", strlen("both")+1); - else { - _E("Error: gpio edge is wrong\n"); - return -EIO; - } - - if (status <= 0) { - _E("Error: gpio edge set error\n"); - return -EIO; - } - - return 0; -} - -int gpio_write(peripheral_gpio_h gpio, int value) -{ - int status; - - if (value == 1) - status = write(gpio->fd_value, "1", strlen("1")+1); - else if (value == 0) - status = write(gpio->fd_value, "0", strlen("0")+1); - else { - _E("Error: gpio write value error \n"); - return -EIO; - } - - if (status <= 0) { - _E("Error: gpio write error\n"); - return -EIO; - } - - return 0; -} - -int gpio_read(peripheral_gpio_h gpio, int *value) -{ - int len; - char gpio_buf[GPIO_BUFFER_MAX] = {0, }; - - len = read(gpio->fd_value, &gpio_buf, 1); - 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(peripheral_gpio_h gpio) -{ - int status; - - status = close(gpio->fd_direction); - if (status < 0) { - _E("Error: gpio direction fd close error \n"); - return -EIO; - } - - status = close(gpio->fd_edge); - if (status < 0) { - _E("Error: gpio edge fd close error \n"); - return -EIO; - } - - status = close(gpio->fd_value); - if (status < 0) { - _E("Error: gpio value fd close error \n"); - return -EIO; - } - - return 0; -} - -int gpio_open_isr(peripheral_gpio_h gpio) -{ - // 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; - - return 0; -} - -int gpio_close_isr(peripheral_gpio_h gpio) -{ -// if (fd <= 0) return -EINVAL; - -// close(fd); - - return 0; -} \ No newline at end of file diff --git a/src/interface/i2c.c b/src/interface/i2c.c deleted file mode 100644 index fec6ea2..0000000 --- a/src/interface/i2c.c +++ /dev/null @@ -1,116 +0,0 @@ -/* - * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include -#include -#include -#include -#include -#include - -#include "i2c.h" -#include "peripheral_common.h" -#include "peripheral_internal.h" - -#define MAX_ERR_LEN 255 - -int i2c_close(peripheral_i2c_h i2c) -{ - int status; - - _D("fd : %d", i2c->fd); - RETVM_IF(i2c->fd < 0, -EINVAL, "Invalid fd"); - - status = close(i2c->fd); - if (status < 0) { - char errmsg[MAX_ERR_LEN]; - strerror_r(errno, errmsg, MAX_ERR_LEN); - _E("Failed to close fd : %d", i2c->fd); - return -EIO; - } - - return 0; -} - -int i2c_set_address(peripheral_i2c_h i2c, int address) -{ - int status; - - _D("fd : %d, slave address : 0x%x", i2c->fd, address); - RETVM_IF(i2c->fd < 0, -EINVAL, "Invalid fd"); - - status = ioctl(i2c->fd, I2C_SLAVE, address); - if (status < 0) { - char errmsg[MAX_ERR_LEN]; - strerror_r(errno, errmsg, MAX_ERR_LEN); - _E("Failed to set slave address(%x), fd : %d, errmsg : %s", address, i2c->fd, errmsg); - return status; - } - - return 0; -} - -int i2c_read(peripheral_i2c_h i2c, unsigned char *data, int length) -{ - int status; - - RETVM_IF(i2c->fd < 0, -EINVAL, "Invalid fd : %d", i2c->fd); - - status = read(i2c->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", i2c->fd, errmsg); - return -EIO; - } - - return 0; -} - -int i2c_write(peripheral_i2c_h i2c, const unsigned char *data, int length) -{ - int status; - - RETVM_IF(i2c->fd < 0, -EINVAL, "Invalid fd : %d", i2c->fd); - - status = write(i2c->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", i2c->fd, errmsg); - return -EIO; - } - - return 0; -} - -int i2c_smbus_ioctl(peripheral_i2c_h i2c, struct i2c_smbus_ioctl_data *data) -{ - int status; - - RETVM_IF(i2c->fd < 0, -EINVAL, "Invalid fd : %d", i2c->fd); - - status = ioctl(i2c->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", i2c->fd, errmsg); - return -EIO; - } - - return 0; -} diff --git a/src/interface/peripheral_interface_gpio.c b/src/interface/peripheral_interface_gpio.c new file mode 100644 index 0000000..e4620ca --- /dev/null +++ b/src/interface/peripheral_interface_gpio.c @@ -0,0 +1,160 @@ +/* + * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "peripheral_interface_gpio.h" +#include "peripheral_common.h" +#include "peripheral_internal.h" + +#define MAX_ERR_LEN 255 + +int peripheral_interface_gpio_set_direction(peripheral_gpio_h gpio, gpio_direction_e dir) +{ + int status; + + if (dir == GPIO_DIRECTION_IN) + status = write(gpio->fd_direction, "in", strlen("in")+1); + else if (dir == GPIO_DIRECTION_OUT_HIGH) + status = write(gpio->fd_direction, "high", strlen("high")+1); + else if (dir == GPIO_DIRECTION_OUT_LOW) + status = write(gpio->fd_direction, "low", strlen("low")+1); + else { + _E("Error: gpio direction is wrong\n"); + return -EIO; + } + + if (status <= 0) { + _E("Error: gpio direction set error\n"); + return -EIO; + } + + return 0; +} + +int peripheral_interface_gpio_set_edge_mode(peripheral_gpio_h gpio, gpio_edge_e edge) +{ + int status; + + if (edge == GPIO_EDGE_NONE) + status = write(gpio->fd_edge, "none", strlen("none")+1); + else if (edge == GPIO_EDGE_RISING) + status = write(gpio->fd_edge, "rising", strlen("rising")+1); + else if (edge == GPIO_EDGE_FALLING) + status = write(gpio->fd_edge, "falling", strlen("falling")+1); + else if (edge == GPIO_EDGE_BOTH) + status = write(gpio->fd_edge, "both", strlen("both")+1); + else { + _E("Error: gpio edge is wrong\n"); + return -EIO; + } + + if (status <= 0) { + _E("Error: gpio edge set error\n"); + return -EIO; + } + + return 0; +} + +int peripheral_interface_gpio_write(peripheral_gpio_h gpio, int value) +{ + int status; + + if (value == 1) + status = write(gpio->fd_value, "1", strlen("1")+1); + else if (value == 0) + status = write(gpio->fd_value, "0", strlen("0")+1); + else { + _E("Error: gpio write value error \n"); + return -EIO; + } + + if (status <= 0) { + _E("Error: gpio write error\n"); + return -EIO; + } + + return 0; +} + +int peripheral_interface_gpio_read(peripheral_gpio_h gpio, int *value) +{ + int len; + char gpio_buf[GPIO_BUFFER_MAX] = {0, }; + + len = read(gpio->fd_value, &gpio_buf, 1); + 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 peripheral_interface_gpio_close(peripheral_gpio_h gpio) +{ + int status; + + status = close(gpio->fd_direction); + if (status < 0) { + _E("Error: gpio direction fd close error \n"); + return -EIO; + } + + status = close(gpio->fd_edge); + if (status < 0) { + _E("Error: gpio edge fd close error \n"); + return -EIO; + } + + status = close(gpio->fd_value); + if (status < 0) { + _E("Error: gpio value fd close error \n"); + return -EIO; + } + + return 0; +} + +int peripheral_interface_gpio_open_isr(peripheral_gpio_h gpio) +{ + // TODO: set interrupted callback function + + return 0; +} + +int peripheral_interface_gpio_close_isr(peripheral_gpio_h gpio) +{ + // TODO: unset interrupted callback function + + return 0; +} \ No newline at end of file diff --git a/src/interface/peripheral_interface_i2c.c b/src/interface/peripheral_interface_i2c.c new file mode 100644 index 0000000..9da17bd --- /dev/null +++ b/src/interface/peripheral_interface_i2c.c @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "peripheral_interface_i2c.h" +#include "peripheral_common.h" +#include "peripheral_internal.h" + +#define MAX_ERR_LEN 255 + +int peripheral_interface_i2c_close(peripheral_i2c_h i2c) +{ + int status; + + _D("fd : %d", i2c->fd); + RETVM_IF(i2c->fd < 0, -EINVAL, "Invalid fd"); + + status = close(i2c->fd); + if (status < 0) { + char errmsg[MAX_ERR_LEN]; + strerror_r(errno, errmsg, MAX_ERR_LEN); + _E("Failed to close fd : %d", i2c->fd); + return -EIO; + } + + return 0; +} + +int peripheral_interface_i2c_set_address(peripheral_i2c_h i2c, int address) +{ + int status; + + _D("fd : %d, slave address : 0x%x", i2c->fd, address); + RETVM_IF(i2c->fd < 0, -EINVAL, "Invalid fd"); + + status = ioctl(i2c->fd, I2C_SLAVE, address); + if (status < 0) { + char errmsg[MAX_ERR_LEN]; + strerror_r(errno, errmsg, MAX_ERR_LEN); + _E("Failed to set slave address(%x), fd : %d, errmsg : %s", address, i2c->fd, errmsg); + return status; + } + + return 0; +} + +int peripheral_interface_i2c_read(peripheral_i2c_h i2c, unsigned char *data, int length) +{ + int status; + + RETVM_IF(i2c->fd < 0, -EINVAL, "Invalid fd : %d", i2c->fd); + + status = read(i2c->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", i2c->fd, errmsg); + return -EIO; + } + + return 0; +} + +int peripheral_interface_i2c_write(peripheral_i2c_h i2c, const unsigned char *data, int length) +{ + int status; + + RETVM_IF(i2c->fd < 0, -EINVAL, "Invalid fd : %d", i2c->fd); + + status = write(i2c->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", i2c->fd, errmsg); + return -EIO; + } + + return 0; +} + +int peripheral_interface_i2c_smbus_ioctl(peripheral_i2c_h i2c, struct i2c_smbus_ioctl_data *data) +{ + int status; + + RETVM_IF(i2c->fd < 0, -EINVAL, "Invalid fd : %d", i2c->fd); + + status = ioctl(i2c->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", i2c->fd, errmsg); + return -EIO; + } + + return 0; +} diff --git a/src/interface/peripheral_interface_pwm.c b/src/interface/peripheral_interface_pwm.c new file mode 100644 index 0000000..a5cae4d --- /dev/null +++ b/src/interface/peripheral_interface_pwm.c @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "peripheral_interface_pwm.h" +#include "peripheral_common.h" +#include "peripheral_internal.h" + +#define SYSFS_PWM_PATH "/sys/class/pwm" + +#define PATH_BUF_MAX 64 +#define PWM_BUF_MAX 16 +#define MAX_ERR_LEN 255 + +int peripheral_interface_pwm_close(peripheral_pwm_h pwm) +{ + int status; + + status = close(pwm->fd_period); + if (status < 0) { + _E("Error: pwm period fd close error \n"); + return -EIO; + } + + status = close(pwm->fd_duty_cycle); + if (status < 0) { + _E("Error: pwm duty cycle fd close error \n"); + return -EIO; + } + + status = close(pwm->fd_polarity); + if (status < 0) { + _E("Error: pwm polarity fd close error \n"); + return -EIO; + } + + status = close(pwm->fd_enable); + if (status < 0) { + _E("Error: pwm enable fd close error \n"); + return -EIO; + } + + return 0; +} + +int peripheral_interface_pwm_set_period(peripheral_pwm_h pwm, int period) +{ + int len, status; + char pwm_buf[PWM_BUF_MAX] = {0}; + + len = snprintf(pwm_buf, sizeof(pwm_buf), "%d", period); + status = write(pwm->fd_period, pwm_buf, len); + if (status < 0) { + _E("Failed to set period"); + return -EIO; + } + + return 0; +} + +int peripheral_interface_pwm_set_duty_cycle(peripheral_pwm_h pwm, int duty_cycle) +{ + int len, status; + char pwm_buf[PWM_BUF_MAX] = {0}; + + len = snprintf(pwm_buf, sizeof(pwm_buf), "%d", duty_cycle); + status = write(pwm->fd_duty_cycle, pwm_buf, len); + if (status < 0) { + _E("Failed to set duty cycle"); + return -EIO; + } + + return 0; +} + +int peripheral_interface_pwm_set_polarity(peripheral_pwm_h pwm, pwm_polarity_e polarity) +{ + int status; + + if (polarity == PWM_POLARITY_NORMAL) + status = write(pwm->fd_polarity, "normal", strlen("normal")+1); + else if (polarity == PWM_POLARITY_INVERSED) + status = write(pwm->fd_polarity, "inversed", strlen("inversed")+1); + else { + _E("Invalid pwm polarity : %d", polarity); + return -EINVAL; + } + + if (status <= 0) { + _E("Failed to set polarity"); + return -EIO; + } + + return 0; +} + +int peripheral_interface_pwm_set_enable(peripheral_pwm_h pwm, bool enable) +{ + int len, status; + char pwm_buf[PWM_BUF_MAX] = {0}; + + len = snprintf(pwm_buf, sizeof(pwm_buf), "%d", enable); + status = write(pwm->fd_enable, pwm_buf, len); + if (status < 0) { + _E("Failed to set enable"); + return -EIO; + } + + return 0; +} diff --git a/src/interface/peripheral_interface_spi.c b/src/interface/peripheral_interface_spi.c new file mode 100644 index 0000000..1296d9f --- /dev/null +++ b/src/interface/peripheral_interface_spi.c @@ -0,0 +1,192 @@ +/* + * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "peripheral_interface_spi.h" +#include "peripheral_common.h" +#include "peripheral_internal.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 + +int peripheral_interface_spi_close(peripheral_spi_h spi) +{ + int status; + + _D("fd : %d", spi->fd); + RETVM_IF(spi->fd < 0, -EINVAL, "Invalid fd"); + + status = close(spi->fd); + if (status < 0) { + char errmsg[MAX_ERR_LEN]; + strerror_r(errno, errmsg, MAX_ERR_LEN); + _E("Failed to close fd : %d", spi->fd); + return -EIO; + } + + return 0; +} + +int peripheral_interface_spi_set_mode(peripheral_spi_h spi, unsigned char mode) +{ + int status; + + _D("fd : %d, mode : %d", spi->fd, mode); + RETVM_IF(spi->fd < 0, -EINVAL, "Invalid fd"); + + status = ioctl(spi->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 peripheral_interface_spi_set_bit_order(peripheral_spi_h spi, unsigned char lsb) +{ + int status; + + _D("fd : %d, lsb : %d", spi->fd, lsb); + RETVM_IF(spi->fd < 0, -EINVAL, "Invalid fd"); + + status = ioctl(spi->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, spi->fd, errmsg); + return -EIO; + } + + return 0; +} + +int peripheral_interface_spi_set_bits_per_word(peripheral_spi_h spi, unsigned char bits) +{ + int status; + + _D("fd : %d, bits : %d", spi->fd, bits); + RETVM_IF(spi->fd < 0, -EINVAL, "Invalid fd"); + + status = ioctl(spi->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, spi->fd, errmsg); + return -EIO; + } + + return 0; +} + +int peripheral_interface_spi_set_frequency(peripheral_spi_h spi, unsigned int freq) +{ + int status; + + _D("fd : %d, freq : %d", spi->fd, freq); + RETVM_IF(spi->fd < 0, -EINVAL, "Invalid fd"); + + status = ioctl(spi->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, spi->fd, errmsg); + return -EIO; + } + + return 0; +} + +int peripheral_interface_spi_read(peripheral_spi_h spi, unsigned char *rxbuf, int length) +{ + int status; + struct spi_ioc_transfer xfer; + + RETVM_IF(spi->fd < 0, -EINVAL, "Invalid fd : %d", spi->fd); + + memset(&xfer, 0, sizeof(struct spi_ioc_transfer)); + xfer.rx_buf = (unsigned long)rxbuf; + xfer.len = length; + + status = ioctl(spi->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", spi->fd, length, errmsg); + return -EIO; + } + + return 0; +} + +int peripheral_interface_spi_write(peripheral_spi_h spi, unsigned char *txbuf, int length) +{ + int status; + struct spi_ioc_transfer xfer; + + RETVM_IF(spi->fd < 0, -EINVAL, "Invalid fd : %d", spi->fd); + + memset(&xfer, 0, sizeof(struct spi_ioc_transfer)); + xfer.tx_buf = (unsigned long)txbuf; + xfer.len = length; + + status = ioctl(spi->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 peripheral_interface_spi_transfer(peripheral_spi_h spi, unsigned char *txbuf, unsigned char *rxbuf, int length) +{ + int status; + struct spi_ioc_transfer xfer; + + RETVM_IF(spi->fd < 0, -EINVAL, "Invalid fd : %d", spi->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(spi->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; +} diff --git a/src/interface/peripheral_interface_uart.c b/src/interface/peripheral_interface_uart.c new file mode 100644 index 0000000..92fffce --- /dev/null +++ b/src/interface/peripheral_interface_uart.c @@ -0,0 +1,443 @@ +/* + * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "peripheral_interface_uart.h" +#include "peripheral_common.h" +#include "peripheral_internal.h" + +#define PATH_BUF_MAX 64 +#define UART_BUF_MAX 16 + +#define UART_BAUDRATE_SIZE 19 + +#ifndef ARRAY_SIZE +#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0])) +#endif +#define MAX_ERR_LEN 128 + +char *sysfs_uart_path[] = { + "/dev/ttyS", + "/dev/ttyAMA", + "/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 peripheral_interface_uart_close(peripheral_uart_h uart) +{ + int status; + + _D("file_hndl : %d", uart->fd); + + if (uart->fd < 0) { + _E("Invalid NULL parameter"); + return -EINVAL; + } + + status = peripheral_interface_uart_flush(uart); + if (status < 0) { + char errmsg[MAX_ERR_LEN]; + strerror_r(errno, errmsg, MAX_ERR_LEN); + _E("Failed to close fd : %d, errmsg : %s", uart->fd, errmsg); + return -EIO; + } + + status = close(uart->fd); + if (status < 0) { + char errmsg[MAX_ERR_LEN]; + strerror_r(errno, errmsg, MAX_ERR_LEN); + _E("Failed to close fd : %d, errmsg : %s", uart->fd, errmsg); + return -EIO; + } + + return 0; +} + +int peripheral_interface_uart_flush(peripheral_uart_h uart) +{ + int ret; + + if (!uart->fd) { + _E("Invalid NULL parameter"); + return -EINVAL; + } + + ret = tcflush(uart->fd, TCIOFLUSH); + if (ret < 0) { + char errmsg[MAX_ERR_LEN]; + strerror_r(errno, errmsg, MAX_ERR_LEN); + _E("tcflush failed, errmsg : %s", errmsg); + return -1; + } + + return 0; +} + +int peripheral_interface_uart_set_baud_rate(peripheral_uart_h uart, uart_baud_rate_e baud) +{ + int ret; + struct termios tio; + + _D("file_hndl : %d, baud : %d", uart->fd, baud); + + memset(&tio, 0, sizeof(tio)); + if (!uart->fd) { + _E("Invalid NULL parameter"); + return -EINVAL; + } + + if (baud > UART_BAUD_RATE_230400) { + _E("Invalid parameter"); + return -EINVAL; + } + + ret = tcgetattr(uart->fd, &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; + + peripheral_interface_uart_flush(uart); + ret = tcsetattr(uart->fd, 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 peripheral_interface_uart_set_mode(peripheral_uart_h uart, 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", uart->fd, byte_size, parity, stop_bits); + + if (!uart->fd) { + _E("Invalid NULL parameter"); + return -EINVAL; + } + + if (byte_size > UART_BYTE_SIZE_8BIT) { + _E("Invalid bytesize parameter"); + return -EINVAL; + } + + ret = tcgetattr(uart->fd, &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; + } + + peripheral_interface_uart_flush(uart); + ret = tcsetattr(uart->fd, 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 peripheral_interface_uart_set_byte_size(peripheral_uart_h uart, uart_byte_size_e byte_size) +{ + int ret; + struct termios tio; + + _D("file_hndl : %d, bytesize : %d", uart->fd, byte_size); + + if (!uart->fd) { + _E("Invalid NULL parameter"); + return -EINVAL; + } + + if (byte_size > UART_BYTE_SIZE_8BIT) { + _E("Invalid bytesize parameter"); + return -EINVAL; + } + + ret = tcgetattr(uart->fd, &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); + + peripheral_interface_uart_flush(uart); + ret = tcsetattr(uart->fd, 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 peripheral_interface_uart_set_parity(peripheral_uart_h uart, uart_parity_e parity) +{ + int ret; + struct termios tio; + + _D("file_hndl : %d, parity : %d", uart->fd, parity); + + if (!uart->fd) { + _E("Invalid NULL parameter"); + return -EINVAL; + } + + ret = tcgetattr(uart->fd, &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; + } + + peripheral_interface_uart_flush(uart); + ret = tcsetattr(uart->fd, 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 peripheral_interface_uart_set_stop_bits(peripheral_uart_h uart, uart_stop_bits_e stop_bits) +{ + int ret; + struct termios tio; + + _D("file_hndl : %d, stopbits : %d", uart->fd, stop_bits); + + if (!uart->fd) { + _E("Invalid NULL parameter"); + return -EINVAL; + } + + ret = tcgetattr(uart->fd, &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; + } + + peripheral_interface_uart_flush(uart); + ret = tcsetattr(uart->fd, 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 peripheral_interface_uart_set_flow_control(peripheral_uart_h uart, bool xonxoff, bool rtscts) +{ + int ret; + struct termios tio; + + _D("file_hndl : %d, xonxoff : %d, rtscts : %d", uart->fd, xonxoff, rtscts); + + if (!uart->fd) { + _E("Invalid NULL parameter"); + return -EINVAL; + } + + ret = tcgetattr(uart->fd, &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(uart->fd, 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 peripheral_interface_uart_read(peripheral_uart_h uart, uint8_t *buf, unsigned int length) +{ + int ret; + + if (!uart->fd) { + _E("Invalid NULL parameter"); + return -EINVAL; + } + + ret = read(uart->fd, (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 peripheral_interface_uart_write(peripheral_uart_h uart, uint8_t *buf, unsigned int length) +{ + int ret; + + if (!uart->fd) { + _E("Invalid NULL parameter"); + return -EINVAL; + } + + ret = write(uart->fd, 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; +} diff --git a/src/interface/pwm.c b/src/interface/pwm.c deleted file mode 100644 index 2d34ec7..0000000 --- a/src/interface/pwm.c +++ /dev/null @@ -1,130 +0,0 @@ -/* - * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include -#include -#include -#include -#include -#include - -#include "pwm.h" -#include "peripheral_common.h" -#include "peripheral_internal.h" - -#define SYSFS_PWM_PATH "/sys/class/pwm" - -#define PATH_BUF_MAX 64 -#define PWM_BUF_MAX 16 -#define MAX_ERR_LEN 255 - -int pwm_close(peripheral_pwm_h pwm) -{ - int status; - - status = close(pwm->fd_period); - if (status < 0) { - _E("Error: pwm period fd close error \n"); - return -EIO; - } - - status = close(pwm->fd_duty_cycle); - if (status < 0) { - _E("Error: pwm duty cycle fd close error \n"); - return -EIO; - } - - status = close(pwm->fd_polarity); - if (status < 0) { - _E("Error: pwm polarity fd close error \n"); - return -EIO; - } - - status = close(pwm->fd_enable); - if (status < 0) { - _E("Error: pwm enable fd close error \n"); - return -EIO; - } - - return 0; -} - -int pwm_set_period(peripheral_pwm_h pwm, int period) -{ - int len, status; - char pwm_buf[PWM_BUF_MAX] = {0}; - - len = snprintf(pwm_buf, sizeof(pwm_buf), "%d", period); - status = write(pwm->fd_period, pwm_buf, len); - if (status < 0) { - _E("Failed to set period"); - return -EIO; - } - - return 0; -} - -int pwm_set_duty_cycle(peripheral_pwm_h pwm, int duty_cycle) -{ - int len, status; - char pwm_buf[PWM_BUF_MAX] = {0}; - - len = snprintf(pwm_buf, sizeof(pwm_buf), "%d", duty_cycle); - status = write(pwm->fd_duty_cycle, pwm_buf, len); - if (status < 0) { - _E("Failed to set duty cycle"); - return -EIO; - } - - return 0; -} - -int pwm_set_polarity(peripheral_pwm_h pwm, pwm_polarity_e polarity) -{ - int status; - - if (polarity == PWM_POLARITY_NORMAL) - status = write(pwm->fd_polarity, "normal", strlen("normal")+1); - else if (polarity == PWM_POLARITY_INVERSED) - status = write(pwm->fd_polarity, "inversed", strlen("inversed")+1); - else { - _E("Invalid pwm polarity : %d", polarity); - return -EINVAL; - } - - if (status <= 0) { - _E("Failed to set polarity"); - return -EIO; - } - - return 0; -} - -int pwm_set_enable(peripheral_pwm_h pwm, bool enable) -{ - int len, status; - char pwm_buf[PWM_BUF_MAX] = {0}; - - len = snprintf(pwm_buf, sizeof(pwm_buf), "%d", enable); - status = write(pwm->fd_enable, pwm_buf, len); - if (status < 0) { - _E("Failed to set enable"); - return -EIO; - } - - return 0; -} diff --git a/src/interface/spi.c b/src/interface/spi.c deleted file mode 100644 index c212792..0000000 --- a/src/interface/spi.c +++ /dev/null @@ -1,192 +0,0 @@ -/* - * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "spi.h" -#include "peripheral_common.h" -#include "peripheral_internal.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 - -int spi_close(peripheral_spi_h spi) -{ - int status; - - _D("fd : %d", spi->fd); - RETVM_IF(spi->fd < 0, -EINVAL, "Invalid fd"); - - status = close(spi->fd); - if (status < 0) { - char errmsg[MAX_ERR_LEN]; - strerror_r(errno, errmsg, MAX_ERR_LEN); - _E("Failed to close fd : %d", spi->fd); - return -EIO; - } - - return 0; -} - -int spi_set_mode(peripheral_spi_h spi, unsigned char mode) -{ - int status; - - _D("fd : %d, mode : %d", spi->fd, mode); - RETVM_IF(spi->fd < 0, -EINVAL, "Invalid fd"); - - status = ioctl(spi->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(peripheral_spi_h spi, unsigned char lsb) -{ - int status; - - _D("fd : %d, lsb : %d", spi->fd, lsb); - RETVM_IF(spi->fd < 0, -EINVAL, "Invalid fd"); - - status = ioctl(spi->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, spi->fd, errmsg); - return -EIO; - } - - return 0; -} - -int spi_set_bits_per_word(peripheral_spi_h spi, unsigned char bits) -{ - int status; - - _D("fd : %d, bits : %d", spi->fd, bits); - RETVM_IF(spi->fd < 0, -EINVAL, "Invalid fd"); - - status = ioctl(spi->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, spi->fd, errmsg); - return -EIO; - } - - return 0; -} - -int spi_set_frequency(peripheral_spi_h spi, unsigned int freq) -{ - int status; - - _D("fd : %d, freq : %d", spi->fd, freq); - RETVM_IF(spi->fd < 0, -EINVAL, "Invalid fd"); - - status = ioctl(spi->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, spi->fd, errmsg); - return -EIO; - } - - return 0; -} - -int spi_read(peripheral_spi_h spi, unsigned char *rxbuf, int length) -{ - int status; - struct spi_ioc_transfer xfer; - - RETVM_IF(spi->fd < 0, -EINVAL, "Invalid fd : %d", spi->fd); - - memset(&xfer, 0, sizeof(struct spi_ioc_transfer)); - xfer.rx_buf = (unsigned long)rxbuf; - xfer.len = length; - - status = ioctl(spi->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", spi->fd, length, errmsg); - return -EIO; - } - - return 0; -} - -int spi_write(peripheral_spi_h spi, unsigned char *txbuf, int length) -{ - int status; - struct spi_ioc_transfer xfer; - - RETVM_IF(spi->fd < 0, -EINVAL, "Invalid fd : %d", spi->fd); - - memset(&xfer, 0, sizeof(struct spi_ioc_transfer)); - xfer.tx_buf = (unsigned long)txbuf; - xfer.len = length; - - status = ioctl(spi->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(peripheral_spi_h spi, unsigned char *txbuf, unsigned char *rxbuf, int length) -{ - int status; - struct spi_ioc_transfer xfer; - - RETVM_IF(spi->fd < 0, -EINVAL, "Invalid fd : %d", spi->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(spi->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; -} diff --git a/src/interface/uart.c b/src/interface/uart.c deleted file mode 100644 index fcddde9..0000000 --- a/src/interface/uart.c +++ /dev/null @@ -1,443 +0,0 @@ -/* - * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "uart.h" -#include "peripheral_common.h" -#include "peripheral_internal.h" - -#define PATH_BUF_MAX 64 -#define UART_BUF_MAX 16 - -#define UART_BAUDRATE_SIZE 19 - -#ifndef ARRAY_SIZE -#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0])) -#endif -#define MAX_ERR_LEN 128 - -char *sysfs_uart_path[] = { - "/dev/ttyS", - "/dev/ttyAMA", - "/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_close(peripheral_uart_h uart) -{ - int status; - - _D("file_hndl : %d", uart->fd); - - if (uart->fd < 0) { - _E("Invalid NULL parameter"); - return -EINVAL; - } - - status = uart_flush(uart); - if (status < 0) { - char errmsg[MAX_ERR_LEN]; - strerror_r(errno, errmsg, MAX_ERR_LEN); - _E("Failed to close fd : %d, errmsg : %s", uart->fd, errmsg); - return -EIO; - } - - status = close(uart->fd); - if (status < 0) { - char errmsg[MAX_ERR_LEN]; - strerror_r(errno, errmsg, MAX_ERR_LEN); - _E("Failed to close fd : %d, errmsg : %s", uart->fd, errmsg); - return -EIO; - } - - return 0; -} - -int uart_flush(peripheral_uart_h uart) -{ - int ret; - - if (!uart->fd) { - _E("Invalid NULL parameter"); - return -EINVAL; - } - - ret = tcflush(uart->fd, TCIOFLUSH); - if (ret < 0) { - char errmsg[MAX_ERR_LEN]; - strerror_r(errno, errmsg, MAX_ERR_LEN); - _E("tcflush failed, errmsg : %s", errmsg); - return -1; - } - - return 0; -} - -int uart_set_baud_rate(peripheral_uart_h uart, uart_baud_rate_e baud) -{ - int ret; - struct termios tio; - - _D("file_hndl : %d, baud : %d", uart->fd, baud); - - memset(&tio, 0, sizeof(tio)); - if (!uart->fd) { - _E("Invalid NULL parameter"); - return -EINVAL; - } - - if (baud > UART_BAUD_RATE_230400) { - _E("Invalid parameter"); - return -EINVAL; - } - - ret = tcgetattr(uart->fd, &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(uart); - ret = tcsetattr(uart->fd, 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(peripheral_uart_h uart, 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", uart->fd, byte_size, parity, stop_bits); - - if (!uart->fd) { - _E("Invalid NULL parameter"); - return -EINVAL; - } - - if (byte_size > UART_BYTE_SIZE_8BIT) { - _E("Invalid bytesize parameter"); - return -EINVAL; - } - - ret = tcgetattr(uart->fd, &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(uart); - ret = tcsetattr(uart->fd, 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(peripheral_uart_h uart, uart_byte_size_e byte_size) -{ - int ret; - struct termios tio; - - _D("file_hndl : %d, bytesize : %d", uart->fd, byte_size); - - if (!uart->fd) { - _E("Invalid NULL parameter"); - return -EINVAL; - } - - if (byte_size > UART_BYTE_SIZE_8BIT) { - _E("Invalid bytesize parameter"); - return -EINVAL; - } - - ret = tcgetattr(uart->fd, &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(uart); - ret = tcsetattr(uart->fd, 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(peripheral_uart_h uart, uart_parity_e parity) -{ - int ret; - struct termios tio; - - _D("file_hndl : %d, parity : %d", uart->fd, parity); - - if (!uart->fd) { - _E("Invalid NULL parameter"); - return -EINVAL; - } - - ret = tcgetattr(uart->fd, &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(uart); - ret = tcsetattr(uart->fd, 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(peripheral_uart_h uart, uart_stop_bits_e stop_bits) -{ - int ret; - struct termios tio; - - _D("file_hndl : %d, stopbits : %d", uart->fd, stop_bits); - - if (!uart->fd) { - _E("Invalid NULL parameter"); - return -EINVAL; - } - - ret = tcgetattr(uart->fd, &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(uart); - ret = tcsetattr(uart->fd, 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(peripheral_uart_h uart, bool xonxoff, bool rtscts) -{ - int ret; - struct termios tio; - - _D("file_hndl : %d, xonxoff : %d, rtscts : %d", uart->fd, xonxoff, rtscts); - - if (!uart->fd) { - _E("Invalid NULL parameter"); - return -EINVAL; - } - - ret = tcgetattr(uart->fd, &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(uart->fd, 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(peripheral_uart_h uart, uint8_t *buf, unsigned int length) -{ - int ret; - - if (!uart->fd) { - _E("Invalid NULL parameter"); - return -EINVAL; - } - - ret = read(uart->fd, (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(peripheral_uart_h uart, uint8_t *buf, unsigned int length) -{ - int ret; - - if (!uart->fd) { - _E("Invalid NULL parameter"); - return -EINVAL; - } - - ret = write(uart->fd, 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; -}