1 /* drivers/gpu/t6xx/kbase/src/platform/rk/mali_kbase_platform.c
3 * Rockchip SoC Mali-T764 platform-dependent codes
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software FoundatIon.
11 * @file mali_kbase_platform.c
12 * Platform-dependent init.
14 #include <kbase/src/common/mali_kbase.h>
15 #include <kbase/src/common/mali_kbase_pm.h>
16 #include <kbase/src/common/mali_kbase_uku.h>
17 #include <kbase/src/common/mali_kbase_mem.h>
18 #include <kbase/src/common/mali_midg_regmap.h>
19 #include <kbase/src/linux/mali_kbase_mem_linux.h>
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/poll.h>
24 #include <linux/kernel.h>
25 #include <linux/errno.h>
26 #include <linux/platform_device.h>
27 #include <linux/pci.h>
28 #include <linux/miscdevice.h>
29 #include <linux/list.h>
30 #include <linux/semaphore.h>
32 #include <linux/uaccess.h>
33 #include <linux/interrupt.h>
37 #include <linux/clk.h>
38 #include <linux/delay.h>
39 #include <kbase/src/platform/rk/mali_kbase_platform.h>
40 #include <kbase/src/platform/rk/mali_kbase_dvfs.h>
42 #include <kbase/src/common/mali_kbase_gator.h>
44 #include <linux/rockchip/dvfs.h>
46 #define MALI_T7XX_DEFAULT_CLOCK 400000000
49 static int mali_clk_status = 0;
50 static int mali_pd_status = 0;
52 int mali_dvfs_clk_set(struct dvfs_node *node,unsigned long rate)
57 printk("clk_get_dvfs_node error \r\n");
60 ret = dvfs_clk_set_rate(node,rate);
63 printk("dvfs_clk_set_rate error \r\n");
67 static int kbase_platform_power_clock_init(kbase_device *kbdev)
69 struct device *dev = kbdev->osdev.dev;
70 struct rk_context *platform;
72 platform = (struct rk_context *)kbdev->platform_context;
76 /* enable mali t760 powerdomain*/
77 platform->mali_pd_node = clk_get_dvfs_node("mali_pd");
78 if(IS_ERR_OR_NULL(platform->mali_pd_node))
80 platform->mali_pd_node = NULL;
81 printk(KERN_ERR "%s, %s(): failed to get [platform->mali_pd_node]\n", __FILE__, __func__);
86 //dvfs_clk_prepare_enable(platform->mali_pd_node);
87 printk("pd not enable\n");
91 /* enable mali t760 clock */
92 platform->mali_clk_node = clk_get_dvfs_node("clk_gpu");
93 if (IS_ERR_OR_NULL(platform->mali_clk_node))
95 platform->mali_clk_node = NULL;
96 printk(KERN_ERR "%s, %s(): failed to get [platform->mali_clk_node]\n", __FILE__, __func__);
101 dvfs_clk_prepare_enable(platform->mali_clk_node);
102 printk("clk enabled\n");
104 mali_dvfs_clk_set(platform->mali_clk_node,MALI_T7XX_DEFAULT_CLOCK);
110 if(platform->mali_pd_node)
111 clk_put_dvfs_node(platform->mali_pd_node);
116 int kbase_platform_clock_off(struct kbase_device *kbdev)
118 struct rk_context *platform;
122 platform = (struct rk_context *)kbdev->platform_context;
126 if (mali_clk_status == 0)
129 if((platform->mali_clk_node))
130 dvfs_clk_disable_unprepare(platform->mali_clk_node);
137 int kbase_platform_clock_on(struct kbase_device *kbdev)
139 struct rk_context *platform;
143 platform = (struct rk_context *)kbdev->platform_context;
147 if (mali_clk_status == 1)
150 if(platform->mali_clk_node)
151 dvfs_clk_prepare_enable(platform->mali_clk_node);
157 int kbase_platform_is_power_on(void)
159 return mali_pd_status;
162 /*turn on power domain*/
163 static int kbase_platform_power_on(struct kbase_device *kbdev)
165 struct rk_context *platform;
169 platform = (struct rk_context *)kbdev->platform_context;
173 if (mali_pd_status == 1)
176 if(platform->mali_pd_node)
177 dvfs_clk_prepare_enable(platform->mali_pd_node);
180 KBASE_TIMELINE_GPU_POWER(kbdev, 1);
185 /*turn off power domain*/
186 static int kbase_platform_power_off(struct kbase_device *kbdev)
188 struct rk_context *platform;
192 platform = (struct rk_context *)kbdev->platform_context;
196 if (mali_pd_status== 0)
199 if(platform->mali_pd_node)
200 dvfs_clk_disable_unprepare(platform->mali_pd_node);
203 KBASE_TIMELINE_GPU_POWER(kbdev, 0);
208 int kbase_platform_cmu_pmu_control(struct kbase_device *kbdev, int control)
211 struct rk_context *platform;
215 platform = (struct rk_context *)kbdev->platform_context;
219 spin_lock_irqsave(&platform->cmu_pmu_lock, flags);
224 if (platform->cmu_pmu_status == 0)
226 spin_unlock_irqrestore(&platform->cmu_pmu_lock, flags);
230 if (kbase_platform_power_off(kbdev))
231 panic("failed to turn off mali power domain\n");
232 if (kbase_platform_clock_off(kbdev))
233 panic("failed to turn off mali clock\n");
235 platform->cmu_pmu_status = 0;
236 printk("turn off mali power \n");
241 if (platform->cmu_pmu_status == 1)
243 spin_unlock_irqrestore(&platform->cmu_pmu_lock, flags);
247 if (kbase_platform_power_on(kbdev))
248 panic("failed to turn on mali power domain\n");
249 if (kbase_platform_clock_on(kbdev))
250 panic("failed to turn on mali clock\n");
252 platform->cmu_pmu_status = 1;
253 printk(KERN_ERR "turn on mali power\n");
256 spin_unlock_irqrestore(&platform->cmu_pmu_lock, flags);
261 #ifdef CONFIG_MALI_T6XX_DEBUG_SYS
262 static ssize_t show_clock(struct device *dev, struct device_attribute *attr, char *buf)
264 struct kbase_device *kbdev;
265 struct rk_context *platform;
267 unsigned int clkrate;
269 kbdev = dev_get_drvdata(dev);
274 platform = (struct rk_context *)kbdev->platform_context;
278 if (!platform->mali_clk_node)
280 printk("mali_clk_node not init\n");
283 clkrate = dvfs_clk_get_rate(platform->mali_clk_node);
284 ret += snprintf(buf + ret, PAGE_SIZE - ret, "Current clk mali = %dMhz", clkrate / 1000000);
287 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\nPossible settings : 500, 400, 350, 266, 160, 100Mhz");
289 if (ret < PAGE_SIZE - 1)
290 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
292 buf[PAGE_SIZE - 2] = '\n';
293 buf[PAGE_SIZE - 1] = '\0';
300 static ssize_t set_clock(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
302 struct kbase_device *kbdev;
303 struct rk_context *platform;
304 unsigned int tmp = 0, freq = 0;
305 kbdev = dev_get_drvdata(dev);
310 platform = (struct rk_context *)kbdev->platform_context;
314 if (!platform->mali_clk_node)
317 if (sysfs_streq("500", buf)) {
319 } else if (sysfs_streq("400", buf)) {
321 } else if (sysfs_streq("350", buf)) {
323 } else if (sysfs_streq("266", buf)) {
325 } else if (sysfs_streq("160", buf)) {
327 } else if (sysfs_streq("100", buf)) {
330 dev_err(dev, "set_clock: invalid value\n");
334 kbase_platform_dvfs_set_level(kbdev, kbase_platform_dvfs_get_level(freq));
335 /* Waiting for clock is stable
337 tmp = __raw_readl(EXYNOS5_CLKDIV_STAT_TOP0);
338 } while (tmp & 0x1000000);
344 static ssize_t show_fbdev(struct device *dev, struct device_attribute *attr, char *buf)
346 struct kbase_device *kbdev;
350 kbdev = dev_get_drvdata(dev);
355 for (i = 0; i < num_registered_fb; i++)
356 ret += snprintf(buf + ret, PAGE_SIZE - ret, "fb[%d] xres=%d, yres=%d, addr=0x%lx\n", i, registered_fb[i]->var.xres, registered_fb[i]->var.yres, registered_fb[i]->fix.smem_start);
358 if (ret < PAGE_SIZE - 1)
359 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
361 buf[PAGE_SIZE - 2] = '\n';
362 buf[PAGE_SIZE - 1] = '\0';
371 L1_I_data_RAM = 0x01,
375 L1_I_indirect_predictor_RAM = 0x05,
377 L1_D_data_RAM = 0x09,
378 L1_D_load_TLB_array = 0x0A,
379 L1_D_store_TLB_array = 0x0B,
382 L2_snoop_tag_RAM = 0x12,
383 L2_data_ECC_RAM = 0x13,
388 static inline void asm_ramindex_mrc(u32 *DL1Data0, u32 *DL1Data1, u32 *DL1Data2, u32 *DL1Data3)
393 asm volatile ("mrc p15, 0, %0, c15, c1, 0" : "=r" (val));
397 asm volatile ("mrc p15, 0, %0, c15, c1, 1" : "=r" (val));
401 asm volatile ("mrc p15, 0, %0, c15, c1, 2" : "=r" (val));
405 asm volatile ("mrc p15, 0, %0, c15, c1, 3" : "=r" (val));
410 static inline void asm_ramindex_mcr(u32 val)
412 asm volatile ("mcr p15, 0, %0, c15, c4, 0" : : "r" (val));
413 asm volatile ("dsb");
414 asm volatile ("isb");
417 static void get_tlb_array(u32 val, u32 *DL1Data0, u32 *DL1Data1, u32 *DL1Data2, u32 *DL1Data3)
419 asm_ramindex_mcr(val);
420 asm_ramindex_mrc(DL1Data0, DL1Data1, DL1Data2, DL1Data3);
423 static RAMID_type ramindex = L1_D_load_TLB_array;
424 static ssize_t show_dtlb(struct device *dev, struct device_attribute *attr, char *buf)
426 struct kbase_device *kbdev;
429 u32 DL1Data0 = 0, DL1Data1 = 0, DL1Data2 = 0, DL1Data3 = 0;
431 kbdev = dev_get_drvdata(dev);
437 if (ramindex == L1_I_tag_RAM)
438 printk(KERN_DEBUG "Not implemented yet\n");
440 else if (ramindex == L1_I_data_RAM)
441 printk(KERN_DEBUG "Not implemented yet\n");
443 else if (ramindex == L1_I_BTB_RAM)
444 printk(KERN_DEBUG "Not implemented yet\n");
446 else if (ramindex == L1_I_GHB_RAM)
447 printk(KERN_DEBUG "Not implemented yet\n");
449 else if (ramindex == L1_I_TLB_RAM) {
450 printk(KERN_DEBUG "L1-I TLB RAM\n");
451 for (entries = 0; entries < 32; entries++) {
452 get_tlb_array((((u8) ramindex) << 24) + entries, &DL1Data0, &DL1Data1, &DL1Data2, NULL);
453 printk(KERN_DEBUG "entries[%d], DL1Data0=%08x, DL1Data1=%08x DL1Data2=%08x\n", entries, DL1Data0, DL1Data1 & 0xffff, 0x0);
456 /* L1-I indirect predictor RAM */
457 else if (ramindex == L1_I_indirect_predictor_RAM)
458 printk(KERN_DEBUG "Not implemented yet\n");
460 else if (ramindex == L1_D_tag_RAM)
461 printk(KERN_DEBUG "Not implemented yet\n");
463 else if (ramindex == L1_D_data_RAM)
464 printk(KERN_DEBUG "Not implemented yet\n");
465 /* L1-D load TLB array */
466 else if (ramindex == L1_D_load_TLB_array) {
467 printk(KERN_DEBUG "L1-D load TLB array\n");
468 for (entries = 0; entries < 32; entries++) {
469 get_tlb_array((((u8) ramindex) << 24) + entries, &DL1Data0, &DL1Data1, &DL1Data2, &DL1Data3);
470 printk(KERN_DEBUG "entries[%d], DL1Data0=%08x, DL1Data1=%08x, DL1Data2=%08x, DL1Data3=%08x\n", entries, DL1Data0, DL1Data1, DL1Data2, DL1Data3 & 0x3f);
473 /* L1-D store TLB array */
474 else if (ramindex == L1_D_store_TLB_array) {
475 printk(KERN_DEBUG "\nL1-D store TLB array\n");
476 for (entries = 0; entries < 32; entries++) {
477 get_tlb_array((((u8) ramindex) << 24) + entries, &DL1Data0, &DL1Data1, &DL1Data2, &DL1Data3);
478 printk(KERN_DEBUG "entries[%d], DL1Data0=%08x, DL1Data1=%08x, DL1Data2=%08x, DL1Data3=%08x\n", entries, DL1Data0, DL1Data1, DL1Data2, DL1Data3 & 0x3f);
482 else if (ramindex == L2_tag_RAM)
483 printk(KERN_DEBUG "Not implemented yet\n");
485 else if (ramindex == L2_data_RAM)
486 printk(KERN_DEBUG "Not implemented yet\n");
487 /* L2 snoop tag RAM */
488 else if (ramindex == L2_snoop_tag_RAM)
489 printk(KERN_DEBUG "Not implemented yet\n");
490 /* L2 data ECC RAM */
491 else if (ramindex == L2_data_ECC_RAM)
492 printk(KERN_DEBUG "Not implemented yet\n");
494 else if (ramindex == L2_dirty_RAM)
495 printk(KERN_DEBUG "Not implemented yet\n");
498 else if (ramindex == L2_TLB_RAM) {
499 printk(KERN_DEBUG "\nL2 TLB array\n");
500 for (ways = 0; ways < 4; ways++) {
501 for (entries = 0; entries < 512; entries++) {
502 get_tlb_array((ramindex << 24) + (ways << 18) + entries, &DL1Data0, &DL1Data1, &DL1Data2, &DL1Data3);
503 printk(KERN_DEBUG "ways[%d]:entries[%d], DL1Data0=%08x, DL1Data1=%08x, DL1Data2=%08x, DL1Data3=%08x\n", ways, entries, DL1Data0, DL1Data1, DL1Data2, DL1Data3);
509 ret += snprintf(buf + ret, PAGE_SIZE - ret, "Succeeded...\n");
511 if (ret < PAGE_SIZE - 1)
512 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
514 buf[PAGE_SIZE - 2] = '\n';
515 buf[PAGE_SIZE - 1] = '\0';
521 static ssize_t set_dtlb(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
523 struct kbase_device *kbdev;
524 kbdev = dev_get_drvdata(dev);
529 if (sysfs_streq("L1_I_tag_RAM", buf)) {
530 ramindex = L1_I_tag_RAM;
531 } else if (sysfs_streq("L1_I_data_RAM", buf)) {
532 ramindex = L1_I_data_RAM;
533 } else if (sysfs_streq("L1_I_BTB_RAM", buf)) {
534 ramindex = L1_I_BTB_RAM;
535 } else if (sysfs_streq("L1_I_GHB_RAM", buf)) {
536 ramindex = L1_I_GHB_RAM;
537 } else if (sysfs_streq("L1_I_TLB_RAM", buf)) {
538 ramindex = L1_I_TLB_RAM;
539 } else if (sysfs_streq("L1_I_indirect_predictor_RAM", buf)) {
540 ramindex = L1_I_indirect_predictor_RAM;
541 } else if (sysfs_streq("L1_D_tag_RAM", buf)) {
542 ramindex = L1_D_tag_RAM;
543 } else if (sysfs_streq("L1_D_data_RAM", buf)) {
544 ramindex = L1_D_data_RAM;
545 } else if (sysfs_streq("L1_D_load_TLB_array", buf)) {
546 ramindex = L1_D_load_TLB_array;
547 } else if (sysfs_streq("L1_D_store_TLB_array", buf)) {
548 ramindex = L1_D_store_TLB_array;
549 } else if (sysfs_streq("L2_tag_RAM", buf)) {
550 ramindex = L2_tag_RAM;
551 } else if (sysfs_streq("L2_data_RAM", buf)) {
552 ramindex = L2_data_RAM;
553 } else if (sysfs_streq("L2_snoop_tag_RAM", buf)) {
554 ramindex = L2_snoop_tag_RAM;
555 } else if (sysfs_streq("L2_data_ECC_RAM", buf)) {
556 ramindex = L2_data_ECC_RAM;
557 } else if (sysfs_streq("L2_dirty_RAM", buf)) {
558 ramindex = L2_dirty_RAM;
559 } else if (sysfs_streq("L2_TLB_RAM", buf)) {
560 ramindex = L2_TLB_RAM;
562 printk(KERN_DEBUG "Invalid value....\n\n");
563 printk(KERN_DEBUG "Available options are one of below\n");
564 printk(KERN_DEBUG "L1_I_tag_RAM, L1_I_data_RAM, L1_I_BTB_RAM\n");
565 printk(KERN_DEBUG "L1_I_GHB_RAM, L1_I_TLB_RAM, L1_I_indirect_predictor_RAM\n");
566 printk(KERN_DEBUG "L1_D_tag_RAM, L1_D_data_RAM, L1_D_load_TLB_array, L1_D_store_TLB_array\n");
567 printk(KERN_DEBUG "L2_tag_RAM, L2_data_RAM, L2_snoop_tag_RAM, L2_data_ECC_RAM\n");
568 printk(KERN_DEBUG "L2_dirty_RAM, L2_TLB_RAM\n");
574 static ssize_t show_dvfs(struct device *dev, struct device_attribute *attr, char *buf)
576 struct kbase_device *kbdev;
579 kbdev = dev_get_drvdata(dev);
584 #ifdef CONFIG_MALI_T6XX_DVFS
585 if (kbase_platform_dvfs_get_enable_status())
586 ret += snprintf(buf + ret, PAGE_SIZE - ret, "mali DVFS is on\nutilisation:%d", kbase_platform_dvfs_get_utilisation());
588 ret += snprintf(buf + ret, PAGE_SIZE - ret, "mali DVFS is off");
590 ret += snprintf(buf + ret, PAGE_SIZE - ret, "mali DVFS is disabled");
593 if (ret < PAGE_SIZE - 1)
594 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
596 buf[PAGE_SIZE - 2] = '\n';
597 buf[PAGE_SIZE - 1] = '\0';
604 static ssize_t set_dvfs(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
606 struct kbase_device *kbdev = dev_get_drvdata(dev);
607 #ifdef CONFIG_MALI_T6XX_DVFS
608 struct rk_context *platform;
614 #ifdef CONFIG_MALI_T6XX_DVFS
615 platform = (struct rk_context *)kbdev->platform_context;
616 if (sysfs_streq("off", buf)) {
617 kbase_platform_dvfs_enable(false, MALI_DVFS_BL_CONFIG_FREQ);
618 platform->dvfs_enabled = false;
619 } else if (sysfs_streq("on", buf)) {
620 kbase_platform_dvfs_enable(true, MALI_DVFS_START_FREQ);
621 platform->dvfs_enabled = true;
623 printk(KERN_DEBUG "invalid val -only [on, off] is accepted\n");
626 printk(KERN_DEBUG "mali DVFS is disabled\n");
631 static ssize_t show_upper_lock_dvfs(struct device *dev, struct device_attribute *attr, char *buf)
633 struct kbase_device *kbdev;
635 #ifdef CONFIG_MALI_T6XX_DVFS
636 int locked_level = -1;
639 kbdev = dev_get_drvdata(dev);
644 #ifdef CONFIG_MALI_T6XX_DVFS
645 locked_level = mali_get_dvfs_upper_locked_freq();
646 if (locked_level > 0)
647 ret += snprintf(buf + ret, PAGE_SIZE - ret, "Current Upper Lock Level = %dMhz", locked_level);
649 ret += snprintf(buf + ret, PAGE_SIZE - ret, "Unset the Upper Lock Level");
650 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\nPossible settings : 400, 350,266, 160, 100, If you want to unlock : 500 or off");
653 ret += snprintf(buf + ret, PAGE_SIZE - ret, "mali DVFS is disabled. You can not set");
656 if (ret < PAGE_SIZE - 1)
657 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
659 buf[PAGE_SIZE - 2] = '\n';
660 buf[PAGE_SIZE - 1] = '\0';
667 static ssize_t set_upper_lock_dvfs(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
669 struct kbase_device *kbdev;
670 kbdev = dev_get_drvdata(dev);
675 #ifdef CONFIG_MALI_T6XX_DVFS
676 if (sysfs_streq("off", buf)) {
677 mali_dvfs_freq_unlock();
678 } else if (sysfs_streq("500", buf)) {
679 mali_dvfs_freq_unlock();
680 } else if (sysfs_streq("400", buf)) {
681 mali_dvfs_freq_lock(4);
682 } else if (sysfs_streq("350", buf)) {
683 mali_dvfs_freq_lock(3);
684 } else if (sysfs_streq("266", buf)) {
685 mali_dvfs_freq_lock(2);
686 } else if (sysfs_streq("160", buf)) {
687 mali_dvfs_freq_lock(1);
688 } else if (sysfs_streq("100", buf)) {
689 mali_dvfs_freq_lock(0);
691 dev_err(dev, "set_clock: invalid value\n");
692 dev_err(dev, "Possible settings : 400, 350,266, 160, 100, If you want to unlock : 500\n");
695 #else /* CONFIG_MALI_T6XX_DVFS */
696 printk(KERN_DEBUG "mali DVFS is disabled. You can not set\n");
702 static ssize_t show_under_lock_dvfs(struct device *dev, struct device_attribute *attr, char *buf)
704 struct kbase_device *kbdev;
706 #ifdef CONFIG_MALI_T6XX_DVFS
707 int locked_level = -1;
710 kbdev = dev_get_drvdata(dev);
715 #ifdef CONFIG_MALI_T6XX_DVFS
716 locked_level = mali_get_dvfs_under_locked_freq();
717 if (locked_level > 0)
718 ret += snprintf(buf + ret, PAGE_SIZE - ret, "Current Under Lock Level = %dMhz", locked_level);
720 ret += snprintf(buf + ret, PAGE_SIZE - ret, "Unset the Under Lock Level");
721 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\nPossible settings : 500, 400, 350,266, 160, If you want to unlock : 100 or off");
724 ret += snprintf(buf + ret, PAGE_SIZE - ret, "mali DVFS is disabled. You can not set");
727 if (ret < PAGE_SIZE - 1)
728 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
730 buf[PAGE_SIZE - 2] = '\n';
731 buf[PAGE_SIZE - 1] = '\0';
738 static ssize_t set_under_lock_dvfs(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
740 struct kbase_device *kbdev;
741 kbdev = dev_get_drvdata(dev);
746 #ifdef CONFIG_MALI_T6XX_DVFS
747 if (sysfs_streq("off", buf)) {
748 mali_dvfs_freq_under_unlock();
749 } else if (sysfs_streq("500", buf)) {
750 mali_dvfs_freq_under_lock(5);
751 } else if (sysfs_streq("400", buf)) {
752 mali_dvfs_freq_under_lock(4);
753 } else if (sysfs_streq("350", buf)) {
754 mali_dvfs_freq_under_lock(3);
755 } else if (sysfs_streq("266", buf)) {
756 mali_dvfs_freq_under_lock(2);
757 } else if (sysfs_streq("160", buf)) {
758 mali_dvfs_freq_under_lock(1);
759 } else if (sysfs_streq("100", buf)) {
760 mali_dvfs_freq_under_unlock();
762 dev_err(dev, "set_clock: invalid value\n");
763 dev_err(dev, "Possible settings : 500, 400,350,266, 160, If you want to unlock : 100 or off\n");
767 printk(KERN_DEBUG "G3D DVFS is disabled. You can not set\n");
768 #endif /* CONFIG_MALI_T6XX_DVFS */
773 /** The sysfs file @c clock, fbdev.
775 * This is used for obtaining information about the mali t6xx operating clock & framebuffer address,
777 DEVICE_ATTR(clock, S_IRUGO | S_IWUSR, show_clock, set_clock);
778 DEVICE_ATTR(fbdev, S_IRUGO, show_fbdev, NULL);
779 DEVICE_ATTR(dtlb, S_IRUGO | S_IWUSR, show_dtlb, set_dtlb);
780 DEVICE_ATTR(dvfs, S_IRUGO | S_IWUSR, show_dvfs, set_dvfs);
781 DEVICE_ATTR(dvfs_upper_lock, S_IRUGO | S_IWUSR, show_upper_lock_dvfs, set_upper_lock_dvfs);
782 DEVICE_ATTR(dvfs_under_lock, S_IRUGO | S_IWUSR, show_under_lock_dvfs, set_under_lock_dvfs);
783 DEVICE_ATTR(time_in_state, S_IRUGO | S_IWUSR, show_time_in_state, set_time_in_state);
785 int kbase_platform_create_sysfs_file(struct device *dev)
787 if (device_create_file(dev, &dev_attr_clock)) {
788 dev_err(dev, "Couldn't create sysfs file [clock]\n");
792 if (device_create_file(dev, &dev_attr_fbdev)) {
793 dev_err(dev, "Couldn't create sysfs file [fbdev]\n");
797 if (device_create_file(dev, &dev_attr_dtlb)) {
798 dev_err(dev, "Couldn't create sysfs file [dtlb]\n");
802 if (device_create_file(dev, &dev_attr_dvfs)) {
803 dev_err(dev, "Couldn't create sysfs file [dvfs]\n");
807 if (device_create_file(dev, &dev_attr_dvfs_upper_lock)) {
808 dev_err(dev, "Couldn't create sysfs file [dvfs_upper_lock]\n");
812 if (device_create_file(dev, &dev_attr_dvfs_under_lock)) {
813 dev_err(dev, "Couldn't create sysfs file [dvfs_under_lock]\n");
817 if (device_create_file(dev, &dev_attr_time_in_state)) {
818 dev_err(dev, "Couldn't create sysfs file [time_in_state]\n");
826 void kbase_platform_remove_sysfs_file(struct device *dev)
828 device_remove_file(dev, &dev_attr_clock);
829 device_remove_file(dev, &dev_attr_fbdev);
830 device_remove_file(dev, &dev_attr_dtlb);
831 device_remove_file(dev, &dev_attr_dvfs);
832 device_remove_file(dev, &dev_attr_dvfs_upper_lock);
833 device_remove_file(dev, &dev_attr_dvfs_under_lock);
834 device_remove_file(dev, &dev_attr_time_in_state);
836 #endif /* CONFIG_MALI_T6XX_DEBUG_SYS */
838 mali_error kbase_platform_init(struct kbase_device *kbdev)
840 struct rk_context *platform;
842 platform = kmalloc(sizeof(struct rk_context), GFP_KERNEL);
844 if (NULL == platform)
845 return MALI_ERROR_OUT_OF_MEMORY;
847 kbdev->platform_context = (void *)platform;
849 platform->cmu_pmu_status = 0;
850 #ifdef CONFIG_MALI_T6XX_DVFS
851 platform->utilisation = 0;
852 platform->time_busy = 0;
853 platform->time_idle = 0;
854 platform->time_tick = 0;
855 platform->dvfs_enabled = true;
858 spin_lock_init(&platform->cmu_pmu_lock);
860 if (kbase_platform_power_clock_init(kbdev))
861 goto clock_init_fail;
863 #ifdef CONFIG_MALI_T6XX_DVFS
864 kbase_platform_dvfs_init(kbdev);
865 #endif /* CONFIG_MALI_T6XX_DVFS */
868 kbase_platform_cmu_pmu_control(kbdev, 1);
869 return MALI_ERROR_NONE;
874 return MALI_ERROR_FUNCTION_FAILED;
877 void kbase_platform_term(kbase_device *kbdev)
879 struct rk_context *platform;
881 platform = (struct rk_context *)kbdev->platform_context;
883 #ifdef CONFIG_MALI_T6XX_DVFS
884 kbase_platform_dvfs_term();
885 #endif /* CONFIG_MALI_T6XX_DVFS */
888 kbase_platform_cmu_pmu_control(kbdev, 0);
889 kfree(kbdev->platform_context);
890 kbdev->platform_context = 0;