Eric Lee / smarc-uboot

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit accaae

mentioned in commit d2e938

mentioned in commit c877ef

mentioned in commit d64caa

mentioned in commit e5e06b

mentioned in commit 291da9

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit accaae

mentioned in commit d2e938

mentioned in commit c877ef

mentioned in commit d64caa

mentioned in commit e5e06b

mentioned in commit 291da9

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit accaae

mentioned in commit d2e938

mentioned in commit c877ef

mentioned in commit d64caa

mentioned in commit e5e06b

mentioned in commit 291da9

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit accaae

mentioned in commit d2e938

mentioned in commit c877ef

mentioned in commit d64caa

mentioned in commit e5e06b

mentioned in commit 291da9

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit accaae

mentioned in commit d2e938

mentioned in commit c877ef

mentioned in commit d64caa

mentioned in commit e5e06b

mentioned in commit 291da9

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit accaae

mentioned in commit d2e938

mentioned in commit c877ef

mentioned in commit d64caa

mentioned in commit e5e06b

mentioned in commit 291da9

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit accaae

mentioned in commit d2e938

mentioned in commit c877ef

mentioned in commit d64caa

mentioned in commit e5e06b

mentioned in commit 291da9

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit accaae

mentioned in commit d2e938

mentioned in commit c877ef

mentioned in commit d64caa

mentioned in commit e5e06b

mentioned in commit 291da9

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit accaae

mentioned in commit d2e938

mentioned in commit c877ef

mentioned in commit d64caa

mentioned in commit e5e06b

mentioned in commit 291da9

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit accaae

mentioned in commit d2e938

mentioned in commit c877ef

mentioned in commit d64caa

mentioned in commit e5e06b

mentioned in commit 291da9

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit accaae

mentioned in commit d2e938

mentioned in commit c877ef

mentioned in commit d64caa

mentioned in commit e5e06b

mentioned in commit 291da9

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit accaae

mentioned in commit d2e938

mentioned in commit c877ef

mentioned in commit d64caa

mentioned in commit e5e06b

mentioned in commit 291da9

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit accaae

mentioned in commit d2e938

mentioned in commit c877ef

mentioned in commit d64caa

mentioned in commit e5e06b

mentioned in commit 291da9

mentioned in commit 05e23d

mentioned in commit 434d5a

mentioned in commit accaae

mentioned in commit d2e938

mentioned in commit c877ef

mentioned in commit d64caa

mentioned in commit e5e06b

mentioned in commit 291da9

GITLAB

Eric Lee / smarc-uboot

clk: implement clk_set_defaults()

 /*
  * Copyright (C) 2015 Google, Inc
  * Written by Simon Glass <sjg@chromium.org>
  * Copyright (c) 2016, NVIDIA CORPORATION.
+ * Copyright (c) 2018, Theobroma Systems Design und Consulting GmbH
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <common.h>
 #include <clk.h>
 #include <clk-uclass.h>
 #include <dm.h>
+#include <dm/read.h>
 #include <dt-structs.h>
 #include <errno.h>
 static inline const struct clk_ops *clk_dev_ops(struct udevice *dev)
 {
 	return (const struct clk_ops *)dev->driver->ops;
 }
 #if CONFIG_IS_ENABLED(OF_CONTROL)
 # if CONFIG_IS_ENABLED(OF_PLATDATA)
 int clk_get_by_index_platdata(struct udevice *dev, int index,
 			      struct phandle_1_arg *cells, struct clk *clk)
 {
 	int ret;
 	if (index != 0)
 		return -ENOSYS;
 	ret = uclass_get_device(UCLASS_CLK, 0, &clk->dev);
 	if (ret)
 		return ret;
 	clk->id = cells[0].arg[0];
 	return 0;
 }
 # else
 static int clk_of_xlate_default(struct clk *clk,
 				struct ofnode_phandle_args *args)
 {
 	debug("%s(clk=%p)\n", __func__, clk);
 	if (args->args_count > 1) {
 		debug("Invaild args_count: %d\n", args->args_count);
 		return -EINVAL;
 	}
 	if (args->args_count)
 		clk->id = args->args[0];
 	else
 		clk->id = 0;
 	return 0;
 }
 static int clk_get_by_indexed_prop(struct udevice *dev, const char *prop_name,
 				   int index, struct clk *clk)
 {
 	int ret;
 	struct ofnode_phandle_args args;
 	struct udevice *dev_clk;
 	const struct clk_ops *ops;
 	debug("%s(dev=%p, index=%d, clk=%p)\n", __func__, dev, index, clk);
 	assert(clk);
 	clk->dev = NULL;
 	ret = dev_read_phandle_with_args(dev, prop_name, "#clock-cells", 0,
 					 index, &args);
 	if (ret) {
 		debug("%s: fdtdec_parse_phandle_with_args failed: err=%d\n",
 		      __func__, ret);
 		return ret;
 	}
 	ret = uclass_get_device_by_ofnode(UCLASS_CLK, args.node, &dev_clk);
 	if (ret) {
 		debug("%s: uclass_get_device_by_of_offset failed: err=%d\n",
 		      __func__, ret);
 		return ret;
 	}
 	clk->dev = dev_clk;
 	ops = clk_dev_ops(dev_clk);
 	if (ops->of_xlate)
 		ret = ops->of_xlate(clk, &args);
 	else
 		ret = clk_of_xlate_default(clk, &args);
 	if (ret) {
 		debug("of_xlate() failed: %d\n", ret);
 		return ret;
 	}
 	return clk_request(dev_clk, clk);
 }
 int clk_get_by_index(struct udevice *dev, int index, struct clk *clk)
 {
 	return clk_get_by_indexed_prop(dev, "clocks", index, clk);
+}
+static int clk_set_default_parents(struct udevice *dev)
+{
+	struct clk clk, parent_clk;
+	int index;
+	int num_parents;
+	int ret;
+	num_parents = dev_count_phandle_with_args(dev, "assigned-clock-parents",
+						  "#clock-cells");
+	if (num_parents < 0) {
+		debug("%s: could not read assigned-clock-parents for %p\n",
+		      __func__, dev);
+		return 0;
+	}
+	for (index = 0; index < num_parents; index++) {
+		ret = clk_get_by_indexed_prop(dev, "assigned-clock-parents",
+					      index, &parent_clk);
+		if (ret) {
+			debug("%s: could not get parent clock %d for %s\n",
+			      __func__, index, dev_read_name(dev));
+			return ret;
+		}
+		ret = clk_get_by_indexed_prop(dev, "assigned-clocks",
+					      index, &clk);
+		if (ret) {
+			debug("%s: could not get assigned clock %d for %s\n",
+			      __func__, index, dev_read_name(dev));
+			return ret;
+		}
+		ret = clk_set_parent(&clk, &parent_clk);
+		/*
+		 * Not all drivers may support clock-reparenting (as of now).
+		 * Ignore errors due to this.
+		 */
+		if (ret == -ENOSYS)
+			continue;
+		if (ret) {
+			debug("%s: failed to reparent clock %d for %s\n",
+			      __func__, index, dev_read_name(dev));
+			return ret;
+		}
+	}
+	return 0;
+}
+static int clk_set_default_rates(struct udevice *dev)
+{
+	struct clk clk;
+	int index;
+	int num_rates;
+	int size;
+	int ret = 0;
+	u32 *rates = NULL;
+	size = dev_read_size(dev, "assigned-clock-rates");
+	if (size < 0)
+		return 0;
+	num_rates = size / sizeof(u32);
+	rates = calloc(num_rates, sizeof(u32));
+	if (!rates)
+		return -ENOMEM;
+	ret = dev_read_u32_array(dev, "assigned-clock-rates", rates, num_rates);
+	if (ret)
+		goto fail;
+	for (index = 0; index < num_rates; index++) {
+		ret = clk_get_by_indexed_prop(dev, "assigned-clocks",
+					      index, &clk);
+		if (ret) {
+			debug("%s: could not get assigned clock %d for %s\n",
+			      __func__, index, dev_read_name(dev));
+			continue;
+		}
+		ret = clk_set_rate(&clk, rates[index]);
+		if (ret < 0) {
+			debug("%s: failed to set rate on clock %d for %s\n",
+			      __func__, index, dev_read_name(dev));
+			break;
+		}
+	}
+fail:
+	free(rates);
+	return ret;
+}
+int clk_set_defaults(struct udevice *dev)
+{
+	int ret;
+	/* If this is running pre-reloc state, don't take any action. */
+	if (!(gd->flags & GD_FLG_RELOC))
+		return 0;
+	debug("%s(%s)\n", __func__, dev_read_name(dev));
+	ret = clk_set_default_parents(dev);
+	if (ret)
+		return ret;
+	ret = clk_set_default_rates(dev);
+	if (ret < 0)
+		return ret;
+	return 0;
 }
 # endif /* OF_PLATDATA */
 int clk_get_by_name(struct udevice *dev, const char *name, struct clk *clk)
 {
 	int index;
 	debug("%s(dev=%p, name=%s, clk=%p)\n", __func__, dev, name, clk);
 	clk->dev = NULL;
 	index = dev_read_stringlist_search(dev, "clock-names", name);
 	if (index < 0) {
 		debug("fdt_stringlist_search() failed: %d\n", index);
 		return index;
 	}
 	return clk_get_by_index(dev, index, clk);
 }
 int clk_release_all(struct clk *clk, int count)
 {
 	int i, ret;
 	for (i = 0; i < count; i++) {
 		debug("%s(clk[%d]=%p)\n", __func__, i, &clk[i]);
 		/* check if clock has been previously requested */
 		if (!clk[i].dev)
 			continue;
 		ret = clk_disable(&clk[i]);
 		if (ret && ret != -ENOSYS)
 			return ret;
 		ret = clk_free(&clk[i]);
 		if (ret && ret != -ENOSYS)
 			return ret;
 	}
 	return 0;
 }
 #endif /* OF_CONTROL */
 int clk_request(struct udevice *dev, struct clk *clk)
 {
 	const struct clk_ops *ops = clk_dev_ops(dev);
 	debug("%s(dev=%p, clk=%p)\n", __func__, dev, clk);
 	clk->dev = dev;
 	if (!ops->request)
 		return 0;
 	return ops->request(clk);
 }
 int clk_free(struct clk *clk)
 {
 	const struct clk_ops *ops = clk_dev_ops(clk->dev);
 	debug("%s(clk=%p)\n", __func__, clk);
 	if (!ops->free)
 		return 0;
 	return ops->free(clk);
 }
 ulong clk_get_rate(struct clk *clk)
 {
 	const struct clk_ops *ops = clk_dev_ops(clk->dev);
 	debug("%s(clk=%p)\n", __func__, clk);
 	if (!ops->get_rate)
 		return -ENOSYS;
 	return ops->get_rate(clk);
 }
 ulong clk_set_rate(struct clk *clk, ulong rate)
 {
 	const struct clk_ops *ops = clk_dev_ops(clk->dev);
 	debug("%s(clk=%p, rate=%lu)\n", __func__, clk, rate);
 	if (!ops->set_rate)
 		return -ENOSYS;
 	return ops->set_rate(clk, rate);
 }
 int clk_set_parent(struct clk *clk, struct clk *parent)
 {
 	const struct clk_ops *ops = clk_dev_ops(clk->dev);
 	debug("%s(clk=%p, parent=%p)\n", __func__, clk, parent);
 	if (!ops->set_parent)
 		return -ENOSYS;
 	return ops->set_parent(clk, parent);
 }
 int clk_enable(struct clk *clk)
 {
 	const struct clk_ops *ops = clk_dev_ops(clk->dev);
 	debug("%s(clk=%p)\n", __func__, clk);
 	if (!ops->enable)
 		return -ENOSYS;
 	return ops->enable(clk);
 }
 int clk_disable(struct clk *clk)
 {
 	const struct clk_ops *ops = clk_dev_ops(clk->dev);
 	debug("%s(clk=%p)\n", __func__, clk);
 	if (!ops->disable)
 		return -ENOSYS;
 	return ops->disable(clk);
 }
 UCLASS_DRIVER(clk) = {
 	.id		= UCLASS_CLK,
 	.name		= "clk",
 };

 /*
  * Device manager
  *
  * Copyright (c) 2013 Google, Inc
  *
  * (C) Copyright 2012
  * Pavel Herrmann <morpheus.ibis@gmail.com>
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <common.h>
 #include <asm/io.h>
+#include <clk.h>
 #include <fdtdec.h>
 #include <fdt_support.h>
 #include <malloc.h>
 #include <dm/device.h>
 #include <dm/device-internal.h>
 #include <dm/lists.h>
 #include <dm/of_access.h>
 #include <dm/pinctrl.h>
 #include <dm/platdata.h>
 #include <dm/read.h>
 #include <dm/uclass.h>
 #include <dm/uclass-internal.h>
 #include <dm/util.h>
 #include <linux/err.h>
 #include <linux/list.h>
 DECLARE_GLOBAL_DATA_PTR;
 static int device_bind_common(struct udevice *parent, const struct driver *drv,
 			      const char *name, void *platdata,
 			      ulong driver_data, ofnode node,
 			      uint of_platdata_size, struct udevice **devp)
 {
 	struct udevice *dev;
 	struct uclass *uc;
 	int size, ret = 0;
 	if (devp)
 		*devp = NULL;
 	if (!name)
 		return -EINVAL;
 	ret = uclass_get(drv->id, &uc);
 	if (ret) {
 		debug("Missing uclass for driver %s\n", drv->name);
 		return ret;
 	}
 	dev = calloc(1, sizeof(struct udevice));
 	if (!dev)
 		return -ENOMEM;
 	INIT_LIST_HEAD(&dev->sibling_node);
 	INIT_LIST_HEAD(&dev->child_head);
 	INIT_LIST_HEAD(&dev->uclass_node);
 #ifdef CONFIG_DEVRES
 	INIT_LIST_HEAD(&dev->devres_head);
 #endif
 	dev->platdata = platdata;
 	dev->driver_data = driver_data;
 	dev->name = name;
 	dev->node = node;
 	dev->parent = parent;
 	dev->driver = drv;
 	dev->uclass = uc;
 	dev->seq = -1;
 	dev->req_seq = -1;
 	if (CONFIG_IS_ENABLED(OF_CONTROL) && CONFIG_IS_ENABLED(DM_SEQ_ALIAS)) {
 		/*
 		 * Some devices, such as a SPI bus, I2C bus and serial ports
 		 * are numbered using aliases.
 		 *
 		 * This is just a 'requested' sequence, and will be
 		 * resolved (and ->seq updated) when the device is probed.
 		 */
 		if (uc->uc_drv->flags & DM_UC_FLAG_SEQ_ALIAS) {
 			if (uc->uc_drv->name && ofnode_valid(node)) {
 				dev_read_alias_seq(dev, &dev->req_seq);
 			}
 		}
 	}
 	if (drv->platdata_auto_alloc_size) {
 		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)
 					alloc = true;
 			}
 		}
 		if (alloc) {
 			dev->flags |= DM_FLAG_ALLOC_PDATA;
 			dev->platdata = calloc(1,
 					       drv->platdata_auto_alloc_size);
 			if (!dev->platdata) {
 				ret = -ENOMEM;
 				goto fail_alloc1;
 			}
 			if (CONFIG_IS_ENABLED(OF_PLATDATA) && platdata) {
 				memcpy(dev->platdata, platdata,
 				       of_platdata_size);
 			}
 		}
 	}
 	size = uc->uc_drv->per_device_platdata_auto_alloc_size;
 	if (size) {
 		dev->flags |= DM_FLAG_ALLOC_UCLASS_PDATA;
 		dev->uclass_platdata = calloc(1, size);
 		if (!dev->uclass_platdata) {
 			ret = -ENOMEM;
 			goto fail_alloc2;
 		}
 	}
 	if (parent) {
 		size = parent->driver->per_child_platdata_auto_alloc_size;
 		if (!size) {
 			size = parent->uclass->uc_drv->
 					per_child_platdata_auto_alloc_size;
 		}
 		if (size) {
 			dev->flags |= DM_FLAG_ALLOC_PARENT_PDATA;
 			dev->parent_platdata = calloc(1, size);
 			if (!dev->parent_platdata) {
 				ret = -ENOMEM;
 				goto fail_alloc3;
 			}
 		}
 	}
 	/* put dev into parent's successor list */
 	if (parent)
 		list_add_tail(&dev->sibling_node, &parent->child_head);
 	ret = uclass_bind_device(dev);
 	if (ret)
 		goto fail_uclass_bind;
 	/* if we fail to bind we remove device from successors and free it */
 	if (drv->bind) {
 		ret = drv->bind(dev);
 		if (ret)
 			goto fail_bind;
 	}
 	if (parent && parent->driver->child_post_bind) {
 		ret = parent->driver->child_post_bind(dev);
 		if (ret)
 			goto fail_child_post_bind;
 	}
 	if (uc->uc_drv->post_bind) {
 		ret = uc->uc_drv->post_bind(dev);
 		if (ret)
 			goto fail_uclass_post_bind;
 	}
 	if (parent)
 		pr_debug("Bound device %s to %s\n", dev->name, parent->name);
 	if (devp)
 		*devp = dev;
 	dev->flags |= DM_FLAG_BOUND;
 	return 0;
 fail_uclass_post_bind:
 	/* There is no child unbind() method, so no clean-up required */
 fail_child_post_bind:
 	if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
 		if (drv->unbind && drv->unbind(dev)) {
 			dm_warn("unbind() method failed on dev '%s' on error path\n",
 				dev->name);
 		}
 	}
 fail_bind:
 	if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
 		if (uclass_unbind_device(dev)) {
 			dm_warn("Failed to unbind dev '%s' on error path\n",
 				dev->name);
 		}
 	}
 fail_uclass_bind:
 	if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
 		list_del(&dev->sibling_node);
 		if (dev->flags & DM_FLAG_ALLOC_PARENT_PDATA) {
 			free(dev->parent_platdata);
 			dev->parent_platdata = NULL;
 		}
 	}
 fail_alloc3:
 	if (dev->flags & DM_FLAG_ALLOC_UCLASS_PDATA) {
 		free(dev->uclass_platdata);
 		dev->uclass_platdata = NULL;
 	}
 fail_alloc2:
 	if (dev->flags & DM_FLAG_ALLOC_PDATA) {
 		free(dev->platdata);
 		dev->platdata = NULL;
 	}
 fail_alloc1:
 	devres_release_all(dev);
 	free(dev);
 	return ret;
 }
 int device_bind_with_driver_data(struct udevice *parent,
 				 const struct driver *drv, const char *name,
 				 ulong driver_data, ofnode node,
 				 struct udevice **devp)
 {
 	return device_bind_common(parent, drv, name, NULL, driver_data, node,
 				  0, devp);
 }
 int device_bind(struct udevice *parent, const struct driver *drv,
 		const char *name, void *platdata, int of_offset,
 		struct udevice **devp)
 {
 	return device_bind_common(parent, drv, name, platdata, 0,
 				  offset_to_ofnode(of_offset), 0, devp);
 }
 int device_bind_by_name(struct udevice *parent, bool pre_reloc_only,
 			const struct driver_info *info, struct udevice **devp)
 {
 	struct driver *drv;
 	uint platdata_size = 0;
 	drv = lists_driver_lookup_name(info->name);
 	if (!drv)
 		return -ENOENT;
 	if (pre_reloc_only && !(drv->flags & DM_FLAG_PRE_RELOC))
 		return -EPERM;
 #if CONFIG_IS_ENABLED(OF_PLATDATA)
 	platdata_size = info->platdata_size;
 #endif
 	return device_bind_common(parent, drv, info->name,
 			(void *)info->platdata, 0, ofnode_null(), platdata_size,
 			devp);
 }
 static void *alloc_priv(int size, uint flags)
 {
 	void *priv;
 	if (flags & DM_FLAG_ALLOC_PRIV_DMA) {
 		size = ROUND(size, ARCH_DMA_MINALIGN);
 		priv = memalign(ARCH_DMA_MINALIGN, size);
 		if (priv) {
 			memset(priv, '\0', size);
 			/*
 			 * Ensure that the zero bytes are flushed to memory.
 			 * This prevents problems if the driver uses this as
 			 * both an input and an output buffer:
 			 *
 			 * 1. Zeroes written to buffer (here) and sit in the
 			 *	cache
 			 * 2. Driver issues a read command to DMA
 			 * 3. CPU runs out of cache space and evicts some cache
 			 *	data in the buffer, writing zeroes to RAM from
 			 *	the memset() above
 			 * 4. DMA completes
 			 * 5. Buffer now has some DMA data and some zeroes
 			 * 6. Data being read is now incorrect
 			 *
 			 * To prevent this, ensure that the cache is clean
 			 * within this range at the start. The driver can then
 			 * use normal flush-after-write, invalidate-before-read
 			 * procedures.
 			 *
 			 * TODO(sjg@chromium.org): Drop this microblaze
 			 * exception.
 			 */
 #ifndef CONFIG_MICROBLAZE
 			flush_dcache_range((ulong)priv, (ulong)priv + size);
 #endif
 		}
 	} else {
 		priv = calloc(1, size);
 	}
 	return priv;
 }
 int device_probe(struct udevice *dev)
 {
 	const struct driver *drv;
 	int size = 0;
 	int ret;
 	int seq;
 	if (!dev)
 		return -EINVAL;
 	if (dev->flags & DM_FLAG_ACTIVATED)
 		return 0;
 	drv = dev->driver;
 	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 (!dev->priv) {
 			ret = -ENOMEM;
 			goto fail;
 		}
 	}
 	/* Allocate private data if requested and not reentered */
 	size = dev->uclass->uc_drv->per_device_auto_alloc_size;
 	if (size && !dev->uclass_priv) {
 		dev->uclass_priv = calloc(1, size);
 		if (!dev->uclass_priv) {
 			ret = -ENOMEM;
 			goto fail;
 		}
 	}
 	/* Ensure all parents are probed */
 	if (dev->parent) {
 		size = dev->parent->driver->per_child_auto_alloc_size;
 		if (!size) {
 			size = dev->parent->uclass->uc_drv->
 					per_child_auto_alloc_size;
 		}
 		if (size && !dev->parent_priv) {
 			dev->parent_priv = alloc_priv(size, drv->flags);
 			if (!dev->parent_priv) {
 				ret = -ENOMEM;
 				goto fail;
 			}
 		}
 		ret = device_probe(dev->parent);
 		if (ret)
 			goto fail;
 		/*
 		 * The device might have already been probed during
 		 * the call to device_probe() on its parent device
 		 * (e.g. PCI bridge devices). Test the flags again
 		 * so that we don't mess up the device.
 		 */
 		if (dev->flags & DM_FLAG_ACTIVATED)
 			return 0;
 	}
 	seq = uclass_resolve_seq(dev);
 	if (seq < 0) {
 		ret = seq;
 		goto fail;
 	}
 	dev->seq = seq;
 	dev->flags |= DM_FLAG_ACTIVATED;
 	/*
 	 * Process pinctrl for everything except the root device, and
 	 * continue regardless of the result of pinctrl. Don't process pinctrl
 	 * settings for pinctrl devices since the device may not yet be
 	 * probed.
 	 */
 	if (dev->parent && device_get_uclass_id(dev) != UCLASS_PINCTRL)
 		pinctrl_select_state(dev, "default");
 	ret = uclass_pre_probe_device(dev);
 	if (ret)
 		goto fail;
 	if (dev->parent && dev->parent->driver->child_pre_probe) {
 		ret = dev->parent->driver->child_pre_probe(dev);
 		if (ret)
 			goto fail;
 	}
 	if (drv->ofdata_to_platdata && dev_has_of_node(dev)) {
 		ret = drv->ofdata_to_platdata(dev);
 		if (ret)
 			goto fail;
 	}
+	/* Process 'assigned-{clocks/clock-parents/clock-rates}' properties */
+	ret = clk_set_defaults(dev);
+	if (ret)
+		goto fail;
 	if (drv->probe) {
 		ret = drv->probe(dev);
 		if (ret) {
 			dev->flags &= ~DM_FLAG_ACTIVATED;
 			goto fail;
 		}
 	}
 	ret = uclass_post_probe_device(dev);
 	if (ret)
 		goto fail_uclass;
 	if (dev->parent && device_get_uclass_id(dev) == UCLASS_PINCTRL)
 		pinctrl_select_state(dev, "default");
 	return 0;
 fail_uclass:
 	if (device_remove(dev, DM_REMOVE_NORMAL)) {
 		dm_warn("%s: Device '%s' failed to remove on error path\n",
 			__func__, dev->name);
 	}
 fail:
 	dev->flags &= ~DM_FLAG_ACTIVATED;
 	dev->seq = -1;
 	device_free(dev);
 	return ret;
 }
 void *dev_get_platdata(struct udevice *dev)
 {
 	if (!dev) {
 		dm_warn("%s: null device\n", __func__);
 		return NULL;
 	}
 	return dev->platdata;
 }
 void *dev_get_parent_platdata(struct udevice *dev)
 {
 	if (!dev) {
 		dm_warn("%s: null device\n", __func__);
 		return NULL;
 	}
 	return dev->parent_platdata;
 }
 void *dev_get_uclass_platdata(struct udevice *dev)
 {
 	if (!dev) {
 		dm_warn("%s: null device\n", __func__);
 		return NULL;
 	}
 	return dev->uclass_platdata;
 }
 void *dev_get_priv(struct udevice *dev)
 {
 	if (!dev) {
 		dm_warn("%s: null device\n", __func__);
 		return NULL;
 	}
 	return dev->priv;
 }
 void *dev_get_uclass_priv(struct udevice *dev)
 {
 	if (!dev) {
 		dm_warn("%s: null device\n", __func__);
 		return NULL;
 	}
 	return dev->uclass_priv;
 }
 void *dev_get_parent_priv(struct udevice *dev)
 {
 	if (!dev) {
 		dm_warn("%s: null device\n", __func__);
 		return NULL;
 	}
 	return dev->parent_priv;
 }
 static int device_get_device_tail(struct udevice *dev, int ret,
 				  struct udevice **devp)
 {
 	if (ret)
 		return ret;
 	ret = device_probe(dev);
 	if (ret)
 		return ret;
 	*devp = dev;
 	return 0;
 }
 int device_get_child(struct udevice *parent, int index, struct udevice **devp)
 {
 	struct udevice *dev;
 	list_for_each_entry(dev, &parent->child_head, sibling_node) {
 		if (!index--)
 			return device_get_device_tail(dev, 0, devp);
 	}
 	return -ENODEV;
 }
 int device_find_child_by_seq(struct udevice *parent, int seq_or_req_seq,
 			     bool find_req_seq, struct udevice **devp)
 {
 	struct udevice *dev;
 	*devp = NULL;
 	if (seq_or_req_seq == -1)
 		return -ENODEV;
 	list_for_each_entry(dev, &parent->child_head, sibling_node) {
 		if ((find_req_seq ? dev->req_seq : dev->seq) ==
 				seq_or_req_seq) {
 			*devp = dev;
 			return 0;
 		}
 	}
 	return -ENODEV;
 }
 int device_get_child_by_seq(struct udevice *parent, int seq,
 			    struct udevice **devp)
 {
 	struct udevice *dev;
 	int ret;
 	*devp = NULL;
 	ret = device_find_child_by_seq(parent, seq, false, &dev);
 	if (ret == -ENODEV) {
 		/*
 		 * We didn't find it in probed devices. See if there is one
 		 * that will request this seq if probed.
 		 */
 		ret = device_find_child_by_seq(parent, seq, true, &dev);
 	}
 	return device_get_device_tail(dev, ret, devp);
 }
 int device_find_child_by_of_offset(struct udevice *parent, int of_offset,
 				   struct udevice **devp)
 {
 	struct udevice *dev;
 	*devp = NULL;
 	list_for_each_entry(dev, &parent->child_head, sibling_node) {
 		if (dev_of_offset(dev) == of_offset) {
 			*devp = dev;
 			return 0;
 		}
 	}
 	return -ENODEV;
 }
 int device_get_child_by_of_offset(struct udevice *parent, int node,
 				  struct udevice **devp)
 {
 	struct udevice *dev;
 	int ret;
 	*devp = NULL;
 	ret = device_find_child_by_of_offset(parent, node, &dev);
 	return device_get_device_tail(dev, ret, devp);
 }
 static struct udevice *_device_find_global_by_of_offset(struct udevice *parent,
 							int of_offset)
 {
 	struct udevice *dev, *found;
 	if (dev_of_offset(parent) == of_offset)
 		return parent;
 	list_for_each_entry(dev, &parent->child_head, sibling_node) {
 		found = _device_find_global_by_of_offset(dev, of_offset);
 		if (found)
 			return found;
 	}
 	return NULL;
 }
 int device_get_global_by_of_offset(int of_offset, struct udevice **devp)
 {
 	struct udevice *dev;
 	dev = _device_find_global_by_of_offset(gd->dm_root, of_offset);
 	return device_get_device_tail(dev, dev ? 0 : -ENOENT, devp);
 }
 int device_find_first_child(struct udevice *parent, struct udevice **devp)
 {
 	if (list_empty(&parent->child_head)) {
 		*devp = NULL;
 	} else {
 		*devp = list_first_entry(&parent->child_head, struct udevice,
 					 sibling_node);
 	}
 	return 0;
 }
 int device_find_next_child(struct udevice **devp)
 {
 	struct udevice *dev = *devp;
 	struct udevice *parent = dev->parent;
 	if (list_is_last(&dev->sibling_node, &parent->child_head)) {
 		*devp = NULL;
 	} else {
 		*devp = list_entry(dev->sibling_node.next, struct udevice,
 				   sibling_node);
 	}
 	return 0;
 }
 struct udevice *dev_get_parent(struct udevice *child)
 {
 	return child->parent;
 }
 ulong dev_get_driver_data(struct udevice *dev)
 {
 	return dev->driver_data;
 }
 const void *dev_get_driver_ops(struct udevice *dev)
 {
 	if (!dev || !dev->driver->ops)
 		return NULL;
 	return dev->driver->ops;
 }
 enum uclass_id device_get_uclass_id(struct udevice *dev)
 {
 	return dev->uclass->uc_drv->id;
 }
 const char *dev_get_uclass_name(struct udevice *dev)
 {
 	if (!dev)
 		return NULL;
 	return dev->uclass->uc_drv->name;
 }
 bool device_has_children(struct udevice *dev)
 {
 	return !list_empty(&dev->child_head);
 }
 bool device_has_active_children(struct udevice *dev)
 {
 	struct udevice *child;
 	for (device_find_first_child(dev, &child);
 	     child;
 	     device_find_next_child(&child)) {
 		if (device_active(child))
 			return true;
 	}
 	return false;
 }
 bool device_is_last_sibling(struct udevice *dev)
 {
 	struct udevice *parent = dev->parent;
 	if (!parent)
 		return false;
 	return list_is_last(&dev->sibling_node, &parent->child_head);
 }
 void device_set_name_alloced(struct udevice *dev)
 {
 	dev->flags |= DM_FLAG_NAME_ALLOCED;
 }
 int device_set_name(struct udevice *dev, const char *name)
 {
 	name = strdup(name);
 	if (!name)
 		return -ENOMEM;
 	dev->name = name;
 	device_set_name_alloced(dev);
 	return 0;
 }
 bool device_is_compatible(struct udevice *dev, const char *compat)
 {
 	const void *fdt = gd->fdt_blob;
 	ofnode node = dev_ofnode(dev);
 	if (ofnode_is_np(node))
 		return of_device_is_compatible(ofnode_to_np(node), compat, NULL, NULL);
 	else
 		return !fdt_node_check_compatible(fdt, ofnode_to_offset(node), compat);
 }
 bool of_machine_is_compatible(const char *compat)
 {
 	const void *fdt = gd->fdt_blob;
 	return !fdt_node_check_compatible(fdt, 0, compat);
 }

 /*
  * Copyright (c) 2015 Google, Inc
  * Written by Simon Glass <sjg@chromium.org>
  * Copyright (c) 2016, NVIDIA CORPORATION.
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #ifndef _CLK_H_
 #define _CLK_H_
 #include <linux/errno.h>
 #include <linux/types.h>
 /**
  * A clock is a hardware signal that oscillates autonomously at a specific
  * frequency and duty cycle. Most hardware modules require one or more clock
  * signal to drive their operation. Clock signals are typically generated
  * externally to the HW module consuming them, by an entity this API calls a
  * clock provider. This API provides a standard means for drivers to enable and
  * disable clocks, and to set the rate at which they oscillate.
  *
  * A driver that implements UCLASS_CLOCK is a clock provider. A provider will
  * often implement multiple separate clocks, since the hardware it manages
  * often has this capability. clock_uclass.h describes the interface which
  * clock providers must implement.
  *
  * Clock consumers/clients are the HW modules driven by the clock signals. This
  * header file describes the API used by drivers for those HW modules.
  */
 struct udevice;
 /**
  * struct clk - A handle to (allowing control of) a single clock.
  *
  * Clients provide storage for clock handles. The content of the structure is
  * managed solely by the clock API and clock drivers. A clock struct is
  * initialized by "get"ing the clock struct. The clock struct is passed to all
  * other clock APIs to identify which clock signal to operate upon.
  *
  * @dev: The device which implements the clock signal.
  * @id: The clock signal ID within the provider.
  *
  * Currently, the clock API assumes that a single integer ID is enough to
  * identify and configure any clock signal for any clock provider. If this
  * assumption becomes invalid in the future, the struct could be expanded to
  * either (a) add more fields to allow clock providers to store additional
  * information, or (b) replace the id field with an opaque pointer, which the
  * provider would dynamically allocated during its .of_xlate op, and process
  * during is .request op. This may require the addition of an extra op to clean
  * up the allocation.
  */
 struct clk {
 	struct udevice *dev;
 	/*
 	 * Written by of_xlate. We assume a single id is enough for now. In the
 	 * future, we might add more fields here.
 	 */
 	unsigned long id;
 };
 #if CONFIG_IS_ENABLED(OF_CONTROL) && CONFIG_IS_ENABLED(CLK)
 struct phandle_1_arg;
 int clk_get_by_index_platdata(struct udevice *dev, int index,
 			      struct phandle_1_arg *cells, struct clk *clk);
 /**
  * clock_get_by_index - Get/request a clock by integer index.
  *
  * This looks up and requests a clock. The index is relative to the client
  * device; each device is assumed to have n clocks associated with it somehow,
  * and this function finds and requests one of them. The mapping of client
  * device clock indices to provider clocks may be via device-tree properties,
  * board-provided mapping tables, or some other mechanism.
  *
  * @dev:	The client device.
  * @index:	The index of the clock to request, within the client's list of
  *		clocks.
  * @clock	A pointer to a clock struct to initialize.
  * @return 0 if OK, or a negative error code.
  */
 int clk_get_by_index(struct udevice *dev, int index, struct clk *clk);
 /**
  * clock_get_by_name - Get/request a clock by name.
  *
  * This looks up and requests a clock. The name is relative to the client
  * device; each device is assumed to have n clocks associated with it somehow,
  * and this function finds and requests one of them. The mapping of client
  * device clock names to provider clocks may be via device-tree properties,
  * board-provided mapping tables, or some other mechanism.
  *
  * @dev:	The client device.
  * @name:	The name of the clock to request, within the client's list of
  *		clocks.
  * @clock:	A pointer to a clock struct to initialize.
  * @return 0 if OK, or a negative error code.
  */
 int clk_get_by_name(struct udevice *dev, const char *name, struct clk *clk);
 /**
  * clk_release_all() - Disable (turn off)/Free an array of previously
  * requested clocks.
  *
  * For each clock contained in the clock array, this function will check if
  * clock has been previously requested and then will disable and free it.
  *
  * @clk:	A clock struct array that was previously successfully
  *		requested by clk_request/get_by_*().
  * @count	Number of clock contained in the array
  * @return zero on success, or -ve error code.
  */
 int clk_release_all(struct clk *clk, int count);
 #else
 static inline int clk_get_by_index(struct udevice *dev, int index,
 				   struct clk *clk)
 {
 	return -ENOSYS;
 }
 static inline int clk_get_by_name(struct udevice *dev, const char *name,
 			   struct clk *clk)
 {
 	return -ENOSYS;
 }
 static inline int clk_release_all(struct clk *clk, int count)
 {
 	return -ENOSYS;
 }
 #endif
+#if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) && \
+	CONFIG_IS_ENABLED(CLK)
+/**
+ * clk_set_defaults - Process 'assigned-{clocks/clock-parents/clock-rates}'
+ *                    properties to configure clocks
+ *
+ * @dev:        A device to process (the ofnode associated with this device
+ *              will be processed).
+ */
+int clk_set_defaults(struct udevice *dev);
+#else
+static inline int clk_set_defaults(struct udevice *dev)
+{
+	return 0;
+}
+#endif
 /**
  * clk_request - Request a clock by provider-specific ID.
  *
  * This requests a clock using a provider-specific ID. Generally, this function
  * should not be used, since clk_get_by_index/name() provide an interface that
  * better separates clients from intimate knowledge of clock providers.
  * However, this function may be useful in core SoC-specific code.
  *
  * @dev:	The clock provider device.
  * @clock:	A pointer to a clock struct to initialize. The caller must
  *		have already initialized any field in this struct which the
  *		clock provider uses to identify the clock.
  * @return 0 if OK, or a negative error code.
  */
 int clk_request(struct udevice *dev, struct clk *clk);
 /**
  * clock_free - Free a previously requested clock.
  *
  * @clock:	A clock struct that was previously successfully requested by
  *		clk_request/get_by_*().
  * @return 0 if OK, or a negative error code.
  */
 int clk_free(struct clk *clk);
 /**
  * clk_get_rate() - Get current clock rate.
  *
  * @clk:	A clock struct that was previously successfully requested by
  *		clk_request/get_by_*().
  * @return clock rate in Hz, or -ve error code.
  */
 ulong clk_get_rate(struct clk *clk);
 /**
  * clk_set_rate() - Set current clock rate.
  *
  * @clk:	A clock struct that was previously successfully requested by
  *		clk_request/get_by_*().
  * @rate:	New clock rate in Hz.
  * @return new rate, or -ve error code.
  */
 ulong clk_set_rate(struct clk *clk, ulong rate);
 /**
  * clk_set_parent() - Set current clock parent.
  *
  * @clk:	A clock struct that was previously successfully requested by
  *		clk_request/get_by_*().
  * @parent:	A clock struct that was previously successfully requested by
  *		clk_request/get_by_*().
  * @return new rate, or -ve error code.
  */
 int clk_set_parent(struct clk *clk, struct clk *parent);
 /**
  * clk_enable() - Enable (turn on) a clock.
  *
  * @clk:	A clock struct that was previously successfully requested by
  *		clk_request/get_by_*().
  * @return zero on success, or -ve error code.
  */
 int clk_enable(struct clk *clk);
 /**
  * clk_disable() - Disable (turn off) a clock.
  *
  * @clk:	A clock struct that was previously successfully requested by
  *		clk_request/get_by_*().
  * @return zero on success, or -ve error code.
  */
 int clk_disable(struct clk *clk);
 int soc_clk_dump(void);
 #endif