/src/u-boot/drivers/clk/clk.c

Source
// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2019 DENX Software Engineering
 * Lukasz Majewski, DENX Software Engineering, lukma@denx.de
 */

#define LOG_CATEGORY UCLASS_CLK

#include <clk.h>
#include <clk-uclass.h>
#include <log.h>
#include <dm/device.h>
#include <dm/uclass.h>
#include <dm/lists.h>
#include <dm/device-internal.h>

int clk_register(struct clk *clk, const char *drv_name,
     const char *name, const char *parent_name)
{
  struct udevice *parent = NULL;
  struct driver *drv;
  int ret;

  if (parent_name) {
    ret = uclass_get_device_by_name(UCLASS_CLK, parent_name, &parent);
    if (ret) {
      log_err("%s: failed to get %s device (parent of %s)\n",
        __func__, parent_name, name);
    } else {
      log_debug("%s: name: %s parent: %s [0x%p]\n", __func__, name,
          parent->name, parent);
    }
  }

  drv = lists_driver_lookup_name(drv_name);
  if (!drv) {
    log_err("%s: %s is not a valid driver name\n",
      __func__, drv_name);
    return -ENOENT;
  }

  ret = device_bind(parent, drv, name, NULL, ofnode_null(), &clk->dev);
  if (ret) {
    log_err("%s: CLK: %s driver bind error [%d]!\n", __func__, name,
      ret);
    return ret;
  }

  clk->enable_count = 0;

  /* Store back pointer to clk from udevice */
  /* FIXME: This is not allowed...should be allocated by driver model */
  dev_set_uclass_priv(clk->dev, clk);

  return 0;
}

ulong clk_generic_get_rate(struct clk *clk)
{
  return clk_get_parent_rate(clk);
}

const char *clk_hw_get_name(const struct clk *hw)
{
  assert(hw);
  assert(hw->dev);

  return hw->dev->name;
}

bool clk_dev_binded(struct clk *clk)
{
  if (clk->dev && (dev_get_flags(clk->dev) & DM_FLAG_BOUND))
    return true;

  return false;
}

/* Helper functions for clock ops */

ulong ccf_clk_get_rate(struct clk *clk)
{
  struct clk *c;
  int err = clk_get_by_id(clk->id, &c);

  if (err)
    return err;
  return clk_get_rate(c);
}

ulong ccf_clk_set_rate(struct clk *clk, unsigned long rate)
{
  struct clk *c;
  int err = clk_get_by_id(clk->id, &c);

  if (err)
    return err;
  return clk_set_rate(c, rate);
}

int ccf_clk_set_parent(struct clk *clk, struct clk *parent)
{
  struct clk *c, *p;
  int err = clk_get_by_id(clk->id, &c);

  if (err)
    return err;

  err = clk_get_by_id(parent->id, &p);
  if (err)
    return err;

  return clk_set_parent(c, p);
}

static int ccf_clk_endisable(struct clk *clk, bool enable)
{
  struct clk *c;
  int err = clk_get_by_id(clk->id, &c);

  if (err)
    return err;
  return enable ? clk_enable(c) : clk_disable(c);
}

int ccf_clk_enable(struct clk *clk)
{
  return ccf_clk_endisable(clk, true);
}

int ccf_clk_disable(struct clk *clk)
{
  return ccf_clk_endisable(clk, false);
}

const struct clk_ops ccf_clk_ops = {
  .set_rate = ccf_clk_set_rate,
  .get_rate = ccf_clk_get_rate,
  .set_parent = ccf_clk_set_parent,
  .enable = ccf_clk_enable,
  .disable = ccf_clk_disable,
};

Line	Count	Source
1		// SPDX-License-Identifier: GPL-2.0+
2		/*
3		* Copyright (C) 2019 DENX Software Engineering
4		* Lukasz Majewski, DENX Software Engineering, lukma@denx.de
5		*/
6
7		#define LOG_CATEGORY UCLASS_CLK
8
9		#include <clk.h>
10		#include <clk-uclass.h>
11		#include <log.h>
12		#include <dm/device.h>
13		#include <dm/uclass.h>
14		#include <dm/lists.h>
15		#include <dm/device-internal.h>
16
17		int clk_register(struct clk clk, const char drv_name,
18		const char name, const char parent_name)
19	0	{
20	0	struct udevice *parent = NULL;
21	0	struct driver *drv;
22	0	int ret;
23
24	0	if (parent_name) {
25	0	ret = uclass_get_device_by_name(UCLASS_CLK, parent_name, &parent);
26	0	if (ret) {
27	0	log_err("%s: failed to get %s device (parent of %s)\n",
28	0	__func__, parent_name, name);
29	0	} else {
30	0	log_debug("%s: name: %s parent: %s [0x%p]\n", __func__, name,
31	0	parent->name, parent);
32	0	}
33	0	}
34
35	0	drv = lists_driver_lookup_name(drv_name);
36	0	if (!drv) {
37	0	log_err("%s: %s is not a valid driver name\n",
38	0	__func__, drv_name);
39	0	return -ENOENT;
40	0	}
41
42	0	ret = device_bind(parent, drv, name, NULL, ofnode_null(), &clk->dev);
43	0	if (ret) {
44	0	log_err("%s: CLK: %s driver bind error [%d]!\n", __func__, name,
45	0	ret);
46	0	return ret;
47	0	}
48
49	0	clk->enable_count = 0;
50
51		/* Store back pointer to clk from udevice */
52		/* FIXME: This is not allowed...should be allocated by driver model */
53	0	dev_set_uclass_priv(clk->dev, clk);
54
55	0	return 0;
56	0	}
57
58		ulong clk_generic_get_rate(struct clk *clk)
59	0	{
60	0	return clk_get_parent_rate(clk);
61	0	}
62
63		const char clk_hw_get_name(const struct clk hw)
64		{
65		assert(hw);
66		assert(hw->dev);
67
68		return hw->dev->name;
69		}
70
71		bool clk_dev_binded(struct clk *clk)
72	0	{
73	0	if (clk->dev && (dev_get_flags(clk->dev) & DM_FLAG_BOUND))
74	0	return true;
75
76	0	return false;
77	0	}
78
79		/* Helper functions for clock ops */
80
81		ulong ccf_clk_get_rate(struct clk *clk)
82	0	{
83	0	struct clk *c;
84	0	int err = clk_get_by_id(clk->id, &c);
85
86	0	if (err)
87	0	return err;
88	0	return clk_get_rate(c);
89	0	}
90
91		ulong ccf_clk_set_rate(struct clk *clk, unsigned long rate)
92	0	{
93	0	struct clk *c;
94	0	int err = clk_get_by_id(clk->id, &c);
95
96	0	if (err)
97	0	return err;
98	0	return clk_set_rate(c, rate);
99	0	}
100
101		int ccf_clk_set_parent(struct clk clk, struct clk parent)
102	0	{
103	0	struct clk c, p;
104	0	int err = clk_get_by_id(clk->id, &c);
105
106	0	if (err)
107	0	return err;
108
109	0	err = clk_get_by_id(parent->id, &p);
110	0	if (err)
111	0	return err;
112
113	0	return clk_set_parent(c, p);
114	0	}
115
116		static int ccf_clk_endisable(struct clk *clk, bool enable)
117	0	{
118	0	struct clk *c;
119	0	int err = clk_get_by_id(clk->id, &c);
120
121	0	if (err)
122	0	return err;
123	0	return enable ? clk_enable(c) : clk_disable(c);
124	0	}
125
126		int ccf_clk_enable(struct clk *clk)
127	0	{
128	0	return ccf_clk_endisable(clk, true);
129	0	}
130
131		int ccf_clk_disable(struct clk *clk)
132	0	{
133		return ccf_clk_endisable(clk, false);
134	0	}
135
136		const struct clk_ops ccf_clk_ops = {
137		.set_rate = ccf_clk_set_rate,
138		.get_rate = ccf_clk_get_rate,
139		.set_parent = ccf_clk_set_parent,
140		.enable = ccf_clk_enable,
141		.disable = ccf_clk_disable,
142		};

Coverage Report

Created: 2026-03-11 06:21