dm: treewide: Rename ..._platdata variables to just ..._plat

Try to maintain some consistency between these variables by using _plat as
a suffix for them.

Signed-off-by: Simon Glass <sjg@chromium.org>

28 files changed, 166 insertions, 166 deletions

diff --git a/drivers/serial/altera_jtag_uart.c b/drivers/serial/altera_jtag_uart.c
index af7fe39e20..0d3ccd880c 100644
--- a/drivers/serial/altera_jtag_uart.c
+++ b/drivers/serial/altera_jtag_uart.c
@@ -26,7 +26,7 @@ struct altera_jtaguart_regs {
 	u32	control;		/* Control register */
 };
 
-struct altera_jtaguart_platdata {
+struct altera_jtaguart_plat {
 	struct altera_jtaguart_regs *regs;
 };
 
@@ -37,7 +37,7 @@ static int altera_jtaguart_setbrg(struct udevice *dev, int baudrate)
 
 static int altera_jtaguart_putc(struct udevice *dev, const char ch)
 {
-	struct altera_jtaguart_platdata *plat = dev->plat;
+	struct altera_jtaguart_plat *plat = dev->plat;
 	struct altera_jtaguart_regs *const regs = plat->regs;
 	u32 st = readl(&regs->control);
 
@@ -56,7 +56,7 @@ static int altera_jtaguart_putc(struct udevice *dev, const char ch)
 
 static int altera_jtaguart_pending(struct udevice *dev, bool input)
 {
-	struct altera_jtaguart_platdata *plat = dev->plat;
+	struct altera_jtaguart_plat *plat = dev->plat;
 	struct altera_jtaguart_regs *const regs = plat->regs;
 	u32 st = readl(&regs->control);
 
@@ -68,7 +68,7 @@ static int altera_jtaguart_pending(struct udevice *dev, bool input)
 
 static int altera_jtaguart_getc(struct udevice *dev)
 {
-	struct altera_jtaguart_platdata *plat = dev->plat;
+	struct altera_jtaguart_plat *plat = dev->plat;
 	struct altera_jtaguart_regs *const regs = plat->regs;
 	u32 val;
 
@@ -83,7 +83,7 @@ static int altera_jtaguart_getc(struct udevice *dev)
 static int altera_jtaguart_probe(struct udevice *dev)
 {
 #ifdef CONFIG_ALTERA_JTAG_UART_BYPASS
-	struct altera_jtaguart_platdata *plat = dev->plat;
+	struct altera_jtaguart_plat *plat = dev->plat;
 	struct altera_jtaguart_regs *const regs = plat->regs;
 
 	writel(ALTERA_JTAG_AC, &regs->control); /* clear AC flag */
@@ -93,7 +93,7 @@ static int altera_jtaguart_probe(struct udevice *dev)
 
 static int altera_jtaguart_of_to_plat(struct udevice *dev)
 {
-	struct altera_jtaguart_platdata *plat = dev_get_plat(dev);
+	struct altera_jtaguart_plat *plat = dev_get_plat(dev);
 
 	plat->regs = map_physmem(dev_read_addr(dev),
 				 sizeof(struct altera_jtaguart_regs),
@@ -119,7 +119,7 @@ U_BOOT_DRIVER(altera_jtaguart) = {
 	.id	= UCLASS_SERIAL,
 	.of_match = altera_jtaguart_ids,
 	.of_to_plat = altera_jtaguart_of_to_plat,
-	.plat_auto	= sizeof(struct altera_jtaguart_platdata),
+	.plat_auto	= sizeof(struct altera_jtaguart_plat),
 	.probe = altera_jtaguart_probe,
 	.ops	= &altera_jtaguart_ops,
 };
diff --git a/drivers/serial/altera_uart.c b/drivers/serial/altera_uart.c
index fe6550551d..a3efa1ee1b 100644
--- a/drivers/serial/altera_uart.c
+++ b/drivers/serial/altera_uart.c
@@ -25,14 +25,14 @@ struct altera_uart_regs {
 	u32	endofpacket;	/* End-of-packet reg */
 };
 
-struct altera_uart_platdata {
+struct altera_uart_plat {
 	struct altera_uart_regs *regs;
 	unsigned int uartclk;
 };
 
 static int altera_uart_setbrg(struct udevice *dev, int baudrate)
 {
-	struct altera_uart_platdata *plat = dev->plat;
+	struct altera_uart_plat *plat = dev->plat;
 	struct altera_uart_regs *const regs = plat->regs;
 	u32 div;
 
@@ -44,7 +44,7 @@ static int altera_uart_setbrg(struct udevice *dev, int baudrate)
 
 static int altera_uart_putc(struct udevice *dev, const char ch)
 {
-	struct altera_uart_platdata *plat = dev->plat;
+	struct altera_uart_plat *plat = dev->plat;
 	struct altera_uart_regs *const regs = plat->regs;
 
 	if (!(readl(&regs->status) & ALTERA_UART_TRDY))
@@ -57,7 +57,7 @@ static int altera_uart_putc(struct udevice *dev, const char ch)
 
 static int altera_uart_pending(struct udevice *dev, bool input)
 {
-	struct altera_uart_platdata *plat = dev->plat;
+	struct altera_uart_plat *plat = dev->plat;
 	struct altera_uart_regs *const regs = plat->regs;
 	u32 st = readl(&regs->status);
 
@@ -69,7 +69,7 @@ static int altera_uart_pending(struct udevice *dev, bool input)
 
 static int altera_uart_getc(struct udevice *dev)
 {
-	struct altera_uart_platdata *plat = dev->plat;
+	struct altera_uart_plat *plat = dev->plat;
 	struct altera_uart_regs *const regs = plat->regs;
 
 	if (!(readl(&regs->status) & ALTERA_UART_RRDY))
@@ -85,7 +85,7 @@ static int altera_uart_probe(struct udevice *dev)
 
 static int altera_uart_of_to_plat(struct udevice *dev)
 {
-	struct altera_uart_platdata *plat = dev_get_plat(dev);
+	struct altera_uart_plat *plat = dev_get_plat(dev);
 
 	plat->regs = map_physmem(dev_read_addr(dev),
 				 sizeof(struct altera_uart_regs),
@@ -112,7 +112,7 @@ U_BOOT_DRIVER(altera_uart) = {
 	.id	= UCLASS_SERIAL,
 	.of_match = altera_uart_ids,
 	.of_to_plat = altera_uart_of_to_plat,
-	.plat_auto	= sizeof(struct altera_uart_platdata),
+	.plat_auto	= sizeof(struct altera_uart_plat),
 	.probe = altera_uart_probe,
 	.ops	= &altera_uart_ops,
 };
diff --git a/drivers/serial/atmel_usart.c b/drivers/serial/atmel_usart.c
index 463bedef23..7eabf76d92 100644
--- a/drivers/serial/atmel_usart.c
+++ b/drivers/serial/atmel_usart.c
@@ -262,7 +262,7 @@ static int atmel_serial_enable_clk(struct udevice *dev)
 
 static int atmel_serial_probe(struct udevice *dev)
 {
-	struct atmel_serial_platdata *plat = dev->plat;
+	struct atmel_serial_plat *plat = dev->plat;
 	struct atmel_serial_priv *priv = dev_get_priv(dev);
 	int ret;
 #if CONFIG_IS_ENABLED(OF_CONTROL)
@@ -304,7 +304,7 @@ U_BOOT_DRIVER(serial_atmel) = {
 	.id	= UCLASS_SERIAL,
 #if CONFIG_IS_ENABLED(OF_CONTROL)
 	.of_match = atmel_serial_ids,
-	.plat_auto	= sizeof(struct atmel_serial_platdata),
+	.plat_auto	= sizeof(struct atmel_serial_plat),
 #endif
 	.probe = atmel_serial_probe,
 	.ops	= &atmel_serial_ops,
diff --git a/drivers/serial/lpc32xx_hsuart.c b/drivers/serial/lpc32xx_hsuart.c
index 4e34643b4a..d39a3c0494 100644
--- a/drivers/serial/lpc32xx_hsuart.c
+++ b/drivers/serial/lpc32xx_hsuart.c
@@ -85,7 +85,7 @@ static int lpc32xx_serial_init(struct hsuart_regs *hsuart)
 
 static int lpc32xx_hsuart_probe(struct udevice *dev)
 {
-	struct lpc32xx_hsuart_platdata *plat = dev_get_plat(dev);
+	struct lpc32xx_hsuart_plat *plat = dev_get_plat(dev);
 	struct lpc32xx_hsuart_priv *priv = dev_get_priv(dev);
 
 	priv->hsuart = (struct hsuart_regs *)plat->base;
diff --git a/drivers/serial/ns16550.c b/drivers/serial/ns16550.c
index 6f80e02a0a..8dd81ad794 100644
--- a/drivers/serial/ns16550.c
+++ b/drivers/serial/ns16550.c
@@ -103,7 +103,7 @@ static inline int serial_in_shift(void *addr, int shift)
  * on a platform
  */
 #ifdef CONFIG_NS16550_DYNAMIC
-static void serial_out_dynamic(struct ns16550_platdata *plat, u8 *addr,
+static void serial_out_dynamic(struct ns16550_plat *plat, u8 *addr,
 			       int value)
 {
 	if (plat->flags & NS16550_FLAG_IO) {
@@ -124,7 +124,7 @@ static void serial_out_dynamic(struct ns16550_platdata *plat, u8 *addr,
 	}
 }
 
-static int serial_in_dynamic(struct ns16550_platdata *plat, u8 *addr)
+static int serial_in_dynamic(struct ns16550_plat *plat, u8 *addr)
 {
 	if (plat->flags & NS16550_FLAG_IO) {
 		return inb(addr);
@@ -144,12 +144,12 @@ static int serial_in_dynamic(struct ns16550_platdata *plat, u8 *addr)
 	}
 }
 #else
-static inline void serial_out_dynamic(struct ns16550_platdata *plat, u8 *addr,
+static inline void serial_out_dynamic(struct ns16550_plat *plat, u8 *addr,
 				      int value)
 {
 }
 
-static inline int serial_in_dynamic(struct ns16550_platdata *plat, u8 *addr)
+static inline int serial_in_dynamic(struct ns16550_plat *plat, u8 *addr)
 {
 	return 0;
 }
@@ -158,7 +158,7 @@ static inline int serial_in_dynamic(struct ns16550_platdata *plat, u8 *addr)
 
 static void ns16550_writeb(NS16550_t port, int offset, int value)
 {
-	struct ns16550_platdata *plat = port->plat;
+	struct ns16550_plat *plat = port->plat;
 	unsigned char *addr;
 
 	offset *= 1 << plat->reg_shift;
@@ -172,7 +172,7 @@ static void ns16550_writeb(NS16550_t port, int offset, int value)
 
 static int ns16550_readb(NS16550_t port, int offset)
 {
-	struct ns16550_platdata *plat = port->plat;
+	struct ns16550_plat *plat = port->plat;
 	unsigned char *addr;
 
 	offset *= 1 << plat->reg_shift;
@@ -186,7 +186,7 @@ static int ns16550_readb(NS16550_t port, int offset)
 
 static u32 ns16550_getfcr(NS16550_t port)
 {
-	struct ns16550_platdata *plat = port->plat;
+	struct ns16550_plat *plat = port->plat;
 
 	return plat->fcr;
 }
@@ -418,7 +418,7 @@ static int ns16550_serial_getc(struct udevice *dev)
 static int ns16550_serial_setbrg(struct udevice *dev, int baudrate)
 {
 	struct NS16550 *const com_port = dev_get_priv(dev);
-	struct ns16550_platdata *plat = com_port->plat;
+	struct ns16550_plat *plat = com_port->plat;
 	int clock_divisor;
 
 	clock_divisor = ns16550_calc_divisor(com_port, plat->clock, baudrate);
@@ -465,7 +465,7 @@ static int ns16550_serial_getinfo(struct udevice *dev,
 				  struct serial_device_info *info)
 {
 	struct NS16550 *const com_port = dev_get_priv(dev);
-	struct ns16550_platdata *plat = com_port->plat;
+	struct ns16550_plat *plat = com_port->plat;
 
 	info->type = SERIAL_CHIP_16550_COMPATIBLE;
 #ifdef CONFIG_SYS_NS16550_PORT_MAPPED
@@ -482,7 +482,7 @@ static int ns16550_serial_getinfo(struct udevice *dev,
 	return 0;
 }
 
-static int ns16550_serial_assign_base(struct ns16550_platdata *plat, ulong base)
+static int ns16550_serial_assign_base(struct ns16550_plat *plat, ulong base)
 {
 	if (base == FDT_ADDR_T_NONE)
 		return -EINVAL;
@@ -498,7 +498,7 @@ static int ns16550_serial_assign_base(struct ns16550_platdata *plat, ulong base)
 
 int ns16550_serial_probe(struct udevice *dev)
 {
-	struct ns16550_platdata *plat = dev->plat;
+	struct ns16550_plat *plat = dev->plat;
 	struct NS16550 *const com_port = dev_get_priv(dev);
 	struct reset_ctl_bulk reset_bulk;
 	fdt_addr_t addr;
@@ -535,7 +535,7 @@ enum {
 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
 int ns16550_serial_of_to_plat(struct udevice *dev)
 {
-	struct ns16550_platdata *plat = dev->plat;
+	struct ns16550_plat *plat = dev->plat;
 	const u32 port_type = dev_get_driver_data(dev);
 	fdt_addr_t addr;
 	struct clk clk;
@@ -611,7 +611,7 @@ U_BOOT_DRIVER(ns16550_serial) = {
 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
 	.of_match = ns16550_serial_ids,
 	.of_to_plat = ns16550_serial_of_to_plat,
-	.plat_auto	= sizeof(struct ns16550_platdata),
+	.plat_auto	= sizeof(struct ns16550_plat),
 #endif
 	.priv_auto	= sizeof(struct NS16550),
 	.probe = ns16550_serial_probe,
diff --git a/drivers/serial/sandbox.c b/drivers/serial/sandbox.c
index 2deb14d5d1..c7d5390b43 100644
--- a/drivers/serial/sandbox.c
+++ b/drivers/serial/sandbox.c
@@ -21,7 +21,7 @@
 
 DECLARE_GLOBAL_DATA_PTR;
 
-struct sandbox_serial_platdata {
+struct sandbox_serial_plat {
 	int colour;	/* Text colour to use for output, -1 for none */
 };
 
@@ -72,7 +72,7 @@ static int sandbox_serial_probe(struct udevice *dev)
 
 static int sandbox_serial_remove(struct udevice *dev)
 {
-	struct sandbox_serial_platdata *plat = dev->plat;
+	struct sandbox_serial_plat *plat = dev->plat;
 
 	if (plat->colour != -1)
 		output_ansi_reset();
@@ -83,7 +83,7 @@ static int sandbox_serial_remove(struct udevice *dev)
 static int sandbox_serial_putc(struct udevice *dev, const char ch)
 {
 	struct sandbox_serial_priv *priv = dev_get_priv(dev);
-	struct sandbox_serial_platdata *plat = dev->plat;
+	struct sandbox_serial_plat *plat = dev->plat;
 
 	/* With of-platdata we don't real the colour correctly, so disable it */
 	if (!CONFIG_IS_ENABLED(OF_PLATDATA) && priv->start_of_line &&
@@ -203,7 +203,7 @@ static const char * const ansi_colour[] = {
 
 static int sandbox_serial_of_to_plat(struct udevice *dev)
 {
-	struct sandbox_serial_platdata *plat = dev->plat;
+	struct sandbox_serial_plat *plat = dev->plat;
 	const char *colour;
 	int i;
 
@@ -242,7 +242,7 @@ U_BOOT_DRIVER(sandbox_serial) = {
 	.id	= UCLASS_SERIAL,
 	.of_match = sandbox_serial_ids,
 	.of_to_plat = sandbox_serial_of_to_plat,
-	.plat_auto	= sizeof(struct sandbox_serial_platdata),
+	.plat_auto	= sizeof(struct sandbox_serial_plat),
 	.priv_auto	= sizeof(struct sandbox_serial_priv),
 	.probe = sandbox_serial_probe,
 	.remove = sandbox_serial_remove,
@@ -251,7 +251,7 @@ U_BOOT_DRIVER(sandbox_serial) = {
 };
 
 #if !CONFIG_IS_ENABLED(OF_PLATDATA)
-static const struct sandbox_serial_platdata platdata_non_fdt = {
+static const struct sandbox_serial_plat platdata_non_fdt = {
 	.colour = -1,
 };
 
diff --git a/drivers/serial/serial_arc.c b/drivers/serial/serial_arc.c
index dae55ea6f4..022e37748c 100644
--- a/drivers/serial/serial_arc.c
+++ b/drivers/serial/serial_arc.c
@@ -25,7 +25,7 @@ struct arc_serial_regs {
 };
 
 
-struct arc_serial_platdata {
+struct arc_serial_plat {
 	struct arc_serial_regs *reg;
 	unsigned int uartclk;
 };
@@ -37,7 +37,7 @@ struct arc_serial_platdata {
 
 static int arc_serial_setbrg(struct udevice *dev, int baudrate)
 {
-	struct arc_serial_platdata *plat = dev->plat;
+	struct arc_serial_plat *plat = dev->plat;
 	struct arc_serial_regs *const regs = plat->reg;
 	int arc_console_baud = gd->cpu_clk / (baudrate * 4) - 1;
 
@@ -49,7 +49,7 @@ static int arc_serial_setbrg(struct udevice *dev, int baudrate)
 
 static int arc_serial_putc(struct udevice *dev, const char c)
 {
-	struct arc_serial_platdata *plat = dev->plat;
+	struct arc_serial_plat *plat = dev->plat;
 	struct arc_serial_regs *const regs = plat->reg;
 
 	while (!(readb(&regs->status) & UART_TXEMPTY))
@@ -67,7 +67,7 @@ static int arc_serial_tstc(struct arc_serial_regs *const regs)
 
 static int arc_serial_pending(struct udevice *dev, bool input)
 {
-	struct arc_serial_platdata *plat = dev->plat;
+	struct arc_serial_plat *plat = dev->plat;
 	struct arc_serial_regs *const regs = plat->reg;
 	uint32_t status = readb(&regs->status);
 
@@ -79,7 +79,7 @@ static int arc_serial_pending(struct udevice *dev, bool input)
 
 static int arc_serial_getc(struct udevice *dev)
 {
-	struct arc_serial_platdata *plat = dev->plat;
+	struct arc_serial_plat *plat = dev->plat;
 	struct arc_serial_regs *const regs = plat->reg;
 
 	while (!arc_serial_tstc(regs))
@@ -111,7 +111,7 @@ static const struct udevice_id arc_serial_ids[] = {
 
 static int arc_serial_of_to_plat(struct udevice *dev)
 {
-	struct arc_serial_platdata *plat = dev_get_plat(dev);
+	struct arc_serial_plat *plat = dev_get_plat(dev);
 	DECLARE_GLOBAL_DATA_PTR;
 
 	plat->reg = dev_read_addr_ptr(dev);
@@ -126,7 +126,7 @@ U_BOOT_DRIVER(serial_arc) = {
 	.id	= UCLASS_SERIAL,
 	.of_match = arc_serial_ids,
 	.of_to_plat = arc_serial_of_to_plat,
-	.plat_auto	= sizeof(struct arc_serial_platdata),
+	.plat_auto	= sizeof(struct arc_serial_plat),
 	.probe = arc_serial_probe,
 	.ops	= &arc_serial_ops,
 };
diff --git a/drivers/serial/serial_bcm283x_mu.c b/drivers/serial/serial_bcm283x_mu.c
index a53288dc91..58fa722b4b 100644
--- a/drivers/serial/serial_bcm283x_mu.c
+++ b/drivers/serial/serial_bcm283x_mu.c
@@ -55,7 +55,7 @@ static int bcm283x_mu_serial_getc(struct udevice *dev);
 
 static int bcm283x_mu_serial_setbrg(struct udevice *dev, int baudrate)
 {
-	struct bcm283x_mu_serial_platdata *plat = dev_get_plat(dev);
+	struct bcm283x_mu_serial_plat *plat = dev_get_plat(dev);
 	struct bcm283x_mu_priv *priv = dev_get_priv(dev);
 	struct bcm283x_mu_regs *regs = priv->regs;
 	u32 divider;
@@ -158,7 +158,7 @@ static bool bcm283x_is_serial_muxed(void)
 
 static int bcm283x_mu_serial_probe(struct udevice *dev)
 {
-	struct bcm283x_mu_serial_platdata *plat = dev_get_plat(dev);
+	struct bcm283x_mu_serial_plat *plat = dev_get_plat(dev);
 	struct bcm283x_mu_priv *priv = dev_get_priv(dev);
 	fdt_addr_t addr;
 
@@ -194,7 +194,7 @@ U_BOOT_DRIVER(serial_bcm283x_mu) = {
 	.name = "serial_bcm283x_mu",
 	.id = UCLASS_SERIAL,
 	.of_match = of_match_ptr(bcm283x_mu_serial_id),
-	.plat_auto	= sizeof(struct bcm283x_mu_serial_platdata),
+	.plat_auto	= sizeof(struct bcm283x_mu_serial_plat),
 	.probe = bcm283x_mu_serial_probe,
 	.ops = &bcm283x_mu_serial_ops,
 #if !CONFIG_IS_ENABLED(OF_CONTROL) || CONFIG_IS_ENABLED(OF_BOARD)
diff --git a/drivers/serial/serial_bcm283x_pl011.c b/drivers/serial/serial_bcm283x_pl011.c
index 967f8421ab..2d2e970316 100644
--- a/drivers/serial/serial_bcm283x_pl011.c
+++ b/drivers/serial/serial_bcm283x_pl011.c
@@ -35,7 +35,7 @@ static bool bcm283x_is_serial_muxed(void)
 
 static int bcm283x_pl011_serial_probe(struct udevice *dev)
 {
-	struct pl01x_serial_platdata *plat = dev_get_plat(dev);
+	struct pl01x_serial_plat *plat = dev_get_plat(dev);
 	int ret;
 
 	/* Don't spawn the device if it's not muxed */
@@ -92,7 +92,7 @@ U_BOOT_DRIVER(bcm283x_pl011_uart) = {
 	.id	= UCLASS_SERIAL,
 	.of_match = of_match_ptr(bcm283x_pl011_serial_id),
 	.probe	= bcm283x_pl011_serial_probe,
-	.plat_auto	= sizeof(struct pl01x_serial_platdata),
+	.plat_auto	= sizeof(struct pl01x_serial_plat),
 	.ops	= &bcm283x_pl011_serial_ops,
 #if !CONFIG_IS_ENABLED(OF_CONTROL) || CONFIG_IS_ENABLED(OF_BOARD)
 	.flags	= DM_FLAG_PRE_RELOC,
diff --git a/drivers/serial/serial_coreboot.c b/drivers/serial/serial_coreboot.c
index ece27aca88..904e1b306e 100644
--- a/drivers/serial/serial_coreboot.c
+++ b/drivers/serial/serial_coreboot.c
@@ -13,7 +13,7 @@
 
 static int coreboot_of_to_plat(struct udevice *dev)
 {
-	struct ns16550_platdata *plat = dev_get_plat(dev);
+	struct ns16550_plat *plat = dev_get_plat(dev);
 	struct cb_serial *cb_info = lib_sysinfo.serial;
 
 	plat->base = cb_info->baseaddr;
@@ -38,7 +38,7 @@ U_BOOT_DRIVER(coreboot_uart) = {
 	.id	= UCLASS_SERIAL,
 	.of_match	= coreboot_serial_ids,
 	.priv_auto	= sizeof(struct NS16550),
-	.plat_auto	= sizeof(struct ns16550_platdata),
+	.plat_auto	= sizeof(struct ns16550_plat),
 	.of_to_plat  = coreboot_of_to_plat,
 	.probe	= ns16550_serial_probe,
 	.ops	= &ns16550_serial_ops,
diff --git a/drivers/serial/serial_intel_mid.c b/drivers/serial/serial_intel_mid.c
index 55da805b8e..be9bf662fd 100644
--- a/drivers/serial/serial_intel_mid.c
+++ b/drivers/serial/serial_intel_mid.c
@@ -21,7 +21,7 @@
 #define UART_MUL	0x34
 #define UART_DIV	0x38
 
-static void mid_writel(struct ns16550_platdata *plat, int offset, int value)
+static void mid_writel(struct ns16550_plat *plat, int offset, int value)
 {
 	unsigned char *addr;
 
@@ -33,7 +33,7 @@ static void mid_writel(struct ns16550_platdata *plat, int offset, int value)
 
 static int mid_serial_probe(struct udevice *dev)
 {
-	struct ns16550_platdata *plat = dev_get_plat(dev);
+	struct ns16550_plat *plat = dev_get_plat(dev);
 
 	/*
 	 * Initialize fractional divider correctly for Intel Edison
@@ -60,7 +60,7 @@ U_BOOT_DRIVER(serial_intel_mid) = {
 	.id	= UCLASS_SERIAL,
 	.of_match = mid_serial_ids,
 	.of_to_plat = ns16550_serial_of_to_plat,
-	.plat_auto	= sizeof(struct ns16550_platdata),
+	.plat_auto	= sizeof(struct ns16550_plat),
 	.priv_auto	= sizeof(struct NS16550),
 	.probe	= mid_serial_probe,
 	.ops	= &ns16550_serial_ops,
diff --git a/drivers/serial/serial_linflexuart.c b/drivers/serial/serial_linflexuart.c
index 4f8867ab7b..ced005706a 100644
--- a/drivers/serial/serial_linflexuart.c
+++ b/drivers/serial/serial_linflexuart.c
@@ -115,7 +115,7 @@ static int _linflex_serial_init(struct linflex_fsl *base)
 	return 0;
 }
 
-struct linflex_serial_platdata {
+struct linflex_serial_plat {
 	struct linflex_fsl *base_addr;
 	u8 port_id; /* do we need this? */
 };
@@ -168,7 +168,7 @@ static void linflex_serial_init_internal(struct linflex_fsl *lfuart)
 
 static int linflex_serial_probe(struct udevice *dev)
 {
-	struct linflex_serial_platdata *plat = dev->plat;
+	struct linflex_serial_plat *plat = dev->plat;
 	struct linflex_serial_priv *priv = dev_get_priv(dev);
 
 	priv->lfuart = (struct linflex_fsl *)plat->base_addr;
diff --git a/drivers/serial/serial_lpuart.c b/drivers/serial/serial_lpuart.c
index 56362339be..5beb5f2ce6 100644
--- a/drivers/serial/serial_lpuart.c
+++ b/drivers/serial/serial_lpuart.c
@@ -74,7 +74,7 @@ enum lpuart_devtype {
 	DEV_IMXRT,
 };
 
-struct lpuart_serial_platdata {
+struct lpuart_serial_plat {
 	void *reg;
 	enum lpuart_devtype devtype;
 	ulong flags;
@@ -138,7 +138,7 @@ static inline int get_lpuart_clk_rate(struct udevice *dev, u32 *clk)
 
 static bool is_lpuart32(struct udevice *dev)
 {
-	struct lpuart_serial_platdata *plat = dev->plat;
+	struct lpuart_serial_plat *plat = dev->plat;
 
 	return plat->flags & LPUART_FLAG_REGMAP_32BIT_REG;
 }
@@ -146,7 +146,7 @@ static bool is_lpuart32(struct udevice *dev)
 static void _lpuart_serial_setbrg(struct udevice *dev,
 				  int baudrate)
 {
-	struct lpuart_serial_platdata *plat = dev_get_plat(dev);
+	struct lpuart_serial_plat *plat = dev_get_plat(dev);
 	struct lpuart_fsl *base = plat->reg;
 	u32 clk;
 	u16 sbr;
@@ -167,7 +167,7 @@ static void _lpuart_serial_setbrg(struct udevice *dev,
 	__raw_writeb(sbr & 0xff, &base->ubdl);
 }
 
-static int _lpuart_serial_getc(struct lpuart_serial_platdata *plat)
+static int _lpuart_serial_getc(struct lpuart_serial_plat *plat)
 {
 	struct lpuart_fsl *base = plat->reg;
 	while (!(__raw_readb(&base->us1) & (US1_RDRF | US1_OR)))
@@ -178,7 +178,7 @@ static int _lpuart_serial_getc(struct lpuart_serial_platdata *plat)
 	return __raw_readb(&base->ud);
 }
 
-static void _lpuart_serial_putc(struct lpuart_serial_platdata *plat,
+static void _lpuart_serial_putc(struct lpuart_serial_plat *plat,
 				const char c)
 {
 	struct lpuart_fsl *base = plat->reg;
@@ -190,7 +190,7 @@ static void _lpuart_serial_putc(struct lpuart_serial_platdata *plat,
 }
 
 /* Test whether a character is in the RX buffer */
-static int _lpuart_serial_tstc(struct lpuart_serial_platdata *plat)
+static int _lpuart_serial_tstc(struct lpuart_serial_plat *plat)
 {
 	struct lpuart_fsl *base = plat->reg;
 
@@ -206,7 +206,7 @@ static int _lpuart_serial_tstc(struct lpuart_serial_platdata *plat)
  */
 static int _lpuart_serial_init(struct udevice *dev)
 {
-	struct lpuart_serial_platdata *plat = dev_get_plat(dev);
+	struct lpuart_serial_plat *plat = dev_get_plat(dev);
 	struct lpuart_fsl *base = (struct lpuart_fsl *)plat->reg;
 	u8 ctrl;
 
@@ -235,7 +235,7 @@ static int _lpuart_serial_init(struct udevice *dev)
 static void _lpuart32_serial_setbrg_7ulp(struct udevice *dev,
 					 int baudrate)
 {
-	struct lpuart_serial_platdata *plat = dev_get_plat(dev);
+	struct lpuart_serial_plat *plat = dev_get_plat(dev);
 	struct lpuart_fsl_reg32 *base = plat->reg;
 	u32 sbr, osr, baud_diff, tmp_osr, tmp_sbr, tmp_diff, tmp;
 	u32 clk;
@@ -304,7 +304,7 @@ static void _lpuart32_serial_setbrg_7ulp(struct udevice *dev,
 static void _lpuart32_serial_setbrg(struct udevice *dev,
 				    int baudrate)
 {
-	struct lpuart_serial_platdata *plat = dev_get_plat(dev);
+	struct lpuart_serial_plat *plat = dev_get_plat(dev);
 	struct lpuart_fsl_reg32 *base = plat->reg;
 	u32 clk;
 	u32 sbr;
@@ -324,7 +324,7 @@ static void _lpuart32_serial_setbrg(struct udevice *dev,
 	lpuart_write32(plat->flags, &base->baud, sbr);
 }
 
-static int _lpuart32_serial_getc(struct lpuart_serial_platdata *plat)
+static int _lpuart32_serial_getc(struct lpuart_serial_plat *plat)
 {
 	struct lpuart_fsl_reg32 *base = plat->reg;
 	u32 stat, val;
@@ -345,7 +345,7 @@ static int _lpuart32_serial_getc(struct lpuart_serial_platdata *plat)
 	return val & 0x3ff;
 }
 
-static void _lpuart32_serial_putc(struct lpuart_serial_platdata *plat,
+static void _lpuart32_serial_putc(struct lpuart_serial_plat *plat,
 				  const char c)
 {
 	struct lpuart_fsl_reg32 *base = plat->reg;
@@ -367,7 +367,7 @@ static void _lpuart32_serial_putc(struct lpuart_serial_platdata *plat,
 }
 
 /* Test whether a character is in the RX buffer */
-static int _lpuart32_serial_tstc(struct lpuart_serial_platdata *plat)
+static int _lpuart32_serial_tstc(struct lpuart_serial_plat *plat)
 {
 	struct lpuart_fsl_reg32 *base = plat->reg;
 	u32 water;
@@ -386,7 +386,7 @@ static int _lpuart32_serial_tstc(struct lpuart_serial_platdata *plat)
  */
 static int _lpuart32_serial_init(struct udevice *dev)
 {
-	struct lpuart_serial_platdata *plat = dev_get_plat(dev);
+	struct lpuart_serial_plat *plat = dev_get_plat(dev);
 	struct lpuart_fsl_reg32 *base = (struct lpuart_fsl_reg32 *)plat->reg;
 	u32 val, tx_fifo_size;
 
@@ -428,7 +428,7 @@ static int _lpuart32_serial_init(struct udevice *dev)
 
 static int lpuart_serial_setbrg(struct udevice *dev, int baudrate)
 {
-	struct lpuart_serial_platdata *plat = dev_get_plat(dev);
+	struct lpuart_serial_plat *plat = dev_get_plat(dev);
 
 	if (is_lpuart32(dev)) {
 		if (plat->devtype == DEV_MX7ULP || plat->devtype == DEV_IMX8 ||
@@ -445,7 +445,7 @@ static int lpuart_serial_setbrg(struct udevice *dev, int baudrate)
 
 static int lpuart_serial_getc(struct udevice *dev)
 {
-	struct lpuart_serial_platdata *plat = dev->plat;
+	struct lpuart_serial_plat *plat = dev->plat;
 
 	if (is_lpuart32(dev))
 		return _lpuart32_serial_getc(plat);
@@ -455,7 +455,7 @@ static int lpuart_serial_getc(struct udevice *dev)
 
 static int lpuart_serial_putc(struct udevice *dev, const char c)
 {
-	struct lpuart_serial_platdata *plat = dev->plat;
+	struct lpuart_serial_plat *plat = dev->plat;
 
 	if (is_lpuart32(dev))
 		_lpuart32_serial_putc(plat, c);
@@ -467,7 +467,7 @@ static int lpuart_serial_putc(struct udevice *dev, const char c)
 
 static int lpuart_serial_pending(struct udevice *dev, bool input)
 {
-	struct lpuart_serial_platdata *plat = dev->plat;
+	struct lpuart_serial_plat *plat = dev->plat;
 	struct lpuart_fsl *reg = plat->reg;
 	struct lpuart_fsl_reg32 *reg32 = plat->reg;
 	u32 stat;
@@ -513,7 +513,7 @@ static int lpuart_serial_probe(struct udevice *dev)
 
 static int lpuart_serial_of_to_plat(struct udevice *dev)
 {
-	struct lpuart_serial_platdata *plat = dev->plat;
+	struct lpuart_serial_plat *plat = dev->plat;
 	const void *blob = gd->fdt_blob;
 	int node = dev_of_offset(dev);
 	fdt_addr_t addr;
@@ -567,7 +567,7 @@ U_BOOT_DRIVER(serial_lpuart) = {
 	.id	= UCLASS_SERIAL,
 	.of_match = lpuart_serial_ids,
 	.of_to_plat = lpuart_serial_of_to_plat,
-	.plat_auto	= sizeof(struct lpuart_serial_platdata),
+	.plat_auto	= sizeof(struct lpuart_serial_plat),
 	.probe = lpuart_serial_probe,
 	.ops	= &lpuart_serial_ops,
 };
diff --git a/drivers/serial/serial_mcf.c b/drivers/serial/serial_mcf.c
index 12b2df2e56..a78a7ec6f8 100644
--- a/drivers/serial/serial_mcf.c
+++ b/drivers/serial/serial_mcf.c
@@ -83,7 +83,7 @@ static void mcf_serial_setbrg_common(uart_t *uart, int baudrate)
 
 static int coldfire_serial_probe(struct udevice *dev)
 {
-	struct coldfire_serial_platdata *plat = dev->plat;
+	struct coldfire_serial_plat *plat = dev->plat;
 
 	plat->port = dev->seq;
 
@@ -93,7 +93,7 @@ static int coldfire_serial_probe(struct udevice *dev)
 
 static int coldfire_serial_putc(struct udevice *dev, const char ch)
 {
-	struct coldfire_serial_platdata *plat = dev->plat;
+	struct coldfire_serial_plat *plat = dev->plat;
 	uart_t *uart = (uart_t *)plat->base;
 
 	/* Wait for last character to go. */
@@ -107,7 +107,7 @@ static int coldfire_serial_putc(struct udevice *dev, const char ch)
 
 static int coldfire_serial_getc(struct udevice *dev)
 {
-	struct coldfire_serial_platdata *plat = dev->plat;
+	struct coldfire_serial_plat *plat = dev->plat;
 	uart_t *uart = (uart_t *)(plat->base);
 
 	/* Wait for a character to arrive. */
@@ -119,7 +119,7 @@ static int coldfire_serial_getc(struct udevice *dev)
 
 int coldfire_serial_setbrg(struct udevice *dev, int baudrate)
 {
-	struct coldfire_serial_platdata *plat = dev->plat;
+	struct coldfire_serial_plat *plat = dev->plat;
 	uart_t *uart = (uart_t *)(plat->base);
 
 	mcf_serial_setbrg_common(uart, baudrate);
@@ -129,7 +129,7 @@ int coldfire_serial_setbrg(struct udevice *dev, int baudrate)
 
 static int coldfire_serial_pending(struct udevice *dev, bool input)
 {
-	struct coldfire_serial_platdata *plat = dev->plat;
+	struct coldfire_serial_plat *plat = dev->plat;
 	uart_t *uart = (uart_t *)(plat->base);
 
 	if (input)
@@ -142,7 +142,7 @@ static int coldfire_serial_pending(struct udevice *dev, bool input)
 
 static int coldfire_of_to_plat(struct udevice *dev)
 {
-	struct coldfire_serial_platdata *plat = dev_get_plat(dev);
+	struct coldfire_serial_plat *plat = dev_get_plat(dev);
 	fdt_addr_t addr_base;
 
 	addr_base = dev_read_addr(dev);
@@ -172,7 +172,7 @@ U_BOOT_DRIVER(serial_coldfire) = {
 	.id = UCLASS_SERIAL,
 	.of_match = coldfire_serial_ids,
 	.of_to_plat = coldfire_of_to_plat,
-	.plat_auto	= sizeof(struct coldfire_serial_platdata),
+	.plat_auto	= sizeof(struct coldfire_serial_plat),
 	.probe = coldfire_serial_probe,
 	.ops = &coldfire_serial_ops,
 	.flags = DM_FLAG_PRE_RELOC,
diff --git a/drivers/serial/serial_meson.c b/drivers/serial/serial_meson.c
index ac3727d1c2..40d9bfe7c6 100644
--- a/drivers/serial/serial_meson.c
+++ b/drivers/serial/serial_meson.c
@@ -19,7 +19,7 @@ struct meson_uart {
 	u32 misc;
 };
 
-struct meson_serial_platdata {
+struct meson_serial_plat {
 	struct meson_uart *reg;
 };
 
@@ -57,7 +57,7 @@ static void meson_serial_init(struct meson_uart *uart)
 
 static int meson_serial_probe(struct udevice *dev)
 {
-	struct meson_serial_platdata *plat = dev->plat;
+	struct meson_serial_plat *plat = dev->plat;
 	struct meson_uart *const uart = plat->reg;
 
 	meson_serial_init(uart);
@@ -67,7 +67,7 @@ static int meson_serial_probe(struct udevice *dev)
 
 static void meson_serial_rx_error(struct udevice *dev)
 {
-	struct meson_serial_platdata *plat = dev->plat;
+	struct meson_serial_plat *plat = dev->plat;
 	struct meson_uart *const uart = plat->reg;
 	u32 val = readl(&uart->control);
 
@@ -83,7 +83,7 @@ static void meson_serial_rx_error(struct udevice *dev)
 
 static int meson_serial_getc(struct udevice *dev)
 {
-	struct meson_serial_platdata *plat = dev->plat;
+	struct meson_serial_plat *plat = dev->plat;
 	struct meson_uart *const uart = plat->reg;
 	uint32_t status = readl(&uart->status);
 
@@ -100,7 +100,7 @@ static int meson_serial_getc(struct udevice *dev)
 
 static int meson_serial_putc(struct udevice *dev, const char ch)
 {
-	struct meson_serial_platdata *plat = dev->plat;
+	struct meson_serial_plat *plat = dev->plat;
 	struct meson_uart *const uart = plat->reg;
 
 	if (readl(&uart->status) & AML_UART_TX_FULL)
@@ -113,7 +113,7 @@ static int meson_serial_putc(struct udevice *dev, const char ch)
 
 static int meson_serial_pending(struct udevice *dev, bool input)
 {
-	struct meson_serial_platdata *plat = dev->plat;
+	struct meson_serial_plat *plat = dev->plat;
 	struct meson_uart *const uart = plat->reg;
 	uint32_t status = readl(&uart->status);
 
@@ -138,7 +138,7 @@ static int meson_serial_pending(struct udevice *dev, bool input)
 
 static int meson_serial_of_to_plat(struct udevice *dev)
 {
-	struct meson_serial_platdata *plat = dev->plat;
+	struct meson_serial_plat *plat = dev->plat;
 	fdt_addr_t addr;
 
 	addr = dev_read_addr(dev);
@@ -169,7 +169,7 @@ U_BOOT_DRIVER(serial_meson) = {
 	.probe		= meson_serial_probe,
 	.ops		= &meson_serial_ops,
 	.of_to_plat = meson_serial_of_to_plat,
-	.plat_auto	= sizeof(struct meson_serial_platdata),
+	.plat_auto	= sizeof(struct meson_serial_plat),
 };
 
 #ifdef CONFIG_DEBUG_UART_MESON
diff --git a/drivers/serial/serial_mvebu_a3700.c b/drivers/serial/serial_mvebu_a3700.c
index f4676f0b8e..5a1d40e0a6 100644
--- a/drivers/serial/serial_mvebu_a3700.c
+++ b/drivers/serial/serial_mvebu_a3700.c
@@ -8,7 +8,7 @@
 #include <serial.h>
 #include <asm/io.h>
 
-struct mvebu_platdata {
+struct mvebu_plat {
 	void __iomem *base;
 };
 
@@ -32,7 +32,7 @@ struct mvebu_platdata {
 
 static int mvebu_serial_putc(struct udevice *dev, const char ch)
 {
-	struct mvebu_platdata *plat = dev_get_plat(dev);
+	struct mvebu_plat *plat = dev_get_plat(dev);
 	void __iomem *base = plat->base;
 
 	while (readl(base + UART_STATUS_REG) & UART_STATUS_TXFIFO_FULL)
@@ -45,7 +45,7 @@ static int mvebu_serial_putc(struct udevice *dev, const char ch)
 
 static int mvebu_serial_getc(struct udevice *dev)
 {
-	struct mvebu_platdata *plat = dev_get_plat(dev);
+	struct mvebu_plat *plat = dev_get_plat(dev);
 	void __iomem *base = plat->base;
 
 	while (!(readl(base + UART_STATUS_REG) & UART_STATUS_RX_RDY))
@@ -56,7 +56,7 @@ static int mvebu_serial_getc(struct udevice *dev)
 
 static int mvebu_serial_pending(struct udevice *dev, bool input)
 {
-	struct mvebu_platdata *plat = dev_get_plat(dev);
+	struct mvebu_plat *plat = dev_get_plat(dev);
 	void __iomem *base = plat->base;
 
 	if (readl(base + UART_STATUS_REG) & UART_STATUS_RX_RDY)
@@ -67,7 +67,7 @@ static int mvebu_serial_pending(struct udevice *dev, bool input)
 
 static int mvebu_serial_setbrg(struct udevice *dev, int baudrate)
 {
-	struct mvebu_platdata *plat = dev_get_plat(dev);
+	struct mvebu_plat *plat = dev_get_plat(dev);
 	void __iomem *base = plat->base;
 
 	/*
@@ -87,7 +87,7 @@ static int mvebu_serial_setbrg(struct udevice *dev, int baudrate)
 
 static int mvebu_serial_probe(struct udevice *dev)
 {
-	struct mvebu_platdata *plat = dev_get_plat(dev);
+	struct mvebu_plat *plat = dev_get_plat(dev);
 	void __iomem *base = plat->base;
 
 	/* reset FIFOs */
@@ -102,7 +102,7 @@ static int mvebu_serial_probe(struct udevice *dev)
 
 static int mvebu_serial_of_to_plat(struct udevice *dev)
 {
-	struct mvebu_platdata *plat = dev_get_plat(dev);
+	struct mvebu_plat *plat = dev_get_plat(dev);
 
 	plat->base = dev_read_addr_ptr(dev);
 
@@ -126,7 +126,7 @@ U_BOOT_DRIVER(serial_mvebu) = {
 	.id	= UCLASS_SERIAL,
 	.of_match = mvebu_serial_ids,
 	.of_to_plat = mvebu_serial_of_to_plat,
-	.plat_auto	= sizeof(struct mvebu_platdata),
+	.plat_auto	= sizeof(struct mvebu_plat),
 	.probe	= mvebu_serial_probe,
 	.ops	= &mvebu_serial_ops,
 };
diff --git a/drivers/serial/serial_mxc.c b/drivers/serial/serial_mxc.c
index 9602ddc7e0..2603fa8611 100644
--- a/drivers/serial/serial_mxc.c
+++ b/drivers/serial/serial_mxc.c
@@ -264,7 +264,7 @@ __weak struct serial_device *default_serial_console(void)
 
 int mxc_serial_setbrg(struct udevice *dev, int baudrate)
 {
-	struct mxc_serial_platdata *plat = dev->plat;
+	struct mxc_serial_plat *plat = dev->plat;
 	u32 clk = imx_get_uartclk();
 
 	_mxc_serial_setbrg(plat->reg, clk, baudrate, plat->use_dte);
@@ -274,7 +274,7 @@ int mxc_serial_setbrg(struct udevice *dev, int baudrate)
 
 static int mxc_serial_probe(struct udevice *dev)
 {
-	struct mxc_serial_platdata *plat = dev->plat;
+	struct mxc_serial_plat *plat = dev->plat;
 
 	_mxc_serial_init(plat->reg, plat->use_dte);
 
@@ -283,7 +283,7 @@ static int mxc_serial_probe(struct udevice *dev)
 
 static int mxc_serial_getc(struct udevice *dev)
 {
-	struct mxc_serial_platdata *plat = dev->plat;
+	struct mxc_serial_plat *plat = dev->plat;
 	struct mxc_uart *const uart = plat->reg;
 
 	if (readl(&uart->ts) & UTS_RXEMPTY)
@@ -294,7 +294,7 @@ static int mxc_serial_getc(struct udevice *dev)
 
 static int mxc_serial_putc(struct udevice *dev, const char ch)
 {
-	struct mxc_serial_platdata *plat = dev->plat;
+	struct mxc_serial_plat *plat = dev->plat;
 	struct mxc_uart *const uart = plat->reg;
 
 	if (!(readl(&uart->ts) & UTS_TXEMPTY))
@@ -307,7 +307,7 @@ static int mxc_serial_putc(struct udevice *dev, const char ch)
 
 static int mxc_serial_pending(struct udevice *dev, bool input)
 {
-	struct mxc_serial_platdata *plat = dev->plat;
+	struct mxc_serial_plat *plat = dev->plat;
 	struct mxc_uart *const uart = plat->reg;
 	uint32_t sr2 = readl(&uart->sr2);
 
@@ -327,7 +327,7 @@ static const struct dm_serial_ops mxc_serial_ops = {
 #if CONFIG_IS_ENABLED(OF_CONTROL)
 static int mxc_serial_of_to_plat(struct udevice *dev)
 {
-	struct mxc_serial_platdata *plat = dev->plat;
+	struct mxc_serial_plat *plat = dev->plat;
 	fdt_addr_t addr;
 
 	addr = dev_read_addr(dev);
@@ -358,7 +358,7 @@ U_BOOT_DRIVER(serial_mxc) = {
 #if CONFIG_IS_ENABLED(OF_CONTROL)
 	.of_match = mxc_serial_ids,
 	.of_to_plat = mxc_serial_of_to_plat,
-	.plat_auto	= sizeof(struct mxc_serial_platdata),
+	.plat_auto	= sizeof(struct mxc_serial_plat),
 #endif
 	.probe = mxc_serial_probe,
 	.ops	= &mxc_serial_ops,
diff --git a/drivers/serial/serial_omap.c b/drivers/serial/serial_omap.c
index 2b0a3e4d06..2f38e1b890 100644
--- a/drivers/serial/serial_omap.c
+++ b/drivers/serial/serial_omap.c
@@ -101,7 +101,7 @@ DEBUG_UART_FUNCS
 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
 static int omap_serial_of_to_plat(struct udevice *dev)
 {
-	struct ns16550_platdata *plat = dev->plat;
+	struct ns16550_plat *plat = dev->plat;
 	fdt_addr_t addr;
 	struct clk clk;
 	int err;
@@ -158,7 +158,7 @@ U_BOOT_DRIVER(omap_serial) = {
 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
 	.of_match = omap_serial_ids,
 	.of_to_plat = omap_serial_of_to_plat,
-	.plat_auto	= sizeof(struct ns16550_platdata),
+	.plat_auto	= sizeof(struct ns16550_plat),
 #endif
 	.priv_auto	= sizeof(struct NS16550),
 	.probe = ns16550_serial_probe,
diff --git a/drivers/serial/serial_pl01x.c b/drivers/serial/serial_pl01x.c
index 45bc1de059..b21e943d21 100644
--- a/drivers/serial/serial_pl01x.c
+++ b/drivers/serial/serial_pl01x.c
@@ -281,7 +281,7 @@ __weak struct serial_device *default_serial_console(void)
 
 int pl01x_serial_setbrg(struct udevice *dev, int baudrate)
 {
-	struct pl01x_serial_platdata *plat = dev_get_plat(dev);
+	struct pl01x_serial_plat *plat = dev_get_plat(dev);
 	struct pl01x_priv *priv = dev_get_priv(dev);
 
 	if (!plat->skip_init) {
@@ -294,7 +294,7 @@ int pl01x_serial_setbrg(struct udevice *dev, int baudrate)
 
 int pl01x_serial_probe(struct udevice *dev)
 {
-	struct pl01x_serial_platdata *plat = dev_get_plat(dev);
+	struct pl01x_serial_plat *plat = dev_get_plat(dev);
 	struct pl01x_priv *priv = dev_get_priv(dev);
 
 	priv->regs = (struct pl01x_regs *)plat->base;
@@ -350,7 +350,7 @@ static const struct udevice_id pl01x_serial_id[] ={
 
 int pl01x_serial_of_to_plat(struct udevice *dev)
 {
-	struct pl01x_serial_platdata *plat = dev_get_plat(dev);
+	struct pl01x_serial_plat *plat = dev_get_plat(dev);
 	struct clk clk;
 	fdt_addr_t addr;
 	int ret;
@@ -388,7 +388,7 @@ U_BOOT_DRIVER(serial_pl01x) = {
 	.id	= UCLASS_SERIAL,
 	.of_match = of_match_ptr(pl01x_serial_id),
 	.of_to_plat = of_match_ptr(pl01x_serial_of_to_plat),
-	.plat_auto	= sizeof(struct pl01x_serial_platdata),
+	.plat_auto	= sizeof(struct pl01x_serial_plat),
 	.probe = pl01x_serial_probe,
 	.ops	= &pl01x_serial_ops,
 	.flags = DM_FLAG_PRE_RELOC,
diff --git a/drivers/serial/serial_pxa.c b/drivers/serial/serial_pxa.c
index 232218dcdc..d82f3b9752 100644
--- a/drivers/serial/serial_pxa.c
+++ b/drivers/serial/serial_pxa.c
@@ -268,7 +268,7 @@ void pxa_serial_initialize(void)
 #ifdef CONFIG_DM_SERIAL
 static int pxa_serial_probe(struct udevice *dev)
 {
-	struct pxa_serial_platdata *plat = dev->plat;
+	struct pxa_serial_plat *plat = dev->plat;
 
 	pxa_setbrg_common((struct pxa_uart_regs *)plat->base, plat->port,
 			  plat->baudrate);
@@ -277,7 +277,7 @@ static int pxa_serial_probe(struct udevice *dev)
 
 static int pxa_serial_putc(struct udevice *dev, const char ch)
 {
-	struct pxa_serial_platdata *plat = dev->plat;
+	struct pxa_serial_plat *plat = dev->plat;
 	struct pxa_uart_regs *uart_regs = (struct pxa_uart_regs *)plat->base;
 
 	/* Wait for last character to go. */
@@ -291,7 +291,7 @@ static int pxa_serial_putc(struct udevice *dev, const char ch)
 
 static int pxa_serial_getc(struct udevice *dev)
 {
-	struct pxa_serial_platdata *plat = dev->plat;
+	struct pxa_serial_plat *plat = dev->plat;
 	struct pxa_uart_regs *uart_regs = (struct pxa_uart_regs *)plat->base;
 
 	/* Wait for a character to arrive. */
@@ -303,7 +303,7 @@ static int pxa_serial_getc(struct udevice *dev)
 
 int pxa_serial_setbrg(struct udevice *dev, int baudrate)
 {
-	struct pxa_serial_platdata *plat = dev->plat;
+	struct pxa_serial_plat *plat = dev->plat;
 	struct pxa_uart_regs *uart_regs = (struct pxa_uart_regs *)plat->base;
 	int port = plat->port;
 
@@ -314,7 +314,7 @@ int pxa_serial_setbrg(struct udevice *dev, int baudrate)
 
 static int pxa_serial_pending(struct udevice *dev, bool input)
 {
-	struct pxa_serial_platdata *plat = dev->plat;
+	struct pxa_serial_plat *plat = dev->plat;
 	struct pxa_uart_regs *uart_regs = (struct pxa_uart_regs *)plat->base;
 
 	if (input)
diff --git a/drivers/serial/serial_rockchip.c b/drivers/serial/serial_rockchip.c
index 930103a42c..4c0548ed0f 100644
--- a/drivers/serial/serial_rockchip.c
+++ b/drivers/serial/serial_rockchip.c
@@ -12,22 +12,22 @@
 #include <asm/arch-rockchip/clock.h>
 
 #if defined(CONFIG_ROCKCHIP_RK3188)
-struct rockchip_uart_platdata {
+struct rockchip_uart_plat {
 	struct dtd_rockchip_rk3188_uart dtplat;
-	struct ns16550_platdata plat;
+	struct ns16550_plat plat;
 };
 struct dtd_rockchip_rk3188_uart *dtplat, s_dtplat;
 #elif defined(CONFIG_ROCKCHIP_RK3288)
-struct rockchip_uart_platdata {
+struct rockchip_uart_plat {
 	struct dtd_rockchip_rk3288_uart dtplat;
-	struct ns16550_platdata plat;
+	struct ns16550_plat plat;
 };
 struct dtd_rockchip_rk3288_uart *dtplat, s_dtplat;
 #endif
 
 static int rockchip_serial_probe(struct udevice *dev)
 {
-	struct rockchip_uart_platdata *plat = dev_get_plat(dev);
+	struct rockchip_uart_plat *plat = dev_get_plat(dev);
 
 	/* Create some new platform data for the standard driver */
 	plat->plat.base = plat->dtplat.reg[0];
@@ -43,7 +43,7 @@ U_BOOT_DRIVER(rockchip_rk3188_uart) = {
 	.name	= "rockchip_rk3188_uart",
 	.id	= UCLASS_SERIAL,
 	.priv_auto	= sizeof(struct NS16550),
-	.plat_auto	= sizeof(struct rockchip_uart_platdata),
+	.plat_auto	= sizeof(struct rockchip_uart_plat),
 	.probe	= rockchip_serial_probe,
 	.ops	= &ns16550_serial_ops,
 	.flags	= DM_FLAG_PRE_RELOC,
@@ -53,7 +53,7 @@ U_BOOT_DRIVER(rockchip_rk3288_uart) = {
 	.name	= "rockchip_rk3288_uart",
 	.id	= UCLASS_SERIAL,
 	.priv_auto	= sizeof(struct NS16550),
-	.plat_auto	= sizeof(struct rockchip_uart_platdata),
+	.plat_auto	= sizeof(struct rockchip_uart_plat),
 	.probe	= rockchip_serial_probe,
 	.ops	= &ns16550_serial_ops,
 	.flags	= DM_FLAG_PRE_RELOC,
diff --git a/drivers/serial/serial_s5p.c b/drivers/serial/serial_s5p.c
index 5a333c4bb0..e328fb6538 100644
--- a/drivers/serial/serial_s5p.c
+++ b/drivers/serial/serial_s5p.c
@@ -28,7 +28,7 @@ DECLARE_GLOBAL_DATA_PTR;
 #define TX_FIFO_FULL		(1 << 24)
 
 /* Information about a serial port */
-struct s5p_serial_platdata {
+struct s5p_serial_plat {
 	struct s5p_uart *reg;  /* address of registers in physical memory */
 	u8 port_id;     /* uart port number */
 };
@@ -88,7 +88,7 @@ static void __maybe_unused s5p_serial_baud(struct s5p_uart *uart, uint uclk,
 #ifndef CONFIG_SPL_BUILD
 int s5p_serial_setbrg(struct udevice *dev, int baudrate)
 {
-	struct s5p_serial_platdata *plat = dev->plat;
+	struct s5p_serial_plat *plat = dev->plat;
 	struct s5p_uart *const uart = plat->reg;
 	u32 uclk;
 
@@ -111,7 +111,7 @@ int s5p_serial_setbrg(struct udevice *dev, int baudrate)
 
 static int s5p_serial_probe(struct udevice *dev)
 {
-	struct s5p_serial_platdata *plat = dev->plat;
+	struct s5p_serial_plat *plat = dev->plat;
 	struct s5p_uart *const uart = plat->reg;
 
 	s5p_serial_init(uart);
@@ -140,7 +140,7 @@ static int serial_err_check(const struct s5p_uart *const uart, int op)
 
 static int s5p_serial_getc(struct udevice *dev)
 {
-	struct s5p_serial_platdata *plat = dev->plat;
+	struct s5p_serial_plat *plat = dev->plat;
 	struct s5p_uart *const uart = plat->reg;
 
 	if (!(readl(&uart->ufstat) & RX_FIFO_COUNT_MASK))
@@ -152,7 +152,7 @@ static int s5p_serial_getc(struct udevice *dev)
 
 static int s5p_serial_putc(struct udevice *dev, const char ch)
 {
-	struct s5p_serial_platdata *plat = dev->plat;
+	struct s5p_serial_plat *plat = dev->plat;
 	struct s5p_uart *const uart = plat->reg;
 
 	if (readl(&uart->ufstat) & TX_FIFO_FULL)
@@ -166,7 +166,7 @@ static int s5p_serial_putc(struct udevice *dev, const char ch)
 
 static int s5p_serial_pending(struct udevice *dev, bool input)
 {
-	struct s5p_serial_platdata *plat = dev->plat;
+	struct s5p_serial_plat *plat = dev->plat;
 	struct s5p_uart *const uart = plat->reg;
 	uint32_t ufstat = readl(&uart->ufstat);
 
@@ -178,7 +178,7 @@ static int s5p_serial_pending(struct udevice *dev, bool input)
 
 static int s5p_serial_of_to_plat(struct udevice *dev)
 {
-	struct s5p_serial_platdata *plat = dev->plat;
+	struct s5p_serial_plat *plat = dev->plat;
 	fdt_addr_t addr;
 
 	addr = dev_read_addr(dev);
@@ -208,7 +208,7 @@ U_BOOT_DRIVER(serial_s5p) = {
 	.id	= UCLASS_SERIAL,
 	.of_match = s5p_serial_ids,
 	.of_to_plat = s5p_serial_of_to_plat,
-	.plat_auto	= sizeof(struct s5p_serial_platdata),
+	.plat_auto	= sizeof(struct s5p_serial_plat),
 	.probe = s5p_serial_probe,
 	.ops	= &s5p_serial_ops,
 };
diff --git a/drivers/serial/serial_sh.c b/drivers/serial/serial_sh.c
index a961ead1d4..d74f890233 100644
--- a/drivers/serial/serial_sh.c
+++ b/drivers/serial/serial_sh.c
@@ -169,7 +169,7 @@ static int sh_serial_getc(struct udevice *dev)
 
 static int sh_serial_setbrg(struct udevice *dev, int baudrate)
 {
-	struct sh_serial_platdata *plat = dev_get_plat(dev);
+	struct sh_serial_plat *plat = dev_get_plat(dev);
 	struct uart_port *priv = dev_get_priv(dev);
 
 	sh_serial_setbrg_generic(priv, plat->clk, baudrate);
@@ -179,7 +179,7 @@ static int sh_serial_setbrg(struct udevice *dev, int baudrate)
 
 static int sh_serial_probe(struct udevice *dev)
 {
-	struct sh_serial_platdata *plat = dev_get_plat(dev);
+	struct sh_serial_plat *plat = dev_get_plat(dev);
 	struct uart_port *priv = dev_get_priv(dev);
 
 	priv->membase	= (unsigned char *)plat->base;
@@ -209,7 +209,7 @@ static const struct udevice_id sh_serial_id[] ={
 
 static int sh_serial_of_to_plat(struct udevice *dev)
 {
-	struct sh_serial_platdata *plat = dev_get_plat(dev);
+	struct sh_serial_plat *plat = dev_get_plat(dev);
 	struct clk sh_serial_clk;
 	fdt_addr_t addr;
 	int ret;
@@ -240,7 +240,7 @@ U_BOOT_DRIVER(serial_sh) = {
 	.id	= UCLASS_SERIAL,
 	.of_match = of_match_ptr(sh_serial_id),
 	.of_to_plat = of_match_ptr(sh_serial_of_to_plat),
-	.plat_auto	= sizeof(struct sh_serial_platdata),
+	.plat_auto	= sizeof(struct sh_serial_plat),
 	.probe	= sh_serial_probe,
 	.ops	= &sh_serial_ops,
 #if !CONFIG_IS_ENABLED(OF_CONTROL)
diff --git a/drivers/serial/serial_sifive.c b/drivers/serial/serial_sifive.c
index 5248c6814c..d26fe7e770 100644
--- a/drivers/serial/serial_sifive.c
+++ b/drivers/serial/serial_sifive.c
@@ -37,7 +37,7 @@ struct uart_sifive {
 	u32 div;
 };
 
-struct sifive_uart_platdata {
+struct sifive_uart_plat {
 	unsigned long clock;
 	struct uart_sifive *regs;
 };
@@ -105,7 +105,7 @@ static int sifive_serial_setbrg(struct udevice *dev, int baudrate)
 {
 	int ret;
 	struct clk clk;
-	struct sifive_uart_platdata *plat = dev_get_plat(dev);
+	struct sifive_uart_plat *plat = dev_get_plat(dev);
 	u32 clock = 0;
 
 	ret = clk_get_by_index(dev, 0, &clk);
@@ -131,7 +131,7 @@ static int sifive_serial_setbrg(struct udevice *dev, int baudrate)
 
 static int sifive_serial_probe(struct udevice *dev)
 {
-	struct sifive_uart_platdata *plat = dev_get_plat(dev);
+	struct sifive_uart_plat *plat = dev_get_plat(dev);
 
 	/* No need to reinitialize the UART after relocation */
 	if (gd->flags & GD_FLG_RELOC)
@@ -145,7 +145,7 @@ static int sifive_serial_probe(struct udevice *dev)
 static int sifive_serial_getc(struct udevice *dev)
 {
 	int c;
-	struct sifive_uart_platdata *plat = dev_get_plat(dev);
+	struct sifive_uart_plat *plat = dev_get_plat(dev);
 	struct uart_sifive *regs = plat->regs;
 
 	while ((c = _sifive_serial_getc(regs)) == -EAGAIN) ;
@@ -156,7 +156,7 @@ static int sifive_serial_getc(struct udevice *dev)
 static int sifive_serial_putc(struct udevice *dev, const char ch)
 {
 	int rc;
-	struct sifive_uart_platdata *plat = dev_get_plat(dev);
+	struct sifive_uart_plat *plat = dev_get_plat(dev);
 
 	while ((rc = _sifive_serial_putc(plat->regs, ch)) == -EAGAIN) ;
 
@@ -165,7 +165,7 @@ static int sifive_serial_putc(struct udevice *dev, const char ch)
 
 static int sifive_serial_pending(struct udevice *dev, bool input)
 {
-	struct sifive_uart_platdata *plat = dev_get_plat(dev);
+	struct sifive_uart_plat *plat = dev_get_plat(dev);
 	struct uart_sifive *regs = plat->regs;
 
 	if (input)
@@ -176,7 +176,7 @@ static int sifive_serial_pending(struct udevice *dev, bool input)
 
 static int sifive_serial_of_to_plat(struct udevice *dev)
 {
-	struct sifive_uart_platdata *plat = dev_get_plat(dev);
+	struct sifive_uart_plat *plat = dev_get_plat(dev);
 
 	plat->regs = (struct uart_sifive *)dev_read_addr(dev);
 	if (IS_ERR(plat->regs))
@@ -202,7 +202,7 @@ U_BOOT_DRIVER(serial_sifive) = {
 	.id	= UCLASS_SERIAL,
 	.of_match = sifive_serial_ids,
 	.of_to_plat = sifive_serial_of_to_plat,
-	.plat_auto	= sizeof(struct sifive_uart_platdata),
+	.plat_auto	= sizeof(struct sifive_uart_plat),
 	.probe = sifive_serial_probe,
 	.ops	= &sifive_serial_ops,
 };
diff --git a/drivers/serial/serial_stm32.c b/drivers/serial/serial_stm32.c
index 63344b3418..818c34cf11 100644
--- a/drivers/serial/serial_stm32.c
+++ b/drivers/serial/serial_stm32.c
@@ -44,7 +44,7 @@ static void _stm32_serial_setbrg(fdt_addr_t base,
 
 static int stm32_serial_setbrg(struct udevice *dev, int baudrate)
 {
-	struct stm32x7_serial_platdata *plat = dev_get_plat(dev);
+	struct stm32x7_serial_plat *plat = dev_get_plat(dev);
 
 	_stm32_serial_setbrg(plat->base, plat->uart_info,
 			     plat->clock_rate, baudrate);
@@ -54,7 +54,7 @@ static int stm32_serial_setbrg(struct udevice *dev, int baudrate)
 
 static int stm32_serial_setconfig(struct udevice *dev, uint serial_config)
 {
-	struct stm32x7_serial_platdata *plat = dev_get_plat(dev);
+	struct stm32x7_serial_plat *plat = dev_get_plat(dev);
 	bool stm32f4 = plat->uart_info->stm32f4;
 	u8 uart_enable_bit = plat->uart_info->uart_enable_bit;
 	u32 cr1 = plat->base + CR1_OFFSET(stm32f4);
@@ -102,7 +102,7 @@ static int stm32_serial_setconfig(struct udevice *dev, uint serial_config)
 
 static int stm32_serial_getc(struct udevice *dev)
 {
-	struct stm32x7_serial_platdata *plat = dev_get_plat(dev);
+	struct stm32x7_serial_plat *plat = dev_get_plat(dev);
 	bool stm32f4 = plat->uart_info->stm32f4;
 	fdt_addr_t base = plat->base;
 	u32 isr = readl(base + ISR_OFFSET(stm32f4));
@@ -139,14 +139,14 @@ static int _stm32_serial_putc(fdt_addr_t base,
 
 static int stm32_serial_putc(struct udevice *dev, const char c)
 {
-	struct stm32x7_serial_platdata *plat = dev_get_plat(dev);
+	struct stm32x7_serial_plat *plat = dev_get_plat(dev);
 
 	return _stm32_serial_putc(plat->base, plat->uart_info, c);
 }
 
 static int stm32_serial_pending(struct udevice *dev, bool input)
 {
-	struct stm32x7_serial_platdata *plat = dev_get_plat(dev);
+	struct stm32x7_serial_plat *plat = dev_get_plat(dev);
 	bool stm32f4 = plat->uart_info->stm32f4;
 	fdt_addr_t base = plat->base;
 
@@ -175,7 +175,7 @@ static void _stm32_serial_init(fdt_addr_t base,
 
 static int stm32_serial_probe(struct udevice *dev)
 {
-	struct stm32x7_serial_platdata *plat = dev_get_plat(dev);
+	struct stm32x7_serial_plat *plat = dev_get_plat(dev);
 	struct clk clk;
 	struct reset_ctl reset;
 	int ret;
@@ -219,7 +219,7 @@ static const struct udevice_id stm32_serial_id[] = {
 
 static int stm32_serial_of_to_plat(struct udevice *dev)
 {
-	struct stm32x7_serial_platdata *plat = dev_get_plat(dev);
+	struct stm32x7_serial_plat *plat = dev_get_plat(dev);
 
 	plat->base = dev_read_addr(dev);
 	if (plat->base == FDT_ADDR_T_NONE)
@@ -241,7 +241,7 @@ U_BOOT_DRIVER(serial_stm32) = {
 	.id = UCLASS_SERIAL,
 	.of_match = of_match_ptr(stm32_serial_id),
 	.of_to_plat = of_match_ptr(stm32_serial_of_to_plat),
-	.plat_auto	= sizeof(struct stm32x7_serial_platdata),
+	.plat_auto	= sizeof(struct stm32x7_serial_plat),
 	.ops = &stm32_serial_ops,
 	.probe = stm32_serial_probe,
 #if !CONFIG_IS_ENABLED(OF_CONTROL)
diff --git a/drivers/serial/serial_stm32.h b/drivers/serial/serial_stm32.h
index 5737651888..5bee68fa9c 100644
--- a/drivers/serial/serial_stm32.h
+++ b/drivers/serial/serial_stm32.h
@@ -48,7 +48,7 @@ struct stm32_uart_info stm32h7_info = {
 };
 
 /* Information about a serial port */
-struct stm32x7_serial_platdata {
+struct stm32x7_serial_plat {
 	fdt_addr_t base;  /* address of registers in physical memory */
 	struct stm32_uart_info *uart_info;
 	unsigned long int clock_rate;
diff --git a/drivers/serial/serial_xuartlite.c b/drivers/serial/serial_xuartlite.c
index df4877a0b9..0efdc93c60 100644
--- a/drivers/serial/serial_xuartlite.c
+++ b/drivers/serial/serial_xuartlite.c
@@ -32,7 +32,7 @@ struct uartlite {
 	unsigned int control;
 };
 
-struct uartlite_platdata {
+struct uartlite_plat {
 	struct uartlite *regs;
 };
 
@@ -54,7 +54,7 @@ static void uart_out32(void __iomem *addr, u32 val)
 
 static int uartlite_serial_putc(struct udevice *dev, const char ch)
 {
-	struct uartlite_platdata *plat = dev_get_plat(dev);
+	struct uartlite_plat *plat = dev_get_plat(dev);
 	struct uartlite *regs = plat->regs;
 
 	if (uart_in32(&regs->status) & SR_TX_FIFO_FULL)
@@ -67,7 +67,7 @@ static int uartlite_serial_putc(struct udevice *dev, const char ch)
 
 static int uartlite_serial_getc(struct udevice *dev)
 {
-	struct uartlite_platdata *plat = dev_get_plat(dev);
+	struct uartlite_plat *plat = dev_get_plat(dev);
 	struct uartlite *regs = plat->regs;
 
 	if (!(uart_in32(&regs->status) & SR_RX_FIFO_VALID_DATA))
@@ -78,7 +78,7 @@ static int uartlite_serial_getc(struct udevice *dev)
 
 static int uartlite_serial_pending(struct udevice *dev, bool input)
 {
-	struct uartlite_platdata *plat = dev_get_plat(dev);
+	struct uartlite_plat *plat = dev_get_plat(dev);
 	struct uartlite *regs = plat->regs;
 
 	if (input)
@@ -89,7 +89,7 @@ static int uartlite_serial_pending(struct udevice *dev, bool input)
 
 static int uartlite_serial_probe(struct udevice *dev)
 {
-	struct uartlite_platdata *plat = dev_get_plat(dev);
+	struct uartlite_plat *plat = dev_get_plat(dev);
 	struct uartlite *regs = plat->regs;
 	int ret;
 
@@ -108,7 +108,7 @@ static int uartlite_serial_probe(struct udevice *dev)
 
 static int uartlite_serial_of_to_plat(struct udevice *dev)
 {
-	struct uartlite_platdata *plat = dev_get_plat(dev);
+	struct uartlite_plat *plat = dev_get_plat(dev);
 
 	plat->regs = dev_read_addr_ptr(dev);
 
@@ -132,7 +132,7 @@ U_BOOT_DRIVER(serial_uartlite) = {
 	.id	= UCLASS_SERIAL,
 	.of_match = uartlite_serial_ids,
 	.of_to_plat = uartlite_serial_of_to_plat,
-	.plat_auto	= sizeof(struct uartlite_platdata),
+	.plat_auto	= sizeof(struct uartlite_plat),
 	.probe = uartlite_serial_probe,
 	.ops	= &uartlite_serial_ops,
 };
diff --git a/drivers/serial/serial_zynq.c b/drivers/serial/serial_zynq.c
index 1d748e16ee..2883e2466f 100644
--- a/drivers/serial/serial_zynq.c
+++ b/drivers/serial/serial_zynq.c
@@ -41,7 +41,7 @@ struct uart_zynq {
 	u32 baud_rate_divider; /* 0x34 - Baud Rate Divider [7:0] */
 };
 
-struct zynq_uart_platdata {
+struct zynq_uart_plat {
 	struct uart_zynq *regs;
 };
 
@@ -107,7 +107,7 @@ static int _uart_zynq_serial_putc(struct uart_zynq *regs, const char c)
 
 static int zynq_serial_setbrg(struct udevice *dev, int baudrate)
 {
-	struct zynq_uart_platdata *plat = dev_get_plat(dev);
+	struct zynq_uart_plat *plat = dev_get_plat(dev);
 	unsigned long clock;
 
 	int ret;
@@ -139,7 +139,7 @@ static int zynq_serial_setbrg(struct udevice *dev, int baudrate)
 
 static int zynq_serial_probe(struct udevice *dev)
 {
-	struct zynq_uart_platdata *plat = dev_get_plat(dev);
+	struct zynq_uart_plat *plat = dev_get_plat(dev);
 	struct uart_zynq *regs = plat->regs;
 	u32 val;
 
@@ -155,7 +155,7 @@ static int zynq_serial_probe(struct udevice *dev)
 
 static int zynq_serial_getc(struct udevice *dev)
 {
-	struct zynq_uart_platdata *plat = dev_get_plat(dev);
+	struct zynq_uart_plat *plat = dev_get_plat(dev);
 	struct uart_zynq *regs = plat->regs;
 
 	if (readl(&regs->channel_sts) & ZYNQ_UART_SR_RXEMPTY)
@@ -166,14 +166,14 @@ static int zynq_serial_getc(struct udevice *dev)
 
 static int zynq_serial_putc(struct udevice *dev, const char ch)
 {
-	struct zynq_uart_platdata *plat = dev_get_plat(dev);
+	struct zynq_uart_plat *plat = dev_get_plat(dev);
 
 	return _uart_zynq_serial_putc(plat->regs, ch);
 }
 
 static int zynq_serial_pending(struct udevice *dev, bool input)
 {
-	struct zynq_uart_platdata *plat = dev_get_plat(dev);
+	struct zynq_uart_plat *plat = dev_get_plat(dev);
 	struct uart_zynq *regs = plat->regs;
 
 	if (input)
@@ -184,7 +184,7 @@ static int zynq_serial_pending(struct udevice *dev, bool input)
 
 static int zynq_serial_of_to_plat(struct udevice *dev)
 {
-	struct zynq_uart_platdata *plat = dev_get_plat(dev);
+	struct zynq_uart_plat *plat = dev_get_plat(dev);
 
 	plat->regs = (struct uart_zynq *)dev_read_addr(dev);
 	if (IS_ERR(plat->regs))
@@ -212,7 +212,7 @@ U_BOOT_DRIVER(serial_zynq) = {
 	.id	= UCLASS_SERIAL,
 	.of_match = zynq_serial_ids,
 	.of_to_plat = zynq_serial_of_to_plat,
-	.plat_auto	= sizeof(struct zynq_uart_platdata),
+	.plat_auto	= sizeof(struct zynq_uart_plat),
 	.probe = zynq_serial_probe,
 	.ops	= &zynq_serial_ops,
 };