1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
/*
*
* (C) COPYRIGHT 2011-2016 ARM Limited. All rights reserved.
*
* This program is free software and is provided to you under the terms of the
* GNU General Public License version 2 as published by the Free Software
* Foundation, and any use by you of this program is subject to the terms
* of such GNU licence.
*
* A copy of the licence is included with the program, and can also be obtained
* from Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#include <linux/ioport.h>
#include <linux/thermal.h>
#include <mali_kbase.h>
#include <mali_kbase_defs.h>
#include <mali_kbase_config.h>
#include <mali_kbase_smc.h>
/* Versatile Express (VE) Juno Development Platform */
#define HARD_RESET_AT_POWER_OFF 0
#ifndef CONFIG_OF
static struct kbase_io_resources io_resources = {
.job_irq_number = 65,
.mmu_irq_number = 66,
.gpu_irq_number = 64,
.io_memory_region = {
.start = 0x2D000000,
.end = 0x2D000000 + (4096 * 4) - 1}
};
#endif
static int pm_callback_power_on(struct kbase_device *kbdev)
{
/* Nothing is needed on VExpress, but we may have destroyed GPU state (if the below HARD_RESET code is active) */
return 1;
}
static void pm_callback_power_off(struct kbase_device *kbdev)
{
#if HARD_RESET_AT_POWER_OFF
/* Cause a GPU hard reset to test whether we have actually idled the GPU
* and that we properly reconfigure the GPU on power up.
* Usually this would be dangerous, but if the GPU is working correctly it should
* be completely safe as the GPU should not be active at this point.
* However this is disabled normally because it will most likely interfere with
* bus logging etc.
*/
KBASE_TRACE_ADD(kbdev, CORE_GPU_HARD_RESET, NULL, NULL, 0u, 0);
kbase_os_reg_write(kbdev, GPU_CONTROL_REG(GPU_COMMAND), GPU_COMMAND_HARD_RESET);
#endif
}
struct kbase_pm_callback_conf pm_callbacks = {
.power_on_callback = pm_callback_power_on,
.power_off_callback = pm_callback_power_off,
.power_suspend_callback = NULL,
.power_resume_callback = NULL
};
/*
* Juno Protected Mode integration
*/
/* SMC Function Numbers */
#define JUNO_SMC_PROTECTED_ENTER_FUNC 0xff06
#define JUNO_SMC_PROTECTED_RESET_FUNC 0xff07
static int juno_protected_mode_enter(struct kbase_device *kbdev)
{
/* T62X in SoC detected */
u64 ret = kbase_invoke_smc(SMC_OEN_SIP,
JUNO_SMC_PROTECTED_ENTER_FUNC, false,
0, 0, 0);
return ret;
}
/* TODO: Remove these externs, reset should should be done by the firmware */
extern void kbase_reg_write(struct kbase_device *kbdev, u16 offset, u32 value,
struct kbase_context *kctx);
extern u32 kbase_reg_read(struct kbase_device *kbdev, u16 offset,
struct kbase_context *kctx);
static int juno_protected_mode_reset(struct kbase_device *kbdev)
{
/* T62X in SoC detected */
u64 ret = kbase_invoke_smc(SMC_OEN_SIP,
JUNO_SMC_PROTECTED_RESET_FUNC, false,
0, 0, 0);
/* The GPU should now be reset */
return ret;
}
static bool juno_protected_mode_supported(struct kbase_device *kbdev)
{
u32 gpu_id = kbdev->gpu_props.props.raw_props.gpu_id;
/*
* Protected mode is only supported for the built in GPU
* _and_ only if the right firmware is running.
*
* Given that at init time the GPU is not powered up the
* juno_protected_mode_reset function can't be used as
* is needs to access GPU registers.
* However, although we don't want the GPU to boot into
* protected mode we know a GPU reset will be done after
* this function is called so although we set the GPU to
* protected mode it will exit protected mode before the
* driver is ready to run work.
*/
if (gpu_id == GPU_ID_MAKE(GPU_ID_PI_T62X, 0, 1, 0) &&
(kbdev->reg_start == 0x2d000000))
return juno_protected_mode_enter(kbdev) == 0;
return false;
}
struct kbase_protected_ops juno_protected_ops = {
.protected_mode_enter = juno_protected_mode_enter,
.protected_mode_reset = juno_protected_mode_reset,
.protected_mode_supported = juno_protected_mode_supported,
};
static struct kbase_platform_config versatile_platform_config = {
#ifndef CONFIG_OF
.io_resources = &io_resources
#endif
};
struct kbase_platform_config *kbase_get_platform_config(void)
{
return &versatile_platform_config;
}
int kbase_platform_early_init(void)
{
/* Nothing needed at this stage */
return 0;
}
|
