dm: treewide: Rename auto_alloc_size members to be shorter
This construct is quite long-winded. In earlier days it made some sense
since auto-allocation was a strange concept. But with driver model now
used pretty universally, we can shorten this to 'auto'. This reduces
verbosity and makes it easier to read.
Coincidentally it also ensures that every declaration is on one line,
thus making dtoc's job easier.
Signed-off-by: Simon Glass <sjg@chromium.org>
diff --git a/doc/driver-model/design.rst b/doc/driver-model/design.rst
index 96525b6..92d1304 100644
--- a/doc/driver-model/design.rst
+++ b/doc/driver-model/design.rst
@@ -448,10 +448,10 @@
.. 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
@@ -464,7 +464,7 @@
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.
@@ -589,7 +589,7 @@
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.
@@ -695,24 +695,24 @@
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
@@ -726,7 +726,7 @@
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
@@ -795,9 +795,9 @@
- 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'
@@ -843,10 +843,10 @@
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.
diff --git a/doc/driver-model/ethernet.rst b/doc/driver-model/ethernet.rst
index 1f5310d..781644d 100644
--- a/doc/driver-model/ethernet.rst
+++ b/doc/driver-model/ethernet.rst
@@ -28,14 +28,14 @@
.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.
@@ -43,7 +43,7 @@
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:
diff --git a/doc/driver-model/of-plat.rst b/doc/driver-model/of-plat.rst
index 5848166..2df59ed 100644
--- a/doc/driver-model/of-plat.rst
+++ b/doc/driver-model/of-plat.rst
@@ -293,8 +293,8 @@
.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 */
@@ -305,7 +305,7 @@
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).
diff --git a/doc/driver-model/spi-howto.rst b/doc/driver-model/spi-howto.rst
index 9631a50..a12d692 100644
--- a/doc/driver-model/spi-howto.rst
+++ b/doc/driver-model/spi-howto.rst
@@ -231,7 +231,7 @@
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
@@ -335,7 +335,7 @@
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
@@ -621,7 +621,7 @@
U_BOOT_DRIVER(exynos_spi) = {
...
- .per_child_auto_alloc_size = sizeof(struct spi_slave),
+ .per_child_auto = sizeof(struct spi_slave),
}
diff --git a/doc/driver-model/usb-info.rst b/doc/driver-model/usb-info.rst
index 1817df4..5f7cbfc 100644
--- a/doc/driver-model/usb-info.rst
+++ b/doc/driver-model/usb-info.rst
@@ -43,8 +43,8 @@
.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,
};
@@ -58,7 +58,7 @@
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.
diff --git a/doc/imx/clk/ccf.txt b/doc/imx/clk/ccf.txt
index e40ac36..f47ca88 100644
--- a/doc/imx/clk/ccf.txt
+++ b/doc/imx/clk/ccf.txt
@@ -37,7 +37,7 @@
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