| Message ID | 20220901221857.2600340-1-michael@walle.cc |
|---|---|
| Headers | show |
| Series | nvmem: core: introduce NVMEM layouts | expand |
On 9/1/22 15:18, Michael Walle wrote: > Add a helper to add an offset to a ethernet address. This comes in handy > if you have a base ethernet address for multiple interfaces. > > Signed-off-by: Michael Walle <michael@walle.cc> > Reviewed-by: Andrew Lunn <andrew@lunn.ch> > Acked-by: Jakub Kicinski <kuba@kernel.org> > --- > changes since v1: > - none > > include/linux/etherdevice.h | 14 ++++++++++++++ > 1 file changed, 14 insertions(+) > > diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h > index a541f0c4f146..f144cadbe99d 100644 > --- a/include/linux/etherdevice.h > +++ b/include/linux/etherdevice.h > @@ -507,6 +507,20 @@ static inline void eth_addr_inc(u8 *addr) > u64_to_ether_addr(u, addr); > } > > +/** > + * eth_addr_add() - Add (or subtract) and offset to/from the given MAC address. an offset ? > + * > + * @offset: Offset to add. > + * @addr: Pointer to a six-byte array containing Ethernet address to increment. > + */ > +static inline void eth_addr_add(u8 *addr, long offset) > +{ > + u64 u = ether_addr_to_u64(addr); > + > + u += offset; > + u64_to_ether_addr(u, addr); > +} > + > /** > * is_etherdev_addr - Tell if given Ethernet address belongs to the device. > * @dev: Pointer to a device structure
Am 2022-09-02 01:22, schrieb Randy Dunlap: >> +/** >> + * eth_addr_add() - Add (or subtract) and offset to/from the given >> MAC address. > > an offset > ? yes thanks, I'll change that in the next version. -michael
Am 2022-09-02 00:18, schrieb Michael Walle: > In preparation of retiring the global post processing hook change this > driver to use layouts. The layout will be supplied during registration > and will be used to add the post processing hook to all added cells. > > Signed-off-by: Michael Walle <michael@walle.cc> > --- > Complile-time tested only! Please test. Tested-by: Michael Walle <michael@walle.cc> # on kontron-pitx-imx8m -michael
On 01/09/2022 23:18, Michael Walle wrote: > + ret = of_parse_phandle_with_optional_args(np, "nvmem-cells", > + "#nvmem-cell-cells", > + index, &cell_spec); where is the bindings for this new #nvmem-cell-cells property? --srini
On 01/09/2022 23:18, Michael Walle wrote: > Add a new function to add exactly one cell. This will be used by the > nvmem layout drivers to add custom cells. In contrast to the > nvmem_add_cells(), this has the advantage that we don't have to assemble > a list of cells on runtime. > > Signed-off-by: Michael Walle <michael@walle.cc> > --- > changes since v1: > - none > > drivers/nvmem/core.c | 58 ++++++++++++++++++++-------------- > include/linux/nvmem-provider.h | 8 +++++ > 2 files changed, 42 insertions(+), 24 deletions(-) > > diff --git a/drivers/nvmem/core.c b/drivers/nvmem/core.c > index be38e62fd190..3dfd149374a8 100644 > --- a/drivers/nvmem/core.c > +++ b/drivers/nvmem/core.c > @@ -501,6 +501,35 @@ static int nvmem_cell_info_to_nvmem_cell_entry(struct nvmem_device *nvmem, > return 0; > } > > +/** > + * nvmem_add_one_cell() - Add one cell information to an nvmem device > + * > + * @nvmem: nvmem device to add cells to. > + * @info: nvmem cell info to add to the device > + * > + * Return: 0 or negative error code on failure. > + */ > +int nvmem_add_one_cell(struct nvmem_device *nvmem, > + const struct nvmem_cell_info *info) > +{ > + struct nvmem_cell_entry *cell; > + int rval; > + > + cell = kzalloc(sizeof(*cell), GFP_KERNEL); > + if (!cell) > + return -ENOMEM; > + > + rval = nvmem_cell_info_to_nvmem_cell_entry(nvmem, info, cell); > + if (rval) { > + kfree(cell); > + return rval; > + } > + > + nvmem_cell_entry_add(cell); > + > + return 0; > +} > + EXPORT_SYMBOL_GPL ??? > /** > * nvmem_add_cells() - Add cell information to an nvmem device > * > @@ -514,34 +543,15 @@ static int nvmem_add_cells(struct nvmem_device *nvmem, > const struct nvmem_cell_info *info, > int ncells) > { > - struct nvmem_cell_entry **cells; > - int i, rval = 0; > - > - cells = kcalloc(ncells, sizeof(*cells), GFP_KERNEL); > - if (!cells) > - return -ENOMEM; > + int i, rval; > > for (i = 0; i < ncells; i++) { > - cells[i] = kzalloc(sizeof(**cells), GFP_KERNEL); > - if (!cells[i]) { > - rval = -ENOMEM; > - goto out; > - } > - > - rval = nvmem_cell_info_to_nvmem_cell_entry(nvmem, &info[i], cells[i]); > - if (rval) { > - kfree(cells[i]); > - goto out; > - } > - > - nvmem_cell_entry_add(cells[i]); > + rval = nvmem_add_one_cell(nvmem, &info[i]); > + if (rval) > + return rval; > } > > -out: > - /* remove tmp array */ > - kfree(cells); > - > - return rval; > + return 0; > } > > /** > diff --git a/include/linux/nvmem-provider.h b/include/linux/nvmem-provider.h > index 14a32a1bc249..385d29168008 100644 > --- a/include/linux/nvmem-provider.h > +++ b/include/linux/nvmem-provider.h > @@ -155,6 +155,9 @@ struct nvmem_device *devm_nvmem_register(struct device *dev, > void nvmem_add_cell_table(struct nvmem_cell_table *table); > void nvmem_del_cell_table(struct nvmem_cell_table *table); > > +int nvmem_add_one_cell(struct nvmem_device *nvmem, > + const struct nvmem_cell_info *info); > + > #else > > static inline struct nvmem_device *nvmem_register(const struct nvmem_config *c) > @@ -172,6 +175,11 @@ devm_nvmem_register(struct device *dev, const struct nvmem_config *c) > > static inline void nvmem_add_cell_table(struct nvmem_cell_table *table) {} > static inline void nvmem_del_cell_table(struct nvmem_cell_table *table) {} > +static inline int nvmem_add_one_cell(struct nvmem_device *nvmem, > + const struct nvmem_cell_info *info) > +{ > + return -EOPNOTSUPP; > +} > > #endif /* CONFIG_NVMEM */ > #endif /* ifndef _LINUX_NVMEM_PROVIDER_H */
On 01/09/2022 23:18, Michael Walle wrote: > It doesn't make any more sense to have a opaque pointer set up by the > nvmem device. Usually, the layout isn't associated with a particular > nvmem device. > This is really not a good idea to remove the context pointer, as this is the only way for callback to get context which it can make use of. I would prefer this to be left as it is. --srini > Signed-off-by: Michael Walle <michael@walle.cc> > --- > changes since v1: > - new patch > > drivers/nvmem/core.c | 4 ++-- > drivers/nvmem/imx-ocotp.c | 4 ++-- > include/linux/nvmem-provider.h | 5 +++-- > 3 files changed, 7 insertions(+), 6 deletions(-) > > diff --git a/drivers/nvmem/core.c b/drivers/nvmem/core.c > index d31d3f0ab517..6910796937f9 100644 > --- a/drivers/nvmem/core.c > +++ b/drivers/nvmem/core.c > @@ -1523,8 +1523,8 @@ static int __nvmem_cell_read(struct nvmem_device *nvmem, > nvmem_shift_read_buffer_in_place(cell, buf); > > if (cell->read_post_process) { > - rc = cell->read_post_process(nvmem->priv, id, index, > - cell->offset, buf, cell->bytes); > + rc = cell->read_post_process(id, index, cell->offset, buf, > + cell->bytes); > if (rc) > return rc; > } > diff --git a/drivers/nvmem/imx-ocotp.c b/drivers/nvmem/imx-ocotp.c > index ac0edb6398f1..5e869d4a81c5 100644 > --- a/drivers/nvmem/imx-ocotp.c > +++ b/drivers/nvmem/imx-ocotp.c > @@ -222,8 +222,8 @@ static int imx_ocotp_read(void *context, unsigned int offset, > return ret; > } > > -static int imx_ocotp_cell_pp(void *context, const char *id, int index, > - unsigned int offset, void *data, size_t bytes) > +static int imx_ocotp_cell_pp(const char *id, int index, unsigned int offset, > + void *data, size_t bytes) > { > u8 *buf = data; > int i; > diff --git a/include/linux/nvmem-provider.h b/include/linux/nvmem-provider.h > index 9d22dc5a3fa5..46067a6a0395 100644 > --- a/include/linux/nvmem-provider.h > +++ b/include/linux/nvmem-provider.h > @@ -19,8 +19,9 @@ typedef int (*nvmem_reg_read_t)(void *priv, unsigned int offset, > typedef int (*nvmem_reg_write_t)(void *priv, unsigned int offset, > void *val, size_t bytes); > /* used for vendor specific post processing of cell data */ > -typedef int (*nvmem_cell_post_process_t)(void *priv, const char *id, int index, > - unsigned int offset, void *buf, size_t bytes); > +typedef int (*nvmem_cell_post_process_t)(const char *id, int index, > + unsigned int offset, void *buf, > + size_t bytes); > > enum nvmem_type { > NVMEM_TYPE_UNKNOWN = 0,
Am 2022-09-09 10:52, schrieb Srinivas Kandagatla: > On 01/09/2022 23:18, Michael Walle wrote: >> It doesn't make any more sense to have a opaque pointer set up by the >> nvmem device. Usually, the layout isn't associated with a particular >> nvmem device. >> > This is really not a good idea to remove the context pointer, as this > is the only way for callback to get context which it can make use of. In which case? As I mentioned it's the priv to the nvmem driver and all the "normal" callbacks can do very little with it. If there will be a future need, then there should be a proper opaque pointer associated with the layout and not the nvmem driver. -michael > I would prefer this to be left as it is. > > --srini > >> Signed-off-by: Michael Walle <michael@walle.cc> >> --- >> changes since v1: >> - new patch >> >> drivers/nvmem/core.c | 4 ++-- >> drivers/nvmem/imx-ocotp.c | 4 ++-- >> include/linux/nvmem-provider.h | 5 +++-- >> 3 files changed, 7 insertions(+), 6 deletions(-) >> >> diff --git a/drivers/nvmem/core.c b/drivers/nvmem/core.c >> index d31d3f0ab517..6910796937f9 100644 >> --- a/drivers/nvmem/core.c >> +++ b/drivers/nvmem/core.c >> @@ -1523,8 +1523,8 @@ static int __nvmem_cell_read(struct nvmem_device >> *nvmem, >> nvmem_shift_read_buffer_in_place(cell, buf); >> if (cell->read_post_process) { >> - rc = cell->read_post_process(nvmem->priv, id, index, >> - cell->offset, buf, cell->bytes); >> + rc = cell->read_post_process(id, index, cell->offset, buf, >> + cell->bytes); >> if (rc) >> return rc; >> } >> diff --git a/drivers/nvmem/imx-ocotp.c b/drivers/nvmem/imx-ocotp.c >> index ac0edb6398f1..5e869d4a81c5 100644 >> --- a/drivers/nvmem/imx-ocotp.c >> +++ b/drivers/nvmem/imx-ocotp.c >> @@ -222,8 +222,8 @@ static int imx_ocotp_read(void *context, unsigned >> int offset, >> return ret; >> } >> -static int imx_ocotp_cell_pp(void *context, const char *id, int >> index, >> - unsigned int offset, void *data, size_t bytes) >> +static int imx_ocotp_cell_pp(const char *id, int index, unsigned int >> offset, >> + void *data, size_t bytes) >> { >> u8 *buf = data; >> int i; >> diff --git a/include/linux/nvmem-provider.h >> b/include/linux/nvmem-provider.h >> index 9d22dc5a3fa5..46067a6a0395 100644 >> --- a/include/linux/nvmem-provider.h >> +++ b/include/linux/nvmem-provider.h >> @@ -19,8 +19,9 @@ typedef int (*nvmem_reg_read_t)(void *priv, unsigned >> int offset, >> typedef int (*nvmem_reg_write_t)(void *priv, unsigned int offset, >> void *val, size_t bytes); >> /* used for vendor specific post processing of cell data */ >> -typedef int (*nvmem_cell_post_process_t)(void *priv, const char *id, >> int index, >> - unsigned int offset, void *buf, size_t bytes); >> +typedef int (*nvmem_cell_post_process_t)(const char *id, int index, >> + unsigned int offset, void *buf, >> + size_t bytes); >> enum nvmem_type { >> NVMEM_TYPE_UNKNOWN = 0,
On 09/09/2022 09:58, Michael Walle wrote: > Am 2022-09-09 10:52, schrieb Srinivas Kandagatla: >> On 01/09/2022 23:18, Michael Walle wrote: >>> It doesn't make any more sense to have a opaque pointer set up by the >>> nvmem device. Usually, the layout isn't associated with a particular >>> nvmem device. >>> >> This is really not a good idea to remove the context pointer, as this >> is the only way for callback to get context which it can make use of. > > In which case? As I mentioned it's the priv to the nvmem driver and all > the "normal" callbacks can do very little with it. If there will be a > future need, then there should be a proper opaque pointer associated > with the layout and not the nvmem driver. Yes, the opaque object here is the layout priv which I agree with, but removing the context totally from the callback is not a good idea. We should have some context to callbacks to be able to allow them to deal with some private info. --srini > > -michael > >> I would prefer this to be left as it is. >> >> --srini >> >>> Signed-off-by: Michael Walle <michael@walle.cc> >>> --- >>> changes since v1: >>> - new patch >>> >>> drivers/nvmem/core.c | 4 ++-- >>> drivers/nvmem/imx-ocotp.c | 4 ++-- >>> include/linux/nvmem-provider.h | 5 +++-- >>> 3 files changed, 7 insertions(+), 6 deletions(-) >>> >>> diff --git a/drivers/nvmem/core.c b/drivers/nvmem/core.c >>> index d31d3f0ab517..6910796937f9 100644 >>> --- a/drivers/nvmem/core.c >>> +++ b/drivers/nvmem/core.c >>> @@ -1523,8 +1523,8 @@ static int __nvmem_cell_read(struct >>> nvmem_device *nvmem, >>> nvmem_shift_read_buffer_in_place(cell, buf); >>> if (cell->read_post_process) { >>> - rc = cell->read_post_process(nvmem->priv, id, index, >>> - cell->offset, buf, cell->bytes); >>> + rc = cell->read_post_process(id, index, cell->offset, buf, >>> + cell->bytes); >>> if (rc) >>> return rc; >>> } >>> diff --git a/drivers/nvmem/imx-ocotp.c b/drivers/nvmem/imx-ocotp.c >>> index ac0edb6398f1..5e869d4a81c5 100644 >>> --- a/drivers/nvmem/imx-ocotp.c >>> +++ b/drivers/nvmem/imx-ocotp.c >>> @@ -222,8 +222,8 @@ static int imx_ocotp_read(void *context, unsigned >>> int offset, >>> return ret; >>> } >>> -static int imx_ocotp_cell_pp(void *context, const char *id, int >>> index, >>> - unsigned int offset, void *data, size_t bytes) >>> +static int imx_ocotp_cell_pp(const char *id, int index, unsigned int >>> offset, >>> + void *data, size_t bytes) >>> { >>> u8 *buf = data; >>> int i; >>> diff --git a/include/linux/nvmem-provider.h >>> b/include/linux/nvmem-provider.h >>> index 9d22dc5a3fa5..46067a6a0395 100644 >>> --- a/include/linux/nvmem-provider.h >>> +++ b/include/linux/nvmem-provider.h >>> @@ -19,8 +19,9 @@ typedef int (*nvmem_reg_read_t)(void *priv, >>> unsigned int offset, >>> typedef int (*nvmem_reg_write_t)(void *priv, unsigned int offset, >>> void *val, size_t bytes); >>> /* used for vendor specific post processing of cell data */ >>> -typedef int (*nvmem_cell_post_process_t)(void *priv, const char *id, >>> int index, >>> - unsigned int offset, void *buf, size_t bytes); >>> +typedef int (*nvmem_cell_post_process_t)(const char *id, int index, >>> + unsigned int offset, void *buf, >>> + size_t bytes); >>> enum nvmem_type { >>> NVMEM_TYPE_UNKNOWN = 0,
Am 2022-09-09 11:08, schrieb Srinivas Kandagatla: > On 09/09/2022 09:58, Michael Walle wrote: >> Am 2022-09-09 10:52, schrieb Srinivas Kandagatla: >>> On 01/09/2022 23:18, Michael Walle wrote: >>>> It doesn't make any more sense to have a opaque pointer set up by >>>> the >>>> nvmem device. Usually, the layout isn't associated with a particular >>>> nvmem device. >>>> >>> This is really not a good idea to remove the context pointer, as this >>> is the only way for callback to get context which it can make use of. >> >> In which case? As I mentioned it's the priv to the nvmem driver and >> all >> the "normal" callbacks can do very little with it. If there will be a >> future need, then there should be a proper opaque pointer associated >> with the layout and not the nvmem driver. > > Yes, the opaque object here is the layout priv which I agree with, but > removing the context totally from the callback is not a good idea. > > We should have some context to callbacks to be able to allow them to > deal with some private info. I agree, but my thinking was this: as the old priv pointer doesn't make any sense and no one is using it at the moment for now, we can remove it it. If it's needed again it can easily added together with a user. That being said, I could leave the pointer argument and just pass NULL, so if someone (re)adds that, we don't have to modify all the callbacks. Because we don't have any user for now, I could only speculate who should or could set that pointer. -michael
Hi Michael, Srinivas, + Thomas and Robert michael@walle.cc wrote on Fri, 2 Sep 2022 00:18:37 +0200: > This is now the third attempt to fetch the MAC addresses from the VPD > for the Kontron sl28 boards. Previous discussions can be found here: > https://lore.kernel.org/lkml/20211228142549.1275412-1-michael@walle.cc/ > > > NVMEM cells are typically added by board code or by the devicetree. But > as the cells get more complex, there is (valid) push back from the > devicetree maintainers to not put that handling in the devicetree. > > Therefore, introduce NVMEM layouts. They operate on the NVMEM device and > can add cells during runtime. That way it is possible to add more complex > cells than it is possible right now with the offset/length/bits > description in the device tree. For example, you can have post processing > for individual cells (think of endian swapping, or ethernet offset > handling). > > The imx-ocotp driver is the only user of the global post processing hook, > convert it to nvmem layouts and drop the global post pocessing hook. Please > note, that this change is only compile-time tested. These layouts are an excellent idea. I actually have a new use case for them. In modern Ethernet switches which follow the ONIE standard [1] there is an nvmem device which contains a standardized type-length-value array with many information about manufacturing and mac addresses. There is no "static" pattern there and anyway so many possible entries that it would be very tedious to list all of them in the bindings, as each manufacturer chooses what it want to export on each of its devices (although reading the data sequentially and extracting the cells is rather straightforward). Moreover, the specification [1] does not define any storage device type, so it can be eg. an MTD device or an EEPROM. Having an nvmem device provider separated from the nvmem cells provider makes complete sense, the "layout" drivers idea proposed by Michael seem to be a perfect fit. Srinivas, can you give us an update on what you think about this series (not a commitment, just how you feel it overall)? Michael, is there a v3 in preparation? I'll try to write something on top of your v2 otherwise. > You can also have cells which have no static offset, like the > ones in an u-boot environment. The last patches will convert the current > u-boot environment driver to a NVMEM layout and lifting the restriction > that it only works with mtd devices. But as it will change the required > compatible strings, it is marked as RFC for now. It also needs to have > its device tree schema update which is left out here. These two patches > are not expected to be applied, but rather to show another example of > how to use the layouts. Actually I think these two matches make complete sense, right now one can only use the u-boot-env cells if the environment is stored in an mtd device, of course this covers many cases but not all of them and it would be really nice to have this first layout example merged, not only on the mailing list. > For now, the layouts are selected by a specific compatible string in a > device tree. E.g. the VPD on the kontron sl28 do (within a SPI flash node): > compatible = "kontron,sl28-vpd", "user-otp"; > or if you'd use the u-boot environment (within an MTD patition): > compatible = "u-boot,env", "nvmem"; > > The "user-otp" (or "nvmem") will lead to a NVMEM device, the > "kontron,sl28-vpd" (or "u-boot,env") will then apply the specific layout > on top of the NVMEM device. Thanks, Miquèl
Hi Michael, michael@walle.cc wrote on Fri, 2 Sep 2022 00:18:56 +0200: > Instead of hardcoding the underlying access method mtd_read() and > duplicating all the error handling, rewrite the driver as a nvmem > layout which just uses nvmem_device_read() and thus works with any > NVMEM device. > > But because this is now not a device anymore, the compatible string > will have to be changed so the device will still be probed: > compatible = "u-boot,env"; > to > compatible = "u-boot,env", "nvmem-cells"; > > "nvmem-cells" will tell the mtd layer to register a nvmem_device(). > "u-boot,env" will tell the NVMEM that it should apply the u-boot > environment layout to the NVMEM device. > > Signed-off-by: Michael Walle <michael@walle.cc> > --- > changes since v1: > - none > > drivers/nvmem/layouts/Kconfig | 8 ++ > drivers/nvmem/layouts/Makefile | 1 + > drivers/nvmem/layouts/u-boot-env.c | 144 +++++++++++++++++++ > drivers/nvmem/u-boot-env.c | 218 ----------------------------- Nit: IIRC there is a MAINTAINERS entry to update as well. Thanks, Miquèl
On 21/09/2022 10:58, Miquel Raynal wrote: > > Srinivas, can you give us an update on what you think about this > series (not a commitment, just how you feel it overall)? > Overall this is going in right direction, there are few bindings related comments once those are sorted out it should be good to go. From NVMEM side am happy with this feature, which has been a long pending one. We have few discussions on ONIE standard before, layouts would fit in nicely. --srini > Michael, is there a v3 in preparation? I'll try to write something on > top of your v2 otherwise.
Hi Srinivas, Thanks for the quick feedback. srinivas.kandagatla@linaro.org wrote on Thu, 22 Sep 2022 22:22:17 +0100: > On 21/09/2022 10:58, Miquel Raynal wrote: > > > > Srinivas, can you give us an update on what you think about this > > series (not a commitment, just how you feel it overall)? > > > Overall this is going in right direction, there are few bindings related comments once those are sorted out it should be good to go. Ok, let's tackle those. > From NVMEM side am happy with this feature, which has been a long pending one. > > We have few discussions on ONIE standard before, layouts would fit in nicely. I agree they would. Thanks, Miquèl
Hi Michael, I have a few additional questions regarding the bindings. michael@walle.cc wrote on Fri, 2 Sep 2022 00:18:37 +0200: > This is now the third attempt to fetch the MAC addresses from the VPD > for the Kontron sl28 boards. Previous discussions can be found here: > https://lore.kernel.org/lkml/20211228142549.1275412-1-michael@walle.cc/ > > > NVMEM cells are typically added by board code or by the devicetree. But > as the cells get more complex, there is (valid) push back from the > devicetree maintainers to not put that handling in the devicetree. > > Therefore, introduce NVMEM layouts. They operate on the NVMEM device and > can add cells during runtime. That way it is possible to add more complex > cells than it is possible right now with the offset/length/bits > description in the device tree. For example, you can have post processing > for individual cells (think of endian swapping, or ethernet offset > handling). > > The imx-ocotp driver is the only user of the global post processing hook, > convert it to nvmem layouts and drop the global post pocessing hook. Please > note, that this change is only compile-time tested. > > You can also have cells which have no static offset, like the > ones in an u-boot environment. The last patches will convert the current > u-boot environment driver to a NVMEM layout and lifting the restriction > that it only works with mtd devices. But as it will change the required > compatible strings, it is marked as RFC for now. It also needs to have > its device tree schema update which is left out here. These two patches > are not expected to be applied, but rather to show another example of > how to use the layouts. > > For now, the layouts are selected by a specific compatible string in a > device tree. E.g. the VPD on the kontron sl28 do (within a SPI flash node): > compatible = "kontron,sl28-vpd", "user-otp"; > or if you'd use the u-boot environment (within an MTD patition): > compatible = "u-boot,env", "nvmem"; > > The "user-otp" (or "nvmem") will lead to a NVMEM device, the > "kontron,sl28-vpd" (or "u-boot,env") will then apply the specific layout > on top of the NVMEM device. So if I understand correctly, there should be: - one DT node defining the storage medium eeprom/mtd/whatever, - another DT node defining the nvmem device with two compatibles, the "nvmem" (or "user-otp") and the layout. Is this correct? Actually I was a bit surprised because generally speaking, DT maintainers (rightfully) do not want to describe how we use devices, the nvmem abstraction looks like a Linux thing when on top of mtd devices for instance, so I just wanted to confirm this point. Then, as we have an nvmem device described in the DT, why not just pointing at the nvmem device from the cell consumer, rather than still having the need to define all the cells that the nvmem device will produce in the DT? Maybe an example to show what I mean. Here is the current way: nvmem_provider: nvmem-provider { properties; mycell: my_cell { [properties;] }; }; And we point to a cell with: nvmem-cells = <&mycell>; But, as for the tlv tables, there are many cells that will be produced, and the driver may anyway just ask for the cell name (eg. performing a lookup of the "mac-address" cell name), so why bothering to describe all the cells in the DT, like: nvmem-cells-providers = <&nvmem_provider>; What do you think? Maybe for the mac addresses this is a bit limiting as, in practice, we often have base mac addresses available and using: nvmem-cells = <&mycell INDEX>; allows to dynamically create many different mac addresses, but I wonder if the approach would be interesting for other cell types. Just an open question. Thanks, Miquèl
Hi, Am 2022-09-23 17:47, schrieb Miquel Raynal: > I have a few additional questions regarding the bindings. > > michael@walle.cc wrote on Fri, 2 Sep 2022 00:18:37 +0200: > >> This is now the third attempt to fetch the MAC addresses from the VPD >> for the Kontron sl28 boards. Previous discussions can be found here: >> https://lore.kernel.org/lkml/20211228142549.1275412-1-michael@walle.cc/ >> >> >> NVMEM cells are typically added by board code or by the devicetree. >> But >> as the cells get more complex, there is (valid) push back from the >> devicetree maintainers to not put that handling in the devicetree. >> >> Therefore, introduce NVMEM layouts. They operate on the NVMEM device >> and >> can add cells during runtime. That way it is possible to add more >> complex >> cells than it is possible right now with the offset/length/bits >> description in the device tree. For example, you can have post >> processing >> for individual cells (think of endian swapping, or ethernet offset >> handling). >> >> The imx-ocotp driver is the only user of the global post processing >> hook, >> convert it to nvmem layouts and drop the global post pocessing hook. >> Please >> note, that this change is only compile-time tested. >> >> You can also have cells which have no static offset, like the >> ones in an u-boot environment. The last patches will convert the >> current >> u-boot environment driver to a NVMEM layout and lifting the >> restriction >> that it only works with mtd devices. But as it will change the >> required >> compatible strings, it is marked as RFC for now. It also needs to have >> its device tree schema update which is left out here. These two >> patches >> are not expected to be applied, but rather to show another example of >> how to use the layouts. >> >> For now, the layouts are selected by a specific compatible string in a >> device tree. E.g. the VPD on the kontron sl28 do (within a SPI flash >> node): >> compatible = "kontron,sl28-vpd", "user-otp"; >> or if you'd use the u-boot environment (within an MTD patition): >> compatible = "u-boot,env", "nvmem"; >> >> The "user-otp" (or "nvmem") will lead to a NVMEM device, the >> "kontron,sl28-vpd" (or "u-boot,env") will then apply the specific >> layout >> on top of the NVMEM device. > > So if I understand correctly, there should be: > - one DT node defining the storage medium eeprom/mtd/whatever, > - another DT node defining the nvmem device with two compatibles, the > "nvmem" (or "user-otp") and the layout. > Is this correct? Actually I was a bit surprised because generally > speaking, DT maintainers (rightfully) do not want to describe how we > use devices, the nvmem abstraction looks like a Linux thing when on top > of mtd devices for instance, so I just wanted to confirm this point. What do you mean by two nodes? Two separate ones or one being a subnode of the other? There is only one (storage) node and nvmem cells as subnodes. The two compatibles aren't strictly needed. But it will simplify the drivers in linux greatly. Otherwise the storage driver would need to know for which compatibles it needs to register a nvmem device. E.g. MTD devices determine that by the "nvmem" compatible. The OTP driver will probe by "{user,factory}-otp". If you'd only have one compatible, the storage driver would need a list of all the layouts so it can register a nvmem device. But also from a device tree POV this makes sense IMHO because the second compatible is a more specific one. With only the more generic compatible you just get a nvmem device without any cells - or only the cells described in the device tree. Regarding "describe how the devices are used": then there shouldn't be nvmem (cell) bindings at all, because you are actually describing how you are using the nvmem provider. So IMHO having for example the compatible "kontron,sl28-vpd" is actually fits more than having a nvmem provider compatible with cells subnodes. > Then, as we have an nvmem device described in the DT, why not just > pointing at the nvmem device from the cell consumer, rather than still > having the need to define all the cells that the nvmem device will > produce in the DT? See also https://lore.kernel.org/linux-devicetree/4bf16e18-1591-8bc9-7c46-649391de3761@linaro.org/ > Maybe an example to show what I mean. Here is the current way: > > nvmem_provider: nvmem-provider { > properties; > > mycell: my_cell { > [properties;] > }; > }; > > And we point to a cell with: > > nvmem-cells = <&mycell>; > > But, as for the tlv tables, there are many cells that will be produced, > and the driver may anyway just ask for the cell name (eg. performing a > lookup of the "mac-address" cell name), so why bothering to describe > all > the cells in the DT, like: > > nvmem-cells-providers = <&nvmem_provider>; > > What do you think? Ok, you even go one step further and even removing the argument of the phandle and you are proposing to use the nvmem-cell-name, right? That might work with simple cells created by a layout. But what if there are two consumers with different names for the same cell? Consumer bindings might already be present, e.g. the ethernet bindings will use "mac-address". What if there is another binding which want to use that cell but doesn't name it "mac-address"? IMHO to reference a nvmem cell you shouldn't rely on the consumer. Also keep in mind, that the number of arguments is fixed and given by the "#.*-cells" property found on the target node. Therefore, that won't work if you have cells where one has an argument and another don't. > Maybe for the mac addresses this is a bit limiting as, in practice, we > often have base mac addresses available and using: > > nvmem-cells = <&mycell INDEX>; > > allows to dynamically create many different mac addresses, but I wonder > if the approach would be interesting for other cell types. Just an open > question. So how would your idea work with that? Maybe we could support both? But again, I'm not sure if it is a good idea to mix the consumer with the provider. -michael