soc: sensry: udma, pad renaming

Before that fix the names for UDMA could be misleading.
With that fix the namespace is clear and easy to follow.
Same applies for peripheral addresses and pad config.

Signed-off-by: Sven Ginka <[email protected]>

Author: tswaehn

drivers/serial/uart_sy1xx.c

@@ -20,27 +20,27 @@ struct sy1xx_uart_config {
 typedef struct {
 	uint16_t data_len;
 	uint8_t *data;
-} uartTransfer_t;
+} sy1xx_uartTransfer_t;
 
 typedef enum {
 	DRIVERS_UART_STOP_1,
 	DRIVERS_UART_STOP_1_5,
 	DRIVERS_UART_STOP_2
-} uart_stop_t;
+} sy1xx_uart_stop_t;
 
 typedef enum {
 	DRIVERS_UART_PAR_NONE,
 	DRIVERS_UART_PAR_EVEN,
 	DRIVERS_UART_PAR_ODD,
 	DRIVERS_UART_PAR_MARK,
 	DRIVERS_UART_PAR_SPACE
-} uart_parity_t;
+} sy1xx_uart_parity_t;
 
 typedef struct {
 	uint32_t baudrate;
-	uart_stop_t stopbits;
-	uart_parity_t parity;
-} uartConfig_t;
+	sy1xx_uart_stop_t stopbits;
+	sy1xx_uart_parity_t parity;
+} sy1xx_uartConfig_t;
 
 #define DEVICE_MAX_BUFFER_SIZE (512)
 
@@ -50,10 +50,10 @@ struct sy1xx_uart_data {
 };
 
 /* prototypes */
-static int32_t drivers_uart_read(const struct device *dev, uartTransfer_t *request);
-static int32_t drivers_uart_write(const struct device *dev, uartTransfer_t *request);
+static int32_t sy1xx_uart_read(const struct device *dev, sy1xx_uartTransfer_t *request);
+static int32_t sy1xx_uart_write(const struct device *dev, sy1xx_uartTransfer_t *request);
 
-static int32_t drivers_uart_configure(const struct device *dev, uartConfig_t *uart_cfg)
+static int32_t sy1xx_uart_configure(const struct device *dev, sy1xx_uartConfig_t *uart_cfg)
 {
 	struct sy1xx_uart_config *config = (struct sy1xx_uart_config *)dev->config;
 
@@ -66,7 +66,7 @@ static int32_t drivers_uart_configure(const struct device *dev, uartConfig_t *ua
 	 * and then will restart from 0, so we must give div - 1 as
 	 * divider
 	 */
-	int32_t divider = soc_get_peripheral_clock() / uart_cfg->baudrate - 1;
+	uint32_t divider = sy1xx_soc_get_peripheral_clock() / uart_cfg->baudrate - 1;
 
 	/*
 	 * [31:16]: clock divider (from SoC clock)
@@ -85,17 +85,17 @@ static int32_t drivers_uart_configure(const struct device *dev, uartConfig_t *ua
 	volatile uint32_t setup = 0x0306 | uart_cfg->parity;
 
 	setup |= ((divider) << 16);
-	UDMA_WRITE_REG(config->base, UDMA_SETUP_REG, setup);
+	SY1XX_UDMA_WRITE_REG(config->base, SY1XX_UDMA_SETUP_REG, setup);
 
 	/* start initial reading request to get the dma running */
 	uint8_t dummy_data[10];
 
-	uartTransfer_t dummy_request = {
+	sy1xx_uartTransfer_t dummy_request = {
 		.data_len = 10,
 		.data = (uint8_t *)dummy_data,
 	};
 
-	drivers_uart_read(dev, &dummy_request);
+	sy1xx_uart_read(dev, &dummy_request);
 	return 0;
 }
 
@@ -105,7 +105,7 @@ static int32_t drivers_uart_configure(const struct device *dev, uartConfig_t *ua
  *  -   0: OK
  *  - > 0: Busy
  */
-int32_t drivers_uart_read(const struct device *dev, uartTransfer_t *request)
+int32_t sy1xx_uart_read(const struct device *dev, sy1xx_uartTransfer_t *request)
 {
 	struct sy1xx_uart_config *config = (struct sy1xx_uart_config *)dev->config;
 	struct sy1xx_uart_data *data = (struct sy1xx_uart_data *)dev->data;
@@ -125,7 +125,7 @@ int32_t drivers_uart_read(const struct device *dev, uartTransfer_t *request)
 	int32_t ret = 0;
 
 	/* rx is ready */
-	int32_t remaining_bytes = UDMA_READ_REG(config->base, UDMA_RX_SIZE_REG);
+	int32_t remaining_bytes = SY1XX_UDMA_READ_REG(config->base, SY1XX_UDMA_RX_SIZE_REG);
 	int32_t bytes_transferred = (DEVICE_MAX_BUFFER_SIZE - remaining_bytes);
 
 	if (bytes_transferred > 0) {
@@ -140,10 +140,10 @@ int32_t drivers_uart_read(const struct device *dev, uartTransfer_t *request)
 		request->data_len = bytes_transferred;
 
 		/* stop and restart receiving */
-		UDMA_CANCEL_RX(config->base);
+		SY1XX_UDMA_CANCEL_RX(config->base);
 
 		/* start another read request, with maximum buffer size */
-		UDMA_START_RX(config->base, (int32_t)data->read, DEVICE_MAX_BUFFER_SIZE, 0);
+		SY1XX_UDMA_START_RX(config->base, (int32_t)data->read, DEVICE_MAX_BUFFER_SIZE, 0);
 
 		/* return: some data received */
 		ret = 0;
@@ -162,7 +162,7 @@ int32_t drivers_uart_read(const struct device *dev, uartTransfer_t *request)
  *  -   0: OK
  *  - > 0: Busy
  */
-int32_t drivers_uart_write(const struct device *dev, uartTransfer_t *request)
+int32_t sy1xx_uart_write(const struct device *dev, sy1xx_uartTransfer_t *request)
 {
 	struct sy1xx_uart_config *config = (struct sy1xx_uart_config *)dev->config;
 	struct sy1xx_uart_data *data = (struct sy1xx_uart_data *)dev->data;
@@ -180,15 +180,15 @@ int32_t drivers_uart_write(const struct device *dev, uartTransfer_t *request)
 		return -2;
 	}
 
-	if (0 == UDMA_IS_FINISHED_TX(config->base)) {
+	if (0 == SY1XX_UDMA_IS_FINISHED_TX(config->base)) {
 		/* writing not finished => busy */
 		return 1;
 	}
 
-	uint32_t remaining_bytes = UDMA_GET_REMAINING_TX(config->base);
+	uint32_t remaining_bytes = SY1XX_UDMA_GET_REMAINING_TX(config->base);
 
 	if (remaining_bytes != 0) {
-		UDMA_CANCEL_TX(config->base);
+		SY1XX_UDMA_CANCEL_TX(config->base);
 		return -3;
 	}
 
@@ -198,7 +198,7 @@ int32_t drivers_uart_write(const struct device *dev, uartTransfer_t *request)
 	}
 
 	/* start new transmission */
-	UDMA_START_TX(config->base, (uint32_t)data->write, request->data_len, 0);
+	SY1XX_UDMA_START_TX(config->base, (uint32_t)data->write, request->data_len, 0);
 
 	/* success */
 	return 0;
@@ -207,14 +207,14 @@ int32_t drivers_uart_write(const struct device *dev, uartTransfer_t *request)
 /*
  * it should be avoided to read single characters only
  */
-static int sensry_uart_poll_in(const struct device *dev, unsigned char *c)
+static int sy1xx_uart_poll_in(const struct device *dev, unsigned char *c)
 {
-	uartTransfer_t request = {
+	sy1xx_uartTransfer_t request = {
 		.data_len = 1,
 		.data = c,
 	};
 
-	if (0 == drivers_uart_read(dev, &request)) {
+	if (0 == sy1xx_uart_read(dev, &request)) {
 		return 0;
 	}
 
@@ -224,21 +224,21 @@ static int sensry_uart_poll_in(const struct device *dev, unsigned char *c)
 /*
  * it should be avoided to write single characters only
  */
-static void sensry_uart_poll_out(const struct device *dev, unsigned char c)
+static void sy1xx_uart_poll_out(const struct device *dev, unsigned char c)
 {
-	uartTransfer_t request = {
+	sy1xx_uartTransfer_t request = {
 		.data_len = 1,
 		.data = &c,
 	};
 
 	while (1) {
-		if (0 == drivers_uart_write(dev, &request)) {
+		if (0 == sy1xx_uart_write(dev, &request)) {
 			break;
 		}
 	}
 }
 
-static int sensry_uart_err_check(const struct device *dev)
+static int sy1xx_uart_err_check(const struct device *dev)
 {
 	int err = 0;
 
@@ -256,47 +256,51 @@ static int sy1xx_uart_init(const struct device *dev)
 	}
 
 	/* UDMA clock enable */
-	drivers_udma_enable_clock(DRIVERS_UDMA_UART, config->inst);
+	sy1xx_udma_enable_clock(SY1XX_UDMA_MODULE_UART, config->inst);
 
 	/* PAD config */
 	uint32_t pad_config_tx =
-		PAD_CONFIG(0, PAD_SMT_DISABLE, PAD_SLEW_LOW, PAD_PULLUP_DIS, PAD_PULLDOWN_DIS,
-			   PAD_DRIVE_2PF, PAD_PMOD_NORMAL, PAD_DIR_OUTPUT);
+		SY1XX_PAD_CONFIG(0, SY1XX_PAD_SMT_DISABLE, SY1XX_PAD_SLEW_LOW, SY1XX_PAD_PULLUP_DIS,
+				 SY1XX_PAD_PULLDOWN_DIS, SY1XX_PAD_DRIVE_2PF, SY1XX_PAD_PMOD_NORMAL,
+				 SY1XX_PAD_DIR_OUTPUT);
 
 	uint32_t pad_config_rx =
-		PAD_CONFIG(8, PAD_SMT_DISABLE, PAD_SLEW_LOW, PAD_PULLUP_DIS, PAD_PULLDOWN_DIS,
-			   PAD_DRIVE_2PF, PAD_PMOD_NORMAL, PAD_DIR_INPUT);
+		SY1XX_PAD_CONFIG(8, SY1XX_PAD_SMT_DISABLE, SY1XX_PAD_SLEW_LOW, SY1XX_PAD_PULLUP_DIS,
+				 SY1XX_PAD_PULLDOWN_DIS, SY1XX_PAD_DRIVE_2PF, SY1XX_PAD_PMOD_NORMAL,
+				 SY1XX_PAD_DIR_INPUT);
 
 	uint32_t pad_config_cts =
-		PAD_CONFIG(16, PAD_SMT_DISABLE, PAD_SLEW_LOW, PAD_PULLUP_EN, PAD_PULLDOWN_DIS,
-			   PAD_DRIVE_2PF, PAD_PMOD_NORMAL, PAD_DIR_INPUT);
+		SY1XX_PAD_CONFIG(16, SY1XX_PAD_SMT_DISABLE, SY1XX_PAD_SLEW_LOW, SY1XX_PAD_PULLUP_EN,
+				 SY1XX_PAD_PULLDOWN_DIS, SY1XX_PAD_DRIVE_2PF, SY1XX_PAD_PMOD_NORMAL,
+				 SY1XX_PAD_DIR_INPUT);
 
 	uint32_t pad_config_rts =
-		PAD_CONFIG(24, PAD_SMT_DISABLE, PAD_SLEW_LOW, PAD_PULLUP_DIS, PAD_PULLDOWN_DIS,
-			   PAD_DRIVE_2PF, PAD_PMOD_NORMAL, PAD_DIR_OUTPUT);
+		SY1XX_PAD_CONFIG(24, SY1XX_PAD_SMT_DISABLE, SY1XX_PAD_SLEW_LOW,
+				 SY1XX_PAD_PULLUP_DIS, SY1XX_PAD_PULLDOWN_DIS, SY1XX_PAD_DRIVE_2PF,
+				 SY1XX_PAD_PMOD_NORMAL, SY1XX_PAD_DIR_OUTPUT);
 
 	sys_write32((pad_config_tx | pad_config_rx | pad_config_cts | pad_config_rts),
-		    PAD_CONFIG_ADDR_UART + (config->inst * 4 + 0));
+		    SY1XX_PAD_CONFIG_ADDR_UART + (config->inst * 4 + 0));
 
-	uartConfig_t default_config = {
+	sy1xx_uartConfig_t default_config = {
 		.baudrate = 1000000,
 		.parity = DRIVERS_UART_PAR_NONE,
 		.stopbits = DRIVERS_UART_STOP_1,
 	};
 
-	UDMA_CANCEL_RX(config->base);
-	UDMA_CANCEL_TX(config->base);
+	SY1XX_UDMA_CANCEL_RX(config->base);
+	SY1XX_UDMA_CANCEL_TX(config->base);
 
-	drivers_uart_configure(dev, &default_config);
+	sy1xx_uart_configure(dev, &default_config);
 
 	return 0;
 }
 
 static const struct uart_driver_api sy1xx_uart_driver_api = {
 
-	.poll_in = sensry_uart_poll_in,
-	.poll_out = sensry_uart_poll_out,
-	.err_check = sensry_uart_err_check,
+	.poll_in = sy1xx_uart_poll_in,
+	.poll_out = sy1xx_uart_poll_out,
+	.err_check = sy1xx_uart_err_check,
 
 };