1 /*
2 * Copyright (C) 2016 NVIDIA Corporation
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 */
8
9 #include <linux/clk-provider.h>
10 #include <linux/device.h>
11 #include <linux/seq_buf.h>
12 #include <linux/slab.h>
13
14 #include <soc/tegra/bpmp.h>
15 #include <soc/tegra/bpmp-abi.h>
16
17 #define TEGRA_BPMP_DUMP_CLOCK_INFO 0
18
19 #define TEGRA_BPMP_CLK_HAS_MUX BIT(0)
20 #define TEGRA_BPMP_CLK_HAS_SET_RATE BIT(1)
21 #define TEGRA_BPMP_CLK_IS_ROOT BIT(2)
22
23 struct tegra_bpmp_clk_info {
24 unsigned int id;
25 char name[MRQ_CLK_NAME_MAXLEN];
26 unsigned int parents[MRQ_CLK_MAX_PARENTS];
27 unsigned int num_parents;
28 unsigned long flags;
29 };
30
31 struct tegra_bpmp_clk {
32 struct clk_hw hw;
33
34 struct tegra_bpmp *bpmp;
35 unsigned int id;
36
37 unsigned int num_parents;
38 unsigned int *parents;
39 };
40
to_tegra_bpmp_clk(struct clk_hw * hw)41 static inline struct tegra_bpmp_clk *to_tegra_bpmp_clk(struct clk_hw *hw)
42 {
43 return container_of(hw, struct tegra_bpmp_clk, hw);
44 }
45
46 struct tegra_bpmp_clk_message {
47 unsigned int cmd;
48 unsigned int id;
49
50 struct {
51 const void *data;
52 size_t size;
53 } tx;
54
55 struct {
56 void *data;
57 size_t size;
58 int ret;
59 } rx;
60 };
61
tegra_bpmp_clk_transfer(struct tegra_bpmp * bpmp,const struct tegra_bpmp_clk_message * clk)62 static int tegra_bpmp_clk_transfer(struct tegra_bpmp *bpmp,
63 const struct tegra_bpmp_clk_message *clk)
64 {
65 struct mrq_clk_request request;
66 struct tegra_bpmp_message msg;
67 void *req = &request;
68 int err;
69
70 memset(&request, 0, sizeof(request));
71 request.cmd_and_id = (clk->cmd << 24) | clk->id;
72
73 /*
74 * The mrq_clk_request structure has an anonymous union at offset 4
75 * that contains all possible sub-command structures. Copy the data
76 * to that union. Ideally we'd be able to refer to it by name, but
77 * doing so would require changing the ABI header and increase the
78 * maintenance burden.
79 */
80 memcpy(req + 4, clk->tx.data, clk->tx.size);
81
82 memset(&msg, 0, sizeof(msg));
83 msg.mrq = MRQ_CLK;
84 msg.tx.data = &request;
85 msg.tx.size = sizeof(request);
86 msg.rx.data = clk->rx.data;
87 msg.rx.size = clk->rx.size;
88
89 err = tegra_bpmp_transfer(bpmp, &msg);
90 if (err < 0)
91 return err;
92 else if (msg.rx.ret < 0)
93 return -EINVAL;
94
95 return 0;
96 }
97
tegra_bpmp_clk_prepare(struct clk_hw * hw)98 static int tegra_bpmp_clk_prepare(struct clk_hw *hw)
99 {
100 struct tegra_bpmp_clk *clk = to_tegra_bpmp_clk(hw);
101 struct tegra_bpmp_clk_message msg;
102
103 memset(&msg, 0, sizeof(msg));
104 msg.cmd = CMD_CLK_ENABLE;
105 msg.id = clk->id;
106
107 return tegra_bpmp_clk_transfer(clk->bpmp, &msg);
108 }
109
tegra_bpmp_clk_unprepare(struct clk_hw * hw)110 static void tegra_bpmp_clk_unprepare(struct clk_hw *hw)
111 {
112 struct tegra_bpmp_clk *clk = to_tegra_bpmp_clk(hw);
113 struct tegra_bpmp_clk_message msg;
114 int err;
115
116 memset(&msg, 0, sizeof(msg));
117 msg.cmd = CMD_CLK_DISABLE;
118 msg.id = clk->id;
119
120 err = tegra_bpmp_clk_transfer(clk->bpmp, &msg);
121 if (err < 0)
122 dev_err(clk->bpmp->dev, "failed to disable clock %s: %d\n",
123 clk_hw_get_name(hw), err);
124 }
125
tegra_bpmp_clk_is_prepared(struct clk_hw * hw)126 static int tegra_bpmp_clk_is_prepared(struct clk_hw *hw)
127 {
128 struct tegra_bpmp_clk *clk = to_tegra_bpmp_clk(hw);
129 struct cmd_clk_is_enabled_response response;
130 struct tegra_bpmp_clk_message msg;
131 int err;
132
133 memset(&msg, 0, sizeof(msg));
134 msg.cmd = CMD_CLK_IS_ENABLED;
135 msg.id = clk->id;
136 msg.rx.data = &response;
137 msg.rx.size = sizeof(response);
138
139 err = tegra_bpmp_clk_transfer(clk->bpmp, &msg);
140 if (err < 0)
141 return err;
142
143 return response.state;
144 }
145
tegra_bpmp_clk_recalc_rate(struct clk_hw * hw,unsigned long parent_rate)146 static unsigned long tegra_bpmp_clk_recalc_rate(struct clk_hw *hw,
147 unsigned long parent_rate)
148 {
149 struct tegra_bpmp_clk *clk = to_tegra_bpmp_clk(hw);
150 struct cmd_clk_get_rate_response response;
151 struct cmd_clk_get_rate_request request;
152 struct tegra_bpmp_clk_message msg;
153 int err;
154
155 memset(&msg, 0, sizeof(msg));
156 msg.cmd = CMD_CLK_GET_RATE;
157 msg.id = clk->id;
158 msg.tx.data = &request;
159 msg.tx.size = sizeof(request);
160 msg.rx.data = &response;
161 msg.rx.size = sizeof(response);
162
163 err = tegra_bpmp_clk_transfer(clk->bpmp, &msg);
164 if (err < 0)
165 return err;
166
167 return response.rate;
168 }
169
tegra_bpmp_clk_round_rate(struct clk_hw * hw,unsigned long rate,unsigned long * parent_rate)170 static long tegra_bpmp_clk_round_rate(struct clk_hw *hw, unsigned long rate,
171 unsigned long *parent_rate)
172 {
173 struct tegra_bpmp_clk *clk = to_tegra_bpmp_clk(hw);
174 struct cmd_clk_round_rate_response response;
175 struct cmd_clk_round_rate_request request;
176 struct tegra_bpmp_clk_message msg;
177 int err;
178
179 memset(&request, 0, sizeof(request));
180 request.rate = rate;
181
182 memset(&msg, 0, sizeof(msg));
183 msg.cmd = CMD_CLK_ROUND_RATE;
184 msg.id = clk->id;
185 msg.tx.data = &request;
186 msg.tx.size = sizeof(request);
187 msg.rx.data = &response;
188 msg.rx.size = sizeof(response);
189
190 err = tegra_bpmp_clk_transfer(clk->bpmp, &msg);
191 if (err < 0)
192 return err;
193
194 return response.rate;
195 }
196
tegra_bpmp_clk_set_parent(struct clk_hw * hw,u8 index)197 static int tegra_bpmp_clk_set_parent(struct clk_hw *hw, u8 index)
198 {
199 struct tegra_bpmp_clk *clk = to_tegra_bpmp_clk(hw);
200 struct cmd_clk_set_parent_response response;
201 struct cmd_clk_set_parent_request request;
202 struct tegra_bpmp_clk_message msg;
203 int err;
204
205 memset(&request, 0, sizeof(request));
206 request.parent_id = clk->parents[index];
207
208 memset(&msg, 0, sizeof(msg));
209 msg.cmd = CMD_CLK_SET_PARENT;
210 msg.id = clk->id;
211 msg.tx.data = &request;
212 msg.tx.size = sizeof(request);
213 msg.rx.data = &response;
214 msg.rx.size = sizeof(response);
215
216 err = tegra_bpmp_clk_transfer(clk->bpmp, &msg);
217 if (err < 0)
218 return err;
219
220 /* XXX check parent ID in response */
221
222 return 0;
223 }
224
tegra_bpmp_clk_get_parent(struct clk_hw * hw)225 static u8 tegra_bpmp_clk_get_parent(struct clk_hw *hw)
226 {
227 struct tegra_bpmp_clk *clk = to_tegra_bpmp_clk(hw);
228 struct cmd_clk_get_parent_response response;
229 struct tegra_bpmp_clk_message msg;
230 unsigned int i;
231 int err;
232
233 memset(&msg, 0, sizeof(msg));
234 msg.cmd = CMD_CLK_GET_PARENT;
235 msg.id = clk->id;
236 msg.rx.data = &response;
237 msg.rx.size = sizeof(response);
238
239 err = tegra_bpmp_clk_transfer(clk->bpmp, &msg);
240 if (err < 0) {
241 dev_err(clk->bpmp->dev, "failed to get parent for %s: %d\n",
242 clk_hw_get_name(hw), err);
243 return U8_MAX;
244 }
245
246 for (i = 0; i < clk->num_parents; i++)
247 if (clk->parents[i] == response.parent_id)
248 return i;
249
250 return U8_MAX;
251 }
252
tegra_bpmp_clk_set_rate(struct clk_hw * hw,unsigned long rate,unsigned long parent_rate)253 static int tegra_bpmp_clk_set_rate(struct clk_hw *hw, unsigned long rate,
254 unsigned long parent_rate)
255 {
256 struct tegra_bpmp_clk *clk = to_tegra_bpmp_clk(hw);
257 struct cmd_clk_set_rate_response response;
258 struct cmd_clk_set_rate_request request;
259 struct tegra_bpmp_clk_message msg;
260
261 memset(&request, 0, sizeof(request));
262 request.rate = rate;
263
264 memset(&msg, 0, sizeof(msg));
265 msg.cmd = CMD_CLK_SET_RATE;
266 msg.id = clk->id;
267 msg.tx.data = &request;
268 msg.tx.size = sizeof(request);
269 msg.rx.data = &response;
270 msg.rx.size = sizeof(response);
271
272 return tegra_bpmp_clk_transfer(clk->bpmp, &msg);
273 }
274
275 static const struct clk_ops tegra_bpmp_clk_gate_ops = {
276 .prepare = tegra_bpmp_clk_prepare,
277 .unprepare = tegra_bpmp_clk_unprepare,
278 .is_prepared = tegra_bpmp_clk_is_prepared,
279 .recalc_rate = tegra_bpmp_clk_recalc_rate,
280 };
281
282 static const struct clk_ops tegra_bpmp_clk_mux_ops = {
283 .prepare = tegra_bpmp_clk_prepare,
284 .unprepare = tegra_bpmp_clk_unprepare,
285 .is_prepared = tegra_bpmp_clk_is_prepared,
286 .recalc_rate = tegra_bpmp_clk_recalc_rate,
287 .set_parent = tegra_bpmp_clk_set_parent,
288 .get_parent = tegra_bpmp_clk_get_parent,
289 };
290
291 static const struct clk_ops tegra_bpmp_clk_rate_ops = {
292 .prepare = tegra_bpmp_clk_prepare,
293 .unprepare = tegra_bpmp_clk_unprepare,
294 .is_prepared = tegra_bpmp_clk_is_prepared,
295 .recalc_rate = tegra_bpmp_clk_recalc_rate,
296 .round_rate = tegra_bpmp_clk_round_rate,
297 .set_rate = tegra_bpmp_clk_set_rate,
298 };
299
300 static const struct clk_ops tegra_bpmp_clk_mux_rate_ops = {
301 .prepare = tegra_bpmp_clk_prepare,
302 .unprepare = tegra_bpmp_clk_unprepare,
303 .is_prepared = tegra_bpmp_clk_is_prepared,
304 .recalc_rate = tegra_bpmp_clk_recalc_rate,
305 .round_rate = tegra_bpmp_clk_round_rate,
306 .set_parent = tegra_bpmp_clk_set_parent,
307 .get_parent = tegra_bpmp_clk_get_parent,
308 .set_rate = tegra_bpmp_clk_set_rate,
309 };
310
tegra_bpmp_clk_get_max_id(struct tegra_bpmp * bpmp)311 static int tegra_bpmp_clk_get_max_id(struct tegra_bpmp *bpmp)
312 {
313 struct cmd_clk_get_max_clk_id_response response;
314 struct tegra_bpmp_clk_message msg;
315 int err;
316
317 memset(&msg, 0, sizeof(msg));
318 msg.cmd = CMD_CLK_GET_MAX_CLK_ID;
319 msg.rx.data = &response;
320 msg.rx.size = sizeof(response);
321
322 err = tegra_bpmp_clk_transfer(bpmp, &msg);
323 if (err < 0)
324 return err;
325
326 if (response.max_id > INT_MAX)
327 return -E2BIG;
328
329 return response.max_id;
330 }
331
tegra_bpmp_clk_get_info(struct tegra_bpmp * bpmp,unsigned int id,struct tegra_bpmp_clk_info * info)332 static int tegra_bpmp_clk_get_info(struct tegra_bpmp *bpmp, unsigned int id,
333 struct tegra_bpmp_clk_info *info)
334 {
335 struct cmd_clk_get_all_info_response response;
336 struct tegra_bpmp_clk_message msg;
337 unsigned int i;
338 int err;
339
340 memset(&msg, 0, sizeof(msg));
341 msg.cmd = CMD_CLK_GET_ALL_INFO;
342 msg.id = id;
343 msg.rx.data = &response;
344 msg.rx.size = sizeof(response);
345
346 err = tegra_bpmp_clk_transfer(bpmp, &msg);
347 if (err < 0)
348 return err;
349
350 strlcpy(info->name, response.name, MRQ_CLK_NAME_MAXLEN);
351 info->num_parents = response.num_parents;
352
353 for (i = 0; i < info->num_parents; i++)
354 info->parents[i] = response.parents[i];
355
356 info->flags = response.flags;
357
358 return 0;
359 }
360
tegra_bpmp_clk_info_dump(struct tegra_bpmp * bpmp,const char * level,const struct tegra_bpmp_clk_info * info)361 static void tegra_bpmp_clk_info_dump(struct tegra_bpmp *bpmp,
362 const char *level,
363 const struct tegra_bpmp_clk_info *info)
364 {
365 const char *prefix = "";
366 struct seq_buf buf;
367 unsigned int i;
368 char flags[64];
369
370 seq_buf_init(&buf, flags, sizeof(flags));
371
372 if (info->flags)
373 seq_buf_printf(&buf, "(");
374
375 if (info->flags & TEGRA_BPMP_CLK_HAS_MUX) {
376 seq_buf_printf(&buf, "%smux", prefix);
377 prefix = ", ";
378 }
379
380 if ((info->flags & TEGRA_BPMP_CLK_HAS_SET_RATE) == 0) {
381 seq_buf_printf(&buf, "%sfixed", prefix);
382 prefix = ", ";
383 }
384
385 if (info->flags & TEGRA_BPMP_CLK_IS_ROOT) {
386 seq_buf_printf(&buf, "%sroot", prefix);
387 prefix = ", ";
388 }
389
390 if (info->flags)
391 seq_buf_printf(&buf, ")");
392
393 dev_printk(level, bpmp->dev, "%03u: %s\n", info->id, info->name);
394 dev_printk(level, bpmp->dev, " flags: %lx %s\n", info->flags, flags);
395 dev_printk(level, bpmp->dev, " parents: %u\n", info->num_parents);
396
397 for (i = 0; i < info->num_parents; i++)
398 dev_printk(level, bpmp->dev, " %03u\n", info->parents[i]);
399 }
400
tegra_bpmp_probe_clocks(struct tegra_bpmp * bpmp,struct tegra_bpmp_clk_info ** clocksp)401 static int tegra_bpmp_probe_clocks(struct tegra_bpmp *bpmp,
402 struct tegra_bpmp_clk_info **clocksp)
403 {
404 struct tegra_bpmp_clk_info *clocks;
405 unsigned int max_id, id, count = 0;
406 unsigned int holes = 0;
407 int err;
408
409 err = tegra_bpmp_clk_get_max_id(bpmp);
410 if (err < 0)
411 return err;
412
413 max_id = err;
414
415 dev_dbg(bpmp->dev, "maximum clock ID: %u\n", max_id);
416
417 clocks = kcalloc(max_id + 1, sizeof(*clocks), GFP_KERNEL);
418 if (!clocks)
419 return -ENOMEM;
420
421 for (id = 0; id <= max_id; id++) {
422 struct tegra_bpmp_clk_info *info = &clocks[count];
423
424 err = tegra_bpmp_clk_get_info(bpmp, id, info);
425 if (err < 0)
426 continue;
427
428 if (info->num_parents >= U8_MAX) {
429 dev_err(bpmp->dev,
430 "clock %u has too many parents (%u, max: %u)\n",
431 id, info->num_parents, U8_MAX);
432 continue;
433 }
434
435 /* clock not exposed by BPMP */
436 if (info->name[0] == '\0') {
437 holes++;
438 continue;
439 }
440
441 info->id = id;
442 count++;
443
444 if (TEGRA_BPMP_DUMP_CLOCK_INFO)
445 tegra_bpmp_clk_info_dump(bpmp, KERN_DEBUG, info);
446 }
447
448 dev_dbg(bpmp->dev, "holes: %u\n", holes);
449 *clocksp = clocks;
450
451 return count;
452 }
453
454 static const struct tegra_bpmp_clk_info *
tegra_bpmp_clk_find(const struct tegra_bpmp_clk_info * clocks,unsigned int num_clocks,unsigned int id)455 tegra_bpmp_clk_find(const struct tegra_bpmp_clk_info *clocks,
456 unsigned int num_clocks, unsigned int id)
457 {
458 unsigned int i;
459
460 for (i = 0; i < num_clocks; i++)
461 if (clocks[i].id == id)
462 return &clocks[i];
463
464 return NULL;
465 }
466
467 static struct tegra_bpmp_clk *
tegra_bpmp_clk_register(struct tegra_bpmp * bpmp,const struct tegra_bpmp_clk_info * info,const struct tegra_bpmp_clk_info * clocks,unsigned int num_clocks)468 tegra_bpmp_clk_register(struct tegra_bpmp *bpmp,
469 const struct tegra_bpmp_clk_info *info,
470 const struct tegra_bpmp_clk_info *clocks,
471 unsigned int num_clocks)
472 {
473 struct tegra_bpmp_clk *clk;
474 struct clk_init_data init;
475 const char **parents;
476 unsigned int i;
477 int err;
478
479 clk = devm_kzalloc(bpmp->dev, sizeof(*clk), GFP_KERNEL);
480 if (!clk)
481 return ERR_PTR(-ENOMEM);
482
483 clk->id = info->id;
484 clk->bpmp = bpmp;
485
486 clk->parents = devm_kcalloc(bpmp->dev, info->num_parents,
487 sizeof(*clk->parents), GFP_KERNEL);
488 if (!clk->parents)
489 return ERR_PTR(-ENOMEM);
490
491 clk->num_parents = info->num_parents;
492
493 /* hardware clock initialization */
494 memset(&init, 0, sizeof(init));
495 init.name = info->name;
496 clk->hw.init = &init;
497
498 if (info->flags & TEGRA_BPMP_CLK_HAS_MUX) {
499 if (info->flags & TEGRA_BPMP_CLK_HAS_SET_RATE)
500 init.ops = &tegra_bpmp_clk_mux_rate_ops;
501 else
502 init.ops = &tegra_bpmp_clk_mux_ops;
503 } else {
504 if (info->flags & TEGRA_BPMP_CLK_HAS_SET_RATE)
505 init.ops = &tegra_bpmp_clk_rate_ops;
506 else
507 init.ops = &tegra_bpmp_clk_gate_ops;
508 }
509
510 init.num_parents = info->num_parents;
511
512 parents = kcalloc(info->num_parents, sizeof(*parents), GFP_KERNEL);
513 if (!parents)
514 return ERR_PTR(-ENOMEM);
515
516 for (i = 0; i < info->num_parents; i++) {
517 const struct tegra_bpmp_clk_info *parent;
518
519 /* keep a private copy of the ID to parent index map */
520 clk->parents[i] = info->parents[i];
521
522 parent = tegra_bpmp_clk_find(clocks, num_clocks,
523 info->parents[i]);
524 if (!parent) {
525 dev_err(bpmp->dev, "no parent %u found for %u\n",
526 info->parents[i], info->id);
527 continue;
528 }
529
530 parents[i] = parent->name;
531 }
532
533 init.parent_names = parents;
534
535 err = devm_clk_hw_register(bpmp->dev, &clk->hw);
536
537 kfree(parents);
538
539 if (err < 0)
540 return ERR_PTR(err);
541
542 return clk;
543 }
544
tegra_bpmp_register_clocks(struct tegra_bpmp * bpmp,struct tegra_bpmp_clk_info * infos,unsigned int count)545 static int tegra_bpmp_register_clocks(struct tegra_bpmp *bpmp,
546 struct tegra_bpmp_clk_info *infos,
547 unsigned int count)
548 {
549 struct tegra_bpmp_clk *clk;
550 unsigned int i;
551
552 bpmp->num_clocks = count;
553
554 bpmp->clocks = devm_kcalloc(bpmp->dev, count, sizeof(clk), GFP_KERNEL);
555 if (!bpmp->clocks)
556 return -ENOMEM;
557
558 for (i = 0; i < count; i++) {
559 struct tegra_bpmp_clk_info *info = &infos[i];
560
561 clk = tegra_bpmp_clk_register(bpmp, info, infos, count);
562 if (IS_ERR(clk)) {
563 dev_err(bpmp->dev,
564 "failed to register clock %u (%s): %ld\n",
565 info->id, info->name, PTR_ERR(clk));
566 continue;
567 }
568
569 bpmp->clocks[i] = clk;
570 }
571
572 return 0;
573 }
574
tegra_bpmp_unregister_clocks(struct tegra_bpmp * bpmp)575 static void tegra_bpmp_unregister_clocks(struct tegra_bpmp *bpmp)
576 {
577 unsigned int i;
578
579 for (i = 0; i < bpmp->num_clocks; i++)
580 clk_hw_unregister(&bpmp->clocks[i]->hw);
581 }
582
tegra_bpmp_clk_of_xlate(struct of_phandle_args * clkspec,void * data)583 static struct clk_hw *tegra_bpmp_clk_of_xlate(struct of_phandle_args *clkspec,
584 void *data)
585 {
586 unsigned int id = clkspec->args[0], i;
587 struct tegra_bpmp *bpmp = data;
588
589 for (i = 0; i < bpmp->num_clocks; i++) {
590 struct tegra_bpmp_clk *clk = bpmp->clocks[i];
591
592 if (!clk)
593 continue;
594
595 if (clk->id == id)
596 return &clk->hw;
597 }
598
599 return NULL;
600 }
601
tegra_bpmp_init_clocks(struct tegra_bpmp * bpmp)602 int tegra_bpmp_init_clocks(struct tegra_bpmp *bpmp)
603 {
604 struct tegra_bpmp_clk_info *clocks;
605 unsigned int count;
606 int err;
607
608 err = tegra_bpmp_probe_clocks(bpmp, &clocks);
609 if (err < 0)
610 return err;
611
612 count = err;
613
614 dev_dbg(bpmp->dev, "%u clocks probed\n", count);
615
616 err = tegra_bpmp_register_clocks(bpmp, clocks, count);
617 if (err < 0)
618 goto free;
619
620 err = of_clk_add_hw_provider(bpmp->dev->of_node,
621 tegra_bpmp_clk_of_xlate,
622 bpmp);
623 if (err < 0) {
624 tegra_bpmp_unregister_clocks(bpmp);
625 goto free;
626 }
627
628 free:
629 kfree(clocks);
630 return err;
631 }
632
