dm: treewide: Rename 'platdata' variables to just 'plat'

We use 'priv' for private data but often use 'platdata' for platform data.
We can't really use 'pdata' since that is ambiguous (it could mean private
or platform data).

Rename some of the latter variables to end with 'plat' for consistency.

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

6 files changed, 85 insertions, 90 deletions

diff --git a/drivers/usb/musb-new/da8xx.c b/drivers/usb/musb-new/da8xx.c
index 6c0d0b8b16..2889e855ab 100644
--- a/drivers/usb/musb-new/da8xx.c
+++ b/drivers/usb/musb-new/da8xx.c
@@ -258,43 +258,43 @@ struct da8xx_musb_platdata {
 
 static int da8xx_musb_ofdata_to_platdata(struct udevice *dev)
 {
-	struct da8xx_musb_platdata *platdata = dev_get_platdata(dev);
+	struct da8xx_musb_platdata *plat = dev_get_platdata(dev);
 	const void *fdt = gd->fdt_blob;
 	int node = dev_of_offset(dev);
 
-	platdata->base = (void *)dev_read_addr_ptr(dev);
-	platdata->musb_config.multipoint = 1;
-	platdata->musb_config.dyn_fifo = 1;
-	platdata->musb_config.num_eps = 5;
-	platdata->musb_config.ram_bits = 10;
-	platdata->plat.power = fdtdec_get_int(fdt, node, "power", 50);
-	platdata->otg_board_data.interface_type = MUSB_INTERFACE_UTMI;
-	platdata->plat.mode = MUSB_HOST;
-	platdata->otg_board_data.dev = dev;
-	platdata->plat.config = &platdata->musb_config;
-	platdata->plat.platform_ops = &da8xx_ops;
-	platdata->plat.board_data = &platdata->otg_board_data;
-	platdata->otg_board_data.clear_irq = da8xx_musb_clear_irq;
-	platdata->otg_board_data.reset = da8xx_musb_reset;
+	plat->base = (void *)dev_read_addr_ptr(dev);
+	plat->musb_config.multipoint = 1;
+	plat->musb_config.dyn_fifo = 1;
+	plat->musb_config.num_eps = 5;
+	plat->musb_config.ram_bits = 10;
+	plat->plat.power = fdtdec_get_int(fdt, node, "power", 50);
+	plat->otg_board_data.interface_type = MUSB_INTERFACE_UTMI;
+	plat->plat.mode = MUSB_HOST;
+	plat->otg_board_data.dev = dev;
+	plat->plat.config = &plat->musb_config;
+	plat->plat.platform_ops = &da8xx_ops;
+	plat->plat.board_data = &plat->otg_board_data;
+	plat->otg_board_data.clear_irq = da8xx_musb_clear_irq;
+	plat->otg_board_data.reset = da8xx_musb_reset;
 	return 0;
 }
 
 static int da8xx_musb_probe(struct udevice *dev)
 {
 	struct musb_host_data *host = dev_get_priv(dev);
-	struct da8xx_musb_platdata *platdata = dev_get_platdata(dev);
+	struct da8xx_musb_platdata *plat = dev_get_platdata(dev);
 	struct usb_bus_priv *priv = dev_get_uclass_priv(dev);
 	struct omap_musb_board_data *otg_board_data;
 	int ret;
 	void *base = dev_read_addr_ptr(dev);
 
 	/* Get the phy info from the device tree */
-	ret = generic_phy_get_by_name(dev, "usb-phy", &platdata->phy);
+	ret = generic_phy_get_by_name(dev, "usb-phy", &plat->phy);
 	if (ret)
 		return ret;
 
 	/* Initialize the phy */
-	ret = generic_phy_init(&platdata->phy);
+	ret = generic_phy_init(&plat->phy);
 	if (ret)
 		return ret;
 
@@ -302,14 +302,14 @@ static int da8xx_musb_probe(struct udevice *dev)
 	lpsc_on(33);
 
 	/* Enable phy */
-	generic_phy_power_on(&platdata->phy);
+	generic_phy_power_on(&plat->phy);
 
 	priv->desc_before_addr = true;
-	otg_board_data = &platdata->otg_board_data;
+	otg_board_data = &plat->otg_board_data;
 
-	host->host = musb_init_controller(&platdata->plat,
+	host->host = musb_init_controller(&plat->plat,
 					  (struct device *)otg_board_data,
-					  platdata->base);
+					  plat->base);
 	if (!host->host) {
 		ret = -ENODEV;
 		goto shutdown; /* Shutdown what we started */
@@ -321,7 +321,7 @@ static int da8xx_musb_probe(struct udevice *dev)
 		return 0;
 shutdown:
 	/* Turn off the phy if we fail */
-	generic_phy_power_off(&platdata->phy);
+	generic_phy_power_off(&plat->phy);
 	lpsc_disable(33);
 	return ret;
 }
@@ -348,6 +348,6 @@ U_BOOT_DRIVER(da8xx_musb) = {
 	.probe = da8xx_musb_probe,
 	.remove = da8xx_musb_remove,
 	.ops = &musb_usb_ops,
-	.platdata_auto	= sizeof(struct da8xx_musb_platdata),
+	.plat_auto	= sizeof(struct da8xx_musb_platdata),
 	.priv_auto	= sizeof(struct musb_host_data),
 };
diff --git a/drivers/usb/musb-new/mt85xx.c b/drivers/usb/musb-new/mt85xx.c
index 8adfa426c4..4847b2c80d 100644
--- a/drivers/usb/musb-new/mt85xx.c
+++ b/drivers/usb/musb-new/mt85xx.c
@@ -414,6 +414,6 @@ U_BOOT_DRIVER(mtk_musb) = {
 #ifdef CONFIG_USB_MUSB_HOST
 	.ops		= &musb_usb_ops,
 #endif
-	.platdata_auto	= sizeof(struct usb_platdata),
+	.plat_auto	= sizeof(struct usb_platdata),
 	.priv_auto	= sizeof(struct mtk_musb_glue),
 };
diff --git a/drivers/usb/musb-new/omap2430.c b/drivers/usb/musb-new/omap2430.c
index 2e029d84bc..9150c4d745 100644
--- a/drivers/usb/musb-new/omap2430.c
+++ b/drivers/usb/musb-new/omap2430.c
@@ -151,67 +151,63 @@ struct omap2430_musb_platdata {
 
 static int omap2430_musb_ofdata_to_platdata(struct udevice *dev)
 {
-	struct omap2430_musb_platdata *platdata = dev_get_platdata(dev);
+	struct omap2430_musb_platdata *plat = dev_get_platdata(dev);
 	const void *fdt = gd->fdt_blob;
 	int node = dev_of_offset(dev);
 
-	platdata->base = (void *)dev_read_addr_ptr(dev);
+	plat->base = (void *)dev_read_addr_ptr(dev);
 
-	platdata->musb_config.multipoint = fdtdec_get_int(fdt, node,
-							  "multipoint",
-							  -1);
-	if (platdata->musb_config.multipoint < 0) {
+	plat->musb_config.multipoint = fdtdec_get_int(fdt, node, "multipoint",
+						      -1);
+	if (plat->musb_config.multipoint < 0) {
 		pr_err("MUSB multipoint DT entry missing\n");
 		return -ENOENT;
 	}
 
-	platdata->musb_config.dyn_fifo = 1;
-	platdata->musb_config.num_eps = fdtdec_get_int(fdt, node,
-						       "num-eps", -1);
-	if (platdata->musb_config.num_eps < 0) {
+	plat->musb_config.dyn_fifo = 1;
+	plat->musb_config.num_eps = fdtdec_get_int(fdt, node, "num-eps", -1);
+	if (plat->musb_config.num_eps < 0) {
 		pr_err("MUSB num-eps DT entry missing\n");
 		return -ENOENT;
 	}
 
-	platdata->musb_config.ram_bits = fdtdec_get_int(fdt, node,
-							"ram-bits", -1);
-	if (platdata->musb_config.ram_bits < 0) {
+	plat->musb_config.ram_bits = fdtdec_get_int(fdt, node, "ram-bits", -1);
+	if (plat->musb_config.ram_bits < 0) {
 		pr_err("MUSB ram-bits DT entry missing\n");
 		return -ENOENT;
 	}
 
-	platdata->plat.power = fdtdec_get_int(fdt, node,
-								"power", -1);
-	if (platdata->plat.power < 0) {
+	plat->plat.power = fdtdec_get_int(fdt, node, "power", -1);
+	if (plat->plat.power < 0) {
 		pr_err("MUSB power DT entry missing\n");
 		return -ENOENT;
 	}
 
-	platdata->otg_board_data.interface_type = fdtdec_get_int(fdt, node,
-									"interface-type", -1);
-	if (platdata->otg_board_data.interface_type < 0) {
+	plat->otg_board_data.interface_type = fdtdec_get_int(fdt, node,
+							     "interface-type",
+							     -1);
+	if (plat->otg_board_data.interface_type < 0) {
 		pr_err("MUSB interface-type DT entry missing\n");
 		return -ENOENT;
 	}
 
 #if 0 /* In a perfect world, mode would be set to OTG, mode 3 from DT */
-	platdata->plat.mode = fdtdec_get_int(fdt, node,
-										"mode", -1);
-	if (platdata->plat.mode < 0) {
+	plat->plat.mode = fdtdec_get_int(fdt, node, "mode", -1);
+	if (plat->plat.mode < 0) {
 		pr_err("MUSB mode DT entry missing\n");
 		return -ENOENT;
 	}
 #else /* MUSB_OTG, it doesn't work */
 #ifdef CONFIG_USB_MUSB_HOST /* Host seems to be the only option that works */
-	platdata->plat.mode = MUSB_HOST;
+	plat->plat.mode = MUSB_HOST;
 #else /* For that matter, MUSB_PERIPHERAL doesn't either */
-	platdata->plat.mode = MUSB_PERIPHERAL;
+	plat->plat.mode = MUSB_PERIPHERAL;
 #endif
 #endif
-	platdata->otg_board_data.dev = dev;
-	platdata->plat.config = &platdata->musb_config;
-	platdata->plat.platform_ops = &omap2430_ops;
-	platdata->plat.board_data = &platdata->otg_board_data;
+	plat->otg_board_data.dev = dev;
+	plat->plat.config = &plat->musb_config;
+	plat->plat.platform_ops = &omap2430_ops;
+	plat->plat.board_data = &plat->otg_board_data;
 	return 0;
 }
 
@@ -222,7 +218,7 @@ static int omap2430_musb_probe(struct udevice *dev)
 #else
 	struct musb *musbp;
 #endif
-	struct omap2430_musb_platdata *platdata = dev_get_platdata(dev);
+	struct omap2430_musb_platdata *plat = dev_get_platdata(dev);
 	struct usb_bus_priv *priv = dev_get_uclass_priv(dev);
 	struct omap_musb_board_data *otg_board_data;
 	int ret = 0;
@@ -230,21 +226,20 @@ static int omap2430_musb_probe(struct udevice *dev)
 
 	priv->desc_before_addr = true;
 
-	otg_board_data = &platdata->otg_board_data;
+	otg_board_data = &plat->otg_board_data;
 
 #ifdef CONFIG_USB_MUSB_HOST
-	host->host = musb_init_controller(&platdata->plat,
+	host->host = musb_init_controller(&plat->plat,
 					  (struct device *)otg_board_data,
-					  platdata->base);
+					  plat->base);
 	if (!host->host) {
 		return -EIO;
 	}
 
 	ret = musb_lowlevel_init(host);
 #else
-	musbp = musb_register(&platdata->plat,
-			  (struct device *)otg_board_data,
-			  platdata->base);
+	musbp = musb_register(&plat->plat, (struct device *)otg_board_data,
+			      plat->base);
 	if (IS_ERR_OR_NULL(musbp))
 		return -EINVAL;
 #endif
@@ -280,7 +275,7 @@ U_BOOT_DRIVER(omap2430_musb) = {
 #ifdef CONFIG_USB_MUSB_HOST
 	.ops = &musb_usb_ops,
 #endif
-	.platdata_auto	= sizeof(struct omap2430_musb_platdata),
+	.plat_auto	= sizeof(struct omap2430_musb_platdata),
 	.priv_auto	= sizeof(struct musb_host_data),
 };
 
diff --git a/drivers/usb/musb-new/pic32.c b/drivers/usb/musb-new/pic32.c
index e45ab20562..7970d1620f 100644
--- a/drivers/usb/musb-new/pic32.c
+++ b/drivers/usb/musb-new/pic32.c
@@ -288,6 +288,6 @@ U_BOOT_DRIVER(usb_musb) = {
 #ifdef CONFIG_USB_MUSB_HOST
 	.ops		= &musb_usb_ops,
 #endif
-	.platdata_auto	= sizeof(struct usb_platdata),
+	.plat_auto	= sizeof(struct usb_platdata),
 	.priv_auto	= sizeof(struct pic32_musb_data),
 };
diff --git a/drivers/usb/musb-new/sunxi.c b/drivers/usb/musb-new/sunxi.c
index 10bc3e8956..1337e5260b 100644
--- a/drivers/usb/musb-new/sunxi.c
+++ b/drivers/usb/musb-new/sunxi.c
@@ -552,6 +552,6 @@ U_BOOT_DRIVER(usb_musb) = {
 #ifdef CONFIG_USB_MUSB_HOST
 	.ops		= &musb_usb_ops,
 #endif
-	.platdata_auto	= sizeof(struct usb_platdata),
+	.plat_auto	= sizeof(struct usb_platdata),
 	.priv_auto	= sizeof(struct sunxi_glue),
 };
diff --git a/drivers/usb/musb-new/ti-musb.c b/drivers/usb/musb-new/ti-musb.c
index 34b1a34d2c..29a06320e6 100644
--- a/drivers/usb/musb-new/ti-musb.c
+++ b/drivers/usb/musb-new/ti-musb.c
@@ -33,17 +33,17 @@ DECLARE_GLOBAL_DATA_PTR;
 
 static void ti_musb_set_phy_power(struct udevice *dev, u8 on)
 {
-	struct ti_musb_platdata *platdata = dev_get_platdata(dev);
+	struct ti_musb_platdata *plat = dev_get_platdata(dev);
 
-	if (!platdata->ctrl_mod_base)
+	if (!plat->ctrl_mod_base)
 		return;
 
 	if (on) {
-		clrsetbits_le32(platdata->ctrl_mod_base,
+		clrsetbits_le32(plat->ctrl_mod_base,
 				CM_PHY_PWRDN | CM_PHY_OTG_PWRDN,
 				OTGVDET_EN | OTGSESSENDEN);
 	} else {
-		clrsetbits_le32(platdata->ctrl_mod_base, 0,
+		clrsetbits_le32(plat->ctrl_mod_base, 0,
 				CM_PHY_PWRDN | CM_PHY_OTG_PWRDN);
 	}
 }
@@ -79,7 +79,7 @@ static int ti_musb_get_usb_index(int node)
 
 static int ti_musb_ofdata_to_platdata(struct udevice *dev)
 {
-	struct ti_musb_platdata *platdata = dev_get_platdata(dev);
+	struct ti_musb_platdata *plat = dev_get_platdata(dev);
 	const void *fdt = gd->fdt_blob;
 	int node = dev_of_offset(dev);
 	int phys;
@@ -87,18 +87,18 @@ static int ti_musb_ofdata_to_platdata(struct udevice *dev)
 	int usb_index;
 	struct musb_hdrc_config *musb_config;
 
-	platdata->base = (void *)devfdt_get_addr_index(dev, 1);
+	plat->base = (void *)devfdt_get_addr_index(dev, 1);
 
 	phys = fdtdec_lookup_phandle(fdt, node, "phys");
 	ctrl_mod = fdtdec_lookup_phandle(fdt, phys, "ti,ctrl_mod");
-	platdata->ctrl_mod_base = (void *)fdtdec_get_addr(fdt, ctrl_mod, "reg");
+	plat->ctrl_mod_base = (void *)fdtdec_get_addr(fdt, ctrl_mod, "reg");
 	usb_index = ti_musb_get_usb_index(node);
 	switch (usb_index) {
 	case 1:
-		platdata->ctrl_mod_base += AM335X_USB1_CTRL;
+		plat->ctrl_mod_base += AM335X_USB1_CTRL;
 		break;
 	case 0:
-		platdata->ctrl_mod_base += AM335X_USB0_CTRL;
+		plat->ctrl_mod_base += AM335X_USB0_CTRL;
 		break;
 	default:
 		break;
@@ -130,15 +130,15 @@ static int ti_musb_ofdata_to_platdata(struct udevice *dev)
 		return -ENOENT;
 	}
 
-	platdata->plat.config = musb_config;
+	plat->plat.config = musb_config;
 
-	platdata->plat.power = fdtdec_get_int(fdt, node, "mentor,power", -1);
-	if (platdata->plat.power < 0) {
+	plat->plat.power = fdtdec_get_int(fdt, node, "mentor,power", -1);
+	if (plat->plat.power < 0) {
 		pr_err("MUSB mentor,power DT entry missing\n");
 		return -ENOENT;
 	}
 
-	platdata->plat.platform_ops = &musb_dsps_ops;
+	plat->plat.platform_ops = &musb_dsps_ops;
 
 	return 0;
 }
@@ -147,15 +147,15 @@ static int ti_musb_ofdata_to_platdata(struct udevice *dev)
 static int ti_musb_host_probe(struct udevice *dev)
 {
 	struct musb_host_data *host = dev_get_priv(dev);
-	struct ti_musb_platdata *platdata = dev_get_platdata(dev);
+	struct ti_musb_platdata *plat = dev_get_platdata(dev);
 	struct usb_bus_priv *priv = dev_get_uclass_priv(dev);
 	int ret;
 
 	priv->desc_before_addr = true;
 
-	host->host = musb_init_controller(&platdata->plat,
+	host->host = musb_init_controller(&plat->plat,
 					  NULL,
-					  platdata->base);
+					  plat->base);
 	if (!host->host)
 		return -EIO;
 
@@ -178,18 +178,18 @@ static int ti_musb_host_remove(struct udevice *dev)
 #if CONFIG_IS_ENABLED(OF_CONTROL)
 static int ti_musb_host_ofdata_to_platdata(struct udevice *dev)
 {
-	struct ti_musb_platdata *platdata = dev_get_platdata(dev);
+	struct ti_musb_platdata *plat = dev_get_platdata(dev);
 	const void *fdt = gd->fdt_blob;
 	int node = dev_of_offset(dev);
 	int ret;
 
 	ret = ti_musb_ofdata_to_platdata(dev);
 	if (ret) {
-		pr_err("platdata dt parse error\n");
+		pr_err("plat dt parse error\n");
 		return ret;
 	}
 
-	platdata->plat.mode = MUSB_HOST;
+	plat->plat.mode = MUSB_HOST;
 
 	return 0;
 }
@@ -204,7 +204,7 @@ U_BOOT_DRIVER(ti_musb_host) = {
 	.probe = ti_musb_host_probe,
 	.remove = ti_musb_host_remove,
 	.ops	= &musb_usb_ops,
-	.platdata_auto	= sizeof(struct ti_musb_platdata),
+	.plat_auto	= sizeof(struct ti_musb_platdata),
 	.priv_auto	= sizeof(struct musb_host_data),
 };
 
@@ -216,17 +216,17 @@ struct ti_musb_peripheral {
 #if CONFIG_IS_ENABLED(OF_CONTROL)
 static int ti_musb_peripheral_ofdata_to_platdata(struct udevice *dev)
 {
-	struct ti_musb_platdata *platdata = dev_get_platdata(dev);
+	struct ti_musb_platdata *plat = dev_get_platdata(dev);
 	const void *fdt = gd->fdt_blob;
 	int node = dev_of_offset(dev);
 	int ret;
 
 	ret = ti_musb_ofdata_to_platdata(dev);
 	if (ret) {
-		pr_err("platdata dt parse error\n");
+		pr_err("plat dt parse error\n");
 		return ret;
 	}
-	platdata->plat.mode = MUSB_PERIPHERAL;
+	plat->plat.mode = MUSB_PERIPHERAL;
 
 	return 0;
 }
@@ -244,12 +244,12 @@ int dm_usb_gadget_handle_interrupts(struct udevice *dev)
 static int ti_musb_peripheral_probe(struct udevice *dev)
 {
 	struct ti_musb_peripheral *priv = dev_get_priv(dev);
-	struct ti_musb_platdata *platdata = dev_get_platdata(dev);
+	struct ti_musb_platdata *plat = dev_get_platdata(dev);
 	int ret;
 
-	priv->periph = musb_init_controller(&platdata->plat,
+	priv->periph = musb_init_controller(&plat->plat,
 					    NULL,
-					    platdata->base);
+					    plat->base);
 	if (!priv->periph)
 		return -EIO;
 
@@ -277,7 +277,7 @@ U_BOOT_DRIVER(ti_musb_peripheral) = {
 	.probe = ti_musb_peripheral_probe,
 	.remove = ti_musb_peripheral_remove,
 	.ops	= &musb_usb_ops,
-	.platdata_auto	= sizeof(struct ti_musb_platdata),
+	.plat_auto	= sizeof(struct ti_musb_platdata),
 	.priv_auto	= sizeof(struct ti_musb_peripheral),
 	.flags = DM_FLAG_PRE_RELOC,
 };