2 * Copyright (c) 2011, NVIDIA Corporation.
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; version 2 of the License.
8 * This program is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 #include <linux/kernel.h>
19 #include <linux/spinlock.h>
20 #include <linux/err.h>
22 #include <linux/clk.h>
23 #include <linux/interrupt.h>
24 #include <linux/suspend.h>
25 #include <linux/debugfs.h>
26 #include <linux/seq_file.h>
27 #include <linux/uaccess.h>
29 #include <mach/iomap.h>
30 #include <mach/irqs.h>
35 #define ACTMON_GLB_STATUS 0x00
36 #define ACTMON_GLB_PERIOD_CTRL 0x04
38 #define ACTMON_DEV_CTRL 0x00
39 #define ACTMON_DEV_CTRL_ENB (0x1 << 31)
40 #define ACTMON_DEV_CTRL_UP_WMARK_ENB (0x1 << 30)
41 #define ACTMON_DEV_CTRL_DOWN_WMARK_ENB (0x1 << 29)
42 #define ACTMON_DEV_CTRL_UP_WMARK_NUM_SHIFT 26
43 #define ACTMON_DEV_CTRL_UP_WMARK_NUM_MASK (0x7 << 26)
44 #define ACTMON_DEV_CTRL_DOWN_WMARK_NUM_SHIFT 23
45 #define ACTMON_DEV_CTRL_DOWN_WMARK_NUM_MASK (0x7 << 23)
46 #define ACTMON_DEV_CTRL_AVG_UP_WMARK_ENB (0x1 << 21)
47 #define ACTMON_DEV_CTRL_AVG_DOWN_WMARK_ENB (0x1 << 20)
48 #define ACTMON_DEV_CTRL_PERIODIC_ENB (0x1 << 18)
49 #define ACTMON_DEV_CTRL_K_VAL_SHIFT 10
50 #define ACTMON_DEV_CTRL_K_VAL_MASK (0x7 << 10)
52 #define ACTMON_DEV_UP_WMARK 0x04
53 #define ACTMON_DEV_DOWN_WMARK 0x08
54 #define ACTMON_DEV_INIT_AVG 0x0c
55 #define ACTMON_DEV_AVG_UP_WMARK 0x10
56 #define ACTMON_DEV_AVG_DOWN_WMARK 0x14
58 #define ACTMON_DEV_COUNT_WEGHT 0x18
59 #define ACTMON_DEV_COUNT 0x1c
60 #define ACTMON_DEV_AVG_COUNT 0x20
62 #define ACTMON_DEV_INTR_STATUS 0x24
63 #define ACTMON_DEV_INTR_UP_WMARK (0x1 << 31)
64 #define ACTMON_DEV_INTR_DOWN_WMARK (0x1 << 30)
65 #define ACTMON_DEV_INTR_AVG_DOWN_WMARK (0x1 << 25)
66 #define ACTMON_DEV_INTR_AVG_UP_WMARK (0x1 << 24)
68 #define ACTMON_DEFAULT_AVG_WINDOW_LOG2 6
69 #define ACTMON_DEFAULT_AVG_BAND 6 /* 1/10 of % */
77 ACTMON_UNINITIALIZED = -1,
83 #define ACTMON_DEFAULT_SAMPLING_PERIOD 12
84 static u8 actmon_sampling_period;
86 static unsigned long actmon_clk_freq;
91 * - coefficients, and thresholds in %
92 * - sampling period in ms
93 * - window in sample periods (value = setting + 1)
97 u32 glb_status_irq_mask;
102 unsigned long max_freq;
103 unsigned long target_freq;
104 unsigned long cur_freq;
106 unsigned long avg_actv_freq;
107 unsigned long avg_band_freq;
108 unsigned int avg_sustain_coef;
111 unsigned long boost_freq;
112 unsigned long boost_freq_step;
113 unsigned int boost_up_coef;
114 unsigned int boost_down_coef;
115 unsigned int boost_up_threshold;
116 unsigned int boost_down_threshold;
119 u8 down_wmark_window;
123 enum actmon_type type;
124 enum actmon_state state;
125 enum actmon_state saved_state;
129 struct notifier_block rate_change_nb;
132 static void __iomem *actmon_base = IO_ADDRESS(TEGRA_ACTMON_BASE);
134 static inline u32 actmon_readl(u32 offset)
136 return __raw_readl((u32)actmon_base + offset);
138 static inline void actmon_writel(u32 val, u32 offset)
140 __raw_writel(val, (u32)actmon_base + offset);
142 static inline void actmon_wmb(void)
145 actmon_readl(ACTMON_GLB_STATUS);
148 #define offs(x) (dev->reg + x)
150 static inline unsigned long do_percent(unsigned long val, unsigned int pct)
152 return val * pct / 100;
155 static inline void actmon_dev_up_wmark_set(struct actmon_dev *dev)
158 unsigned long freq = (dev->type == ACTMON_FREQ_SAMPLER) ?
159 dev->cur_freq : actmon_clk_freq;
161 val = freq * actmon_sampling_period;
162 actmon_writel(do_percent(val, dev->boost_up_threshold),
163 offs(ACTMON_DEV_UP_WMARK));
166 static inline void actmon_dev_down_wmark_set(struct actmon_dev *dev)
169 unsigned long freq = (dev->type == ACTMON_FREQ_SAMPLER) ?
170 dev->cur_freq : actmon_clk_freq;
172 val = freq * actmon_sampling_period;
173 actmon_writel(do_percent(val, dev->boost_down_threshold),
174 offs(ACTMON_DEV_DOWN_WMARK));
177 static inline void actmon_dev_wmark_set(struct actmon_dev *dev)
180 unsigned long freq = (dev->type == ACTMON_FREQ_SAMPLER) ?
181 dev->cur_freq : actmon_clk_freq;
183 val = freq * actmon_sampling_period;
184 actmon_writel(do_percent(val, dev->boost_up_threshold),
185 offs(ACTMON_DEV_UP_WMARK));
186 actmon_writel(do_percent(val, dev->boost_down_threshold),
187 offs(ACTMON_DEV_DOWN_WMARK));
190 static inline void actmon_dev_avg_wmark_set(struct actmon_dev *dev)
192 u32 avg = dev->avg_count;
193 u32 band = dev->avg_band_freq * actmon_sampling_period;
195 actmon_writel(avg + band, offs(ACTMON_DEV_AVG_UP_WMARK));
196 avg = max(avg, band);
197 actmon_writel(avg - band, offs(ACTMON_DEV_AVG_DOWN_WMARK));
200 static unsigned long actmon_dev_avg_freq_get(struct actmon_dev *dev)
204 if (dev->type == ACTMON_FREQ_SAMPLER)
205 return dev->avg_count / actmon_sampling_period;
207 val = (u64)dev->avg_count * dev->cur_freq;
208 do_div(val, actmon_clk_freq * actmon_sampling_period);
212 /* Activity monitor sampling operations */
213 irqreturn_t actmon_dev_isr(int irq, void *dev_id)
217 struct actmon_dev *dev = (struct actmon_dev *)dev_id;
219 val = actmon_readl(ACTMON_GLB_STATUS) & dev->glb_status_irq_mask;
223 spin_lock_irqsave(&dev->lock, flags);
225 dev->avg_count = actmon_readl(offs(ACTMON_DEV_AVG_COUNT));
226 actmon_dev_avg_wmark_set(dev);
228 val = actmon_readl(offs(ACTMON_DEV_INTR_STATUS));
229 if (val & ACTMON_DEV_INTR_UP_WMARK) {
230 val = actmon_readl(offs(ACTMON_DEV_CTRL)) |
231 ACTMON_DEV_CTRL_UP_WMARK_ENB |
232 ACTMON_DEV_CTRL_DOWN_WMARK_ENB;
234 dev->boost_freq = dev->boost_freq_step +
235 do_percent(dev->boost_freq, dev->boost_up_coef);
236 if (dev->boost_freq >= dev->max_freq) {
237 dev->boost_freq = dev->max_freq;
238 val &= ~ACTMON_DEV_CTRL_UP_WMARK_ENB;
240 actmon_writel(val, offs(ACTMON_DEV_CTRL));
241 } else if (val & ACTMON_DEV_INTR_DOWN_WMARK) {
242 val = actmon_readl(offs(ACTMON_DEV_CTRL)) |
243 ACTMON_DEV_CTRL_UP_WMARK_ENB |
244 ACTMON_DEV_CTRL_DOWN_WMARK_ENB;
247 do_percent(dev->boost_freq, dev->boost_down_coef);
248 if (dev->boost_freq < (dev->boost_freq_step >> 1)) {
250 val &= ~ACTMON_DEV_CTRL_DOWN_WMARK_ENB;
252 actmon_writel(val, offs(ACTMON_DEV_CTRL));
255 actmon_writel(0xffffffff, offs(ACTMON_DEV_INTR_STATUS)); /* clr all */
258 spin_unlock_irqrestore(&dev->lock, flags);
259 return IRQ_WAKE_THREAD;
262 irqreturn_t actmon_dev_fn(int irq, void *dev_id)
264 unsigned long flags, freq;
265 struct actmon_dev *dev = (struct actmon_dev *)dev_id;
267 spin_lock_irqsave(&dev->lock, flags);
269 if (dev->state != ACTMON_ON) {
270 spin_unlock_irqrestore(&dev->lock, flags);
274 freq = actmon_dev_avg_freq_get(dev);
275 dev->avg_actv_freq = freq;
276 freq = do_percent(freq, dev->avg_sustain_coef);
277 freq += dev->boost_freq;
278 dev->target_freq = freq;
280 spin_unlock_irqrestore(&dev->lock, flags);
282 pr_debug("%s.%s(kHz): avg: %lu, target: %lu current: %lu\n",
283 dev->dev_id, dev->con_id, dev->avg_actv_freq,
284 dev->target_freq, dev->cur_freq);
285 clk_set_rate(dev->clk, freq * 1000);
290 static int actmon_rate_notify_cb(
291 struct notifier_block *nb, unsigned long rate, void *v)
294 struct actmon_dev *dev = container_of(
295 nb, struct actmon_dev, rate_change_nb);
297 spin_lock_irqsave(&dev->lock, flags);
299 dev->cur_freq = rate / 1000;
300 if (dev->type == ACTMON_FREQ_SAMPLER) {
301 actmon_dev_wmark_set(dev);
305 spin_unlock_irqrestore(&dev->lock, flags);
309 /* Activity monitor configuration and control */
310 static void actmon_dev_configure(struct actmon_dev *dev, unsigned long freq)
314 dev->cur_freq = freq;
315 dev->target_freq = freq;
316 dev->avg_actv_freq = freq;
318 if (dev->type == ACTMON_FREQ_SAMPLER) {
319 dev->avg_count = dev->cur_freq * actmon_sampling_period;
320 dev->avg_band_freq = dev->max_freq *
321 ACTMON_DEFAULT_AVG_BAND / 1000;
323 dev->avg_count = actmon_clk_freq * actmon_sampling_period;
324 dev->avg_band_freq = actmon_clk_freq *
325 ACTMON_DEFAULT_AVG_BAND / 1000;
327 actmon_writel(dev->avg_count, offs(ACTMON_DEV_INIT_AVG));
329 BUG_ON(!dev->boost_up_threshold);
330 dev->avg_sustain_coef = 100 * 100 / dev->boost_up_threshold;
331 actmon_dev_avg_wmark_set(dev);
332 actmon_dev_wmark_set(dev);
334 actmon_writel(dev->count_weight, offs(ACTMON_DEV_COUNT_WEGHT));
335 actmon_writel(0xffffffff, offs(ACTMON_DEV_INTR_STATUS)); /* clr all */
337 val = ACTMON_DEV_CTRL_PERIODIC_ENB | ACTMON_DEV_CTRL_AVG_UP_WMARK_ENB |
338 ACTMON_DEV_CTRL_AVG_DOWN_WMARK_ENB;
339 val |= ((dev->avg_window_log2 - 1) << ACTMON_DEV_CTRL_K_VAL_SHIFT) &
340 ACTMON_DEV_CTRL_K_VAL_MASK;
341 val |= ((dev->down_wmark_window - 1) <<
342 ACTMON_DEV_CTRL_DOWN_WMARK_NUM_SHIFT) &
343 ACTMON_DEV_CTRL_DOWN_WMARK_NUM_MASK;
344 val |= ((dev->up_wmark_window - 1) <<
345 ACTMON_DEV_CTRL_UP_WMARK_NUM_SHIFT) &
346 ACTMON_DEV_CTRL_UP_WMARK_NUM_MASK;
347 val |= ACTMON_DEV_CTRL_DOWN_WMARK_ENB | ACTMON_DEV_CTRL_UP_WMARK_ENB;
348 actmon_writel(val, offs(ACTMON_DEV_CTRL));
352 static void actmon_dev_enable(struct actmon_dev *dev)
357 spin_lock_irqsave(&dev->lock, flags);
359 if (dev->state == ACTMON_OFF) {
360 dev->state = ACTMON_ON;
362 val = actmon_readl(offs(ACTMON_DEV_CTRL));
363 val |= ACTMON_DEV_CTRL_ENB;
364 actmon_writel(val, offs(ACTMON_DEV_CTRL));
367 spin_unlock_irqrestore(&dev->lock, flags);
370 static void actmon_dev_disable(struct actmon_dev *dev)
375 spin_lock_irqsave(&dev->lock, flags);
377 if (dev->state == ACTMON_ON) {
378 dev->state = ACTMON_OFF;
380 val = actmon_readl(offs(ACTMON_DEV_CTRL));
381 val &= ~ACTMON_DEV_CTRL_ENB;
382 actmon_writel(val, offs(ACTMON_DEV_CTRL));
383 actmon_writel(0xffffffff, offs(ACTMON_DEV_INTR_STATUS));
386 spin_unlock_irqrestore(&dev->lock, flags);
389 static void actmon_dev_suspend(struct actmon_dev *dev)
394 spin_lock_irqsave(&dev->lock, flags);
396 if ((dev->state == ACTMON_ON) || (dev->state == ACTMON_OFF)){
397 dev->saved_state = dev->state;
398 dev->state = ACTMON_SUSPENDED;
400 val = actmon_readl(offs(ACTMON_DEV_CTRL));
401 val &= ~ACTMON_DEV_CTRL_ENB;
402 actmon_writel(val, offs(ACTMON_DEV_CTRL));
403 actmon_writel(0xffffffff, offs(ACTMON_DEV_INTR_STATUS));
406 spin_unlock_irqrestore(&dev->lock, flags);
409 static void actmon_dev_resume(struct actmon_dev *dev)
413 unsigned long freq = clk_get_rate(dev->clk) / 1000;
415 spin_lock_irqsave(&dev->lock, flags);
417 if (dev->state == ACTMON_SUSPENDED) {
418 actmon_dev_configure(dev, freq);
419 dev->state = dev->saved_state;
420 if (dev->state == ACTMON_ON) {
421 val = actmon_readl(offs(ACTMON_DEV_CTRL));
422 val |= ACTMON_DEV_CTRL_ENB;
423 actmon_writel(val, offs(ACTMON_DEV_CTRL));
427 spin_unlock_irqrestore(&dev->lock, flags);
430 static int __init actmon_dev_init(struct actmon_dev *dev)
436 spin_lock_init(&dev->lock);
438 dev->clk = clk_get_sys(dev->dev_id, dev->con_id);
439 if (IS_ERR(dev->clk)) {
440 pr_err("Failed to find %s.%s clock\n",
441 dev->dev_id, dev->con_id);
444 dev->max_freq = clk_round_rate(dev->clk, ULONG_MAX);
445 clk_set_rate(dev->clk, dev->max_freq);
446 dev->max_freq /= 1000;
447 freq = clk_get_rate(dev->clk) / 1000;
448 actmon_dev_configure(dev, freq);
450 /* actmon device controls shared bus user clock, but rate
451 change notification should come from bus clock itself */
452 p = clk_get_parent(dev->clk);
455 if (dev->rate_change_nb.notifier_call) {
456 ret = tegra_register_clk_rate_notifier(p, &dev->rate_change_nb);
458 pr_err("Failed to register %s rate change notifier"
459 " for %s\n", p->name, dev->dev_id);
464 ret = request_threaded_irq(INT_ACTMON, actmon_dev_isr, actmon_dev_fn,
465 IRQF_SHARED, dev->dev_id, dev);
467 pr_err("Failed irq %d request for %s.%s\n",
468 INT_ACTMON, dev->dev_id, dev->con_id);
469 tegra_unregister_clk_rate_notifier(p, &dev->rate_change_nb);
473 dev->state = ACTMON_OFF;
474 actmon_dev_enable(dev);
475 clk_enable(dev->clk);
479 /* EMC activity monitor: frequency sampling device:
480 * activity counter is incremented every 256 memory transactions, and
481 * each transaction takes 2 EMC clocks; count_weight = 512.
483 static struct actmon_dev actmon_dev_emc = {
485 .glb_status_irq_mask = (0x1 << 26),
486 .dev_id = "tegra_actmon",
489 .boost_freq_step = 16000,
490 .boost_up_coef = 200,
491 .boost_down_coef = 50,
492 .boost_up_threshold = 60,
493 .boost_down_threshold = 40,
495 .up_wmark_window = 1,
496 .down_wmark_window = 3,
497 .avg_window_log2 = ACTMON_DEFAULT_AVG_WINDOW_LOG2,
498 .count_weight = 0x200,
500 .type = ACTMON_FREQ_SAMPLER,
501 .state = ACTMON_UNINITIALIZED,
504 .notifier_call = actmon_rate_notify_cb,
508 /* AVP activity monitor: load sampling device:
509 * activity counter is incremented on every actmon clock pulse while
510 * AVP is not halted by flow controller; count_weight = 1.
512 static struct actmon_dev actmon_dev_avp = {
514 .glb_status_irq_mask = (0x1 << 30),
515 .dev_id = "tegra_actmon",
518 .boost_freq_step = 8000,
519 .boost_up_coef = 200,
520 .boost_down_coef = 50,
521 .boost_up_threshold = 75,
522 .boost_down_threshold = 50,
524 .up_wmark_window = 1,
525 .down_wmark_window = 3,
526 .avg_window_log2 = ACTMON_DEFAULT_AVG_WINDOW_LOG2,
529 .type = ACTMON_LOAD_SAMPLER,
530 .state = ACTMON_UNINITIALIZED,
533 .notifier_call = actmon_rate_notify_cb,
537 static struct actmon_dev *actmon_devices[] = {
542 /* Activity monitor suspend/resume */
543 static int actmon_pm_notify(struct notifier_block *nb,
544 unsigned long event, void *data)
549 case PM_SUSPEND_PREPARE:
550 for (i = 0; i < ARRAY_SIZE(actmon_devices); i++)
551 actmon_dev_suspend(actmon_devices[i]);
553 case PM_POST_SUSPEND:
554 for (i = 0; i < ARRAY_SIZE(actmon_devices); i++)
555 actmon_dev_resume(actmon_devices[i]);
562 static struct notifier_block actmon_pm_nb = {
563 .notifier_call = actmon_pm_notify,
566 #ifdef CONFIG_DEBUG_FS
568 #define RW_MODE (S_IWUSR | S_IRUGO)
569 #define RO_MODE S_IRUGO
571 static struct dentry *clk_debugfs_root;
573 static int type_show(struct seq_file *s, void *data)
575 struct actmon_dev *dev = s->private;
577 seq_printf(s, "%s\n", (dev->type == ACTMON_LOAD_SAMPLER) ?
578 "Load Activity Monitor" : "Frequency Activity Monitor");
581 static int type_open(struct inode *inode, struct file *file)
583 return single_open(file, type_show, inode->i_private);
585 static const struct file_operations type_fops = {
589 .release = single_release,
592 static int actv_get(void *data, u64 *val)
595 struct actmon_dev *dev = data;
597 spin_lock_irqsave(&dev->lock, flags);
598 *val = actmon_dev_avg_freq_get(dev);
599 spin_unlock_irqrestore(&dev->lock, flags);
602 DEFINE_SIMPLE_ATTRIBUTE(actv_fops, actv_get, NULL, "%llu\n");
604 static int step_get(void *data, u64 *val)
606 struct actmon_dev *dev = data;
607 *val = dev->boost_freq_step * 100 / dev->max_freq;
610 static int step_set(void *data, u64 val)
613 struct actmon_dev *dev = data;
618 spin_lock_irqsave(&dev->lock, flags);
619 dev->boost_freq_step = do_percent(dev->max_freq, (unsigned int)val);
620 spin_unlock_irqrestore(&dev->lock, flags);
623 DEFINE_SIMPLE_ATTRIBUTE(step_fops, step_get, step_set, "%llu\n");
625 static int up_threshold_get(void *data, u64 *val)
627 struct actmon_dev *dev = data;
628 *val = dev->boost_up_threshold;
631 static int up_threshold_set(void *data, u64 val)
634 struct actmon_dev *dev = data;
635 unsigned int up_threshold = (unsigned int)val;
637 if (up_threshold > 100)
640 spin_lock_irqsave(&dev->lock, flags);
642 if (up_threshold <= dev->boost_down_threshold)
643 up_threshold = dev->boost_down_threshold;
645 dev->avg_sustain_coef = 100 * 100 / up_threshold;
646 dev->boost_up_threshold = up_threshold;
648 actmon_dev_up_wmark_set(dev);
651 spin_unlock_irqrestore(&dev->lock, flags);
654 DEFINE_SIMPLE_ATTRIBUTE(up_threshold_fops, up_threshold_get,
655 up_threshold_set, "%llu\n");
657 static int down_threshold_get(void *data, u64 *val)
659 struct actmon_dev *dev = data;
660 *val = dev->boost_down_threshold;
663 static int down_threshold_set(void *data, u64 val)
666 struct actmon_dev *dev = data;
667 unsigned int down_threshold = (unsigned int)val;
669 if (down_threshold < 0)
672 spin_lock_irqsave(&dev->lock, flags);
674 if (down_threshold >= dev->boost_up_threshold)
675 down_threshold = dev->boost_up_threshold;
676 dev->boost_down_threshold = down_threshold;
678 actmon_dev_down_wmark_set(dev);
681 spin_unlock_irqrestore(&dev->lock, flags);
684 DEFINE_SIMPLE_ATTRIBUTE(down_threshold_fops, down_threshold_get,
685 down_threshold_set, "%llu\n");
687 static int state_get(void *data, u64 *val)
689 struct actmon_dev *dev = data;
693 static int state_set(void *data, u64 val)
695 struct actmon_dev *dev = data;
698 actmon_dev_enable(dev);
700 actmon_dev_disable(dev);
703 DEFINE_SIMPLE_ATTRIBUTE(state_fops, state_get, state_set, "%llu\n");
705 static int period_get(void *data, u64 *val)
707 *val = actmon_sampling_period;
710 static int period_set(void *data, u64 val)
717 actmon_sampling_period = period;
718 actmon_writel(period - 1, ACTMON_GLB_PERIOD_CTRL);
720 for (i = 0; i < ARRAY_SIZE(actmon_devices); i++) {
721 struct actmon_dev *dev = actmon_devices[i];
722 spin_lock_irqsave(&dev->lock, flags);
723 actmon_dev_wmark_set(dev);
724 spin_unlock_irqrestore(&dev->lock, flags);
731 DEFINE_SIMPLE_ATTRIBUTE(period_fops, period_get, period_set, "%llu\n");
734 static int actmon_debugfs_create_dev(struct actmon_dev *dev)
736 struct dentry *dir, *d;
738 if (dev->state == ACTMON_UNINITIALIZED)
741 dir = debugfs_create_dir(dev->con_id, clk_debugfs_root);
745 d = debugfs_create_file(
746 "actv_type", RO_MODE, dir, dev, &type_fops);
750 d = debugfs_create_file(
751 "avg_activity", RO_MODE, dir, dev, &actv_fops);
755 d = debugfs_create_file(
756 "boost_step", RW_MODE, dir, dev, &step_fops);
760 d = debugfs_create_u32(
761 "boost_rate_dec", RW_MODE, dir, (u32 *)&dev->boost_down_coef);
765 d = debugfs_create_u32(
766 "boost_rate_inc", RW_MODE, dir, (u32 *)&dev->boost_up_coef);
770 d = debugfs_create_file(
771 "boost_threshold_dn", RW_MODE, dir, dev, &down_threshold_fops);
775 d = debugfs_create_file(
776 "boost_threshold_up", RW_MODE, dir, dev, &up_threshold_fops);
780 d = debugfs_create_file(
781 "state", RW_MODE, dir, dev, &state_fops);
788 static int __init actmon_debugfs_init(void)
794 d = debugfs_create_dir("tegra_actmon", NULL);
797 clk_debugfs_root = d;
799 d = debugfs_create_file("period", RW_MODE, d, NULL, &period_fops);
803 for (i = 0; i < ARRAY_SIZE(actmon_devices); i++) {
804 ret = actmon_debugfs_create_dev(actmon_devices[i]);
811 debugfs_remove_recursive(clk_debugfs_root);
817 static int __init tegra_actmon_init(void)
820 struct clk *c = tegra_get_clock_by_name("actmon");
823 pr_err("%s: Failed to find actmon clock\n", __func__);
826 actmon_clk_freq = clk_get_rate(c) / 1000;
829 pr_err("%s: Failed to enable actmon clock\n", __func__);
832 actmon_sampling_period = ACTMON_DEFAULT_SAMPLING_PERIOD;
833 actmon_writel(actmon_sampling_period - 1, ACTMON_GLB_PERIOD_CTRL);
835 for (i = 0; i < ARRAY_SIZE(actmon_devices); i++) {
836 ret = actmon_dev_init(actmon_devices[i]);
837 pr_info("%s.%s: %s initialization (%d)\n",
838 actmon_devices[i]->dev_id, actmon_devices[i]->con_id,
839 ret ? "Failed" : "Completed", ret);
841 register_pm_notifier(&actmon_pm_nb);
843 #ifdef CONFIG_DEBUG_FS
844 actmon_debugfs_init();
848 late_initcall(tegra_actmon_init);