On Wed, May 29, 2024 at 06:00:19PM +0300, Andy Shevchenko wrote: > On Wed, May 29, 2024 at 5:35 PM Laurent Pinchart wrote: > > On Wed, May 29, 2024 at 05:24:03PM +0300, Andy Shevchenko wrote: > > > On Wed, May 29, 2024 at 12:48 PM Laurent Pinchart wrote: > > > > On Wed, May 29, 2024 at 09:16:43AM +0300, Andy Shevchenko wrote: > > > > > On Tue, May 28, 2024 at 11:20 PM Laurent Pinchart wrote: > > > > > > On Tue, May 28, 2024 at 10:36:06PM +0300, Andy Shevchenko wrote: > > ... > > > > > > > > > + device_set_of_node_from_dev(dev, dev->parent); > > > > > > > > > > > > > > Why not device_set_node()? > > > > > > > > > > > > Because device_set_of_node_from_dev() is meant for this exact use case, > > > > > > where the same node is used for multiple devices. It also puts any > > > > > > previous dev->of_node, ensuring proper refcounting when devices are > > > > > > unbound and rebound, without being deleted. > > > > > > > > > > When will the refcount be dropped (in case of removal of this device)? > > > > > Or you mean it shouldn't? > > > > > > > > Any refcount taken on the OF node needs to be dropped. The device core > > > > only drops the refcount when the device is being deleted, not when > > > > there's an unbind-rebind cycle without deletion of the device (as > > > > happens for instance when the module is unloaded and reloaded). > > > > > > Under "device" you meant the real hardware, as Linux device (instance > > > of the struct device object) is being rebuilt AFAIK)? > > > > I mean struct device. The driver core will drop the reference in > > platform_device_release(), called when the last reference to the > > platform device is released, just before freeing the platform_device > > instance. This happens after the device is removed from the system (e.g. > > hot-unplug), but not when a device is unbound from a driver and rebound > > (e.g. module unload and reload). > > This is something I need to refresh in my memory. Any pointers (the > links to the exact code lines are also okay) where I can find the > proof of what you are saying. (It's not that I untrust you, it's just > that I take my time on studying it.) I wish this was documented, I could then point you to a nice text that explains it all :-) My understanding comes from reading platform_device_release(), and from failing to find other of_node_put() calls that would be relevant to this. > > > > This has > > > > to be handled by the driver. device_set_of_node_from_dev() handles it. > > > > > > But why do you need to keep a parent node reference bumped? > > > Only very few drivers in the kernel use this API and I believe either > > s/very/a/ (sorry for the confusion) > > > > nobody knows what they are doing and you are right, or you are doing > > > something which is not needed. > > > > I need to set the of_node and fwnode fields of struct device to enable > > OF-based lookups of GPIOs and PWMs. The of_node field is meant to be > > populated by the driver core when the device is created, with a > > reference to the OF node. When populated directly by driver, this needs > > to be taken into account, and drivers need to ensure the reference will > > be released correctly. device_set_of_node_from_dev() is meant for that. > > What you are doing is sharing the parent node with the child, but at > the same time you bump the parent's reference count. As this is a > child of MFD I don't think you need this as MFD already takes care of > it via parent -> child natural dependencies. Is it incorrect > understanding? It is true that the parent device will not be destroyed as long as the child device exists. The parent device's of_node will thus be kept around by the reference that the parent device holds on it. However, if I set dev.of_node for the child device without acquiring a reference, we will have dev.of_node pointing to the same device_node, with a single reference to it. This means that when the child device is destroyed and platform_device_release() is called for it, of_node_put() will release that reference, and the parent dev.of_node will point to a device_node without holding a reference. Then, when the parent device, which is an i2c_client, is unregistered, the call to i2c_unregister_device() will call of_node_put(), releasing a reference we don't have. The order of i2c_unregister_device() and platform_device_release() may be swapped in practice, I haven't double-checked, but the reasoning still holds. We have two functions that expect dev.of_node to hold a reference, so both dev.of_node need to hold a reference. Another way to handle the problem would be to borrow the parent's reference in the probe function of the child, and set dev.of_node to NULL manually in the child .remove() function. This will ensure that platform_device_release(), which is called after .remove() (not necessarily directly after, but certainly not before), will not attempt to incorrectly release a reference on dev.of_node. This will however not be safe if i2c_unregister_device() is called before the child .remove(), as the child dev.of_node would then for some amount of time point to a device_node without a reference. TL;DR: Using device_set_of_node_from_dev() seems the safest option, especially given that it was designed for this purpose. -- Regards, Laurent Pinchart
