clk: keystone: sci-clk: Fix sci_clk_get
[sfrench/cifs-2.6.git] / drivers / clk / keystone / sci-clk.c
1 /*
2  * SCI Clock driver for keystone based devices
3  *
4  * Copyright (C) 2015-2016 Texas Instruments Incorporated - http://www.ti.com/
5  *      Tero Kristo <t-kristo@ti.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  *
11  * This program is distributed "as is" WITHOUT ANY WARRANTY of any
12  * kind, whether express or implied; without even the implied warranty
13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  */
16 #include <linux/clk-provider.h>
17 #include <linux/err.h>
18 #include <linux/io.h>
19 #include <linux/module.h>
20 #include <linux/of_address.h>
21 #include <linux/of_device.h>
22 #include <linux/platform_device.h>
23 #include <linux/slab.h>
24 #include <linux/soc/ti/ti_sci_protocol.h>
25 #include <linux/bsearch.h>
26
27 #define SCI_CLK_SSC_ENABLE              BIT(0)
28 #define SCI_CLK_ALLOW_FREQ_CHANGE       BIT(1)
29 #define SCI_CLK_INPUT_TERMINATION       BIT(2)
30
31 /**
32  * struct sci_clk_data - TI SCI clock data
33  * @dev: device index
34  * @num_clks: number of clocks for this device
35  */
36 struct sci_clk_data {
37         u16 dev;
38         u16 num_clks;
39 };
40
41 /**
42  * struct sci_clk_provider - TI SCI clock provider representation
43  * @sci: Handle to the System Control Interface protocol handler
44  * @ops: Pointer to the SCI ops to be used by the clocks
45  * @dev: Device pointer for the clock provider
46  * @clk_data: Clock data
47  * @clocks: Clocks array for this device
48  * @num_clocks: Total number of clocks for this provider
49  */
50 struct sci_clk_provider {
51         const struct ti_sci_handle *sci;
52         const struct ti_sci_clk_ops *ops;
53         struct device *dev;
54         const struct sci_clk_data *clk_data;
55         struct clk_hw **clocks;
56         int num_clocks;
57 };
58
59 /**
60  * struct sci_clk - TI SCI clock representation
61  * @hw:          Hardware clock cookie for common clock framework
62  * @dev_id:      Device index
63  * @clk_id:      Clock index
64  * @provider:    Master clock provider
65  * @flags:       Flags for the clock
66  */
67 struct sci_clk {
68         struct clk_hw hw;
69         u16 dev_id;
70         u8 clk_id;
71         struct sci_clk_provider *provider;
72         u8 flags;
73 };
74
75 #define to_sci_clk(_hw) container_of(_hw, struct sci_clk, hw)
76
77 /**
78  * sci_clk_prepare - Prepare (enable) a TI SCI clock
79  * @hw: clock to prepare
80  *
81  * Prepares a clock to be actively used. Returns the SCI protocol status.
82  */
83 static int sci_clk_prepare(struct clk_hw *hw)
84 {
85         struct sci_clk *clk = to_sci_clk(hw);
86         bool enable_ssc = clk->flags & SCI_CLK_SSC_ENABLE;
87         bool allow_freq_change = clk->flags & SCI_CLK_ALLOW_FREQ_CHANGE;
88         bool input_termination = clk->flags & SCI_CLK_INPUT_TERMINATION;
89
90         return clk->provider->ops->get_clock(clk->provider->sci, clk->dev_id,
91                                              clk->clk_id, enable_ssc,
92                                              allow_freq_change,
93                                              input_termination);
94 }
95
96 /**
97  * sci_clk_unprepare - Un-prepares (disables) a TI SCI clock
98  * @hw: clock to unprepare
99  *
100  * Un-prepares a clock from active state.
101  */
102 static void sci_clk_unprepare(struct clk_hw *hw)
103 {
104         struct sci_clk *clk = to_sci_clk(hw);
105         int ret;
106
107         ret = clk->provider->ops->put_clock(clk->provider->sci, clk->dev_id,
108                                             clk->clk_id);
109         if (ret)
110                 dev_err(clk->provider->dev,
111                         "unprepare failed for dev=%d, clk=%d, ret=%d\n",
112                         clk->dev_id, clk->clk_id, ret);
113 }
114
115 /**
116  * sci_clk_is_prepared - Check if a TI SCI clock is prepared or not
117  * @hw: clock to check status for
118  *
119  * Checks if a clock is prepared (enabled) in hardware. Returns non-zero
120  * value if clock is enabled, zero otherwise.
121  */
122 static int sci_clk_is_prepared(struct clk_hw *hw)
123 {
124         struct sci_clk *clk = to_sci_clk(hw);
125         bool req_state, current_state;
126         int ret;
127
128         ret = clk->provider->ops->is_on(clk->provider->sci, clk->dev_id,
129                                         clk->clk_id, &req_state,
130                                         &current_state);
131         if (ret) {
132                 dev_err(clk->provider->dev,
133                         "is_prepared failed for dev=%d, clk=%d, ret=%d\n",
134                         clk->dev_id, clk->clk_id, ret);
135                 return 0;
136         }
137
138         return req_state;
139 }
140
141 /**
142  * sci_clk_recalc_rate - Get clock rate for a TI SCI clock
143  * @hw: clock to get rate for
144  * @parent_rate: parent rate provided by common clock framework, not used
145  *
146  * Gets the current clock rate of a TI SCI clock. Returns the current
147  * clock rate, or zero in failure.
148  */
149 static unsigned long sci_clk_recalc_rate(struct clk_hw *hw,
150                                          unsigned long parent_rate)
151 {
152         struct sci_clk *clk = to_sci_clk(hw);
153         u64 freq;
154         int ret;
155
156         ret = clk->provider->ops->get_freq(clk->provider->sci, clk->dev_id,
157                                            clk->clk_id, &freq);
158         if (ret) {
159                 dev_err(clk->provider->dev,
160                         "recalc-rate failed for dev=%d, clk=%d, ret=%d\n",
161                         clk->dev_id, clk->clk_id, ret);
162                 return 0;
163         }
164
165         return freq;
166 }
167
168 /**
169  * sci_clk_determine_rate - Determines a clock rate a clock can be set to
170  * @hw: clock to change rate for
171  * @req: requested rate configuration for the clock
172  *
173  * Determines a suitable clock rate and parent for a TI SCI clock.
174  * The parent handling is un-used, as generally the parent clock rates
175  * are not known by the kernel; instead these are internally handled
176  * by the firmware. Returns 0 on success, negative error value on failure.
177  */
178 static int sci_clk_determine_rate(struct clk_hw *hw,
179                                   struct clk_rate_request *req)
180 {
181         struct sci_clk *clk = to_sci_clk(hw);
182         int ret;
183         u64 new_rate;
184
185         ret = clk->provider->ops->get_best_match_freq(clk->provider->sci,
186                                                       clk->dev_id,
187                                                       clk->clk_id,
188                                                       req->min_rate,
189                                                       req->rate,
190                                                       req->max_rate,
191                                                       &new_rate);
192         if (ret) {
193                 dev_err(clk->provider->dev,
194                         "determine-rate failed for dev=%d, clk=%d, ret=%d\n",
195                         clk->dev_id, clk->clk_id, ret);
196                 return ret;
197         }
198
199         req->rate = new_rate;
200
201         return 0;
202 }
203
204 /**
205  * sci_clk_set_rate - Set rate for a TI SCI clock
206  * @hw: clock to change rate for
207  * @rate: target rate for the clock
208  * @parent_rate: rate of the clock parent, not used for TI SCI clocks
209  *
210  * Sets a clock frequency for a TI SCI clock. Returns the TI SCI
211  * protocol status.
212  */
213 static int sci_clk_set_rate(struct clk_hw *hw, unsigned long rate,
214                             unsigned long parent_rate)
215 {
216         struct sci_clk *clk = to_sci_clk(hw);
217
218         return clk->provider->ops->set_freq(clk->provider->sci, clk->dev_id,
219                                             clk->clk_id, rate, rate, rate);
220 }
221
222 /**
223  * sci_clk_get_parent - Get the current parent of a TI SCI clock
224  * @hw: clock to get parent for
225  *
226  * Returns the index of the currently selected parent for a TI SCI clock.
227  */
228 static u8 sci_clk_get_parent(struct clk_hw *hw)
229 {
230         struct sci_clk *clk = to_sci_clk(hw);
231         u8 parent_id;
232         int ret;
233
234         ret = clk->provider->ops->get_parent(clk->provider->sci, clk->dev_id,
235                                              clk->clk_id, &parent_id);
236         if (ret) {
237                 dev_err(clk->provider->dev,
238                         "get-parent failed for dev=%d, clk=%d, ret=%d\n",
239                         clk->dev_id, clk->clk_id, ret);
240                 return 0;
241         }
242
243         return parent_id - clk->clk_id - 1;
244 }
245
246 /**
247  * sci_clk_set_parent - Set the parent of a TI SCI clock
248  * @hw: clock to set parent for
249  * @index: new parent index for the clock
250  *
251  * Sets the parent of a TI SCI clock. Return TI SCI protocol status.
252  */
253 static int sci_clk_set_parent(struct clk_hw *hw, u8 index)
254 {
255         struct sci_clk *clk = to_sci_clk(hw);
256
257         return clk->provider->ops->set_parent(clk->provider->sci, clk->dev_id,
258                                               clk->clk_id,
259                                               index + 1 + clk->clk_id);
260 }
261
262 static const struct clk_ops sci_clk_ops = {
263         .prepare = sci_clk_prepare,
264         .unprepare = sci_clk_unprepare,
265         .is_prepared = sci_clk_is_prepared,
266         .recalc_rate = sci_clk_recalc_rate,
267         .determine_rate = sci_clk_determine_rate,
268         .set_rate = sci_clk_set_rate,
269         .get_parent = sci_clk_get_parent,
270         .set_parent = sci_clk_set_parent,
271 };
272
273 /**
274  * _sci_clk_get - Gets a handle for an SCI clock
275  * @provider: Handle to SCI clock provider
276  * @dev_id: device ID for the clock to register
277  * @clk_id: clock ID for the clock to register
278  *
279  * Gets a handle to an existing TI SCI hw clock, or builds a new clock
280  * entry and registers it with the common clock framework. Called from
281  * the common clock framework, when a corresponding of_clk_get call is
282  * executed, or recursively from itself when parsing parent clocks.
283  * Returns a pointer to the hw clock struct, or ERR_PTR value in failure.
284  */
285 static struct clk_hw *_sci_clk_build(struct sci_clk_provider *provider,
286                                      u16 dev_id, u8 clk_id)
287 {
288         struct clk_init_data init = { NULL };
289         struct sci_clk *sci_clk = NULL;
290         char *name = NULL;
291         char **parent_names = NULL;
292         int i;
293         int ret;
294
295         sci_clk = devm_kzalloc(provider->dev, sizeof(*sci_clk), GFP_KERNEL);
296         if (!sci_clk)
297                 return ERR_PTR(-ENOMEM);
298
299         sci_clk->dev_id = dev_id;
300         sci_clk->clk_id = clk_id;
301         sci_clk->provider = provider;
302
303         ret = provider->ops->get_num_parents(provider->sci, dev_id,
304                                              clk_id,
305                                              &init.num_parents);
306         if (ret)
307                 goto err;
308
309         name = kasprintf(GFP_KERNEL, "%s:%d:%d", dev_name(provider->dev),
310                          sci_clk->dev_id, sci_clk->clk_id);
311
312         init.name = name;
313
314         /*
315          * From kernel point of view, we only care about a clocks parents,
316          * if it has more than 1 possible parent. In this case, it is going
317          * to have mux functionality. Otherwise it is going to act as a root
318          * clock.
319          */
320         if (init.num_parents < 2)
321                 init.num_parents = 0;
322
323         if (init.num_parents) {
324                 parent_names = kcalloc(init.num_parents, sizeof(char *),
325                                        GFP_KERNEL);
326
327                 if (!parent_names) {
328                         ret = -ENOMEM;
329                         goto err;
330                 }
331
332                 for (i = 0; i < init.num_parents; i++) {
333                         char *parent_name;
334
335                         parent_name = kasprintf(GFP_KERNEL, "%s:%d:%d",
336                                                 dev_name(provider->dev),
337                                                 sci_clk->dev_id,
338                                                 sci_clk->clk_id + 1 + i);
339                         if (!parent_name) {
340                                 ret = -ENOMEM;
341                                 goto err;
342                         }
343                         parent_names[i] = parent_name;
344                 }
345                 init.parent_names = (void *)parent_names;
346         }
347
348         init.ops = &sci_clk_ops;
349         sci_clk->hw.init = &init;
350
351         ret = devm_clk_hw_register(provider->dev, &sci_clk->hw);
352         if (ret)
353                 dev_err(provider->dev, "failed clk register with %d\n", ret);
354
355 err:
356         if (parent_names) {
357                 for (i = 0; i < init.num_parents; i++)
358                         kfree(parent_names[i]);
359
360                 kfree(parent_names);
361         }
362
363         kfree(name);
364
365         if (ret)
366                 return ERR_PTR(ret);
367
368         return &sci_clk->hw;
369 }
370
371 static int _cmp_sci_clk(const void *a, const void *b)
372 {
373         const struct sci_clk *ca = a;
374         const struct sci_clk *cb = *(struct sci_clk **)b;
375
376         if (ca->dev_id == cb->dev_id && ca->clk_id == cb->clk_id)
377                 return 0;
378         if (ca->dev_id > cb->dev_id ||
379             (ca->dev_id == cb->dev_id && ca->clk_id > cb->clk_id))
380                 return 1;
381         return -1;
382 }
383
384 /**
385  * sci_clk_get - Xlate function for getting clock handles
386  * @clkspec: device tree clock specifier
387  * @data: pointer to the clock provider
388  *
389  * Xlate function for retrieving clock TI SCI hw clock handles based on
390  * device tree clock specifier. Called from the common clock framework,
391  * when a corresponding of_clk_get call is executed. Returns a pointer
392  * to the TI SCI hw clock struct, or ERR_PTR value in failure.
393  */
394 static struct clk_hw *sci_clk_get(struct of_phandle_args *clkspec, void *data)
395 {
396         struct sci_clk_provider *provider = data;
397         struct sci_clk **clk;
398         struct sci_clk key;
399
400         if (clkspec->args_count != 2)
401                 return ERR_PTR(-EINVAL);
402
403         key.dev_id = clkspec->args[0];
404         key.clk_id = clkspec->args[1];
405
406         clk = bsearch(&key, provider->clocks, provider->num_clocks,
407                       sizeof(clk), _cmp_sci_clk);
408
409         if (!clk)
410                 return ERR_PTR(-ENODEV);
411
412         return &(*clk)->hw;
413 }
414
415 static int ti_sci_init_clocks(struct sci_clk_provider *p)
416 {
417         const struct sci_clk_data *data = p->clk_data;
418         struct clk_hw *hw;
419         int i;
420         int num_clks = 0;
421
422         while (data->num_clks) {
423                 num_clks += data->num_clks;
424                 data++;
425         }
426
427         p->num_clocks = num_clks;
428
429         p->clocks = devm_kcalloc(p->dev, num_clks, sizeof(struct sci_clk),
430                                  GFP_KERNEL);
431         if (!p->clocks)
432                 return -ENOMEM;
433
434         num_clks = 0;
435
436         data = p->clk_data;
437
438         while (data->num_clks) {
439                 for (i = 0; i < data->num_clks; i++) {
440                         hw = _sci_clk_build(p, data->dev, i);
441                         if (!IS_ERR(hw)) {
442                                 p->clocks[num_clks++] = hw;
443                                 continue;
444                         }
445
446                         /* Skip any holes in the clock lists */
447                         if (PTR_ERR(hw) == -ENODEV)
448                                 continue;
449
450                         return PTR_ERR(hw);
451                 }
452                 data++;
453         }
454
455         return 0;
456 }
457
458 static const struct sci_clk_data k2g_clk_data[] = {
459         /* pmmc */
460         { .dev = 0x0, .num_clks = 4 },
461
462         /* mlb0 */
463         { .dev = 0x1, .num_clks = 5 },
464
465         /* dss0 */
466         { .dev = 0x2, .num_clks = 2 },
467
468         /* mcbsp0 */
469         { .dev = 0x3, .num_clks = 8 },
470
471         /* mcasp0 */
472         { .dev = 0x4, .num_clks = 8 },
473
474         /* mcasp1 */
475         { .dev = 0x5, .num_clks = 8 },
476
477         /* mcasp2 */
478         { .dev = 0x6, .num_clks = 8 },
479
480         /* dcan0 */
481         { .dev = 0x8, .num_clks = 2 },
482
483         /* dcan1 */
484         { .dev = 0x9, .num_clks = 2 },
485
486         /* emif0 */
487         { .dev = 0xa, .num_clks = 6 },
488
489         /* mmchs0 */
490         { .dev = 0xb, .num_clks = 3 },
491
492         /* mmchs1 */
493         { .dev = 0xc, .num_clks = 3 },
494
495         /* gpmc0 */
496         { .dev = 0xd, .num_clks = 1 },
497
498         /* elm0 */
499         { .dev = 0xe, .num_clks = 1 },
500
501         /* spi0 */
502         { .dev = 0x10, .num_clks = 1 },
503
504         /* spi1 */
505         { .dev = 0x11, .num_clks = 1 },
506
507         /* spi2 */
508         { .dev = 0x12, .num_clks = 1 },
509
510         /* spi3 */
511         { .dev = 0x13, .num_clks = 1 },
512
513         /* icss0 */
514         { .dev = 0x14, .num_clks = 6 },
515
516         /* icss1 */
517         { .dev = 0x15, .num_clks = 6 },
518
519         /* usb0 */
520         { .dev = 0x16, .num_clks = 7 },
521
522         /* usb1 */
523         { .dev = 0x17, .num_clks = 7 },
524
525         /* nss0 */
526         { .dev = 0x18, .num_clks = 14 },
527
528         /* pcie0 */
529         { .dev = 0x19, .num_clks = 1 },
530
531         /* gpio0 */
532         { .dev = 0x1b, .num_clks = 1 },
533
534         /* gpio1 */
535         { .dev = 0x1c, .num_clks = 1 },
536
537         /* timer64_0 */
538         { .dev = 0x1d, .num_clks = 9 },
539
540         /* timer64_1 */
541         { .dev = 0x1e, .num_clks = 9 },
542
543         /* timer64_2 */
544         { .dev = 0x1f, .num_clks = 9 },
545
546         /* timer64_3 */
547         { .dev = 0x20, .num_clks = 9 },
548
549         /* timer64_4 */
550         { .dev = 0x21, .num_clks = 9 },
551
552         /* timer64_5 */
553         { .dev = 0x22, .num_clks = 9 },
554
555         /* timer64_6 */
556         { .dev = 0x23, .num_clks = 9 },
557
558         /* msgmgr0 */
559         { .dev = 0x25, .num_clks = 1 },
560
561         /* bootcfg0 */
562         { .dev = 0x26, .num_clks = 1 },
563
564         /* arm_bootrom0 */
565         { .dev = 0x27, .num_clks = 1 },
566
567         /* dsp_bootrom0 */
568         { .dev = 0x29, .num_clks = 1 },
569
570         /* debugss0 */
571         { .dev = 0x2b, .num_clks = 8 },
572
573         /* uart0 */
574         { .dev = 0x2c, .num_clks = 1 },
575
576         /* uart1 */
577         { .dev = 0x2d, .num_clks = 1 },
578
579         /* uart2 */
580         { .dev = 0x2e, .num_clks = 1 },
581
582         /* ehrpwm0 */
583         { .dev = 0x2f, .num_clks = 1 },
584
585         /* ehrpwm1 */
586         { .dev = 0x30, .num_clks = 1 },
587
588         /* ehrpwm2 */
589         { .dev = 0x31, .num_clks = 1 },
590
591         /* ehrpwm3 */
592         { .dev = 0x32, .num_clks = 1 },
593
594         /* ehrpwm4 */
595         { .dev = 0x33, .num_clks = 1 },
596
597         /* ehrpwm5 */
598         { .dev = 0x34, .num_clks = 1 },
599
600         /* eqep0 */
601         { .dev = 0x35, .num_clks = 1 },
602
603         /* eqep1 */
604         { .dev = 0x36, .num_clks = 1 },
605
606         /* eqep2 */
607         { .dev = 0x37, .num_clks = 1 },
608
609         /* ecap0 */
610         { .dev = 0x38, .num_clks = 1 },
611
612         /* ecap1 */
613         { .dev = 0x39, .num_clks = 1 },
614
615         /* i2c0 */
616         { .dev = 0x3a, .num_clks = 1 },
617
618         /* i2c1 */
619         { .dev = 0x3b, .num_clks = 1 },
620
621         /* i2c2 */
622         { .dev = 0x3c, .num_clks = 1 },
623
624         /* edma0 */
625         { .dev = 0x3f, .num_clks = 2 },
626
627         /* semaphore0 */
628         { .dev = 0x40, .num_clks = 1 },
629
630         /* intc0 */
631         { .dev = 0x41, .num_clks = 1 },
632
633         /* gic0 */
634         { .dev = 0x42, .num_clks = 1 },
635
636         /* qspi0 */
637         { .dev = 0x43, .num_clks = 5 },
638
639         /* arm_64b_counter0 */
640         { .dev = 0x44, .num_clks = 2 },
641
642         /* tetris0 */
643         { .dev = 0x45, .num_clks = 2 },
644
645         /* cgem0 */
646         { .dev = 0x46, .num_clks = 2 },
647
648         /* msmc0 */
649         { .dev = 0x47, .num_clks = 1 },
650
651         /* cbass0 */
652         { .dev = 0x49, .num_clks = 1 },
653
654         /* board0 */
655         { .dev = 0x4c, .num_clks = 36 },
656
657         /* edma1 */
658         { .dev = 0x4f, .num_clks = 2 },
659         { .num_clks = 0 },
660 };
661
662 static const struct of_device_id ti_sci_clk_of_match[] = {
663         { .compatible = "ti,k2g-sci-clk", .data = &k2g_clk_data },
664         { /* Sentinel */ },
665 };
666 MODULE_DEVICE_TABLE(of, ti_sci_clk_of_match);
667
668 /**
669  * ti_sci_clk_probe - Probe function for the TI SCI clock driver
670  * @pdev: platform device pointer to be probed
671  *
672  * Probes the TI SCI clock device. Allocates a new clock provider
673  * and registers this to the common clock framework. Also applies
674  * any required flags to the identified clocks via clock lists
675  * supplied from DT. Returns 0 for success, negative error value
676  * for failure.
677  */
678 static int ti_sci_clk_probe(struct platform_device *pdev)
679 {
680         struct device *dev = &pdev->dev;
681         struct device_node *np = dev->of_node;
682         struct sci_clk_provider *provider;
683         const struct ti_sci_handle *handle;
684         const struct sci_clk_data *data;
685         int ret;
686
687         data = of_device_get_match_data(dev);
688         if (!data)
689                 return -EINVAL;
690
691         handle = devm_ti_sci_get_handle(dev);
692         if (IS_ERR(handle))
693                 return PTR_ERR(handle);
694
695         provider = devm_kzalloc(dev, sizeof(*provider), GFP_KERNEL);
696         if (!provider)
697                 return -ENOMEM;
698
699         provider->clk_data = data;
700
701         provider->sci = handle;
702         provider->ops = &handle->ops.clk_ops;
703         provider->dev = dev;
704
705         ret = ti_sci_init_clocks(provider);
706         if (ret) {
707                 pr_err("ti-sci-init-clocks failed.\n");
708                 return ret;
709         }
710
711         return of_clk_add_hw_provider(np, sci_clk_get, provider);
712 }
713
714 /**
715  * ti_sci_clk_remove - Remove TI SCI clock device
716  * @pdev: platform device pointer for the device to be removed
717  *
718  * Removes the TI SCI device. Unregisters the clock provider registered
719  * via common clock framework. Any memory allocated for the device will
720  * be free'd silently via the devm framework. Returns 0 always.
721  */
722 static int ti_sci_clk_remove(struct platform_device *pdev)
723 {
724         of_clk_del_provider(pdev->dev.of_node);
725
726         return 0;
727 }
728
729 static struct platform_driver ti_sci_clk_driver = {
730         .probe = ti_sci_clk_probe,
731         .remove = ti_sci_clk_remove,
732         .driver = {
733                 .name = "ti-sci-clk",
734                 .of_match_table = of_match_ptr(ti_sci_clk_of_match),
735         },
736 };
737 module_platform_driver(ti_sci_clk_driver);
738
739 MODULE_LICENSE("GPL v2");
740 MODULE_DESCRIPTION("TI System Control Interface(SCI) Clock driver");
741 MODULE_AUTHOR("Tero Kristo");
742 MODULE_ALIAS("platform:ti-sci-clk");