1 /* SPDX-License-Identifier: GPL-2.0+ */
2 /*
3 * Copyright (c) 2015 Google, Inc
4 * Written by Simon Glass <sjg@chromium.org>
5 * Copyright (c) 2016, NVIDIA CORPORATION.
6 */
7
8 #ifndef _CLK_H_
9 #define _CLK_H_
10
11 #include <dm/ofnode.h>
12 #include <linux/err.h>
13 #include <linux/errno.h>
14 #include <linux/types.h>
15
16 #ifdef CONFIG_CLK_AUTO_ID
17 #define CLK_ID_SZ 24
18 #define CLK_ID_MSK GENMASK(23, 0)
19 #define CLK_ID(dev, id) (((dev_seq(dev) + 1) << CLK_ID_SZ) | ((id) & CLK_ID_MSK))
20 #else
21 #define CLK_ID_MSK (~0UL)
22 #define CLK_ID(dev, id) id
23 #endif
24
25 /**
26 * DOC: Overview
27 *
28 * A clock is a hardware signal that oscillates autonomously at a specific
29 * frequency and duty cycle. Most hardware modules require one or more clock
30 * signal to drive their operation. Clock signals are typically generated
31 * externally to the HW module consuming them, by an entity this API calls a
32 * clock provider. This API provides a standard means for drivers to enable and
33 * disable clocks, and to set the rate at which they oscillate.
34 *
35 * A driver that implements UCLASS_CLK is a clock provider. A provider will
36 * often implement multiple separate clocks, since the hardware it manages
37 * often has this capability. clk-uclass.h describes the interface which
38 * clock providers must implement.
39 *
40 * Clock consumers/clients are the HW modules driven by the clock signals. This
41 * header file describes the API used by drivers for those HW modules.
42 */
43
44 struct udevice;
45
46 /**
47 * struct clk - A handle to (allowing control of) a single clock.
48 * @dev: The device which implements the clock signal.
49 * @rate: The clock rate (in HZ).
50 * @flags: Flags used across common clock structure (e.g. %CLK_)
51 * Clock IP blocks specific flags (i.e. mux, div, gate, etc) are defined
52 * in struct's for those devices (e.g. &struct clk_mux).
53 * @enable_count: The number of times this clock has been enabled.
54 * @id: The clock signal ID within the provider.
55 * @data: An optional data field for scenarios where a single integer ID is not
56 * sufficient. If used, it can be populated through an .of_xlate op and
57 * processed during the various clock ops.
58 *
59 * Clients provide storage for clock handles. The content of the structure is
60 * managed solely by the clock API and clock drivers. A clock struct is
61 * initialized by "get"ing the clock struct. The clock struct is passed to all
62 * other clock APIs to identify which clock signal to operate upon.
63 *
64 * Should additional information to identify and configure any clock signal
65 * for any provider be required in the future, the struct could be expanded to
66 * either (a) add more fields to allow clock providers to store additional
67 * information, or (b) replace the id field with an opaque pointer, which the
68 * provider would dynamically allocated during its .of_xlate op, and process
69 * during is .request op. This may require the addition of an extra op to clean
70 * up the allocation.
71 */
72 struct clk {
73 struct udevice *dev;
74 long long rate; /* in HZ */
75 u32 flags;
76 int enable_count;
77 /*
78 * Written by of_xlate. In the future, we might add more fields here.
79 */
80 unsigned long id;
81 unsigned long data;
82 };
83
84 /**
85 * struct clk_bulk - A handle to (allowing control of) a bulk of clocks.
86 * @clks: An array of clock handles.
87 * @count: The number of clock handles in the clks array.
88 *
89 * Clients provide storage for the clock bulk. The content of the structure is
90 * managed solely by the clock API. A clock bulk struct is
91 * initialized by "get"ing the clock bulk struct.
92 * The clock bulk struct is passed to all other bulk clock APIs to apply
93 * the API to all the clock in the bulk struct.
94 */
95 struct clk_bulk {
96 struct clk *clks;
97 unsigned int count;
98 };
99
100 struct phandle_1_arg;
101
102 #if CONFIG_IS_ENABLED(OF_CONTROL) && CONFIG_IS_ENABLED(CLK)
103 /**
104 * clk_get_by_phandle() - Get a clock by its phandle information (of-platadata)
105 * @dev: Device containing the phandle
106 * @cells: Phandle info
107 * @clk: A pointer to a clock struct to initialise
108 *
109 * This function is used when of-platdata is enabled.
110 *
111 * This looks up a clock using the phandle info. With dtoc, each phandle in the
112 * 'clocks' property is transformed into an idx representing the device.
113 * For example::
114 *
115 * clocks = <&dpll_mpu_ck 23>;
116 *
117 * might result in::
118 *
119 * .clocks = {1, {23}},},
120 *
121 * indicating that the clock is udevice idx 1 in dt-plat.c with an argument of
122 * 23. This function can return a valid clock given the above information. In
123 * this example it would return a clock containing the 'dpll_mpu_ck' device and
124 * the clock ID 23.
125 *
126 * Return: 0 if OK, or a negative error code.
127 */
128 int clk_get_by_phandle(struct udevice *dev, const struct phandle_1_arg *cells,
129 struct clk *clk);
130
131 /**
132 * clk_get_by_index() - Get/request a clock by integer index.
133 * @dev: The client device.
134 * @index: The index of the clock to request, within the client's list of
135 * clocks.
136 * @clk: A pointer to a clock struct to initialize.
137 *
138 * This looks up and requests a clock. The index is relative to the client
139 * device; each device is assumed to have n clocks associated with it somehow,
140 * and this function finds and requests one of them. The mapping of client
141 * device clock indices to provider clocks may be via device-tree properties,
142 * board-provided mapping tables, or some other mechanism.
143 *
144 * Return: 0 if OK, or a negative error code.
145 */
146 int clk_get_by_index(struct udevice *dev, int index, struct clk *clk);
147
148 /**
149 * clk_get_by_index_nodev() - Get/request a clock by integer index without a
150 * device.
151 * @node: The client ofnode.
152 * @index: The index of the clock to request, within the client's list of
153 * clocks.
154 * @clk: A pointer to a clock struct to initialize.
155 *
156 * Return: 0 if OK, or a negative error code.
157 */
158 int clk_get_by_index_nodev(ofnode node, int index, struct clk *clk);
159
160 /**
161 * clk_get_bulk() - Get/request all clocks of a device.
162 * @dev: The client device.
163 * @bulk: A pointer to a clock bulk struct to initialize.
164 *
165 * This looks up and requests all clocks of the client device; each device is
166 * assumed to have n clocks associated with it somehow, and this function finds
167 * and requests all of them in a separate structure. The mapping of client
168 * device clock indices to provider clocks may be via device-tree properties,
169 * board-provided mapping tables, or some other mechanism.
170 *
171 * Return: 0 if OK, or a negative error code.
172 */
173 int clk_get_bulk(struct udevice *dev, struct clk_bulk *bulk);
174
175 /**
176 * clk_get_by_name() - Get/request a clock by name.
177 * @dev: The client device.
178 * @name: The name of the clock to request, within the client's list of
179 * clocks, or NULL to request the first clock in the list.
180 * @clk: A pointer to a clock struct to initialize.
181 *
182 * This looks up and requests a clock. The name is relative to the client
183 * device; each device is assumed to have n clocks associated with it somehow,
184 * and this function finds and requests one of them. The mapping of client
185 * device clock names to provider clocks may be via device-tree properties,
186 * board-provided mapping tables, or some other mechanism.
187 *
188 * Return: 0 if OK, or a negative error code.
189 */
190 int clk_get_by_name(struct udevice *dev, const char *name, struct clk *clk);
191
192 /**
193 * clk_get_by_name_nodev - Get/request a clock by name without a device.
194 * @node: The client ofnode.
195 * @name: The name of the clock to request, within the client's list of
196 * clocks, or NULL to request the first clock in the list.
197 * @clk: A pointer to a clock struct to initialize.
198 *
199 * Return: 0 if OK, or a negative error code.
200 */
201 int clk_get_by_name_nodev(ofnode node, const char *name, struct clk *clk);
202
203 /**
204 * devm_clk_get() - lookup and obtain a managed reference to a clock producer.
205 * @dev: device for clock "consumer"
206 * @id: clock consumer ID
207 *
208 * The implementation uses @dev and @id to determine the clock consumer, and
209 * thereby the clock producer. (IOW, @id may be identical strings, but clk_get
210 * may return different clock producers depending on @dev.)
211 *
212 * Drivers must assume that the clock source is not enabled.
213 *
214 * The clock will automatically be freed when the device is unbound
215 * from the bus.
216 *
217 * Return:
218 * a struct clk corresponding to the clock producer, or
219 * valid IS_ERR() condition containing errno
220 */
221 struct clk *devm_clk_get(struct udevice *dev, const char *id);
222
223 /**
224 * devm_clk_get_optional() - lookup and obtain a managed reference to an
225 * optional clock producer.
226 * @dev: device for clock "consumer"
227 * @id: clock consumer ID
228 *
229 * Behaves the same as devm_clk_get() except where there is no clock producer.
230 * In this case, instead of returning -%ENOENT, the function returns NULL.
231 */
devm_clk_get_optional(struct udevice * dev,const char * id)232 static inline struct clk *devm_clk_get_optional(struct udevice *dev,
233 const char *id)
234 {
235 int ret;
236 struct clk *clk = devm_clk_get(dev, id);
237
238 ret = PTR_ERR(clk);
239 if (ret == -ENODATA || ret == -ENOENT)
240 return NULL;
241
242 return clk;
243 }
244
245 /**
246 * clk_release_all() - Disable (turn off)/Free an array of previously
247 * requested clocks.
248 * @clk: A clock struct array that was previously successfully
249 * requested by clk_request/get_by_*().
250 * @count: Number of clock contained in the array
251 *
252 * For each clock contained in the clock array, this function will check if
253 * clock has been previously requested and then will disable and free it.
254 *
255 * Return: zero on success, or -ve error code.
256 */
257 int clk_release_all(struct clk *clk, unsigned int count);
258
259 #else
260
clk_get_by_phandle(struct udevice * dev,const struct phandle_1_arg * cells,struct clk * clk)261 static inline int clk_get_by_phandle(struct udevice *dev, const
262 struct phandle_1_arg *cells,
263 struct clk *clk)
264 {
265 return -ENOSYS;
266 }
267
clk_get_by_index(struct udevice * dev,int index,struct clk * clk)268 static inline int clk_get_by_index(struct udevice *dev, int index,
269 struct clk *clk)
270 {
271 return -ENOSYS;
272 }
273
clk_get_by_index_nodev(ofnode node,int index,struct clk * clk)274 static inline int clk_get_by_index_nodev(ofnode node, int index,
275 struct clk *clk)
276 {
277 return -ENOSYS;
278 }
279
clk_get_bulk(struct udevice * dev,struct clk_bulk * bulk)280 static inline int clk_get_bulk(struct udevice *dev, struct clk_bulk *bulk)
281 {
282 return -ENOSYS;
283 }
284
clk_get_by_name(struct udevice * dev,const char * name,struct clk * clk)285 static inline int clk_get_by_name(struct udevice *dev, const char *name,
286 struct clk *clk)
287 {
288 return -ENOSYS;
289 }
290
devm_clk_get(struct udevice * dev,const char * id)291 static inline struct clk *devm_clk_get(struct udevice *dev, const char *id)
292 {
293 return ERR_PTR(-ENOSYS);
294 }
295
devm_clk_get_optional(struct udevice * dev,const char * id)296 static inline struct clk *devm_clk_get_optional(struct udevice *dev,
297 const char *id)
298 {
299 return ERR_PTR(-ENOSYS);
300 }
301
302 static inline int
clk_get_by_name_nodev(ofnode node,const char * name,struct clk * clk)303 clk_get_by_name_nodev(ofnode node, const char *name, struct clk *clk)
304 {
305 return -ENOSYS;
306 }
307
clk_release_all(struct clk * clk,unsigned int count)308 static inline int clk_release_all(struct clk *clk, unsigned int count)
309 {
310 return -ENOSYS;
311 }
312 #endif
313
314 /**
315 * clk_get_by_name_optional() - Get/request a optional clock by name.
316 * @dev: The client device.
317 * @name: The name of the clock to request, within the client's list of
318 * clocks.
319 * @clk: A pointer to a clock struct to initialize.
320 *
321 * Behaves the same as clk_get_by_name(), except when there is no clock
322 * provider. In the latter case, return 0.
323 *
324 * Return: 0 if OK, or a negative error code.
325 */
clk_get_by_name_optional(struct udevice * dev,const char * name,struct clk * clk)326 static inline int clk_get_by_name_optional(struct udevice *dev,
327 const char *name, struct clk *clk)
328 {
329 int ret;
330
331 ret = clk_get_by_name(dev, name, clk);
332 if (ret == -ENODATA || ret == -ENOENT)
333 return 0;
334
335 return ret;
336 }
337
338 /**
339 * clk_get_by_name_nodev_optional - Get/request an optinonal clock by name
340 * without a device.
341 * @node: The client ofnode.
342 * @name: The name of the clock to request, within the client's list of
343 * clocks.
344 * @clk: A pointer to a clock struct to initialize.
345 *
346 * Behaves the same as clk_get_by_name_nodev() except where there is
347 * no clock producer, in this case, skip the error number -%ENODATA, and
348 * the function returns 0.
349 */
clk_get_by_name_nodev_optional(ofnode node,const char * name,struct clk * clk)350 static inline int clk_get_by_name_nodev_optional(ofnode node, const char *name,
351 struct clk *clk)
352 {
353 int ret;
354
355 ret = clk_get_by_name_nodev(node, name, clk);
356 if (ret == -ENODATA || ret == -ENOENT)
357 return 0;
358
359 return ret;
360 }
361
362 /**
363 * clk_resolve_parent_clk - Determine name of clock udevice based on clock-names
364 * @dev: The client udevice.
365 * @name: The name of the clock to look up.
366 *
367 * Return name of the clock udevice which represents clock with clock-names name.
368 */
369 const char *clk_resolve_parent_clk(struct udevice *dev, const char *name);
370
371 /**
372 * enum clk_defaults_stage - What stage clk_set_defaults() is called at
373 * @CLK_DEFAULTS_PRE: Called before probe. Setting of defaults for clocks owned
374 * by this clock driver will be defered until after probing.
375 * @CLK_DEFAULTS_POST: Called after probe. Only defaults for clocks owned by
376 * this clock driver will be set.
377 * @CLK_DEFAULTS_POST_FORCE: Called after probe, and always set defaults, even
378 * before relocation. Usually, defaults are not set
379 * pre-relocation to avoid setting them twice (when
380 * the device is probed again post-relocation). This
381 * may incur a performance cost as device tree
382 * properties must be parsed for a second time.
383 * However, when not using SPL, pre-relocation may be
384 * the only time we can set defaults for some clocks
385 * (such as those used for the RAM we will relocate
386 * into).
387 */
388 enum clk_defaults_stage {
389 CLK_DEFAULTS_PRE = 0,
390 CLK_DEFAULTS_POST = 1,
391 CLK_DEFAULTS_POST_FORCE,
392 };
393
394 #if CONFIG_IS_ENABLED(OF_REAL) && CONFIG_IS_ENABLED(CLK)
395 /**
396 * clk_set_defaults - Process ``assigned-{clocks/clock-parents/clock-rates}``
397 * properties to configure clocks
398 * @dev: A device to process (the ofnode associated with this device
399 * will be processed).
400 * @stage: The stage of the probing process this function is called during.
401 *
402 * Return: zero on success, or -ve error code.
403 */
404 int clk_set_defaults(struct udevice *dev, enum clk_defaults_stage stage);
405 #else
clk_set_defaults(struct udevice * dev,int stage)406 static inline int clk_set_defaults(struct udevice *dev, int stage)
407 {
408 return 0;
409 }
410 #endif
411
412 /**
413 * clk_release_bulk() - Disable (turn off)/Free an array of previously
414 * requested clocks in a clock bulk struct.
415 * @bulk: A clock bulk struct that was previously successfully
416 * requested by clk_get_bulk().
417 *
418 * For each clock contained in the clock bulk struct, this function will check
419 * if clock has been previously requested and then will disable and free it.
420 *
421 * Return: zero on success, or -ve error code.
422 */
clk_release_bulk(struct clk_bulk * bulk)423 static inline int clk_release_bulk(struct clk_bulk *bulk)
424 {
425 return clk_release_all(bulk->clks, bulk->count);
426 }
427
428 #if CONFIG_IS_ENABLED(CLK)
429 /**
430 * clk_request() - Request a clock by provider-specific ID.
431 * @dev: The clock provider device.
432 * @clk: A pointer to a clock struct to initialize. The caller must
433 * have already initialized any field in this struct which the
434 * clock provider uses to identify the clock.
435 *
436 * This requests a clock using a provider-specific ID. Generally, this function
437 * should not be used, since clk_get_by_index/name() provide an interface that
438 * better separates clients from intimate knowledge of clock providers.
439 * However, this function may be useful in core SoC-specific code.
440 *
441 * Return: 0 if OK, or a negative error code.
442 */
443 int clk_request(struct udevice *dev, struct clk *clk);
444
445 /**
446 * clk_get_rate() - Get current clock rate.
447 * @clk: A clock struct that was previously successfully requested by
448 * clk_request/get_by_*().
449 *
450 * Return: clock rate in Hz on success, 0 for invalid clock, or -ve error code
451 * for other errors.
452 */
453 ulong clk_get_rate(struct clk *clk);
454
455 /**
456 * clk_get_parent() - Get current clock's parent.
457 * @clk: A clock struct that was previously successfully requested by
458 * clk_request/get_by_*().
459 *
460 * Return: pointer to parent's struct clk, or error code passed as pointer
461 */
462 struct clk *clk_get_parent(struct clk *clk);
463
464 /**
465 * clk_get_parent_rate() - Get rate of current clock's parent.
466 * @clk: A clock struct that was previously successfully requested by
467 * clk_request/get_by_*().
468 *
469 * Return: clock rate in Hz, or -ve error code.
470 */
471 ulong clk_get_parent_rate(struct clk *clk);
472
473 /**
474 * clk_round_rate() - Adjust a rate to the exact rate a clock can provide
475 * @clk: A clock struct that was previously successfully requested by
476 * clk_request/get_by_*().
477 * @rate: desired clock rate in Hz.
478 *
479 * This answers the question "if I were to pass @rate to clk_set_rate(),
480 * what clock rate would I end up with?" without changing the hardware
481 * in any way. In other words::
482 *
483 * rate = clk_round_rate(clk, r);
484 *
485 * and::
486 *
487 * rate = clk_set_rate(clk, r);
488 *
489 * are equivalent except the former does not modify the clock hardware
490 * in any way.
491 *
492 * Return: rounded rate in Hz, or -ve error code.
493 */
494 ulong clk_round_rate(struct clk *clk, ulong rate);
495
496 /**
497 * clk_set_rate() - Set current clock rate.
498 * @clk: A clock struct that was previously successfully requested by
499 * clk_request/get_by_*().
500 * @rate: New clock rate in Hz.
501 *
502 * Return: new rate, or -ve error code.
503 */
504 ulong clk_set_rate(struct clk *clk, ulong rate);
505
506 /**
507 * clk_set_parent() - Set current clock parent.
508 * @clk: A clock struct that was previously successfully requested by
509 * clk_request/get_by_*().
510 * @parent: A clock struct that was previously successfully requested by
511 * clk_request/get_by_*().
512 *
513 * Return: new rate, or -ve error code.
514 */
515 int clk_set_parent(struct clk *clk, struct clk *parent);
516
517 /**
518 * clk_enable() - Enable (turn on) a clock.
519 * @clk: A clock struct that was previously successfully requested by
520 * clk_request/get_by_*().
521 *
522 * Return: zero on success, or -ve error code.
523 */
524 int clk_enable(struct clk *clk);
525
526 /**
527 * clk_enable_bulk() - Enable (turn on) all clocks in a clock bulk struct.
528 * @bulk: A clock bulk struct that was previously successfully requested
529 * by clk_get_bulk().
530 *
531 * Return: zero on success, or -ve error code.
532 */
533 int clk_enable_bulk(struct clk_bulk *bulk);
534
535 /**
536 * clk_disable() - Disable (turn off) a clock.
537 * @clk: A clock struct that was previously successfully requested by
538 * clk_request/get_by_*().
539 *
540 * Return: zero on success, or -ve error code.
541 */
542 int clk_disable(struct clk *clk);
543
544 /**
545 * clk_disable_bulk() - Disable (turn off) all clocks in a clock bulk struct.
546 * @bulk: A clock bulk struct that was previously successfully requested
547 * by clk_get_bulk().
548 *
549 * Return: zero on success, or -ve error code.
550 */
551 int clk_disable_bulk(struct clk_bulk *bulk);
552
553 /**
554 * clk_is_match - check if two clk's point to the same hardware clock
555 * @p: clk compared against q
556 * @q: clk compared against p
557 *
558 * Return:
559 * %true if the two struct clk pointers both point to the same hardware clock
560 * node, and %false otherwise. Note that two %NULL clks are treated as matching.
561 */
562 bool clk_is_match(const struct clk *p, const struct clk *q);
563
564 /**
565 * clk_get_by_id() - Get the clock by its ID
566 * @id: The clock ID to search for
567 * @clkp: A pointer to clock struct that has been found among added clocks
568 * to UCLASS_CLK
569 *
570 * Return: zero on success, or -ENOENT on error
571 */
572 int clk_get_by_id(ulong id, struct clk **clkp);
573
574 /**
575 * clk_dev_binded() - Check whether the clk has a device binded
576 * @clk: A pointer to the clk
577 *
578 * Return: true on binded, or false on no
579 */
580 bool clk_dev_binded(struct clk *clk);
581
582 /**
583 * clk_get_id - get clk id
584 *
585 * @clk: A clock struct
586 *
587 * Return: the clock identifier as it is defined by the clock provider in
588 * device tree or in platdata
589 */
590 ulong clk_get_id(const struct clk *clk);
591
592 #else /* CONFIG_IS_ENABLED(CLK) */
593
clk_request(struct udevice * dev,struct clk * clk)594 static inline int clk_request(struct udevice *dev, struct clk *clk)
595 {
596 return -ENOSYS;
597 }
598
clk_get_rate(struct clk * clk)599 static inline ulong clk_get_rate(struct clk *clk)
600 {
601 return -ENOSYS;
602 }
603
clk_get_parent(struct clk * clk)604 static inline struct clk *clk_get_parent(struct clk *clk)
605 {
606 return ERR_PTR(-ENOSYS);
607 }
608
clk_get_parent_rate(struct clk * clk)609 static inline ulong clk_get_parent_rate(struct clk *clk)
610 {
611 return -ENOSYS;
612 }
613
clk_round_rate(struct clk * clk,ulong rate)614 static inline ulong clk_round_rate(struct clk *clk, ulong rate)
615 {
616 return -ENOSYS;
617 }
618
clk_set_rate(struct clk * clk,ulong rate)619 static inline ulong clk_set_rate(struct clk *clk, ulong rate)
620 {
621 return -ENOSYS;
622 }
623
clk_set_parent(struct clk * clk,struct clk * parent)624 static inline int clk_set_parent(struct clk *clk, struct clk *parent)
625 {
626 return -ENOSYS;
627 }
628
clk_enable(struct clk * clk)629 static inline int clk_enable(struct clk *clk)
630 {
631 return 0;
632 }
633
clk_enable_bulk(struct clk_bulk * bulk)634 static inline int clk_enable_bulk(struct clk_bulk *bulk)
635 {
636 return 0;
637 }
638
clk_disable(struct clk * clk)639 static inline int clk_disable(struct clk *clk)
640 {
641 return 0;
642 }
643
clk_disable_bulk(struct clk_bulk * bulk)644 static inline int clk_disable_bulk(struct clk_bulk *bulk)
645 {
646 return 0;
647 }
648
clk_is_match(const struct clk * p,const struct clk * q)649 static inline bool clk_is_match(const struct clk *p, const struct clk *q)
650 {
651 return false;
652 }
653
clk_get_by_id(ulong id,struct clk ** clkp)654 static inline int clk_get_by_id(ulong id, struct clk **clkp)
655 {
656 return -ENOSYS;
657 }
658
clk_dev_binded(struct clk * clk)659 static inline bool clk_dev_binded(struct clk *clk)
660 {
661 return false;
662 }
663
clk_get_id(const struct clk * clk)664 static inline ulong clk_get_id(const struct clk *clk)
665 {
666 return 0;
667 }
668 #endif /* CONFIG_IS_ENABLED(CLK) */
669
670 /**
671 * clk_valid() - check if clk is valid
672 * @clk: the clock to check
673 *
674 * Return: true if valid, or false
675 */
clk_valid(struct clk * clk)676 static inline bool clk_valid(struct clk *clk)
677 {
678 return clk && !!clk->dev;
679 }
680
681 #endif
682
683 #define clk_prepare_enable(clk) clk_enable(clk)
684 #define clk_disable_unprepare(clk) clk_disable(clk)
685