eaw/u-boot
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
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>
This commit is contained in:
Simon Glass
2020-12-03 16:55:18 -07:00
parent 41575d8e4c
commit caa4daa2ae
575 changed files with 1633 additions and 1644 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
drivers/adc/adc-uclass.c
View File

@@ -15,7 +15,7 @@
#include <linux/delay.h>
#include <power/regulator.h>
#define ADC_UCLASS_PLATDATA_SIZE sizeof(struct adc_uclass_platdata)
#define ADC_UCLASS_PLATDATA_SIZE sizeof(struct adc_uclass_plat)
#define CHECK_NUMBER true
#define CHECK_MASK (!CHECK_NUMBER)
@@ -29,7 +29,7 @@ extern void sdelay(unsigned long loops);
static int check_channel(struct udevice *dev, int value, bool number_or_mask,
const char *caller_function)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
unsigned mask = number_or_mask ? (1 << value) : value;
/* For the real ADC hardware, some ADC channels can be inactive.
@@ -48,7 +48,7 @@ static int check_channel(struct udevice *dev, int value, bool number_or_mask,
static int adc_supply_enable(struct udevice *dev)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
const char *supply_type;
int ret = 0;
@@ -70,7 +70,7 @@ static int adc_supply_enable(struct udevice *dev)
int adc_data_mask(struct udevice *dev, unsigned int *data_mask)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
if (!uc_pdata)
return -ENOSYS;
@@ -81,7 +81,7 @@ int adc_data_mask(struct udevice *dev, unsigned int *data_mask)
int adc_channel_mask(struct udevice *dev, unsigned int *channel_mask)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
if (!uc_pdata)
return -ENOSYS;
@@ -141,7 +141,7 @@ int adc_start_channels(struct udevice *dev, unsigned int channel_mask)
int adc_channel_data(struct udevice *dev, int channel, unsigned int *data)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
const struct adc_ops *ops = dev_get_driver_ops(dev);
unsigned int timeout_us = uc_pdata->data_timeout_us;
int ret;
@@ -168,7 +168,7 @@ int adc_channel_data(struct udevice *dev, int channel, unsigned int *data)
int adc_channels_data(struct udevice *dev, unsigned int channel_mask,
struct adc_channel *channels)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
unsigned int timeout_us = uc_pdata->multidata_timeout_us;
const struct adc_ops *ops = dev_get_driver_ops(dev);
int ret;
@@ -269,7 +269,7 @@ try_manual:
static int adc_vdd_platdata_update(struct udevice *dev)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
int ret;
/* Warning!
@@ -292,7 +292,7 @@ static int adc_vdd_platdata_update(struct udevice *dev)
static int adc_vss_platdata_update(struct udevice *dev)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
int ret;
if (!uc_pdata->vss_supply)
@@ -309,7 +309,7 @@ static int adc_vss_platdata_update(struct udevice *dev)
int adc_vdd_value(struct udevice *dev, int *uV)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
int ret, value_sign = uc_pdata->vdd_polarity_negative ? -1 : 1;
/* Update the regulator Value. */
@@ -327,7 +327,7 @@ int adc_vdd_value(struct udevice *dev, int *uV)
int adc_vss_value(struct udevice *dev, int *uV)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
int ret, value_sign = uc_pdata->vss_polarity_negative ? -1 : 1;
/* Update the regulator Value. */
@@ -369,7 +369,7 @@ int adc_raw_to_uV(struct udevice *dev, unsigned int raw, int *uV)
static int adc_vdd_platdata_set(struct udevice *dev)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
int ret;
char *prop;
@@ -394,7 +394,7 @@ static int adc_vdd_platdata_set(struct udevice *dev)
static int adc_vss_platdata_set(struct udevice *dev)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
int ret;
char *prop;
@@ -420,12 +420,12 @@ static int adc_pre_probe(struct udevice *dev)
{
int ret;
/* Set ADC VDD platdata: polarity, uV, regulator (phandle). */
/* Set ADC VDD plat: polarity, uV, regulator (phandle). */
ret = adc_vdd_platdata_set(dev);
if (ret)
pr_err("%s: Can't update Vdd. Error: %d", dev->name, ret);
/* Set ADC VSS platdata: polarity, uV, regulator (phandle). */
/* Set ADC VSS plat: polarity, uV, regulator (phandle). */
ret = adc_vss_platdata_set(dev);
if (ret)
pr_err("%s: Can't update Vss. Error: %d", dev->name, ret);
@@ -437,5 +437,5 @@ UCLASS_DRIVER(adc) = {
.id = UCLASS_ADC,
.name = "adc",
.pre_probe = adc_pre_probe,
.per_device_platdata_auto = ADC_UCLASS_PLATDATA_SIZE,
.per_device_plat_auto = ADC_UCLASS_PLATDATA_SIZE,
};

2
drivers/adc/exynos-adc.c
View File

@@ -103,7 +103,7 @@ int exynos_adc_probe(struct udevice *dev)
int exynos_adc_ofdata_to_platdata(struct udevice *dev)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
struct exynos_adc_priv *priv = dev_get_priv(dev);
priv->regs = dev_read_addr_ptr(dev);

2
drivers/adc/meson-saradc.c
View File

@@ -677,7 +677,7 @@ static int meson_saradc_probe(struct udevice *dev)
int meson_saradc_ofdata_to_platdata(struct udevice *dev)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
struct meson_saradc_priv *priv = dev_get_priv(dev);
priv->data = (struct meson_saradc_data *)dev_get_driver_data(dev);

4
drivers/adc/rockchip-saradc.c
View File

@@ -44,7 +44,7 @@ int rockchip_saradc_channel_data(struct udevice *dev, int channel,
unsigned int *data)
{
struct rockchip_saradc_priv *priv = dev_get_priv(dev);
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
if (channel != priv->active_channel) {
pr_err("Requested channel is not active!");
@@ -119,7 +119,7 @@ int rockchip_saradc_probe(struct udevice *dev)
int rockchip_saradc_ofdata_to_platdata(struct udevice *dev)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
struct rockchip_saradc_priv *priv = dev_get_priv(dev);
struct rockchip_saradc_data *data;

2
drivers/adc/sandbox.c
View File

@@ -137,7 +137,7 @@ int sandbox_adc_probe(struct udevice *dev)
int sandbox_adc_ofdata_to_platdata(struct udevice *dev)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
uc_pdata->data_mask = SANDBOX_ADC_DATA_MASK;
uc_pdata->data_format = ADC_DATA_FORMAT_BIN;

6
drivers/adc/stm32-adc.c
View File

@@ -80,7 +80,7 @@ static int stm32_adc_stop(struct udevice *dev)
static int stm32_adc_start_channel(struct udevice *dev, int channel)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
struct stm32_adc_common *common = dev_get_priv(dev_get_parent(dev));
struct stm32_adc *adc = dev_get_priv(dev);
int ret;
@@ -164,7 +164,7 @@ static int stm32_adc_channel_data(struct udevice *dev, int channel,
static int stm32_adc_chan_of_init(struct udevice *dev)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
struct stm32_adc *adc = dev_get_priv(dev);
u32 chans[STM32_ADC_CH_MAX];
unsigned int i, num_channels;
@@ -206,7 +206,7 @@ static int stm32_adc_chan_of_init(struct udevice *dev)
static int stm32_adc_probe(struct udevice *dev)
{
struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
struct adc_uclass_plat *uc_pdata = dev_get_uclass_plat(dev);
struct stm32_adc_common *common = dev_get_priv(dev_get_parent(dev));
struct stm32_adc *adc = dev_get_priv(dev);
int offset;

6
drivers/ata/ahci.c
View File

@@ -172,7 +172,7 @@ static int ahci_host_init(struct ahci_uc_priv *uc_priv)
#if !defined(CONFIG_SCSI_AHCI_PLAT) && !defined(CONFIG_DM_SCSI)
# ifdef CONFIG_DM_PCI
struct udevice *dev = uc_priv->dev;
struct pci_child_platdata *pplat = dev_get_parent_platdata(dev);
struct pci_child_platdata *pplat = dev_get_parent_plat(dev);
# else
pci_dev_t pdev = uc_priv->dev;
unsigned short vendor;
@@ -474,7 +474,7 @@ static int ahci_init_one(struct ahci_uc_priv *uc_priv, pci_dev_t dev)
pci_write_config_byte(dev, 0x41, 0xa1);
#endif
#else
struct scsi_platdata *plat = dev_get_uclass_platdata(dev);
struct scsi_platdata *plat = dev_get_uclass_plat(dev);
uc_priv->mmio_base = (void *)plat->base;
#endif
@@ -1170,7 +1170,7 @@ int ahci_probe_scsi(struct udevice *ahci_dev, ulong base)
device_find_first_child(ahci_dev, &dev);
if (!dev)
return -ENODEV;
uc_plat = dev_get_uclass_platdata(dev);
uc_plat = dev_get_uclass_plat(dev);
uc_plat->base = base;
uc_plat->max_lun = 1;
uc_plat->max_id = 2;

6
drivers/ata/dwc_ahsata.c
View File

@@ -1019,7 +1019,7 @@ int dwc_ahsata_scan(struct udevice *dev)
}
}
desc = dev_get_uclass_platdata(blk);
desc = dev_get_uclass_plat(blk);
ret = dwc_ahsata_scan_common(uc_priv, desc);
if (ret) {
debug("%s: Failed to scan bus\n", __func__);
@@ -1054,7 +1054,7 @@ int dwc_ahsata_probe(struct udevice *dev)
static ulong dwc_ahsata_read(struct udevice *blk, lbaint_t blknr,
lbaint_t blkcnt, void *buffer)
{
struct blk_desc *desc = dev_get_uclass_platdata(blk);
struct blk_desc *desc = dev_get_uclass_plat(blk);
struct udevice *dev = dev_get_parent(blk);
struct ahci_uc_priv *uc_priv;
@@ -1065,7 +1065,7 @@ static ulong dwc_ahsata_read(struct udevice *blk, lbaint_t blknr,
static ulong dwc_ahsata_write(struct udevice *blk, lbaint_t blknr,
lbaint_t blkcnt, const void *buffer)
{
struct blk_desc *desc = dev_get_uclass_platdata(blk);
struct blk_desc *desc = dev_get_uclass_plat(blk);
struct udevice *dev = dev_get_parent(blk);
struct ahci_uc_priv *uc_priv;

4
drivers/ata/fsl_sata.c
View File

@@ -808,7 +808,7 @@ int scan_sata(int dev)
#else
static int scan_sata(struct udevice *dev)
{
struct blk_desc *desc = dev_get_uclass_platdata(dev);
struct blk_desc *desc = dev_get_uclass_plat(dev);
struct fsl_ata_priv *priv = dev_get_platdata(dev);
fsl_sata_t *sata = priv->fsl_sata;
#endif
@@ -900,7 +900,7 @@ U_BOOT_DRIVER(sata_fsl_driver) = {
.name = "sata_fsl_blk",
.id = UCLASS_BLK,
.ops = &sata_fsl_blk_ops,
.platdata_auto = sizeof(struct fsl_ata_priv),
.plat_auto = sizeof(struct fsl_ata_priv),
};
static int fsl_ata_ofdata_to_platdata(struct udevice *dev)

6
drivers/ata/sata_mv.c
View File

@@ -727,7 +727,7 @@ static u32 mv_sata_rw_cmd(struct udevice *dev, int port, lbaint_t start,
static u32 ata_low_level_rw(struct udevice *dev, int port, lbaint_t blknr,
lbaint_t blkcnt, void *buffer, int is_write)
{
struct blk_desc *desc = dev_get_uclass_platdata(dev);
struct blk_desc *desc = dev_get_uclass_plat(dev);
lbaint_t start, blks;
u8 *addr;
int max_blks;
@@ -943,7 +943,7 @@ static int sata_mv_init_sata(struct udevice *dev, int port)
static int sata_mv_scan_sata(struct udevice *dev, int port)
{
struct blk_desc *desc = dev_get_uclass_platdata(dev);
struct blk_desc *desc = dev_get_uclass_plat(dev);
struct mv_priv *priv = dev_get_platdata(dev);
unsigned char serial[ATA_ID_SERNO_LEN + 1];
unsigned char firmware[ATA_ID_FW_REV_LEN + 1];
@@ -1030,7 +1030,7 @@ U_BOOT_DRIVER(sata_mv_driver) = {
.name = "sata_mv_blk",
.id = UCLASS_BLK,
.ops = &sata_mv_blk_ops,
.platdata_auto = sizeof(struct mv_priv),
.plat_auto = sizeof(struct mv_priv),
};
static int sata_mv_probe(struct udevice *dev)

4
drivers/ata/sata_sil.c
View File

@@ -708,7 +708,7 @@ int scan_sata(int dev)
#else
static int scan_sata(struct udevice *blk_dev, int dev)
{
struct blk_desc *desc = dev_get_uclass_platdata(blk_dev);
struct blk_desc *desc = dev_get_uclass_plat(blk_dev);
struct sil_sata_priv *priv = dev_get_platdata(blk_dev);
struct sil_sata *sata = priv->sil_sata_desc[dev];
#endif
@@ -772,7 +772,7 @@ U_BOOT_DRIVER(sata_sil_driver) = {
.name = "sata_sil_blk",
.id = UCLASS_BLK,
.ops = &sata_sil_blk_ops,
.platdata_auto = sizeof(struct sil_sata_priv),
.plat_auto = sizeof(struct sil_sata_priv),
};
static int sil_unbind_device(struct udevice *dev)

28
drivers/block/blk-uclass.c
View File

@@ -79,7 +79,7 @@ struct blk_desc *blk_get_devnum_by_type(enum if_type if_type, int devnum)
ret = blk_get_device(if_type, devnum, &dev);
if (ret)
return NULL;
desc = dev_get_uclass_platdata(dev);
desc = dev_get_uclass_plat(dev);
return desc;
}
@@ -114,7 +114,7 @@ struct blk_desc *blk_get_devnum_by_typename(const char *if_typename, int devnum)
if (ret)
return NULL;
uclass_foreach_dev(dev, uc) {
struct blk_desc *desc = dev_get_uclass_platdata(dev);
struct blk_desc *desc = dev_get_uclass_plat(dev);
debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
if_type, devnum, dev->name, desc->if_type, desc->devnum);
@@ -154,7 +154,7 @@ struct blk_desc *blk_get_by_device(struct udevice *dev)
if (device_get_uclass_id(child_dev) != UCLASS_BLK)
continue;
return dev_get_uclass_platdata(child_dev);
return dev_get_uclass_plat(child_dev);
}
debug("%s: No block device found\n", __func__);
@@ -184,7 +184,7 @@ static int get_desc(enum if_type if_type, int devnum, struct blk_desc **descp)
if (ret)
return ret;
uclass_foreach_dev(dev, uc) {
struct blk_desc *desc = dev_get_uclass_platdata(dev);
struct blk_desc *desc = dev_get_uclass_plat(dev);
debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
if_type, devnum, dev->name, desc->if_type, desc->devnum);
@@ -368,7 +368,7 @@ int blk_first_device(int if_type, struct udevice **devp)
if (!*devp)
return -ENODEV;
do {
desc = dev_get_uclass_platdata(*devp);
desc = dev_get_uclass_plat(*devp);
if (desc->if_type == if_type)
return 0;
ret = uclass_find_next_device(devp);
@@ -384,7 +384,7 @@ int blk_next_device(struct udevice **devp)
struct blk_desc *desc;
int ret, if_type;
desc = dev_get_uclass_platdata(*devp);
desc = dev_get_uclass_plat(*devp);
if_type = desc->if_type;
do {
ret = uclass_find_next_device(devp);
@@ -392,7 +392,7 @@ int blk_next_device(struct udevice **devp)
return ret;
if (!*devp)
return -ENODEV;
desc = dev_get_uclass_platdata(*devp);
desc = dev_get_uclass_plat(*devp);
if (desc->if_type == if_type)
return 0;
} while (1);
@@ -408,7 +408,7 @@ int blk_find_device(int if_type, int devnum, struct udevice **devp)
if (ret)
return ret;
uclass_foreach_dev(dev, uc) {
struct blk_desc *desc = dev_get_uclass_platdata(dev);
struct blk_desc *desc = dev_get_uclass_plat(dev);
debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
if_type, devnum, dev->name, desc->if_type, desc->devnum);
@@ -516,7 +516,7 @@ int blk_find_max_devnum(enum if_type if_type)
if (ret)
return ret;
uclass_foreach_dev(dev, uc) {
struct blk_desc *desc = dev_get_uclass_platdata(dev);
struct blk_desc *desc = dev_get_uclass_plat(dev);
if (desc->if_type == if_type && desc->devnum > max_devnum)
max_devnum = desc->devnum;
@@ -548,7 +548,7 @@ static int blk_claim_devnum(enum if_type if_type, int devnum)
if (ret)
return ret;
uclass_foreach_dev(dev, uc) {
struct blk_desc *desc = dev_get_uclass_platdata(dev);
struct blk_desc *desc = dev_get_uclass_plat(dev);
if (desc->if_type == if_type && desc->devnum == devnum) {
int next = blk_next_free_devnum(if_type);
@@ -583,7 +583,7 @@ int blk_create_device(struct udevice *parent, const char *drv_name,
ret = device_bind_driver(parent, drv_name, name, &dev);
if (ret)
return ret;
desc = dev_get_uclass_platdata(dev);
desc = dev_get_uclass_plat(dev);
desc->if_type = if_type;
desc->blksz = blksz;
desc->log2blksz = LOG2(desc->blksz);
@@ -629,7 +629,7 @@ int blk_unbind_all(int if_type)
if (ret)
return ret;
uclass_foreach_dev_safe(dev, next, uc) {
struct blk_desc *desc = dev_get_uclass_platdata(dev);
struct blk_desc *desc = dev_get_uclass_plat(dev);
if (desc->if_type == if_type) {
ret = device_remove(dev, DM_REMOVE_NORMAL);
@@ -648,7 +648,7 @@ static int blk_post_probe(struct udevice *dev)
{
if (IS_ENABLED(CONFIG_PARTITIONS) &&
IS_ENABLED(CONFIG_HAVE_BLOCK_DEVICE)) {
struct blk_desc *desc = dev_get_uclass_platdata(dev);
struct blk_desc *desc = dev_get_uclass_plat(dev);
part_init(desc);
}
@@ -660,5 +660,5 @@ UCLASS_DRIVER(blk) = {
.id = UCLASS_BLK,
.name = "blk",
.post_probe = blk_post_probe,
.per_device_platdata_auto = sizeof(struct blk_desc),
.per_device_plat_auto = sizeof(struct blk_desc),
};

6
drivers/block/ide.c
View File

@@ -940,7 +940,7 @@ ulong ide_read(struct blk_desc *block_dev, lbaint_t blknr, lbaint_t blkcnt,
#endif
{
#ifdef CONFIG_BLK
struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
struct blk_desc *block_dev = dev_get_uclass_plat(dev);
#endif
int device = block_dev->devnum;
ulong n = 0;
@@ -1067,7 +1067,7 @@ ulong ide_write(struct blk_desc *block_dev, lbaint_t blknr, lbaint_t blkcnt,
#endif
{
#ifdef CONFIG_BLK
struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
struct blk_desc *block_dev = dev_get_uclass_plat(dev);
#endif
int device = block_dev->devnum;
ulong n = 0;
@@ -1160,7 +1160,7 @@ int ide_device_present(int dev)
#ifdef CONFIG_BLK
static int ide_blk_probe(struct udevice *udev)
{
struct blk_desc *desc = dev_get_uclass_platdata(udev);
struct blk_desc *desc = dev_get_uclass_plat(udev);
/* fill in device vendor/product/rev strings */
strncpy(desc->vendor, ide_dev_desc[desc->devnum].vendor,

8
drivers/block/sandbox.c
View File

@@ -35,7 +35,7 @@ static unsigned long host_block_read(struct udevice *dev,
void *buffer)
{
struct host_block_dev *host_dev = dev_get_platdata(dev);
struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
struct blk_desc *block_dev = dev_get_uclass_plat(dev);
#else
static unsigned long host_block_read(struct blk_desc *block_dev,
@@ -66,7 +66,7 @@ static unsigned long host_block_write(struct udevice *dev,
const void *buffer)
{
struct host_block_dev *host_dev = dev_get_platdata(dev);
struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
struct blk_desc *block_dev = dev_get_uclass_plat(dev);
#else
static unsigned long host_block_write(struct blk_desc *block_dev,
unsigned long start, lbaint_t blkcnt,
@@ -202,7 +202,7 @@ int host_get_dev_err(int devnum, struct blk_desc **blk_devp)
ret = blk_get_device(IF_TYPE_HOST, devnum, &dev);
if (ret)
return ret;
*blk_devp = dev_get_uclass_platdata(dev);
*blk_devp = dev_get_uclass_plat(dev);
#else
struct host_block_dev *host_dev = find_host_device(devnum);
@@ -228,7 +228,7 @@ U_BOOT_DRIVER(sandbox_host_blk) = {
.name = "sandbox_host_blk",
.id = UCLASS_BLK,
.ops = &sandbox_host_blk_ops,
.platdata_auto = sizeof(struct host_block_dev),
.plat_auto = sizeof(struct host_block_dev),
};
#else
U_BOOT_LEGACY_BLK(sandbox_host) = {

4
drivers/button/button-gpio.c
View File

@@ -31,7 +31,7 @@ static enum button_state_t button_gpio_get_state(struct udevice *dev)
static int button_gpio_probe(struct udevice *dev)
{
struct button_uc_plat *uc_plat = dev_get_uclass_platdata(dev);
struct button_uc_plat *uc_plat = dev_get_uclass_plat(dev);
struct button_gpio_priv *priv = dev_get_priv(dev);
int ret;
@@ -83,7 +83,7 @@ static int button_gpio_bind(struct udevice *parent)
node, &dev);
if (ret)
return ret;
uc_plat = dev_get_uclass_platdata(dev);
uc_plat = dev_get_uclass_plat(dev);
uc_plat->label = label;
}

4
drivers/button/button-uclass.c
View File

@@ -16,7 +16,7 @@ int button_get_by_label(const char *label, struct udevice **devp)
struct uclass *uc;
uclass_id_foreach_dev(UCLASS_BUTTON, dev, uc) {
struct button_uc_plat *uc_plat = dev_get_uclass_platdata(dev);
struct button_uc_plat *uc_plat = dev_get_uclass_plat(dev);
/* Ignore the top-level button node */
if (uc_plat->label && !strcmp(label, uc_plat->label))
@@ -39,5 +39,5 @@ enum button_state_t button_get_state(struct udevice *dev)
UCLASS_DRIVER(button) = {
.id = UCLASS_BUTTON,
.name = "button",
.per_device_platdata_auto = sizeof(struct button_uc_plat),
.per_device_plat_auto = sizeof(struct button_uc_plat),
};

2
drivers/cache/cache-v5l2.c vendored
View File

@@ -182,7 +182,7 @@ U_BOOT_DRIVER(v5l2_cache) = {
.of_match = v5l2_cache_ids,
.ofdata_to_platdata = v5l2_ofdata_to_platdata,
.probe = v5l2_probe,
.platdata_auto = sizeof(struct v5l2_plat),
.plat_auto = sizeof(struct v5l2_plat),
.ops = &v5l2_cache_ops,
.flags = DM_FLAG_PRE_RELOC,
};

2
drivers/clk/altera/clk-agilex.c
View File

@@ -658,5 +658,5 @@ U_BOOT_DRIVER(socfpga_agilex_clk) = {
.ops = &socfpga_clk_ops,
.probe = socfpga_clk_probe,
.ofdata_to_platdata = socfpga_clk_ofdata_to_platdata,
.platdata_auto = sizeof(struct socfpga_clk_platdata),
.plat_auto = sizeof(struct socfpga_clk_platdata),
};

2
drivers/clk/altera/clk-arria10.c
View File

@@ -359,5 +359,5 @@ U_BOOT_DRIVER(socfpga_a10_clk) = {
.probe = socfpga_a10_clk_probe,
.ofdata_to_platdata = socfpga_a10_ofdata_to_platdata,
.platdata_auto = sizeof(struct socfpga_a10_clk_platdata),
.plat_auto = sizeof(struct socfpga_a10_clk_platdata),
};

18
drivers/clk/at91/compat.c
View File

@@ -225,7 +225,7 @@ U_BOOT_DRIVER(at91sam9x5_main_osc_clk) = {
.id = UCLASS_CLK,
.of_match = main_osc_clk_match,
.probe = main_osc_clk_probe,
.platdata_auto = sizeof(struct pmc_platdata),
.plat_auto = sizeof(struct pmc_platdata),
.ops = &main_osc_clk_ops,
};
@@ -266,7 +266,7 @@ U_BOOT_DRIVER(at91_plla_clk) = {
.id = UCLASS_CLK,
.of_match = plla_clk_match,
.probe = plla_clk_probe,
.platdata_auto = sizeof(struct pmc_platdata),
.plat_auto = sizeof(struct pmc_platdata),
.ops = &plla_clk_ops,
};
@@ -340,7 +340,7 @@ U_BOOT_DRIVER(at91_plladiv_clk) = {
.id = UCLASS_CLK,
.of_match = at91_plladiv_clk_match,
.probe = at91_plladiv_clk_probe,
.platdata_auto = sizeof(struct pmc_platdata),
.plat_auto = sizeof(struct pmc_platdata),
.ops = &at91_plladiv_clk_ops,
};
@@ -437,7 +437,7 @@ U_BOOT_DRIVER(system_clk) = {
.name = "system-clk",
.id = UCLASS_CLK,
.probe = at91_clk_probe,
.platdata_auto = sizeof(struct pmc_platdata),
.plat_auto = sizeof(struct pmc_platdata),
.ops = &system_clk_ops,
};
@@ -536,7 +536,7 @@ static struct clk_ops periph_clk_ops = {
U_BOOT_DRIVER(clk_periph) = {
.name = "periph-clk",
.id = UCLASS_CLK,
.platdata_auto = sizeof(struct pmc_platdata),
.plat_auto = sizeof(struct pmc_platdata),
.probe = at91_clk_probe,
.ops = &periph_clk_ops,
};
@@ -668,7 +668,7 @@ U_BOOT_DRIVER(at91sam9x5_utmi_clk) = {
.of_match = utmi_clk_match,
.probe = utmi_clk_probe,
.ofdata_to_platdata = utmi_clk_ofdata_to_platdata,
.platdata_auto = sizeof(struct pmc_platdata),
.plat_auto = sizeof(struct pmc_platdata),
.ops = &utmi_clk_ops,
};
@@ -713,7 +713,7 @@ U_BOOT_DRIVER(sama5d4_h32mx_clk) = {
.id = UCLASS_CLK,
.of_match = sama5d4_h32mx_clk_match,
.probe = sama5d4_h32mx_clk_probe,
.platdata_auto = sizeof(struct pmc_platdata),
.plat_auto = sizeof(struct pmc_platdata),
.ops = &sama5d4_h32mx_clk_ops,
};
@@ -877,7 +877,7 @@ U_BOOT_DRIVER(generic_clk) = {
.probe = at91_clk_probe,
.ofdata_to_platdata = generic_clk_ofdata_to_platdata,
.priv_auto = sizeof(struct generic_clk_priv),
.platdata_auto = sizeof(struct pmc_platdata),
.plat_auto = sizeof(struct pmc_platdata),
.ops = &generic_clk_ops,
};
@@ -1013,7 +1013,7 @@ U_BOOT_DRIVER(at91_usb_clk) = {
.probe = at91_usb_clk_probe,
.ofdata_to_platdata = at91_usb_clk_ofdata_to_platdata,
.priv_auto = sizeof(struct at91_usb_clk_priv),
.platdata_auto = sizeof(struct pmc_platdata),
.plat_auto = sizeof(struct pmc_platdata),
.ops = &at91_usb_clk_ops,
};

2
drivers/clk/clk_boston.c
View File

@@ -92,6 +92,6 @@ U_BOOT_DRIVER(clk_boston) = {
.id = UCLASS_CLK,
.of_match = clk_boston_match,
.ofdata_to_platdata = clk_boston_ofdata_to_platdata,
.platdata_auto = sizeof(struct clk_boston),
.plat_auto = sizeof(struct clk_boston),
.ops = &clk_boston_ops,
};

2
drivers/clk/clk_fixed_factor.c
View File

@@ -67,6 +67,6 @@ U_BOOT_DRIVER(clk_fixed_factor) = {
.id = UCLASS_CLK,
.of_match = clk_fixed_factor_match,
.ofdata_to_platdata = clk_fixed_factor_ofdata_to_platdata,
.platdata_auto = sizeof(struct clk_fixed_factor),
.plat_auto = sizeof(struct clk_fixed_factor),
.ops = &clk_fixed_factor_ops,
};

2
drivers/clk/clk_fixed_rate.c
View File

@@ -51,7 +51,7 @@ U_BOOT_DRIVER(fixed_clock) = {
.id = UCLASS_CLK,
.of_match = clk_fixed_rate_match,
.ofdata_to_platdata = clk_fixed_rate_ofdata_to_platdata,
.platdata_auto = sizeof(struct clk_fixed_rate),
.plat_auto = sizeof(struct clk_fixed_rate),
.ops = &clk_fixed_rate_ops,
.flags = DM_FLAG_PRE_RELOC,
};

2
drivers/clk/rockchip/clk_rk3188.c
View File

@@ -617,7 +617,7 @@ U_BOOT_DRIVER(rockchip_rk3188_cru) = {
.id = UCLASS_CLK,
.of_match = rk3188_clk_ids,
.priv_auto = sizeof(struct rk3188_clk_priv),
.platdata_auto = sizeof(struct rk3188_clk_plat),
.plat_auto = sizeof(struct rk3188_clk_plat),
.ops = &rk3188_clk_ops,
.bind = rk3188_clk_bind,
.ofdata_to_platdata = rk3188_clk_ofdata_to_platdata,

2
drivers/clk/rockchip/clk_rk3288.c
View File

@@ -1041,7 +1041,7 @@ U_BOOT_DRIVER(rockchip_rk3288_cru) = {
.id = UCLASS_CLK,
.of_match = rk3288_clk_ids,
.priv_auto = sizeof(struct rk3288_clk_priv),
.platdata_auto = sizeof(struct rk3288_clk_plat),
.plat_auto = sizeof(struct rk3288_clk_plat),
.ops = &rk3288_clk_ops,
.bind = rk3288_clk_bind,
.ofdata_to_platdata = rk3288_clk_ofdata_to_platdata,

2
drivers/clk/rockchip/clk_rk3368.c
View File

@@ -645,7 +645,7 @@ U_BOOT_DRIVER(rockchip_rk3368_cru) = {
.of_match = rk3368_clk_ids,
.priv_auto = sizeof(struct rk3368_clk_priv),
#if CONFIG_IS_ENABLED(OF_PLATDATA)
.platdata_auto = sizeof(struct rk3368_clk_plat),
.plat_auto = sizeof(struct rk3368_clk_plat),
#endif
.ofdata_to_platdata = rk3368_clk_ofdata_to_platdata,
.ops = &rk3368_clk_ops,

4
drivers/clk/rockchip/clk_rk3399.c
View File

@@ -1453,7 +1453,7 @@ U_BOOT_DRIVER(clk_rk3399) = {
.bind = rk3399_clk_bind,
.probe = rk3399_clk_probe,
#if CONFIG_IS_ENABLED(OF_PLATDATA)
.platdata_auto = sizeof(struct rk3399_clk_plat),
.plat_auto = sizeof(struct rk3399_clk_plat),
#endif
};
@@ -1648,6 +1648,6 @@ U_BOOT_DRIVER(rockchip_rk3399_pmuclk) = {
.probe = rk3399_pmuclk_probe,
.bind = rk3399_pmuclk_bind,
#if CONFIG_IS_ENABLED(OF_PLATDATA)
.platdata_auto = sizeof(struct rk3399_pmuclk_plat),
.plat_auto = sizeof(struct rk3399_pmuclk_plat),
#endif
};

12
drivers/core/device-remove.c
View File

@@ -89,16 +89,16 @@ int device_unbind(struct udevice *dev)
return log_msg_ret("child unbind", ret);
if (dev->flags & DM_FLAG_ALLOC_PDATA) {
free(dev->platdata);
dev->platdata = NULL;
free(dev->plat);
dev->plat = NULL;
}
if (dev->flags & DM_FLAG_ALLOC_UCLASS_PDATA) {
free(dev->uclass_platdata);
dev->uclass_platdata = NULL;
free(dev->uclass_plat);
dev->uclass_plat = NULL;
}
if (dev->flags & DM_FLAG_ALLOC_PARENT_PDATA) {
free(dev->parent_platdata);
dev->parent_platdata = NULL;
free(dev->parent_plat);
dev->parent_plat = NULL;
}
ret = uclass_unbind_device(dev);
if (ret)

63
drivers/core/device.c
View File

@@ -34,7 +34,7 @@
DECLARE_GLOBAL_DATA_PTR;
static int device_bind_common(struct udevice *parent, const struct driver *drv,
const char *name, void *platdata,
const char *name, void *plat,
ulong driver_data, ofnode node,
uint of_platdata_size, struct udevice **devp)
{
@@ -63,7 +63,7 @@ static int device_bind_common(struct udevice *parent, const struct driver *drv,
#ifdef CONFIG_DEVRES
INIT_LIST_HEAD(&dev->devres_head);
#endif
dev->platdata = platdata;
dev->plat = plat;
dev->driver_data = driver_data;
dev->name = name;
dev->node = node;
@@ -96,49 +96,49 @@ static int device_bind_common(struct udevice *parent, const struct driver *drv,
}
}
if (drv->platdata_auto) {
bool alloc = !platdata;
if (drv->plat_auto) {
bool alloc = !plat;
if (CONFIG_IS_ENABLED(OF_PLATDATA)) {
if (of_platdata_size) {
dev->flags |= DM_FLAG_OF_PLATDATA;
if (of_platdata_size < drv->platdata_auto)
if (of_platdata_size < drv->plat_auto)
alloc = true;
}
}
if (alloc) {
dev->flags |= DM_FLAG_ALLOC_PDATA;
dev->platdata = calloc(1, drv->platdata_auto);
if (!dev->platdata) {
dev->plat = calloc(1, drv->plat_auto);
if (!dev->plat) {
ret = -ENOMEM;
goto fail_alloc1;
}
if (CONFIG_IS_ENABLED(OF_PLATDATA) && platdata) {
memcpy(dev->platdata, platdata,
if (CONFIG_IS_ENABLED(OF_PLATDATA) && plat) {
memcpy(dev->plat, plat,
of_platdata_size);
}
}
}
size = uc->uc_drv->per_device_platdata_auto;
size = uc->uc_drv->per_device_plat_auto;
if (size) {
dev->flags |= DM_FLAG_ALLOC_UCLASS_PDATA;
dev->uclass_platdata = calloc(1, size);
if (!dev->uclass_platdata) {
dev->uclass_plat = calloc(1, size);
if (!dev->uclass_plat) {
ret = -ENOMEM;
goto fail_alloc2;
}
}
if (parent) {
size = parent->driver->per_child_platdata_auto;
size = parent->driver->per_child_plat_auto;
if (!size) {
size = parent->uclass->uc_drv->per_child_platdata_auto;
size = parent->uclass->uc_drv->per_child_plat_auto;
}
if (size) {
dev->flags |= DM_FLAG_ALLOC_PARENT_PDATA;
dev->parent_platdata = calloc(1, size);
if (!dev->parent_platdata) {
dev->parent_plat = calloc(1, size);
if (!dev->parent_plat) {
ret = -ENOMEM;
goto fail_alloc3;
}
@@ -198,19 +198,19 @@ fail_uclass_bind:
if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
list_del(&dev->sibling_node);
if (dev->flags & DM_FLAG_ALLOC_PARENT_PDATA) {
free(dev->parent_platdata);
dev->parent_platdata = NULL;
free(dev->parent_plat);
dev->parent_plat = NULL;
}
}
fail_alloc3:
if (dev->flags & DM_FLAG_ALLOC_UCLASS_PDATA) {
free(dev->uclass_platdata);
dev->uclass_platdata = NULL;
free(dev->uclass_plat);
dev->uclass_plat = NULL;
}
fail_alloc2:
if (dev->flags & DM_FLAG_ALLOC_PDATA) {
free(dev->platdata);
dev->platdata = NULL;
free(dev->plat);
dev->plat = NULL;
}
fail_alloc1:
devres_release_all(dev);
@@ -230,10 +230,10 @@ int device_bind_with_driver_data(struct udevice *parent,
}
int device_bind(struct udevice *parent, const struct driver *drv,
const char *name, void *platdata, ofnode node,
const char *name, void *plat, ofnode node,
struct udevice **devp)
{
return device_bind_common(parent, drv, name, platdata, 0, node, 0,
return device_bind_common(parent, drv, name, plat, 0, node, 0,
devp);
}
@@ -253,9 +253,8 @@ int device_bind_by_name(struct udevice *parent, bool pre_reloc_only,
#if CONFIG_IS_ENABLED(OF_PLATDATA)
platdata_size = info->platdata_size;
#endif
ret = device_bind_common(parent, drv, info->name,
(void *)info->platdata, 0, ofnode_null(),
platdata_size, devp);
ret = device_bind_common(parent, drv, info->name, (void *)info->plat, 0,
ofnode_null(), platdata_size, devp);
if (ret)
return ret;
@@ -526,27 +525,27 @@ void *dev_get_platdata(const struct udevice *dev)
return NULL;
}
return dev->platdata;
return dev->plat;
}
void *dev_get_parent_platdata(const struct udevice *dev)
void *dev_get_parent_plat(const struct udevice *dev)
{
if (!dev) {
dm_warn("%s: null device\n", __func__);
return NULL;
}
return dev->parent_platdata;
return dev->parent_plat;
}
void *dev_get_uclass_platdata(const struct udevice *dev)
void *dev_get_uclass_plat(const struct udevice *dev)
{
if (!dev) {
dm_warn("%s: null device\n", __func__);
return NULL;
}
return dev->uclass_platdata;
return dev->uclass_plat;
}
void *dev_get_priv(const struct udevice *dev)

2
drivers/core/dump.c
View File

@@ -170,6 +170,6 @@ void dm_dump_static_driver_info(void)
puts("---------------------------------\n");
for (entry = drv; entry != drv + n_ents; entry++) {
printf("%-25.25s @%08lx\n", entry->name,
(ulong)map_to_sysmem(entry->platdata));
(ulong)map_to_sysmem(entry->plat));
}
}

4
drivers/core/root.c
View File

@@ -123,8 +123,8 @@ void fix_devices(void)
struct driver_info *entry;
for (entry = dev; entry != dev + n_ents; entry++) {
if (entry->platdata)
entry->platdata += gd->reloc_off;
if (entry->plat)
entry->plat += gd->reloc_off;
}
}

6
drivers/core/simple-bus.c
View File

@@ -14,7 +14,7 @@ struct simple_bus_plat {
fdt_addr_t simple_bus_translate(struct udevice *dev, fdt_addr_t addr)
{
struct simple_bus_plat *plat = dev_get_uclass_platdata(dev);
struct simple_bus_plat *plat = dev_get_uclass_plat(dev);
if (addr >= plat->base && addr < plat->base + plat->size)
addr = (addr - plat->base) + plat->target;
@@ -32,7 +32,7 @@ static int simple_bus_post_bind(struct udevice *dev)
ret = dev_read_u32_array(dev, "ranges", cell, ARRAY_SIZE(cell));
if (!ret) {
struct simple_bus_plat *plat = dev_get_uclass_platdata(dev);
struct simple_bus_plat *plat = dev_get_uclass_plat(dev);
plat->base = cell[0];
plat->target = cell[1];
@@ -47,7 +47,7 @@ UCLASS_DRIVER(simple_bus) = {
.id = UCLASS_SIMPLE_BUS,
.name = "simple_bus",
.post_bind = simple_bus_post_bind,
.per_device_platdata_auto = sizeof(struct simple_bus_plat),
.per_device_plat_auto = sizeof(struct simple_bus_plat),
};
static const struct udevice_id generic_simple_bus_ids[] = {

2
drivers/cpu/at91_cpu.c
View File

@@ -118,6 +118,6 @@ U_BOOT_DRIVER(cpu_at91_drv) = {
.of_match = at91_cpu_ids,
.ops = &at91_cpu_ops,
.probe = at91_cpu_probe,
.platdata_auto = sizeof(struct at91_cpu_platdata),
.plat_auto = sizeof(struct at91_cpu_platdata),
.flags = DM_FLAG_PRE_RELOC,
};

2
drivers/cpu/bmips_cpu.c
View File

@@ -425,7 +425,7 @@ static const struct cpu_ops bmips_cpu_ops = {
/* BMIPS CPU driver */
int bmips_cpu_bind(struct udevice *dev)
{
struct cpu_platdata *plat = dev_get_parent_platdata(dev);
struct cpu_platdata *plat = dev_get_parent_plat(dev);
plat->cpu_id = dev_read_u32_default(dev, "reg", -1);
plat->device_id = read_c0_prid();

2
drivers/cpu/cpu-uclass.c
View File

@@ -115,7 +115,7 @@ int cpu_get_vendor(const struct udevice *dev, char *buf, int size)
U_BOOT_DRIVER(cpu_bus) = {
.name = "cpu_bus",
.id = UCLASS_SIMPLE_BUS,
.per_child_platdata_auto = sizeof(struct cpu_platdata),
.per_child_plat_auto = sizeof(struct cpu_platdata),
};
static int uclass_cpu_init(struct uclass *uc)

2
drivers/cpu/cpu_sandbox.c
View File

@@ -64,7 +64,7 @@ static const struct cpu_ops cpu_sandbox_ops = {
static int cpu_sandbox_bind(struct udevice *dev)
{
int ret;
struct cpu_platdata *plat = dev_get_parent_platdata(dev);
struct cpu_platdata *plat = dev_get_parent_plat(dev);
/* first examine the property in current cpu node */
ret = dev_read_u32(dev, "timebase-frequency", &plat->timebase_freq);

2
drivers/cpu/imx8_cpu.c
View File

@@ -230,6 +230,6 @@ U_BOOT_DRIVER(cpu_imx8_drv) = {
.of_match = cpu_imx8_ids,
.ops = &cpu_imx8_ops,
.probe = imx8_cpu_probe,
.platdata_auto = sizeof(struct cpu_imx_platdata),
.plat_auto = sizeof(struct cpu_imx_platdata),
.flags = DM_FLAG_PRE_RELOC,
};

2
drivers/cpu/riscv_cpu.c
View File

@@ -91,7 +91,7 @@ static int riscv_cpu_get_count(const struct udevice *dev)
static int riscv_cpu_bind(struct udevice *dev)
{
struct cpu_platdata *plat = dev_get_parent_platdata(dev);
struct cpu_platdata *plat = dev_get_parent_plat(dev);
struct driver *drv;
int ret;

2
drivers/ddr/altera/sdram_agilex.c
View File

@@ -25,7 +25,7 @@ DECLARE_GLOBAL_DATA_PTR;
int sdram_mmr_init_full(struct udevice *dev)
{
struct altera_sdram_platdata *plat = dev->platdata;
struct altera_sdram_platdata *plat = dev->plat;
struct altera_sdram_priv *priv = dev_get_priv(dev);
u32 i;
int ret;

6
drivers/ddr/altera/sdram_gen5.c
View File

@@ -565,7 +565,7 @@ static unsigned long sdram_calculate_size(struct socfpga_sdr_ctrl *sdr_ctrl)
static int altera_gen5_sdram_ofdata_to_platdata(struct udevice *dev)
{
struct altera_gen5_sdram_platdata *plat = dev->platdata;
struct altera_gen5_sdram_platdata *plat = dev->plat;
plat->sdr = (struct socfpga_sdr *)devfdt_get_addr_index(dev, 0);
if (!plat->sdr)
@@ -578,7 +578,7 @@ static int altera_gen5_sdram_probe(struct udevice *dev)
{
int ret;
unsigned long sdram_size;
struct altera_gen5_sdram_platdata *plat = dev->platdata;
struct altera_gen5_sdram_platdata *plat = dev->plat;
struct altera_gen5_sdram_priv *priv = dev_get_priv(dev);
struct socfpga_sdr_ctrl *sdr_ctrl = &plat->sdr->sdr_ctrl;
struct reset_ctl_bulk resets;
@@ -647,7 +647,7 @@ U_BOOT_DRIVER(altera_gen5_sdram) = {
.of_match = altera_gen5_sdram_ids,
.ops = &altera_gen5_sdram_ops,
.ofdata_to_platdata = altera_gen5_sdram_ofdata_to_platdata,
.platdata_auto = sizeof(struct altera_gen5_sdram_platdata),
.plat_auto = sizeof(struct altera_gen5_sdram_platdata),
.probe = altera_gen5_sdram_probe,
.priv_auto = sizeof(struct altera_gen5_sdram_priv),
};

2
drivers/ddr/altera/sdram_s10.c
View File

@@ -70,7 +70,7 @@ int match_ddr_conf(u32 ddr_conf)
*/
int sdram_mmr_init_full(struct udevice *dev)
{
struct altera_sdram_platdata *plat = dev->platdata;
struct altera_sdram_platdata *plat = dev->plat;
struct altera_sdram_priv *priv = dev_get_priv(dev);
u32 update_value, io48_value, ddrioctl;
u32 i;

4
drivers/ddr/altera/sdram_soc64.c
View File

@@ -232,7 +232,7 @@ phys_size_t sdram_calculate_size(struct altera_sdram_platdata *plat)
static int altera_sdram_ofdata_to_platdata(struct udevice *dev)
{
struct altera_sdram_platdata *plat = dev->platdata;
struct altera_sdram_platdata *plat = dev->plat;
fdt_addr_t addr;
addr = dev_read_addr_index(dev, 0);
@@ -304,7 +304,7 @@ U_BOOT_DRIVER(altera_sdram) = {
.of_match = altera_sdram_ids,
.ops = &altera_sdram_ops,
.ofdata_to_platdata = altera_sdram_ofdata_to_platdata,
.platdata_auto = sizeof(struct altera_sdram_platdata),
.plat_auto = sizeof(struct altera_sdram_platdata),
.probe = altera_sdram_probe,
.priv_auto = sizeof(struct altera_sdram_priv),
};

10
drivers/demo/demo-pdata.c
View File

@@ -22,25 +22,25 @@ static const struct dm_demo_pdata yellow_hexagon = {
U_BOOT_DEVICE(demo0) = {
.name = "demo_shape_drv",
.platdata = &red_square,
.plat = &red_square,
};
U_BOOT_DEVICE(demo1) = {
.name = "demo_simple_drv",
.platdata = &red_square,
.plat = &red_square,
};
U_BOOT_DEVICE(demo2) = {
.name = "demo_shape_drv",
.platdata = &green_triangle,
.plat = &green_triangle,
};
U_BOOT_DEVICE(demo3) = {
.name = "demo_simple_drv",
.platdata = &yellow_hexagon,
.plat = &yellow_hexagon,
};
U_BOOT_DEVICE(demo4) = {
.name = "demo_shape_drv",
.platdata = &yellow_hexagon,
.plat = &yellow_hexagon,
};

2
drivers/demo/demo-shape.c
View File

@@ -194,5 +194,5 @@ U_BOOT_DRIVER(demo_shape_drv) = {
.probe = dm_shape_probe,
.remove = dm_shape_remove,
.priv_auto = sizeof(struct shape_data),
.platdata_auto = sizeof(struct dm_demo_pdata),
.plat_auto = sizeof(struct dm_demo_pdata),
};

2
drivers/demo/demo-simple.c
View File

@@ -43,5 +43,5 @@ U_BOOT_DRIVER(demo_simple_drv) = {
.id = UCLASS_DEMO,
.ofdata_to_platdata = demo_shape_ofdata_to_platdata,
.ops = &simple_ops,
.platdata_auto = sizeof(struct dm_demo_pdata),
.plat_auto = sizeof(struct dm_demo_pdata),
};

2
drivers/gpio/altera_pio.c
View File

@@ -117,6 +117,6 @@ U_BOOT_DRIVER(altera_pio) = {
.of_match = altera_pio_ids,
.ops = &altera_pio_ops,
.ofdata_to_platdata = altera_pio_ofdata_to_platdata,
.platdata_auto = sizeof(struct altera_pio_platdata),
.plat_auto = sizeof(struct altera_pio_platdata),
.probe = altera_pio_probe,
};

2
drivers/gpio/at91_gpio.c
View File

@@ -629,7 +629,7 @@ U_BOOT_DRIVER(atmel_at91rm9200_gpio) = {
.id = UCLASS_GPIO,
#if CONFIG_IS_ENABLED(OF_CONTROL)
.of_match = at91_gpio_ids,
.platdata_auto = sizeof(struct at91_port_platdata),
.plat_auto = sizeof(struct at91_port_platdata),
#endif
.ops = &gpio_at91_ops,
.probe = at91_gpio_probe,

2
drivers/gpio/atmel_pio4.c
View File

@@ -338,7 +338,7 @@ U_BOOT_DRIVER(gpio_atmel_pio4) = {
.probe = atmel_pio4_probe,
.bind = atmel_pio4_bind,
.of_match = atmel_pio4_ids,
.platdata_auto = sizeof(struct atmel_pio4_platdata),
.plat_auto = sizeof(struct atmel_pio4_platdata),
};
#endif

2
drivers/gpio/bcm2835_gpio.c
View File

@@ -134,7 +134,7 @@ U_BOOT_DRIVER(gpio_bcm2835) = {
.name = "gpio_bcm2835",
.id = UCLASS_GPIO,
.ofdata_to_platdata = of_match_ptr(bcm2835_gpio_ofdata_to_platdata),
.platdata_auto = sizeof(struct bcm2835_gpio_platdata),
.plat_auto = sizeof(struct bcm2835_gpio_platdata),
.ops = &gpio_bcm2835_ops,
.probe = bcm2835_gpio_probe,
.flags = DM_FLAG_PRE_RELOC,

2
drivers/gpio/da8xx_gpio.c
View File

@@ -560,7 +560,7 @@ U_BOOT_DRIVER(ti_dm6441_gpio) = {
.ofdata_to_platdata = of_match_ptr(davinci_gpio_ofdata_to_platdata),
.of_match = davinci_gpio_ids,
.bind = dm_scan_fdt_dev,
.platdata_auto = sizeof(struct davinci_gpio_platdata),
.plat_auto = sizeof(struct davinci_gpio_platdata),
.probe = davinci_gpio_probe,
.priv_auto = sizeof(struct davinci_gpio_bank),
};

2
drivers/gpio/dwapb_gpio.c
View File

@@ -141,7 +141,7 @@ static int gpio_dwapb_reset(struct udevice *dev)
static int gpio_dwapb_probe(struct udevice *dev)
{
struct gpio_dev_priv *priv = dev_get_uclass_priv(dev);
struct gpio_dwapb_platdata *plat = dev->platdata;
struct gpio_dwapb_platdata *plat = dev->plat;
if (!plat) {
/* Reset on parent device only */

2
drivers/gpio/gpio-uclass.c
View File

@@ -341,7 +341,7 @@ U_BOOT_DRIVER(gpio_hog) = {
.ofdata_to_platdata = gpio_hog_ofdata_to_platdata,
.probe = gpio_hog_probe,
.priv_auto = sizeof(struct gpio_hog_priv),
.platdata_auto = sizeof(struct gpio_hog_data),
.plat_auto = sizeof(struct gpio_hog_data),
};
#else
int gpio_hog_lookup_name(const char *name, struct gpio_desc **desc)

2
drivers/gpio/hsdk-creg-gpio.c
View File

@@ -165,5 +165,5 @@ U_BOOT_DRIVER(gpio_hsdk_creg) = {
.ops = &hsdk_creg_gpio_ops,
.probe = hsdk_creg_gpio_probe,
.of_match = hsdk_creg_gpio_ids,
.platdata_auto = sizeof(struct hsdk_creg_gpio),
.plat_auto = sizeof(struct hsdk_creg_gpio),
};

10
drivers/gpio/imx_rgpio2p.c
View File

@@ -151,12 +151,12 @@ static int imx_rgpio2p_probe(struct udevice *dev)
static int imx_rgpio2p_bind(struct udevice *dev)
{
struct imx_rgpio2p_plat *plat = dev->platdata;
struct imx_rgpio2p_plat *plat = dev->plat;
fdt_addr_t addr;
/*
* If platdata already exsits, directly return.
* Actually only when DT is not supported, platdata
* If plat already exsits, directly return.
* Actually only when DT is not supported, plat
* is statically initialized in U_BOOT_DEVICES.Here
* will return.
*/
@@ -171,7 +171,7 @@ static int imx_rgpio2p_bind(struct udevice *dev)
* TODO:
* When every board is converted to driver model and DT is supported,
* this can be done by auto-alloc feature, but not using calloc
* to alloc memory for platdata.
* to alloc memory for plat.
*
* For example imx_rgpio2p_plat uses platform data rather than device
* tree.
@@ -184,7 +184,7 @@ static int imx_rgpio2p_bind(struct udevice *dev)
plat->regs = (struct gpio_regs *)addr;
plat->bank_index = dev->req_seq;
dev->platdata = plat;
dev->plat = plat;
return 0;
}

2
drivers/gpio/intel_broadwell_gpio.c
View File

@@ -185,5 +185,5 @@ U_BOOT_DRIVER(gpio_broadwell) = {
.ofdata_to_platdata = broadwell_gpio_ofdata_to_platdata,
.probe = broadwell_gpio_probe,
.priv_auto = sizeof(struct broadwell_bank_priv),
.platdata_auto = sizeof(struct broadwell_bank_platdata),
.plat_auto = sizeof(struct broadwell_bank_platdata),
};

2
drivers/gpio/intel_ich6_gpio.c
View File

@@ -237,5 +237,5 @@ U_BOOT_DRIVER(gpio_ich6) = {
.ofdata_to_platdata = gpio_ich6_ofdata_to_platdata,
.probe = ich6_gpio_probe,
.priv_auto = sizeof(struct ich6_bank_priv),
.platdata_auto = sizeof(struct ich6_bank_platdata),
.plat_auto = sizeof(struct ich6_bank_platdata),
};

2
drivers/gpio/iproc_gpio.c
View File

@@ -286,5 +286,5 @@ U_BOOT_DRIVER(iproc_gpio) = {
.of_match = iproc_gpio_ids,
.ops = &iproc_gpio_ops,
.ofdata_to_platdata = iproc_gpio_ofdata_to_platdata,
.platdata_auto = sizeof(struct iproc_gpio_platdata),
.plat_auto = sizeof(struct iproc_gpio_platdata),
};

2
drivers/gpio/mpc83xx_spisel_boot.c
View File

@@ -141,7 +141,7 @@ U_BOOT_DRIVER(spisel_boot_mpc83xx) = {
.ops = &mpc83xx_spisel_boot_ops,
#if CONFIG_IS_ENABLED(OF_CONTROL)
.ofdata_to_platdata = mpc83xx_spisel_boot_ofdata_to_platdata,
.platdata_auto = sizeof(struct mpc8xxx_gpio_plat),
.plat_auto = sizeof(struct mpc8xxx_gpio_plat),
.of_match = mpc83xx_spisel_boot_ids,
#endif
.probe = mpc83xx_spisel_boot_probe,

2
drivers/gpio/mpc8xxx_gpio.c
View File

@@ -295,7 +295,7 @@ U_BOOT_DRIVER(gpio_mpc8xxx) = {
.ops = &gpio_mpc8xxx_ops,
#if CONFIG_IS_ENABLED(OF_CONTROL)
.ofdata_to_platdata = mpc8xxx_gpio_ofdata_to_platdata,
.platdata_auto = sizeof(struct mpc8xxx_gpio_plat),
.plat_auto = sizeof(struct mpc8xxx_gpio_plat),
.of_match = mpc8xxx_gpio_ids,
#endif
.probe = mpc8xxx_gpio_probe,

2
drivers/gpio/mt7621_gpio.c
View File

@@ -130,7 +130,7 @@ static int gpio_mediatek_probe(struct udevice *dev)
*/
static int gpio_mediatek_bind(struct udevice *parent)
{
struct mediatek_gpio_platdata *plat = parent->platdata;
struct mediatek_gpio_platdata *plat = parent->plat;
ofnode node;
int bank = 0;
int ret;

2
drivers/gpio/mxc_gpio.c
View File

@@ -339,7 +339,7 @@ U_BOOT_DRIVER(gpio_mxc) = {
.ops = &gpio_mxc_ops,
.probe = mxc_gpio_probe,
.ofdata_to_platdata = mxc_gpio_ofdata_to_platdata,
.platdata_auto = sizeof(struct mxc_gpio_plat),
.plat_auto = sizeof(struct mxc_gpio_plat),
.priv_auto = sizeof(struct mxc_bank_info),
.of_match = mxc_gpio_ids,
.bind = mxc_gpio_bind,

4
drivers/gpio/mxs_gpio.c
View File

@@ -264,7 +264,7 @@ static int mxs_gpio_probe(struct udevice *dev)
#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
static int mxs_ofdata_to_platdata(struct udevice *dev)
{
struct mxs_gpio_platdata *plat = dev->platdata;
struct mxs_gpio_platdata *plat = dev->plat;
struct fdtdec_phandle_args args;
int node = dev_of_offset(dev);
int ret;
@@ -299,7 +299,7 @@ U_BOOT_DRIVER(fsl_imx23_gpio) = {
.ops = &gpio_mxs_ops,
.probe = mxs_gpio_probe,
.priv_auto = sizeof(struct mxs_gpio_priv),
.platdata_auto = sizeof(struct mxs_gpio_platdata),
.plat_auto = sizeof(struct mxs_gpio_platdata),
#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
.of_match = mxs_gpio_ids,
.ofdata_to_platdata = mxs_ofdata_to_platdata,

2
drivers/gpio/nx_gpio.c
View File

@@ -245,6 +245,6 @@ U_BOOT_DRIVER(nx_gpio) = {
.of_match = nx_gpio_ids,
.ops = &nx_gpio_ops,
.ofdata_to_platdata = nx_gpio_ofdata_to_platdata,
.platdata_auto = sizeof(struct nx_gpio_platdata),
.plat_auto = sizeof(struct nx_gpio_platdata),
.probe = nx_gpio_probe,
};

6
drivers/gpio/omap_gpio.c
View File

@@ -316,7 +316,7 @@ static int omap_gpio_bind(struct udevice *dev)
* TODO:
* When every board is converted to driver model and DT is
* supported, this can be done by auto-alloc feature, but
* not using calloc to alloc memory for platdata.
* not using calloc to alloc memory for plat.
*
* For example am33xx_gpio uses platform data rather than device tree.
*
@@ -328,7 +328,7 @@ static int omap_gpio_bind(struct udevice *dev)
plat->base = base_addr;
plat->port_name = fdt_get_name(gd->fdt_blob, dev_of_offset(dev), NULL);
dev->platdata = plat;
dev->plat = plat;
return 0;
}
@@ -363,7 +363,7 @@ U_BOOT_DRIVER(gpio_omap) = {
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
.of_match = omap_gpio_ids,
.ofdata_to_platdata = of_match_ptr(omap_gpio_ofdata_to_platdata),
.platdata_auto = sizeof(struct omap_gpio_platdata),
.plat_auto = sizeof(struct omap_gpio_platdata),
#endif
#else
.bind = omap_gpio_bind,

2
drivers/gpio/pca953x_gpio.c
View File

@@ -385,6 +385,6 @@ U_BOOT_DRIVER(pca953x) = {
.id = UCLASS_GPIO,
.ops = &pca953x_ops,
.probe = pca953x_probe,
.platdata_auto = sizeof(struct pca953x_info),
.plat_auto = sizeof(struct pca953x_info),
.of_match = pca953x_ids,
};

6
drivers/gpio/pcf8575_gpio.c
View File

@@ -55,7 +55,7 @@ struct pcf8575_chip {
static int pcf8575_i2c_write_le16(struct udevice *dev, unsigned int word)
{
struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
u8 buf[2] = { word & 0xff, word >> 8, };
int ret;
@@ -69,7 +69,7 @@ static int pcf8575_i2c_write_le16(struct udevice *dev, unsigned int word)
static int pcf8575_i2c_read_le16(struct udevice *dev)
{
struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
u8 buf[2];
int ret;
@@ -177,5 +177,5 @@ U_BOOT_DRIVER(gpio_pcf8575) = {
.of_match = pcf8575_gpio_ids,
.ofdata_to_platdata = pcf8575_ofdata_platdata,
.probe = pcf8575_gpio_probe,
.platdata_auto = sizeof(struct pcf8575_chip),
.plat_auto = sizeof(struct pcf8575_chip),
};

4
drivers/gpio/s5p_gpio.c
View File

@@ -287,7 +287,7 @@ static int gpio_exynos_probe(struct udevice *dev)
{
struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
struct exynos_bank_info *priv = dev->priv;
struct exynos_gpio_platdata *plat = dev->platdata;
struct exynos_gpio_platdata *plat = dev->plat;
/* Only child devices have ports */
if (!plat)
@@ -307,7 +307,7 @@ static int gpio_exynos_probe(struct udevice *dev)
*/
static int gpio_exynos_bind(struct udevice *parent)
{
struct exynos_gpio_platdata *plat = parent->platdata;
struct exynos_gpio_platdata *plat = parent->plat;
struct s5p_gpio_bank *bank, *base;
const void *blob = gd->fdt_blob;
int node;

2
drivers/gpio/sifive-gpio.c
View File

@@ -172,7 +172,7 @@ U_BOOT_DRIVER(gpio_sifive) = {
.id = UCLASS_GPIO,
.of_match = sifive_gpio_match,
.ofdata_to_platdata = of_match_ptr(sifive_gpio_ofdata_to_platdata),
.platdata_auto = sizeof(struct sifive_gpio_platdata),
.plat_auto = sizeof(struct sifive_gpio_platdata),
.ops = &sifive_gpio_ops,
.probe = sifive_gpio_probe,
};

2
drivers/gpio/sunxi_gpio.c
View File

@@ -285,7 +285,7 @@ static int gpio_sunxi_bind(struct udevice *parent)
{
struct sunxi_gpio_soc_data *soc_data =
(struct sunxi_gpio_soc_data *)dev_get_driver_data(parent);
struct sunxi_gpio_platdata *plat = parent->platdata;
struct sunxi_gpio_platdata *plat = parent->plat;
struct sunxi_gpio_reg *ctlr;
int bank, ret;

6
drivers/gpio/tegra186_gpio.c
View File

@@ -34,7 +34,7 @@ struct tegra186_gpio_platdata {
static uint32_t *tegra186_gpio_reg(struct udevice *dev, uint32_t reg,
uint32_t gpio)
{
struct tegra186_gpio_platdata *plat = dev->platdata;
struct tegra186_gpio_platdata *plat = dev->plat;
uint32_t index = (reg + (gpio * TEGRA186_GPIO_PER_GPIO_STRIDE)) / 4;
return &(plat->regs[index]);
@@ -166,7 +166,7 @@ static const struct dm_gpio_ops tegra186_gpio_ops = {
*/
static int tegra186_gpio_bind(struct udevice *parent)
{
struct tegra186_gpio_platdata *parent_plat = parent->platdata;
struct tegra186_gpio_platdata *parent_plat = parent->plat;
struct tegra186_gpio_ctlr_data *ctlr_data =
(struct tegra186_gpio_ctlr_data *)dev_get_driver_data(parent);
uint32_t *regs;
@@ -201,7 +201,7 @@ static int tegra186_gpio_bind(struct udevice *parent)
static int tegra186_gpio_probe(struct udevice *dev)
{
struct tegra186_gpio_platdata *plat = dev->platdata;
struct tegra186_gpio_platdata *plat = dev->plat;
struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
/* Only child devices have ports */

4
drivers/gpio/tegra_gpio.c
View File

@@ -292,7 +292,7 @@ static int gpio_tegra_probe(struct udevice *dev)
{
struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
struct tegra_port_info *priv = dev->priv;
struct tegra_gpio_platdata *plat = dev->platdata;
struct tegra_gpio_platdata *plat = dev->plat;
/* Only child devices have ports */
if (!plat)
@@ -313,7 +313,7 @@ static int gpio_tegra_probe(struct udevice *dev)
*/
static int gpio_tegra_bind(struct udevice *parent)
{
struct tegra_gpio_platdata *plat = parent->platdata;
struct tegra_gpio_platdata *plat = parent->plat;
struct gpio_ctlr *ctlr;
int bank_count;
int bank;

2
drivers/gpio/vybrid_gpio.c
View File

@@ -133,5 +133,5 @@ U_BOOT_DRIVER(gpio_vybrid) = {
.ofdata_to_platdata = vybrid_gpio_odata_to_platdata,
.probe = vybrid_gpio_probe,
.priv_auto = sizeof(struct vybrid_gpios),
.platdata_auto = sizeof(struct vybrid_gpio_platdata),
.plat_auto = sizeof(struct vybrid_gpio_platdata),
};

92
drivers/gpio/xilinx_gpio.c
View File

@@ -36,13 +36,13 @@ struct xilinx_gpio_privdata {
static int xilinx_gpio_get_bank_pin(unsigned offset, u32 *bank_num,
u32 *bank_pin_num, struct udevice *dev)
{
struct xilinx_gpio_platdata *platdata = dev_get_platdata(dev);
struct xilinx_gpio_platdata *plat = dev_get_platdata(dev);
u32 bank, max_pins;
/* the first gpio is 0 not 1 */
u32 pin_num = offset;
for (bank = 0; bank < XILINX_GPIO_MAX_BANK; bank++) {
max_pins = platdata->bank_max[bank];
max_pins = plat->bank_max[bank];
if (pin_num < max_pins) {
debug("%s: found at bank 0x%x pin 0x%x\n", __func__,
bank, pin_num);
@@ -59,7 +59,7 @@ static int xilinx_gpio_get_bank_pin(unsigned offset, u32 *bank_num,
static int xilinx_gpio_set_value(struct udevice *dev, unsigned offset,
int value)
{
struct xilinx_gpio_platdata *platdata = dev_get_platdata(dev);
struct xilinx_gpio_platdata *plat = dev_get_platdata(dev);
struct xilinx_gpio_privdata *priv = dev_get_priv(dev);
int val, ret;
u32 bank, pin;
@@ -71,14 +71,14 @@ static int xilinx_gpio_set_value(struct udevice *dev, unsigned offset,
val = priv->output_val[bank];
debug("%s: regs: %lx, value: %x, gpio: %x, bank %x, pin %x, out %x\n",
__func__, (ulong)platdata->regs, value, offset, bank, pin, val);
__func__, (ulong)plat->regs, value, offset, bank, pin, val);
if (value)
val = val | (1 << pin);
else
val = val & ~(1 << pin);
writel(val, &platdata->regs->gpiodata + bank * 2);
writel(val, &plat->regs->gpiodata + bank * 2);
priv->output_val[bank] = val;
@@ -87,7 +87,7 @@ static int xilinx_gpio_set_value(struct udevice *dev, unsigned offset,
static int xilinx_gpio_get_value(struct udevice *dev, unsigned offset)
{
struct xilinx_gpio_platdata *platdata = dev_get_platdata(dev);
struct xilinx_gpio_platdata *plat = dev_get_platdata(dev);
struct xilinx_gpio_privdata *priv = dev_get_priv(dev);
int val, ret;
u32 bank, pin;
@@ -97,14 +97,14 @@ static int xilinx_gpio_get_value(struct udevice *dev, unsigned offset)
return ret;
debug("%s: regs: %lx, gpio: %x, bank %x, pin %x\n", __func__,
(ulong)platdata->regs, offset, bank, pin);
(ulong)plat->regs, offset, bank, pin);
if (platdata->bank_output[bank]) {
if (plat->bank_output[bank]) {
debug("%s: Read saved output value\n", __func__);
val = priv->output_val[bank];
} else {
debug("%s: Read input value from reg\n", __func__);
val = readl(&platdata->regs->gpiodata + bank * 2);
val = readl(&plat->regs->gpiodata + bank * 2);
}
val = !!(val & (1 << pin));
@@ -114,7 +114,7 @@ static int xilinx_gpio_get_value(struct udevice *dev, unsigned offset)
static int xilinx_gpio_get_function(struct udevice *dev, unsigned offset)
{
struct xilinx_gpio_platdata *platdata = dev_get_platdata(dev);
struct xilinx_gpio_platdata *plat = dev_get_platdata(dev);
int val, ret;
u32 bank, pin;
@@ -123,15 +123,15 @@ static int xilinx_gpio_get_function(struct udevice *dev, unsigned offset)
return ret;
/* Check if all pins are inputs */
if (platdata->bank_input[bank])
if (plat->bank_input[bank])
return GPIOF_INPUT;
/* Check if all pins are outputs */
if (platdata->bank_output[bank])
if (plat->bank_output[bank])
return GPIOF_OUTPUT;
/* FIXME test on dual */
val = readl(&platdata->regs->gpiodir + bank * 2);
val = readl(&plat->regs->gpiodir + bank * 2);
val = !(val & (1 << pin));
/* input is 1 in reg but GPIOF_INPUT is 0 */
@@ -143,7 +143,7 @@ static int xilinx_gpio_get_function(struct udevice *dev, unsigned offset)
static int xilinx_gpio_direction_output(struct udevice *dev, unsigned offset,
int value)
{
struct xilinx_gpio_platdata *platdata = dev_get_platdata(dev);
struct xilinx_gpio_platdata *plat = dev_get_platdata(dev);
int val, ret;
u32 bank, pin;
@@ -152,15 +152,15 @@ static int xilinx_gpio_direction_output(struct udevice *dev, unsigned offset,
return ret;
/* can't change it if all is input by default */
if (platdata->bank_input[bank])
if (plat->bank_input[bank])
return -EINVAL;
xilinx_gpio_set_value(dev, offset, value);
if (!platdata->bank_output[bank]) {
val = readl(&platdata->regs->gpiodir + bank * 2);
if (!plat->bank_output[bank]) {
val = readl(&plat->regs->gpiodir + bank * 2);
val = val & ~(1 << pin);
writel(val, &platdata->regs->gpiodir + bank * 2);
writel(val, &plat->regs->gpiodir + bank * 2);
}
return 0;
@@ -168,7 +168,7 @@ static int xilinx_gpio_direction_output(struct udevice *dev, unsigned offset,
static int xilinx_gpio_direction_input(struct udevice *dev, unsigned offset)
{
struct xilinx_gpio_platdata *platdata = dev_get_platdata(dev);
struct xilinx_gpio_platdata *plat = dev_get_platdata(dev);
int val, ret;
u32 bank, pin;
@@ -177,16 +177,16 @@ static int xilinx_gpio_direction_input(struct udevice *dev, unsigned offset)
return ret;
/* Already input */
if (platdata->bank_input[bank])
if (plat->bank_input[bank])
return 0;
/* can't change it if all is output by default */
if (platdata->bank_output[bank])
if (plat->bank_output[bank])
return -EINVAL;
val = readl(&platdata->regs->gpiodir + bank * 2);
val = readl(&plat->regs->gpiodir + bank * 2);
val = val | (1 << pin);
writel(val, &platdata->regs->gpiodir + bank * 2);
writel(val, &plat->regs->gpiodir + bank * 2);
return 0;
}
@@ -194,7 +194,7 @@ static int xilinx_gpio_direction_input(struct udevice *dev, unsigned offset)
static int xilinx_gpio_xlate(struct udevice *dev, struct gpio_desc *desc,
struct ofnode_phandle_args *args)
{
struct xilinx_gpio_platdata *platdata = dev_get_platdata(dev);
struct xilinx_gpio_platdata *plat = dev_get_platdata(dev);
desc->offset = args->args[0];
@@ -209,13 +209,13 @@ static int xilinx_gpio_xlate(struct udevice *dev, struct gpio_desc *desc,
* add amount of pins in second channel if present.
*/
if (args->args[1]) {
if (!platdata->bank_max[1]) {
if (!plat->bank_max[1]) {
printf("%s: %s has no second channel\n",
__func__, dev->name);
return -EINVAL;
}
desc->offset += platdata->bank_max[0];
desc->offset += plat->bank_max[0];
}
/* The third cell is optional */
@@ -239,7 +239,7 @@ static const struct dm_gpio_ops xilinx_gpio_ops = {
static int xilinx_gpio_probe(struct udevice *dev)
{
struct xilinx_gpio_platdata *platdata = dev_get_platdata(dev);
struct xilinx_gpio_platdata *plat = dev_get_platdata(dev);
struct xilinx_gpio_privdata *priv = dev_get_priv(dev);
struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
const void *label_ptr;
@@ -253,42 +253,38 @@ static int xilinx_gpio_probe(struct udevice *dev)
uc_priv->bank_name = dev->name;
}
uc_priv->gpio_count = platdata->bank_max[0] + platdata->bank_max[1];
uc_priv->gpio_count = plat->bank_max[0] + plat->bank_max[1];
priv->output_val[0] = platdata->dout_default[0];
priv->output_val[0] = plat->dout_default[0];
if (platdata->bank_max[1])
priv->output_val[1] = platdata->dout_default[1];
if (plat->bank_max[1])
priv->output_val[1] = plat->dout_default[1];
return 0;
}
static int xilinx_gpio_ofdata_to_platdata(struct udevice *dev)
{
struct xilinx_gpio_platdata *platdata = dev_get_platdata(dev);
struct xilinx_gpio_platdata *plat = dev_get_platdata(dev);
int is_dual;
platdata->regs = (struct gpio_regs *)dev_read_addr(dev);
plat->regs = (struct gpio_regs *)dev_read_addr(dev);
platdata->bank_max[0] = dev_read_u32_default(dev,
"xlnx,gpio-width", 0);
platdata->bank_input[0] = dev_read_u32_default(dev,
"xlnx,all-inputs", 0);
platdata->bank_output[0] = dev_read_u32_default(dev,
"xlnx,all-outputs", 0);
platdata->dout_default[0] = dev_read_u32_default(dev,
"xlnx,dout-default",
0);
plat->bank_max[0] = dev_read_u32_default(dev, "xlnx,gpio-width", 0);
plat->bank_input[0] = dev_read_u32_default(dev, "xlnx,all-inputs", 0);
plat->bank_output[0] = dev_read_u32_default(dev, "xlnx,all-outputs", 0);
plat->dout_default[0] = dev_read_u32_default(dev, "xlnx,dout-default",
0);
is_dual = dev_read_u32_default(dev, "xlnx,is-dual", 0);
if (is_dual) {
platdata->bank_max[1] = dev_read_u32_default(dev,
"xlnx,gpio2-width", 0);
platdata->bank_input[1] = dev_read_u32_default(dev,
plat->bank_max[1] = dev_read_u32_default(dev,
"xlnx,gpio2-width", 0);
plat->bank_input[1] = dev_read_u32_default(dev,
"xlnx,all-inputs-2", 0);
platdata->bank_output[1] = dev_read_u32_default(dev,
plat->bank_output[1] = dev_read_u32_default(dev,
"xlnx,all-outputs-2", 0);
platdata->dout_default[1] = dev_read_u32_default(dev,
plat->dout_default[1] = dev_read_u32_default(dev,
"xlnx,dout-default-2", 0);
}
@@ -307,6 +303,6 @@ U_BOOT_DRIVER(xilinx_gpio) = {
.of_match = xilinx_gpio_ids,
.ofdata_to_platdata = xilinx_gpio_ofdata_to_platdata,
.probe = xilinx_gpio_probe,
.platdata_auto = sizeof(struct xilinx_gpio_platdata),
.plat_auto = sizeof(struct xilinx_gpio_platdata),
.priv_auto = sizeof(struct xilinx_gpio_privdata),
};

58
drivers/gpio/zynq_gpio.c
View File

@@ -193,20 +193,20 @@ static inline void zynq_gpio_get_bank_pin(unsigned int pin_num,
unsigned int *bank_pin_num,
struct udevice *dev)
{
struct zynq_gpio_platdata *platdata = dev_get_platdata(dev);
struct zynq_gpio_platdata *plat = dev_get_platdata(dev);
u32 bank;
for (bank = 0; bank < platdata->p_data->max_bank; bank++) {
if (pin_num >= platdata->p_data->bank_min[bank] &&
pin_num <= platdata->p_data->bank_max[bank]) {
for (bank = 0; bank < plat->p_data->max_bank; bank++) {
if (pin_num >= plat->p_data->bank_min[bank] &&
pin_num <= plat->p_data->bank_max[bank]) {
*bank_num = bank;
*bank_pin_num = pin_num -
platdata->p_data->bank_min[bank];
plat->p_data->bank_min[bank];
return;
}
}
if (bank >= platdata->p_data->max_bank) {
if (bank >= plat->p_data->max_bank) {
printf("Invalid bank and pin num\n");
*bank_num = 0;
*bank_pin_num = 0;
@@ -215,9 +215,9 @@ static inline void zynq_gpio_get_bank_pin(unsigned int pin_num,
static int gpio_is_valid(unsigned gpio, struct udevice *dev)
{
struct zynq_gpio_platdata *platdata = dev_get_platdata(dev);
struct zynq_gpio_platdata *plat = dev_get_platdata(dev);
return gpio < platdata->p_data->ngpio;
return gpio < plat->p_data->ngpio;
}
static int check_gpio(unsigned gpio, struct udevice *dev)
@@ -233,14 +233,14 @@ static int zynq_gpio_get_value(struct udevice *dev, unsigned gpio)
{
u32 data;
unsigned int bank_num, bank_pin_num;
struct zynq_gpio_platdata *platdata = dev_get_platdata(dev);
struct zynq_gpio_platdata *plat = dev_get_platdata(dev);
if (check_gpio(gpio, dev) < 0)
return -1;
zynq_gpio_get_bank_pin(gpio, &bank_num, &bank_pin_num, dev);
data = readl(platdata->base +
data = readl(plat->base +
ZYNQ_GPIO_DATA_RO_OFFSET(bank_num));
return (data >> bank_pin_num) & 1;
@@ -249,7 +249,7 @@ static int zynq_gpio_get_value(struct udevice *dev, unsigned gpio)
static int zynq_gpio_set_value(struct udevice *dev, unsigned gpio, int value)
{
unsigned int reg_offset, bank_num, bank_pin_num;
struct zynq_gpio_platdata *platdata = dev_get_platdata(dev);
struct zynq_gpio_platdata *plat = dev_get_platdata(dev);
if (check_gpio(gpio, dev) < 0)
return -1;
@@ -272,7 +272,7 @@ static int zynq_gpio_set_value(struct udevice *dev, unsigned gpio, int value)
value = ~(1 << (bank_pin_num + ZYNQ_GPIO_MID_PIN_NUM)) &
((value << bank_pin_num) | ZYNQ_GPIO_UPPER_MASK);
writel(value, platdata->base + reg_offset);
writel(value, plat->base + reg_offset);
return 0;
}
@@ -281,7 +281,7 @@ static int zynq_gpio_direction_input(struct udevice *dev, unsigned gpio)
{
u32 reg;
unsigned int bank_num, bank_pin_num;
struct zynq_gpio_platdata *platdata = dev_get_platdata(dev);
struct zynq_gpio_platdata *plat = dev_get_platdata(dev);
if (check_gpio(gpio, dev) < 0)
return -1;
@@ -293,9 +293,9 @@ static int zynq_gpio_direction_input(struct udevice *dev, unsigned gpio)
return -1;
/* clear the bit in direction mode reg to set the pin as input */
reg = readl(platdata->base + ZYNQ_GPIO_DIRM_OFFSET(bank_num));
reg = readl(plat->base + ZYNQ_GPIO_DIRM_OFFSET(bank_num));
reg &= ~BIT(bank_pin_num);
writel(reg, platdata->base + ZYNQ_GPIO_DIRM_OFFSET(bank_num));
writel(reg, plat->base + ZYNQ_GPIO_DIRM_OFFSET(bank_num));
return 0;
}
@@ -305,7 +305,7 @@ static int zynq_gpio_direction_output(struct udevice *dev, unsigned gpio,
{
u32 reg;
unsigned int bank_num, bank_pin_num;
struct zynq_gpio_platdata *platdata = dev_get_platdata(dev);
struct zynq_gpio_platdata *plat = dev_get_platdata(dev);
if (check_gpio(gpio, dev) < 0)
return -1;
@@ -313,14 +313,14 @@ static int zynq_gpio_direction_output(struct udevice *dev, unsigned gpio,
zynq_gpio_get_bank_pin(gpio, &bank_num, &bank_pin_num, dev);
/* set the GPIO pin as output */
reg = readl(platdata->base + ZYNQ_GPIO_DIRM_OFFSET(bank_num));
reg = readl(plat->base + ZYNQ_GPIO_DIRM_OFFSET(bank_num));
reg |= BIT(bank_pin_num);
writel(reg, platdata->base + ZYNQ_GPIO_DIRM_OFFSET(bank_num));
writel(reg, plat->base + ZYNQ_GPIO_DIRM_OFFSET(bank_num));
/* configure the output enable reg for the pin */
reg = readl(platdata->base + ZYNQ_GPIO_OUTEN_OFFSET(bank_num));
reg = readl(plat->base + ZYNQ_GPIO_OUTEN_OFFSET(bank_num));
reg |= BIT(bank_pin_num);
writel(reg, platdata->base + ZYNQ_GPIO_OUTEN_OFFSET(bank_num));
writel(reg, plat->base + ZYNQ_GPIO_OUTEN_OFFSET(bank_num));
/* set the state of the pin */
zynq_gpio_set_value(dev, gpio, value);
@@ -331,7 +331,7 @@ static int zynq_gpio_get_function(struct udevice *dev, unsigned offset)
{
u32 reg;
unsigned int bank_num, bank_pin_num;
struct zynq_gpio_platdata *platdata = dev_get_platdata(dev);
struct zynq_gpio_platdata *plat = dev_get_platdata(dev);
if (check_gpio(offset, dev) < 0)
return -1;
@@ -339,7 +339,7 @@ static int zynq_gpio_get_function(struct udevice *dev, unsigned offset)
zynq_gpio_get_bank_pin(offset, &bank_num, &bank_pin_num, dev);
/* set the GPIO pin as output */
reg = readl(platdata->base + ZYNQ_GPIO_DIRM_OFFSET(bank_num));
reg = readl(plat->base + ZYNQ_GPIO_DIRM_OFFSET(bank_num));
reg &= BIT(bank_pin_num);
if (reg)
return GPIOF_OUTPUT;
@@ -369,7 +369,7 @@ static const struct udevice_id zynq_gpio_ids[] = {
static int zynq_gpio_probe(struct udevice *dev)
{
struct zynq_gpio_platdata *platdata = dev_get_platdata(dev);
struct zynq_gpio_platdata *plat = dev_get_platdata(dev);
struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
const void *label_ptr;
@@ -382,19 +382,19 @@ static int zynq_gpio_probe(struct udevice *dev)
uc_priv->bank_name = dev->name;
}
if (platdata->p_data)
uc_priv->gpio_count = platdata->p_data->ngpio;
if (plat->p_data)
uc_priv->gpio_count = plat->p_data->ngpio;
return 0;
}
static int zynq_gpio_ofdata_to_platdata(struct udevice *dev)
{
struct zynq_gpio_platdata *platdata = dev_get_platdata(dev);
struct zynq_gpio_platdata *plat = dev_get_platdata(dev);
platdata->base = (phys_addr_t)dev_read_addr(dev);
plat->base = (phys_addr_t)dev_read_addr(dev);
platdata->p_data =
plat->p_data =
(struct zynq_platform_data *)dev_get_driver_data(dev);
return 0;
@@ -407,5 +407,5 @@ U_BOOT_DRIVER(gpio_zynq) = {
.of_match = zynq_gpio_ids,
.ofdata_to_platdata = zynq_gpio_ofdata_to_platdata,
.probe = zynq_gpio_probe,
.platdata_auto = sizeof(struct zynq_gpio_platdata),
.plat_auto = sizeof(struct zynq_gpio_platdata),
};

2
drivers/i2c/Kconfig
View File

@@ -11,7 +11,7 @@ config DM_I2C
Enable driver model for I2C. The I2C uclass interface: probe, read,
write and speed, is implemented with the bus drivers operations,
which provide methods for bus setting and data transfer. Each chip
device (bus child) info is kept as parent platdata. The interface
device (bus child) info is kept as parent plat. The interface
is defined in include/i2c.h.
config I2C_CROS_EC_TUNNEL

2
drivers/i2c/acpi_i2c.c
View File

@@ -210,7 +210,7 @@ int acpi_i2c_ofdata_to_platdata(struct udevice *dev)
/* Use name specified in priv or build one from I2C address */
static int acpi_i2c_get_name(const struct udevice *dev, char *out_name)
{
struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
struct acpi_i2c_priv *priv = dev_get_priv(dev);
snprintf(out_name, ACPI_NAME_MAX,

14
drivers/i2c/i2c-emul-uclass.c
View File

@@ -14,7 +14,7 @@
* i2c emulation works using an 'emul' node at the bus level. Each device in
* that node is in the UCLASS_I2C_EMUL uclass, and emulates one i2c device. A
* pointer to the device it emulates is in the 'dev' property of the emul device
* uclass platdata (struct i2c_emul_platdata), put there by i2c_emul_find().
* uclass plat (struct i2c_emul_platdata), put there by i2c_emul_find().
* When sandbox wants an emulator for a device, it calls i2c_emul_find() which
* searches for the emulator with the correct address. To find the device for an
* emulator, call i2c_emul_get_device().
@@ -27,7 +27,7 @@
* struct i2c_emul_uc_platdata - information about the emulator for this device
*
* This is used by devices in UCLASS_I2C_EMUL to record information about the
* device being emulated. It is accessible with dev_get_uclass_platdata()
* device being emulated. It is accessible with dev_get_uclass_plat()
*
* @dev: Device being emulated
*/
@@ -37,7 +37,7 @@ struct i2c_emul_uc_platdata {
struct udevice *i2c_emul_get_device(struct udevice *emul)
{
struct i2c_emul_uc_platdata *uc_plat = dev_get_uclass_platdata(emul);
struct i2c_emul_uc_platdata *uc_plat = dev_get_uclass_plat(emul);
return uc_plat->dev;
}
@@ -54,7 +54,7 @@ int i2c_emul_find(struct udevice *dev, struct udevice **emulp)
log_err("No emulators for device '%s'\n", dev->name);
return ret;
}
uc_plat = dev_get_uclass_platdata(emul);
uc_plat = dev_get_uclass_plat(emul);
uc_plat->dev = dev;
*emulp = emul;
@@ -64,14 +64,14 @@ int i2c_emul_find(struct udevice *dev, struct udevice **emulp)
UCLASS_DRIVER(i2c_emul) = {
.id = UCLASS_I2C_EMUL,
.name = "i2c_emul",
.per_device_platdata_auto =
.per_device_plat_auto =
sizeof(struct i2c_emul_uc_platdata),
};
/*
* This uclass is a child of the i2c bus. Its platdata is not defined here so
* This uclass is a child of the i2c bus. Its plat is not defined here so
* is defined by its parent, UCLASS_I2C, which uses struct dm_i2c_chip. See
* per_child_platdata_auto in UCLASS_DRIVER(i2c).
* per_child_plat_auto in UCLASS_DRIVER(i2c).
*/
UCLASS_DRIVER(i2c_emul_parent) = {
.id = UCLASS_I2C_EMUL_PARENT,

28
drivers/i2c/i2c-uclass.c
View File

@@ -79,7 +79,7 @@ static int i2c_setup_offset(struct dm_i2c_chip *chip, uint offset,
static int i2c_read_bytewise(struct udevice *dev, uint offset,
uint8_t *buffer, int len)
{
struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
struct udevice *bus = dev_get_parent(dev);
struct dm_i2c_ops *ops = i2c_get_ops(bus);
struct i2c_msg msg[2], *ptr;
@@ -108,7 +108,7 @@ static int i2c_read_bytewise(struct udevice *dev, uint offset,
static int i2c_write_bytewise(struct udevice *dev, uint offset,
const uint8_t *buffer, int len)
{
struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
struct udevice *bus = dev_get_parent(dev);
struct dm_i2c_ops *ops = i2c_get_ops(bus);
struct i2c_msg msg[1];
@@ -131,7 +131,7 @@ static int i2c_write_bytewise(struct udevice *dev, uint offset,
int dm_i2c_read(struct udevice *dev, uint offset, uint8_t *buffer, int len)
{
struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
struct udevice *bus = dev_get_parent(dev);
struct dm_i2c_ops *ops = i2c_get_ops(bus);
struct i2c_msg msg[2], *ptr;
@@ -162,7 +162,7 @@ int dm_i2c_read(struct udevice *dev, uint offset, uint8_t *buffer, int len)
int dm_i2c_write(struct udevice *dev, uint offset, const uint8_t *buffer,
int len)
{
struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
struct udevice *bus = dev_get_parent(dev);
struct dm_i2c_ops *ops = i2c_get_ops(bus);
struct i2c_msg msg[1];
@@ -297,7 +297,7 @@ static int i2c_bind_driver(struct udevice *bus, uint chip_addr, uint offset_len,
goto err_bind;
/* Tell the device what we know about it */
chip = dev_get_parent_platdata(dev);
chip = dev_get_parent_plat(dev);
chip->chip_addr = chip_addr;
chip->offset_len = offset_len;
ret = device_probe(dev);
@@ -328,7 +328,7 @@ int i2c_get_chip(struct udevice *bus, uint chip_addr, uint offset_len,
bus->name, chip_addr);
for (device_find_first_child(bus, &dev); dev;
device_find_next_child(&dev)) {
struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
int ret;
if (chip->chip_addr == (chip_addr &
@@ -433,7 +433,7 @@ int dm_i2c_get_bus_speed(struct udevice *bus)
int i2c_set_chip_flags(struct udevice *dev, uint flags)
{
struct udevice *bus = dev->parent;
struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
struct dm_i2c_ops *ops = i2c_get_ops(bus);
int ret;
@@ -449,7 +449,7 @@ int i2c_set_chip_flags(struct udevice *dev, uint flags)
int i2c_get_chip_flags(struct udevice *dev, uint *flagsp)
{
struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
*flagsp = chip->flags;
@@ -458,7 +458,7 @@ int i2c_get_chip_flags(struct udevice *dev, uint *flagsp)
int i2c_set_chip_offset_len(struct udevice *dev, uint offset_len)
{
struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
if (offset_len > I2C_MAX_OFFSET_LEN)
return log_ret(-EINVAL);
@@ -469,14 +469,14 @@ int i2c_set_chip_offset_len(struct udevice *dev, uint offset_len)
int i2c_get_chip_offset_len(struct udevice *dev)
{
struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
return chip->offset_len;
}
int i2c_set_chip_addr_offset_mask(struct udevice *dev, uint mask)
{
struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
chip->chip_addr_offset_mask = mask;
@@ -485,7 +485,7 @@ int i2c_set_chip_addr_offset_mask(struct udevice *dev, uint mask)
uint i2c_get_chip_addr_offset_mask(struct udevice *dev)
{
struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
return chip->chip_addr_offset_mask;
}
@@ -676,7 +676,7 @@ static int i2c_post_probe(struct udevice *dev)
static int i2c_child_post_bind(struct udevice *dev)
{
#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
struct dm_i2c_chip *plat = dev_get_parent_platdata(dev);
struct dm_i2c_chip *plat = dev_get_parent_plat(dev);
if (!dev_of_valid(dev))
return 0;
@@ -743,7 +743,7 @@ UCLASS_DRIVER(i2c) = {
.pre_probe = i2c_pre_probe,
.post_probe = i2c_post_probe,
.per_device_auto = sizeof(struct dm_i2c_bus),
.per_child_platdata_auto = sizeof(struct dm_i2c_chip),
.per_child_plat_auto = sizeof(struct dm_i2c_chip),
.child_post_bind = i2c_child_post_bind,
};

8
drivers/i2c/muxes/i2c-mux-uclass.c
View File

@@ -36,7 +36,7 @@ struct i2c_mux_bus {
/* Find out the mux channel number */
static int i2c_mux_child_post_bind(struct udevice *dev)
{
struct i2c_mux_bus *plat = dev_get_parent_platdata(dev);
struct i2c_mux_bus *plat = dev_get_parent_plat(dev);
int channel;
channel = dev_read_u32_default(dev, "reg", -1);
@@ -126,7 +126,7 @@ static int i2c_mux_post_probe(struct udevice *mux)
int i2c_mux_select(struct udevice *dev)
{
struct i2c_mux_bus *plat = dev_get_parent_platdata(dev);
struct i2c_mux_bus *plat = dev_get_parent_plat(dev);
struct udevice *mux = dev->parent;
struct i2c_mux_ops *ops = i2c_mux_get_ops(mux);
@@ -138,7 +138,7 @@ int i2c_mux_select(struct udevice *dev)
int i2c_mux_deselect(struct udevice *dev)
{
struct i2c_mux_bus *plat = dev_get_parent_platdata(dev);
struct i2c_mux_bus *plat = dev_get_parent_plat(dev);
struct udevice *mux = dev->parent;
struct i2c_mux_ops *ops = i2c_mux_get_ops(mux);
@@ -221,6 +221,6 @@ UCLASS_DRIVER(i2c_mux) = {
.post_bind = i2c_mux_post_bind,
.post_probe = i2c_mux_post_probe,
.per_device_auto = sizeof(struct i2c_mux),
.per_child_platdata_auto = sizeof(struct i2c_mux_bus),
.per_child_plat_auto = sizeof(struct i2c_mux_bus),
.child_post_bind = i2c_mux_child_post_bind,
};

2
drivers/i2c/omap24xx_i2c.c
View File

@@ -1094,7 +1094,7 @@ U_BOOT_DRIVER(i2c_omap) = {
#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
.of_match = omap_i2c_ids,
.ofdata_to_platdata = omap_i2c_ofdata_to_platdata,
.platdata_auto = sizeof(struct omap_i2c_platdata),
.plat_auto = sizeof(struct omap_i2c_platdata),
#endif
.probe = omap_i2c_probe,
.priv_auto = sizeof(struct omap_i2c),

2
drivers/i2c/sandbox_i2c.c
View File

@@ -27,7 +27,7 @@ static int get_emul(struct udevice *dev, struct udevice **devp,
*devp = NULL;
*opsp = NULL;
plat = dev_get_parent_platdata(dev);
plat = dev_get_parent_plat(dev);
if (!plat->emul) {
ret = i2c_emul_find(dev, &plat->emul);
if (ret)

4
drivers/led/led-uclass.c
View File

@@ -22,7 +22,7 @@ int led_get_by_label(const char *label, struct udevice **devp)
if (ret)
return ret;
uclass_foreach_dev(dev, uc) {
struct led_uc_plat *uc_plat = dev_get_uclass_platdata(dev);
struct led_uc_plat *uc_plat = dev_get_uclass_plat(dev);
/* Ignore the top-level LED node */
if (uc_plat->label && !strcmp(label, uc_plat->label))
@@ -96,5 +96,5 @@ int led_default_state(void)
UCLASS_DRIVER(led) = {
.id = UCLASS_LED,
.name = "led",
.per_device_platdata_auto = sizeof(struct led_uc_plat),
.per_device_plat_auto = sizeof(struct led_uc_plat),
};

4
drivers/led/led_bcm6328.c
View File

@@ -147,7 +147,7 @@ static const struct led_ops bcm6328_led_ops = {
static int bcm6328_led_probe(struct udevice *dev)
{
struct led_uc_plat *uc_plat = dev_get_uclass_platdata(dev);
struct led_uc_plat *uc_plat = dev_get_uclass_plat(dev);
/* Top-level LED node */
if (!uc_plat->label) {
@@ -222,7 +222,7 @@ static int bcm6328_led_bind(struct udevice *parent)
if (ret)
return ret;
uc_plat = dev_get_uclass_platdata(dev);
uc_plat = dev_get_uclass_plat(dev);
uc_plat->label = label;
}

4
drivers/led/led_bcm6358.c
View File

@@ -113,7 +113,7 @@ static const struct led_ops bcm6358_led_ops = {
static int bcm6358_led_probe(struct udevice *dev)
{
struct led_uc_plat *uc_plat = dev_get_uclass_platdata(dev);
struct led_uc_plat *uc_plat = dev_get_uclass_plat(dev);
/* Top-level LED node */
if (!uc_plat->label) {
@@ -192,7 +192,7 @@ static int bcm6358_led_bind(struct udevice *parent)
if (ret)
return ret;
uc_plat = dev_get_uclass_platdata(dev);
uc_plat = dev_get_uclass_plat(dev);
uc_plat->label = label;
}

4
drivers/led/led_bcm6858.c
View File

@@ -154,7 +154,7 @@ static const struct led_ops bcm6858_led_ops = {
static int bcm6858_led_probe(struct udevice *dev)
{
struct led_uc_plat *uc_plat = dev_get_uclass_platdata(dev);
struct led_uc_plat *uc_plat = dev_get_uclass_plat(dev);
/* Top-level LED node */
if (!uc_plat->label) {
@@ -229,7 +229,7 @@ static int bcm6858_led_bind(struct udevice *parent)
if (ret)
return ret;
uc_plat = dev_get_uclass_platdata(dev);
uc_plat = dev_get_uclass_plat(dev);
uc_plat->label = label;
}

18
drivers/led/led_cortina.c
View File

@@ -132,7 +132,7 @@ static const struct led_ops cortina_led_ops = {
static int ca_led_ofdata_to_platdata(struct udevice *dev)
{
struct led_uc_plat *uc_plat = dev_get_uclass_platdata(dev);
struct led_uc_plat *uc_plat = dev_get_uclass_plat(dev);
/* Top-level LED node */
if (!uc_plat->label) {
@@ -165,22 +165,22 @@ static int ca_led_ofdata_to_platdata(struct udevice *dev)
static int cortina_led_probe(struct udevice *dev)
{
struct led_uc_plat *uc_plat = dev_get_uclass_platdata(dev);
struct led_uc_plat *uc_plat = dev_get_uclass_plat(dev);
/* Top-level LED node */
if (!uc_plat->label) {
struct cortina_led_platdata *platdata = dev_get_platdata(dev);
struct cortina_led_platdata *plat = dev_get_platdata(dev);
u32 reg_value, val;
u16 rate1, rate2;
if (!platdata->ctrl_regs)
if (!plat->ctrl_regs)
return -EINVAL;
reg_value = 0;
reg_value |= LED_CLK_POLARITY;
rate1 = platdata->rate1;
rate2 = platdata->rate2;
rate1 = plat->rate1;
rate2 = plat->rate2;
val = rate1 / 16 - 1;
rate1 = val > LED_MAX_HW_BLINK ?
@@ -194,7 +194,7 @@ static int cortina_led_probe(struct udevice *dev)
reg_value |= (rate2 & LED_BLINK_RATE2_MASK) <<
LED_BLINK_RATE2_SHIFT;
cortina_led_write(platdata->ctrl_regs, reg_value);
cortina_led_write(plat->ctrl_regs, reg_value);
} else {
struct cortina_led_cfg *priv = dev_get_priv(dev);
@@ -273,7 +273,7 @@ static int cortina_led_bind(struct udevice *parent)
node, &dev);
if (ret)
return ret;
uc_plat = dev_get_uclass_platdata(dev);
uc_plat = dev_get_uclass_plat(dev);
uc_plat->label = label;
}
@@ -292,7 +292,7 @@ U_BOOT_DRIVER(cortina_led) = {
.ofdata_to_platdata = ca_led_ofdata_to_platdata,
.bind = cortina_led_bind,
.probe = cortina_led_probe,
.platdata_auto = sizeof(struct cortina_led_platdata),
.plat_auto = sizeof(struct cortina_led_platdata),
.priv_auto = sizeof(struct cortina_led_cfg),
.ops = &cortina_led_ops,
};

4
drivers/led/led_gpio.c
View File

@@ -57,7 +57,7 @@ static enum led_state_t gpio_led_get_state(struct udevice *dev)
static int led_gpio_probe(struct udevice *dev)
{
struct led_uc_plat *uc_plat = dev_get_uclass_platdata(dev);
struct led_uc_plat *uc_plat = dev_get_uclass_plat(dev);
struct led_gpio_priv *priv = dev_get_priv(dev);
int ret;
@@ -106,7 +106,7 @@ static int led_gpio_bind(struct udevice *parent)
node, &dev);
if (ret)
return ret;
uc_plat = dev_get_uclass_platdata(dev);
uc_plat = dev_get_uclass_plat(dev);
uc_plat->label = label;
}

4
drivers/misc/altera_sysid.c
View File

@@ -59,7 +59,7 @@ U_BOOT_CMD(
static int altera_sysid_read(struct udevice *dev,
int offset, void *buf, int size)
{
struct altera_sysid_platdata *plat = dev->platdata;
struct altera_sysid_platdata *plat = dev->plat;
struct altera_sysid_regs *const regs = plat->regs;
u32 *sysid = buf;
@@ -94,6 +94,6 @@ U_BOOT_DRIVER(altera_sysid) = {
.id = UCLASS_MISC,
.of_match = altera_sysid_ids,
.ofdata_to_platdata = altera_sysid_ofdata_to_platdata,
.platdata_auto = sizeof(struct altera_sysid_platdata),
.plat_auto = sizeof(struct altera_sysid_platdata),
.ops = &altera_sysid_ops,
};

4
drivers/misc/cros_ec_i2c.c
View File

@@ -52,7 +52,7 @@ struct ec_host_response_i2c {
static int cros_ec_i2c_packet(struct udevice *udev, int out_bytes, int in_bytes)
{
struct cros_ec_dev *dev = dev_get_uclass_priv(udev);
struct dm_i2c_chip *chip = dev_get_parent_platdata(udev);
struct dm_i2c_chip *chip = dev_get_parent_plat(udev);
struct ec_host_request_i2c *ec_request_i2c =
(struct ec_host_request_i2c *)dev->dout;
struct ec_host_response_i2c *ec_response_i2c =
@@ -112,7 +112,7 @@ static int cros_ec_i2c_command(struct udevice *udev, uint8_t cmd,
int dout_len, uint8_t **dinp, int din_len)
{
struct cros_ec_dev *dev = dev_get_uclass_priv(udev);
struct dm_i2c_chip *chip = dev_get_parent_platdata(udev);
struct dm_i2c_chip *chip = dev_get_parent_plat(udev);
struct i2c_msg i2c_msg[2];
/* version8, cmd8, arglen8, out8[dout_len], csum8 */
int out_bytes = dout_len + 4;

8
drivers/misc/fs_loader.c
View File

@@ -161,7 +161,7 @@ static int fw_get_filesystem_firmware(struct udevice *dev)
else
ret = -ENODEV;
} else {
ret = select_fs_dev(dev->platdata);
ret = select_fs_dev(dev->plat);
}
if (ret)
@@ -228,7 +228,7 @@ static int fs_loader_ofdata_to_platdata(struct udevice *dev)
if (ofnode_valid(fs_loader_node)) {
struct device_platdata *plat;
plat = dev->platdata;
plat = dev->plat;
if (!ofnode_read_u32_array(fs_loader_node,
"phandlepart",
phandlepart, 2)) {
@@ -250,7 +250,7 @@ static int fs_loader_probe(struct udevice *dev)
{
#if CONFIG_IS_ENABLED(DM) && CONFIG_IS_ENABLED(BLK)
int ret;
struct device_platdata *plat = dev->platdata;
struct device_platdata *plat = dev->plat;
if (plat->phandlepart.phandle) {
ofnode node = ofnode_get_by_phandle(plat->phandlepart.phandle);
@@ -285,7 +285,7 @@ U_BOOT_DRIVER(fs_loader) = {
.of_match = fs_loader_ids,
.probe = fs_loader_probe,
.ofdata_to_platdata = fs_loader_ofdata_to_platdata,
.platdata_auto = sizeof(struct device_platdata),
.plat_auto = sizeof(struct device_platdata),
.priv_auto = sizeof(struct firmware),
};

2
drivers/misc/i2c_eeprom_emul.c
View File

@@ -201,6 +201,6 @@ U_BOOT_DRIVER(sandbox_i2c_emul) = {
.probe = sandbox_i2c_eeprom_probe,
.remove = sandbox_i2c_eeprom_remove,
.priv_auto = sizeof(struct sandbox_i2c_flash),
.platdata_auto = sizeof(struct sandbox_i2c_flash_plat_data),
.plat_auto = sizeof(struct sandbox_i2c_flash_plat_data),
.ops = &sandbox_i2c_emul_ops,
};

2
drivers/misc/imx8/scu.c
View File

@@ -245,6 +245,6 @@ U_BOOT_DRIVER(imx8_scu) = {
.bind = imx8_scu_bind,
.remove = imx8_scu_remove,
.ops = &imx8_scu_ops,
.platdata_auto = sizeof(struct imx8_scu),
.plat_auto = sizeof(struct imx8_scu),
.flags = DM_FLAG_PRE_RELOC,
};

2
drivers/misc/microchip_flexcom.c
View File

@@ -62,5 +62,5 @@ U_BOOT_DRIVER(microchip_flexcom) = {
.id = UCLASS_MISC,
.of_match = microchip_flexcom_ids,
.ofdata_to_platdata = microchip_flexcom_ofdata_to_platdata,
.platdata_auto = sizeof(struct microchip_flexcom_platdata),
.plat_auto = sizeof(struct microchip_flexcom_platdata),
};

14
drivers/misc/p2sb-uclass.c
View File

@@ -30,7 +30,7 @@ int p2sb_set_hide(struct udevice *dev, bool hide)
void *pcr_reg_address(struct udevice *dev, uint offset)
{
struct p2sb_child_platdata *pplat = dev_get_parent_platdata(dev);
struct p2sb_child_platdata *pplat = dev_get_parent_plat(dev);
struct udevice *p2sb = dev_get_parent(dev);
struct p2sb_uc_priv *upriv = dev_get_uclass_priv(p2sb);
uintptr_t reg_addr;
@@ -161,7 +161,7 @@ void pcr_clrsetbits8(struct udevice *dev, uint offset, uint clr, uint set)
int p2sb_get_port_id(struct udevice *dev)
{
struct p2sb_child_platdata *pplat = dev_get_parent_platdata(dev);
struct p2sb_child_platdata *pplat = dev_get_parent_plat(dev);
return pplat->pid;
}
@@ -184,11 +184,11 @@ int p2sb_set_port_id(struct udevice *dev, int portid)
* We must allocate this, since when the device was bound it did
* not have a parent.
*/
dev->parent_platdata = malloc(sizeof(*pplat));
if (!dev->parent_platdata)
dev->parent_plat = malloc(sizeof(*pplat));
if (!dev->parent_plat)
return -ENOMEM;
}
pplat = dev_get_parent_platdata(dev);
pplat = dev_get_parent_plat(dev);
pplat->pid = portid;
return 0;
@@ -197,7 +197,7 @@ int p2sb_set_port_id(struct udevice *dev, int portid)
static int p2sb_child_post_bind(struct udevice *dev)
{
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
struct p2sb_child_platdata *pplat = dev_get_parent_platdata(dev);
struct p2sb_child_platdata *pplat = dev_get_parent_plat(dev);
int ret;
u32 pid;
@@ -224,6 +224,6 @@ UCLASS_DRIVER(p2sb) = {
.per_device_auto = sizeof(struct p2sb_uc_priv),
.post_bind = p2sb_post_bind,
.child_post_bind = p2sb_child_post_bind,
.per_child_platdata_auto =
.per_child_plat_auto =
sizeof(struct p2sb_child_platdata),
};

4
drivers/misc/p2sb_emul.c
View File

@@ -198,7 +198,7 @@ static int find_p2sb_channel(struct udevice *emul, uint offset,
device_foreach_child(dev, p2sb) {
struct p2sb_child_platdata *pplat =
dev_get_parent_platdata(dev);
dev_get_parent_plat(dev);
log_debug(" - child %s, pid %d, want %d\n", dev->name,
pplat->pid, pid);
@@ -263,7 +263,7 @@ U_BOOT_DRIVER(sandbox_p2sb_emul_emul) = {
.of_match = sandbox_p2sb_emul_ids,
.ops = &sandbox_p2sb_emul_emul_ops,
.priv_auto = sizeof(struct p2sb_emul_priv),
.platdata_auto = sizeof(struct p2sb_emul_platdata),
.plat_auto = sizeof(struct p2sb_emul_platdata),
};
static struct pci_device_id sandbox_p2sb_emul_supported[] = {

2
drivers/misc/rockchip-efuse.c
View File

@@ -155,6 +155,6 @@ U_BOOT_DRIVER(rockchip_efuse) = {
.id = UCLASS_MISC,
.of_match = rockchip_efuse_ids,
.ofdata_to_platdata = rockchip_efuse_ofdata_to_platdata,
.platdata_auto = sizeof(struct rockchip_efuse_platdata),
.plat_auto = sizeof(struct rockchip_efuse_platdata),
.ops = &rockchip_efuse_ops,
};

2
drivers/misc/rockchip-otp.c
View File

@@ -172,5 +172,5 @@ U_BOOT_DRIVER(rockchip_otp) = {
.of_match = rockchip_otp_ids,
.ops = &rockchip_otp_ops,
.ofdata_to_platdata = rockchip_otp_ofdata_to_platdata,
.platdata_auto = sizeof(struct rockchip_otp_platdata),
.plat_auto = sizeof(struct rockchip_otp_platdata),
};

2
drivers/misc/sandbox_adder.c
View File

@@ -21,7 +21,7 @@ struct sandbox_adder_priv {
int sandbox_adder_read(struct udevice *dev, ulong address, void *data,
enum axi_size_t size)
{
struct p2sb_child_platdata *pplat = dev_get_parent_platdata(dev);
struct p2sb_child_platdata *pplat = dev_get_parent_plat(dev);
u32 *val = data;
*val = pplat->pid << 24 | address;

2
drivers/misc/sifive-otp.c
View File

@@ -270,6 +270,6 @@ U_BOOT_DRIVER(sifive_otp) = {
.id = UCLASS_MISC,
.of_match = sifive_otp_ids,
.ofdata_to_platdata = sifive_otp_ofdata_to_platdata,
.platdata_auto = sizeof(struct sifive_otp_platdata),
.plat_auto = sizeof(struct sifive_otp_platdata),
.ops = &sifive_otp_ops,
};

2
drivers/misc/swap_case.c
View File

@@ -392,7 +392,7 @@ U_BOOT_DRIVER(sandbox_swap_case_emul) = {
.of_match = sandbox_swap_case_ids,
.ops = &sandbox_swap_case_emul_ops,
.priv_auto = sizeof(struct swap_case_priv),
.platdata_auto = sizeof(struct swap_case_platdata),
.plat_auto = sizeof(struct swap_case_platdata),
};
static struct pci_device_id sandbox_swap_case_supported[] = {

Some files were not shown because too many files have changed in this diff Show More