.id = UCLASS_CLK,
.of_match = msm_clk_ids,
.ops = &msm_clk_ops,
- .priv_auto_alloc_size = sizeof(struct msm_clk_priv),
+ .priv_auto = sizeof(struct msm_clk_priv),
.probe = msm_clk_probe,
};
.name = "pinctrl_msm",
.id = UCLASS_PINCTRL,
.of_match = msm_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct msm_pinctrl_priv),
+ .priv_auto = sizeof(struct msm_pinctrl_priv),
.ops = &msm_pinctrl_ops,
.probe = msm_pinctrl_probe,
};
.id = UCLASS_CLK,
.of_match = msm_clk_ids,
.ops = &msm_clk_ops,
- .priv_auto_alloc_size = sizeof(struct msm_clk_priv),
+ .priv_auto = sizeof(struct msm_clk_priv),
.probe = msm_clk_probe,
};
.name = "pinctrl_msm",
.id = UCLASS_PINCTRL,
.of_match = msm_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct msm_pinctrl_priv),
+ .priv_auto = sizeof(struct msm_pinctrl_priv),
.ops = &msm_pinctrl_ops,
.probe = msm_pinctrl_probe,
};
.id = UCLASS_MISC,
.of_match = stm32mp_bsec_ids,
.ofdata_to_platdata = stm32mp_bsec_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct stm32mp_bsec_platdata),
+ .platdata_auto = sizeof(struct stm32mp_bsec_platdata),
.ops = &stm32mp_bsec_ops,
.probe = stm32mp_bsec_probe,
};
.bind = stm32mp_pwr_bind,
.ops = &stm32mp_pwr_ops,
.ofdata_to_platdata = stm32mp_pwr_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct stm32mp_pwr_priv),
+ .priv_auto = sizeof(struct stm32mp_pwr_priv),
};
static const struct stm32mp_pwr_reg_info stm32mp_pwr_reg11 = {
.of_match = acpi_gpe_ids,
.ops = &acpi_gpe_ops,
.ofdata_to_platdata = acpi_gpe_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct acpi_gpe_priv),
+ .priv_auto = sizeof(struct acpi_gpe_priv),
};
.ofdata_to_platdata = apl_hostbridge_ofdata_to_platdata,
.probe = apl_hostbridge_probe,
.remove = apl_hostbridge_remove,
- .platdata_auto_alloc_size = sizeof(struct apl_hostbridge_platdata),
+ .platdata_auto = sizeof(struct apl_hostbridge_platdata),
ACPI_OPS_PTR(&apl_hostbridge_acpi_ops)
.flags = DM_FLAG_OS_PREPARE,
};
.ofdata_to_platdata = apl_pmc_ofdata_to_uc_platdata,
.probe = apl_pmc_probe,
.ops = &apl_pmc_ops,
- .platdata_auto_alloc_size = sizeof(struct apl_pmc_platdata),
+ .platdata_auto = sizeof(struct apl_pmc_platdata),
};
.of_match = apl_flash_ids,
.bind = apl_flash_bind,
.probe = apl_flash_probe,
- .priv_auto_alloc_size = sizeof(struct spi_flash),
+ .priv_auto = sizeof(struct spi_flash),
.ops = &apl_flash_ops,
};
.name = "intel_apl_ns16550",
.id = UCLASS_SERIAL,
.of_match = apl_ns16550_serial_ids,
- .platdata_auto_alloc_size = sizeof(struct ns16550_platdata),
- .priv_auto_alloc_size = sizeof(struct NS16550),
+ .platdata_auto = sizeof(struct ns16550_platdata),
+ .priv_auto = sizeof(struct NS16550),
.ops = &ns16550_serial_ops,
.ofdata_to_platdata = apl_ns16550_ofdata_to_platdata,
.probe = apl_ns16550_probe,
.bind = cpu_x86_bind,
.probe = cpu_x86_broadwell_probe,
.ops = &cpu_x86_broadwell_ops,
- .priv_auto_alloc_size = sizeof(struct cpu_broadwell_priv),
+ .priv_auto = sizeof(struct cpu_broadwell_priv),
.flags = DM_FLAG_PRE_RELOC,
};
.of_match = broadwell_ahci_ids,
.ofdata_to_platdata = broadwell_sata_ofdata_to_platdata,
.probe = broadwell_sata_probe,
- .platdata_auto_alloc_size = sizeof(struct sata_platdata),
+ .platdata_auto = sizeof(struct sata_platdata),
};
.ops = &itss_ops,
.bind = itss_bind,
.ofdata_to_platdata = itss_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct itss_platdata),
- .priv_auto_alloc_size = sizeof(struct itss_priv),
+ .platdata_auto = sizeof(struct itss_platdata),
+ .priv_auto = sizeof(struct itss_priv),
};
.remove = p2sb_remove,
.ops = &p2sb_ops,
.ofdata_to_platdata = p2sb_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct p2sb_platdata),
- .per_child_platdata_auto_alloc_size =
+ .platdata_auto = sizeof(struct p2sb_platdata),
+ .per_child_platdata_auto =
sizeof(struct p2sb_child_platdata),
.child_post_bind = p2sb_child_post_bind,
.flags = DM_FLAG_OS_PREPARE,
.id = UCLASS_IRQ,
.of_match = irq_router_ids,
.probe = irq_router_probe,
- .priv_auto_alloc_size = sizeof(struct irq_router),
+ .priv_auto = sizeof(struct irq_router),
};
.id = UCLASS_SERIAL,
.of_match = slimbootloader_serial_ids,
.ofdata_to_platdata = slimbootloader_serial_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct ns16550_platdata),
- .priv_auto_alloc_size = sizeof(struct NS16550),
+ .platdata_auto = sizeof(struct ns16550_platdata),
+ .priv_auto = sizeof(struct NS16550),
.probe = ns16550_serial_probe,
.ops = &ns16550_serial_ops,
};
.id = UCLASS_SYSCON,
.of_match = tangier_pinctrl_match,
.probe = tangier_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct mrfld_pinctrl),
+ .priv_auto = sizeof(struct mrfld_pinctrl),
};
.id = UCLASS_SYSCON,
.of_match = pmu_mid_match,
.probe = pmu_mid_probe,
- .priv_auto_alloc_size = sizeof(struct pmu_mid),
+ .priv_auto = sizeof(struct pmu_mid),
};
.id = UCLASS_SYSCON,
.of_match = scu_ipc_match,
.probe = scu_ipc_probe,
- .priv_auto_alloc_size = sizeof(struct scu),
+ .priv_auto = sizeof(struct scu),
};
.ops = &renesas_ulcb_sysreset,
.probe = renesas_ulcb_sysreset_probe,
.of_match = renesas_ulcb_sysreset_ids,
- .priv_auto_alloc_size = sizeof(struct renesas_ulcb_sysreset_priv),
+ .priv_auto = sizeof(struct renesas_ulcb_sysreset_priv),
};
.post_bind = dm_scan_fdt_dev,
.post_probe = usb_hub_post_probe,
.child_pre_probe = usb_child_pre_probe,
- .per_child_auto_alloc_size = sizeof(struct usb_device),
- .per_child_platdata_auto_alloc_size = sizeof(struct usb_dev_platdata),
- .per_device_auto_alloc_size = sizeof(struct usb_hub_device),
+ .per_child_auto = sizeof(struct usb_device),
+ .per_child_platdata_auto = sizeof(struct usb_dev_platdata),
+ .per_device_auto = sizeof(struct usb_hub_device),
};
static const struct usb_device_id hub_id_table[] = {
.of_match = usb_mass_storage_ids,
.probe = usb_mass_storage_probe,
#if CONFIG_IS_ENABLED(BLK)
- .platdata_auto_alloc_size = sizeof(struct us_data),
+ .platdata_auto = sizeof(struct us_data),
#endif
};
.. code-block:: c
- .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
+ .platdata_auto = sizeof(struct dm_test_pdata),
.ofdata_to_platdata = testfdt_ofdata_to_platdata,
-The 'auto_alloc' feature allowed space for the platdata to be allocated
+The 'auto' feature allowed space for the platdata to be allocated
and zeroed before the driver's ofdata_to_platdata() method is called. The
ofdata_to_platdata() method, which the driver write supplies, should parse
the device tree node for this device and place it in dev->platdata. Thus
details.
If you don't want to have the platdata automatically allocated then you
-can leave out platdata_auto_alloc_size. In this case you can use malloc
+can leave out platdata_auto. In this case you can use malloc
in your ofdata_to_platdata (or probe) method to allocate the required memory,
and you should free it in the remove method.
To achieve this, the bus device can use dev->parent_platdata in each of its
three children. This can be auto-allocated if the bus driver (or bus uclass)
-has a non-zero value for per_child_platdata_auto_alloc_size. If not, then
+has a non-zero value for per_child_platdata_auto. If not, then
the bus device or uclass can allocate the space itself before the child
device is probed.
The steps are:
- 1. If priv_auto_alloc_size is non-zero, then the device-private space
+ 1. If priv_auto is non-zero, then the device-private space
is allocated for the device and zeroed. It will be accessible as
dev->priv. The driver can put anything it likes in there, but should use
it for run-time information, not platform data (which should be static
and known before the device is probed).
- 2. If platdata_auto_alloc_size is non-zero, then the platform data space
+ 2. If platdata_auto is non-zero, then the platform data space
is allocated. This is only useful for device tree operation, since
otherwise you would have to specific the platform data in the
U_BOOT_DEVICE() declaration. The space is allocated for the device and
zeroed. It will be accessible as dev->platdata.
- 3. If the device's uclass specifies a non-zero per_device_auto_alloc_size,
+ 3. If the device's uclass specifies a non-zero per_device_auto,
then this space is allocated and zeroed also. It is allocated for and
stored in the device, but it is uclass data. owned by the uclass driver.
It is possible for the device to access it.
- 4. If the device's immediate parent specifies a per_child_auto_alloc_size
+ 4. If the device's immediate parent specifies a per_child_auto
then this space is allocated. This is intended for use by the parent
device to keep track of things related to the child. For example a USB
flash stick attached to a USB host controller would likely use this
works the same way whether it was bound using a device tree node or
U_BOOT_DEVICE() structure. In either case, the platform data is now stored
in the platdata structure. Typically you will use the
- platdata_auto_alloc_size feature to specify the size of the platform data
+ platdata_auto feature to specify the size of the platform data
structure, and U-Boot will automatically allocate and zero it for you before
entry to ofdata_to_platdata(). But if not, you can allocate it yourself in
ofdata_to_platdata(). Note that it is preferable to do all the device tree
- uclass data in dev->uclass_priv (for things the uclass stores
about this device)
- Note: If you don't use priv_auto_alloc_size then you will need to
+ Note: If you don't use priv_auto then you will need to
allocate the priv space here yourself. The same applies also to
- platdata_auto_alloc_size. Remember to free them in the remove() method.
+ platdata_auto. Remember to free them in the remove() method.
5. The device is marked 'activated'
be dynamically allocated, and thus needs to be deallocated during the
remove() method, either:
- - if the platdata_auto_alloc_size is non-zero, the deallocation
+ - if the platdata_auto is non-zero, the deallocation
happens automatically within the driver model core; or
- - when platdata_auto_alloc_size is 0, both the allocation (in probe()
+ - when platdata_auto is 0, both the allocation (in probe()
or preferably ofdata_to_platdata()) and the deallocation in remove()
are the responsibility of the driver author.
.ofdata_to_platdata = eth_ape_ofdata_to_platdata,
.probe = eth_ape_probe,
.ops = ð_ape_ops,
- .priv_auto_alloc_size = sizeof(struct eth_ape_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_ape_pdata),
+ .priv_auto = sizeof(struct eth_ape_priv),
+ .platdata_auto = sizeof(struct eth_ape_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
struct eth_ape_priv contains runtime per-instance data, like buffers, pointers
to current descriptors, current speed settings, pointers to PHY related data
-(like struct mii_dev) and so on. Declaring its size in .priv_auto_alloc_size
+(like struct mii_dev) and so on. Declaring its size in .priv_auto
will let the driver framework allocate it at the right time.
It can be retrieved using a dev_get_priv(dev) call.
a hardware variant, the MAC address. ``struct eth_pdata eth_pdata``
as the first member of this struct helps to avoid duplicated code.
If you don't need any more platform data beside the standard member,
-just use sizeof(struct eth_pdata) for the platdata_auto_alloc_size.
+just use sizeof(struct eth_pdata) for the platdata_auto.
PCI devices add a line pointing to supported vendor/device ID pairs:
.of_match = mmc_ids,
.ofdata_to_platdata = mmc_ofdata_to_platdata,
.probe = mmc_probe,
- .priv_auto_alloc_size = sizeof(struct mmc_priv),
- .platdata_auto_alloc_size = sizeof(struct mmc_platdata),
+ .priv_auto = sizeof(struct mmc_priv),
+ .platdata_auto = sizeof(struct mmc_platdata),
};
U_BOOT_DRIVER_ALIAS(mmc_drv, vendor_mmc) /* matches compatible string */
There is just one driver C file for each struct, that can convert from the
of-platdata struct to the standard one used by the driver.
-In the case where SPL_OF_PLATDATA is enabled, platdata_auto_alloc_size is
+In the case where SPL_OF_PLATDATA is enabled, platdata_auto is
still used to allocate space for the platform data. This is different from
the normal behaviour and is triggered by the use of of-platdata (strictly
speaking it is a non-zero platdata_size which triggers this).
U_BOOT_DRIVER(spi_exynos) = {
...
- .platdata_auto_alloc_size = sizeof(struct exynos_spi_platdata),
+ .platdata_auto = sizeof(struct exynos_spi_platdata),
Here is a sample function. It gets a pointer to the platform data and
U_BOOT_DRIVER(spi_exynos) = {
...
- .priv_auto_alloc_size = sizeof(struct exynos_spi_priv),
+ .priv_auto = sizeof(struct exynos_spi_priv),
Note that this is created before the probe method is called, and destroyed
U_BOOT_DRIVER(exynos_spi) = {
...
- .per_child_auto_alloc_size = sizeof(struct spi_slave),
+ .per_child_auto = sizeof(struct spi_slave),
}
.probe = tegra_ehci_usb_probe,
.remove = tegra_ehci_usb_remove,
.ops = &ehci_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(struct fdt_usb),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct fdt_usb),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
most cases, since they are all EHCI-compatible. For EHCI there are also some
special operations that can be overridden when calling ehci_register().
-The driver can use priv_auto_alloc_size to set the size of its private data.
+The driver can use priv_auto to set the size of its private data.
This can hold run-time information needed by the driver for operation. It
exists when the device is probed (not when it is bound) and is removed when
the driver is removed.
modify clk-uclass.c file and add there struct uc_clk_priv, which would have
clock related members (like pointer to clk). As of this writing there is no
such need, so to avoid extra allocations (as it can be auto allocated by
- setting .per_device_auto_alloc_size = sizeof(struct uc_clk_priv)) the
+ setting .per_device_auto = sizeof(struct uc_clk_priv)) the
uclass_priv stores the pointer to struct clk.
* Non-CCF clocks do not have a pointer to a clock in clk->dev->priv. In the case
.id = UCLASS_ADC,
.name = "adc",
.pre_probe = adc_pre_probe,
- .per_device_platdata_auto_alloc_size = ADC_UCLASS_PLATDATA_SIZE,
+ .per_device_platdata_auto = ADC_UCLASS_PLATDATA_SIZE,
};
.ops = &exynos_adc_ops,
.probe = exynos_adc_probe,
.ofdata_to_platdata = exynos_adc_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct exynos_adc_priv),
+ .priv_auto = sizeof(struct exynos_adc_priv),
};
.ops = &meson_saradc_ops,
.probe = meson_saradc_probe,
.ofdata_to_platdata = meson_saradc_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct meson_saradc_priv),
+ .priv_auto = sizeof(struct meson_saradc_priv),
};
.ops = &rockchip_saradc_ops,
.probe = rockchip_saradc_probe,
.ofdata_to_platdata = rockchip_saradc_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct rockchip_saradc_priv),
+ .priv_auto = sizeof(struct rockchip_saradc_priv),
};
.ops = &sandbox_adc_ops,
.probe = sandbox_adc_probe,
.ofdata_to_platdata = sandbox_adc_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct sandbox_adc_priv),
+ .priv_auto = sizeof(struct sandbox_adc_priv),
};
.id = UCLASS_SIMPLE_BUS,
.of_match = stm32_adc_core_ids,
.probe = stm32_adc_core_probe,
- .priv_auto_alloc_size = sizeof(struct stm32_adc_common),
+ .priv_auto = sizeof(struct stm32_adc_common),
};
.of_match = stm32_adc_ids,
.probe = stm32_adc_probe,
.ops = &stm32_adc_ops,
- .priv_auto_alloc_size = sizeof(struct stm32_adc),
+ .priv_auto = sizeof(struct stm32_adc),
};
UCLASS_DRIVER(ahci) = {
.id = UCLASS_AHCI,
.name = "ahci",
- .per_device_auto_alloc_size = sizeof(struct ahci_uc_priv),
+ .per_device_auto = sizeof(struct ahci_uc_priv),
};
.ofdata_to_platdata = dwc_ahci_ofdata_to_platdata,
.ops = &scsi_ops,
.probe = dwc_ahci_probe,
- .priv_auto_alloc_size = sizeof(struct dwc_ahci_priv),
+ .priv_auto = sizeof(struct dwc_ahci_priv),
};
.name = "sata_fsl_blk",
.id = UCLASS_BLK,
.ops = &sata_fsl_blk_ops,
- .platdata_auto_alloc_size = sizeof(struct fsl_ata_priv),
+ .platdata_auto = sizeof(struct fsl_ata_priv),
};
static int fsl_ata_ofdata_to_platdata(struct udevice *dev)
.ofdata_to_platdata = fsl_ata_ofdata_to_platdata,
.probe = fsl_ata_probe,
.remove = fsl_ata_remove,
- .priv_auto_alloc_size = sizeof(struct fsl_ata_priv),
+ .priv_auto = sizeof(struct fsl_ata_priv),
};
#endif
.ofdata_to_platdata = mtk_ahci_ofdata_to_platdata,
.ops = &scsi_ops,
.probe = mtk_ahci_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_ahci_priv),
+ .priv_auto = sizeof(struct mtk_ahci_priv),
};
.of_match = sata_ceva_ids,
.bind = sata_ceva_bind,
.ops = &scsi_ops,
- .priv_auto_alloc_size = sizeof(struct ceva_sata_priv),
+ .priv_auto = sizeof(struct ceva_sata_priv),
.probe = sata_ceva_probe,
.ofdata_to_platdata = sata_ceva_ofdata_to_platdata,
};
.name = "sata_mv_blk",
.id = UCLASS_BLK,
.ops = &sata_mv_blk_ops,
- .platdata_auto_alloc_size = sizeof(struct mv_priv),
+ .platdata_auto = sizeof(struct mv_priv),
};
static int sata_mv_probe(struct udevice *dev)
.name = "sata_sil_blk",
.id = UCLASS_BLK,
.ops = &sata_sil_blk_ops,
- .platdata_auto_alloc_size = sizeof(struct sil_sata_priv),
+ .platdata_auto = sizeof(struct sil_sata_priv),
};
static int sil_unbind_device(struct udevice *dev)
.ops = &sata_sil_ops,
.probe = sil_pci_probe,
.remove = sil_pci_remove,
- .priv_auto_alloc_size = sizeof(struct sil_sata_priv),
+ .priv_auto = sizeof(struct sil_sata_priv),
};
U_BOOT_PCI_DEVICE(sil_ahci_pci, supported);
.id = UCLASS_AXI,
.of_match = ihs_axi_ids,
.ops = &ihs_axi_ops,
- .priv_auto_alloc_size = sizeof(struct ihs_axi_priv),
+ .priv_auto = sizeof(struct ihs_axi_priv),
.probe = ihs_axi_probe,
};
.id = UCLASS_AXI_EMUL,
.of_match = sandbox_store_ids,
.ops = &sandbox_store_ops,
- .priv_auto_alloc_size = sizeof(struct sandbox_store_priv),
+ .priv_auto = sizeof(struct sandbox_store_priv),
.probe = sandbox_store_probe,
.remove = sandbox_store_remove,
};
.id = UCLASS_BLK,
.name = "blk",
.post_probe = blk_post_probe,
- .per_device_platdata_auto_alloc_size = sizeof(struct blk_desc),
+ .per_device_platdata_auto = sizeof(struct blk_desc),
};
.name = "sandbox_host_blk",
.id = UCLASS_BLK,
.ops = &sandbox_host_blk_ops,
- .platdata_auto_alloc_size = sizeof(struct host_block_dev),
+ .platdata_auto = sizeof(struct host_block_dev),
};
#else
U_BOOT_LEGACY_BLK(sandbox_host) = {
U_BOOT_DRIVER(bootcount_mem) = {
.name = "bootcount-mem",
.id = UCLASS_BOOTCOUNT,
- .priv_auto_alloc_size = sizeof(struct bootcount_mem_priv),
+ .priv_auto = sizeof(struct bootcount_mem_priv),
.probe = bootcount_mem_probe,
.of_match = bootcount_mem_ids,
.ops = &bootcount_mem_ops,
U_BOOT_DRIVER(bootcount_spi_flash) = {
.name = "bootcount-i2c-eeprom",
.id = UCLASS_BOOTCOUNT,
- .priv_auto_alloc_size = sizeof(struct bootcount_i2c_eeprom_priv),
+ .priv_auto = sizeof(struct bootcount_i2c_eeprom_priv),
.probe = bootcount_i2c_eeprom_probe,
.of_match = bootcount_i2c_eeprom_ids,
.ops = &bootcount_i2c_eeprom_ops,
U_BOOT_DRIVER(bootcount_rtc) = {
.name = "bootcount-rtc",
.id = UCLASS_BOOTCOUNT,
- .priv_auto_alloc_size = sizeof(struct bootcount_rtc_priv),
+ .priv_auto = sizeof(struct bootcount_rtc_priv),
.probe = bootcount_rtc_probe,
.of_match = bootcount_rtc_ids,
.ops = &bootcount_rtc_ops,
U_BOOT_DRIVER(bootcount_spi_flash) = {
.name = "bootcount-spi-flash",
.id = UCLASS_BOOTCOUNT,
- .priv_auto_alloc_size = sizeof(struct bootcount_spi_flash_priv),
+ .priv_auto = sizeof(struct bootcount_spi_flash_priv),
.probe = bootcount_spi_flash_probe,
.of_match = bootcount_spi_flash_ids,
.ops = &bootcount_spi_flash_ops,
.id = UCLASS_BUTTON,
.of_match = button_gpio_ids,
.ops = &button_gpio_ops,
- .priv_auto_alloc_size = sizeof(struct button_gpio_priv),
+ .priv_auto = sizeof(struct button_gpio_priv),
.bind = button_gpio_bind,
.probe = button_gpio_probe,
.remove = button_gpio_remove,
UCLASS_DRIVER(button) = {
.id = UCLASS_BUTTON,
.name = "button",
- .per_device_platdata_auto_alloc_size = sizeof(struct button_uc_plat),
+ .per_device_platdata_auto = sizeof(struct button_uc_plat),
};
.of_match = v5l2_cache_ids,
.ofdata_to_platdata = v5l2_ofdata_to_platdata,
.probe = v5l2_probe,
- .platdata_auto_alloc_size = sizeof(struct v5l2_plat),
+ .platdata_auto = sizeof(struct v5l2_plat),
.ops = &v5l2_cache_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.ops = &socfpga_clk_ops,
.probe = socfpga_clk_probe,
.ofdata_to_platdata = socfpga_clk_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct socfpga_clk_platdata),
+ .platdata_auto = sizeof(struct socfpga_clk_platdata),
};
.probe = socfpga_a10_clk_probe,
.ofdata_to_platdata = socfpga_a10_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct socfpga_a10_clk_platdata),
+ .platdata_auto = sizeof(struct socfpga_a10_clk_platdata),
};
.name = "aspeed_ast2500_scu",
.id = UCLASS_CLK,
.of_match = ast2500_clk_ids,
- .priv_auto_alloc_size = sizeof(struct ast2500_clk_priv),
+ .priv_auto = sizeof(struct ast2500_clk_priv),
.ops = &ast2500_clk_ops,
.bind = ast2500_clk_bind,
.ofdata_to_platdata = ast2500_clk_ofdata_to_platdata,
.id = UCLASS_CLK,
.of_match = main_osc_clk_match,
.probe = main_osc_clk_probe,
- .platdata_auto_alloc_size = sizeof(struct pmc_platdata),
+ .platdata_auto = sizeof(struct pmc_platdata),
.ops = &main_osc_clk_ops,
};
.id = UCLASS_CLK,
.of_match = plla_clk_match,
.probe = plla_clk_probe,
- .platdata_auto_alloc_size = sizeof(struct pmc_platdata),
+ .platdata_auto = sizeof(struct pmc_platdata),
.ops = &plla_clk_ops,
};
.id = UCLASS_CLK,
.of_match = at91_plladiv_clk_match,
.probe = at91_plladiv_clk_probe,
- .platdata_auto_alloc_size = sizeof(struct pmc_platdata),
+ .platdata_auto = sizeof(struct pmc_platdata),
.ops = &at91_plladiv_clk_ops,
};
.name = "system-clk",
.id = UCLASS_CLK,
.probe = at91_clk_probe,
- .platdata_auto_alloc_size = sizeof(struct pmc_platdata),
+ .platdata_auto = sizeof(struct pmc_platdata),
.ops = &system_clk_ops,
};
U_BOOT_DRIVER(clk_periph) = {
.name = "periph-clk",
.id = UCLASS_CLK,
- .platdata_auto_alloc_size = sizeof(struct pmc_platdata),
+ .platdata_auto = sizeof(struct pmc_platdata),
.probe = at91_clk_probe,
.ops = &periph_clk_ops,
};
.of_match = utmi_clk_match,
.probe = utmi_clk_probe,
.ofdata_to_platdata = utmi_clk_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct pmc_platdata),
+ .platdata_auto = sizeof(struct pmc_platdata),
.ops = &utmi_clk_ops,
};
.id = UCLASS_CLK,
.of_match = sama5d4_h32mx_clk_match,
.probe = sama5d4_h32mx_clk_probe,
- .platdata_auto_alloc_size = sizeof(struct pmc_platdata),
+ .platdata_auto = sizeof(struct pmc_platdata),
.ops = &sama5d4_h32mx_clk_ops,
};
.id = UCLASS_CLK,
.probe = at91_clk_probe,
.ofdata_to_platdata = generic_clk_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct generic_clk_priv),
- .platdata_auto_alloc_size = sizeof(struct pmc_platdata),
+ .priv_auto = sizeof(struct generic_clk_priv),
+ .platdata_auto = sizeof(struct pmc_platdata),
.ops = &generic_clk_ops,
};
.of_match = at91_usb_clk_match,
.probe = at91_usb_clk_probe,
.ofdata_to_platdata = at91_usb_clk_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct at91_usb_clk_priv),
- .platdata_auto_alloc_size = sizeof(struct pmc_platdata),
+ .priv_auto = sizeof(struct at91_usb_clk_priv),
+ .platdata_auto = sizeof(struct pmc_platdata),
.ops = &at91_usb_clk_ops,
};
.name = UBOOT_DM_CLK_AT91_SCKC,
.id = UCLASS_CLK,
.of_match = sam9x60_sckc_ids,
- .priv_auto_alloc_size = sizeof(struct sam9x60_sckc) * 2,
+ .priv_auto = sizeof(struct sam9x60_sckc) * 2,
.ops = &sam9x60_sckc_ops,
.probe = at91_sam9x60_sckc_probe,
.flags = DM_FLAG_PRE_RELOC,
.id = UCLASS_CLK,
.of_match = cdce9xx_clk_of_match,
.probe = cdce9xx_clk_probe,
- .priv_auto_alloc_size = sizeof(struct cdce9xx_clk_data),
+ .priv_auto = sizeof(struct cdce9xx_clk_data),
.ops = &cdce9xx_clk_ops,
};
.id = UCLASS_CLK,
.of_match = hsdk_cgu_clk_id,
.probe = hsdk_cgu_clk_probe,
- .priv_auto_alloc_size = sizeof(struct hsdk_cgu_clk),
+ .priv_auto = sizeof(struct hsdk_cgu_clk),
.ops = &hsdk_cgu_ops,
};
.id = UCLASS_CLK,
.of_match = ti_sci_clk_of_match,
.probe = ti_sci_clk_probe,
- .priv_auto_alloc_size = sizeof(struct ti_sci_clk_data),
+ .priv_auto = sizeof(struct ti_sci_clk_data),
.ops = &ti_sci_clk_ops,
};
.of_match = bcm6345_clk_ids,
.ops = &bcm6345_clk_ops,
.probe = bcm63xx_clk_probe,
- .priv_auto_alloc_size = sizeof(struct bcm6345_clk_priv),
+ .priv_auto = sizeof(struct bcm6345_clk_priv),
};
.id = UCLASS_CLK,
.of_match = clk_boston_match,
.ofdata_to_platdata = clk_boston_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct clk_boston),
+ .platdata_auto = sizeof(struct clk_boston),
.ops = &clk_boston_ops,
};
.id = UCLASS_CLK,
.of_match = clk_fixed_factor_match,
.ofdata_to_platdata = clk_fixed_factor_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct clk_fixed_factor),
+ .platdata_auto = sizeof(struct clk_fixed_factor),
.ops = &clk_fixed_factor_ops,
};
.id = UCLASS_CLK,
.of_match = clk_fixed_rate_match,
.ofdata_to_platdata = clk_fixed_rate_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct clk_fixed_rate),
+ .platdata_auto = sizeof(struct clk_fixed_rate),
.ops = &clk_fixed_rate_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.of_match = octeon_clk_ids,
.ops = &octeon_clk_ops,
.probe = octeon_clk_probe,
- .priv_auto_alloc_size = sizeof(struct octeon_clk_priv),
+ .priv_auto = sizeof(struct octeon_clk_priv),
};
.of_match = pic32_clk_ids,
.ops = &pic32_pic32_clk_ops,
.probe = pic32_clk_probe,
- .priv_auto_alloc_size = sizeof(struct pic32_clk_priv),
+ .priv_auto = sizeof(struct pic32_clk_priv),
};
.of_match = sandbox_clk_ids,
.ops = &sandbox_clk_ops,
.probe = sandbox_clk_probe,
- .priv_auto_alloc_size = sizeof(struct sandbox_clk_priv),
+ .priv_auto = sizeof(struct sandbox_clk_priv),
};
ulong sandbox_clk_query_rate(struct udevice *dev, int id)
.id = UCLASS_MISC,
.of_match = sandbox_clk_test_ids,
.probe = sandbox_clk_test_probe,
- .priv_auto_alloc_size = sizeof(struct sandbox_clk_test),
+ .priv_auto = sizeof(struct sandbox_clk_test),
};
.id = UCLASS_CLK,
.ops = &stm32_clk_ops,
.probe = stm32_clk_probe,
- .priv_auto_alloc_size = sizeof(struct stm32_clk),
+ .priv_auto = sizeof(struct stm32_clk),
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.ops = &stm32_clk_ops,
.probe = stm32_clk_probe,
- .priv_auto_alloc_size = sizeof(struct stm32_clk),
+ .priv_auto = sizeof(struct stm32_clk),
.flags = DM_FLAG_PRE_RELOC,
};
.name = "stm32mp1_clk",
.id = UCLASS_CLK,
.ops = &stm32mp1_clk_ops,
- .priv_auto_alloc_size = sizeof(struct stm32mp1_clk_priv),
+ .priv_auto = sizeof(struct stm32mp1_clk_priv),
.probe = stm32mp1_clk_probe,
};
.of_match = versal_clk_ids,
.probe = versal_clk_probe,
.ops = &versal_clk_ops,
- .priv_auto_alloc_size = sizeof(struct versal_clk_priv),
+ .priv_auto = sizeof(struct versal_clk_priv),
};
.id = UCLASS_CLK,
.of_match = vexpress_osc_clk_ids,
.ops = &vexpress_osc_clk_ops,
- .priv_auto_alloc_size = sizeof(struct vexpress_osc_clk_priv),
+ .priv_auto = sizeof(struct vexpress_osc_clk_priv),
.probe = vexpress_osc_clk_probe,
};
.id = UCLASS_CLK,
.of_match = zynq_clk_ids,
.ops = &zynq_clk_ops,
- .priv_auto_alloc_size = sizeof(struct zynq_clk_priv),
+ .priv_auto = sizeof(struct zynq_clk_priv),
.probe = zynq_clk_probe,
};
.of_match = zynqmp_clk_ids,
.probe = zynqmp_clk_probe,
.ops = &zynqmp_clk_ops,
- .priv_auto_alloc_size = sizeof(struct zynqmp_clk_priv),
+ .priv_auto = sizeof(struct zynqmp_clk_priv),
};
.id = UCLASS_CLK,
.of_match = exynos7420_clk_topc_compat,
.probe = exynos7420_clk_topc_probe,
- .priv_auto_alloc_size = sizeof(struct exynos7420_clk_topc_priv),
+ .priv_auto = sizeof(struct exynos7420_clk_topc_priv),
.ops = &exynos7420_clk_topc_ops,
};
.id = UCLASS_CLK,
.of_match = exynos7420_clk_top0_compat,
.probe = exynos7420_clk_top0_probe,
- .priv_auto_alloc_size = sizeof(struct exynos7420_clk_top0_priv),
+ .priv_auto = sizeof(struct exynos7420_clk_top0_priv),
.ops = &exynos7420_clk_top0_ops,
};
.ops = &ics8n3qv01_ops,
.of_match = ics8n3qv01_ids,
.probe = ics8n3qv01_probe,
- .priv_auto_alloc_size = sizeof(struct ics8n3qv01_priv),
+ .priv_auto = sizeof(struct ics8n3qv01_priv),
};
.id = UCLASS_CLK,
.of_match = mt7622_apmixed_compat,
.probe = mt7622_apmixedsys_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_clk_priv),
+ .priv_auto = sizeof(struct mtk_clk_priv),
.ops = &mtk_clk_apmixedsys_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt7622_topckgen_compat,
.probe = mt7622_topckgen_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_clk_priv),
+ .priv_auto = sizeof(struct mtk_clk_priv),
.ops = &mtk_clk_topckgen_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt7622_infracfg_compat,
.probe = mt7622_infracfg_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt7622_pericfg_compat,
.probe = mt7622_pericfg_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.of_match = mt7622_pciesys_compat,
.probe = mt7622_pciesys_probe,
.bind = mt7622_pciesys_bind,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
};
.of_match = mt7622_ethsys_compat,
.probe = mt7622_ethsys_probe,
.bind = mt7622_ethsys_bind,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
};
.id = UCLASS_CLK,
.of_match = mt7622_sgmiisys_compat,
.probe = mt7622_sgmiisys_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
};
.id = UCLASS_CLK,
.of_match = mt7622_ssusbsys_compat,
.probe = mt7622_ssusbsys_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
};
.id = UCLASS_CLK,
.of_match = mt7623_apmixed_compat,
.probe = mt7623_apmixedsys_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_clk_priv),
+ .priv_auto = sizeof(struct mtk_clk_priv),
.ops = &mtk_clk_apmixedsys_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt7623_topckgen_compat,
.probe = mt7623_topckgen_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_clk_priv),
+ .priv_auto = sizeof(struct mtk_clk_priv),
.ops = &mtk_clk_topckgen_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt7623_infracfg_compat,
.probe = mt7623_infracfg_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt7623_pericfg_compat,
.probe = mt7623_pericfg_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.of_match = mt7623_hifsys_compat,
.probe = mt7623_hifsys_probe,
.bind = mt7623_ethsys_hifsys_bind,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
};
.of_match = mt7623_ethsys_compat,
.probe = mt7623_ethsys_probe,
.bind = mt7623_ethsys_hifsys_bind,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
};
.id = UCLASS_CLK,
.of_match = mt7629_apmixed_compat,
.probe = mt7629_apmixedsys_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_clk_priv),
+ .priv_auto = sizeof(struct mtk_clk_priv),
.ops = &mtk_clk_apmixedsys_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt7629_topckgen_compat,
.probe = mt7629_topckgen_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_clk_priv),
+ .priv_auto = sizeof(struct mtk_clk_priv),
.ops = &mtk_clk_topckgen_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt7629_infracfg_compat,
.probe = mt7629_infracfg_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt7629_pericfg_compat,
.probe = mt7629_pericfg_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.of_match = mt7629_ethsys_compat,
.probe = mt7629_ethsys_probe,
.bind = mt7629_ethsys_bind,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
};
.id = UCLASS_CLK,
.of_match = mt7629_sgmiisys_compat,
.probe = mt7629_sgmiisys_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
};
.id = UCLASS_CLK,
.of_match = mt7629_ssusbsys_compat,
.probe = mt7629_ssusbsys_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
};
.id = UCLASS_CLK,
.of_match = mt8512_apmixed_compat,
.probe = mt8512_apmixedsys_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_clk_priv),
+ .priv_auto = sizeof(struct mtk_clk_priv),
.ops = &mtk_clk_apmixedsys_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt8512_topckgen_compat,
.probe = mt8512_topckgen_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_clk_priv),
+ .priv_auto = sizeof(struct mtk_clk_priv),
.ops = &mtk_clk_topckgen_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt8512_topckgen_cg_compat,
.probe = mt8512_topckgen_cg_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt8512_infracfg_compat,
.probe = mt8512_infracfg_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt8516_apmixed_compat,
.probe = mt8516_apmixedsys_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_clk_priv),
+ .priv_auto = sizeof(struct mtk_clk_priv),
.ops = &mtk_clk_apmixedsys_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt8516_topckgen_compat,
.probe = mt8516_topckgen_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_clk_priv),
+ .priv_auto = sizeof(struct mtk_clk_priv),
.ops = &mtk_clk_topckgen_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt8516_topckgen_cg_compat,
.probe = mt8516_topckgen_cg_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt8518_apmixed_compat,
.probe = mt8518_apmixedsys_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_clk_priv),
+ .priv_auto = sizeof(struct mtk_clk_priv),
.ops = &mtk_clk_apmixedsys_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt8518_topckgen_compat,
.probe = mt8518_topckgen_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_clk_priv),
+ .priv_auto = sizeof(struct mtk_clk_priv),
.ops = &mtk_clk_topckgen_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CLK,
.of_match = mt8518_topckgen_cg_compat,
.probe = mt8518_topckgen_cg_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_cg_priv),
+ .priv_auto = sizeof(struct mtk_cg_priv),
.ops = &mtk_clk_gate_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.name = "meson_clk_axg",
.id = UCLASS_CLK,
.of_match = meson_clk_ids,
- .priv_auto_alloc_size = sizeof(struct meson_clk),
+ .priv_auto = sizeof(struct meson_clk),
.ops = &meson_clk_ops,
.probe = meson_clk_probe,
};
.name = "meson_clk_g12a",
.id = UCLASS_CLK,
.of_match = meson_clk_ids,
- .priv_auto_alloc_size = sizeof(struct meson_clk),
+ .priv_auto = sizeof(struct meson_clk),
.ops = &meson_clk_ops,
.probe = meson_clk_probe,
};
.name = "meson_clk",
.id = UCLASS_CLK,
.of_match = meson_clk_ids,
- .priv_auto_alloc_size = sizeof(struct meson_clk),
+ .priv_auto = sizeof(struct meson_clk),
.ops = &meson_clk_ops,
.probe = meson_clk_probe,
};
.of_match = mpc83xx_clk_match,
.ops = &mpc83xx_clk_ops,
.probe = mpc83xx_clk_probe,
- .priv_auto_alloc_size = sizeof(struct mpc83xx_clk_priv),
+ .priv_auto = sizeof(struct mpc83xx_clk_priv),
.bind = mpc83xx_clk_bind,
};
.id = UCLASS_CLK,
.of_match = mt7628_clk_ids,
.probe = mt7628_clk_probe,
- .priv_auto_alloc_size = sizeof(struct mt7628_clk_priv),
+ .priv_auto = sizeof(struct mt7628_clk_priv),
.ops = &mt7628_clk_ops,
};
.id = UCLASS_CLK,
.of_match = armada_37xx_periph_clk_ids,
.ops = &armada_37xx_periph_clk_ops,
- .priv_auto_alloc_size = sizeof(struct a37xx_periphclk),
+ .priv_auto = sizeof(struct a37xx_periphclk),
.probe = armada_37xx_periph_clk_probe,
};
.id = UCLASS_CLK,
.of_match = armada_37xx_tbg_clk_ids,
.ops = &armada_37xx_tbg_clk_ops,
- .priv_auto_alloc_size = sizeof(struct a37xx_tbgclk),
+ .priv_auto = sizeof(struct a37xx_tbgclk),
.probe = armada_37xx_tbg_clk_probe,
};
.id = UCLASS_CLK,
.of_match = owl_clk_ids,
.ops = &owl_clk_ops,
- .priv_auto_alloc_size = sizeof(struct owl_clk_priv),
+ .priv_auto = sizeof(struct owl_clk_priv),
.probe = owl_clk_probe,
};
.name = "clk_r8a774a1",
.id = UCLASS_CLK,
.of_match = r8a774a1_clk_ids,
- .priv_auto_alloc_size = sizeof(struct gen3_clk_priv),
+ .priv_auto = sizeof(struct gen3_clk_priv),
.ops = &gen3_clk_ops,
.probe = gen3_clk_probe,
.remove = gen3_clk_remove,
.name = "clk_r8a774b1",
.id = UCLASS_CLK,
.of_match = r8a774b1_clk_ids,
- .priv_auto_alloc_size = sizeof(struct gen3_clk_priv),
+ .priv_auto = sizeof(struct gen3_clk_priv),
.ops = &gen3_clk_ops,
.probe = gen3_clk_probe,
.remove = gen3_clk_remove,
.name = "clk_r8a774c0",
.id = UCLASS_CLK,
.of_match = r8a774c0_clk_ids,
- .priv_auto_alloc_size = sizeof(struct gen3_clk_priv),
+ .priv_auto = sizeof(struct gen3_clk_priv),
.ops = &gen3_clk_ops,
.probe = gen3_clk_probe,
.remove = gen3_clk_remove,
.name = "clk_r8a774e1",
.id = UCLASS_CLK,
.of_match = r8a774e1_clk_ids,
- .priv_auto_alloc_size = sizeof(struct gen3_clk_priv),
+ .priv_auto = sizeof(struct gen3_clk_priv),
.ops = &gen3_clk_ops,
.probe = gen3_clk_probe,
.remove = gen3_clk_remove,
.name = "clk_r8a7790",
.id = UCLASS_CLK,
.of_match = r8a7790_clk_ids,
- .priv_auto_alloc_size = sizeof(struct gen2_clk_priv),
+ .priv_auto = sizeof(struct gen2_clk_priv),
.ops = &gen2_clk_ops,
.probe = gen2_clk_probe,
.remove = gen2_clk_remove,
.name = "clk_r8a7791",
.id = UCLASS_CLK,
.of_match = r8a7791_clk_ids,
- .priv_auto_alloc_size = sizeof(struct gen2_clk_priv),
+ .priv_auto = sizeof(struct gen2_clk_priv),
.ops = &gen2_clk_ops,
.probe = gen2_clk_probe,
.remove = gen2_clk_remove,
.name = "clk_r8a7792",
.id = UCLASS_CLK,
.of_match = r8a7792_clk_ids,
- .priv_auto_alloc_size = sizeof(struct gen2_clk_priv),
+ .priv_auto = sizeof(struct gen2_clk_priv),
.ops = &gen2_clk_ops,
.probe = gen2_clk_probe,
.remove = gen2_clk_remove,
.name = "clk_r8a7794",
.id = UCLASS_CLK,
.of_match = r8a7794_clk_ids,
- .priv_auto_alloc_size = sizeof(struct gen2_clk_priv),
+ .priv_auto = sizeof(struct gen2_clk_priv),
.ops = &gen2_clk_ops,
.probe = gen2_clk_probe,
.remove = gen2_clk_remove,
.name = "clk_r8a7795",
.id = UCLASS_CLK,
.of_match = r8a7795_clk_ids,
- .priv_auto_alloc_size = sizeof(struct gen3_clk_priv),
+ .priv_auto = sizeof(struct gen3_clk_priv),
.ops = &gen3_clk_ops,
.probe = gen3_clk_probe,
.remove = gen3_clk_remove,
.name = "clk_r8a7796",
.id = UCLASS_CLK,
.of_match = r8a7796_clk_ids,
- .priv_auto_alloc_size = sizeof(struct gen3_clk_priv),
+ .priv_auto = sizeof(struct gen3_clk_priv),
.ops = &gen3_clk_ops,
.probe = gen3_clk_probe,
.remove = gen3_clk_remove,
.name = "clk_r8a77965",
.id = UCLASS_CLK,
.of_match = r8a77965_clk_ids,
- .priv_auto_alloc_size = sizeof(struct gen3_clk_priv),
+ .priv_auto = sizeof(struct gen3_clk_priv),
.ops = &gen3_clk_ops,
.probe = gen3_clk_probe,
.remove = gen3_clk_remove,
.name = "clk_r8a77970",
.id = UCLASS_CLK,
.of_match = r8a77970_clk_ids,
- .priv_auto_alloc_size = sizeof(struct gen3_clk_priv),
+ .priv_auto = sizeof(struct gen3_clk_priv),
.ops = &gen3_clk_ops,
.probe = gen3_clk_probe,
.remove = gen3_clk_remove,
.name = "clk_r8a77980",
.id = UCLASS_CLK,
.of_match = r8a77980_clk_ids,
- .priv_auto_alloc_size = sizeof(struct gen3_clk_priv),
+ .priv_auto = sizeof(struct gen3_clk_priv),
.ops = &gen3_clk_ops,
.probe = gen3_clk_probe,
.remove = gen3_clk_remove,
.name = "clk_r8a77990",
.id = UCLASS_CLK,
.of_match = r8a77990_clk_ids,
- .priv_auto_alloc_size = sizeof(struct gen3_clk_priv),
+ .priv_auto = sizeof(struct gen3_clk_priv),
.ops = &gen3_clk_ops,
.probe = gen3_clk_probe,
.remove = gen3_clk_remove,
.name = "clk_r8a77995",
.id = UCLASS_CLK,
.of_match = r8a77995_clk_ids,
- .priv_auto_alloc_size = sizeof(struct gen3_clk_priv),
+ .priv_auto = sizeof(struct gen3_clk_priv),
.ops = &gen3_clk_ops,
.probe = gen3_clk_probe,
.remove = gen3_clk_remove,
.name = "rockchip_px30_cru",
.id = UCLASS_CLK,
.of_match = px30_clk_ids,
- .priv_auto_alloc_size = sizeof(struct px30_clk_priv),
+ .priv_auto = sizeof(struct px30_clk_priv),
.ofdata_to_platdata = px30_clk_ofdata_to_platdata,
.ops = &px30_clk_ops,
.bind = px30_clk_bind,
.name = "rockchip_px30_pmucru",
.id = UCLASS_CLK,
.of_match = px30_pmuclk_ids,
- .priv_auto_alloc_size = sizeof(struct px30_pmuclk_priv),
+ .priv_auto = sizeof(struct px30_pmuclk_priv),
.ofdata_to_platdata = px30_pmuclk_ofdata_to_platdata,
.ops = &px30_pmuclk_ops,
.probe = px30_pmuclk_probe,
.name = "clk_rk3036",
.id = UCLASS_CLK,
.of_match = rk3036_clk_ids,
- .priv_auto_alloc_size = sizeof(struct rk3036_clk_priv),
+ .priv_auto = sizeof(struct rk3036_clk_priv),
.ofdata_to_platdata = rk3036_clk_ofdata_to_platdata,
.ops = &rk3036_clk_ops,
.bind = rk3036_clk_bind,
.name = "clk_rk3128",
.id = UCLASS_CLK,
.of_match = rk3128_clk_ids,
- .priv_auto_alloc_size = sizeof(struct rk3128_clk_priv),
+ .priv_auto = sizeof(struct rk3128_clk_priv),
.ofdata_to_platdata = rk3128_clk_ofdata_to_platdata,
.ops = &rk3128_clk_ops,
.bind = rk3128_clk_bind,
.name = "rockchip_rk3188_cru",
.id = UCLASS_CLK,
.of_match = rk3188_clk_ids,
- .priv_auto_alloc_size = sizeof(struct rk3188_clk_priv),
- .platdata_auto_alloc_size = sizeof(struct rk3188_clk_plat),
+ .priv_auto = sizeof(struct rk3188_clk_priv),
+ .platdata_auto = sizeof(struct rk3188_clk_plat),
.ops = &rk3188_clk_ops,
.bind = rk3188_clk_bind,
.ofdata_to_platdata = rk3188_clk_ofdata_to_platdata,
.name = "clk_rk322x",
.id = UCLASS_CLK,
.of_match = rk322x_clk_ids,
- .priv_auto_alloc_size = sizeof(struct rk322x_clk_priv),
+ .priv_auto = sizeof(struct rk322x_clk_priv),
.ofdata_to_platdata = rk322x_clk_ofdata_to_platdata,
.ops = &rk322x_clk_ops,
.bind = rk322x_clk_bind,
.name = "rockchip_rk3288_cru",
.id = UCLASS_CLK,
.of_match = rk3288_clk_ids,
- .priv_auto_alloc_size = sizeof(struct rk3288_clk_priv),
- .platdata_auto_alloc_size = sizeof(struct rk3288_clk_plat),
+ .priv_auto = sizeof(struct rk3288_clk_priv),
+ .platdata_auto = sizeof(struct rk3288_clk_plat),
.ops = &rk3288_clk_ops,
.bind = rk3288_clk_bind,
.ofdata_to_platdata = rk3288_clk_ofdata_to_platdata,
.name = "rockchip_rk3308_cru",
.id = UCLASS_CLK,
.of_match = rk3308_clk_ids,
- .priv_auto_alloc_size = sizeof(struct rk3308_clk_priv),
+ .priv_auto = sizeof(struct rk3308_clk_priv),
.ofdata_to_platdata = rk3308_clk_ofdata_to_platdata,
.ops = &rk3308_clk_ops,
.bind = rk3308_clk_bind,
.name = "rockchip_rk3328_cru",
.id = UCLASS_CLK,
.of_match = rk3328_clk_ids,
- .priv_auto_alloc_size = sizeof(struct rk3328_clk_priv),
+ .priv_auto = sizeof(struct rk3328_clk_priv),
.ofdata_to_platdata = rk3328_clk_ofdata_to_platdata,
.ops = &rk3328_clk_ops,
.bind = rk3328_clk_bind,
.name = "rockchip_rk3368_cru",
.id = UCLASS_CLK,
.of_match = rk3368_clk_ids,
- .priv_auto_alloc_size = sizeof(struct rk3368_clk_priv),
+ .priv_auto = sizeof(struct rk3368_clk_priv),
#if CONFIG_IS_ENABLED(OF_PLATDATA)
- .platdata_auto_alloc_size = sizeof(struct rk3368_clk_plat),
+ .platdata_auto = sizeof(struct rk3368_clk_plat),
#endif
.ofdata_to_platdata = rk3368_clk_ofdata_to_platdata,
.ops = &rk3368_clk_ops,
.name = "rockchip_rk3399_cru",
.id = UCLASS_CLK,
.of_match = rk3399_clk_ids,
- .priv_auto_alloc_size = sizeof(struct rk3399_clk_priv),
+ .priv_auto = sizeof(struct rk3399_clk_priv),
.ofdata_to_platdata = rk3399_clk_ofdata_to_platdata,
.ops = &rk3399_clk_ops,
.bind = rk3399_clk_bind,
.probe = rk3399_clk_probe,
#if CONFIG_IS_ENABLED(OF_PLATDATA)
- .platdata_auto_alloc_size = sizeof(struct rk3399_clk_plat),
+ .platdata_auto = sizeof(struct rk3399_clk_plat),
#endif
};
.name = "rockchip_rk3399_pmucru",
.id = UCLASS_CLK,
.of_match = rk3399_pmuclk_ids,
- .priv_auto_alloc_size = sizeof(struct rk3399_pmuclk_priv),
+ .priv_auto = sizeof(struct rk3399_pmuclk_priv),
.ofdata_to_platdata = rk3399_pmuclk_ofdata_to_platdata,
.ops = &rk3399_pmuclk_ops,
.probe = rk3399_pmuclk_probe,
.bind = rk3399_pmuclk_bind,
#if CONFIG_IS_ENABLED(OF_PLATDATA)
- .platdata_auto_alloc_size = sizeof(struct rk3399_pmuclk_plat),
+ .platdata_auto = sizeof(struct rk3399_pmuclk_plat),
#endif
};
.name = "clk_rv1108",
.id = UCLASS_CLK,
.of_match = rv1108_clk_ids,
- .priv_auto_alloc_size = sizeof(struct rv1108_clk_priv),
+ .priv_auto = sizeof(struct rv1108_clk_priv),
.ops = &rv1108_clk_ops,
.bind = rv1108_clk_bind,
.ofdata_to_platdata = rv1108_clk_ofdata_to_platdata,
.of_match = sifive_fu540_prci_ids,
.probe = sifive_fu540_prci_probe,
.ops = &sifive_fu540_prci_ops,
- .priv_auto_alloc_size = sizeof(struct __prci_data),
+ .priv_auto = sizeof(struct __prci_data),
.bind = sifive_fu540_clk_bind,
};
.name = "sun4i_a10_ccu",
.id = UCLASS_CLK,
.of_match = a10_ccu_ids,
- .priv_auto_alloc_size = sizeof(struct ccu_priv),
+ .priv_auto = sizeof(struct ccu_priv),
.ops = &sunxi_clk_ops,
.probe = sunxi_clk_probe,
.bind = a10_clk_bind,
.name = "sun5i_a10s_ccu",
.id = UCLASS_CLK,
.of_match = a10s_ccu_ids,
- .priv_auto_alloc_size = sizeof(struct ccu_priv),
+ .priv_auto = sizeof(struct ccu_priv),
.ops = &sunxi_clk_ops,
.probe = sunxi_clk_probe,
.bind = a10s_clk_bind,
.name = "sun8i_a23_ccu",
.id = UCLASS_CLK,
.of_match = a23_clk_ids,
- .priv_auto_alloc_size = sizeof(struct ccu_priv),
+ .priv_auto = sizeof(struct ccu_priv),
.ops = &sunxi_clk_ops,
.probe = sunxi_clk_probe,
.bind = a23_clk_bind,
.name = "sun6i_a31_ccu",
.id = UCLASS_CLK,
.of_match = a31_clk_ids,
- .priv_auto_alloc_size = sizeof(struct ccu_priv),
+ .priv_auto = sizeof(struct ccu_priv),
.ops = &sunxi_clk_ops,
.probe = sunxi_clk_probe,
.bind = a31_clk_bind,
.name = "sun50i_a64_ccu",
.id = UCLASS_CLK,
.of_match = a64_ccu_ids,
- .priv_auto_alloc_size = sizeof(struct ccu_priv),
+ .priv_auto = sizeof(struct ccu_priv),
.ops = &sunxi_clk_ops,
.probe = sunxi_clk_probe,
.bind = a64_clk_bind,
.name = "sun9i_a80_ccu",
.id = UCLASS_CLK,
.of_match = a80_ccu_ids,
- .priv_auto_alloc_size = sizeof(struct ccu_priv),
+ .priv_auto = sizeof(struct ccu_priv),
.ops = &sunxi_clk_ops,
.probe = sunxi_clk_probe,
.bind = a80_clk_bind,
.name = "sun8i_a83t_ccu",
.id = UCLASS_CLK,
.of_match = a83t_clk_ids,
- .priv_auto_alloc_size = sizeof(struct ccu_priv),
+ .priv_auto = sizeof(struct ccu_priv),
.ops = &sunxi_clk_ops,
.probe = sunxi_clk_probe,
.bind = a83t_clk_bind,
.name = "sun8i_h3_ccu",
.id = UCLASS_CLK,
.of_match = h3_ccu_ids,
- .priv_auto_alloc_size = sizeof(struct ccu_priv),
+ .priv_auto = sizeof(struct ccu_priv),
.ops = &sunxi_clk_ops,
.probe = sunxi_clk_probe,
.bind = h3_clk_bind,
.name = "sun50i_h6_ccu",
.id = UCLASS_CLK,
.of_match = h6_ccu_ids,
- .priv_auto_alloc_size = sizeof(struct ccu_priv),
+ .priv_auto = sizeof(struct ccu_priv),
.ops = &sunxi_clk_ops,
.probe = sunxi_clk_probe,
.bind = h6_clk_bind,
.name = "sun8i_r40_ccu",
.id = UCLASS_CLK,
.of_match = r40_clk_ids,
- .priv_auto_alloc_size = sizeof(struct ccu_priv),
+ .priv_auto = sizeof(struct ccu_priv),
.ops = &sunxi_clk_ops,
.probe = sunxi_clk_probe,
.bind = r40_clk_bind,
.name = "sun8i_v3s_ccu",
.id = UCLASS_CLK,
.of_match = v3s_clk_ids,
- .priv_auto_alloc_size = sizeof(struct ccu_priv),
+ .priv_auto = sizeof(struct ccu_priv),
.ops = &sunxi_clk_ops,
.probe = sunxi_clk_probe,
.bind = v3s_clk_bind,
.id = UCLASS_CLK,
.of_match = uniphier_clk_match,
.probe = uniphier_clk_probe,
- .priv_auto_alloc_size = sizeof(struct uniphier_clk_priv),
+ .priv_auto = sizeof(struct uniphier_clk_priv),
.ops = &uniphier_clk_ops,
};
{
int size;
- if (dev->driver->priv_auto_alloc_size) {
+ if (dev->driver->priv_auto) {
free(dev->priv);
dev->priv = NULL;
}
- size = dev->uclass->uc_drv->per_device_auto_alloc_size;
+ size = dev->uclass->uc_drv->per_device_auto;
if (size) {
free(dev->uclass_priv);
dev->uclass_priv = NULL;
}
if (dev->parent) {
- size = dev->parent->driver->per_child_auto_alloc_size;
+ size = dev->parent->driver->per_child_auto;
if (!size) {
size = dev->parent->uclass->uc_drv->
- per_child_auto_alloc_size;
+ per_child_auto;
}
if (size) {
free(dev->parent_priv);
}
}
- if (drv->platdata_auto_alloc_size) {
+ if (drv->platdata_auto) {
bool alloc = !platdata;
if (CONFIG_IS_ENABLED(OF_PLATDATA)) {
if (of_platdata_size) {
dev->flags |= DM_FLAG_OF_PLATDATA;
- if (of_platdata_size <
- drv->platdata_auto_alloc_size)
+ if (of_platdata_size < drv->platdata_auto)
alloc = true;
}
}
if (alloc) {
dev->flags |= DM_FLAG_ALLOC_PDATA;
- dev->platdata = calloc(1,
- drv->platdata_auto_alloc_size);
+ dev->platdata = calloc(1, drv->platdata_auto);
if (!dev->platdata) {
ret = -ENOMEM;
goto fail_alloc1;
}
}
- size = uc->uc_drv->per_device_platdata_auto_alloc_size;
+ size = uc->uc_drv->per_device_platdata_auto;
if (size) {
dev->flags |= DM_FLAG_ALLOC_UCLASS_PDATA;
dev->uclass_platdata = calloc(1, size);
}
if (parent) {
- size = parent->driver->per_child_platdata_auto_alloc_size;
+ size = parent->driver->per_child_platdata_auto;
if (!size) {
- size = parent->uclass->uc_drv->
- per_child_platdata_auto_alloc_size;
+ size = parent->uclass->uc_drv->per_child_platdata_auto;
}
if (size) {
dev->flags |= DM_FLAG_ALLOC_PARENT_PDATA;
assert(drv);
/* Allocate private data if requested and not reentered */
- if (drv->priv_auto_alloc_size && !dev->priv) {
- dev->priv = alloc_priv(drv->priv_auto_alloc_size, drv->flags);
+ if (drv->priv_auto && !dev->priv) {
+ dev->priv = alloc_priv(drv->priv_auto, drv->flags);
if (!dev->priv) {
ret = -ENOMEM;
goto fail;
}
}
/* Allocate private data if requested and not reentered */
- size = dev->uclass->uc_drv->per_device_auto_alloc_size;
+ size = dev->uclass->uc_drv->per_device_auto;
if (size && !dev->uclass_priv) {
dev->uclass_priv = alloc_priv(size,
dev->uclass->uc_drv->flags);
/* Allocate parent data for this child */
if (dev->parent) {
- size = dev->parent->driver->per_child_auto_alloc_size;
+ size = dev->parent->driver->per_child_auto;
if (!size) {
- size = dev->parent->uclass->uc_drv->
- per_child_auto_alloc_size;
+ size = dev->parent->uclass->uc_drv->per_child_auto;
}
if (size && !dev->parent_priv) {
dev->parent_priv = alloc_priv(size, drv->flags);
.id = UCLASS_SIMPLE_BUS,
.name = "simple_bus",
.post_bind = simple_bus_post_bind,
- .per_device_platdata_auto_alloc_size = sizeof(struct simple_bus_plat),
+ .per_device_platdata_auto = sizeof(struct simple_bus_plat),
};
static const struct udevice_id generic_simple_bus_ids[] = {
.of_match = simple_pm_bus_ids,
.probe = simple_pm_bus_probe,
.remove = simple_pm_bus_remove,
- .priv_auto_alloc_size = sizeof(struct clk_bulk),
+ .priv_auto = sizeof(struct clk_bulk),
.flags = DM_FLAG_PRE_RELOC,
};
UCLASS_DRIVER(syscon) = {
.id = UCLASS_SYSCON,
.name = "syscon",
- .per_device_auto_alloc_size = sizeof(struct syscon_uc_info),
+ .per_device_auto = sizeof(struct syscon_uc_info),
.pre_probe = syscon_pre_probe,
};
uc = calloc(1, sizeof(*uc));
if (!uc)
return -ENOMEM;
- if (uc_drv->priv_auto_alloc_size) {
- uc->priv = calloc(1, uc_drv->priv_auto_alloc_size);
+ if (uc_drv->priv_auto) {
+ uc->priv = calloc(1, uc_drv->priv_auto);
if (!uc->priv) {
ret = -ENOMEM;
goto fail_mem;
return 0;
fail:
- if (uc_drv->priv_auto_alloc_size) {
+ if (uc_drv->priv_auto) {
free(uc->priv);
uc->priv = NULL;
}
if (uc_drv->destroy)
uc_drv->destroy(uc);
list_del(&uc->sibling_node);
- if (uc_drv->priv_auto_alloc_size)
+ if (uc_drv->priv_auto)
free(uc->priv);
free(uc);
.of_match = at91_cpu_ids,
.ops = &at91_cpu_ops,
.probe = at91_cpu_probe,
- .platdata_auto_alloc_size = sizeof(struct at91_cpu_platdata),
+ .platdata_auto = sizeof(struct at91_cpu_platdata),
.flags = DM_FLAG_PRE_RELOC,
};
.of_match = bmips_cpu_ids,
.bind = bmips_cpu_bind,
.probe = bmips_cpu_probe,
- .priv_auto_alloc_size = sizeof(struct bmips_cpu_priv),
+ .priv_auto = sizeof(struct bmips_cpu_priv),
.ops = &bmips_cpu_ops,
.flags = DM_FLAG_PRE_RELOC,
};
U_BOOT_DRIVER(cpu_bus) = {
.name = "cpu_bus",
.id = UCLASS_SIMPLE_BUS,
- .per_child_platdata_auto_alloc_size = sizeof(struct cpu_platdata),
+ .per_child_platdata_auto = sizeof(struct cpu_platdata),
};
static int uclass_cpu_init(struct uclass *uc)
.of_match = cpu_imx8_ids,
.ops = &cpu_imx8_ops,
.probe = imx8_cpu_probe,
- .platdata_auto_alloc_size = sizeof(struct cpu_imx_platdata),
+ .platdata_auto = sizeof(struct cpu_imx_platdata),
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_CPU,
.of_match = mpc83xx_cpu_ids,
.probe = mpc83xx_cpu_probe,
- .priv_auto_alloc_size = sizeof(struct mpc83xx_cpu_priv),
+ .priv_auto = sizeof(struct mpc83xx_cpu_priv),
.ops = &mpc83xx_cpu_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_RNG,
.ops = &caam_rng_ops,
.probe = caam_rng_probe,
- .priv_auto_alloc_size = sizeof(struct caam_rng_priv),
+ .priv_auto = sizeof(struct caam_rng_priv),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.of_match = altera_gen5_sdram_ids,
.ops = &altera_gen5_sdram_ops,
.ofdata_to_platdata = altera_gen5_sdram_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct altera_gen5_sdram_platdata),
+ .platdata_auto = sizeof(struct altera_gen5_sdram_platdata),
.probe = altera_gen5_sdram_probe,
- .priv_auto_alloc_size = sizeof(struct altera_gen5_sdram_priv),
+ .priv_auto = sizeof(struct altera_gen5_sdram_priv),
};
#endif /* CONFIG_SPL_BUILD */
.of_match = altera_sdram_ids,
.ops = &altera_sdram_ops,
.ofdata_to_platdata = altera_sdram_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct altera_sdram_platdata),
+ .platdata_auto = sizeof(struct altera_sdram_platdata),
.probe = altera_sdram_probe,
- .priv_auto_alloc_size = sizeof(struct altera_sdram_priv),
+ .priv_auto = sizeof(struct altera_sdram_priv),
};
.ops = &shape_ops,
.probe = dm_shape_probe,
.remove = dm_shape_remove,
- .priv_auto_alloc_size = sizeof(struct shape_data),
- .platdata_auto_alloc_size = sizeof(struct dm_demo_pdata),
+ .priv_auto = sizeof(struct shape_data),
+ .platdata_auto = sizeof(struct dm_demo_pdata),
};
.id = UCLASS_DEMO,
.ofdata_to_platdata = demo_shape_ofdata_to_platdata,
.ops = &simple_ops,
- .platdata_auto_alloc_size = sizeof(struct dm_demo_pdata),
+ .platdata_auto = sizeof(struct dm_demo_pdata),
};
.id = UCLASS_DMA,
.of_match = bcm6348_iudma_ids,
.ops = &bcm6348_iudma_ops,
- .priv_auto_alloc_size = sizeof(struct bcm6348_iudma_priv),
+ .priv_auto = sizeof(struct bcm6348_iudma_priv),
.probe = bcm6348_iudma_probe,
};
.id = UCLASS_DMA,
.name = "dma",
.flags = DM_UC_FLAG_SEQ_ALIAS,
- .per_device_auto_alloc_size = sizeof(struct dma_dev_priv),
+ .per_device_auto = sizeof(struct dma_dev_priv),
};
.of_match = sandbox_dma_ids,
.ops = &sandbox_dma_ops,
.probe = sandbox_dma_probe,
- .priv_auto_alloc_size = sizeof(struct sandbox_dma_dev),
+ .priv_auto = sizeof(struct sandbox_dma_dev),
};
.ops = &ti_edma3_ops,
.ofdata_to_platdata = ti_edma3_ofdata_to_platdata,
.probe = ti_edma3_probe,
- .priv_auto_alloc_size = sizeof(struct ti_edma3_priv),
+ .priv_auto = sizeof(struct ti_edma3_priv),
};
#endif /* CONFIG_DMA */
.of_match = udma_ids,
.ops = &udma_ops,
.probe = udma_probe,
- .priv_auto_alloc_size = sizeof(struct udma_dev),
+ .priv_auto = sizeof(struct udma_dev),
};
.name = "scmi-over-mailbox",
.id = UCLASS_SCMI_AGENT,
.of_match = scmi_mbox_ids,
- .priv_auto_alloc_size = sizeof(struct scmi_mbox_channel),
+ .priv_auto = sizeof(struct scmi_mbox_channel),
.probe = scmi_mbox_probe,
.ops = &scmi_mbox_ops,
};
.name = "sandbox-scmi_agent",
.id = UCLASS_SCMI_AGENT,
.of_match = sandbox_scmi_test_ids,
- .priv_auto_alloc_size = sizeof(struct sandbox_scmi_agent),
+ .priv_auto = sizeof(struct sandbox_scmi_agent),
.probe = sandbox_scmi_test_probe,
.remove = sandbox_scmi_test_remove,
.ops = &sandbox_scmi_test_ops,
.name = "sandbox-scmi_devices",
.id = UCLASS_MISC,
.of_match = sandbox_scmi_devices_ids,
- .priv_auto_alloc_size = sizeof(struct sandbox_scmi_device_priv),
+ .priv_auto = sizeof(struct sandbox_scmi_device_priv),
.remove = sandbox_scmi_devices_remove,
.probe = sandbox_scmi_devices_probe,
};
.name = "scmi-over-smccc",
.id = UCLASS_SCMI_AGENT,
.of_match = scmi_smccc_ids,
- .priv_auto_alloc_size = sizeof(struct scmi_smccc_channel),
+ .priv_auto = sizeof(struct scmi_smccc_channel),
.probe = scmi_smccc_probe,
.ops = &scmi_smccc_ops,
};
.id = UCLASS_FIRMWARE,
.of_match = ti_sci_ids,
.probe = ti_sci_probe,
- .priv_auto_alloc_size = sizeof(struct ti_sci_info),
+ .priv_auto = sizeof(struct ti_sci_info),
};
.id = UCLASS_GPIO,
.ops = &gen_74x164_ops,
.probe = gen_74x164_probe,
- .priv_auto_alloc_size = sizeof(struct gen_74x164_priv),
+ .priv_auto = sizeof(struct gen_74x164_priv),
.of_match = gen_74x164_ids,
};
.of_match = altera_pio_ids,
.ops = &altera_pio_ops,
.ofdata_to_platdata = altera_pio_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct altera_pio_platdata),
+ .platdata_auto = sizeof(struct altera_pio_platdata),
.probe = altera_pio_probe,
};
.id = UCLASS_GPIO,
#if CONFIG_IS_ENABLED(OF_CONTROL)
.of_match = at91_gpio_ids,
- .platdata_auto_alloc_size = sizeof(struct at91_port_platdata),
+ .platdata_auto = sizeof(struct at91_port_platdata),
#endif
.ops = &gpio_at91_ops,
.probe = at91_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct at91_port_priv),
+ .priv_auto = sizeof(struct at91_port_priv),
};
#endif
.probe = atmel_pio4_probe,
.bind = atmel_pio4_bind,
.of_match = atmel_pio4_ids,
- .platdata_auto_alloc_size = sizeof(struct atmel_pio4_platdata),
+ .platdata_auto = sizeof(struct atmel_pio4_platdata),
};
#endif
.name = "gpio_bcm2835",
.id = UCLASS_GPIO,
.ofdata_to_platdata = of_match_ptr(bcm2835_gpio_ofdata_to_platdata),
- .platdata_auto_alloc_size = sizeof(struct bcm2835_gpio_platdata),
+ .platdata_auto = sizeof(struct bcm2835_gpio_platdata),
.ops = &gpio_bcm2835_ops,
.probe = bcm2835_gpio_probe,
.flags = DM_FLAG_PRE_RELOC,
- .priv_auto_alloc_size = sizeof(struct bcm2835_gpios),
+ .priv_auto = sizeof(struct bcm2835_gpios),
};
.id = UCLASS_GPIO,
.of_match = bcm6345_gpio_ids,
.ops = &bcm6345_gpio_ops,
- .priv_auto_alloc_size = sizeof(struct bcm6345_gpio_priv),
+ .priv_auto = sizeof(struct bcm6345_gpio_priv),
.probe = bcm6345_gpio_probe,
};
.id = UCLASS_GPIO,
.ops = &gpio_cortina_ops,
.probe = ca_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct cortina_gpio_bank),
+ .priv_auto = sizeof(struct cortina_gpio_bank),
.of_match = ca_gpio_ids,
};
#endif /* CONFIG_DM_GPIO */
.ofdata_to_platdata = of_match_ptr(davinci_gpio_ofdata_to_platdata),
.of_match = davinci_gpio_ids,
.bind = dm_scan_fdt_dev,
- .platdata_auto_alloc_size = sizeof(struct davinci_gpio_platdata),
+ .platdata_auto = sizeof(struct davinci_gpio_platdata),
.probe = davinci_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct davinci_gpio_bank),
+ .priv_auto = sizeof(struct davinci_gpio_bank),
};
#endif
.bind = gpio_dwapb_bind,
.probe = gpio_dwapb_probe,
.remove = gpio_dwapb_remove,
- .priv_auto_alloc_size = sizeof(struct gpio_dwapb_priv),
+ .priv_auto = sizeof(struct gpio_dwapb_priv),
};
.id = UCLASS_GPIO,
.of_match = rcar_gpio_ids,
.ops = &rcar_gpio_ops,
- .priv_auto_alloc_size = sizeof(struct rcar_gpio_priv),
+ .priv_auto = sizeof(struct rcar_gpio_priv),
.probe = rcar_gpio_probe,
};
.name = "r7s72100-gpio",
.id = UCLASS_GPIO,
.ops = &r7s72100_gpio_ops,
- .priv_auto_alloc_size = sizeof(struct r7s72100_gpio_priv),
+ .priv_auto = sizeof(struct r7s72100_gpio_priv),
.probe = r7s72100_gpio_probe,
};
.id = UCLASS_NOP,
.ofdata_to_platdata = gpio_hog_ofdata_to_platdata,
.probe = gpio_hog_probe,
- .priv_auto_alloc_size = sizeof(struct gpio_hog_priv),
- .platdata_auto_alloc_size = sizeof(struct gpio_hog_data),
+ .priv_auto = sizeof(struct gpio_hog_priv),
+ .platdata_auto = sizeof(struct gpio_hog_data),
};
#else
int gpio_hog_lookup_name(const char *name, struct gpio_desc **desc)
.post_probe = gpio_post_probe,
.post_bind = gpio_post_bind,
.pre_remove = gpio_pre_remove,
- .per_device_auto_alloc_size = sizeof(struct gpio_dev_priv),
+ .per_device_auto = sizeof(struct gpio_dev_priv),
};
.id = UCLASS_GPIO,
.of_match = uniphier_gpio_match,
.probe = uniphier_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct uniphier_gpio_priv),
+ .priv_auto = sizeof(struct uniphier_gpio_priv),
.ops = &uniphier_gpio_ops,
};
.id = UCLASS_GPIO,
.ops = &gpio_hi6220_ops,
.probe = hi6220_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct gpio_bank),
+ .priv_auto = sizeof(struct gpio_bank),
};
.ops = &hsdk_creg_gpio_ops,
.probe = hsdk_creg_gpio_probe,
.of_match = hsdk_creg_gpio_ids,
- .platdata_auto_alloc_size = sizeof(struct hsdk_creg_gpio),
+ .platdata_auto = sizeof(struct hsdk_creg_gpio),
};
.id = UCLASS_GPIO,
.ops = &imx_rgpio2p_ops,
.probe = imx_rgpio2p_probe,
- .priv_auto_alloc_size = sizeof(struct imx_rgpio2p_plat),
+ .priv_auto = sizeof(struct imx_rgpio2p_plat),
.of_match = imx_rgpio2p_ids,
.bind = imx_rgpio2p_bind,
};
.ops = &gpio_broadwell_ops,
.ofdata_to_platdata = broadwell_gpio_ofdata_to_platdata,
.probe = broadwell_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct broadwell_bank_priv),
- .platdata_auto_alloc_size = sizeof(struct broadwell_bank_platdata),
+ .priv_auto = sizeof(struct broadwell_bank_priv),
+ .platdata_auto = sizeof(struct broadwell_bank_platdata),
};
.ops = &gpio_ich6_ops,
.ofdata_to_platdata = gpio_ich6_ofdata_to_platdata,
.probe = ich6_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct ich6_bank_priv),
- .platdata_auto_alloc_size = sizeof(struct ich6_bank_platdata),
+ .priv_auto = sizeof(struct ich6_bank_priv),
+ .platdata_auto = sizeof(struct ich6_bank_platdata),
};
.of_match = iproc_gpio_ids,
.ops = &iproc_gpio_ops,
.ofdata_to_platdata = iproc_gpio_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct iproc_gpio_platdata),
+ .platdata_auto = sizeof(struct iproc_gpio_platdata),
};
.id = UCLASS_GPIO,
.ops = &gpio_lpc32xx_ops,
.probe = lpc32xx_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct lpc32xx_gpio_priv),
+ .priv_auto = sizeof(struct lpc32xx_gpio_priv),
};
.ops = &mpc83xx_spisel_boot_ops,
#if CONFIG_IS_ENABLED(OF_CONTROL)
.ofdata_to_platdata = mpc83xx_spisel_boot_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct mpc8xxx_gpio_plat),
+ .platdata_auto = sizeof(struct mpc8xxx_gpio_plat),
.of_match = mpc83xx_spisel_boot_ids,
#endif
.probe = mpc83xx_spisel_boot_probe,
- .priv_auto_alloc_size = sizeof(struct mpc83xx_spisel_boot),
+ .priv_auto = sizeof(struct mpc83xx_spisel_boot),
};
.ops = &gpio_mpc8xxx_ops,
#if CONFIG_IS_ENABLED(OF_CONTROL)
.ofdata_to_platdata = mpc8xxx_gpio_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct mpc8xxx_gpio_plat),
+ .platdata_auto = sizeof(struct mpc8xxx_gpio_plat),
.of_match = mpc8xxx_gpio_ids,
#endif
.probe = mpc8xxx_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct mpc8xxx_gpio_data),
+ .priv_auto = sizeof(struct mpc8xxx_gpio_data),
};
.of_match = mscc_sgpio_ids,
.ops = &mscc_sgpio_ops,
.probe = mscc_sgpio_probe,
- .priv_auto_alloc_size = sizeof(struct mscc_sgpio_priv),
+ .priv_auto = sizeof(struct mscc_sgpio_priv),
};
.ofdata_to_platdata = msm_gpio_ofdata_to_platdata,
.probe = msm_gpio_probe,
.ops = &gpio_msm_ops,
- .priv_auto_alloc_size = sizeof(struct msm_gpio_bank),
+ .priv_auto = sizeof(struct msm_gpio_bank),
};
.of_match = mvebu_gpio_ids,
.ops = &mvebu_gpio_ops,
.probe = mvebu_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct mvebu_gpio_priv),
+ .priv_auto = sizeof(struct mvebu_gpio_priv),
};
.ops = &gpio_mxc_ops,
.probe = mxc_gpio_probe,
.ofdata_to_platdata = mxc_gpio_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct mxc_gpio_plat),
- .priv_auto_alloc_size = sizeof(struct mxc_bank_info),
+ .platdata_auto = sizeof(struct mxc_gpio_plat),
+ .priv_auto = sizeof(struct mxc_bank_info),
.of_match = mxc_gpio_ids,
.bind = mxc_gpio_bind,
};
.id = UCLASS_GPIO,
.ops = &gpio_mxs_ops,
.probe = mxs_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct mxs_gpio_priv),
- .platdata_auto_alloc_size = sizeof(struct mxs_gpio_platdata),
+ .priv_auto = sizeof(struct mxs_gpio_priv),
+ .platdata_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,
.of_match = nx_gpio_ids,
.ops = &nx_gpio_ops,
.ofdata_to_platdata = nx_gpio_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct nx_gpio_platdata),
+ .platdata_auto = sizeof(struct nx_gpio_platdata),
.probe = nx_gpio_probe,
};
.id = UCLASS_GPIO,
.of_match = of_match_ptr(octeon_gpio_ids),
.probe = octeon_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct octeon_gpio),
+ .priv_auto = sizeof(struct octeon_gpio),
.ops = &octeon_gpio_ops,
.flags = DM_FLAG_PRE_RELOC,
};
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
.of_match = omap_gpio_ids,
.ofdata_to_platdata = of_match_ptr(omap_gpio_ofdata_to_platdata),
- .platdata_auto_alloc_size = sizeof(struct omap_gpio_platdata),
+ .platdata_auto = sizeof(struct omap_gpio_platdata),
#endif
#else
.bind = omap_gpio_bind,
#endif
.ops = &gpio_omap_ops,
.probe = omap_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct gpio_bank),
+ .priv_auto = sizeof(struct gpio_bank),
#if !CONFIG_IS_ENABLED(OF_CONTROL)
.flags = DM_FLAG_PRE_RELOC,
#endif
.id = UCLASS_GPIO,
.ops = &pca953x_ops,
.probe = pca953x_probe,
- .platdata_auto_alloc_size = sizeof(struct pca953x_info),
+ .platdata_auto = sizeof(struct pca953x_info),
.of_match = pca953x_ids,
};
.of_match = pcf8575_gpio_ids,
.ofdata_to_platdata = pcf8575_ofdata_platdata,
.probe = pcf8575_gpio_probe,
- .platdata_auto_alloc_size = sizeof(struct pcf8575_chip),
+ .platdata_auto = sizeof(struct pcf8575_chip),
};
.of_match = pic32_gpio_ids,
.ops = &gpio_pic32_ops,
.probe = pic32_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct pic32_gpio_priv),
+ .priv_auto = sizeof(struct pic32_gpio_priv),
};
.ofdata_to_platdata = pm8916_gpio_ofdata_to_platdata,
.probe = pm8916_gpio_probe,
.ops = &pm8916_gpio_ops,
- .priv_auto_alloc_size = sizeof(struct pm8916_gpio_bank),
+ .priv_auto = sizeof(struct pm8916_gpio_bank),
};
.ofdata_to_platdata = pm8941_pwrkey_ofdata_to_platdata,
.probe = pm8941_pwrkey_probe,
.ops = &pm8941_pwrkey_ops,
- .priv_auto_alloc_size = sizeof(struct pm8916_gpio_bank),
+ .priv_auto = sizeof(struct pm8916_gpio_bank),
};
.id = UCLASS_GPIO,
.of_match = rockchip_gpio_ids,
.ops = &gpio_rockchip_ops,
- .priv_auto_alloc_size = sizeof(struct rockchip_gpio_priv),
+ .priv_auto = sizeof(struct rockchip_gpio_priv),
.probe = rockchip_gpio_probe,
};
.of_match = exynos_gpio_ids,
.bind = gpio_exynos_bind,
.probe = gpio_exynos_probe,
- .priv_auto_alloc_size = sizeof(struct exynos_bank_info),
+ .priv_auto = sizeof(struct exynos_bank_info),
.ops = &gpio_exynos_ops,
};
#endif
.ops = &sandbox_pinctrl_gpio_ops,
.bind = dm_scan_fdt_dev,
.probe = sandbox_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct sb_pinctrl_priv),
+ .priv_auto = sizeof(struct sb_pinctrl_priv),
ACPI_OPS_PTR(&pinctrl_sandbox_acpi_ops)
};
.id = UCLASS_GPIO,
.of_match = sifive_gpio_match,
.ofdata_to_platdata = of_match_ptr(sifive_gpio_ofdata_to_platdata),
- .platdata_auto_alloc_size = sizeof(struct sifive_gpio_platdata),
+ .platdata_auto = sizeof(struct sifive_gpio_platdata),
.ops = &sifive_gpio_ops,
.probe = sifive_gpio_probe,
};
.probe = gpio_stm32_probe,
.ops = &gpio_stm32_ops,
.flags = DM_UC_FLAG_SEQ_ALIAS,
- .priv_auto_alloc_size = sizeof(struct stm32_gpio_priv),
+ .priv_auto = sizeof(struct stm32_gpio_priv),
};
.of_match = tegra_gpio_ids,
.bind = gpio_tegra_bind,
.probe = gpio_tegra_probe,
- .priv_auto_alloc_size = sizeof(struct tegra_port_info),
+ .priv_auto = sizeof(struct tegra_port_info),
.ops = &gpio_tegra_ops,
};
.of_match = vybrid_gpio_ids,
.ofdata_to_platdata = vybrid_gpio_odata_to_platdata,
.probe = vybrid_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct vybrid_gpios),
- .platdata_auto_alloc_size = sizeof(struct vybrid_gpio_platdata),
+ .priv_auto = sizeof(struct vybrid_gpios),
+ .platdata_auto = sizeof(struct vybrid_gpio_platdata),
};
.of_match = xilinx_gpio_ids,
.ofdata_to_platdata = xilinx_gpio_ofdata_to_platdata,
.probe = xilinx_gpio_probe,
- .platdata_auto_alloc_size = sizeof(struct xilinx_gpio_platdata),
- .priv_auto_alloc_size = sizeof(struct xilinx_gpio_privdata),
+ .platdata_auto = sizeof(struct xilinx_gpio_platdata),
+ .priv_auto = sizeof(struct xilinx_gpio_privdata),
};
.of_match = zynq_gpio_ids,
.ofdata_to_platdata = zynq_gpio_ofdata_to_platdata,
.probe = zynq_gpio_probe,
- .platdata_auto_alloc_size = sizeof(struct zynq_gpio_platdata),
+ .platdata_auto = sizeof(struct zynq_gpio_platdata),
};
.of_match = stm32mp1_hwspinlock_ids,
.ops = &stm32mp1_hwspinlock_ops,
.probe = stm32mp1_hwspinlock_probe,
- .priv_auto_alloc_size = sizeof(struct stm32mp1_hws_priv),
+ .priv_auto = sizeof(struct stm32mp1_hws_priv),
};
.of_match = ast_i2c_ids,
.probe = ast_i2c_probe,
.ofdata_to_platdata = ast_i2c_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct ast_i2c_priv),
+ .priv_auto = sizeof(struct ast_i2c_priv),
.ops = &ast_i2c_ops,
};
.of_match = at91_i2c_ids,
.probe = at91_i2c_probe,
.ofdata_to_platdata = at91_i2c_ofdata_to_platdata,
- .per_child_auto_alloc_size = sizeof(struct dm_i2c_chip),
- .priv_auto_alloc_size = sizeof(struct at91_i2c_bus),
+ .per_child_auto = sizeof(struct dm_i2c_chip),
+ .priv_auto = sizeof(struct at91_i2c_bus),
.ops = &at91_i2c_ops,
};
.id = UCLASS_I2C,
.of_match = cros_ec_i2c_ids,
.ofdata_to_platdata = cros_ec_i2c_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct cros_ec_i2c_bus),
+ .priv_auto = sizeof(struct cros_ec_i2c_bus),
.ops = &cros_ec_i2c_ops,
};
.id = UCLASS_I2C,
.of_match = davinci_i2c_ids,
.probe = davinci_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct i2c_bus),
+ .priv_auto = sizeof(struct i2c_bus),
.ops = &davinci_i2c_ops,
};
.of_match = designware_i2c_ids,
.ofdata_to_platdata = designware_i2c_ofdata_to_platdata,
.probe = designware_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct dw_i2c),
+ .priv_auto = sizeof(struct dw_i2c),
.remove = designware_i2c_remove,
.flags = DM_FLAG_OS_PREPARE,
.ops = &designware_i2c_ops,
.bind = designware_i2c_pci_bind,
.ofdata_to_platdata = designware_i2c_pci_ofdata_to_platdata,
.probe = designware_i2c_pci_probe,
- .priv_auto_alloc_size = sizeof(struct dw_i2c),
+ .priv_auto = sizeof(struct dw_i2c),
.remove = designware_i2c_remove,
.flags = DM_FLAG_OS_PREPARE,
.ops = &designware_i2c_ops,
.id = UCLASS_I2C,
.of_match = exynos_hs_i2c_ids,
.ofdata_to_platdata = s3c_i2c_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct s3c24x0_i2c_bus),
+ .priv_auto = sizeof(struct s3c24x0_i2c_bus),
.ops = &exynos_hs_i2c_ops,
};
.of_match = fsl_i2c_ids,
.probe = fsl_i2c_probe,
.ofdata_to_platdata = fsl_i2c_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct fsl_i2c_dev),
+ .priv_auto = sizeof(struct fsl_i2c_dev),
.ops = &fsl_i2c_ops,
};
.id = UCLASS_I2C,
.of_match = cdns_i2c_of_match,
.ofdata_to_platdata = cdns_i2c_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct i2c_cdns_bus),
+ .priv_auto = sizeof(struct i2c_cdns_bus),
.ops = &cdns_i2c_ops,
};
.of_match = ca_i2c_ids,
.ofdata_to_platdata = ca_i2c_ofdata_to_platdata,
.probe = ca_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct ca_i2c),
+ .priv_auto = sizeof(struct ca_i2c),
.ops = &ca_i2c_ops,
.flags = DM_FLAG_PRE_RELOC,
};
UCLASS_DRIVER(i2c_emul) = {
.id = UCLASS_I2C_EMUL,
.name = "i2c_emul",
- .per_device_platdata_auto_alloc_size =
+ .per_device_platdata_auto =
sizeof(struct i2c_emul_uc_platdata),
};
/*
* This uclass is a child of the i2c bus. Its platdata is not defined here so
* is defined by its parent, UCLASS_I2C, which uses struct dm_i2c_chip. See
- * per_child_platdata_auto_alloc_size in UCLASS_DRIVER(i2c).
+ * per_child_platdata_auto in UCLASS_DRIVER(i2c).
*/
UCLASS_DRIVER(i2c_emul_parent) = {
.id = UCLASS_I2C_EMUL_PARENT,
.of_match = i2c_gpio_ids,
.probe = i2c_gpio_drv_probe,
.ofdata_to_platdata = i2c_gpio_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct i2c_gpio_bus),
+ .priv_auto = sizeof(struct i2c_gpio_bus),
.ops = &i2c_gpio_ops,
};
.flags = DM_UC_FLAG_SEQ_ALIAS,
.post_bind = i2c_post_bind,
.init = i2c_uclass_init,
- .priv_auto_alloc_size = sizeof(struct i2c_priv),
+ .priv_auto = sizeof(struct i2c_priv),
.pre_probe = i2c_pre_probe,
.post_probe = i2c_post_probe,
- .per_device_auto_alloc_size = sizeof(struct dm_i2c_bus),
- .per_child_platdata_auto_alloc_size = sizeof(struct dm_i2c_chip),
+ .per_device_auto = sizeof(struct dm_i2c_bus),
+ .per_child_platdata_auto = sizeof(struct dm_i2c_chip),
.child_post_bind = i2c_child_post_bind,
};
.of_match = generic_chip_i2c_ids,
#if CONFIG_IS_ENABLED(ACPIGEN)
.ofdata_to_platdata = acpi_i2c_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct acpi_i2c_priv),
+ .priv_auto = sizeof(struct acpi_i2c_priv),
#endif
ACPI_OPS_PTR(&acpi_i2c_ops)
};
.id = UCLASS_I2C,
.of_match = uniphier_fi2c_of_match,
.probe = uniphier_fi2c_probe,
- .priv_auto_alloc_size = sizeof(struct uniphier_fi2c_priv),
+ .priv_auto = sizeof(struct uniphier_fi2c_priv),
.ops = &uniphier_fi2c_ops,
};
.id = UCLASS_I2C,
.of_match = uniphier_i2c_of_match,
.probe = uniphier_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct uniphier_i2c_priv),
+ .priv_auto = sizeof(struct uniphier_i2c_priv),
.ops = &uniphier_i2c_ops,
};
.id = UCLASS_I2C,
.of_match = versatile_i2c_of_match,
.probe = versatile_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct versatile_i2c_priv),
+ .priv_auto = sizeof(struct versatile_i2c_priv),
.ops = &versatile_i2c_ops,
};
.id = UCLASS_I2C,
.of_match = ihs_i2c_ids,
.probe = ihs_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct ihs_i2c_priv),
+ .priv_auto = sizeof(struct ihs_i2c_priv),
.ops = &ihs_i2c_ops,
};
.id = UCLASS_I2C,
.of_match = imx_lpi2c_ids,
.probe = imx_lpi2c_probe,
- .priv_auto_alloc_size = sizeof(struct imx_lpi2c_bus),
+ .priv_auto = sizeof(struct imx_lpi2c_bus),
.ops = &imx_lpi2c_ops,
};
.id = UCLASS_I2C,
.of_match = intel_i2c_ids,
.ops = &intel_i2c_ops,
- .priv_auto_alloc_size = sizeof(struct intel_i2c),
+ .priv_auto = sizeof(struct intel_i2c),
.bind = intel_i2c_bind,
.probe = intel_i2c_probe,
};
.of_match = iproc_i2c_ids,
.ofdata_to_platdata = iproc_i2c_ofdata_to_platdata,
.probe = iproc_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct iproc_i2c),
+ .priv_auto = sizeof(struct iproc_i2c),
.ops = &iproc_i2c_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_I2C,
.of_match = meson_i2c_ids,
.probe = meson_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct meson_i2c),
+ .priv_auto = sizeof(struct meson_i2c),
.ops = &meson_i2c_ops,
};
.probe = i2c_arbitrator_probe,
.remove = i2c_arbitrator_remove,
.ops = &i2c_arbitrator_ops,
- .priv_auto_alloc_size = sizeof(struct i2c_arbitrator_priv),
+ .priv_auto = sizeof(struct i2c_arbitrator_priv),
};
.of_match = i2c_mux_gpio_ids,
.ops = &i2c_mux_gpio_ops,
.probe = i2c_mux_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct i2c_mux_gpio_priv),
+ .priv_auto = sizeof(struct i2c_mux_gpio_priv),
};
.name = "i2c_mux",
.post_bind = i2c_mux_post_bind,
.post_probe = i2c_mux_post_probe,
- .per_device_auto_alloc_size = sizeof(struct i2c_mux),
- .per_child_platdata_auto_alloc_size = sizeof(struct i2c_mux_bus),
+ .per_device_auto = sizeof(struct i2c_mux),
+ .per_child_platdata_auto = sizeof(struct i2c_mux_bus),
.child_post_bind = i2c_mux_child_post_bind,
};
.remove = pca954x_remove,
.ops = &pca954x_ops,
.ofdata_to_platdata = pca954x_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct pca954x_priv),
+ .priv_auto = sizeof(struct pca954x_priv),
};
.id = UCLASS_I2C,
.of_match = mv_i2c_ids,
.probe = mv_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct mv_i2c_priv),
+ .priv_auto = sizeof(struct mv_i2c_priv),
.ops = &mv_i2c_ops,
};
#endif /* CONFIG_DM_I2C */
.bind = mvtwsi_i2c_bind,
.probe = mvtwsi_i2c_probe,
.ofdata_to_platdata = mvtwsi_i2c_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct mvtwsi_i2c_dev),
+ .priv_auto = sizeof(struct mvtwsi_i2c_dev),
.ops = &mvtwsi_i2c_ops,
};
#endif /* CONFIG_DM_I2C */
.id = UCLASS_I2C,
.of_match = mxc_i2c_ids,
.probe = mxc_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct mxc_i2c_bus),
+ .priv_auto = sizeof(struct mxc_i2c_bus),
.ops = &mxc_i2c_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_I2C,
.of_match = nx_i2c_ids,
.probe = nx_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct nx_i2c_bus),
+ .priv_auto = sizeof(struct nx_i2c_bus),
.ops = &nx_i2c_ops,
};
.id = UCLASS_I2C,
.of_match = ocores_i2c_ids,
.probe = ocores_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct ocores_i2c_bus),
+ .priv_auto = sizeof(struct ocores_i2c_bus),
.ops = &ocores_i2c_ops,
};
.id = UCLASS_I2C,
.of_match = octeon_i2c_ids,
.probe = octeon_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct octeon_twsi),
+ .priv_auto = sizeof(struct octeon_twsi),
.ops = &octeon_i2c_ops,
};
#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_alloc_size = sizeof(struct omap_i2c_platdata),
+ .platdata_auto = sizeof(struct omap_i2c_platdata),
#endif
.probe = omap_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct omap_i2c),
+ .priv_auto = sizeof(struct omap_i2c),
.ops = &omap_i2c_ops,
#if !CONFIG_IS_ENABLED(OF_CONTROL)
.flags = DM_FLAG_PRE_RELOC,
.id = UCLASS_I2C,
.of_match = rcar_i2c_ids,
.probe = rcar_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct rcar_i2c_priv),
+ .priv_auto = sizeof(struct rcar_i2c_priv),
.ops = &rcar_i2c_ops,
};
.id = UCLASS_I2C,
.of_match = rcar_iic_ids,
.probe = rcar_iic_probe,
- .priv_auto_alloc_size = sizeof(struct rcar_iic_priv),
+ .priv_auto = sizeof(struct rcar_iic_priv),
.ops = &rcar_iic_ops,
};
.of_match = rockchip_i2c_ids,
.ofdata_to_platdata = rockchip_i2c_ofdata_to_platdata,
.probe = rockchip_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct rk_i2c),
+ .priv_auto = sizeof(struct rk_i2c),
.ops = &rockchip_i2c_ops,
};
.id = UCLASS_I2C,
.of_match = s3c_i2c_ids,
.ofdata_to_platdata = s3c_i2c_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct s3c24x0_i2c_bus),
+ .priv_auto = sizeof(struct s3c24x0_i2c_bus),
.ops = &s3c_i2c_ops,
};
.id = UCLASS_I2C,
.of_match = sandbox_i2c_ids,
.ops = &sandbox_i2c_ops,
- .priv_auto_alloc_size = sizeof(struct sandbox_i2c_priv),
+ .priv_auto = sizeof(struct sandbox_i2c_priv),
};
.of_match = stm32_i2c_of_match,
.ofdata_to_platdata = stm32_ofdata_to_platdata,
.probe = stm32_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct stm32_i2c_priv),
+ .priv_auto = sizeof(struct stm32_i2c_priv),
.ops = &stm32_i2c_ops,
};
.id = UCLASS_I2C,
.of_match = tegra186_bpmp_i2c_ids,
.probe = tegra186_bpmp_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct tegra186_bpmp_i2c),
+ .priv_auto = sizeof(struct tegra186_bpmp_i2c),
.ops = &tegra186_bpmp_i2c_ops,
};
.id = UCLASS_I2C,
.of_match = tegra_i2c_ids,
.probe = tegra_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct i2c_bus),
+ .priv_auto = sizeof(struct i2c_bus),
.ops = &tegra_i2c_ops,
};
.id = UCLASS_I2C,
.of_match = xilinx_xiic_ids,
.probe = xilinx_xiic_probe,
- .priv_auto_alloc_size = sizeof(struct xilinx_xiic_priv),
+ .priv_auto = sizeof(struct xilinx_xiic_priv),
.ops = &xilinx_xiic_ops,
};
.of_match = cros_ec_kbd_ids,
.probe = cros_ec_kbd_probe,
.ops = &cros_ec_kbd_ops,
- .priv_auto_alloc_size = sizeof(struct cros_ec_keyb_priv),
+ .priv_auto = sizeof(struct cros_ec_keyb_priv),
};
.probe = i8042_kbd_probe,
.remove = i8042_kbd_remove,
.ops = &i8042_kbd_ops,
- .priv_auto_alloc_size = sizeof(struct i8042_kbd_priv),
+ .priv_auto = sizeof(struct i8042_kbd_priv),
};
.id = UCLASS_KEYBOARD,
.name = "keyboard",
.pre_probe = keyboard_pre_probe,
- .per_device_auto_alloc_size = sizeof(struct keyboard_priv),
+ .per_device_auto = sizeof(struct keyboard_priv),
};
.of_match = tegra_kbd_ids,
.probe = tegra_kbd_probe,
.ops = &tegra_kbd_ops,
- .priv_auto_alloc_size = sizeof(struct tegra_kbd_priv),
+ .priv_auto = sizeof(struct tegra_kbd_priv),
};
UCLASS_DRIVER(led) = {
.id = UCLASS_LED,
.name = "led",
- .per_device_platdata_auto_alloc_size = sizeof(struct led_uc_plat),
+ .per_device_platdata_auto = sizeof(struct led_uc_plat),
};
.ops = &bcm6328_led_ops,
.bind = bcm6328_led_bind,
.probe = bcm6328_led_probe,
- .priv_auto_alloc_size = sizeof(struct bcm6328_led_priv),
+ .priv_auto = sizeof(struct bcm6328_led_priv),
};
.of_match = bcm6358_led_ids,
.bind = bcm6358_led_bind,
.probe = bcm6358_led_probe,
- .priv_auto_alloc_size = sizeof(struct bcm6358_led_priv),
+ .priv_auto = sizeof(struct bcm6358_led_priv),
.ops = &bcm6358_led_ops,
};
.of_match = bcm6858_led_ids,
.bind = bcm6858_led_bind,
.probe = bcm6858_led_probe,
- .priv_auto_alloc_size = sizeof(struct bcm6858_led_priv),
+ .priv_auto = sizeof(struct bcm6858_led_priv),
.ops = &bcm6858_led_ops,
};
.ofdata_to_platdata = ca_led_ofdata_to_platdata,
.bind = cortina_led_bind,
.probe = cortina_led_probe,
- .platdata_auto_alloc_size = sizeof(struct cortina_led_platdata),
- .priv_auto_alloc_size = sizeof(struct cortina_led_cfg),
+ .platdata_auto = sizeof(struct cortina_led_platdata),
+ .priv_auto = sizeof(struct cortina_led_cfg),
.ops = &cortina_led_ops,
};
.id = UCLASS_LED,
.of_match = led_gpio_ids,
.ops = &gpio_led_ops,
- .priv_auto_alloc_size = sizeof(struct led_gpio_priv),
+ .priv_auto = sizeof(struct led_gpio_priv),
.bind = led_gpio_bind,
.probe = led_gpio_probe,
.remove = led_gpio_remove,
.of_match = k3_sec_proxy_ids,
.probe = k3_sec_proxy_probe,
.remove = k3_sec_proxy_remove,
- .priv_auto_alloc_size = sizeof(struct k3_sec_proxy_mbox),
+ .priv_auto = sizeof(struct k3_sec_proxy_mbox),
.ops = &k3_sec_proxy_mbox_ops,
};
.name = "sandbox_mbox_test",
.id = UCLASS_MISC,
.of_match = sandbox_mbox_test_ids,
- .priv_auto_alloc_size = sizeof(struct sandbox_mbox_test),
+ .priv_auto = sizeof(struct sandbox_mbox_test),
};
.of_match = sandbox_mbox_ids,
.bind = sandbox_mbox_bind,
.probe = sandbox_mbox_probe,
- .priv_auto_alloc_size = sizeof(struct sandbox_mbox),
+ .priv_auto = sizeof(struct sandbox_mbox),
.ops = &sandbox_mbox_mbox_ops,
};
.id = UCLASS_MAILBOX,
.of_match = stm32_ipcc_ids,
.probe = stm32_ipcc_probe,
- .priv_auto_alloc_size = sizeof(struct stm32_ipcc),
+ .priv_auto = sizeof(struct stm32_ipcc),
.ops = &stm32_ipcc_mbox_ops,
};
.of_match = tegra_hsp_ids,
.bind = tegra_hsp_bind,
.probe = tegra_hsp_probe,
- .priv_auto_alloc_size = sizeof(struct tegra_hsp),
+ .priv_auto = sizeof(struct tegra_hsp),
.ops = &tegra_hsp_mbox_ops,
};
.id = UCLASS_MAILBOX,
.of_match = zynqmp_ipi_ids,
.probe = zynqmp_ipi_probe,
- .priv_auto_alloc_size = sizeof(struct zynqmp_ipi),
+ .priv_auto = sizeof(struct zynqmp_ipi),
.ops = &zynqmp_ipi_mbox_ops,
};
.id = UCLASS_NOP,
.of_match = stm32_fmc2_ebi_match,
.probe = stm32_fmc2_ebi_probe,
- .priv_auto_alloc_size = sizeof(struct stm32_fmc2_ebi),
+ .priv_auto = sizeof(struct stm32_fmc2_ebi),
.bind = dm_scan_fdt_dev,
};
.id = UCLASS_MISC,
.of_match = altera_sysid_ids,
.ofdata_to_platdata = altera_sysid_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct altera_sysid_platdata),
+ .platdata_auto = sizeof(struct altera_sysid_platdata),
.ops = &altera_sysid_ops,
};
.id = UCLASS_MISC,
.of_match = atsha204a_ids,
.ofdata_to_platdata = atsha204a_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(fdt_addr_t),
+ .priv_auto = sizeof(fdt_addr_t),
};
UCLASS_DRIVER(cros_ec) = {
.id = UCLASS_CROS_EC,
.name = "cros-ec",
- .per_device_auto_alloc_size = sizeof(struct cros_ec_dev),
+ .per_device_auto = sizeof(struct cros_ec_dev),
.post_bind = dm_scan_fdt_dev,
.flags = DM_UC_FLAG_ALLOC_PRIV_DMA,
};
.id = UCLASS_CROS_EC,
.of_match = cros_ec_ids,
.probe = cros_ec_probe,
- .priv_auto_alloc_size = sizeof(struct ec_state),
+ .priv_auto = sizeof(struct ec_state),
.ops = &cros_ec_ops,
};
.of_match = fs_loader_ids,
.probe = fs_loader_probe,
.ofdata_to_platdata = fs_loader_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct device_platdata),
- .priv_auto_alloc_size = sizeof(struct firmware),
+ .platdata_auto = sizeof(struct device_platdata),
+ .priv_auto = sizeof(struct firmware),
};
UCLASS_DRIVER(fs_loader) = {
.flags = DM_UC_FLAG_SEQ_ALIAS,
.of_match = gdsys_ioep_ids,
.probe = gdsys_ioep_probe,
- .priv_auto_alloc_size = sizeof(struct gdsys_ioep_priv),
+ .priv_auto = sizeof(struct gdsys_ioep_priv),
};
.ops = &gdsys_rxaui_ctrl_ops,
.of_match = gdsys_rxaui_ctrl_ids,
.probe = gdsys_rxaui_ctrl_probe,
- .priv_auto_alloc_size = sizeof(struct gdsys_rxaui_ctrl_priv),
+ .priv_auto = sizeof(struct gdsys_rxaui_ctrl_priv),
};
.id = UCLASS_SIMPLE_BUS,
.of_match = gdsys_soc_ids,
.probe = gdsys_soc_probe,
- .priv_auto_alloc_size = sizeof(struct gdsys_soc_priv),
+ .priv_auto = sizeof(struct gdsys_soc_priv),
};
.bind = i2c_eeprom_std_bind,
.probe = i2c_eeprom_std_probe,
.ofdata_to_platdata = i2c_eeprom_std_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct i2c_eeprom),
+ .priv_auto = sizeof(struct i2c_eeprom),
.ops = &i2c_eeprom_std_ops,
};
.id = UCLASS_I2C_EEPROM,
.probe = i2c_eeprom_partition_probe,
.ofdata_to_platdata = i2c_eeprom_partition_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct i2c_eeprom_partition),
+ .priv_auto = sizeof(struct i2c_eeprom_partition),
.ops = &i2c_eeprom_partition_ops,
};
.ofdata_to_platdata = sandbox_i2c_eeprom_ofdata_to_platdata,
.probe = sandbox_i2c_eeprom_probe,
.remove = sandbox_i2c_eeprom_remove,
- .priv_auto_alloc_size = sizeof(struct sandbox_i2c_flash),
- .platdata_auto_alloc_size = sizeof(struct sandbox_i2c_flash_plat_data),
+ .priv_auto = sizeof(struct sandbox_i2c_flash),
+ .platdata_auto = sizeof(struct sandbox_i2c_flash_plat_data),
.ops = &sandbox_i2c_emul_ops,
};
.id = UCLASS_MISC,
.of_match = ihs_fpga_ids,
.probe = ihs_fpga_probe,
- .priv_auto_alloc_size = sizeof(struct ihs_fpga_priv),
+ .priv_auto = sizeof(struct ihs_fpga_priv),
};
.bind = imx8_scu_bind,
.remove = imx8_scu_remove,
.ops = &imx8_scu_ops,
- .platdata_auto_alloc_size = sizeof(struct imx8_scu),
+ .platdata_auto = sizeof(struct imx8_scu),
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_IRQ,
.of_match = sandbox_irq_ids,
.ops = &sandbox_irq_ops,
- .priv_auto_alloc_size = sizeof(struct sandbox_irq_priv),
+ .priv_auto = sizeof(struct sandbox_irq_priv),
};
.of_match = k3_avs_ids,
.id = UCLASS_MISC,
.probe = k3_avs_probe,
- .priv_auto_alloc_size = sizeof(struct k3_avs_privdata),
+ .priv_auto = sizeof(struct k3_avs_privdata),
};
.id = UCLASS_MISC,
.of_match = microchip_flexcom_ids,
.ofdata_to_platdata = microchip_flexcom_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct microchip_flexcom_platdata),
+ .platdata_auto = sizeof(struct microchip_flexcom_platdata),
};
.ops = &misc_sandbox_ops,
.of_match = misc_sandbox_ids,
.probe = misc_sandbox_probe,
- .priv_auto_alloc_size = sizeof(struct misc_sandbox_priv),
+ .priv_auto = sizeof(struct misc_sandbox_priv),
};
.id = UCLASS_MISC,
.of_match = mpc83xx_serdes_ids,
.probe = mpc83xx_serdes_probe,
- .priv_auto_alloc_size = sizeof(struct mpc83xx_serdes_priv),
+ .priv_auto = sizeof(struct mpc83xx_serdes_priv),
};
UCLASS_DRIVER(p2sb) = {
.id = UCLASS_P2SB,
.name = "p2sb",
- .per_device_auto_alloc_size = sizeof(struct p2sb_uc_priv),
+ .per_device_auto = sizeof(struct p2sb_uc_priv),
.post_bind = p2sb_post_bind,
.child_post_bind = p2sb_child_post_bind,
- .per_child_platdata_auto_alloc_size =
+ .per_child_platdata_auto =
sizeof(struct p2sb_child_platdata),
};
.id = UCLASS_PCI_EMUL,
.of_match = sandbox_p2sb_emul_ids,
.ops = &sandbox_p2sb_emul_emul_ops,
- .priv_auto_alloc_size = sizeof(struct p2sb_emul_priv),
- .platdata_auto_alloc_size = sizeof(struct p2sb_emul_platdata),
+ .priv_auto = sizeof(struct p2sb_emul_priv),
+ .platdata_auto = sizeof(struct p2sb_emul_platdata),
};
static struct pci_device_id sandbox_p2sb_emul_supported[] = {
.id = UCLASS_P2SB,
.of_match = sandbox_p2sb_ids,
.probe = sandbox_p2sb_probe,
- .priv_auto_alloc_size = sizeof(struct sandbox_p2sb_priv),
+ .priv_auto = sizeof(struct sandbox_p2sb_priv),
};
.id = UCLASS_MISC,
.of_match = rockchip_efuse_ids,
.ofdata_to_platdata = rockchip_efuse_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct rockchip_efuse_platdata),
+ .platdata_auto = sizeof(struct rockchip_efuse_platdata),
.ops = &rockchip_efuse_ops,
};
.of_match = rockchip_otp_ids,
.ops = &rockchip_otp_ops,
.ofdata_to_platdata = rockchip_otp_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct rockchip_otp_platdata),
+ .platdata_auto = sizeof(struct rockchip_otp_platdata),
};
.of_match = sandbox_adder_ids,
.probe = sandbox_adder_probe,
.ops = &sandbox_adder_ops,
- .priv_auto_alloc_size = sizeof(struct sandbox_adder_priv),
+ .priv_auto = sizeof(struct sandbox_adder_priv),
};
.id = UCLASS_MISC,
.of_match = sifive_otp_ids,
.ofdata_to_platdata = sifive_otp_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct sifive_otp_platdata),
+ .platdata_auto = sizeof(struct sifive_otp_platdata),
.ops = &sifive_otp_ops,
};
.id = UCLASS_PCI_EMUL,
.of_match = sandbox_swap_case_ids,
.ops = &sandbox_swap_case_emul_ops,
- .priv_auto_alloc_size = sizeof(struct swap_case_priv),
- .platdata_auto_alloc_size = sizeof(struct swap_case_platdata),
+ .priv_auto = sizeof(struct swap_case_priv),
+ .platdata_auto = sizeof(struct swap_case_platdata),
};
static struct pci_device_id sandbox_swap_case_supported[] = {
.probe = tegra186_bpmp_probe,
.remove = tegra186_bpmp_remove,
.ops = &tegra186_bpmp_ops,
- .priv_auto_alloc_size = sizeof(struct tegra186_bpmp),
+ .priv_auto = sizeof(struct tegra186_bpmp),
};
.ops = &sdhci_ops,
.bind = am654_sdhci_bind,
.probe = am654_sdhci_probe,
- .priv_auto_alloc_size = sizeof(struct sdhci_host),
- .platdata_auto_alloc_size = sizeof(struct am654_sdhci_plat),
+ .priv_auto = sizeof(struct sdhci_host),
+ .platdata_auto = sizeof(struct am654_sdhci_plat),
};
.probe = arm_pl180_mmc_probe,
.ofdata_to_platdata = arm_pl180_mmc_ofdata_to_platdata,
.bind = arm_pl180_mmc_bind,
- .priv_auto_alloc_size = sizeof(struct pl180_mmc_host),
- .platdata_auto_alloc_size = sizeof(struct arm_pl180_mmc_plat),
+ .priv_auto = sizeof(struct pl180_mmc_host),
+ .platdata_auto = sizeof(struct arm_pl180_mmc_plat),
};
#endif
.ops = &sdhci_ops,
.bind = aspeed_sdhci_bind,
.probe = aspeed_sdhci_probe,
- .priv_auto_alloc_size = sizeof(struct sdhci_host),
- .platdata_auto_alloc_size = sizeof(struct aspeed_sdhci_plat),
+ .priv_auto = sizeof(struct sdhci_host),
+ .platdata_auto = sizeof(struct aspeed_sdhci_plat),
};
.ops = &sdhci_ops,
.bind = atmel_sdhci_bind,
.probe = atmel_sdhci_probe,
- .priv_auto_alloc_size = sizeof(struct sdhci_host),
- .platdata_auto_alloc_size = sizeof(struct atmel_sdhci_plat),
+ .priv_auto = sizeof(struct sdhci_host),
+ .platdata_auto = sizeof(struct atmel_sdhci_plat),
};
#endif
.of_match = bcm2835_sdhci_match,
.bind = bcm2835_sdhci_bind,
.probe = bcm2835_sdhci_probe,
- .priv_auto_alloc_size = sizeof(struct bcm2835_sdhci_host),
- .platdata_auto_alloc_size = sizeof(struct bcm2835_sdhci_plat),
+ .priv_auto = sizeof(struct bcm2835_sdhci_host),
+ .platdata_auto = sizeof(struct bcm2835_sdhci_plat),
.ops = &sdhci_ops,
};
.of_match = bcm2835_match,
.bind = bcm2835_bind,
.probe = bcm2835_probe,
- .priv_auto_alloc_size = sizeof(struct bcm2835_host),
- .platdata_auto_alloc_size = sizeof(struct bcm2835_plat),
+ .priv_auto = sizeof(struct bcm2835_host),
+ .platdata_auto = sizeof(struct bcm2835_plat),
.ops = &bcm2835_ops,
};
.ops = &sdhci_ops,
.bind = sdhci_bcmstb_bind,
.probe = sdhci_bcmstb_probe,
- .priv_auto_alloc_size = sizeof(struct sdhci_host),
- .platdata_auto_alloc_size = sizeof(struct sdhci_bcmstb_plat),
+ .priv_auto = sizeof(struct sdhci_host),
+ .platdata_auto = sizeof(struct sdhci_bcmstb_plat),
};
.bind = ca_dwmmc_bind,
.ops = &ca_dwmci_dm_ops,
.probe = ca_dwmmc_probe,
- .priv_auto_alloc_size = sizeof(struct ca_dwmmc_priv_data),
- .platdata_auto_alloc_size = sizeof(struct ca_mmc_plat),
+ .priv_auto = sizeof(struct ca_dwmmc_priv_data),
+ .platdata_auto = sizeof(struct ca_mmc_plat),
};
.id = UCLASS_MMC,
#if CONFIG_IS_ENABLED(OF_CONTROL)
.of_match = davinci_mmc_ids,
- .platdata_auto_alloc_size = sizeof(struct davinci_mmc_plat),
+ .platdata_auto = sizeof(struct davinci_mmc_plat),
.ofdata_to_platdata = davinci_mmc_ofdata_to_platdata,
#endif
#if CONFIG_BLK
#endif
.probe = davinci_mmc_probe,
.ops = &davinci_mmc_ops,
- .priv_auto_alloc_size = sizeof(struct davinci_mmc_priv),
+ .priv_auto = sizeof(struct davinci_mmc_priv),
#if !CONFIG_IS_ENABLED(OF_CONTROL)
.flags = DM_FLAG_PRE_RELOC,
#endif
.bind = exynos_dwmmc_bind,
.ops = &dm_dwmci_ops,
.probe = exynos_dwmmc_probe,
- .priv_auto_alloc_size = sizeof(struct dwmci_exynos_priv_data),
- .platdata_auto_alloc_size = sizeof(struct exynos_mmc_plat),
+ .priv_auto = sizeof(struct dwmci_exynos_priv_data),
+ .platdata_auto = sizeof(struct exynos_mmc_plat),
};
#endif
.ops = &fsl_esdhc_ops,
.bind = fsl_esdhc_bind,
.probe = fsl_esdhc_probe,
- .platdata_auto_alloc_size = sizeof(struct fsl_esdhc_plat),
- .priv_auto_alloc_size = sizeof(struct fsl_esdhc_priv),
+ .platdata_auto = sizeof(struct fsl_esdhc_plat),
+ .priv_auto = sizeof(struct fsl_esdhc_priv),
};
#endif
.bind = fsl_esdhc_bind,
#endif
.probe = fsl_esdhc_probe,
- .platdata_auto_alloc_size = sizeof(struct fsl_esdhc_plat),
- .priv_auto_alloc_size = sizeof(struct fsl_esdhc_priv),
+ .platdata_auto = sizeof(struct fsl_esdhc_plat),
+ .priv_auto = sizeof(struct fsl_esdhc_priv),
};
U_BOOT_DRIVER_ALIAS(fsl_esdhc, fsl_imx6q_usdhc)
.ops = &dm_ftsdc010_mmc_ops,
.bind = ftsdc010_mmc_bind,
.probe = ftsdc010_mmc_probe,
- .priv_auto_alloc_size = sizeof(struct ftsdc_priv),
- .platdata_auto_alloc_size = sizeof(struct ftsdc010_plat),
+ .priv_auto = sizeof(struct ftsdc_priv),
+ .platdata_auto = sizeof(struct ftsdc010_plat),
};
.of_match = atmel_mci_ids,
.bind = atmel_mci_bind,
.probe = atmel_mci_probe,
- .platdata_auto_alloc_size = sizeof(struct atmel_mci_plat),
- .priv_auto_alloc_size = sizeof(struct atmel_mci_priv),
+ .platdata_auto = sizeof(struct atmel_mci_plat),
+ .priv_auto = sizeof(struct atmel_mci_priv),
.ops = &atmel_mci_mmc_ops,
};
#endif
.ops = &dm_dwmci_ops,
.bind = hi6220_dwmmc_bind,
.probe = hi6220_dwmmc_probe,
- .priv_auto_alloc_size = sizeof(struct hi6220_dwmmc_priv_data),
- .platdata_auto_alloc_size = sizeof(struct hi6220_dwmmc_plat),
+ .priv_auto = sizeof(struct hi6220_dwmmc_priv_data),
+ .platdata_auto = sizeof(struct hi6220_dwmmc_plat),
};
.ops = &sdhci_ops,
.bind = iproc_sdhci_bind,
.probe = iproc_sdhci_probe,
- .priv_auto_alloc_size = sizeof(struct sdhci_host),
- .platdata_auto_alloc_size = sizeof(struct iproc_sdhci_plat),
+ .priv_auto = sizeof(struct sdhci_host),
+ .platdata_auto = sizeof(struct iproc_sdhci_plat),
};
.ofdata_to_platdata = jz_mmc_ofdata_to_platdata,
.bind = jz_mmc_bind,
.probe = jz_mmc_probe,
- .priv_auto_alloc_size = sizeof(struct jz_mmc_priv),
- .platdata_auto_alloc_size = sizeof(struct jz_mmc_plat),
+ .priv_auto = sizeof(struct jz_mmc_priv),
+ .platdata_auto = sizeof(struct jz_mmc_plat),
.ops = &jz_msc_ops,
};
#endif /* CONFIG_DM_MMC */
.probe = meson_mmc_probe,
.bind = meson_mmc_bind,
.ofdata_to_platdata = meson_mmc_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct meson_mmc_platdata),
+ .platdata_auto = sizeof(struct meson_mmc_platdata),
};
#ifdef CONFIG_PWRSEQ
.id = UCLASS_MMC,
.name = "mmc",
.flags = DM_UC_FLAG_SEQ_ALIAS,
- .per_device_auto_alloc_size = sizeof(struct mmc_uclass_priv),
+ .per_device_auto = sizeof(struct mmc_uclass_priv),
};
.ops = &mmc_spi_ops,
.probe = mmc_spi_probe,
.bind = mmc_spi_bind,
- .platdata_auto_alloc_size = sizeof(struct mmc_spi_plat),
- .priv_auto_alloc_size = sizeof(struct mmc_spi_priv),
+ .platdata_auto = sizeof(struct mmc_spi_plat),
+ .priv_auto = sizeof(struct mmc_spi_priv),
};
.bind = msm_sdc_bind,
.probe = msm_sdc_probe,
.remove = msm_sdc_remove,
- .priv_auto_alloc_size = sizeof(struct msm_sdhc),
- .platdata_auto_alloc_size = sizeof(struct msm_sdhc_plat),
+ .priv_auto = sizeof(struct msm_sdhc),
+ .platdata_auto = sizeof(struct msm_sdhc_plat),
};
.bind = msdc_drv_bind,
.probe = msdc_drv_probe,
.ops = &msdc_ops,
- .platdata_auto_alloc_size = sizeof(struct msdc_plat),
- .priv_auto_alloc_size = sizeof(struct msdc_host),
+ .platdata_auto = sizeof(struct msdc_plat),
+ .priv_auto = sizeof(struct msdc_host),
};
.bind = mv_sdhci_bind,
.probe = mv_sdhci_probe,
.ops = &sdhci_ops,
- .priv_auto_alloc_size = sizeof(struct sdhci_host),
- .platdata_auto_alloc_size = sizeof(struct mv_sdhci_plat),
+ .priv_auto = sizeof(struct sdhci_host),
+ .platdata_auto = sizeof(struct mv_sdhci_plat),
};
#endif /* CONFIG_DM_MMC */
.bind = mxsmmc_bind,
#endif
.probe = mxsmmc_probe,
- .priv_auto_alloc_size = sizeof(struct mxsmmc_priv),
- .platdata_auto_alloc_size = sizeof(struct mxsmmc_platdata),
+ .priv_auto = sizeof(struct mxsmmc_priv),
+ .platdata_auto = sizeof(struct mxsmmc_platdata),
};
U_BOOT_DRIVER_ALIAS(fsl_imx23_mmc, fsl_imx28_mmc)
.ops = &dm_dwmci_ops,
.bind = nexell_dwmmc_bind,
.probe = nexell_dwmmc_probe,
- .priv_auto_alloc_size = sizeof(struct nexell_dwmmc_priv),
- .platdata_auto_alloc_size = sizeof(struct nexell_mmc_plat),
+ .priv_auto = sizeof(struct nexell_dwmmc_priv),
+ .platdata_auto = sizeof(struct nexell_mmc_plat),
};
.id = UCLASS_MISC,
.of_match = of_match_ptr(octeontx_hsmmc_host_ids),
.probe = octeontx_mmc_host_probe,
- .priv_auto_alloc_size = sizeof(struct octeontx_mmc_host),
+ .priv_auto = sizeof(struct octeontx_mmc_host),
.child_pre_probe = octeontx_mmc_host_child_pre_probe,
.flags = DM_FLAG_PRE_RELOC,
};
#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
.of_match = omap_hsmmc_ids,
.ofdata_to_platdata = omap_hsmmc_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct omap_hsmmc_plat),
+ .platdata_auto = sizeof(struct omap_hsmmc_plat),
#endif
#ifdef CONFIG_BLK
.bind = omap_hsmmc_bind,
#endif
.ops = &omap_hsmmc_ops,
.probe = omap_hsmmc_probe,
- .priv_auto_alloc_size = sizeof(struct omap_hsmmc_data),
+ .priv_auto = sizeof(struct omap_hsmmc_data),
#if !CONFIG_IS_ENABLED(OF_CONTROL)
.flags = DM_FLAG_PRE_RELOC,
#endif
.ofdata_to_platdata = pci_mmc_ofdata_to_platdata,
.probe = pci_mmc_probe,
.ops = &sdhci_ops,
- .priv_auto_alloc_size = sizeof(struct pci_mmc_priv),
- .platdata_auto_alloc_size = sizeof(struct pci_mmc_plat),
+ .priv_auto = sizeof(struct pci_mmc_priv),
+ .platdata_auto = sizeof(struct pci_mmc_plat),
ACPI_OPS_PTR(&pci_mmc_acpi_ops)
};
.ops = &sdhci_ops,
.bind = pic32_sdhci_bind,
.probe = pic32_sdhci_probe,
- .priv_auto_alloc_size = sizeof(struct sdhci_host),
- .platdata_auto_alloc_size = sizeof(struct pic32_sdhci_plat)
+ .priv_auto = sizeof(struct sdhci_host),
+ .platdata_auto = sizeof(struct pic32_sdhci_plat)
};
.id = UCLASS_MMC,
.name = "pxa_mmc",
.ops = &pxa_mmc_ops,
- .priv_auto_alloc_size = sizeof(struct pxa_mmc_priv),
+ .priv_auto = sizeof(struct pxa_mmc_priv),
.probe = pxa_mmc_probe,
};
#endif /* !CONFIG_IS_ENABLED(DM_MMC) */
.of_match = renesas_sdhi_match,
.bind = tmio_sd_bind,
.probe = renesas_sdhi_probe,
- .priv_auto_alloc_size = sizeof(struct tmio_sd_priv),
- .platdata_auto_alloc_size = sizeof(struct tmio_sd_plat),
+ .priv_auto = sizeof(struct tmio_sd_priv),
+ .platdata_auto = sizeof(struct tmio_sd_plat),
.ops = &renesas_sdhi_ops,
};
.ops = &dm_dwmci_ops,
.bind = rockchip_dwmmc_bind,
.probe = rockchip_dwmmc_probe,
- .priv_auto_alloc_size = sizeof(struct rockchip_dwmmc_priv),
- .platdata_auto_alloc_size = sizeof(struct rockchip_mmc_plat),
+ .priv_auto = sizeof(struct rockchip_dwmmc_priv),
+ .platdata_auto = sizeof(struct rockchip_mmc_plat),
};
U_BOOT_DRIVER_ALIAS(rockchip_rk3288_dw_mshc, rockchip_rk3328_dw_mshc)
.ops = &sdhci_ops,
.bind = rockchip_sdhci_bind,
.probe = arasan_sdhci_probe,
- .priv_auto_alloc_size = sizeof(struct rockchip_sdhc),
- .platdata_auto_alloc_size = sizeof(struct rockchip_sdhc_plat),
+ .priv_auto = sizeof(struct rockchip_sdhc),
+ .platdata_auto = sizeof(struct rockchip_sdhc_plat),
};
.bind = s5p_sdhci_bind,
.ops = &sdhci_ops,
.probe = s5p_sdhci_probe,
- .priv_auto_alloc_size = sizeof(struct sdhci_host),
- .platdata_auto_alloc_size = sizeof(struct s5p_sdhci_plat),
+ .priv_auto = sizeof(struct sdhci_host),
+ .platdata_auto = sizeof(struct s5p_sdhci_plat),
};
#endif /* CONFIG_DM_MMC */
.bind = sandbox_mmc_bind,
.unbind = sandbox_mmc_unbind,
.probe = sandbox_mmc_probe,
- .platdata_auto_alloc_size = sizeof(struct sandbox_mmc_plat),
+ .platdata_auto = sizeof(struct sandbox_mmc_plat),
};
.of_match = sdhci_cdns_match,
.bind = sdhci_cdns_bind,
.probe = sdhci_cdns_probe,
- .priv_auto_alloc_size = sizeof(struct sdhci_host),
- .platdata_auto_alloc_size = sizeof(struct sdhci_cdns_plat),
+ .priv_auto = sizeof(struct sdhci_host),
+ .platdata_auto = sizeof(struct sdhci_cdns_plat),
.ops = &sdhci_cdns_mmc_ops,
};
.of_match = sh_mmcif_sd_match,
.bind = sh_mmcif_dm_bind,
.probe = sh_mmcif_dm_probe,
- .priv_auto_alloc_size = sizeof(struct sh_mmcif_host),
- .platdata_auto_alloc_size = sizeof(struct sh_mmcif_plat),
+ .priv_auto = sizeof(struct sh_mmcif_host),
+ .platdata_auto = sizeof(struct sh_mmcif_plat),
.ops = &sh_mmcif_dm_ops,
};
#endif
.of_match = sh_sdhi_sd_match,
.bind = sh_sdhi_dm_bind,
.probe = sh_sdhi_dm_probe,
- .priv_auto_alloc_size = sizeof(struct sh_sdhi_host),
- .platdata_auto_alloc_size = sizeof(struct sh_sdhi_plat),
+ .priv_auto = sizeof(struct sh_sdhi_host),
+ .platdata_auto = sizeof(struct sh_sdhi_plat),
.ops = &sh_sdhi_dm_ops,
};
#endif
.ops = &snps_dwmci_dm_ops,
.bind = snps_dwmmc_bind,
.probe = snps_dwmmc_probe,
- .priv_auto_alloc_size = sizeof(struct snps_dwmci_priv_data),
- .platdata_auto_alloc_size = sizeof(struct snps_dwmci_plat),
+ .priv_auto = sizeof(struct snps_dwmci_priv_data),
+ .platdata_auto = sizeof(struct snps_dwmci_plat),
};
.ops = &dm_dwmci_ops,
.bind = socfpga_dwmmc_bind,
.probe = socfpga_dwmmc_probe,
- .priv_auto_alloc_size = sizeof(struct dwmci_socfpga_priv_data),
- .platdata_auto_alloc_size = sizeof(struct socfpga_dwmci_plat),
+ .priv_auto = sizeof(struct dwmci_socfpga_priv_data),
+ .platdata_auto = sizeof(struct socfpga_dwmci_plat),
};
.ops = &sdhci_ops,
.ofdata_to_platdata = sti_sdhci_ofdata_to_platdata,
.probe = sti_sdhci_probe,
- .priv_auto_alloc_size = sizeof(struct sdhci_host),
- .platdata_auto_alloc_size = sizeof(struct sti_sdhci_plat),
+ .priv_auto = sizeof(struct sdhci_host),
+ .platdata_auto = sizeof(struct sti_sdhci_plat),
};
.ops = &stm32_sdmmc2_ops,
.probe = stm32_sdmmc2_probe,
.bind = stm32_sdmmc_bind,
- .priv_auto_alloc_size = sizeof(struct stm32_sdmmc2_priv),
- .platdata_auto_alloc_size = sizeof(struct stm32_sdmmc2_plat),
+ .priv_auto = sizeof(struct stm32_sdmmc2_priv),
+ .platdata_auto = sizeof(struct stm32_sdmmc2_plat),
};
.bind = sunxi_mmc_bind,
.probe = sunxi_mmc_probe,
.ops = &sunxi_mmc_ops,
- .platdata_auto_alloc_size = sizeof(struct sunxi_mmc_plat),
- .priv_auto_alloc_size = sizeof(struct sunxi_mmc_priv),
+ .platdata_auto = sizeof(struct sunxi_mmc_plat),
+ .priv_auto = sizeof(struct sunxi_mmc_priv),
};
#endif
.bind = sdhci_tangier_bind,
.probe = sdhci_tangier_probe,
.ops = &sdhci_ops,
- .priv_auto_alloc_size = sizeof(struct sdhci_host),
- .platdata_auto_alloc_size = sizeof(struct sdhci_tangier_plat),
+ .priv_auto = sizeof(struct sdhci_host),
+ .platdata_auto = sizeof(struct sdhci_tangier_plat),
};
.bind = tegra_mmc_bind,
.probe = tegra_mmc_probe,
.ops = &tegra_mmc_ops,
- .platdata_auto_alloc_size = sizeof(struct tegra_mmc_plat),
- .priv_auto_alloc_size = sizeof(struct tegra_mmc_priv),
+ .platdata_auto = sizeof(struct tegra_mmc_plat),
+ .priv_auto = sizeof(struct tegra_mmc_priv),
};
.of_match = uniphier_sd_match,
.bind = tmio_sd_bind,
.probe = uniphier_sd_probe,
- .priv_auto_alloc_size = sizeof(struct tmio_sd_priv),
- .platdata_auto_alloc_size = sizeof(struct tmio_sd_plat),
+ .priv_auto = sizeof(struct tmio_sd_priv),
+ .platdata_auto = sizeof(struct tmio_sd_plat),
.ops = &uniphier_sd_ops,
};
.ops = &sdhci_ops,
.bind = xenon_sdhci_bind,
.probe = xenon_sdhci_probe,
- .priv_auto_alloc_size = sizeof(struct xenon_sdhci_priv),
- .platdata_auto_alloc_size = sizeof(struct xenon_sdhci_plat),
+ .priv_auto = sizeof(struct xenon_sdhci_priv),
+ .platdata_auto = sizeof(struct xenon_sdhci_plat),
};
.ops = &sdhci_ops,
.bind = arasan_sdhci_bind,
.probe = arasan_sdhci_probe,
- .priv_auto_alloc_size = sizeof(struct arasan_sdhci_priv),
- .platdata_auto_alloc_size = sizeof(struct arasan_sdhci_plat),
+ .priv_auto = sizeof(struct arasan_sdhci_priv),
+ .platdata_auto = sizeof(struct arasan_sdhci_plat),
};
.id = UCLASS_MTD,
.of_match = altera_qspi_ids,
.ofdata_to_platdata = altera_qspi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct altera_qspi_platdata),
+ .platdata_auto = sizeof(struct altera_qspi_platdata),
.probe = altera_qspi_probe,
};
.of_match = am654_hbmc_dt_ids,
.probe = am654_hbmc_probe,
.bind = am654_hbmc_bind,
- .priv_auto_alloc_size = sizeof(struct am654_hbmc_priv),
+ .priv_auto = sizeof(struct am654_hbmc_priv),
};
UCLASS_DRIVER(mtd) = {
.id = UCLASS_MTD,
.name = "mtd",
- .per_device_auto_alloc_size = sizeof(struct mtd_info),
+ .per_device_auto = sizeof(struct mtd_info),
};
.id = UCLASS_MTD,
.of_match = arasan_nand_dt_ids,
.probe = arasan_probe,
- .priv_auto_alloc_size = sizeof(struct arasan_nand_info),
+ .priv_auto = sizeof(struct arasan_nand_info),
};
void board_nand_init(void)
.id = UCLASS_MTD,
.of_match = bcm63158_nand_dt_ids,
.probe = bcm63158_nand_probe,
- .priv_auto_alloc_size = sizeof(struct bcm63158_nand_soc),
+ .priv_auto = sizeof(struct bcm63158_nand_soc),
};
void board_nand_init(void)
.id = UCLASS_MTD,
.of_match = bcm6368_nand_dt_ids,
.probe = bcm6368_nand_probe,
- .priv_auto_alloc_size = sizeof(struct bcm6368_nand_soc),
+ .priv_auto = sizeof(struct bcm6368_nand_soc),
};
void board_nand_init(void)
.id = UCLASS_MTD,
.of_match = bcm68360_nand_dt_ids,
.probe = bcm68360_nand_probe,
- .priv_auto_alloc_size = sizeof(struct bcm68360_nand_soc),
+ .priv_auto = sizeof(struct bcm68360_nand_soc),
};
void board_nand_init(void)
.id = UCLASS_MTD,
.of_match = bcm6838_nand_dt_ids,
.probe = bcm6838_nand_probe,
- .priv_auto_alloc_size = sizeof(struct bcm6838_nand_soc),
+ .priv_auto = sizeof(struct bcm6838_nand_soc),
};
void board_nand_init(void)
.id = UCLASS_MTD,
.of_match = bcm6858_nand_dt_ids,
.probe = bcm6858_nand_probe,
- .priv_auto_alloc_size = sizeof(struct bcm6858_nand_soc),
+ .priv_auto = sizeof(struct bcm6858_nand_soc),
};
void board_nand_init(void)
.id = UCLASS_MTD,
.of_match = davinci_nand_ids,
.probe = davinci_nand_probe,
- .priv_auto_alloc_size = sizeof(struct nand_chip),
+ .priv_auto = sizeof(struct nand_chip),
};
void board_nand_init(void)
.id = UCLASS_MTD,
.of_match = denali_nand_dt_ids,
.probe = denali_dt_probe,
- .priv_auto_alloc_size = sizeof(struct denali_nand_info),
+ .priv_auto = sizeof(struct denali_nand_info),
};
void board_nand_init(void)
.id = UCLASS_MTD,
.of_match = mxs_nand_dt_ids,
.probe = mxs_nand_dt_probe,
- .priv_auto_alloc_size = sizeof(struct mxs_nand_info),
+ .priv_auto = sizeof(struct mxs_nand_info),
};
void board_nand_init(void)
.id = UCLASS_MISC,
.probe = octeontx_pci_bchpf_probe,
.remove = octeontx_pci_bchpf_remove,
- .priv_auto_alloc_size = sizeof(struct bch_device),
+ .priv_auto = sizeof(struct bch_device),
.flags = DM_FLAG_OS_PREPARE,
};
.name = BCHVF_DRIVER_NAME,
.id = UCLASS_MISC,
.probe = octeontx_pci_bchvf_probe,
- .priv_auto_alloc_size = sizeof(struct bch_vf),
+ .priv_auto = sizeof(struct bch_vf),
};
U_BOOT_PCI_DEVICE(octeontx_pci_bchpf, octeontx_bchpf_pci_id_table);
.of_match = of_match_ptr(octeontx_nand_ids),
.ofdata_to_platdata = octeontx_nand_ofdata_to_platdata,
.probe = octeontx_pci_nand_probe,
- .priv_auto_alloc_size = sizeof(struct octeontx_nfc),
+ .priv_auto = sizeof(struct octeontx_nfc),
.remove = octeontx_pci_nand_disable,
.flags = DM_FLAG_OS_PREPARE,
};
.id = UCLASS_MTD,
.of_match = pxa3xx_nand_dt_ids,
.probe = pxa3xx_nand_probe,
- .priv_auto_alloc_size = sizeof(struct pxa3xx_nand_info) +
+ .priv_auto = sizeof(struct pxa3xx_nand_info) +
sizeof(struct pxa3xx_nand_host) * CONFIG_SYS_MAX_NAND_DEVICE,
};
.id = UCLASS_MTD,
.of_match = stm32_fmc2_nfc_match,
.probe = stm32_fmc2_nfc_probe,
- .priv_auto_alloc_size = sizeof(struct stm32_fmc2_nfc),
+ .priv_auto = sizeof(struct stm32_fmc2_nfc),
};
void board_nand_init(void)
.id = UCLASS_MTD,
.of_match = tegra_nand_dt_ids,
.probe = tegra_probe,
- .priv_auto_alloc_size = sizeof(struct tegra_nand_info),
+ .priv_auto = sizeof(struct tegra_nand_info),
};
void board_nand_init(void)
.name = "vf610-nfc-dt",
.id = UCLASS_MTD,
.of_match = vf610_nfc_dt_ids,
- .priv_auto_alloc_size = sizeof(struct vf610_nfc),
+ .priv_auto = sizeof(struct vf610_nfc),
.probe = vf610_nfc_dt_probe,
};
.id = UCLASS_MTD,
.of_match = zynq_nand_dt_ids,
.probe = zynq_nand_probe,
- .priv_auto_alloc_size = sizeof(struct zynq_nand_info),
+ .priv_auto = sizeof(struct zynq_nand_info),
};
void board_nand_init(void)
.name = "spi_nand",
.id = UCLASS_MTD,
.of_match = spinand_ids,
- .priv_auto_alloc_size = sizeof(struct spinand_device),
+ .priv_auto = sizeof(struct spinand_device),
.probe = spinand_probe,
};
.ofdata_to_platdata = sandbox_sf_ofdata_to_platdata,
.probe = sandbox_sf_probe,
.remove = sandbox_sf_remove,
- .priv_auto_alloc_size = sizeof(struct sandbox_spi_flash),
- .platdata_auto_alloc_size = sizeof(struct sandbox_spi_flash_plat_data),
+ .priv_auto = sizeof(struct sandbox_spi_flash),
+ .platdata_auto = sizeof(struct sandbox_spi_flash_plat_data),
.ops = &sandbox_sf_emul_ops,
};
.id = UCLASS_SPI_FLASH,
.name = "spi_flash",
.post_bind = spi_flash_post_bind,
- .per_device_auto_alloc_size = sizeof(struct spi_flash),
+ .per_device_auto = sizeof(struct spi_flash),
};
.id = UCLASS_SPI_FLASH,
.of_match = spi_dataflash_ids,
.probe = spi_dataflash_probe,
- .priv_auto_alloc_size = sizeof(struct dataflash),
+ .priv_auto = sizeof(struct dataflash),
.ops = &spi_dataflash_ops,
};
.of_match = spi_flash_std_ids,
.probe = spi_flash_std_probe,
.remove = spi_flash_std_remove,
- .priv_auto_alloc_size = sizeof(struct spi_flash),
+ .priv_auto = sizeof(struct spi_flash),
.ops = &spi_flash_std_ops,
};
.id = UCLASS_MUX,
.name = "mux",
.post_probe = mux_uclass_post_probe,
- .per_device_auto_alloc_size = sizeof(struct mux_chip),
+ .per_device_auto = sizeof(struct mux_chip),
};
.probe = ag7xxx_eth_probe,
.remove = ag7xxx_eth_remove,
.ops = &ag7xxx_eth_ops,
- .priv_auto_alloc_size = sizeof(struct ar7xxx_eth_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct ar7xxx_eth_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.of_match = altera_tse_ids,
.ops = &altera_tse_ops,
.ofdata_to_platdata = altera_tse_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
- .priv_auto_alloc_size = sizeof(struct altera_tse_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct altera_tse_priv),
.probe = altera_tse_probe,
};
.id = UCLASS_ETH,
.of_match = bcm6348_eth_ids,
.ops = &bcm6348_eth_ops,
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
- .priv_auto_alloc_size = sizeof(struct bcm6348_eth_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct bcm6348_eth_priv),
.probe = bcm6348_eth_probe,
};
.id = UCLASS_ETH,
.of_match = bcm6368_eth_ids,
.ops = &bcm6368_eth_ops,
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
- .priv_auto_alloc_size = sizeof(struct bcm6368_eth_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct bcm6368_eth_priv),
.probe = bcm6368_eth_probe,
};
.ofdata_to_platdata = bcmgenet_eth_ofdata_to_platdata,
.probe = bcmgenet_eth_probe,
.ops = &bcmgenet_gmac_eth_ops,
- .priv_auto_alloc_size = sizeof(struct bcmgenet_eth_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct bcmgenet_eth_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.bind = dc2114x_bind,
.probe = dc2114x_probe,
.ops = &dc2114x_ops,
- .priv_auto_alloc_size = sizeof(struct dc2114x_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct dc2114x_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
};
U_BOOT_PCI_DEVICE(eth_dc2114x, supported);
.probe = designware_eth_probe,
.remove = designware_eth_remove,
.ops = &designware_eth_ops,
- .priv_auto_alloc_size = sizeof(struct dw_eth_dev),
- .platdata_auto_alloc_size = sizeof(struct dw_eth_pdata),
+ .priv_auto = sizeof(struct dw_eth_dev),
+ .platdata_auto = sizeof(struct dw_eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = eqos_probe,
.remove = eqos_remove,
.ops = &eqos_ops,
- .priv_auto_alloc_size = sizeof(struct eqos_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct eqos_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.ofdata_to_platdata = dwmac_s700_ofdata_to_platdata,
.probe = dwmac_s700_probe,
.ops = &designware_eth_ops,
- .priv_auto_alloc_size = sizeof(struct dw_eth_dev),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct dw_eth_dev),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.ofdata_to_platdata = dwmac_socfpga_ofdata_to_platdata,
.probe = dwmac_socfpga_probe,
.ops = &designware_eth_ops,
- .priv_auto_alloc_size = sizeof(struct dw_eth_dev),
- .platdata_auto_alloc_size = sizeof(struct dwmac_socfpga_platdata),
+ .priv_auto = sizeof(struct dw_eth_dev),
+ .platdata_auto = sizeof(struct dwmac_socfpga_platdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.bind = e1000_eth_bind,
.probe = e1000_eth_probe,
.ops = &e1000_eth_ops,
- .priv_auto_alloc_size = sizeof(struct e1000_hw),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct e1000_hw),
+ .platdata_auto = sizeof(struct eth_pdata),
};
U_BOOT_PCI_DEVICE(eth_e1000, e1000_supported);
.bind = eepro100_bind,
.probe = eepro100_probe,
.ops = &eepro100_ops,
- .priv_auto_alloc_size = sizeof(struct eepro100_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct eepro100_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
};
U_BOOT_PCI_DEVICE(eth_eepro100, supported);
UCLASS_DRIVER(eth_phy_generic) = {
.id = UCLASS_ETH_PHY,
.name = "eth_phy_generic",
- .per_device_auto_alloc_size = sizeof(struct eth_phy_device_priv),
+ .per_device_auto = sizeof(struct eth_phy_device_priv),
};
U_BOOT_DRIVER(eth_phy_generic_drv) = {
.probe = ethoc_probe,
.remove = ethoc_remove,
.ops = ðoc_ops,
- .priv_auto_alloc_size = sizeof(struct ethoc),
- .platdata_auto_alloc_size = sizeof(struct ethoc_eth_pdata),
+ .priv_auto = sizeof(struct ethoc),
+ .platdata_auto = sizeof(struct ethoc_eth_pdata),
};
#else
.probe = fecmxc_probe,
.remove = fecmxc_remove,
.ops = &fecmxc_ops,
- .priv_auto_alloc_size = sizeof(struct fec_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct fec_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
};
#endif
.probe = fm_eth_probe,
.remove = fm_eth_remove,
.ops = &fm_eth_ops,
- .priv_auto_alloc_size = sizeof(struct fm_eth),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct fm_eth),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#endif /* CONFIG_DM_ETH */
.of_match = fman_ids,
.probe = fman_probe,
.remove = fman_remove,
- .priv_auto_alloc_size = sizeof(struct fman_priv),
+ .priv_auto = sizeof(struct fman_priv),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#endif /* CONFIG_DM_ETH */
.probe = fm_mdio_probe,
.remove = fm_mdio_remove,
.ops = &fm_mdio_ops,
- .priv_auto_alloc_size = sizeof(struct fm_mdio_priv),
- .platdata_auto_alloc_size = sizeof(struct mdio_perdev_priv),
+ .priv_auto = sizeof(struct fm_mdio_priv),
+ .platdata_auto = sizeof(struct mdio_perdev_priv),
};
#endif /* CONFIG_PHYLIB && CONFIG_DM_MDIO */
#endif /* CONFIG_DM_ETH */
.probe = enetc_probe,
.remove = enetc_remove,
.ops = &enetc_ops,
- .priv_auto_alloc_size = sizeof(struct enetc_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct enetc_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
};
static struct pci_device_id enetc_ids[] = {
.bind = enetc_mdio_bind,
.probe = enetc_mdio_probe,
.ops = &enetc_mdio_ops,
- .priv_auto_alloc_size = sizeof(struct enetc_mdio_priv),
+ .priv_auto = sizeof(struct enetc_mdio_priv),
};
static struct pci_device_id enetc_mdio_ids[] = {
.of_match = fsl_ls_mdio_of_ids,
.probe = fsl_ls_mdio_probe,
.ops = &fsl_ls_mdio_ops,
- .priv_auto_alloc_size = sizeof(struct fsl_ls_mdio_priv),
+ .priv_auto = sizeof(struct fsl_ls_mdio_priv),
};
.probe = mcdmafec_probe,
.remove = mcdmafec_remove,
.ops = &mcdmafec_ops,
- .priv_auto_alloc_size = sizeof(struct fec_info_dma),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct fec_info_dma),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.probe = tsec_mdio_probe,
.remove = tsec_mdio_remove,
.ops = &tsec_mdio_ops,
- .priv_auto_alloc_size = sizeof(struct tsec_mdio_priv),
- .platdata_auto_alloc_size = sizeof(struct mdio_perdev_priv),
+ .priv_auto = sizeof(struct tsec_mdio_priv),
+ .platdata_auto = sizeof(struct mdio_perdev_priv),
};
#endif /* CONFIG_PHYLIB */
#endif /* CONFIG_DM_MDIO */
.probe = ftgmac100_probe,
.remove = ftgmac100_remove,
.ops = &ftgmac100_ops,
- .priv_auto_alloc_size = sizeof(struct ftgmac100_data),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct ftgmac100_data),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.ofdata_to_platdata = ftmac100_ofdata_to_platdata,
.probe = ftmac100_probe,
.ops = &ftmac100_ops,
- .priv_auto_alloc_size = sizeof(struct ftmac100_data),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct ftmac100_data),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#endif
.ofdata_to_platdata = gmac_rockchip_ofdata_to_platdata,
.probe = gmac_rockchip_probe,
.ops = &gmac_rockchip_eth_ops,
- .priv_auto_alloc_size = sizeof(struct dw_eth_dev),
- .platdata_auto_alloc_size = sizeof(struct gmac_rockchip_platdata),
+ .priv_auto = sizeof(struct dw_eth_dev),
+ .platdata_auto = sizeof(struct gmac_rockchip_platdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = higmac_probe,
.remove = higmac_remove,
.ops = &higmac_ops,
- .priv_auto_alloc_size = sizeof(struct higmac_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct higmac_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.ofdata_to_platdata = ks8851_ofdata_to_platdata,
.probe = ks8851_probe,
.ops = &ks8851_ops,
- .priv_auto_alloc_size = sizeof(struct ks_net),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct ks_net),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#endif
.bind = ldpaa_eth_bind,
.probe = ldpaa_eth_probe,
.ops = &ldpaa_eth_ops,
- .priv_auto_alloc_size = sizeof(struct ldpaa_eth_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct ldpaa_eth_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
};
#else
.probe = macb_eth_probe,
.remove = macb_eth_remove,
.ops = &macb_eth_ops,
- .priv_auto_alloc_size = sizeof(struct macb_device),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct macb_device),
+ .platdata_auto = sizeof(struct eth_pdata),
};
#endif
.probe = mcffec_probe,
.remove = mcffec_remove,
.ops = &mcffec_ops,
- .priv_auto_alloc_size = sizeof(struct fec_info_s),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct fec_info_s),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.bind = ipq4019_mdio_bind,
.probe = ipq4019_mdio_probe,
.ops = &ipq4019_mdio_ops,
- .priv_auto_alloc_size = sizeof(struct ipq4019_mdio_priv),
+ .priv_auto = sizeof(struct ipq4019_mdio_priv),
};
.of_match = mdio_mux_i2creg_ids,
.probe = mdio_mux_i2creg_probe,
.ops = &mdio_mux_i2creg_ops,
- .priv_auto_alloc_size = sizeof(struct mdio_mux_i2creg_priv),
+ .priv_auto = sizeof(struct mdio_mux_i2creg_priv),
};
.of_match = mdio_mux_sandbox_ids,
.probe = mdio_mux_sandbox_probe,
.ops = &mdio_mux_sandbox_ops,
- .priv_auto_alloc_size = sizeof(struct mdio_mux_sandbox_priv),
+ .priv_auto = sizeof(struct mdio_mux_sandbox_priv),
};
.of_match = mdio_sandbox_ids,
.probe = mdio_sandbox_probe,
.ops = &mdio_sandbox_ops,
- .priv_auto_alloc_size = sizeof(struct mdio_sandbox_priv),
+ .priv_auto = sizeof(struct mdio_sandbox_priv),
};
.probe = jr2_probe,
.remove = jr2_remove,
.ops = &jr2_ops,
- .priv_auto_alloc_size = sizeof(struct jr2_private),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct jr2_private),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.probe = luton_probe,
.remove = luton_remove,
.ops = &luton_ops,
- .priv_auto_alloc_size = sizeof(struct luton_private),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct luton_private),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.probe = ocelot_probe,
.remove = ocelot_remove,
.ops = &ocelot_ops,
- .priv_auto_alloc_size = sizeof(struct ocelot_private),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct ocelot_private),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.probe = serval_probe,
.remove = serval_remove,
.ops = &serval_ops,
- .priv_auto_alloc_size = sizeof(struct serval_private),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct serval_private),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.probe = servalt_probe,
.remove = servalt_remove,
.ops = &servalt_ops,
- .priv_auto_alloc_size = sizeof(struct servalt_private),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct servalt_private),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.of_match = mt7628_eth_ids,
.probe = mt7628_eth_probe,
.ops = &mt7628_eth_ops,
- .priv_auto_alloc_size = sizeof(struct mt7628_eth_dev),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct mt7628_eth_dev),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.id = UCLASS_ETH,
.of_match = mtk_eth_ids,
.ofdata_to_platdata = mtk_eth_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .platdata_auto = sizeof(struct eth_pdata),
.probe = mtk_eth_probe,
.remove = mtk_eth_remove,
.ops = &mtk_eth_ops,
- .priv_auto_alloc_size = sizeof(struct mtk_eth_priv),
+ .priv_auto = sizeof(struct mtk_eth_priv),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.ofdata_to_platdata = mvgbe_ofdata_to_platdata,
.probe = mvgbe_probe,
.ops = &mvgbe_ops,
- .priv_auto_alloc_size = sizeof(struct mvgbe_device),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct mvgbe_device),
+ .platdata_auto = sizeof(struct eth_pdata),
};
#endif /* CONFIG_DM_ETH */
.bind = mvmdio_bind,
.probe = mvmdio_probe,
.ops = &mvmdio_ops,
- .priv_auto_alloc_size = sizeof(struct mvmdio_priv),
+ .priv_auto = sizeof(struct mvmdio_priv),
};
.ofdata_to_platdata = mvneta_ofdata_to_platdata,
.probe = mvneta_probe,
.ops = &mvneta_ops,
- .priv_auto_alloc_size = sizeof(struct mvneta_port),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct mvneta_port),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.probe = mvpp2_probe,
.remove = mvpp2_remove,
.ops = &mvpp2_ops,
- .priv_auto_alloc_size = sizeof(struct mvpp2_port),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct mvpp2_port),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ACTIVE_DMA,
};
.id = UCLASS_MISC,
.of_match = mvpp2_ids,
.bind = mvpp2_base_bind,
- .priv_auto_alloc_size = sizeof(struct mvpp2),
+ .priv_auto = sizeof(struct mvpp2),
};
.id = UCLASS_MISC,
.probe = octeontx_bgx_probe,
.remove = octeontx_bgx_remove,
- .priv_auto_alloc_size = sizeof(struct bgx),
+ .priv_auto = sizeof(struct bgx),
.flags = DM_FLAG_OS_PREPARE,
};
.name = "octeontx_nic",
.id = UCLASS_MISC,
.probe = octeontx_nic_probe,
- .priv_auto_alloc_size = sizeof(struct nicpf),
+ .priv_auto = sizeof(struct nicpf),
};
static struct pci_device_id octeontx_nic_supported[] = {
.id = UCLASS_ETH,
.probe = octeontx_vnic_probe,
.ops = &octeontx_vnic_ops,
- .priv_auto_alloc_size = sizeof(struct nicvf),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct nicvf),
+ .platdata_auto = sizeof(struct eth_pdata),
};
static struct pci_device_id octeontx_vnic_supported[] = {
.id = UCLASS_MISC,
.probe = cgx_probe,
.remove = cgx_remove,
- .priv_auto_alloc_size = sizeof(struct cgx),
+ .priv_auto = sizeof(struct cgx),
};
static struct pci_device_id cgx_supported[] = {
.id = UCLASS_MISC,
.probe = rvu_af_probe,
.remove = rvu_af_remove,
- .priv_auto_alloc_size = sizeof(struct rvu_af),
+ .priv_auto = sizeof(struct rvu_af),
};
static struct pci_device_id rvu_af_supported[] = {
.probe = rvu_pf_probe,
.remove = rvu_pf_remove,
.ops = &nix_eth_ops,
- .priv_auto_alloc_size = sizeof(struct rvu_pf),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct rvu_pf),
+ .platdata_auto = sizeof(struct eth_pdata),
};
static struct pci_device_id rvu_pf_supported[] = {
.probe = pch_gbe_probe,
.remove = pch_gbe_remove,
.ops = &pch_gbe_ops,
- .priv_auto_alloc_size = sizeof(struct pch_gbe_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct pch_gbe_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.bind = pcnet_bind,
.probe = pcnet_probe,
.ops = &pcnet_ops,
- .priv_auto_alloc_size = sizeof(struct pcnet_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct pcnet_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_UC_FLAG_ALLOC_PRIV_DMA,
};
.probe = pfe_eth_probe,
.remove = pfe_eth_remove,
.ops = &pfe_eth_ops,
- .priv_auto_alloc_size = sizeof(struct pfe_eth_dev),
- .platdata_auto_alloc_size = sizeof(struct pfe_eth_pdata)
+ .priv_auto = sizeof(struct pfe_eth_dev),
+ .platdata_auto = sizeof(struct pfe_eth_pdata)
};
.probe = pic32_eth_probe,
.remove = pic32_eth_remove,
.ops = &pic32_eth_ops,
- .priv_auto_alloc_size = sizeof(struct pic32eth_dev),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct pic32eth_dev),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.probe = qe_uec_probe,
.remove = qe_uec_remove,
.ops = &qe_uec_eth_ops,
- .priv_auto_alloc_size = sizeof(struct qe_uec_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct qe_uec_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.of_match = qe_uec_mdio_ids,
.probe = qe_uec_mdio_probe,
.ops = &qe_uec_mdio_ops,
- .priv_auto_alloc_size = sizeof(struct qe_uec_mdio_priv),
+ .priv_auto = sizeof(struct qe_uec_mdio_priv),
};
.probe = ravb_probe,
.remove = ravb_remove,
.ops = &ravb_ops,
- .priv_auto_alloc_size = sizeof(struct ravb_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct ravb_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.bind = rtl8139_bind,
.probe = rtl8139_probe,
.ops = &rtl8139_ops,
- .priv_auto_alloc_size = sizeof(struct rtl8139_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct rtl8139_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
};
U_BOOT_PCI_DEVICE(eth_rtl8139, supported);
.of_match = rtl8169_eth_ids,
.probe = rtl8169_eth_probe,
.ops = &rtl8169_eth_ops,
- .priv_auto_alloc_size = sizeof(struct rtl8169_private),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct rtl8169_private),
+ .platdata_auto = sizeof(struct eth_pdata),
};
U_BOOT_PCI_DEVICE(eth_rtl8169, supported);
.of_match = sb_eth_raw_ids,
.ofdata_to_platdata = sb_eth_raw_ofdata_to_platdata,
.ops = &sb_eth_raw_ops,
- .priv_auto_alloc_size = sizeof(struct eth_sandbox_raw_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct eth_sandbox_raw_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.ofdata_to_platdata = sb_eth_ofdata_to_platdata,
.remove = sb_eth_remove,
.ops = &sb_eth_ops,
- .priv_auto_alloc_size = sizeof(struct eth_sandbox_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct eth_sandbox_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.probe = sh_ether_probe,
.remove = sh_ether_remove,
.ops = &sh_ether_ops,
- .priv_auto_alloc_size = sizeof(struct sh_ether_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct sh_ether_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#endif
.ofdata_to_platdata = smc911x_ofdata_to_platdata,
.probe = smc911x_probe,
.ops = &smc911x_ops,
- .priv_auto_alloc_size = sizeof(struct smc911x_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct smc911x_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#endif
.remove = ave_remove,
.ofdata_to_platdata = ave_ofdata_to_platdata,
.ops = &ave_ops,
- .priv_auto_alloc_size = sizeof(struct ave_private),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct ave_private),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.ofdata_to_platdata = sun8i_emac_eth_ofdata_to_platdata,
.probe = sun8i_emac_eth_probe,
.ops = &sun8i_emac_eth_ops,
- .priv_auto_alloc_size = sizeof(struct emac_eth_dev),
- .platdata_auto_alloc_size = sizeof(struct sun8i_eth_pdata),
+ .priv_auto = sizeof(struct emac_eth_dev),
+ .platdata_auto = sizeof(struct sun8i_eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.ofdata_to_platdata = sunxi_emac_eth_ofdata_to_platdata,
.probe = sunxi_emac_eth_probe,
.ops = &sunxi_emac_eth_ops,
- .priv_auto_alloc_size = sizeof(struct emac_eth_dev),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct emac_eth_dev),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.of_match = am65_cpsw_nuss_ids,
.probe = am65_cpsw_probe_cpsw,
.ops = &am65_cpsw_ops,
- .priv_auto_alloc_size = sizeof(struct am65_cpsw_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct am65_cpsw_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#if CONFIG_IS_ENABLED(OF_CONTROL)
.of_match = cpsw_eth_ids,
.ofdata_to_platdata = cpsw_eth_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .platdata_auto = sizeof(struct eth_pdata),
#endif
.probe = cpsw_eth_probe,
.ops = &cpsw_eth_ops,
- .priv_auto_alloc_size = sizeof(struct cpsw_priv),
+ .priv_auto = sizeof(struct cpsw_priv),
.flags = DM_FLAG_ALLOC_PRIV_DMA | DM_FLAG_PRE_RELOC,
};
#endif /* CONFIG_DM_ETH */
.of_match = davinci_emac_ids,
.probe = davinci_emac_probe,
.ops = &davinci_emac_ops,
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.probe = ks2_eth_probe,
.remove = ks2_eth_remove,
.ops = &ks2_eth_ops,
- .priv_auto_alloc_size = sizeof(struct ks2_eth_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct ks2_eth_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = ks2_eth_probe,
.remove = ks2_eth_remove,
.ops = &ks2_eth_ops,
- .priv_auto_alloc_size = sizeof(struct ks2_eth_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct ks2_eth_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = tsec_probe,
.remove = tsec_remove,
.ops = &tsec_ops,
- .priv_auto_alloc_size = sizeof(struct tsec_private),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct tsec_private),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#endif /* CONFIG_DM_ETH */
.probe = axi_emac_probe,
.remove = axi_emac_remove,
.ops = &axi_emac_ops,
- .priv_auto_alloc_size = sizeof(struct axidma_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct axidma_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.probe = emaclite_probe,
.remove = emaclite_remove,
.ops = &emaclite_ops,
- .priv_auto_alloc_size = sizeof(struct xemaclite),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct xemaclite),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.probe = zynq_gem_probe,
.remove = zynq_gem_remove,
.ops = &zynq_gem_ops,
- .priv_auto_alloc_size = sizeof(struct zynq_gem_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct zynq_gem_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
};
.id = UCLASS_BLK,
.probe = nvme_blk_probe,
.ops = &nvme_blk_ops,
- .priv_auto_alloc_size = sizeof(struct nvme_ns),
+ .priv_auto = sizeof(struct nvme_ns),
};
static int nvme_bind(struct udevice *udev)
.id = UCLASS_NVME,
.bind = nvme_bind,
.probe = nvme_probe,
- .priv_auto_alloc_size = sizeof(struct nvme_dev),
+ .priv_auto = sizeof(struct nvme_dev),
};
struct pci_device_id nvme_supported[] = {
.id = UCLASS_PCH,
.of_match = sandbox_pch_ids,
.ops = &sandbox_pch_ops,
- .priv_auto_alloc_size = sizeof(struct sandbox_pch_priv),
+ .priv_auto = sizeof(struct sandbox_pch_priv),
};
.probe = pcie_advk_probe,
.remove = pcie_advk_remove,
.flags = DM_FLAG_OS_PREPARE,
- .priv_auto_alloc_size = sizeof(struct pcie_advk),
+ .priv_auto = sizeof(struct pcie_advk),
};
.name = "pci_emul",
.post_probe = sandbox_pci_emul_post_probe,
.pre_remove = sandbox_pci_emul_pre_remove,
- .priv_auto_alloc_size = sizeof(struct sandbox_pci_emul_priv),
- .per_device_auto_alloc_size = sizeof(struct pci_emul_uc_priv),
+ .priv_auto = sizeof(struct sandbox_pci_emul_priv),
+ .per_device_auto = sizeof(struct pci_emul_uc_priv),
};
/*
* This uclass is a child of the pci bus. Its platdata is not defined here so
* is defined by its parent, UCLASS_PCI, which uses struct pci_child_platdata.
- * See per_child_platdata_auto_alloc_size in UCLASS_DRIVER(pci).
+ * See per_child_platdata_auto in UCLASS_DRIVER(pci).
*/
UCLASS_DRIVER(pci_emul_parent) = {
.id = UCLASS_PCI_EMUL_PARENT,
.ops = &rcar_gen2_pci_ops,
.probe = rcar_gen2_pci_probe,
.ofdata_to_platdata = rcar_gen2_pci_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct rcar_gen2_pci_priv),
+ .priv_auto = sizeof(struct rcar_gen2_pci_priv),
};
.ops = &rcar_gen3_pcie_ops,
.probe = rcar_gen3_pcie_probe,
.ofdata_to_platdata = rcar_gen3_pcie_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct rcar_gen3_pcie_priv),
+ .platdata_auto = sizeof(struct rcar_gen3_pcie_priv),
};
.pre_probe = pci_uclass_pre_probe,
.post_probe = pci_uclass_post_probe,
.child_post_bind = pci_uclass_child_post_bind,
- .per_device_auto_alloc_size = sizeof(struct pci_controller),
- .per_child_platdata_auto_alloc_size =
+ .per_device_auto = sizeof(struct pci_controller),
+ .per_child_platdata_auto =
sizeof(struct pci_child_platdata),
};
.probe = mpc85xx_pci_dm_probe,
.remove = mpc85xx_pci_dm_remove,
.ofdata_to_platdata = mpc85xx_pci_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct mpc85xx_pci_priv),
+ .priv_auto = sizeof(struct mpc85xx_pci_priv),
};
.ops = &mvebu_pcie_ops,
.probe = mvebu_pcie_probe,
.ofdata_to_platdata = mvebu_pcie_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct mvebu_pcie),
+ .platdata_auto = sizeof(struct mvebu_pcie),
};
/*
.ops = &pci_octeontx_ops,
.ofdata_to_platdata = pci_octeontx_ofdata_to_platdata,
.probe = pci_octeontx_probe,
- .priv_auto_alloc_size = sizeof(struct octeontx_pci),
+ .priv_auto = sizeof(struct octeontx_pci),
.flags = DM_FLAG_PRE_RELOC,
};
.of_match = sandbox_pci_ids,
.ops = &sandbox_pci_ops,
.probe = sandbox_pci_probe,
- .priv_auto_alloc_size = sizeof(struct sandbox_pci_priv),
+ .priv_auto = sizeof(struct sandbox_pci_priv),
/* Attach an emulator if we can */
.child_post_bind = dm_scan_fdt_dev,
- .per_child_platdata_auto_alloc_size =
+ .per_child_platdata_auto =
sizeof(struct pci_child_platdata),
};
.ops = &pci_tegra_ops,
.ofdata_to_platdata = pci_tegra_ofdata_to_platdata,
.probe = pci_tegra_probe,
- .priv_auto_alloc_size = sizeof(struct tegra_pcie),
+ .priv_auto = sizeof(struct tegra_pcie),
};
.of_match = brcm_pcie_ids,
.probe = brcm_pcie_probe,
.ofdata_to_platdata = brcm_pcie_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct brcm_pcie),
+ .priv_auto = sizeof(struct brcm_pcie),
};
.ops = &pcie_dw_mvebu_ops,
.ofdata_to_platdata = pcie_dw_mvebu_ofdata_to_platdata,
.probe = pcie_dw_mvebu_probe,
- .priv_auto_alloc_size = sizeof(struct pcie_dw_mvebu),
+ .priv_auto = sizeof(struct pcie_dw_mvebu),
};
.ops = &pcie_dw_ti_ops,
.ofdata_to_platdata = pcie_dw_ti_ofdata_to_platdata,
.probe = pcie_dw_ti_probe,
- .priv_auto_alloc_size = sizeof(struct pcie_dw_ti),
+ .priv_auto = sizeof(struct pcie_dw_ti),
};
.ops = &pci_generic_ecam_ops,
.probe = pci_generic_ecam_probe,
.ofdata_to_platdata = pci_generic_ecam_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct generic_ecam_pcie),
+ .priv_auto = sizeof(struct generic_ecam_pcie),
};
.ops = &fsl_pcie_ops,
.ofdata_to_platdata = fsl_pcie_ofdata_to_platdata,
.probe = fsl_pcie_probe,
- .priv_auto_alloc_size = sizeof(struct fsl_pcie),
+ .priv_auto = sizeof(struct fsl_pcie),
};
.probe = imx_pcie_dm_probe,
.remove = imx_pcie_dm_remove,
.ofdata_to_platdata = imx_pcie_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct imx_pcie_priv),
+ .priv_auto = sizeof(struct imx_pcie_priv),
.flags = DM_FLAG_OS_PREPARE,
};
#endif
.ops = &pcie_intel_fpga_ops,
.ofdata_to_platdata = pcie_intel_fpga_ofdata_to_platdata,
.probe = pcie_intel_fpga_probe,
- .priv_auto_alloc_size = sizeof(struct intel_fpga_pcie),
+ .priv_auto = sizeof(struct intel_fpga_pcie),
};
.ops = &iproc_pcie_ops,
.probe = iproc_pcie_probe,
.remove = iproc_pcie_remove,
- .priv_auto_alloc_size = sizeof(struct iproc_pcie),
+ .priv_auto = sizeof(struct iproc_pcie),
.flags = DM_REMOVE_OS_PREPARE,
};
.ops = &ls_pcie_ep_ops,
.probe = ls_pcie_ep_probe,
.remove = ls_pcie_ep_remove,
- .priv_auto_alloc_size = sizeof(struct ls_pcie_ep),
+ .priv_auto = sizeof(struct ls_pcie_ep),
};
.of_match = ls_pcie_g4_ids,
.ops = &ls_pcie_g4_ops,
.probe = ls_pcie_g4_probe,
- .priv_auto_alloc_size = sizeof(struct ls_pcie_g4),
+ .priv_auto = sizeof(struct ls_pcie_g4),
};
.of_match = ls_pcie_ids,
.ops = &ls_pcie_ops,
.probe = ls_pcie_probe,
- .priv_auto_alloc_size = sizeof(struct ls_pcie_rc),
+ .priv_auto = sizeof(struct ls_pcie_rc),
};
.of_match = mtk_pcie_ids,
.ops = &mtk_pcie_ops,
.probe = mtk_pcie_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_pcie),
+ .priv_auto = sizeof(struct mtk_pcie),
};
static const struct udevice_id mtk_pcie_ids_v2[] = {
.of_match = mtk_pcie_ids_v2,
.ops = &mtk_pcie_ops_v2,
.probe = mtk_pcie_probe_v2,
- .priv_auto_alloc_size = sizeof(struct mtk_pcie),
+ .priv_auto = sizeof(struct mtk_pcie),
};
.of_match = pci_phytium_ids,
.ops = &pci_phytium_ops,
.ofdata_to_platdata = pci_phytium_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct phytium_pcie),
+ .priv_auto = sizeof(struct phytium_pcie),
};
.of_match = rockchip_pcie_ids,
.ops = &rockchip_pcie_ops,
.probe = rockchip_pcie_probe,
- .priv_auto_alloc_size = sizeof(struct rockchip_pcie),
+ .priv_auto = sizeof(struct rockchip_pcie),
};
.of_match = pcie_xilinx_ids,
.ops = &pcie_xilinx_ops,
.ofdata_to_platdata = pcie_xilinx_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct xilinx_pcie),
+ .priv_auto = sizeof(struct xilinx_pcie),
};
.ops = &cdns_pci_ep_ops,
.probe = cdns_pci_ep_probe,
.remove = cdns_pci_ep_remove,
- .priv_auto_alloc_size = sizeof(struct cdns_pcie),
+ .priv_auto = sizeof(struct cdns_pcie),
};
.of_match = sandbox_pci_ep_ids,
.probe = sandbox_pci_ep_probe,
.ops = &sandbox_pci_ep_ops,
- .priv_auto_alloc_size = sizeof(struct sandbox_pci_ep_priv),
+ .priv_auto = sizeof(struct sandbox_pci_ep_priv),
};
.of_match = sun4i_usb_phy_ids,
.ops = &sun4i_usb_phy_ops,
.probe = sun4i_usb_phy_probe,
- .platdata_auto_alloc_size = sizeof(struct sun4i_usb_phy_plat[MAX_PHYS]),
- .priv_auto_alloc_size = sizeof(struct sun4i_usb_phy_data),
+ .platdata_auto = sizeof(struct sun4i_usb_phy_plat[MAX_PHYS]),
+ .priv_auto = sizeof(struct sun4i_usb_phy_data),
};
.id = UCLASS_PHY,
.of_match = bcm6318_usbh_ids,
.ops = &bcm6318_usbh_ops,
- .priv_auto_alloc_size = sizeof(struct bcm6318_usbh_priv),
+ .priv_auto = sizeof(struct bcm6318_usbh_priv),
.probe = bcm6318_usbh_probe,
};
.id = UCLASS_PHY,
.of_match = bcm6348_usbh_ids,
.ops = &bcm6348_usbh_ops,
- .priv_auto_alloc_size = sizeof(struct bcm6348_usbh_priv),
+ .priv_auto = sizeof(struct bcm6348_usbh_priv),
.probe = bcm6348_usbh_probe,
};
.id = UCLASS_PHY,
.of_match = bcm6358_usbh_ids,
.ops = &bcm6358_usbh_ops,
- .priv_auto_alloc_size = sizeof(struct bcm6358_usbh_priv),
+ .priv_auto = sizeof(struct bcm6358_usbh_priv),
.probe = bcm6358_usbh_probe,
};
.id = UCLASS_PHY,
.of_match = bcm6368_usbh_ids,
.ops = &bcm6368_usbh_ops,
- .priv_auto_alloc_size = sizeof(struct bcm6368_usbh_priv),
+ .priv_auto = sizeof(struct bcm6368_usbh_priv),
.probe = bcm6368_usbh_probe,
};
.of_match = keystone_usb_phy_ids,
.ops = &keystone_usb_phy_ops,
.probe = keystone_usb_phy_probe,
- .priv_auto_alloc_size = sizeof(struct keystone_usb_phy),
+ .priv_auto = sizeof(struct keystone_usb_phy),
};
.id = UCLASS_MISC,
.of_match = comphy_ids,
.probe = comphy_probe,
- .priv_auto_alloc_size = sizeof(struct chip_serdes_phy_config),
+ .priv_auto = sizeof(struct chip_serdes_phy_config),
};
.of_match = meson_g12a_usb2_phy_ids,
.probe = meson_g12a_usb2_phy_probe,
.ops = &meson_g12a_usb2_phy_ops,
- .priv_auto_alloc_size = sizeof(struct phy_meson_g12a_usb2_priv),
+ .priv_auto = sizeof(struct phy_meson_g12a_usb2_priv),
};
.of_match = meson_g12a_usb3_pcie_phy_ids,
.probe = meson_g12a_usb3_pcie_phy_probe,
.ops = &meson_g12a_usb3_pcie_phy_ops,
- .priv_auto_alloc_size = sizeof(struct phy_g12a_usb3_pcie_priv),
+ .priv_auto = sizeof(struct phy_g12a_usb3_pcie_priv),
};
.probe = meson_gxbb_usb2_phy_probe,
.remove = meson_gxbb_usb2_phy_remove,
.ops = &meson_gxbb_usb2_phy_ops,
- .priv_auto_alloc_size = sizeof(struct phy_meson_gxbb_usb2_priv),
+ .priv_auto = sizeof(struct phy_meson_gxbb_usb2_priv),
};
.of_match = meson_gxl_usb2_phy_ids,
.probe = meson_gxl_usb2_phy_probe,
.ops = &meson_gxl_usb2_phy_ops,
- .priv_auto_alloc_size = sizeof(struct phy_meson_gxl_usb2_priv),
+ .priv_auto = sizeof(struct phy_meson_gxl_usb2_priv),
};
.of_match = msm_phy_ids,
.ops = &msm_phy_ops,
.probe = msm_phy_probe,
- .priv_auto_alloc_size = sizeof(struct msm_phy_priv),
+ .priv_auto = sizeof(struct msm_phy_priv),
};
.of_match = mt76x8_usb_phy_ids,
.ops = &mt76x8_usb_phy_ops,
.probe = mt76x8_usb_phy_probe,
- .priv_auto_alloc_size = sizeof(struct mt76x8_usb_phy),
+ .priv_auto = sizeof(struct mt76x8_usb_phy),
};
.of_match = nop_phy_ids,
.ops = &nop_phy_ops,
.probe = nop_phy_probe,
- .priv_auto_alloc_size = sizeof(struct nop_phy_priv),
+ .priv_auto = sizeof(struct nop_phy_priv),
};
.of_match = omap_usb2_id_table,
.probe = omap_usb2_phy_probe,
.ops = &omap_usb2_phy_ops,
- .priv_auto_alloc_size = sizeof(struct omap_usb2_phy),
+ .priv_auto = sizeof(struct omap_usb2_phy),
};
.probe = sr_pcie_phy_probe,
.of_match = sr_pcie_phy_match_table,
.ops = &sr_pcie_phy_ops,
- .platdata_auto_alloc_size = sizeof(struct sr_pcie_phy_core),
- .priv_auto_alloc_size = sizeof(struct sr_pcie_phy_core),
+ .platdata_auto = sizeof(struct sr_pcie_phy_core),
+ .priv_auto = sizeof(struct sr_pcie_phy_core),
};
.of_match = mtk_tphy_id_table,
.ops = &mtk_tphy_ops,
.probe = mtk_tphy_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_tphy),
+ .priv_auto = sizeof(struct mtk_tphy),
};
.of_match = ipq4019_usb_ss_phy_ids,
.ops = &ipq4019_usb_ss_phy_ops,
.probe = ipq4019_usb_ss_phy_probe,
- .priv_auto_alloc_size = sizeof(struct ipq4019_usb_phy),
+ .priv_auto = sizeof(struct ipq4019_usb_phy),
};
static int ipq4019_hs_phy_power_off(struct phy *_phy)
.of_match = ipq4019_usb_hs_phy_ids,
.ops = &ipq4019_usb_hs_phy_ops,
.probe = ipq4019_usb_hs_phy_probe,
- .priv_auto_alloc_size = sizeof(struct ipq4019_usb_phy),
+ .priv_auto = sizeof(struct ipq4019_usb_phy),
};
.ops = &rcar_gen2_phy_phy_ops,
.probe = rcar_gen2_phy_probe,
.remove = rcar_gen2_phy_remove,
- .priv_auto_alloc_size = sizeof(struct rcar_gen2_phy),
+ .priv_auto = sizeof(struct rcar_gen2_phy),
};
.ops = &rcar_gen3_phy_phy_ops,
.probe = rcar_gen3_phy_probe,
.remove = rcar_gen3_phy_remove,
- .priv_auto_alloc_size = sizeof(struct rcar_gen3_phy),
+ .priv_auto = sizeof(struct rcar_gen3_phy),
};
.of_match = stm32_usbphyc_of_match,
.ops = &stm32_usbphyc_phy_ops,
.probe = stm32_usbphyc_probe,
- .priv_auto_alloc_size = sizeof(struct stm32_usbphyc),
+ .priv_auto = sizeof(struct stm32_usbphyc),
};
.name = "ti-serdes-am654-mux-clk",
.id = UCLASS_CLK,
.probe = serdes_am654_mux_clk_probe,
- .priv_auto_alloc_size = sizeof(struct serdes_am654_mux_clk_data),
+ .priv_auto = sizeof(struct serdes_am654_mux_clk_data),
.ops = &serdes_am654_mux_clk_ops,
};
.bind = serdes_am654_bind,
.ops = &serdes_am654_phy_ops,
.probe = serdes_am654_probe,
- .priv_auto_alloc_size = sizeof(struct serdes_am654),
+ .priv_auto = sizeof(struct serdes_am654),
};
.of_match = rockchip_usb2phy_ids,
.probe = rockchip_usb2phy_probe,
.bind = rockchip_usb2phy_bind,
- .priv_auto_alloc_size = sizeof(struct rockchip_usb2phy),
+ .priv_auto = sizeof(struct rockchip_usb2phy),
};
.of_match = rockchip_pcie_phy_ids,
.ops = &rockchip_pcie_phy_ops,
.probe = rockchip_pcie_phy_probe,
- .priv_auto_alloc_size = sizeof(struct rockchip_pcie_phy),
+ .priv_auto = sizeof(struct rockchip_pcie_phy),
};
.of_match = rockchip_typec_phy_ids,
.probe = rockchip_tcphy_probe,
.bind = rockchip_tcphy_bind,
- .priv_auto_alloc_size = sizeof(struct rockchip_tcphy),
+ .priv_auto = sizeof(struct rockchip_tcphy),
};
.of_match = sandbox_phy_ids,
.ops = &sandbox_phy_ops,
.probe = sandbox_phy_probe,
- .priv_auto_alloc_size = sizeof(struct sandbox_phy_priv),
+ .priv_auto = sizeof(struct sandbox_phy_priv),
};
.of_match = sti_usb_phy_ids,
.probe = sti_usb_phy_probe,
.ops = &sti_usb_phy_ops,
- .priv_auto_alloc_size = sizeof(struct sti_usb_phy),
+ .priv_auto = sizeof(struct sti_usb_phy),
};
.of_match = pipe3_phy_ids,
.ops = &pipe3_phy_ops,
.probe = pipe3_phy_probe,
- .priv_auto_alloc_size = sizeof(struct omap_pipe3),
+ .priv_auto = sizeof(struct omap_pipe3),
};
.name = "aspeed_ast2500_pinctrl",
.id = UCLASS_PINCTRL,
.of_match = ast2500_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct ast2500_pinctrl_priv),
+ .priv_auto = sizeof(struct ast2500_pinctrl_priv),
.ops = &ast2500_pinctrl_ops,
.probe = ast2500_pinctrl_probe,
};
.name = "pinctrl_ar933x",
.id = UCLASS_PINCTRL,
.of_match = ar933x_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct ar933x_pinctrl_priv),
+ .priv_auto = sizeof(struct ar933x_pinctrl_priv),
.ops = &ar933x_pinctrl_ops,
.probe = ar933x_pinctrl_probe,
};
.name = "pinctrl_qca953x",
.id = UCLASS_PINCTRL,
.of_match = qca953x_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct qca953x_pinctrl_priv),
+ .priv_auto = sizeof(struct qca953x_pinctrl_priv),
.ops = &qca953x_pinctrl_ops,
.probe = qca953x_pinctrl_probe,
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(bcm2835_pinctrl_id),
.ofdata_to_platdata = bcm283x_pinctl_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct bcm283x_pinctrl_priv),
+ .priv_auto = sizeof(struct bcm283x_pinctrl_priv),
.ops = &bcm283x_pinctrl_ops,
.probe = bcm283x_pinctl_probe,
#if CONFIG_IS_ENABLED(OF_BOARD)
.id = UCLASS_PINCTRL,
.of_match = bcm6838_pinctrl_match,
.ops = &bcm6838_pinctrl_ops,
- .priv_auto_alloc_size = sizeof(struct bcm6838_pinctrl_priv),
+ .priv_auto = sizeof(struct bcm6838_pinctrl_priv),
.probe = bcm6838_pinctrl_probe,
};
.name = "pinctrl_exynos7420",
.id = UCLASS_PINCTRL,
.of_match = exynos7420_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct exynos_pinctrl_priv),
+ .priv_auto = sizeof(struct exynos_pinctrl_priv),
.ops = &exynos7420_pinctrl_ops,
.probe = exynos_pinctrl_probe,
};
.bind = dm_scan_fdt_dev,
#endif
.ofdata_to_platdata = apl_pinctrl_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct intel_pinctrl_priv),
- .platdata_auto_alloc_size = sizeof(struct apl_gpio_platdata),
+ .priv_auto = sizeof(struct intel_pinctrl_priv),
+ .platdata_auto = sizeof(struct apl_gpio_platdata),
};
.of_match = mt7622_pctrl_match,
.ops = &mtk_pinctrl_ops,
.probe = mtk_pinctrl_mt7622_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_pinctrl_priv),
+ .priv_auto = sizeof(struct mtk_pinctrl_priv),
};
.of_match = mt7623_pctrl_match,
.ops = &mtk_pinctrl_ops,
.probe = mtk_pinctrl_mt7623_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_pinctrl_priv),
+ .priv_auto = sizeof(struct mtk_pinctrl_priv),
};
.of_match = mt7629_pctrl_match,
.ops = &mtk_pinctrl_ops,
.probe = mtk_pinctrl_mt7629_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_pinctrl_priv),
+ .priv_auto = sizeof(struct mtk_pinctrl_priv),
};
.of_match = mt8512_pctrl_match,
.ops = &mtk_pinctrl_ops,
.probe = mtk_pinctrl_mt8512_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_pinctrl_priv),
+ .priv_auto = sizeof(struct mtk_pinctrl_priv),
};
.of_match = mt8516_pctrl_match,
.ops = &mtk_pinctrl_ops,
.probe = mtk_pinctrl_mt8516_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_pinctrl_priv),
+ .priv_auto = sizeof(struct mtk_pinctrl_priv),
};
.of_match = mt8518_pctrl_match,
.ops = &mtk_pinctrl_ops,
.probe = mtk_pinctrl_mt8518_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_pinctrl_priv),
+ .priv_auto = sizeof(struct mtk_pinctrl_priv),
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(meson_axg_pinctrl_match),
.probe = meson_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct meson_pinctrl),
+ .priv_auto = sizeof(struct meson_pinctrl),
.ops = &meson_axg_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(meson_g12a_pinctrl_match),
.probe = meson_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct meson_pinctrl),
+ .priv_auto = sizeof(struct meson_pinctrl),
.ops = &meson_axg_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(meson_gxbb_pinctrl_match),
.probe = meson_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct meson_pinctrl),
+ .priv_auto = sizeof(struct meson_pinctrl),
.ops = &meson_gx_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(meson_gxl_pinctrl_match),
.probe = meson_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct meson_pinctrl),
+ .priv_auto = sizeof(struct meson_pinctrl),
.ops = &meson_gx_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(jr2_pinctrl_of_match),
.probe = jr2_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct mscc_pinctrl),
+ .priv_auto = sizeof(struct mscc_pinctrl),
.ops = &mscc_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(luton_pinctrl_of_match),
.probe = luton_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct mscc_pinctrl),
+ .priv_auto = sizeof(struct mscc_pinctrl),
.ops = &mscc_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(ocelot_pinctrl_of_match),
.probe = ocelot_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct mscc_pinctrl),
+ .priv_auto = sizeof(struct mscc_pinctrl),
.ops = &mscc_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(serval_pinctrl_of_match),
.probe = serval_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct mscc_pinctrl),
+ .priv_auto = sizeof(struct mscc_pinctrl),
.ops = &mscc_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(servalt_pinctrl_of_match),
.probe = servalt_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct mscc_pinctrl),
+ .priv_auto = sizeof(struct mscc_pinctrl),
.ops = &mscc_pinctrl_ops,
};
.ofdata_to_platdata = mt7628_pinctrl_ofdata_to_platdata,
.ops = &mt7628_pinctrl_ops,
.probe = mt7628_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct mt7628_pinctrl_priv),
+ .priv_auto = sizeof(struct mt7628_pinctrl_priv),
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(armada_37xx_pinctrl_of_match),
.probe = armada_37xx_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct armada_37xx_pinctrl),
+ .priv_auto = sizeof(struct armada_37xx_pinctrl),
.ops = &armada_37xx_pinctrl_ops,
};
.name = "mvebu_pinctrl",
.id = UCLASS_PINCTRL,
.of_match = mvebu_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct mvebu_pinctrl_priv),
+ .priv_auto = sizeof(struct mvebu_pinctrl_priv),
.ops = &mvebu_pinctrl_ops,
.probe = mvebu_pinctl_probe
};
.name = "pinctrl_s5pxx18",
.id = UCLASS_PINCTRL,
.of_match = s5pxx18_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct nexell_pinctrl_priv),
+ .priv_auto = sizeof(struct nexell_pinctrl_priv),
.ops = &s5pxx18_pinctrl_ops,
.probe = nexell_pinctrl_probe,
.flags = DM_FLAG_PRE_RELOC
.of_match = of_match_ptr(imx5_pinctrl_match),
.probe = imx5_pinctrl_probe,
.remove = imx_pinctrl_remove,
- .priv_auto_alloc_size = sizeof(struct imx_pinctrl_priv),
+ .priv_auto = sizeof(struct imx_pinctrl_priv),
.ops = &imx_pinctrl_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.of_match = of_match_ptr(imx6_pinctrl_match),
.probe = imx6_pinctrl_probe,
.remove = imx_pinctrl_remove,
- .priv_auto_alloc_size = sizeof(struct imx_pinctrl_priv),
+ .priv_auto = sizeof(struct imx_pinctrl_priv),
.ops = &imx_pinctrl_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.of_match = of_match_ptr(imx7_pinctrl_match),
.probe = imx7_pinctrl_probe,
.remove = imx_pinctrl_remove,
- .priv_auto_alloc_size = sizeof(struct imx_pinctrl_priv),
+ .priv_auto = sizeof(struct imx_pinctrl_priv),
.ops = &imx_pinctrl_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.of_match = of_match_ptr(imx7ulp_pinctrl_match),
.probe = imx7ulp_pinctrl_probe,
.remove = imx_pinctrl_remove,
- .priv_auto_alloc_size = sizeof(struct imx_pinctrl_priv),
+ .priv_auto = sizeof(struct imx_pinctrl_priv),
.ops = &imx_pinctrl_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.of_match = of_match_ptr(imx8_pinctrl_match),
.probe = imx8_pinctrl_probe,
.remove = imx_pinctrl_remove,
- .priv_auto_alloc_size = sizeof(struct imx_pinctrl_priv),
+ .priv_auto = sizeof(struct imx_pinctrl_priv),
.ops = &imx_pinctrl_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.of_match = of_match_ptr(imx8m_pinctrl_match),
.probe = imx8mq_pinctrl_probe,
.remove = imx_pinctrl_remove,
- .priv_auto_alloc_size = sizeof(struct imx_pinctrl_priv),
+ .priv_auto = sizeof(struct imx_pinctrl_priv),
.ops = &imx_pinctrl_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.of_match = of_match_ptr(imxrt_pinctrl_match),
.probe = imxrt_pinctrl_probe,
.remove = imx_pinctrl_remove,
- .priv_auto_alloc_size = sizeof(struct imx_pinctrl_priv),
+ .priv_auto = sizeof(struct imx_pinctrl_priv),
.ops = &imx_pinctrl_ops,
.flags = DM_FLAG_PRE_RELOC,
};
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
.bind = dm_scan_fdt_dev,
#endif
- .priv_auto_alloc_size = sizeof(struct mxs_pinctrl_priv),
+ .priv_auto = sizeof(struct mxs_pinctrl_priv),
.ops = &mxs_pinctrl_ops,
};
.of_match = of_match_ptr(vf610_pinctrl_match),
.probe = vf610_pinctrl_probe,
.remove = imx_pinctrl_remove,
- .priv_auto_alloc_size = sizeof(struct imx_pinctrl_priv),
+ .priv_auto = sizeof(struct imx_pinctrl_priv),
.ops = &imx_pinctrl_ops,
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_PINCTRL,
.of_match = atmel_pinctrl_match,
.probe = atmel_pinctrl_probe,
- .platdata_auto_alloc_size = sizeof(struct atmel_pio4_platdata),
+ .platdata_auto = sizeof(struct atmel_pio4_platdata),
.ops = &atmel_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = at91_pinctrl_match,
.probe = at91_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct at91_pinctrl_priv),
+ .priv_auto = sizeof(struct at91_pinctrl_priv),
.ops = &at91_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = k210_pc_ids,
.probe = k210_pc_probe,
- .priv_auto_alloc_size = sizeof(struct k210_pc_priv),
+ .priv_auto = sizeof(struct k210_pc_priv),
.ops = &k210_pc_pinctrl_ops,
};
.of_match = of_match_ptr(par_io_pinctrl_match),
.probe = par_io_pinctrl_probe,
.ofdata_to_platdata = qe_io_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct qe_io_platdata),
+ .platdata_auto = sizeof(struct qe_io_platdata),
.ops = &par_io_pinctrl_ops,
#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
.flags = DM_FLAG_PRE_RELOC,
.name = "sandbox_pinctrl",
.id = UCLASS_PINCTRL,
.of_match = sandbox_pinctrl_match,
- .priv_auto_alloc_size = sizeof(struct sandbox_pinctrl_priv),
+ .priv_auto = sizeof(struct sandbox_pinctrl_priv),
.ops = &sandbox_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = single_pinctrl_match,
.ops = &single_pinctrl_ops,
- .platdata_auto_alloc_size = sizeof(struct single_pdata),
+ .platdata_auto = sizeof(struct single_pdata),
.ofdata_to_platdata = single_ofdata_to_platdata,
};
.of_match = sti_pinctrl_ids,
.ops = &sti_pinctrl_ops,
.probe = sti_pinctrl_probe,
- .platdata_auto_alloc_size = sizeof(struct sti_pinctrl_platdata),
+ .platdata_auto = sizeof(struct sti_pinctrl_platdata),
.ops = &sti_pinctrl_ops,
};
.bind = stmfx_pinctrl_bind,
.probe = stmfx_pinctrl_probe,
.ops = &stmfx_pinctrl_ops,
- .platdata_auto_alloc_size = sizeof(struct stmfx_pinctrl),
+ .platdata_auto = sizeof(struct stmfx_pinctrl),
};
static int stmfx_chip_init(struct udevice *dev)
.ops = &pic32_pinctrl_ops,
.probe = pic32_pinctrl_probe,
.bind = dm_scan_fdt_dev,
- .priv_auto_alloc_size = sizeof(struct pic32_pinctrl_priv),
+ .priv_auto = sizeof(struct pic32_pinctrl_priv),
};
.ops = &stm32_pinctrl_ops,
.bind = stm32_pinctrl_bind,
.probe = stm32_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct stm32_pinctrl_priv),
+ .priv_auto = sizeof(struct stm32_pinctrl_priv),
};
.id = UCLASS_PINCTRL,
.of_match = r7s72100_pfc_match,
.probe = r7s72100_pfc_probe,
- .platdata_auto_alloc_size = sizeof(struct r7s72100_pfc_platdata),
+ .platdata_auto = sizeof(struct r7s72100_pfc_platdata),
.ops = &r7s72100_pfc_ops,
};
.name = "sh_pfc_pinctrl",
.id = UCLASS_PINCTRL,
.of_match = sh_pfc_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct sh_pfc_pinctrl_priv),
+ .priv_auto = sizeof(struct sh_pfc_pinctrl_priv),
.ops = &sh_pfc_pinctrl_ops,
.probe = sh_pfc_pinctrl_probe,
};
.name = "rockchip_px30_pinctrl",
.id = UCLASS_PINCTRL,
.of_match = px30_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct rockchip_pinctrl_priv),
+ .priv_auto = sizeof(struct rockchip_pinctrl_priv),
.ops = &rockchip_pinctrl_ops,
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
.bind = dm_scan_fdt_dev,
.name = "rk3036-pinctrl",
.id = UCLASS_PINCTRL,
.of_match = rk3036_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct rockchip_pinctrl_priv),
+ .priv_auto = sizeof(struct rockchip_pinctrl_priv),
.ops = &rockchip_pinctrl_ops,
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
.bind = dm_scan_fdt_dev,
.name = "pinctrl_rk3128",
.id = UCLASS_PINCTRL,
.of_match = rk3128_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct rockchip_pinctrl_priv),
+ .priv_auto = sizeof(struct rockchip_pinctrl_priv),
.ops = &rockchip_pinctrl_ops,
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
.bind = dm_scan_fdt_dev,
.name = "rockchip_rk3188_pinctrl",
.id = UCLASS_PINCTRL,
.of_match = rk3188_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct rockchip_pinctrl_priv),
+ .priv_auto = sizeof(struct rockchip_pinctrl_priv),
.ops = &rockchip_pinctrl_ops,
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
.bind = dm_scan_fdt_dev,
.name = "rockchip_rk3228_pinctrl",
.id = UCLASS_PINCTRL,
.of_match = rk3228_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct rockchip_pinctrl_priv),
+ .priv_auto = sizeof(struct rockchip_pinctrl_priv),
.ops = &rockchip_pinctrl_ops,
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
.bind = dm_scan_fdt_dev,
.name = "rockchip_rk3288_pinctrl",
.id = UCLASS_PINCTRL,
.of_match = rk3288_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct rockchip_pinctrl_priv),
+ .priv_auto = sizeof(struct rockchip_pinctrl_priv),
.ops = &rockchip_pinctrl_ops,
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
.bind = dm_scan_fdt_dev,
.name = "rockchip_rk3308_pinctrl",
.id = UCLASS_PINCTRL,
.of_match = rk3308_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct rockchip_pinctrl_priv),
+ .priv_auto = sizeof(struct rockchip_pinctrl_priv),
.ops = &rockchip_pinctrl_ops,
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
.bind = dm_scan_fdt_dev,
.name = "rockchip_rk3328_pinctrl",
.id = UCLASS_PINCTRL,
.of_match = rk3328_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct rockchip_pinctrl_priv),
+ .priv_auto = sizeof(struct rockchip_pinctrl_priv),
.ops = &rockchip_pinctrl_ops,
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
.bind = dm_scan_fdt_dev,
.name = "rockchip_rk3368_pinctrl",
.id = UCLASS_PINCTRL,
.of_match = rk3368_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct rockchip_pinctrl_priv),
+ .priv_auto = sizeof(struct rockchip_pinctrl_priv),
.ops = &rockchip_pinctrl_ops,
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
.bind = dm_scan_fdt_dev,
.name = "rockchip_rk3399_pinctrl",
.id = UCLASS_PINCTRL,
.of_match = rk3399_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct rockchip_pinctrl_priv),
+ .priv_auto = sizeof(struct rockchip_pinctrl_priv),
.ops = &rockchip_pinctrl_ops,
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
.bind = dm_scan_fdt_dev,
.name = "pinctrl_rv1108",
.id = UCLASS_PINCTRL,
.of_match = rv1108_pinctrl_ids,
- .priv_auto_alloc_size = sizeof(struct rockchip_pinctrl_priv),
+ .priv_auto = sizeof(struct rockchip_pinctrl_priv),
.ops = &rockchip_pinctrl_ops,
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
.bind = dm_scan_fdt_dev,
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(uniphier_ld11_pinctrl_match),
.probe = uniphier_ld11_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct uniphier_pinctrl_priv),
+ .priv_auto = sizeof(struct uniphier_pinctrl_priv),
.ops = &uniphier_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(uniphier_ld20_pinctrl_match),
.probe = uniphier_ld20_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct uniphier_pinctrl_priv),
+ .priv_auto = sizeof(struct uniphier_pinctrl_priv),
.ops = &uniphier_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(uniphier_ld4_pinctrl_match),
.probe = uniphier_ld4_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct uniphier_pinctrl_priv),
+ .priv_auto = sizeof(struct uniphier_pinctrl_priv),
.ops = &uniphier_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(uniphier_ld6b_pinctrl_match),
.probe = uniphier_ld6b_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct uniphier_pinctrl_priv),
+ .priv_auto = sizeof(struct uniphier_pinctrl_priv),
.ops = &uniphier_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(uniphier_pro4_pinctrl_match),
.probe = uniphier_pro4_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct uniphier_pinctrl_priv),
+ .priv_auto = sizeof(struct uniphier_pinctrl_priv),
.ops = &uniphier_pinctrl_ops,
#if !CONFIG_IS_ENABLED(OF_CONTROL)
.flags = DM_FLAG_PRE_RELOC,
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(uniphier_pro5_pinctrl_match),
.probe = uniphier_pro5_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct uniphier_pinctrl_priv),
+ .priv_auto = sizeof(struct uniphier_pinctrl_priv),
.ops = &uniphier_pinctrl_ops,
#if !CONFIG_IS_ENABLED(OF_CONTROL)
.flags = DM_FLAG_PRE_RELOC,
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(uniphier_pxs2_pinctrl_match),
.probe = uniphier_pxs2_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct uniphier_pinctrl_priv),
+ .priv_auto = sizeof(struct uniphier_pinctrl_priv),
.ops = &uniphier_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(uniphier_pxs3_pinctrl_match),
.probe = uniphier_pxs3_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct uniphier_pinctrl_priv),
+ .priv_auto = sizeof(struct uniphier_pinctrl_priv),
.ops = &uniphier_pinctrl_ops,
};
.id = UCLASS_PINCTRL,
.of_match = of_match_ptr(uniphier_sld8_pinctrl_match),
.probe = uniphier_sld8_pinctrl_probe,
- .priv_auto_alloc_size = sizeof(struct uniphier_pinctrl_priv),
+ .priv_auto = sizeof(struct uniphier_pinctrl_priv),
.ops = &uniphier_pinctrl_ops,
};
UCLASS_DRIVER(acpi_pmc) = {
.id = UCLASS_ACPI_PMC,
.name = "power-mgr",
- .per_device_auto_alloc_size = sizeof(struct acpi_pmc_upriv),
+ .per_device_auto = sizeof(struct acpi_pmc_upriv),
};
.of_match = sandbox_pmc_emul_ids,
.ops = &sandbox_pmc_emul_emul_ops,
.probe = sandbox_pmc_probe,
- .priv_auto_alloc_size = sizeof(struct pmc_emul_priv),
- .platdata_auto_alloc_size = sizeof(struct pmc_emul_platdata),
+ .priv_auto = sizeof(struct pmc_emul_priv),
+ .platdata_auto = sizeof(struct pmc_emul_platdata),
};
static struct pci_device_id sandbox_pmc_emul_supported[] = {
.of_match = sandbox_pmc_ids,
.probe = sandbox_pmc_probe,
.ops = &sandbox_pmc_ops,
- .priv_auto_alloc_size = sizeof(struct sandbox_pmc_priv),
+ .priv_auto = sizeof(struct sandbox_pmc_priv),
};
.id = UCLASS_POWER_DOMAIN,
.of_match = bcm6328_power_domain_ids,
.ops = &bcm6328_power_domain_ops,
- .priv_auto_alloc_size = sizeof(struct bcm6328_power_domain),
+ .priv_auto = sizeof(struct bcm6328_power_domain),
.probe = bcm6328_power_domain_probe,
};
.bind = imx8_power_domain_bind,
.probe = imx8_power_domain_probe,
.ofdata_to_platdata = imx8_power_domain_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct imx8_power_domain_platdata),
- .priv_auto_alloc_size = sizeof(struct imx8_power_domain_priv),
+ .platdata_auto = sizeof(struct imx8_power_domain_platdata),
+ .priv_auto = sizeof(struct imx8_power_domain_priv),
.ops = &imx8_power_domain_ops,
.flags = DM_FLAG_DEFAULT_PD_CTRL_OFF,
};
.bind = imx8m_power_domain_bind,
.probe = imx8m_power_domain_probe,
.ofdata_to_platdata = imx8m_power_domain_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct imx8m_power_domain_platdata),
+ .platdata_auto = sizeof(struct imx8m_power_domain_platdata),
.ops = &imx8m_power_domain_ops,
};
.of_match = meson_ee_pwrc_ids,
.probe = meson_ee_pwrc_probe,
.ops = &meson_ee_pwrc_ops,
- .priv_auto_alloc_size = sizeof(struct meson_ee_pwrc_priv),
+ .priv_auto = sizeof(struct meson_ee_pwrc_priv),
};
.of_match = meson_gx_pwrc_vpu_ids,
.probe = meson_gx_pwrc_vpu_probe,
.ops = &meson_gx_pwrc_vpu_ops,
- .priv_auto_alloc_size = sizeof(struct meson_gx_pwrc_vpu_priv),
+ .priv_auto = sizeof(struct meson_gx_pwrc_vpu_priv),
};
.ops = &mtk_power_domain_ops,
.probe = mtk_power_domain_probe,
.of_match = mtk_power_domain_ids,
- .priv_auto_alloc_size = sizeof(struct scp_domain),
+ .priv_auto = sizeof(struct scp_domain),
};
.name = "sandbox_power_domain_test",
.id = UCLASS_MISC,
.of_match = sandbox_power_domain_test_ids,
- .priv_auto_alloc_size = sizeof(struct sandbox_power_domain_test),
+ .priv_auto = sizeof(struct sandbox_power_domain_test),
};
.of_match = sandbox_power_domain_ids,
.bind = sandbox_power_domain_bind,
.probe = sandbox_power_domain_probe,
- .priv_auto_alloc_size = sizeof(struct sandbox_power_domain),
+ .priv_auto = sizeof(struct sandbox_power_domain),
.ops = &sandbox_power_domain_ops,
};
.id = UCLASS_POWER_DOMAIN,
.of_match = ti_sci_power_domain_of_match,
.probe = ti_sci_power_domain_probe,
- .priv_auto_alloc_size = sizeof(struct ti_sci_power_domain_data),
+ .priv_auto = sizeof(struct ti_sci_power_domain_data),
.ops = &ti_sci_power_domain_ops,
};
.of_match = sandbox_i2c_pmic_ids,
.ofdata_to_platdata = sandbox_i2c_pmic_ofdata_to_platdata,
.probe = sandbox_i2c_pmic_probe,
- .platdata_auto_alloc_size = sizeof(struct sandbox_i2c_pmic_plat_data),
+ .platdata_auto = sizeof(struct sandbox_i2c_pmic_plat_data),
.ops = &sandbox_i2c_pmic_emul_ops,
};
.bind = dm_scan_fdt_dev,
.probe = pm8916_probe,
.ops = &pm8916_ops,
- .priv_auto_alloc_size = sizeof(struct pm8916_priv),
+ .priv_auto = sizeof(struct pm8916_priv),
};
.id = UCLASS_PMIC,
.name = "pmic",
.pre_probe = pmic_pre_probe,
- .per_device_auto_alloc_size = sizeof(struct uc_pmic_priv),
+ .per_device_auto = sizeof(struct uc_pmic_priv),
};
#if CONFIG_IS_ENABLED(PMIC_CHILDREN)
.bind = rk8xx_bind,
#endif
- .priv_auto_alloc_size = sizeof(struct rk8xx_priv),
+ .priv_auto = sizeof(struct rk8xx_priv),
.probe = rk8xx_probe,
.ops = &rk8xx_ops,
};
.id = UCLASS_REGULATOR,
.ops = &bd71837_regulator_ops,
.probe = bd71837_regulator_probe,
- .platdata_auto_alloc_size = sizeof(struct bd71837_platdata),
+ .platdata_auto = sizeof(struct bd71837_platdata),
};
.id = UCLASS_REGULATOR,
.ops = &da9063_ldo_ops,
.probe = da9063_ldo_probe,
- .priv_auto_alloc_size = sizeof(struct da9063_priv),
+ .priv_auto = sizeof(struct da9063_priv),
};
static const struct dm_regulator_ops da9063_buck_ops = {
.id = UCLASS_REGULATOR,
.ops = &da9063_buck_ops,
.probe = da9063_buck_probe,
- .priv_auto_alloc_size = sizeof(struct da9063_priv),
+ .priv_auto = sizeof(struct da9063_priv),
};
.id = UCLASS_REGULATOR,
.ops = &fan53555_regulator_ops,
.ofdata_to_platdata = fan53555_regulator_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct fan53555_platdata),
- .priv_auto_alloc_size = sizeof(struct fan53555_priv),
+ .platdata_auto = sizeof(struct fan53555_platdata),
+ .priv_auto = sizeof(struct fan53555_priv),
.probe = fan53555_probe,
};
.ops = &fixed_regulator_ops,
.of_match = fixed_regulator_ids,
.ofdata_to_platdata = fixed_regulator_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct regulator_common_platdata),
+ .platdata_auto = sizeof(struct regulator_common_platdata),
};
.ops = &gpio_regulator_ops,
.of_match = gpio_regulator_ids,
.ofdata_to_platdata = gpio_regulator_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct gpio_regulator_platdata),
+ .platdata_auto = sizeof(struct gpio_regulator_platdata),
};
.bind = pbias_bind,
.ops = &pbias_ops,
.ofdata_to_platdata = pbias_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct pbias_priv),
+ .priv_auto = sizeof(struct pbias_priv),
};
static const struct pbias_reg_info pbias_mmc_omap2430 = {
.id = UCLASS_REGULATOR,
.ops = &pfuze100_regulator_ops,
.probe = pfuze100_regulator_probe,
- .platdata_auto_alloc_size = sizeof(struct pfuze100_regulator_platdata),
+ .platdata_auto = sizeof(struct pfuze100_regulator_platdata),
};
.probe = pwm_regulator_probe,
.of_match = pwm_regulator_ids,
.ofdata_to_platdata = pwm_regulator_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct pwm_regulator_info),
+ .priv_auto = sizeof(struct pwm_regulator_info),
};
.name = "regulator",
.post_bind = regulator_post_bind,
.pre_probe = regulator_pre_probe,
- .per_device_platdata_auto_alloc_size =
+ .per_device_platdata_auto =
sizeof(struct dm_regulator_uclass_platdata),
};
.of_match = stm32_vrefbuf_ids,
.probe = stm32_vrefbuf_probe,
.ops = &stm32_vrefbuf_ops,
- .priv_auto_alloc_size = sizeof(struct stm32_vrefbuf),
+ .priv_auto = sizeof(struct stm32_vrefbuf),
};
.id = UCLASS_REGULATOR,
.ops = &tps62360_regulator_ops,
.of_match = tps62360_regulator_ids,
- .platdata_auto_alloc_size = sizeof(struct tps62360_regulator_pdata),
+ .platdata_auto = sizeof(struct tps62360_regulator_pdata),
.probe = tps62360_regulator_probe,
};
.name = TPS65910_BOOST_DRIVER,
.id = UCLASS_REGULATOR,
.ops = &tps65910_boost_ops,
- .platdata_auto_alloc_size = sizeof(struct tps65910_regulator_pdata),
+ .platdata_auto = sizeof(struct tps65910_regulator_pdata),
.ofdata_to_platdata = tps65910_regulator_ofdata_to_platdata,
};
.name = TPS65910_BUCK_DRIVER,
.id = UCLASS_REGULATOR,
.ops = &tps65910_buck_ops,
- .platdata_auto_alloc_size = sizeof(struct tps65910_regulator_pdata),
+ .platdata_auto = sizeof(struct tps65910_regulator_pdata),
.ofdata_to_platdata = tps65910_regulator_ofdata_to_platdata,
};
.name = TPS65910_LDO_DRIVER,
.id = UCLASS_REGULATOR,
.ops = &tps65910_ldo_ops,
- .platdata_auto_alloc_size = sizeof(struct tps65910_regulator_pdata),
+ .platdata_auto = sizeof(struct tps65910_regulator_pdata),
.ofdata_to_platdata = tps65910_regulator_ofdata_to_platdata,
};
.ops = &exynos_pwm_ops,
.probe = exynos_pwm_probe,
.ofdata_to_platdata = exynos_pwm_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct exynos_pwm_priv),
+ .priv_auto = sizeof(struct exynos_pwm_priv),
};
.ops = &imx_pwm_ops,
.ofdata_to_platdata = imx_pwm_ofdata_to_platdata,
.probe = imx_pwm_probe,
- .priv_auto_alloc_size = sizeof(struct imx_pwm_priv),
+ .priv_auto = sizeof(struct imx_pwm_priv),
};
#endif
.ops = &meson_pwm_ops,
.ofdata_to_platdata = meson_pwm_ofdata_to_platdata,
.probe = meson_pwm_probe,
- .priv_auto_alloc_size = sizeof(struct meson_pwm),
+ .priv_auto = sizeof(struct meson_pwm),
};
.of_match = mtk_pwm_ids,
.ops = &mtk_pwm_ops,
.probe = mtk_pwm_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_pwm_priv),
+ .priv_auto = sizeof(struct mtk_pwm_priv),
};
.ops = &pwm_sifive_ops,
.ofdata_to_platdata = pwm_sifive_ofdata_to_platdata,
.probe = pwm_sifive_probe,
- .priv_auto_alloc_size = sizeof(struct pwm_sifive_priv),
+ .priv_auto = sizeof(struct pwm_sifive_priv),
};
.ops = &rk_pwm_ops,
.ofdata_to_platdata = rk_pwm_ofdata_to_platdata,
.probe = rk_pwm_probe,
- .priv_auto_alloc_size = sizeof(struct rk_pwm_priv),
+ .priv_auto = sizeof(struct rk_pwm_priv),
};
.id = UCLASS_PWM,
.of_match = sandbox_pwm_ids,
.ops = &sandbox_pwm_ops,
- .priv_auto_alloc_size = sizeof(struct sandbox_pwm_priv),
+ .priv_auto = sizeof(struct sandbox_pwm_priv),
};
.ops = &sunxi_pwm_ops,
.ofdata_to_platdata = sunxi_pwm_ofdata_to_platdata,
.probe = sunxi_pwm_probe,
- .priv_auto_alloc_size = sizeof(struct sunxi_pwm_priv),
+ .priv_auto = sizeof(struct sunxi_pwm_priv),
};
.of_match = tegra_pwm_ids,
.ops = &tegra_pwm_ops,
.ofdata_to_platdata = tegra_pwm_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct tegra_pwm_priv),
+ .priv_auto = sizeof(struct tegra_pwm_priv),
};
.ops = &ast2500_sdrammc_ops,
.ofdata_to_platdata = ast2500_sdrammc_ofdata_to_platdata,
.probe = ast2500_sdrammc_probe,
- .priv_auto_alloc_size = sizeof(struct dram_info),
+ .priv_auto = sizeof(struct dram_info),
};
.id = UCLASS_RAM,
.of_match = bmips_ram_ids,
.probe = bmips_ram_probe,
- .priv_auto_alloc_size = sizeof(struct bmips_ram_priv),
+ .priv_auto = sizeof(struct bmips_ram_priv),
.ops = &bmips_ram_ops,
};
.ops = &imxrt_semc_ops,
.ofdata_to_platdata = imxrt_semc_ofdata_to_platdata,
.probe = imxrt_semc_probe,
- .platdata_auto_alloc_size = sizeof(struct imxrt_sdram_params),
+ .platdata_auto = sizeof(struct imxrt_sdram_params),
};
.of_match = am654_ddrss_ids,
.ops = &am654_ddrss_ops,
.probe = am654_ddrss_probe,
- .priv_auto_alloc_size = sizeof(struct am654_ddrss_desc),
+ .priv_auto = sizeof(struct am654_ddrss_desc),
};
.of_match = j721e_ddrss_ids,
.ops = &j721e_ddrss_ops,
.probe = j721e_ddrss_probe,
- .priv_auto_alloc_size = sizeof(struct j721e_ddrss_desc),
+ .priv_auto = sizeof(struct j721e_ddrss_desc),
};
.of_match = mtk_ddr3_ids,
.ops = &mtk_ddr3_ops,
.probe = mtk_ddr3_probe,
- .priv_auto_alloc_size = sizeof(struct mtk_ddr3_priv),
+ .priv_auto = sizeof(struct mtk_ddr3_priv),
};
.ops = &mpc83xx_sdram_ops,
.ofdata_to_platdata = mpc83xx_sdram_ofdata_to_platdata,
.probe = mpc83xx_sdram_probe,
- .priv_auto_alloc_size = sizeof(struct mpc83xx_sdram_priv),
+ .priv_auto = sizeof(struct mpc83xx_sdram_priv),
};
.of_match = octeon_ids,
.ops = &octeon_ops,
.probe = octeon_ddr_probe,
- .platdata_auto_alloc_size = sizeof(struct ddr_priv),
+ .platdata_auto = sizeof(struct ddr_priv),
};
.of_match = rk3368_dmc_ids,
.ops = &rk3368_dmc_ops,
.probe = rk3368_dmc_probe,
- .priv_auto_alloc_size = sizeof(struct dram_info),
+ .priv_auto = sizeof(struct dram_info),
.ofdata_to_platdata = rk3368_dmc_ofdata_to_platdata,
.probe = rk3368_dmc_probe,
- .priv_auto_alloc_size = sizeof(struct dram_info),
- .platdata_auto_alloc_size = sizeof(struct rk3368_sdram_params),
+ .priv_auto = sizeof(struct dram_info),
+ .platdata_auto = sizeof(struct rk3368_sdram_params),
};
.of_match = px30_dmc_ids,
.ops = &px30_dmc_ops,
.probe = px30_dmc_probe,
- .priv_auto_alloc_size = sizeof(struct dram_info),
+ .priv_auto = sizeof(struct dram_info),
};
#endif /* CONFIG_TPL_BUILD */
.of_match = rk3128_dmc_ids,
.ops = &rk3128_dmc_ops,
.probe = rk3128_dmc_probe,
- .priv_auto_alloc_size = sizeof(struct dram_info),
+ .priv_auto = sizeof(struct dram_info),
};
.ofdata_to_platdata = rk3188_dmc_ofdata_to_platdata,
#endif
.probe = rk3188_dmc_probe,
- .priv_auto_alloc_size = sizeof(struct dram_info),
+ .priv_auto = sizeof(struct dram_info),
#ifdef CONFIG_SPL_BUILD
- .platdata_auto_alloc_size = sizeof(struct rk3188_sdram_params),
+ .platdata_auto = sizeof(struct rk3188_sdram_params),
#endif
};
.ofdata_to_platdata = rk322x_dmc_ofdata_to_platdata,
#endif
.probe = rk322x_dmc_probe,
- .priv_auto_alloc_size = sizeof(struct dram_info),
+ .priv_auto = sizeof(struct dram_info),
#ifdef CONFIG_TPL_BUILD
- .platdata_auto_alloc_size = sizeof(struct rk322x_sdram_params),
+ .platdata_auto = sizeof(struct rk322x_sdram_params),
#endif
};
.ofdata_to_platdata = rk3288_dmc_ofdata_to_platdata,
#endif
.probe = rk3288_dmc_probe,
- .priv_auto_alloc_size = sizeof(struct dram_info),
+ .priv_auto = sizeof(struct dram_info),
#if defined(CONFIG_TPL_BUILD) || \
(!defined(CONFIG_TPL) && defined(CONFIG_SPL_BUILD))
- .platdata_auto_alloc_size = sizeof(struct rk3288_sdram_params),
+ .platdata_auto = sizeof(struct rk3288_sdram_params),
#endif
};
.of_match = rk3308_dmc_ids,
.ops = &rk3308_dmc_ops,
.probe = rk3308_dmc_probe,
- .priv_auto_alloc_size = sizeof(struct dram_info),
+ .priv_auto = sizeof(struct dram_info),
};
.ofdata_to_platdata = rk3328_dmc_ofdata_to_platdata,
#endif
.probe = rk3328_dmc_probe,
- .priv_auto_alloc_size = sizeof(struct dram_info),
+ .priv_auto = sizeof(struct dram_info),
#ifdef CONFIG_TPL_BUILD
- .platdata_auto_alloc_size = sizeof(struct rockchip_dmc_plat),
+ .platdata_auto = sizeof(struct rockchip_dmc_plat),
#endif
};
.ofdata_to_platdata = rk3399_dmc_ofdata_to_platdata,
#endif
.probe = rk3399_dmc_probe,
- .priv_auto_alloc_size = sizeof(struct dram_info),
+ .priv_auto = sizeof(struct dram_info),
#if defined(CONFIG_TPL_BUILD) || \
(!defined(CONFIG_TPL) && defined(CONFIG_SPL_BUILD))
- .platdata_auto_alloc_size = sizeof(struct rockchip_dmc_plat),
+ .platdata_auto = sizeof(struct rockchip_dmc_plat),
#endif
};
.of_match = fu540_ddr_ids,
.ops = &fu540_ddr_ops,
.probe = fu540_ddr_probe,
- .priv_auto_alloc_size = sizeof(struct fu540_ddr_info),
+ .priv_auto = sizeof(struct fu540_ddr_info),
#if defined(CONFIG_SPL_BUILD)
- .platdata_auto_alloc_size = sizeof(struct sifive_dmc_plat),
+ .platdata_auto = sizeof(struct sifive_dmc_plat),
#endif
};
.ops = &stm32_fmc_ops,
.ofdata_to_platdata = stm32_fmc_ofdata_to_platdata,
.probe = stm32_fmc_probe,
- .platdata_auto_alloc_size = sizeof(struct stm32_sdram_params),
+ .platdata_auto = sizeof(struct stm32_sdram_params),
};
.of_match = stm32mp1_ddr_ids,
.ops = &stm32mp1_ddr_ops,
.probe = stm32mp1_ddr_probe,
- .priv_auto_alloc_size = sizeof(struct ddr_info),
+ .priv_auto = sizeof(struct ddr_info),
};
.id = UCLASS_REMOTEPROC,
.ops = &k3_sysctrler_ops,
.probe = k3_sysctrler_probe,
- .priv_auto_alloc_size = sizeof(struct k3_sysctrler_privdata),
+ .priv_auto = sizeof(struct k3_sysctrler_privdata),
};
.flags = DM_UC_FLAG_SEQ_ALIAS,
.pre_probe = rproc_pre_probe,
.post_probe = rproc_post_probe,
- .per_device_platdata_auto_alloc_size =
+ .per_device_platdata_auto =
sizeof(struct dm_rproc_uclass_pdata),
};
.id = UCLASS_REMOTEPROC,
.ops = &sandbox_testproc_ops,
.probe = sandbox_testproc_probe,
- .priv_auto_alloc_size = sizeof(struct sandbox_test_devdata),
+ .priv_auto = sizeof(struct sandbox_test_devdata),
};
/* TODO(nm@ti.com): Remove this along with non-DT support */
.id = UCLASS_REMOTEPROC,
.ops = &stm32_copro_ops,
.probe = stm32_copro_probe,
- .priv_auto_alloc_size = sizeof(struct stm32_copro_privdata),
+ .priv_auto = sizeof(struct stm32_copro_privdata),
};
.id = UCLASS_REMOTEPROC,
.ops = &k3_arm64_ops,
.probe = k3_arm64_probe,
- .priv_auto_alloc_size = sizeof(struct k3_arm64_privdata),
+ .priv_auto = sizeof(struct k3_arm64_privdata),
.flags = DM_FLAG_DEFAULT_PD_CTRL_OFF,
};
.ops = &k3_dsp_ops,
.probe = k3_dsp_probe,
.remove = k3_dsp_remove,
- .priv_auto_alloc_size = sizeof(struct k3_dsp_privdata),
+ .priv_auto = sizeof(struct k3_dsp_privdata),
};
.ops = &k3_r5f_rproc_ops,
.probe = k3_r5f_probe,
.remove = k3_r5f_remove,
- .priv_auto_alloc_size = sizeof(struct k3_r5f_core),
+ .priv_auto = sizeof(struct k3_r5f_core),
};
static int k3_r5f_cluster_probe(struct udevice *dev)
.of_match = k3_r5fss_ids,
.id = UCLASS_MISC,
.probe = k3_r5f_cluster_probe,
- .priv_auto_alloc_size = sizeof(struct k3_r5f_cluster),
+ .priv_auto = sizeof(struct k3_r5f_cluster),
.flags = DM_FLAG_DEFAULT_PD_CTRL_OFF,
};
.id = UCLASS_REMOTEPROC,
.ops = &ti_powerproc_ops,
.probe = ti_powerproc_probe,
- .priv_auto_alloc_size = sizeof(struct ti_powerproc_privdata),
+ .priv_auto = sizeof(struct ti_powerproc_privdata),
};
.of_match = ast2500_reset_ids,
.probe = ast2500_reset_probe,
.ops = &ast2500_reset_ops,
- .priv_auto_alloc_size = sizeof(struct ast2500_reset_priv),
+ .priv_auto = sizeof(struct ast2500_reset_priv),
};
.of_match = bcm6345_reset_ids,
.ops = &bcm6345_reset_reset_ops,
.probe = bcm6345_reset_probe,
- .priv_auto_alloc_size = sizeof(struct bcm6345_reset_priv),
+ .priv_auto = sizeof(struct bcm6345_reset_priv),
};
.of_match = hisi_reset_ids,
.ops = &hisi_reset_reset_ops,
.probe = hisi_reset_probe,
- .priv_auto_alloc_size = sizeof(struct hisi_reset_priv),
+ .priv_auto = sizeof(struct hisi_reset_priv),
};
.of_match = hsdk_reset_dt_match,
.ops = &hsdk_reset_ops,
.probe = hsdk_reset_probe,
- .priv_auto_alloc_size = sizeof(struct hsdk_rst),
+ .priv_auto = sizeof(struct hsdk_rst),
};
.of_match = imx7_reset_ids,
.ops = &imx7_reset_reset_ops,
.probe = imx7_reset_probe,
- .priv_auto_alloc_size = sizeof(struct imx7_reset_priv),
+ .priv_auto = sizeof(struct imx7_reset_priv),
};
.of_match = ipq4019_reset_ids,
.ops = &ipq4019_reset_ops,
.probe = ipq4019_reset_probe,
- .priv_auto_alloc_size = sizeof(struct ipq4019_reset_priv),
+ .priv_auto = sizeof(struct ipq4019_reset_priv),
};
.id = UCLASS_RESET,
.probe = mediatek_reset_probe,
.ops = &mediatek_reset_ops,
- .priv_auto_alloc_size = sizeof(struct mediatek_reset_priv),
+ .priv_auto = sizeof(struct mediatek_reset_priv),
};
.of_match = meson_reset_ids,
.probe = meson_reset_probe,
.ops = &meson_reset_ops,
- .priv_auto_alloc_size = sizeof(struct meson_reset_priv),
+ .priv_auto = sizeof(struct meson_reset_priv),
};
.of_match = mtmips_reset_ids,
.ofdata_to_platdata = mtmips_reset_ofdata_to_platdata,
.probe = mtmips_reset_probe,
- .priv_auto_alloc_size = sizeof(struct mtmips_reset_priv),
+ .priv_auto = sizeof(struct mtmips_reset_priv),
.ops = &mtmips_reset_ops,
};
.id = UCLASS_RESET,
.probe = rockchip_reset_probe,
.ops = &rockchip_reset_ops,
- .priv_auto_alloc_size = sizeof(struct rockchip_reset_priv),
+ .priv_auto = sizeof(struct rockchip_reset_priv),
};
.id = UCLASS_RESET,
.ops = &sifive_reset_ops,
.probe = sifive_reset_probe,
- .priv_auto_alloc_size = sizeof(struct sifive_reset_priv),
+ .priv_auto = sizeof(struct sifive_reset_priv),
};
.of_match = socfpga_reset_match,
.bind = socfpga_reset_bind,
.probe = socfpga_reset_probe,
- .priv_auto_alloc_size = sizeof(struct socfpga_reset_data),
+ .priv_auto = sizeof(struct socfpga_reset_data),
.ops = &socfpga_reset_ops,
.remove = socfpga_reset_remove,
.flags = DM_FLAG_OS_PREPARE,
.id = UCLASS_RESET,
.ops = &sunxi_reset_ops,
.probe = sunxi_reset_probe,
- .priv_auto_alloc_size = sizeof(struct sunxi_reset_priv),
+ .priv_auto = sizeof(struct sunxi_reset_priv),
};
.id = UCLASS_RESET,
.of_match = syscon_reset_ids,
.probe = syscon_reset_probe,
- .priv_auto_alloc_size = sizeof(struct syscon_reset_priv),
+ .priv_auto = sizeof(struct syscon_reset_priv),
.ops = &syscon_reset_ops,
};
.id = UCLASS_RESET,
.of_match = ti_sci_reset_of_match,
.probe = ti_sci_reset_probe,
- .priv_auto_alloc_size = sizeof(struct ti_sci_reset_data),
+ .priv_auto = sizeof(struct ti_sci_reset_data),
.ops = &ti_sci_reset_ops,
};
.id = UCLASS_RESET,
.of_match = uniphier_reset_match,
.probe = uniphier_reset_probe,
- .priv_auto_alloc_size = sizeof(struct uniphier_reset_priv),
+ .priv_auto = sizeof(struct uniphier_reset_priv),
.ops = &uniphier_reset_ops,
};
.name = "sandbox_reset_test",
.id = UCLASS_MISC,
.of_match = sandbox_reset_test_ids,
- .priv_auto_alloc_size = sizeof(struct sandbox_reset_test),
+ .priv_auto = sizeof(struct sandbox_reset_test),
};
.of_match = sandbox_reset_ids,
.bind = sandbox_reset_bind,
.probe = sandbox_reset_probe,
- .priv_auto_alloc_size = sizeof(struct sandbox_reset),
+ .priv_auto = sizeof(struct sandbox_reset),
.ops = &sandbox_reset_reset_ops,
};
.id = UCLASS_RESET,
.of_match = sti_reset_ids,
.probe = sti_reset_probe,
- .priv_auto_alloc_size = sizeof(struct sti_reset),
+ .priv_auto = sizeof(struct sti_reset),
.ops = &sti_reset_ops,
};
.name = "stm32_rcc_reset",
.id = UCLASS_RESET,
.probe = stm32_reset_probe,
- .priv_auto_alloc_size = sizeof(struct stm32_reset_priv),
+ .priv_auto = sizeof(struct stm32_reset_priv),
.ops = &stm32_reset_ops,
};
.ops = &meson_rng_ops,
.probe = meson_rng_probe,
.remove = meson_rng_remove,
- .platdata_auto_alloc_size = sizeof(struct meson_rng_platdata),
+ .platdata_auto = sizeof(struct meson_rng_platdata),
.ofdata_to_platdata = meson_rng_ofdata_to_platdata,
};
.ops = &msm_rng_ops,
.probe = msm_rng_probe,
.remove = msm_rng_remove,
- .priv_auto_alloc_size = sizeof(struct msm_rng_priv),
+ .priv_auto = sizeof(struct msm_rng_priv),
};
.ops = &rockchip_rng_ops,
.probe = rockchip_rng_probe,
.ofdata_to_platdata = rockchip_rng_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct rk_rng_platdata),
+ .priv_auto = sizeof(struct rk_rng_platdata),
};
.ops = &stm32_rng_ops,
.probe = stm32_rng_probe,
.remove = stm32_rng_remove,
- .platdata_auto_alloc_size = sizeof(struct stm32_rng_platdata),
+ .platdata_auto = sizeof(struct stm32_rng_platdata),
.ofdata_to_platdata = stm32_rng_ofdata_to_platdata,
};
.probe = ds3232_probe,
.of_match = ds3232_rtc_ids,
.ops = &ds3232_rtc_ops,
- .priv_auto_alloc_size = sizeof(struct ds3232_priv_data),
+ .priv_auto = sizeof(struct ds3232_priv_data),
};
.id = UCLASS_RTC,
.ops = &emul_rtc_ops,
.probe = emul_rtc_probe,
- .priv_auto_alloc_size = sizeof(struct emul_rtc),
+ .priv_auto = sizeof(struct emul_rtc),
};
U_BOOT_DEVICE(rtc_emul) = {
.id = UCLASS_I2C_EMUL,
.of_match = sandbox_i2c_rtc_ids,
.bind = sandbox_i2c_rtc_bind,
- .priv_auto_alloc_size = sizeof(struct sandbox_i2c_rtc),
- .platdata_auto_alloc_size = sizeof(struct sandbox_i2c_rtc_plat_data),
+ .priv_auto = sizeof(struct sandbox_i2c_rtc),
+ .platdata_auto = sizeof(struct sandbox_i2c_rtc_plat_data),
.ops = &sandbox_i2c_rtc_emul_ops,
};
.of_match = pl031_ids,
.probe = pl031_probe,
.ofdata_to_platdata = pl031_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct pl031_platdata),
+ .platdata_auto = sizeof(struct pl031_platdata),
.ops = &pl031_ops,
};
.probe = stm32_rtc_probe,
.of_match = stm32_rtc_ids,
.ops = &stm32_rtc_ops,
- .priv_auto_alloc_size = sizeof(struct stm32_rtc_priv),
+ .priv_auto = sizeof(struct stm32_rtc_priv),
};
UCLASS_DRIVER(scsi) = {
.id = UCLASS_SCSI,
.name = "scsi",
- .per_device_platdata_auto_alloc_size = sizeof(struct scsi_platdata),
+ .per_device_platdata_auto = sizeof(struct scsi_platdata),
};
.id = UCLASS_SERIAL,
.of_match = altera_jtaguart_ids,
.ofdata_to_platdata = altera_jtaguart_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct altera_jtaguart_platdata),
+ .platdata_auto = sizeof(struct altera_jtaguart_platdata),
.probe = altera_jtaguart_probe,
.ops = &altera_jtaguart_ops,
};
.id = UCLASS_SERIAL,
.of_match = altera_uart_ids,
.ofdata_to_platdata = altera_uart_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct altera_uart_platdata),
+ .platdata_auto = sizeof(struct altera_uart_platdata),
.probe = altera_uart_probe,
.ops = &altera_uart_ops,
};
.id = UCLASS_SERIAL,
#if CONFIG_IS_ENABLED(OF_CONTROL)
.of_match = atmel_serial_ids,
- .platdata_auto_alloc_size = sizeof(struct atmel_serial_platdata),
+ .platdata_auto = sizeof(struct atmel_serial_platdata),
#endif
.probe = atmel_serial_probe,
.ops = &atmel_serial_ops,
#if !CONFIG_IS_ENABLED(OF_CONTROL)
.flags = DM_FLAG_PRE_RELOC,
#endif
- .priv_auto_alloc_size = sizeof(struct atmel_serial_priv),
+ .priv_auto = sizeof(struct atmel_serial_priv),
};
#endif
.id = UCLASS_SERIAL,
.probe = lpc32xx_hsuart_probe,
.ops = &lpc32xx_hsuart_ops,
- .priv_auto_alloc_size = sizeof(struct lpc32xx_hsuart_priv),
+ .priv_auto = sizeof(struct lpc32xx_hsuart_priv),
.flags = DM_FLAG_PRE_RELOC,
};
#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
.of_match = ns16550_serial_ids,
.ofdata_to_platdata = ns16550_serial_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct ns16550_platdata),
+ .platdata_auto = sizeof(struct ns16550_platdata),
#endif
- .priv_auto_alloc_size = sizeof(struct NS16550),
+ .priv_auto = sizeof(struct NS16550),
.probe = ns16550_serial_probe,
.ops = &ns16550_serial_ops,
#if !CONFIG_IS_ENABLED(OF_CONTROL)
.id = UCLASS_SERIAL,
.of_match = sandbox_serial_ids,
.ofdata_to_platdata = sandbox_serial_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct sandbox_serial_platdata),
- .priv_auto_alloc_size = sizeof(struct sandbox_serial_priv),
+ .platdata_auto = sizeof(struct sandbox_serial_platdata),
+ .priv_auto = sizeof(struct sandbox_serial_priv),
.probe = sandbox_serial_probe,
.remove = sandbox_serial_remove,
.ops = &sandbox_serial_ops,
.flags = DM_UC_FLAG_SEQ_ALIAS,
.post_probe = serial_post_probe,
.pre_remove = serial_pre_remove,
- .per_device_auto_alloc_size = sizeof(struct serial_dev_priv),
+ .per_device_auto = sizeof(struct serial_dev_priv),
};
#endif
.name = "serial_ar933x",
.id = UCLASS_SERIAL,
.of_match = ar933x_serial_ids,
- .priv_auto_alloc_size = sizeof(struct ar933x_serial_priv),
+ .priv_auto = sizeof(struct ar933x_serial_priv),
.probe = ar933x_serial_probe,
.ops = &ar933x_serial_ops,
};
.id = UCLASS_SERIAL,
.of_match = arc_serial_ids,
.ofdata_to_platdata = arc_serial_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct arc_serial_platdata),
+ .platdata_auto = sizeof(struct arc_serial_platdata),
.probe = arc_serial_probe,
.ops = &arc_serial_ops,
};
.name = "serial_bcm283x_mu",
.id = UCLASS_SERIAL,
.of_match = of_match_ptr(bcm283x_mu_serial_id),
- .platdata_auto_alloc_size = sizeof(struct bcm283x_mu_serial_platdata),
+ .platdata_auto = sizeof(struct bcm283x_mu_serial_platdata),
.probe = bcm283x_mu_serial_probe,
.ops = &bcm283x_mu_serial_ops,
#if !CONFIG_IS_ENABLED(OF_CONTROL) || CONFIG_IS_ENABLED(OF_BOARD)
.flags = DM_FLAG_PRE_RELOC,
#endif
- .priv_auto_alloc_size = sizeof(struct bcm283x_mu_priv),
+ .priv_auto = sizeof(struct bcm283x_mu_priv),
};
.id = UCLASS_SERIAL,
.of_match = of_match_ptr(bcm283x_pl011_serial_id),
.probe = bcm283x_pl011_serial_probe,
- .platdata_auto_alloc_size = sizeof(struct pl01x_serial_platdata),
+ .platdata_auto = sizeof(struct pl01x_serial_platdata),
.ops = &bcm283x_pl011_serial_ops,
#if !CONFIG_IS_ENABLED(OF_CONTROL) || CONFIG_IS_ENABLED(OF_BOARD)
.flags = DM_FLAG_PRE_RELOC,
#endif
- .priv_auto_alloc_size = sizeof(struct pl01x_priv),
+ .priv_auto = sizeof(struct pl01x_priv),
};
.id = UCLASS_SERIAL,
.of_match = bcm6345_serial_ids,
.probe = bcm6345_serial_probe,
- .priv_auto_alloc_size = sizeof(struct bcm6345_serial_priv),
+ .priv_auto = sizeof(struct bcm6345_serial_priv),
.ops = &bcm6345_serial_ops,
};
.name = "coreboot_uart",
.id = UCLASS_SERIAL,
.of_match = coreboot_serial_ids,
- .priv_auto_alloc_size = sizeof(struct NS16550),
- .platdata_auto_alloc_size = sizeof(struct ns16550_platdata),
+ .priv_auto = sizeof(struct NS16550),
+ .platdata_auto = sizeof(struct ns16550_platdata),
.ofdata_to_platdata = coreboot_ofdata_to_platdata,
.probe = ns16550_serial_probe,
.ops = &ns16550_serial_ops,
.id = UCLASS_SERIAL,
.of_match = ca_serial_ids,
.ofdata_to_platdata = ca_serial_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct ca_uart_priv),
+ .priv_auto = sizeof(struct ca_uart_priv),
.probe = ca_serial_probe,
.ops = &ca_serial_ops
};
.name = "serial_efi",
.id = UCLASS_SERIAL,
.of_match = serial_efi_ids,
- .priv_auto_alloc_size = sizeof(struct serial_efi_priv),
+ .priv_auto = sizeof(struct serial_efi_priv),
.probe = serial_efi_probe,
.ops = &serial_efi_ops,
};
.id = UCLASS_SERIAL,
.of_match = mid_serial_ids,
.ofdata_to_platdata = ns16550_serial_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct ns16550_platdata),
- .priv_auto_alloc_size = sizeof(struct NS16550),
+ .platdata_auto = sizeof(struct ns16550_platdata),
+ .priv_auto = sizeof(struct NS16550),
.probe = mid_serial_probe,
.ops = &ns16550_serial_ops,
};
.probe = linflex_serial_probe,
.ops = &linflex_serial_ops,
.flags = DM_FLAG_PRE_RELOC,
- .priv_auto_alloc_size = sizeof(struct linflex_serial_priv),
+ .priv_auto = sizeof(struct linflex_serial_priv),
};
#ifdef CONFIG_DEBUG_UART_LINFLEXUART
.id = UCLASS_SERIAL,
.of_match = lpuart_serial_ids,
.ofdata_to_platdata = lpuart_serial_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct lpuart_serial_platdata),
+ .platdata_auto = sizeof(struct lpuart_serial_platdata),
.probe = lpuart_serial_probe,
.ops = &lpuart_serial_ops,
};
.id = UCLASS_SERIAL,
.of_match = coldfire_serial_ids,
.ofdata_to_platdata = coldfire_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct coldfire_serial_platdata),
+ .platdata_auto = sizeof(struct coldfire_serial_platdata),
.probe = coldfire_serial_probe,
.ops = &coldfire_serial_ops,
.flags = DM_FLAG_PRE_RELOC,
.probe = meson_serial_probe,
.ops = &meson_serial_ops,
.ofdata_to_platdata = meson_serial_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct meson_serial_platdata),
+ .platdata_auto = sizeof(struct meson_serial_platdata),
};
#ifdef CONFIG_DEBUG_UART_MESON
.id = UCLASS_SERIAL,
.of_match = msm_serial_ids,
.ofdata_to_platdata = msm_serial_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct msm_serial_data),
+ .priv_auto = sizeof(struct msm_serial_data),
.probe = msm_serial_probe,
.ops = &msm_serial_ops,
};
.id = UCLASS_SERIAL,
.of_match = mtk_serial_ids,
.ofdata_to_platdata = mtk_serial_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct mtk_serial_priv),
+ .priv_auto = sizeof(struct mtk_serial_priv),
.probe = mtk_serial_probe,
.ops = &mtk_serial_ops,
.flags = DM_FLAG_PRE_RELOC,
.id = UCLASS_SERIAL,
.of_match = mvebu_serial_ids,
.ofdata_to_platdata = mvebu_serial_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct mvebu_platdata),
+ .platdata_auto = sizeof(struct mvebu_platdata),
.probe = mvebu_serial_probe,
.ops = &mvebu_serial_ops,
};
#if CONFIG_IS_ENABLED(OF_CONTROL)
.of_match = mxc_serial_ids,
.ofdata_to_platdata = mxc_serial_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct mxc_serial_platdata),
+ .platdata_auto = sizeof(struct mxc_serial_platdata),
#endif
.probe = mxc_serial_probe,
.ops = &mxc_serial_ops,
#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
.of_match = omap_serial_ids,
.ofdata_to_platdata = omap_serial_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct ns16550_platdata),
+ .platdata_auto = sizeof(struct ns16550_platdata),
#endif
- .priv_auto_alloc_size = sizeof(struct NS16550),
+ .priv_auto = sizeof(struct NS16550),
.probe = ns16550_serial_probe,
.ops = &ns16550_serial_ops,
#if !CONFIG_IS_ENABLED(OF_CONTROL)
.id = UCLASS_SERIAL,
.of_match = owl_serial_ids,
.ofdata_to_platdata = owl_serial_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct owl_serial_priv),
+ .priv_auto = sizeof(struct owl_serial_priv),
.probe = owl_serial_probe,
.ops = &owl_serial_ops,
};
.of_match = pic32_uart_ids,
.probe = pic32_uart_probe,
.ops = &pic32_uart_ops,
- .priv_auto_alloc_size = sizeof(struct pic32_uart_priv),
+ .priv_auto = sizeof(struct pic32_uart_priv),
};
#ifdef CONFIG_DEBUG_UART_PIC32
.id = UCLASS_SERIAL,
.of_match = of_match_ptr(pl01x_serial_id),
.ofdata_to_platdata = of_match_ptr(pl01x_serial_ofdata_to_platdata),
- .platdata_auto_alloc_size = sizeof(struct pl01x_serial_platdata),
+ .platdata_auto = sizeof(struct pl01x_serial_platdata),
.probe = pl01x_serial_probe,
.ops = &pl01x_serial_ops,
.flags = DM_FLAG_PRE_RELOC,
- .priv_auto_alloc_size = sizeof(struct pl01x_priv),
+ .priv_auto = sizeof(struct pl01x_priv),
};
#endif
U_BOOT_DRIVER(rockchip_rk3188_uart) = {
.name = "rockchip_rk3188_uart",
.id = UCLASS_SERIAL,
- .priv_auto_alloc_size = sizeof(struct NS16550),
- .platdata_auto_alloc_size = sizeof(struct rockchip_uart_platdata),
+ .priv_auto = sizeof(struct NS16550),
+ .platdata_auto = sizeof(struct rockchip_uart_platdata),
.probe = rockchip_serial_probe,
.ops = &ns16550_serial_ops,
.flags = DM_FLAG_PRE_RELOC,
U_BOOT_DRIVER(rockchip_rk3288_uart) = {
.name = "rockchip_rk3288_uart",
.id = UCLASS_SERIAL,
- .priv_auto_alloc_size = sizeof(struct NS16550),
- .platdata_auto_alloc_size = sizeof(struct rockchip_uart_platdata),
+ .priv_auto = sizeof(struct NS16550),
+ .platdata_auto = sizeof(struct rockchip_uart_platdata),
.probe = rockchip_serial_probe,
.ops = &ns16550_serial_ops,
.flags = DM_FLAG_PRE_RELOC,
.id = UCLASS_SERIAL,
.of_match = s5p_serial_ids,
.ofdata_to_platdata = s5p_serial_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct s5p_serial_platdata),
+ .platdata_auto = sizeof(struct s5p_serial_platdata),
.probe = s5p_serial_probe,
.ops = &s5p_serial_ops,
};
.id = UCLASS_SERIAL,
.of_match = of_match_ptr(sh_serial_id),
.ofdata_to_platdata = of_match_ptr(sh_serial_ofdata_to_platdata),
- .platdata_auto_alloc_size = sizeof(struct sh_serial_platdata),
+ .platdata_auto = sizeof(struct sh_serial_platdata),
.probe = sh_serial_probe,
.ops = &sh_serial_ops,
#if !CONFIG_IS_ENABLED(OF_CONTROL)
.flags = DM_FLAG_PRE_RELOC,
#endif
- .priv_auto_alloc_size = sizeof(struct uart_port),
+ .priv_auto = sizeof(struct uart_port),
};
#else /* CONFIG_DM_SERIAL */
.id = UCLASS_SERIAL,
.of_match = sifive_serial_ids,
.ofdata_to_platdata = sifive_serial_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct sifive_uart_platdata),
+ .platdata_auto = sizeof(struct sifive_uart_platdata),
.probe = sifive_serial_probe,
.ops = &sifive_serial_ops,
};
.of_match = sti_serial_of_match,
.ops = &sti_asc_serial_ops,
.probe = sti_asc_serial_probe,
- .priv_auto_alloc_size = sizeof(struct sti_asc_serial),
+ .priv_auto = sizeof(struct sti_asc_serial),
};
.id = UCLASS_SERIAL,
.of_match = of_match_ptr(stm32_serial_id),
.ofdata_to_platdata = of_match_ptr(stm32_serial_ofdata_to_platdata),
- .platdata_auto_alloc_size = sizeof(struct stm32x7_serial_platdata),
+ .platdata_auto = sizeof(struct stm32x7_serial_platdata),
.ops = &stm32_serial_ops,
.probe = stm32_serial_probe,
#if !CONFIG_IS_ENABLED(OF_CONTROL)
.id = UCLASS_SERIAL,
.of_match = uniphier_uart_of_match,
.probe = uniphier_serial_probe,
- .priv_auto_alloc_size = sizeof(struct uniphier_serial_priv),
+ .priv_auto = sizeof(struct uniphier_serial_priv),
.ops = &uniphier_serial_ops,
};
#if CONFIG_IS_ENABLED(OF_CONTROL)
.of_match = xen_serial_ids,
#endif
- .priv_auto_alloc_size = sizeof(struct xen_uart_priv),
+ .priv_auto = sizeof(struct xen_uart_priv),
.probe = xen_serial_probe,
.ops = &xen_serial_ops,
#if !CONFIG_IS_ENABLED(OF_CONTROL)
.id = UCLASS_SERIAL,
.of_match = uartlite_serial_ids,
.ofdata_to_platdata = uartlite_serial_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct uartlite_platdata),
+ .platdata_auto = sizeof(struct uartlite_platdata),
.probe = uartlite_serial_probe,
.ops = &uartlite_serial_ops,
};
.id = UCLASS_SERIAL,
.of_match = zynq_serial_ids,
.ofdata_to_platdata = zynq_serial_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct zynq_uart_platdata),
+ .platdata_auto = sizeof(struct zynq_uart_platdata),
.probe = zynq_serial_probe,
.ops = &zynq_serial_ops,
};
.ops = &soc_ti_k3_ops,
.of_match = soc_ti_k3_ids,
.probe = soc_ti_k3_probe,
- .platdata_auto_alloc_size = sizeof(struct soc_ti_k3_platdata),
+ .platdata_auto = sizeof(struct soc_ti_k3_platdata),
};
.id = UCLASS_MISC,
.of_match = knav_ringacc_ids,
.probe = k3_nav_ringacc_probe,
- .priv_auto_alloc_size = sizeof(struct k3_nav_ringacc),
+ .priv_auto = sizeof(struct k3_nav_ringacc),
};
.of_match = broadwell_i2s_ids,
.probe = broadwell_i2s_probe,
.ops = &broadwell_i2s_ops,
- .priv_auto_alloc_size = sizeof(struct broadwell_i2s_priv),
+ .priv_auto = sizeof(struct broadwell_i2s_priv),
};
.name = "hda_codec",
.id = UCLASS_SOUND,
.ops = &hda_codec_ops,
- .priv_auto_alloc_size = sizeof(struct hda_codec_priv),
+ .priv_auto = sizeof(struct hda_codec_priv),
.probe = hda_codec_init,
};
UCLASS_DRIVER(i2s) = {
.id = UCLASS_I2S,
.name = "i2s",
- .per_device_auto_alloc_size = sizeof(struct i2s_uc_priv),
+ .per_device_auto = sizeof(struct i2s_uc_priv),
};
.of_match = bd82x6x_azalia_ids,
.probe = bd82x6x_azalia_probe,
.ops = &bd82x6x_azalia_ops,
- .priv_auto_alloc_size = sizeof(struct hda_codec_priv),
+ .priv_auto = sizeof(struct hda_codec_priv),
};
.of_match = max98088_ids,
.probe = max98088_probe,
.ops = &max98088_ops,
- .priv_auto_alloc_size = sizeof(struct maxim_priv),
+ .priv_auto = sizeof(struct maxim_priv),
};
.of_match = max98090_ids,
.probe = max98090_probe,
.ops = &max98090_ops,
- .priv_auto_alloc_size = sizeof(struct maxim_priv),
+ .priv_auto = sizeof(struct maxim_priv),
};
.of_match = max98095_ids,
.probe = max98095_probe,
.ops = &max98095_ops,
- .priv_auto_alloc_size = sizeof(struct maxim_priv),
+ .priv_auto = sizeof(struct maxim_priv),
};
.of_match = rt5677_ids,
.ops = &rt5677_ops,
.probe = rt5677_probe,
- .priv_auto_alloc_size = sizeof(struct rt5677_priv),
+ .priv_auto = sizeof(struct rt5677_priv),
};
.id = UCLASS_AUDIO_CODEC,
.of_match = sandbox_codec_ids,
.ops = &sandbox_codec_ops,
- .priv_auto_alloc_size = sizeof(struct sandbox_codec_priv),
+ .priv_auto = sizeof(struct sandbox_codec_priv),
};
static const struct i2s_ops sandbox_i2s_ops = {
.of_match = sandbox_i2s_ids,
.ops = &sandbox_i2s_ops,
.probe = sandbox_i2s_probe,
- .priv_auto_alloc_size = sizeof(struct sandbox_i2s_priv),
+ .priv_auto = sizeof(struct sandbox_i2s_priv),
};
static const struct sound_ops sandbox_sound_ops = {
.id = UCLASS_SOUND,
.of_match = sandbox_sound_ids,
.ops = &sandbox_sound_ops,
- .priv_auto_alloc_size = sizeof(struct sandbox_sound_priv),
+ .priv_auto = sizeof(struct sandbox_sound_priv),
.probe = sandbox_sound_probe,
};
UCLASS_DRIVER(sound) = {
.id = UCLASS_SOUND,
.name = "sound",
- .per_device_auto_alloc_size = sizeof(struct sound_uc_priv),
+ .per_device_auto = sizeof(struct sound_uc_priv),
};
.of_match = tegra_ahub_ids,
.ops = &tegra_ahub_ops,
.probe = tegra_ahub_probe,
- .priv_auto_alloc_size = sizeof(struct tegra_ahub_priv),
+ .priv_auto = sizeof(struct tegra_ahub_priv),
};
.of_match = wm8994_ids,
.probe = wm8994_probe,
.ops = &wm8994_ops,
- .priv_auto_alloc_size = sizeof(struct wm8994_priv),
+ .priv_auto = sizeof(struct wm8994_priv),
};
.of_match = altera_spi_ids,
.ops = &altera_spi_ops,
.ofdata_to_platdata = altera_spi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct altera_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct altera_spi_priv),
+ .platdata_auto = sizeof(struct altera_spi_platdata),
+ .priv_auto = sizeof(struct altera_spi_priv),
.probe = altera_spi_probe,
};
.of_match = atcspi200_spi_ids,
.ops = &atcspi200_spi_ops,
.ofdata_to_platdata = atcspi200_ofdata_to_platadata,
- .priv_auto_alloc_size = sizeof(struct nds_spi_slave),
+ .priv_auto = sizeof(struct nds_spi_slave),
.probe = atcspi200_spi_probe,
};
.id = UCLASS_SPI,
.of_match = ath79_spi_ids,
.ops = &ath79_spi_ops,
- .priv_auto_alloc_size = sizeof(struct ath79_spi_priv),
+ .priv_auto = sizeof(struct ath79_spi_priv),
.probe = ath79_spi_probe,
};
.id = UCLASS_SPI,
.of_match = atmel_qspi_ids,
.ops = &atmel_qspi_ops,
- .priv_auto_alloc_size = sizeof(struct atmel_qspi),
+ .priv_auto = sizeof(struct atmel_qspi),
.probe = atmel_qspi_probe,
};
.id = UCLASS_SPI,
.of_match = atmel_spi_ids,
.ops = &atmel_spi_ops,
- .platdata_auto_alloc_size = sizeof(struct atmel_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct atmel_spi_priv),
+ .platdata_auto = sizeof(struct atmel_spi_platdata),
+ .priv_auto = sizeof(struct atmel_spi_priv),
.probe = atmel_spi_probe,
};
.id = UCLASS_SPI,
.of_match = bcm63xx_hsspi_ids,
.ops = &bcm63xx_hsspi_ops,
- .priv_auto_alloc_size = sizeof(struct bcm63xx_hsspi_priv),
+ .priv_auto = sizeof(struct bcm63xx_hsspi_priv),
.child_pre_probe = bcm63xx_hsspi_child_pre_probe,
.probe = bcm63xx_hsspi_probe,
};
.id = UCLASS_SPI,
.of_match = bcm63xx_spi_ids,
.ops = &bcm63xx_spi_ops,
- .priv_auto_alloc_size = sizeof(struct bcm63xx_spi_priv),
+ .priv_auto = sizeof(struct bcm63xx_spi_priv),
.child_pre_probe = bcm63xx_spi_child_pre_probe,
.probe = bcm63xx_spi_probe,
};
.ops = &bcmstb_spi_ops,
.ofdata_to_platdata = bcmstb_spi_ofdata_to_platdata,
.probe = bcmstb_spi_probe,
- .platdata_auto_alloc_size = sizeof(struct bcmstb_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct bcmstb_spi_priv),
+ .platdata_auto = sizeof(struct bcmstb_spi_platdata),
+ .priv_auto = sizeof(struct bcmstb_spi_priv),
};
.of_match = cadence_spi_ids,
.ops = &cadence_spi_ops,
.ofdata_to_platdata = cadence_spi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct cadence_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct cadence_spi_priv),
+ .platdata_auto = sizeof(struct cadence_spi_platdata),
+ .priv_auto = sizeof(struct cadence_spi_priv),
.probe = cadence_spi_probe,
.remove = cadence_spi_remove,
.flags = DM_FLAG_OS_PREPARE,
#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
.of_match = coldfire_spi_ids,
.ofdata_to_platdata = coldfire_dspi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct coldfire_spi_platdata),
+ .platdata_auto = sizeof(struct coldfire_spi_platdata),
#endif
.probe = coldfire_spi_probe,
.ops = &coldfire_spi_ops,
- .priv_auto_alloc_size = sizeof(struct coldfire_spi_priv),
+ .priv_auto = sizeof(struct coldfire_spi_priv),
};
#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
.of_match = davinci_spi_ids,
.ofdata_to_platdata = davinci_ofdata_to_platadata,
- .platdata_auto_alloc_size = sizeof(struct davinci_spi_platdata),
+ .platdata_auto = sizeof(struct davinci_spi_platdata),
#endif
.probe = davinci_spi_probe,
.ops = &davinci_spi_ops,
- .priv_auto_alloc_size = sizeof(struct davinci_spi_slave),
+ .priv_auto = sizeof(struct davinci_spi_slave),
};
.of_match = dw_spi_ids,
.ops = &dw_spi_ops,
.ofdata_to_platdata = dw_spi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct dw_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct dw_spi_priv),
+ .platdata_auto = sizeof(struct dw_spi_platdata),
+ .priv_auto = sizeof(struct dw_spi_priv),
.probe = dw_spi_probe,
.remove = dw_spi_remove,
};
.of_match = exynos_spi_ids,
.ops = &exynos_spi_ops,
.ofdata_to_platdata = exynos_spi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct exynos_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct exynos_spi_priv),
+ .platdata_auto = sizeof(struct exynos_spi_platdata),
+ .priv_auto = sizeof(struct exynos_spi_priv),
.probe = exynos_spi_probe,
};
.of_match = fsl_dspi_ids,
.ops = &fsl_dspi_ops,
.ofdata_to_platdata = fsl_dspi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct fsl_dspi_platdata),
- .priv_auto_alloc_size = sizeof(struct fsl_dspi_priv),
+ .platdata_auto = sizeof(struct fsl_dspi_platdata),
+ .priv_auto = sizeof(struct fsl_dspi_priv),
.probe = fsl_dspi_probe,
.child_pre_probe = fsl_dspi_child_pre_probe,
.bind = fsl_dspi_bind,
.ofdata_to_platdata = fsl_espi_ofdata_to_platdata,
#endif
.ops = &fsl_espi_ops,
- .platdata_auto_alloc_size = sizeof(struct fsl_espi_platdata),
- .priv_auto_alloc_size = sizeof(struct fsl_spi_slave),
+ .platdata_auto = sizeof(struct fsl_espi_platdata),
+ .priv_auto = sizeof(struct fsl_spi_slave),
.probe = fsl_espi_probe,
.child_pre_probe = fsl_espi_child_pre_probe,
};
.id = UCLASS_SPI,
.of_match = fsl_qspi_ids,
.ops = &fsl_qspi_ops,
- .priv_auto_alloc_size = sizeof(struct fsl_qspi),
+ .priv_auto = sizeof(struct fsl_qspi),
.probe = fsl_qspi_probe,
};
.of_match = ich_spi_ids,
.ops = &ich_spi_ops,
.ofdata_to_platdata = ich_spi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct ich_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct ich_spi_priv),
+ .platdata_auto = sizeof(struct ich_spi_platdata),
+ .priv_auto = sizeof(struct ich_spi_priv),
.child_pre_probe = ich_spi_child_pre_probe,
.probe = ich_spi_probe,
.remove = ich_spi_remove,
.of_match = mvebu_spi_ids,
.ops = &mvebu_spi_ops,
.ofdata_to_platdata = mvebu_spi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct mvebu_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct mvebu_spi_priv),
+ .platdata_auto = sizeof(struct mvebu_spi_platdata),
+ .priv_auto = sizeof(struct mvebu_spi_priv),
.probe = mvebu_spi_probe,
};
.of_match = meson_spifc_ids,
.ops = &meson_spifc_ops,
.probe = meson_spifc_probe,
- .priv_auto_alloc_size = sizeof(struct meson_spifc_priv),
+ .priv_auto = sizeof(struct meson_spifc_priv),
};
.ops = &mpc8xxx_spi_ops,
.ofdata_to_platdata = mpc8xxx_spi_ofdata_to_platdata,
.probe = mpc8xxx_spi_probe,
- .priv_auto_alloc_size = sizeof(struct mpc8xxx_priv),
+ .priv_auto = sizeof(struct mpc8xxx_priv),
};
.id = UCLASS_SPI,
.of_match = mscc_bb_ids,
.ops = &mscc_bb_ops,
- .priv_auto_alloc_size = sizeof(struct mscc_bb_priv),
+ .priv_auto = sizeof(struct mscc_bb_priv),
.probe = mscc_bb_spi_probe,
};
.id = UCLASS_SPI,
.of_match = mt7621_spi_ids,
.ops = &mt7621_spi_ops,
- .priv_auto_alloc_size = sizeof(struct mt7621_spi),
+ .priv_auto = sizeof(struct mt7621_spi),
.probe = mt7621_spi_probe,
};
.id = UCLASS_SPI,
.of_match = mtk_snfi_spi_ids,
.ops = &mtk_snfi_spi_ops,
- .priv_auto_alloc_size = sizeof(struct mtk_snfi_priv),
+ .priv_auto = sizeof(struct mtk_snfi_priv),
.probe = mtk_snfi_spi_probe,
};
.of_match = mvebu_spi_ids,
.ops = &mvebu_spi_ops,
.ofdata_to_platdata = mvebu_spi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct mvebu_spi_platdata),
+ .platdata_auto = sizeof(struct mvebu_spi_platdata),
.probe = mvebu_spi_probe,
.remove = mvebu_spi_remove,
};
.id = UCLASS_SPI,
.of_match = mxc_spi_ids,
.ops = &mxc_spi_ops,
- .platdata_auto_alloc_size = sizeof(struct mxc_spi_slave),
+ .platdata_auto = sizeof(struct mxc_spi_slave),
.probe = mxc_spi_probe,
};
#endif
.of_match = mxs_spi_ids,
.ofdata_to_platdata = mxs_ofdata_to_platdata,
#endif
- .platdata_auto_alloc_size = sizeof(struct mxs_spi_platdata),
+ .platdata_auto = sizeof(struct mxs_spi_platdata),
.ops = &mxs_spi_ops,
- .priv_auto_alloc_size = sizeof(struct mxs_spi_priv),
+ .priv_auto = sizeof(struct mxs_spi_priv),
.probe = mxs_spi_probe,
};
.of_match = nxp_fspi_ids,
.ops = &nxp_fspi_ops,
.ofdata_to_platdata = nxp_fspi_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct nxp_fspi),
+ .priv_auto = sizeof(struct nxp_fspi),
.probe = nxp_fspi_probe,
};
.id = UCLASS_SPI,
.of_match = octeon_spi_ids,
.probe = octeon_spi_probe,
- .priv_auto_alloc_size = sizeof(struct octeon_spi),
+ .priv_auto = sizeof(struct octeon_spi),
.ops = &octeon_spi_ops,
};
#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
.of_match = omap3_spi_ids,
.ofdata_to_platdata = omap3_spi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct omap3_spi_plat),
+ .platdata_auto = sizeof(struct omap3_spi_plat),
#endif
.probe = omap3_spi_probe,
.ops = &omap3_spi_ops,
- .priv_auto_alloc_size = sizeof(struct omap3_spi_priv),
+ .priv_auto = sizeof(struct omap3_spi_priv),
};
.id = UCLASS_SPI,
.of_match = pic32_spi_ids,
.ops = &pic32_spi_ops,
- .priv_auto_alloc_size = sizeof(struct pic32_spi_priv),
+ .priv_auto = sizeof(struct pic32_spi_priv),
.probe = pic32_spi_probe,
};
.ofdata_to_platdata = pl022_spi_ofdata_to_platdata,
#endif
.ops = &pl022_spi_ops,
- .platdata_auto_alloc_size = sizeof(struct pl022_spi_pdata),
- .priv_auto_alloc_size = sizeof(struct pl022_spi_slave),
+ .platdata_auto = sizeof(struct pl022_spi_pdata),
+ .priv_auto = sizeof(struct pl022_spi_slave),
.probe = pl022_spi_probe,
};
.of_match = rpc_spi_ids,
.ops = &rpc_spi_ops,
.ofdata_to_platdata = rpc_spi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct rpc_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct rpc_spi_priv),
+ .platdata_auto = sizeof(struct rpc_spi_platdata),
+ .priv_auto = sizeof(struct rpc_spi_priv),
.bind = rpc_spi_bind,
.probe = rpc_spi_probe,
};
.of_match = rockchip_spi_ids,
.ops = &rockchip_spi_ops,
.ofdata_to_platdata = rockchip_spi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct rockchip_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct rockchip_spi_priv),
+ .platdata_auto = sizeof(struct rockchip_spi_platdata),
+ .priv_auto = sizeof(struct rockchip_spi_priv),
.probe = rockchip_spi_probe,
};
.of_match = sh_qspi_ids,
.ops = &sh_qspi_ops,
.ofdata_to_platdata = sh_qspi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct sh_qspi_slave),
+ .platdata_auto = sizeof(struct sh_qspi_slave),
.probe = sh_qspi_probe,
};
#endif
.of_match = soft_spi_ids,
.ops = &soft_spi_ops,
.ofdata_to_platdata = soft_spi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct soft_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct soft_spi_priv),
+ .platdata_auto = sizeof(struct soft_spi_platdata),
+ .priv_auto = sizeof(struct soft_spi_priv),
.probe = soft_spi_probe,
};
.id = UCLASS_SPI,
.of_match = qup_spi_ids,
.ops = &qup_spi_ops,
- .priv_auto_alloc_size = sizeof(struct qup_spi_priv),
+ .priv_auto = sizeof(struct qup_spi_priv),
.probe = qup_spi_probe,
};
.id = UCLASS_SPI,
.of_match = sifive_spi_ids,
.ops = &sifive_spi_ops,
- .priv_auto_alloc_size = sizeof(struct sifive_spi),
+ .priv_auto = sizeof(struct sifive_spi),
.probe = sifive_spi_probe,
};
.of_match = sun4i_spi_ids,
.ops = &sun4i_spi_ops,
.ofdata_to_platdata = sun4i_spi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct sun4i_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct sun4i_spi_priv),
+ .platdata_auto = sizeof(struct sun4i_spi_platdata),
+ .priv_auto = sizeof(struct sun4i_spi_priv),
.probe = sun4i_spi_probe,
};
#endif
.post_probe = spi_post_probe,
.child_pre_probe = spi_child_pre_probe,
- .per_device_auto_alloc_size = sizeof(struct dm_spi_bus),
- .per_child_auto_alloc_size = sizeof(struct spi_slave),
- .per_child_platdata_auto_alloc_size =
+ .per_device_auto = sizeof(struct dm_spi_bus),
+ .per_child_auto = sizeof(struct spi_slave),
+ .per_child_platdata_auto =
sizeof(struct dm_spi_slave_platdata),
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
.child_post_bind = spi_child_post_bind,
.id = UCLASS_SPI,
.of_match = stm32_qspi_ids,
.ops = &stm32_qspi_ops,
- .priv_auto_alloc_size = sizeof(struct stm32_qspi_priv),
+ .priv_auto = sizeof(struct stm32_qspi_priv),
.probe = stm32_qspi_probe,
};
.id = UCLASS_SPI,
.of_match = stm32_spi_ids,
.ops = &stm32_spi_ops,
- .priv_auto_alloc_size = sizeof(struct stm32_spi_priv),
+ .priv_auto = sizeof(struct stm32_spi_priv),
.probe = stm32_spi_probe,
.remove = stm32_spi_remove,
};
.of_match = tegra114_spi_ids,
.ops = &tegra114_spi_ops,
.ofdata_to_platdata = tegra114_spi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct tegra_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct tegra114_spi_priv),
+ .platdata_auto = sizeof(struct tegra_spi_platdata),
+ .priv_auto = sizeof(struct tegra114_spi_priv),
.probe = tegra114_spi_probe,
};
.of_match = tegra20_sflash_ids,
.ops = &tegra20_sflash_ops,
.ofdata_to_platdata = tegra20_sflash_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct tegra_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct tegra20_sflash_priv),
+ .platdata_auto = sizeof(struct tegra_spi_platdata),
+ .priv_auto = sizeof(struct tegra20_sflash_priv),
.probe = tegra20_sflash_probe,
};
.of_match = tegra30_spi_ids,
.ops = &tegra30_spi_ops,
.ofdata_to_platdata = tegra30_spi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct tegra_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct tegra30_spi_priv),
+ .platdata_auto = sizeof(struct tegra_spi_platdata),
+ .priv_auto = sizeof(struct tegra30_spi_priv),
.probe = tegra30_spi_probe,
};
.of_match = tegra210_qspi_ids,
.ops = &tegra210_qspi_ops,
.ofdata_to_platdata = tegra210_qspi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct tegra_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct tegra210_qspi_priv),
- .per_child_auto_alloc_size = sizeof(struct spi_slave),
+ .platdata_auto = sizeof(struct tegra_spi_platdata),
+ .priv_auto = sizeof(struct tegra210_qspi_priv),
+ .per_child_auto = sizeof(struct spi_slave),
.probe = tegra210_qspi_probe,
};
.of_match = ti_qspi_ids,
.ops = &ti_qspi_ops,
.ofdata_to_platdata = ti_qspi_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct ti_qspi_priv),
+ .priv_auto = sizeof(struct ti_qspi_priv),
.probe = ti_qspi_probe,
};
.of_match = uniphier_spi_ids,
.ops = &uniphier_spi_ops,
.ofdata_to_platdata = uniphier_spi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct uniphier_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct uniphier_spi_priv),
+ .platdata_auto = sizeof(struct uniphier_spi_platdata),
+ .priv_auto = sizeof(struct uniphier_spi_priv),
.probe = uniphier_spi_probe,
};
.id = UCLASS_SPI,
.of_match = xilinx_spi_ids,
.ops = &xilinx_spi_ops,
- .priv_auto_alloc_size = sizeof(struct xilinx_spi_priv),
+ .priv_auto = sizeof(struct xilinx_spi_priv),
.probe = xilinx_spi_probe,
};
.of_match = zynq_qspi_ids,
.ops = &zynq_qspi_ops,
.ofdata_to_platdata = zynq_qspi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct zynq_qspi_platdata),
- .priv_auto_alloc_size = sizeof(struct zynq_qspi_priv),
+ .platdata_auto = sizeof(struct zynq_qspi_platdata),
+ .priv_auto = sizeof(struct zynq_qspi_priv),
.probe = zynq_qspi_probe,
};
.of_match = zynq_spi_ids,
.ops = &zynq_spi_ops,
.ofdata_to_platdata = zynq_spi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct zynq_spi_platdata),
- .priv_auto_alloc_size = sizeof(struct zynq_spi_priv),
+ .platdata_auto = sizeof(struct zynq_spi_platdata),
+ .priv_auto = sizeof(struct zynq_spi_priv),
.probe = zynq_spi_probe,
};
.of_match = zynqmp_qspi_ids,
.ops = &zynqmp_qspi_ops,
.ofdata_to_platdata = zynqmp_qspi_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct zynqmp_qspi_platdata),
- .priv_auto_alloc_size = sizeof(struct zynqmp_qspi_priv),
+ .platdata_auto = sizeof(struct zynqmp_qspi_platdata),
+ .priv_auto = sizeof(struct zynqmp_qspi_priv),
.probe = zynqmp_qspi_probe,
};
.of_match = msm_spmi_ids,
.ops = &msm_spmi_ops,
.probe = msm_spmi_probe,
- .priv_auto_alloc_size = sizeof(struct msm_spmi_priv),
+ .priv_auto = sizeof(struct msm_spmi_priv),
};
.of_match = sandbox_spmi_ids,
.ops = &sandbox_spmi_ops,
.probe = sandbox_spmi_probe,
- .priv_auto_alloc_size = sizeof(struct sandbox_spmi_priv),
+ .priv_auto = sizeof(struct sandbox_spmi_priv),
};
.id = UCLASS_SYSINFO,
.of_match = sysinfo_gazerbeam_ids,
.ops = &sysinfo_gazerbeam_ops,
- .priv_auto_alloc_size = sizeof(struct sysinfo_gazerbeam_priv),
+ .priv_auto = sizeof(struct sysinfo_gazerbeam_priv),
.probe = sysinfo_gazerbeam_probe,
};
.id = UCLASS_SYSINFO,
.of_match = sysinfo_sandbox_ids,
.ops = &sysinfo_sandbox_ops,
- .priv_auto_alloc_size = sizeof(struct sysinfo_sandbox_priv),
+ .priv_auto = sizeof(struct sysinfo_sandbox_priv),
.probe = sysinfo_sandbox_probe,
};
.id = UCLASS_SYSRESET,
.ops = &poweroff_gpio_ops,
.probe = poweroff_gpio_probe,
- .priv_auto_alloc_size = sizeof(struct poweroff_gpio_info),
+ .priv_auto = sizeof(struct poweroff_gpio_info),
.of_match = poweroff_gpio_ids,
};
.id = UCLASS_SYSRESET,
.of_match = ti_sci_sysreset_of_match,
.probe = ti_sci_sysreset_probe,
- .priv_auto_alloc_size = sizeof(struct ti_sci_sysreset_data),
+ .priv_auto = sizeof(struct ti_sci_sysreset_data),
.ops = &ti_sci_sysreset_ops,
};
.name = "gpio_restart",
.of_match = led_gpio_ids,
.ops = &gpio_reboot_ops,
- .priv_auto_alloc_size = sizeof(struct gpio_reboot_priv),
+ .priv_auto = sizeof(struct gpio_reboot_priv),
.probe = gpio_reboot_probe,
};
U_BOOT_DRIVER(sysreset_octeon) = {
.id = UCLASS_SYSRESET,
.name = "octeon_sysreset",
- .priv_auto_alloc_size = sizeof(struct octeon_sysreset_data),
+ .priv_auto = sizeof(struct octeon_sysreset_data),
.ops = &octeon_sysreset,
.probe = octeon_sysreset_probe,
.of_match = octeon_sysreset_ids,
.name = "resetctl_reboot",
.of_match = resetctl_reboot_ids,
.ops = &resetctl_reboot_ops,
- .priv_auto_alloc_size = sizeof(struct resetctl_reboot_priv),
+ .priv_auto = sizeof(struct resetctl_reboot_priv),
.probe = resetctl_reboot_probe,
};
U_BOOT_DRIVER(sysreset_socfpga) = {
.id = UCLASS_SYSRESET,
.name = "socfpga_sysreset",
- .priv_auto_alloc_size = sizeof(struct socfpga_sysreset_data),
+ .priv_auto = sizeof(struct socfpga_sysreset_data),
.ops = &socfpga_sysreset,
.probe = socfpga_sysreset_probe,
};
.ops = &sti_sysreset,
.probe = sti_sysreset_probe,
.of_match = sti_sysreset_ids,
- .priv_auto_alloc_size = sizeof(struct sti_sysreset_priv),
+ .priv_auto = sizeof(struct sti_sysreset_priv),
};
.id = UCLASS_SYSRESET,
.of_match = syscon_reboot_ids,
.probe = syscon_reboot_probe,
- .priv_auto_alloc_size = sizeof(struct syscon_reboot_priv),
+ .priv_auto = sizeof(struct syscon_reboot_priv),
.ops = &syscon_reboot_ops,
};
.id = UCLASS_SYSRESET,
.of_match = wdt_reboot_ids,
.ops = &wdt_reboot_ops,
- .priv_auto_alloc_size = sizeof(struct wdt_reboot_priv),
+ .priv_auto = sizeof(struct wdt_reboot_priv),
.probe = wdt_reboot_probe,
};
.of_match = x86_sysreset_ids,
.ops = &x86_sysreset_ops,
.probe = x86_sysreset_probe,
- .platdata_auto_alloc_size = sizeof(struct x86_sysreset_platdata),
+ .platdata_auto = sizeof(struct x86_sysreset_platdata),
};
.ofdata_to_platdata = optee_ofdata_to_platdata,
.probe = optee_probe,
.ops = &optee_ops,
- .platdata_auto_alloc_size = sizeof(struct optee_pdata),
- .priv_auto_alloc_size = sizeof(struct optee_private),
+ .platdata_auto = sizeof(struct optee_pdata),
+ .priv_auto = sizeof(struct optee_private),
};
.id = UCLASS_TEE,
.of_match = sandbox_tee_match,
.ops = &sandbox_tee_ops,
- .priv_auto_alloc_size = sizeof(struct sandbox_tee_state),
+ .priv_auto = sizeof(struct sandbox_tee_state),
.probe = sandbox_tee_probe,
.remove = sandbox_tee_remove,
};
UCLASS_DRIVER(tee) = {
.id = UCLASS_TEE,
.name = "tee",
- .per_device_auto_alloc_size = sizeof(struct tee_uclass_priv),
+ .per_device_auto = sizeof(struct tee_uclass_priv),
.pre_probe = tee_pre_probe,
.pre_remove = tee_pre_remove,
};
.bind = imx_sc_thermal_bind,
.probe = imx_sc_thermal_probe,
.ofdata_to_platdata = imx_sc_thermal_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct imx_sc_thermal_plat),
+ .platdata_auto = sizeof(struct imx_sc_thermal_plat),
.flags = DM_FLAG_PRE_RELOC,
};
.id = UCLASS_THERMAL,
.ops = &imx_thermal_ops,
.probe = imx_thermal_probe,
- .priv_auto_alloc_size = sizeof(struct thermal_data),
+ .priv_auto = sizeof(struct thermal_data),
.flags = DM_FLAG_PRE_RELOC,
};
.of_match = imx_tmu_ids,
.bind = imx_tmu_bind,
.probe = imx_tmu_probe,
- .platdata_auto_alloc_size = sizeof(struct imx_tmu_plat),
+ .platdata_auto = sizeof(struct imx_tmu_plat),
.flags = DM_FLAG_PRE_RELOC,
};
.ops = &ti_thermal_ops,
.probe = ti_bandgap_probe,
.of_match = of_ti_bandgap_match,
- .priv_auto_alloc_size = sizeof(struct ti_bandgap),
+ .priv_auto = sizeof(struct ti_bandgap),
};
.id = UCLASS_TIMER,
.of_match = ag101p_timer_ids,
.ofdata_to_platdata = atftme_timer_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct atftmr_timer_platdata),
+ .platdata_auto = sizeof(struct atftmr_timer_platdata),
.probe = atftmr_timer_probe,
.ops = &ag101p_timer_ops,
};
.id = UCLASS_TIMER,
.of_match = altera_timer_ids,
.ofdata_to_platdata = altera_timer_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct altera_timer_platdata),
+ .platdata_auto = sizeof(struct altera_timer_platdata),
.probe = altera_timer_probe,
.ops = &altera_timer_ops,
};
.of_match = arc_timer_ids,
.probe = arc_timer_probe,
.ops = &arc_timer_ops,
- .priv_auto_alloc_size = sizeof(struct arc_timer_priv),
+ .priv_auto = sizeof(struct arc_timer_priv),
};
.id = UCLASS_TIMER,
.of_match = ast_timer_ids,
.probe = ast_timer_probe,
- .priv_auto_alloc_size = sizeof(struct ast_timer_priv),
+ .priv_auto = sizeof(struct ast_timer_priv),
.ofdata_to_platdata = ast_timer_ofdata_to_platdata,
.ops = &ast_timer_ops,
};
.id = UCLASS_TIMER,
.of_match = atcpit_timer_ids,
.ofdata_to_platdata = atcpit_timer_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct atcpit_timer_platdata),
+ .platdata_auto = sizeof(struct atcpit_timer_platdata),
.probe = atcpit_timer_probe,
.ops = &atcpit_timer_ops,
};
.id = UCLASS_TIMER,
.of_match = atmel_pit_ids,
.ofdata_to_platdata = atmel_pit_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct atmel_pit_platdata),
+ .platdata_auto = sizeof(struct atmel_pit_platdata),
.probe = atmel_pit_probe,
.ops = &atmel_pit_ops,
};
.id = UCLASS_TIMER,
.of_match = cadence_ttc_ids,
.ofdata_to_platdata = cadence_ttc_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct cadence_ttc_priv),
+ .priv_auto = sizeof(struct cadence_ttc_priv),
.probe = cadence_ttc_probe,
.ops = &cadence_ttc_ops,
};
.of_match = dw_apb_timer_ids,
.ofdata_to_platdata = dw_apb_timer_ofdata_to_platdata,
.remove = dw_apb_timer_remove,
- .priv_auto_alloc_size = sizeof(struct dw_apb_timer_priv),
+ .priv_auto = sizeof(struct dw_apb_timer_priv),
};
.name = "mchp-pit64b",
.id = UCLASS_TIMER,
.of_match = mchp_pit64b_ids,
- .priv_auto_alloc_size = sizeof(struct mchp_pit64b_priv),
+ .priv_auto = sizeof(struct mchp_pit64b_priv),
.probe = mchp_pit64b_probe,
.ops = &mchp_pit64b_ops,
.flags = DM_FLAG_PRE_RELOC,
.of_match = mpc83xx_timer_ids,
.probe = mpc83xx_timer_probe,
.ops = &mpc83xx_timer_ops,
- .priv_auto_alloc_size = sizeof(struct mpc83xx_timer_priv),
+ .priv_auto = sizeof(struct mpc83xx_timer_priv),
};
.name = "mtk_timer",
.id = UCLASS_TIMER,
.of_match = mtk_timer_ids,
- .priv_auto_alloc_size = sizeof(struct mtk_timer_priv),
+ .priv_auto = sizeof(struct mtk_timer_priv),
.probe = mtk_timer_probe,
.ops = &mtk_timer_ops,
.flags = DM_FLAG_PRE_RELOC,
.name = "nomadik_mtu",
.id = UCLASS_TIMER,
.of_match = nomadik_mtu_ids,
- .priv_auto_alloc_size = sizeof(struct nomadik_mtu_priv),
+ .priv_auto = sizeof(struct nomadik_mtu_priv),
.probe = nomadik_mtu_probe,
.ops = &nomadik_mtu_ops,
};
.id = UCLASS_TIMER,
.of_match = omap_timer_ids,
.ofdata_to_platdata = omap_timer_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct omap_timer_priv),
+ .priv_auto = sizeof(struct omap_timer_priv),
.probe = omap_timer_probe,
.ops = &omap_timer_ops,
};
.probe = ostm_probe,
.of_match = ostm_ids,
.ofdata_to_platdata = ostm_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct ostm_priv),
+ .priv_auto = sizeof(struct ostm_priv),
};
.of_match = rockchip_timer_ids,
.probe = rockchip_timer_probe,
.ops = &rockchip_timer_ops,
- .priv_auto_alloc_size = sizeof(struct rockchip_timer_priv),
+ .priv_auto = sizeof(struct rockchip_timer_priv),
#if CONFIG_IS_ENABLED(OF_PLATDATA)
- .platdata_auto_alloc_size = sizeof(struct rockchip_timer_plat),
+ .platdata_auto = sizeof(struct rockchip_timer_plat),
#endif
.ofdata_to_platdata = rockchip_clk_ofdata_to_platdata,
};
.name = "sti_timer",
.id = UCLASS_TIMER,
.of_match = sti_timer_ids,
- .priv_auto_alloc_size = sizeof(struct sti_timer_priv),
+ .priv_auto = sizeof(struct sti_timer_priv),
.probe = sti_timer_probe,
.ops = &sti_timer_ops,
};
.name = "stm32_timer",
.id = UCLASS_TIMER,
.of_match = stm32_timer_ids,
- .priv_auto_alloc_size = sizeof(struct stm32_timer_priv),
+ .priv_auto = sizeof(struct stm32_timer_priv),
.probe = stm32_timer_probe,
.ops = &stm32_timer_ops,
};
.pre_probe = timer_pre_probe,
.flags = DM_UC_FLAG_SEQ_ALIAS,
.post_probe = timer_post_probe,
- .per_device_auto_alloc_size = sizeof(struct timer_dev_priv),
+ .per_device_auto = sizeof(struct timer_dev_priv),
};
.ofdata_to_platdata = cr50_i2c_ofdata_to_platdata,
.probe = cr50_i2c_probe,
.remove = cr50_i2c_cleanup,
- .priv_auto_alloc_size = sizeof(struct cr50_priv),
+ .priv_auto = sizeof(struct cr50_priv),
ACPI_OPS_PTR(&cr50_acpi_ops)
.flags = DM_FLAG_OS_PREPARE,
};
#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
.post_bind = dm_scan_fdt_dev,
#endif
- .per_device_auto_alloc_size = sizeof(struct tpm_chip_priv),
+ .per_device_auto = sizeof(struct tpm_chip_priv),
};
.probe = ftpm_tee_probe,
.remove = ftpm_tee_remove,
.flags = DM_FLAG_OS_PREPARE,
- .priv_auto_alloc_size = sizeof(struct ftpm_tee_private),
+ .priv_auto = sizeof(struct ftpm_tee_private),
};
.of_match = sandbox_tpm2_ids,
.ops = &sandbox_tpm2_ops,
.probe = sandbox_tpm2_probe,
- .priv_auto_alloc_size = sizeof(struct sandbox_tpm2),
+ .priv_auto = sizeof(struct sandbox_tpm2),
};
.ops = &tpm_tis_spi_ops,
.probe = tpm_tis_spi_probe,
.remove = tpm_tis_spi_remove,
- .priv_auto_alloc_size = sizeof(struct tpm_chip),
+ .priv_auto = sizeof(struct tpm_chip),
};
.of_match = tpm_tis_i2c_ids,
.ops = &tpm_tis_i2c_ops,
.probe = tpm_tis_i2c_probe,
- .priv_auto_alloc_size = sizeof(struct tpm_chip),
+ .priv_auto = sizeof(struct tpm_chip),
};
.of_match = tpm_tis_lpc_ids,
.ops = &tpm_tis_lpc_ops,
.probe = tpm_tis_lpc_probe,
- .priv_auto_alloc_size = sizeof(struct tpm_tis_lpc_priv),
+ .priv_auto = sizeof(struct tpm_tis_lpc_priv),
};
.of_match = sandbox_tpm_ids,
.ops = &sandbox_tpm_ops,
.probe = sandbox_tpm_probe,
- .priv_auto_alloc_size = sizeof(struct tpm_state),
+ .priv_auto = sizeof(struct tpm_state),
};
.probe = st33zp24_i2c_probe,
.remove = st33zp24_i2c_remove,
.ops = &st33zp24_i2c_tpm_ops,
- .priv_auto_alloc_size = sizeof(struct tpm_chip),
+ .priv_auto = sizeof(struct tpm_chip),
};
.probe = st33zp24_spi_probe,
.remove = st33zp24_spi_remove,
.ops = &st33zp24_spi_tpm_ops,
- .priv_auto_alloc_size = sizeof(struct tpm_chip),
- .platdata_auto_alloc_size = sizeof(struct st33zp24_spi_phy),
+ .priv_auto = sizeof(struct tpm_chip),
+ .platdata_auto = sizeof(struct st33zp24_spi_phy),
};
UCLASS_DRIVER(ufs) = {
.id = UCLASS_UFS,
.name = "ufs",
- .per_device_auto_alloc_size = sizeof(struct ufs_hba),
+ .per_device_auto = sizeof(struct ufs_hba),
};
.bind = cdns3_bind,
.probe = cdns_ti_probe,
.remove = cdns_ti_remove,
- .platdata_auto_alloc_size = sizeof(struct cdns_ti),
+ .platdata_auto = sizeof(struct cdns_ti),
.flags = DM_FLAG_OS_PREPARE,
};
.of_match = cdns3_ids,
.probe = cdns3_gadget_probe,
.remove = cdns3_gadget_remove,
- .priv_auto_alloc_size = sizeof(struct cdns3_gadget_priv),
+ .priv_auto = sizeof(struct cdns3_gadget_priv),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#endif
.of_match = cdns3_ids,
.probe = cdns3_host_probe,
.remove = cdns3_host_remove,
- .priv_auto_alloc_size = sizeof(struct cdns3_host_priv),
+ .priv_auto = sizeof(struct cdns3_host_priv),
.ops = &xhci_usb_ops,
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.ofdata_to_platdata = dwc3_generic_ofdata_to_platdata,
.probe = dwc3_generic_peripheral_probe,
.remove = dwc3_generic_peripheral_remove,
- .priv_auto_alloc_size = sizeof(struct dwc3_generic_priv),
- .platdata_auto_alloc_size = sizeof(struct dwc3_generic_plat),
+ .priv_auto = sizeof(struct dwc3_generic_priv),
+ .platdata_auto = sizeof(struct dwc3_generic_plat),
};
#endif
.ofdata_to_platdata = dwc3_generic_ofdata_to_platdata,
.probe = dwc3_generic_host_probe,
.remove = dwc3_generic_host_remove,
- .priv_auto_alloc_size = sizeof(struct dwc3_generic_host_priv),
- .platdata_auto_alloc_size = sizeof(struct dwc3_generic_plat),
+ .priv_auto = sizeof(struct dwc3_generic_host_priv),
+ .platdata_auto = sizeof(struct dwc3_generic_plat),
.ops = &xhci_usb_ops,
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.bind = dwc3_glue_bind,
.probe = dwc3_glue_probe,
.remove = dwc3_glue_remove,
- .platdata_auto_alloc_size = sizeof(struct dwc3_glue_data),
+ .platdata_auto = sizeof(struct dwc3_glue_data),
};
.of_match = dwc3_meson_g12a_ids,
.probe = dwc3_meson_g12a_probe,
.remove = dwc3_meson_g12a_remove,
- .platdata_auto_alloc_size = sizeof(struct dwc3_meson_g12a),
+ .platdata_auto = sizeof(struct dwc3_meson_g12a),
};
.of_match = dwc3_meson_gxl_ids,
.probe = dwc3_meson_gxl_probe,
.remove = dwc3_meson_gxl_remove,
- .platdata_auto_alloc_size = sizeof(struct dwc3_meson_gxl),
+ .platdata_auto = sizeof(struct dwc3_meson_gxl),
};
.probe = sandbox_flash_probe,
.ofdata_to_platdata = sandbox_flash_ofdata_to_platdata,
.ops = &sandbox_usb_flash_ops,
- .priv_auto_alloc_size = sizeof(struct sandbox_flash_priv),
- .platdata_auto_alloc_size = sizeof(struct sandbox_flash_plat),
+ .priv_auto = sizeof(struct sandbox_flash_priv),
+ .platdata_auto = sizeof(struct sandbox_flash_plat),
};
.of_match = sandbox_usb_hub_ids,
.bind = sandbox_hub_bind,
.ops = &sandbox_usb_hub_ops,
- .priv_auto_alloc_size = sizeof(struct sandbox_hub_priv),
- .per_child_platdata_auto_alloc_size =
+ .priv_auto = sizeof(struct sandbox_hub_priv),
+ .per_child_platdata_auto =
sizeof(struct sandbox_hub_platdata),
.child_post_bind = sandbox_child_post_bind,
};
.bind = sandbox_keyb_bind,
.probe = sandbox_keyb_probe,
.ops = &sandbox_usb_keyb_ops,
- .priv_auto_alloc_size = sizeof(struct sandbox_keyb_priv),
- .platdata_auto_alloc_size = sizeof(struct sandbox_keyb_plat),
+ .priv_auto = sizeof(struct sandbox_keyb_priv),
+ .platdata_auto = sizeof(struct sandbox_keyb_plat),
};
.id = UCLASS_USB_EMUL,
.name = "usb_emul",
.post_bind = dm_scan_fdt_dev,
- .per_device_platdata_auto_alloc_size = sizeof(struct usb_emul_platdata),
- .per_child_auto_alloc_size = sizeof(struct usb_device),
- .per_child_platdata_auto_alloc_size = sizeof(struct usb_dev_platdata),
+ .per_device_platdata_auto = sizeof(struct usb_emul_platdata),
+ .per_child_auto = sizeof(struct usb_device),
+ .per_child_platdata_auto = sizeof(struct usb_dev_platdata),
};
.id = UCLASS_ETH,
.probe = asix_eth_probe,
.ops = &asix_eth_ops,
- .priv_auto_alloc_size = sizeof(struct asix_private),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct asix_private),
+ .platdata_auto = sizeof(struct eth_pdata),
};
static const struct usb_device_id asix_eth_id_table[] = {
.id = UCLASS_ETH,
.probe = ax88179_eth_probe,
.ops = &ax88179_eth_ops,
- .priv_auto_alloc_size = sizeof(struct asix_private),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct asix_private),
+ .platdata_auto = sizeof(struct eth_pdata),
};
static const struct usb_device_id ax88179_eth_id_table[] = {
.probe = lan75xx_eth_probe,
.remove = lan7x_eth_remove,
.ops = &lan75xx_eth_ops,
- .priv_auto_alloc_size = sizeof(struct lan7x_private),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct lan7x_private),
+ .platdata_auto = sizeof(struct eth_pdata),
};
static const struct usb_device_id lan75xx_eth_id_table[] = {
.probe = lan78xx_eth_probe,
.remove = lan7x_eth_remove,
.ops = &lan78xx_eth_ops,
- .priv_auto_alloc_size = sizeof(struct lan7x_private),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct lan7x_private),
+ .platdata_auto = sizeof(struct eth_pdata),
};
static const struct usb_device_id lan78xx_eth_id_table[] = {
.id = UCLASS_ETH,
.probe = mcs7830_eth_probe,
.ops = &mcs7830_eth_ops,
- .priv_auto_alloc_size = sizeof(struct mcs7830_private),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct mcs7830_private),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.id = UCLASS_ETH,
.probe = r8152_eth_probe,
.ops = &r8152_eth_ops,
- .priv_auto_alloc_size = sizeof(struct r8152),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct r8152),
+ .platdata_auto = sizeof(struct eth_pdata),
};
static const struct usb_device_id r8152_eth_id_table[] = {
.id = UCLASS_ETH,
.probe = smsc95xx_eth_probe,
.ops = &smsc95xx_eth_ops,
- .priv_auto_alloc_size = sizeof(struct smsc95xx_private),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct smsc95xx_private),
+ .platdata_auto = sizeof(struct eth_pdata),
};
static const struct usb_device_id smsc95xx_eth_id_table[] = {
.ofdata_to_platdata = dwc2_udc_otg_ofdata_to_platdata,
.probe = dwc2_udc_otg_probe,
.remove = dwc2_udc_otg_remove,
- .platdata_auto_alloc_size = sizeof(struct dwc2_plat_otg_data),
- .priv_auto_alloc_size = sizeof(struct dwc2_priv_data),
+ .platdata_auto = sizeof(struct dwc2_plat_otg_data),
+ .priv_auto = sizeof(struct dwc2_priv_data),
};
int dwc2_udc_B_session_valid(struct udevice *dev)
.id = UCLASS_ETH,
.probe = usb_eth_probe,
.ops = &usb_eth_ops,
- .priv_auto_alloc_size = sizeof(struct ether_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct ether_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#endif /* CONFIG_DM_ETH */
.of_match = max3420_ids,
.probe = max3420_udc_probe,
.remove = max3420_udc_remove,
- .priv_auto_alloc_size = sizeof(struct max3420_udc),
+ .priv_auto = sizeof(struct max3420_udc),
};
.probe = dwc2_usb_probe,
.remove = dwc2_usb_remove,
.ops = &dwc2_usb_ops,
- .priv_auto_alloc_size = sizeof(struct dwc2_priv),
+ .priv_auto = sizeof(struct dwc2_priv),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#endif
.of_match = dwc3_of_simple_ids,
.probe = dwc3_of_simple_probe,
.remove = dwc3_of_simple_remove,
- .platdata_auto_alloc_size = sizeof(struct dwc3_of_simple),
+ .platdata_auto = sizeof(struct dwc3_of_simple),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = sti_dwc3_glue_probe,
.remove = sti_dwc3_glue_remove,
.bind = sti_dwc3_glue_bind,
- .platdata_auto_alloc_size = sizeof(struct sti_dwc3_glue_platdata),
+ .platdata_auto = sizeof(struct sti_dwc3_glue_platdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = ehci_atmel_probe,
.remove = ehci_deregister,
.ops = &ehci_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(struct ehci_atmel_priv),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct ehci_atmel_priv),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = ehci_usb_probe,
.remove = ehci_usb_remove,
.ops = &ehci_usb_ops,
- .priv_auto_alloc_size = sizeof(struct exynos_ehci),
- .platdata_auto_alloc_size = sizeof(struct exynos_ehci_platdata),
+ .priv_auto = sizeof(struct exynos_ehci),
+ .platdata_auto = sizeof(struct exynos_ehci_platdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = ehci_fsl_probe,
.remove = ehci_deregister,
.ops = &ehci_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(struct ehci_fsl_priv),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct ehci_fsl_priv),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#else
.probe = ehci_usb_probe,
.remove = ehci_usb_remove,
.ops = &ehci_usb_ops,
- .priv_auto_alloc_size = sizeof(struct generic_ehci),
+ .priv_auto = sizeof(struct generic_ehci),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = ehci_mvebu_probe,
.remove = ehci_deregister,
.ops = &ehci_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(struct ehci_mvebu_priv),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct ehci_mvebu_priv),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = ehci_usb_probe,
.remove = ehci_usb_remove,
.ops = &ehci_usb_ops,
- .priv_auto_alloc_size = sizeof(struct msm_ehci_priv),
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct msm_ehci_priv),
+ .platdata_auto = sizeof(struct usb_platdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = ehci_usb_probe,
.remove = ehci_deregister,
.ops = &ehci_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(struct ehci_mx5_priv_data),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct ehci_mx5_priv_data),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#endif /* !CONFIG_IS_ENABLED(DM_USB) */
.probe = ehci_usb_probe,
.remove = ehci_deregister,
.ops = &ehci_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(struct ehci_mx6_priv_data),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct ehci_mx6_priv_data),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#endif
.of_match = omap_ehci_dt_ids,
.probe = omap_ehci_probe,
.ofdata_to_platdata = ehci_usb_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(struct ehci_omap_priv_data),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct ehci_omap_priv_data),
.remove = ehci_deregister,
.ops = &ehci_usb_ops,
.flags = DM_FLAG_ALLOC_PRIV_DMA,
.remove = ehci_pci_remove,
.of_match = ehci_pci_ids,
.ops = &ehci_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(struct ehci_pci_priv),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct ehci_pci_priv),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = ehci_usb_probe,
.remove = ehci_deregister,
.ops = &ehci_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(struct fdt_usb),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct fdt_usb),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.remove = ehci_deregister,
.ops = &ehci_usb_ops,
.ofdata_to_platdata = vf_usb_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(struct ehci_vf_priv_data),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct ehci_vf_priv_data),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#endif
.probe = ehci_zynq_probe,
.remove = ehci_deregister,
.ops = &ehci_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(struct zynq_ehci_priv),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct zynq_ehci_priv),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = ohci_da8xx_probe,
.remove = ohci_da8xx_remove,
.ops = &ohci_usb_ops,
- .priv_auto_alloc_size = sizeof(struct da8xx_ohci),
+ .priv_auto = sizeof(struct da8xx_ohci),
.flags = DM_FLAG_ALLOC_PRIV_DMA | DM_FLAG_OS_PREPARE,
};
#endif
.probe = ohci_usb_probe,
.remove = ohci_usb_remove,
.ops = &ohci_usb_ops,
- .priv_auto_alloc_size = sizeof(struct generic_ohci),
+ .priv_auto = sizeof(struct generic_ohci),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.remove = ohci_pci_remove,
.of_match = ohci_pci_ids,
.ops = &ohci_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(ohci_t),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(ohci_t),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = r8a66597_usb_probe,
.remove = r8a66597_usb_remove,
.ops = &r8a66597_usb_ops,
- .priv_auto_alloc_size = sizeof(struct r8a66597),
+ .priv_auto = sizeof(struct r8a66597),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.of_match = sandbox_usb_ids,
.probe = sandbox_usb_probe,
.ops = &sandbox_usb_ops,
- .priv_auto_alloc_size = sizeof(struct sandbox_usb_ctrl),
+ .priv_auto = sizeof(struct sandbox_usb_ctrl),
};
.name = "usb",
.flags = DM_UC_FLAG_SEQ_ALIAS,
.post_bind = dm_scan_fdt_dev,
- .priv_auto_alloc_size = sizeof(struct usb_uclass_priv),
- .per_child_auto_alloc_size = sizeof(struct usb_device),
- .per_device_auto_alloc_size = sizeof(struct usb_bus_priv),
+ .priv_auto = sizeof(struct usb_uclass_priv),
+ .per_child_auto = sizeof(struct usb_device),
+ .per_device_auto = sizeof(struct usb_bus_priv),
.child_post_bind = usb_child_post_bind,
.child_pre_probe = usb_child_pre_probe,
- .per_child_platdata_auto_alloc_size = sizeof(struct usb_dev_platdata),
+ .per_child_platdata_auto = sizeof(struct usb_dev_platdata),
};
UCLASS_DRIVER(usb_dev_generic) = {
.remove = xhci_brcm_deregister,
.ops = &xhci_usb_ops,
.of_match = xhci_brcm_ids,
- .platdata_auto_alloc_size = sizeof(struct brcm_xhci_platdata),
- .priv_auto_alloc_size = sizeof(struct xhci_ctrl),
+ .platdata_auto = sizeof(struct brcm_xhci_platdata),
+ .priv_auto = sizeof(struct xhci_ctrl),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = xhci_dwc3_probe,
.remove = xhci_dwc3_remove,
.ops = &xhci_usb_ops,
- .priv_auto_alloc_size = sizeof(struct xhci_ctrl),
- .platdata_auto_alloc_size = sizeof(struct xhci_dwc3_platdata),
+ .priv_auto = sizeof(struct xhci_ctrl),
+ .platdata_auto = sizeof(struct xhci_dwc3_platdata),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#endif
.probe = xhci_usb_probe,
.remove = xhci_usb_remove,
.ops = &xhci_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct exynos_xhci_platdata),
- .priv_auto_alloc_size = sizeof(struct exynos_xhci),
+ .platdata_auto = sizeof(struct exynos_xhci_platdata),
+ .priv_auto = sizeof(struct exynos_xhci),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = xhci_fsl_probe,
.remove = xhci_fsl_remove,
.ops = &xhci_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(struct xhci_fsl_priv),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct xhci_fsl_priv),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
#else
.remove = xhci_mtk_remove,
.ops = &xhci_usb_ops,
.bind = dm_scan_fdt_dev,
- .priv_auto_alloc_size = sizeof(struct mtk_xhci),
+ .priv_auto = sizeof(struct mtk_xhci),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.probe = xhci_usb_probe,
.remove = xhci_deregister,
.ops = &xhci_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct mvebu_xhci_platdata),
- .priv_auto_alloc_size = sizeof(struct mvebu_xhci),
+ .platdata_auto = sizeof(struct mvebu_xhci_platdata),
+ .priv_auto = sizeof(struct mvebu_xhci),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.remove = xhci_deregister,
.of_match = xhci_pci_ids,
.ops = &xhci_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(struct xhci_ctrl),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct xhci_ctrl),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.ops = &xhci_usb_ops,
.of_match = xhci_rcar_ids,
.ofdata_to_platdata = xhci_rcar_ofdata_to_platdata,
- .platdata_auto_alloc_size = sizeof(struct rcar_xhci_platdata),
- .priv_auto_alloc_size = sizeof(struct rcar_xhci),
+ .platdata_auto = sizeof(struct rcar_xhci_platdata),
+ .priv_auto = sizeof(struct rcar_xhci),
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.of_match = ssusb_of_match,
.probe = mtu3_gadget_probe,
.remove = mtu3_gadget_remove,
- .priv_auto_alloc_size = sizeof(struct mtu3),
+ .priv_auto = sizeof(struct mtu3),
};
#endif
.of_match = ssusb_of_match,
.probe = mtu3_host_probe,
.remove = mtu3_host_remove,
- .priv_auto_alloc_size = sizeof(struct mtu3_host),
+ .priv_auto = sizeof(struct mtu3_host),
.ops = &xhci_usb_ops,
.flags = DM_FLAG_ALLOC_PRIV_DMA,
};
.bind = mtu3_glue_bind,
.probe = mtu3_probe,
.remove = mtu3_remove,
- .priv_auto_alloc_size = sizeof(struct ssusb_mtk),
+ .priv_auto = sizeof(struct ssusb_mtk),
};
.probe = da8xx_musb_probe,
.remove = da8xx_musb_remove,
.ops = &musb_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct da8xx_musb_platdata),
- .priv_auto_alloc_size = sizeof(struct musb_host_data),
+ .platdata_auto = sizeof(struct da8xx_musb_platdata),
+ .priv_auto = sizeof(struct musb_host_data),
};
#ifdef CONFIG_USB_MUSB_HOST
.ops = &musb_usb_ops,
#endif
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(struct mtk_musb_glue),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct mtk_musb_glue),
};
#ifdef CONFIG_USB_MUSB_HOST
.ops = &musb_usb_ops,
#endif
- .platdata_auto_alloc_size = sizeof(struct omap2430_musb_platdata),
- .priv_auto_alloc_size = sizeof(struct musb_host_data),
+ .platdata_auto = sizeof(struct omap2430_musb_platdata),
+ .priv_auto = sizeof(struct musb_host_data),
};
#endif /* CONFIG_IS_ENABLED(DM_USB) */
#ifdef CONFIG_USB_MUSB_HOST
.ops = &musb_usb_ops,
#endif
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(struct pic32_musb_data),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct pic32_musb_data),
};
#ifdef CONFIG_USB_MUSB_HOST
.ops = &musb_usb_ops,
#endif
- .platdata_auto_alloc_size = sizeof(struct usb_platdata),
- .priv_auto_alloc_size = sizeof(struct sunxi_glue),
+ .platdata_auto = sizeof(struct usb_platdata),
+ .priv_auto = sizeof(struct sunxi_glue),
};
.probe = ti_musb_host_probe,
.remove = ti_musb_host_remove,
.ops = &musb_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct ti_musb_platdata),
- .priv_auto_alloc_size = sizeof(struct musb_host_data),
+ .platdata_auto = sizeof(struct ti_musb_platdata),
+ .priv_auto = sizeof(struct musb_host_data),
};
#if CONFIG_IS_ENABLED(DM_USB_GADGET)
.probe = ti_musb_peripheral_probe,
.remove = ti_musb_peripheral_remove,
.ops = &musb_usb_ops,
- .platdata_auto_alloc_size = sizeof(struct ti_musb_platdata),
- .priv_auto_alloc_size = sizeof(struct ti_musb_peripheral),
+ .platdata_auto = sizeof(struct ti_musb_platdata),
+ .priv_auto = sizeof(struct ti_musb_peripheral),
.flags = DM_FLAG_PRE_RELOC,
};
#endif
.ofdata_to_platdata = am335x_fb_ofdata_to_platdata,
.probe = am335x_fb_probe,
.remove = am335x_fb_remove,
- .priv_auto_alloc_size = sizeof(struct am335x_fb_priv),
+ .priv_auto = sizeof(struct am335x_fb_priv),
};
#endif /* CONFIG_DM_VIDEO */
.bind = atmel_hlcdc_bind,
.probe = atmel_hlcdc_probe,
.ofdata_to_platdata = atmel_hlcdc_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct atmel_hlcdc_priv),
+ .priv_auto = sizeof(struct atmel_hlcdc_priv),
};
#endif
.bind = atmel_fb_lcd_bind,
.ofdata_to_platdata = atmel_fb_ofdata_to_platdata,
.probe = atmel_fb_lcd_probe,
- .platdata_auto_alloc_size = sizeof(struct atmel_lcd_platdata),
- .priv_auto_alloc_size = sizeof(struct atmel_fb_priv),
+ .platdata_auto = sizeof(struct atmel_lcd_platdata),
+ .priv_auto = sizeof(struct atmel_fb_priv),
};
#endif
.ops = &gpio_backlight_ops,
.ofdata_to_platdata = gpio_backlight_ofdata_to_platdata,
.probe = gpio_backlight_probe,
- .priv_auto_alloc_size = sizeof(struct gpio_backlight_priv),
+ .priv_auto = sizeof(struct gpio_backlight_priv),
};
.of_match = anx6345_ids,
.probe = anx6345_probe,
.ops = &anx6345_ops,
- .priv_auto_alloc_size = sizeof(struct anx6345_priv),
+ .priv_auto = sizeof(struct anx6345_priv),
};
UCLASS_DRIVER(video_bridge) = {
.id = UCLASS_VIDEO_BRIDGE,
.name = "video_bridge",
- .per_device_auto_alloc_size = sizeof(struct video_bridge_priv),
+ .per_device_auto = sizeof(struct video_bridge_priv),
.pre_probe = video_bridge_pre_probe,
};
.ofdata_to_platdata = broadwell_igd_ofdata_to_platdata,
.bind = broadwell_igd_bind,
.probe = broadwell_igd_probe,
- .priv_auto_alloc_size = sizeof(struct broadwell_igd_priv),
- .platdata_auto_alloc_size = sizeof(struct broadwell_igd_plat),
+ .priv_auto = sizeof(struct broadwell_igd_priv),
+ .platdata_auto = sizeof(struct broadwell_igd_plat),
};
.id = UCLASS_VIDEO_CONSOLE,
.ops = &console_truetype_ops,
.probe = console_truetype_probe,
- .priv_auto_alloc_size = sizeof(struct console_tt_priv),
+ .priv_auto = sizeof(struct console_tt_priv),
};
UCLASS_DRIVER(display) = {
.id = UCLASS_DISPLAY,
.name = "display",
- .per_device_platdata_auto_alloc_size = sizeof(struct display_plat),
+ .per_device_platdata_auto = sizeof(struct display_plat),
};
.id = UCLASS_DSI_HOST,
.probe = dw_mipi_dsi_probe,
.ops = &dw_mipi_dsi_ops,
- .priv_auto_alloc_size = sizeof(struct dw_mipi_dsi),
+ .priv_auto = sizeof(struct dw_mipi_dsi),
};
MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>");
.of_match = exynos_dp_ids,
.ops = &exynos_dp_ops,
.ofdata_to_platdata = exynos_dp_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct exynos_dp_priv),
+ .priv_auto = sizeof(struct exynos_dp_priv),
};
.bind = exynos_fb_bind,
.probe = exynos_fb_probe,
.ofdata_to_platdata = exynos_fb_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct exynos_fb_priv),
+ .priv_auto = sizeof(struct exynos_fb_priv),
};
.ops = &ihs_video_out_ops,
.of_match = ihs_video_out_ids,
.probe = ihs_video_out_probe,
- .priv_auto_alloc_size = sizeof(struct ihs_video_out_priv),
+ .priv_auto = sizeof(struct ihs_video_out_priv),
};
.of_match = ipuv3_video_ids,
.bind = ipuv3_video_bind,
.probe = ipuv3_video_probe,
- .priv_auto_alloc_size = sizeof(struct ipuv3_video_priv),
+ .priv_auto = sizeof(struct ipuv3_video_priv),
.flags = DM_FLAG_PRE_RELOC,
};
.of_match = lg4573_ids,
.bind = lg4573_bind,
.probe = lg4573_probe,
- .priv_auto_alloc_size = sizeof(struct lg4573_lcd_priv),
+ .priv_auto = sizeof(struct lg4573_lcd_priv),
};
.id = UCLASS_DISPLAY,
.of_match = logicore_dp_tx_ids,
.probe = logicore_dp_tx_probe,
- .priv_auto_alloc_size = sizeof(struct dp_tx),
+ .priv_auto = sizeof(struct dp_tx),
.ops = &logicore_dp_tx_ops,
};
.of_match = malidp_ids,
.bind = malidp_bind,
.probe = malidp_probe,
- .priv_auto_alloc_size = sizeof(struct malidp_priv),
+ .priv_auto = sizeof(struct malidp_priv),
.ops = &malidp_ops,
};
.of_match = meson_dw_hdmi_ids,
.ops = &meson_dw_hdmi_ops,
.probe = meson_dw_hdmi_probe,
- .priv_auto_alloc_size = sizeof(struct meson_dw_hdmi),
+ .priv_auto = sizeof(struct meson_dw_hdmi),
};
.of_match = meson_vpu_ids,
.probe = meson_vpu_probe,
.bind = meson_vpu_bind,
- .priv_auto_alloc_size = sizeof(struct meson_vpu_priv),
+ .priv_auto = sizeof(struct meson_vpu_priv),
.flags = DM_FLAG_PRE_RELOC | DM_FLAG_REMOVE_WITH_PD_ON,
};
.of_match = mvebu_video_ids,
.bind = mvebu_video_bind,
.probe = mvebu_video_probe,
- .priv_auto_alloc_size = sizeof(struct mvebu_video_priv),
+ .priv_auto = sizeof(struct mvebu_video_priv),
};
.name = "nexell-display",
.id = UCLASS_VIDEO,
.of_match = nx_display_ids,
- .platdata_auto_alloc_size =
+ .platdata_auto =
sizeof(struct nx_display_platdata),
.bind = nx_display_bind,
.probe = nx_display_probe,
- .priv_auto_alloc_size = sizeof(struct nx_display_dev),
+ .priv_auto = sizeof(struct nx_display_dev),
};
.ops = &otm8009a_panel_ops,
.ofdata_to_platdata = otm8009a_panel_ofdata_to_platdata,
.probe = otm8009a_panel_probe,
- .platdata_auto_alloc_size = sizeof(struct mipi_dsi_panel_plat),
- .priv_auto_alloc_size = sizeof(struct otm8009a_panel_priv),
+ .platdata_auto = sizeof(struct mipi_dsi_panel_plat),
+ .priv_auto = sizeof(struct otm8009a_panel_priv),
};
.ops = &pwm_backlight_ops,
.ofdata_to_platdata = pwm_backlight_ofdata_to_platdata,
.probe = pwm_backlight_probe,
- .priv_auto_alloc_size = sizeof(struct pwm_backlight_priv),
+ .priv_auto = sizeof(struct pwm_backlight_priv),
};
.ops = &rm68200_panel_ops,
.ofdata_to_platdata = rm68200_panel_ofdata_to_platdata,
.probe = rm68200_panel_probe,
- .platdata_auto_alloc_size = sizeof(struct mipi_dsi_panel_plat),
- .priv_auto_alloc_size = sizeof(struct rm68200_panel_priv),
+ .platdata_auto = sizeof(struct mipi_dsi_panel_plat),
+ .priv_auto = sizeof(struct rm68200_panel_priv),
};
.ops = &rk3288_hdmi_ops,
.ofdata_to_platdata = rk3288_hdmi_ofdata_to_platdata,
.probe = rk3288_hdmi_probe,
- .priv_auto_alloc_size = sizeof(struct rk_hdmi_priv),
+ .priv_auto = sizeof(struct rk_hdmi_priv),
};
.ofdata_to_platdata = rk_mipi_ofdata_to_platdata,
.probe = rk_mipi_probe,
.ops = &rk_mipi_dsi_ops,
- .priv_auto_alloc_size = sizeof(struct rk_mipi_priv),
+ .priv_auto = sizeof(struct rk_mipi_priv),
};
.bind = rk_vop_bind,
.probe = rk3288_vop_probe,
.remove = rk_vop_remove,
- .priv_auto_alloc_size = sizeof(struct rk_vop_priv),
+ .priv_auto = sizeof(struct rk_vop_priv),
};
.ops = &rk3399_hdmi_ops,
.ofdata_to_platdata = rk3399_hdmi_ofdata_to_platdata,
.probe = rk3399_hdmi_probe,
- .priv_auto_alloc_size = sizeof(struct rk_hdmi_priv),
+ .priv_auto = sizeof(struct rk_hdmi_priv),
};
.ofdata_to_platdata = rk_mipi_ofdata_to_platdata,
.probe = rk_mipi_probe,
.ops = &rk_mipi_dsi_ops,
- .priv_auto_alloc_size = sizeof(struct rk_mipi_priv),
+ .priv_auto = sizeof(struct rk_mipi_priv),
};
.ops = &rk3399_vop_ops,
.bind = rk_vop_bind,
.probe = rk3399_vop_probe,
- .priv_auto_alloc_size = sizeof(struct rk_vop_priv),
+ .priv_auto = sizeof(struct rk_vop_priv),
};
.ofdata_to_platdata = rk_edp_ofdata_to_platdata,
.probe = rk_edp_probe,
.remove = rk_edp_remove,
- .priv_auto_alloc_size = sizeof(struct rk_edp_priv),
+ .priv_auto = sizeof(struct rk_edp_priv),
};
.ops = &lvds_rockchip_ops,
.ofdata_to_platdata = rk_lvds_ofdata_to_platdata,
.probe = rk_lvds_probe,
- .priv_auto_alloc_size = sizeof(struct rk_lvds_priv),
+ .priv_auto = sizeof(struct rk_lvds_priv),
};
.id = UCLASS_DSI_HOST,
.of_match = sandbox_dsi_host_ids,
.ops = &sandbox_dsi_host_ops,
- .priv_auto_alloc_size = sizeof(struct sandbox_dsi_host_priv),
+ .priv_auto = sizeof(struct sandbox_dsi_host_priv),
};
.ops = &sandbox_osd_ops,
.of_match = sandbox_osd_ids,
.probe = sandbox_osd_probe,
- .priv_auto_alloc_size = sizeof(struct sandbox_osd_priv),
+ .priv_auto = sizeof(struct sandbox_osd_priv),
};
.of_match = sandbox_sdl_ids,
.bind = sandbox_sdl_bind,
.probe = sandbox_sdl_probe,
- .platdata_auto_alloc_size = sizeof(struct sandbox_sdl_plat),
+ .platdata_auto = sizeof(struct sandbox_sdl_plat),
};
.ops = &simple_panel_ops,
.ofdata_to_platdata = simple_panel_ofdata_to_platdata,
.probe = simple_panel_probe,
- .priv_auto_alloc_size = sizeof(struct simple_panel_priv),
+ .priv_auto = sizeof(struct simple_panel_priv),
};
.bind = stm32_dsi_bind,
.probe = stm32_dsi_probe,
.ops = &stm32_dsi_ops,
- .priv_auto_alloc_size = sizeof(struct stm32_dsi_priv),
+ .priv_auto = sizeof(struct stm32_dsi_priv),
};
.of_match = stm32_ltdc_ids,
.probe = stm32_ltdc_probe,
.bind = stm32_ltdc_bind,
- .priv_auto_alloc_size = sizeof(struct stm32_ltdc_priv),
+ .priv_auto = sizeof(struct stm32_ltdc_priv),
};
.id = UCLASS_DISPLAY,
.ops = &sunxi_dw_hdmi_ops,
.probe = sunxi_dw_hdmi_probe,
- .priv_auto_alloc_size = sizeof(struct sunxi_dw_hdmi_priv),
+ .priv_auto = sizeof(struct sunxi_dw_hdmi_priv),
};
U_BOOT_DEVICE(sunxi_dw_hdmi) = {
.id = UCLASS_DISPLAY,
.ops = &sunxi_lcd_ops,
.probe = sunxi_lcd_probe,
- .priv_auto_alloc_size = sizeof(struct sunxi_lcd_priv),
+ .priv_auto = sizeof(struct sunxi_lcd_priv),
};
#ifdef CONFIG_MACH_SUN50I
.of_match = tda19988_ids,
.ops = &tda19988_ops,
.probe = tda19988_probe,
- .priv_auto_alloc_size = sizeof(struct tda19988_priv),
+ .priv_auto = sizeof(struct tda19988_priv),
};
.bind = tegra_lcd_bind,
.probe = tegra_lcd_probe,
.ofdata_to_platdata = tegra_lcd_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct tegra_lcd_priv),
+ .priv_auto = sizeof(struct tegra_lcd_priv),
};
.ofdata_to_platdata = tegra_dp_ofdata_to_platdata,
.probe = dp_tegra_probe,
.ops = &dp_tegra_ops,
- .priv_auto_alloc_size = sizeof(struct tegra_dp_priv),
- .platdata_auto_alloc_size = sizeof(struct tegra_dp_plat),
+ .priv_auto = sizeof(struct tegra_dp_priv),
+ .platdata_auto = sizeof(struct tegra_dp_plat),
};
.of_match = tegra_sor_ids,
.ofdata_to_platdata = tegra_sor_ofdata_to_platdata,
.ops = &tegra_sor_ops,
- .priv_auto_alloc_size = sizeof(struct tegra_dc_sor_data),
+ .priv_auto = sizeof(struct tegra_dc_sor_data),
};
.name = "vidconsole0",
.pre_probe = vidconsole_pre_probe,
.post_probe = vidconsole_post_probe,
- .per_device_auto_alloc_size = sizeof(struct vidconsole_priv),
+ .per_device_auto = sizeof(struct vidconsole_priv),
};
#ifdef CONFIG_VIDEO_COPY
.pre_probe = video_pre_probe,
.post_probe = video_post_probe,
.pre_remove = video_pre_remove,
- .priv_auto_alloc_size = sizeof(struct video_uc_priv),
- .per_device_auto_alloc_size = sizeof(struct video_priv),
- .per_device_platdata_auto_alloc_size = sizeof(struct video_uc_platdata),
+ .priv_auto = sizeof(struct video_uc_priv),
+ .per_device_auto = sizeof(struct video_priv),
+ .per_device_platdata_auto = sizeof(struct video_uc_platdata),
};
.child_post_bind = virtio_uclass_child_post_bind,
.child_pre_probe = virtio_uclass_child_pre_probe,
.child_post_probe = virtio_uclass_child_post_probe,
- .per_device_auto_alloc_size = sizeof(struct virtio_dev_priv),
+ .per_device_auto = sizeof(struct virtio_dev_priv),
};
.bind = virtio_blk_bind,
.probe = virtio_blk_probe,
.remove = virtio_reset,
- .priv_auto_alloc_size = sizeof(struct virtio_blk_priv),
+ .priv_auto = sizeof(struct virtio_blk_priv),
.flags = DM_FLAG_ACTIVE_DMA,
};
.ops = &virtio_mmio_ops,
.probe = virtio_mmio_probe,
.ofdata_to_platdata = virtio_mmio_ofdata_to_platdata,
- .priv_auto_alloc_size = sizeof(struct virtio_mmio_priv),
+ .priv_auto = sizeof(struct virtio_mmio_priv),
};
.probe = virtio_net_probe,
.remove = virtio_reset,
.ops = &virtio_net_ops,
- .priv_auto_alloc_size = sizeof(struct virtio_net_priv),
- .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+ .priv_auto = sizeof(struct virtio_net_priv),
+ .platdata_auto = sizeof(struct eth_pdata),
.flags = DM_FLAG_ACTIVE_DMA,
};
.ops = &virtio_pci_ops,
.bind = virtio_pci_bind,
.probe = virtio_pci_probe,
- .priv_auto_alloc_size = sizeof(struct virtio_pci_priv),
+ .priv_auto = sizeof(struct virtio_pci_priv),
};
static struct pci_device_id virtio_pci_supported[] = {
.ops = &virtio_pci_ops,
.bind = virtio_pci_bind,
.probe = virtio_pci_probe,
- .priv_auto_alloc_size = sizeof(struct virtio_pci_priv),
+ .priv_auto = sizeof(struct virtio_pci_priv),
};
static struct pci_device_id virtio_pci_supported[] = {
.probe = virtio_rng_probe,
.remove = virtio_reset,
.ops = &virtio_rng_ops,
- .priv_auto_alloc_size = sizeof(struct virtio_rng_priv),
+ .priv_auto = sizeof(struct virtio_rng_priv),
.flags = DM_FLAG_ACTIVE_DMA,
};
.ops = &virtio_sandbox1_ops,
.probe = virtio_sandbox_probe,
.child_post_remove = virtio_sandbox_child_post_remove,
- .priv_auto_alloc_size = sizeof(struct virtio_sandbox_priv),
+ .priv_auto = sizeof(struct virtio_sandbox_priv),
};
/* this one without notify op */
.of_match = virtio_sandbox2_ids,
.ops = &virtio_sandbox2_ops,
.probe = virtio_sandbox_probe,
- .priv_auto_alloc_size = sizeof(struct virtio_sandbox_priv),
+ .priv_auto = sizeof(struct virtio_sandbox_priv),
};
.of_match = mxc_w1_id,
.ofdata_to_platdata = mxc_w1_ofdata_to_platdata,
.ops = &mxc_w1_ops,
- .platdata_auto_alloc_size = sizeof(struct mxc_w1_pdata),
+ .platdata_auto = sizeof(struct mxc_w1_pdata),
.probe = mxc_w1_probe,
};
.of_match = w1_gpio_id,
.ofdata_to_platdata = w1_gpio_ofdata_to_platdata,
.ops = &w1_gpio_ops,
- .platdata_auto_alloc_size = sizeof(struct w1_gpio_pdata),
+ .platdata_auto = sizeof(struct w1_gpio_pdata),
};
.name = "w1",
.id = UCLASS_W1,
.flags = DM_UC_FLAG_SEQ_ALIAS,
- .per_device_auto_alloc_size = sizeof(struct w1_bus),
+ .per_device_auto = sizeof(struct w1_bus),
.post_probe = w1_post_probe,
#if CONFIG_IS_ENABLED(OF_CONTROL)
.post_bind = dm_scan_fdt_dev,
#endif
- .per_child_platdata_auto_alloc_size = sizeof(struct w1_device),
+ .per_child_platdata_auto = sizeof(struct w1_device),
};
.id = UCLASS_WDT,
.of_match = a37xx_wdt_ids,
.probe = a37xx_wdt_probe,
- .priv_auto_alloc_size = sizeof(struct a37xx_wdt),
+ .priv_auto = sizeof(struct a37xx_wdt),
.ops = &a37xx_wdt_ops,
};
.id = UCLASS_WDT,
.of_match = ast_wdt_ids,
.probe = ast_wdt_probe,
- .priv_auto_alloc_size = sizeof(struct ast_wdt_priv),
+ .priv_auto = sizeof(struct ast_wdt_priv),
.ofdata_to_platdata = ast_wdt_ofdata_to_platdata,
.ops = &ast_wdt_ops,
};
.name = "atmel_at91sam9260_wdt",
.id = UCLASS_WDT,
.of_match = at91_wdt_ids,
- .priv_auto_alloc_size = sizeof(struct at91_wdt_priv),
+ .priv_auto = sizeof(struct at91_wdt_priv),
.ops = &at91_wdt_ops,
.probe = at91_wdt_probe,
};
.id = UCLASS_WDT,
.of_match = bcm6345_wdt_ids,
.ops = &bcm6345_wdt_ops,
- .priv_auto_alloc_size = sizeof(struct bcm6345_wdt_priv),
+ .priv_auto = sizeof(struct bcm6345_wdt_priv),
.probe = bcm6345_wdt_probe,
};
.id = UCLASS_WDT,
.of_match = cdns_wdt_ids,
.probe = cdns_wdt_probe,
- .priv_auto_alloc_size = sizeof(struct cdns_wdt_priv),
+ .priv_auto = sizeof(struct cdns_wdt_priv),
.ofdata_to_platdata = cdns_wdt_ofdata_to_platdata,
.ops = &cdns_wdt_ops,
};
.name = "designware_wdt",
.id = UCLASS_WDT,
.of_match = designware_wdt_ids,
- .priv_auto_alloc_size = sizeof(struct designware_wdt_priv),
+ .priv_auto = sizeof(struct designware_wdt_priv),
.probe = designware_wdt_probe,
.ops = &designware_wdt_ops,
.flags = DM_FLAG_PRE_RELOC,
.of_match = imx_wdt_ids,
.probe = imx_wdt_probe,
.ops = &imx_wdt_ops,
- .priv_auto_alloc_size = sizeof(struct imx_wdt_priv),
+ .priv_auto = sizeof(struct imx_wdt_priv),
.flags = DM_FLAG_PRE_RELOC,
};
#endif
.id = UCLASS_WDT,
.of_match = mt762x_wdt_ids,
.probe = mt762x_wdt_probe,
- .priv_auto_alloc_size = sizeof(struct mt762x_wdt),
+ .priv_auto = sizeof(struct mt762x_wdt),
.ops = &mt762x_wdt_ops,
};
.name = "mtk_wdt",
.id = UCLASS_WDT,
.of_match = mtk_wdt_ids,
- .priv_auto_alloc_size = sizeof(struct mtk_wdt_priv),
+ .priv_auto = sizeof(struct mtk_wdt_priv),
.probe = mtk_wdt_probe,
.ops = &mtk_wdt_ops,
.flags = DM_FLAG_PRE_RELOC,
.id = UCLASS_WDT,
.of_match = octeontx_wdt_ids,
.ops = &octeontx_wdt_ops,
- .priv_auto_alloc_size = sizeof(struct octeontx_wdt),
+ .priv_auto = sizeof(struct octeontx_wdt),
.probe = octeontx_wdt_probe,
.remove = octeontx_wdt_remove,
.flags = DM_FLAG_OS_PREPARE,
.of_match = omap3_wdt_ids,
.ops = &omap3_wdt_ops,
.probe = omap3_wdt_probe,
- .priv_auto_alloc_size = sizeof(struct omap3_wdt_priv),
+ .priv_auto = sizeof(struct omap3_wdt_priv),
};
#endif /* !CONFIG_IS_ENABLED(WDT) */
.id = UCLASS_WDT,
.of_match = orion_wdt_ids,
.probe = orion_wdt_probe,
- .priv_auto_alloc_size = sizeof(struct orion_wdt_priv),
+ .priv_auto = sizeof(struct orion_wdt_priv),
.ofdata_to_platdata = orion_wdt_ofdata_to_platdata,
.ops = &orion_wdt_ops,
};
.of_match = rti_wdt_ids,
.ops = &rti_wdt_ops,
.probe = rti_wdt_probe,
- .priv_auto_alloc_size = sizeof(struct rti_wdt_priv),
+ .priv_auto = sizeof(struct rti_wdt_priv),
.flags = DM_FLAG_REMOVE_WITH_PD_ON,
};
.id = UCLASS_WDT,
.of_match = sbsa_gwdt_ids,
.probe = sbsa_gwdt_probe,
- .priv_auto_alloc_size = sizeof(struct sbsa_gwdt_priv),
+ .priv_auto = sizeof(struct sbsa_gwdt_priv),
.ofdata_to_platdata = sbsa_gwdt_ofdata_to_platdata,
.ops = &sbsa_gwdt_ops,
};
.id = UCLASS_WDT,
.of_match = sp805_wdt_ids,
.probe = sp805_wdt_probe,
- .priv_auto_alloc_size = sizeof(struct sp805_wdt_priv),
+ .priv_auto = sizeof(struct sp805_wdt_priv),
.ofdata_to_platdata = sp805_wdt_ofdata_to_platdata,
.ops = &sp805_wdt_ops,
};
.name = "stm32mp-wdt",
.id = UCLASS_WDT,
.of_match = stm32mp_wdt_match,
- .priv_auto_alloc_size = sizeof(struct stm32mp_wdt_priv),
+ .priv_auto = sizeof(struct stm32mp_wdt_priv),
.probe = stm32mp_wdt_probe,
.ops = &stm32mp_wdt_ops,
};
.id = UCLASS_WDT,
.of_match = xlnx_wdt_ids,
.probe = xlnx_wdt_probe,
- .platdata_auto_alloc_size = sizeof(struct xlnx_wdt_platdata),
+ .platdata_auto = sizeof(struct xlnx_wdt_platdata),
.ofdata_to_platdata = xlnx_wdt_ofdata_to_platdata,
.ops = &xlnx_wdt_ops,
};
.id = UCLASS_WDT,
.of_match = xlnx_wwdt_ids,
.probe = xlnx_wwdt_probe,
- .priv_auto_alloc_size = sizeof(struct xlnx_wwdt_priv),
- .platdata_auto_alloc_size = sizeof(struct xlnx_wwdt_platdata),
+ .priv_auto = sizeof(struct xlnx_wwdt_priv),
+ .platdata_auto = sizeof(struct xlnx_wwdt_platdata),
.ofdata_to_platdata = xlnx_wwdt_ofdata_to_platdata,
.ops = &xlnx_wwdt_ops,
};
.bind = pvblock_blk_bind,
.probe = pvblock_blk_probe,
.remove = pvblock_blk_remove,
- .priv_auto_alloc_size = sizeof(struct blkfront_dev),
+ .priv_auto = sizeof(struct blkfront_dev),
.flags = DM_FLAG_OS_PREPARE,
};
* probe method if the device has a device tree node.
*
* All three of platdata, priv and uclass_priv can be allocated by the
- * driver, or you can use the auto_alloc_size members of struct driver and
+ * driver, or you can use the 'auto' members of struct driver and
* struct uclass_driver to have driver model do this automatically.
*
* @driver: The driver used by this device
* memory allocated but it has not yet been probed.
* @child_post_remove: Called after a child device is removed. The device
* has memory allocated but its device_remove() method has been called.
- * @priv_auto_alloc_size: If non-zero this is the size of the private data
+ * @priv_auto: If non-zero this is the size of the private data
* to be allocated in the device's ->priv pointer. If zero, then the driver
* is responsible for allocating any data required.
- * @platdata_auto_alloc_size: If non-zero this is the size of the
+ * @platdata_auto: If non-zero this is the size of the
* platform data to be allocated in the device's ->platdata pointer.
* This is typically only useful for device-tree-aware drivers (those with
* an of_match), since drivers which use platdata will have the data
* provided in the U_BOOT_DEVICE() instantiation.
- * @per_child_auto_alloc_size: Each device can hold private data owned by
+ * @per_child_auto: Each device can hold private data owned by
* its parent. If required this will be automatically allocated if this
* value is non-zero.
- * @per_child_platdata_auto_alloc_size: A bus likes to store information about
+ * @per_child_platdata_auto: A bus likes to store information about
* its children. If non-zero this is the size of this data, to be allocated
* in the child's parent_platdata pointer.
* @ops: Driver-specific operations. This is typically a list of function
int (*child_post_bind)(struct udevice *dev);
int (*child_pre_probe)(struct udevice *dev);
int (*child_post_remove)(struct udevice *dev);
- int priv_auto_alloc_size;
- int platdata_auto_alloc_size;
- int per_child_auto_alloc_size;
- int per_child_platdata_auto_alloc_size;
+ int priv_auto;
+ int platdata_auto;
+ int per_child_auto;
+ int per_child_platdata_auto;
const void *ops; /* driver-specific operations */
uint32_t flags;
#if CONFIG_IS_ENABLED(ACPIGEN)
* @child_post_probe: Called after a child in this uclass is probed
* @init: Called to set up the uclass
* @destroy: Called to destroy the uclass
- * @priv_auto_alloc_size: If non-zero this is the size of the private data
+ * @priv_auto: If non-zero this is the size of the private data
* to be allocated in the uclass's ->priv pointer. If zero, then the uclass
* driver is responsible for allocating any data required.
- * @per_device_auto_alloc_size: Each device can hold private data owned
+ * @per_device_auto: Each device can hold private data owned
* by the uclass. If required this will be automatically allocated if this
* value is non-zero.
- * @per_device_platdata_auto_alloc_size: Each device can hold platform data
+ * @per_device_platdata_auto: Each device can hold platform data
* owned by the uclass as 'dev->uclass_platdata'. If the value is non-zero,
* then this will be automatically allocated.
- * @per_child_auto_alloc_size: Each child device (of a parent in this
+ * @per_child_auto: Each child device (of a parent in this
* uclass) can hold parent data for the device/uclass. This value is only
* used as a fallback if this member is 0 in the driver.
- * @per_child_platdata_auto_alloc_size: A bus likes to store information about
+ * @per_child_platdata_auto: A bus likes to store information about
* its children. If non-zero this is the size of this data, to be allocated
* in the child device's parent_platdata pointer. This value is only used as
* a fallback if this member is 0 in the driver.
int (*child_post_probe)(struct udevice *dev);
int (*init)(struct uclass *class);
int (*destroy)(struct uclass *class);
- int priv_auto_alloc_size;
- int per_device_auto_alloc_size;
- int per_device_platdata_auto_alloc_size;
- int per_child_auto_alloc_size;
- int per_child_platdata_auto_alloc_size;
+ int priv_auto;
+ int per_device_auto;
+ int per_device_platdata_auto;
+ int per_child_auto;
+ int per_child_platdata_auto;
const void *ops;
uint32_t flags;
};
* ...
*
* Inside U_BOOT_DRIVER():
- * .platdata_auto_alloc_size = sizeof(struct rockchip_mmc_plat),
+ * .platdata_auto = sizeof(struct rockchip_mmc_plat),
*
* To access platform data:
* struct rockchip_mmc_plat *plat = dev_get_platdata(dev);
* ...
*
* Inside U_BOOT_DRIVER():
- * .platdata_auto_alloc_size = sizeof(struct msm_sdhc_plat),
+ * .platdata_auto = sizeof(struct msm_sdhc_plat),
*
* To access platform data:
* struct msm_sdhc_plat *plat = dev_get_platdata(dev);
*
* For driver model this is the per-child data used by the SPI bus. It can
* be accessed using dev_get_parent_priv() on the slave device. The SPI uclass
- * sets uip per_child_auto_alloc_size to sizeof(struct spi_slave), and the
+ * sets up per_child_auto to sizeof(struct spi_slave), and the
* driver should not override it. Two platform data fields (max_hz and mode)
* are copied into this structure to provide an initial value. This allows
* them to be changed, since we should never change platform data in drivers.
.name = "efi_blk",
.id = UCLASS_BLK,
.ops = &efi_blk_ops,
- .platdata_auto_alloc_size = sizeof(struct efi_blk_platdata),
+ .platdata_auto = sizeof(struct efi_blk_platdata),
};
/* EFI driver operators */
.pre_unbind = eth_pre_unbind,
.post_probe = eth_post_probe,
.pre_remove = eth_pre_remove,
- .priv_auto_alloc_size = sizeof(struct eth_uclass_priv),
- .per_device_auto_alloc_size = sizeof(struct eth_device_priv),
+ .priv_auto = sizeof(struct eth_uclass_priv),
+ .per_device_auto = sizeof(struct eth_device_priv),
.flags = DM_UC_FLAG_SEQ_ALIAS,
};
.child_post_bind = dm_mdio_mux_child_post_bind,
.post_bind = dm_mdio_mux_post_bind,
.post_probe = dm_mdio_mux_post_probe,
- .per_device_auto_alloc_size = sizeof(struct mdio_mux_perdev_priv),
- .per_child_platdata_auto_alloc_size = sizeof(struct mdio_mux_ch_data),
+ .per_device_auto = sizeof(struct mdio_mux_perdev_priv),
+ .per_child_platdata_auto = sizeof(struct mdio_mux_ch_data),
};
.post_bind = dm_mdio_post_bind,
.post_probe = dm_mdio_post_probe,
.pre_remove = dm_mdio_pre_remove,
- .per_device_auto_alloc_size = sizeof(struct mdio_perdev_priv),
+ .per_device_auto = sizeof(struct mdio_perdev_priv),
};
.of_match = testacpi_ids,
.id = UCLASS_TEST_ACPI,
.bind = dm_scan_fdt_dev,
- .platdata_auto_alloc_size = sizeof(struct testacpi_platdata),
+ .platdata_auto = sizeof(struct testacpi_platdata),
ACPI_OPS_PTR(&testacpi_ops)
};
.id = UCLASS_TEST_BUS,
.probe = testbus_drv_probe,
.child_post_bind = testbus_child_post_bind,
- .priv_auto_alloc_size = sizeof(struct dm_test_priv),
- .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
- .per_child_auto_alloc_size = sizeof(struct dm_test_parent_data),
- .per_child_platdata_auto_alloc_size =
+ .priv_auto = sizeof(struct dm_test_priv),
+ .platdata_auto = sizeof(struct dm_test_pdata),
+ .per_child_auto = sizeof(struct dm_test_parent_data),
+ .per_child_platdata_auto =
sizeof(struct dm_test_parent_platdata),
.child_pre_probe = testbus_child_pre_probe,
.child_post_remove = testbus_child_post_remove,
/* Set the driver size to 0 so that the uclass size is used */
ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
drv = (struct driver *)bus->driver;
- size = drv->per_child_auto_alloc_size;
+ size = drv->per_child_auto;
#ifdef CONFIG_SANDBOX
os_mprotect_allow(bus->uclass->uc_drv, sizeof(*bus->uclass->uc_drv));
os_mprotect_allow(drv, sizeof(*drv));
#endif
- bus->uclass->uc_drv->per_child_auto_alloc_size = size;
- drv->per_child_auto_alloc_size = 0;
+ bus->uclass->uc_drv->per_child_auto = size;
+ drv->per_child_auto = 0;
ret = test_bus_parent_data(uts);
if (ret)
return ret;
- bus->uclass->uc_drv->per_child_auto_alloc_size = 0;
- drv->per_child_auto_alloc_size = size;
+ bus->uclass->uc_drv->per_child_auto = 0;
+ drv->per_child_auto = size;
return 0;
}
/* Set the driver size to 0 so that the uclass size is used */
ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
drv = (struct driver *)bus->driver;
- size = drv->per_child_platdata_auto_alloc_size;
+ size = drv->per_child_platdata_auto;
#ifdef CONFIG_SANDBOX
os_mprotect_allow(bus->uclass->uc_drv, sizeof(*bus->uclass->uc_drv));
os_mprotect_allow(drv, sizeof(*drv));
#endif
- bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = size;
- drv->per_child_platdata_auto_alloc_size = 0;
+ bus->uclass->uc_drv->per_child_platdata_auto = size;
+ drv->per_child_platdata_auto = 0;
ret = test_bus_parent_platdata(uts);
if (ret)
return ret;
- bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = 0;
- drv->per_child_platdata_auto_alloc_size = size;
+ bus->uclass->uc_drv->per_child_platdata_auto = 0;
+ drv->per_child_platdata_auto = size;
return 0;
}
* Test if test uclass driver requires allocation for the uclass
* platform data and then check the dev->uclass_platdata pointer.
*/
- ut_assert(uc->uc_drv->per_device_platdata_auto_alloc_size);
+ ut_assert(uc->uc_drv->per_device_platdata_auto);
for (uclass_find_first_device(UCLASS_TEST, &dev);
dev;
.of_match = mux_emul_of_match,
.ops = &mux_emul_ops,
.probe = mux_emul_probe,
- .priv_auto_alloc_size = sizeof(struct mux_emul_priv),
+ .priv_auto = sizeof(struct mux_emul_priv),
};
static int dm_test_mux_emul_default_state(struct unit_test_state *uts)
.of_match = regmaptest_ids,
.id = UCLASS_NOP,
.probe = remaptest_probe,
- .priv_auto_alloc_size = sizeof(struct regmaptest_priv),
+ .priv_auto = sizeof(struct regmaptest_priv),
};
static int dm_test_devm_regmap(struct unit_test_state *uts)
.probe = test_probe,
.remove = test_remove,
.unbind = test_unbind,
- .priv_auto_alloc_size = sizeof(struct dm_test_priv),
+ .priv_auto = sizeof(struct dm_test_priv),
};
U_BOOT_DRIVER(test2_drv) = {
.probe = test_probe,
.remove = test_remove,
.unbind = test_unbind,
- .priv_auto_alloc_size = sizeof(struct dm_test_priv),
+ .priv_auto = sizeof(struct dm_test_priv),
};
static int test_manual_drv_ping(struct udevice *dev, int pingval, int *pingret)
.ofdata_to_platdata = testfdt_ofdata_to_platdata,
.probe = testfdt_drv_probe,
.ops = &test_ops,
- .priv_auto_alloc_size = sizeof(struct dm_test_priv),
- .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
+ .priv_auto = sizeof(struct dm_test_priv),
+ .platdata_auto = sizeof(struct dm_test_pdata),
};
static const struct udevice_id testfdt1_ids[] = {
.ofdata_to_platdata = testfdt_ofdata_to_platdata,
.probe = testfdt_drv_probe,
.ops = &test_ops,
- .priv_auto_alloc_size = sizeof(struct dm_test_priv),
- .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
+ .priv_auto = sizeof(struct dm_test_priv),
+ .platdata_auto = sizeof(struct dm_test_pdata),
.flags = DM_FLAG_PRE_RELOC,
};
.of_match = testprobe_ids,
.id = UCLASS_TEST_PROBE,
.probe = testprobe_drv_probe,
- .platdata_auto_alloc_size = sizeof(struct dm_testprobe_pdata),
+ .platdata_auto = sizeof(struct dm_testprobe_pdata),
};
UCLASS_DRIVER(testprobe) = {
.bind = testdevres_drv_bind,
.ofdata_to_platdata = testdevres_drv_ofdata_to_platdata,
.probe = testdevres_drv_probe,
- .platdata_auto_alloc_size = sizeof(struct dm_testdevres_pdata),
- .priv_auto_alloc_size = sizeof(struct dm_testdevres_priv),
+ .platdata_auto = sizeof(struct dm_testdevres_pdata),
+ .priv_auto = sizeof(struct dm_testdevres_priv),
};
UCLASS_DRIVER(testdevres) = {
.pre_remove = test_pre_remove,
.init = test_init,
.destroy = test_destroy,
- .priv_auto_alloc_size = sizeof(struct dm_test_uclass_priv),
- .per_device_auto_alloc_size = sizeof(struct dm_test_uclass_perdev_priv),
- .per_device_platdata_auto_alloc_size =
+ .priv_auto = sizeof(struct dm_test_uclass_priv),
+ .per_device_auto = sizeof(struct dm_test_uclass_perdev_priv),
+ .per_device_platdata_auto =
sizeof(struct dm_test_perdev_uc_pdata),
};
projects / u-boot.git / commitdiff