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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
/*
*
* (C) COPYRIGHT 2023 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 license.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you can access it online at
* http://www.gnu.org/licenses/gpl-2.0.html.
*
*/
#ifndef _MALI_KBASE_HW_ACCESS_H_
#define _MALI_KBASE_HW_ACCESS_H_
#include <linux/version_compat_defs.h>
#define KBASE_REGMAP_PERM_READ (1U << 0)
#define KBASE_REGMAP_PERM_WRITE (1U << 1)
#define KBASE_REGMAP_WIDTH_32_BIT (1U << 2)
#define KBASE_REGMAP_WIDTH_64_BIT (1U << 3)
#define KBASE_REG_READ(kbdev, reg_enum) \
(kbase_reg_is_size64(kbdev, reg_enum) ? kbase_reg_read64(kbdev, reg_enum) : \
kbase_reg_read32(kbdev, reg_enum))
#define KBASE_REG_WRITE(kbdev, reg_enum, value) \
(kbase_reg_is_size64(kbdev, reg_enum) ? kbase_reg_write64(kbdev, reg_enum, value) : \
kbase_reg_write32(kbdev, reg_enum, value))
/**
* kbase_reg_read32 - read from 32-bit GPU register
* @kbdev: Kbase device pointer
* @reg_enum: Register enum
*
* Caller must ensure the GPU is powered (@kbdev->pm.gpu_powered != false).
*
* Return: Value in desired register
*/
u32 kbase_reg_read32(struct kbase_device *kbdev, u32 reg_enum);
/**
* kbase_reg_read64 - read from 64-bit GPU register
* @kbdev: Kbase device pointer
* @reg_enum: Register enum
*
* Caller must ensure the GPU is powered (@kbdev->pm.gpu_powered != false).
*
* Return: Value in desired register
*/
u64 kbase_reg_read64(struct kbase_device *kbdev, u32 reg_enum);
/**
* kbase_reg_read64_coherent - read from 64-bit GPU register while ensuring
* that hi1 == hi2
* @kbdev: Kbase device pointer
* @reg_enum: Register enum
*
* Caller must ensure the GPU is powered (@kbdev->pm.gpu_powered != false).
*
* Return: Value in desired register
*/
u64 kbase_reg_read64_coherent(struct kbase_device *kbdev, u32 reg_enum);
/**
* kbase_reg_write32 - write to 32-bit GPU register
* @kbdev: Kbase device pointer
* @reg_enum: Register enum
* @value: Value to write
*
* Caller must ensure the GPU is powered (@kbdev->pm.gpu_powered != false).
*/
void kbase_reg_write32(struct kbase_device *kbdev, u32 reg_enum, u32 value);
/**
* kbase_reg_write64 - write to 64-bit GPU register
* @kbdev: Kbase device pointer
* @reg_enum: Register enum
* @value: Value to write
*
* Caller must ensure the GPU is powered (@kbdev->pm.gpu_powered != false).
*/
void kbase_reg_write64(struct kbase_device *kbdev, u32 reg_enum, u64 value);
/**
* kbase_reg_is_size64 - check GPU register size is 64-bit
* @kbdev: Kbase device pointer
* @reg_enum: Register enum
*
* Return: boolean if register is 64-bit
*/
bool kbase_reg_is_size64(struct kbase_device *kbdev, u32 reg_enum);
/**
* kbase_reg_is_size32 - check GPU register size is 32-bit
* @kbdev: Kbase device pointer
* @reg_enum: Register enum
*
* Return: boolean if register is 32-bit
*/
bool kbase_reg_is_size32(struct kbase_device *kbdev, u32 reg_enum);
/**
* kbase_reg_is_valid - check register enum is valid and present in regmap
* @kbdev: Kbase device pointer
* @reg_enum: Register enum
*
* Return: boolean if register is present and valid
*/
bool kbase_reg_is_valid(struct kbase_device *kbdev, u32 reg_enum);
/**
* kbase_reg_is_accessible - check register enum is accessible
* @kbdev: Kbase device pointer
* @reg_enum: Register enum
* @flags: Register permissions and size checks
*
* Return: boolean if register is accessible
*/
bool kbase_reg_is_accessible(struct kbase_device *kbdev, u32 reg_enum, u32 flags);
/**
* kbase_reg_get_offset - get register offset from enum
* @kbdev: Kbase device pointer
* @reg_enum: Register enum
* @offset: Pointer to store value of register offset
*
* Return: 0 on success, otherwise a standard Linux error code
*/
int kbase_reg_get_offset(struct kbase_device *kbdev, u32 reg_enum, u32 *offset);
/**
* kbase_reg_get_enum - get enum from register offset
* @kbdev: Kbase device pointer
* @offset: Register offset
* @reg_enum: Pointer to store enum value
*
* Return: 0 on success, otherwise a standard Linux error code
*/
int kbase_reg_get_enum(struct kbase_device *kbdev, u32 offset, u32 *reg_enum);
#ifdef CONFIG_MALI_DEBUG
/**
* kbase_reg_get_enum_string - get the string for a particular enum
* @reg_enum: Register enum
*
* Return: string containing the name of enum
*/
const char *kbase_reg_get_enum_string(u32 reg_enum);
#endif /* CONFIG_MALI_DEBUG */
/**
* kbase_reg_get_gpu_id - get GPU ID from register or dummy model
* @kbdev: Kbase device pointer
*
* Return: GPU ID on success, 0 otherwise.
*/
u64 kbase_reg_get_gpu_id(struct kbase_device *kbdev);
/**
* kbase_regmap_init - regmap init function
* @kbdev: Kbase device pointer
*
* Return: 0 if successful, otherwise a standard Linux error code
*/
int kbase_regmap_init(struct kbase_device *kbdev);
/**
* kbase_regmap_backend_init - Initialize register mapping backend
* @kbdev: Kbase device pointer
*
* Return: the arch_id of the selected look-up table.
*/
u32 kbase_regmap_backend_init(struct kbase_device *kbdev);
/**
* kbase_regmap_term - regmap term function
* @kbdev: Kbase device pointer
*/
void kbase_regmap_term(struct kbase_device *kbdev);
/**
* kbase_reg_poll32_timeout - Poll a 32 bit register with timeout
* @kbdev: Kbase device pointer
* @reg_enum: Register enum
* @val: Variable for result of read
* @cond: Condition to be met
* @delay_us: Delay between each poll (in uS)
* @timeout_us: Timeout (in uS)
* @delay_before_read: If true delay for @delay_us before read
*
* Return: 0 if condition is met, -ETIMEDOUT if timed out.
*/
#define kbase_reg_poll32_timeout(kbdev, reg_enum, val, cond, delay_us, timeout_us, \
delay_before_read) \
read_poll_timeout_atomic(kbase_reg_read32, val, cond, delay_us, timeout_us, \
delay_before_read, kbdev, reg_enum)
/**
* kbase_reg_poll64_timeout - Poll a 64 bit register with timeout
* @kbdev: Kbase device pointer
* @reg_enum: Register enum
* @val: Variable for result of read
* @cond: Condition to be met
* @delay_us: Delay between each poll (in uS)
* @timeout_us: Timeout (in uS)
* @delay_before_read: If true delay for @delay_us before read
*
* Return: 0 if condition is met, -ETIMEDOUT if timed out.
*/
#define kbase_reg_poll64_timeout(kbdev, reg_enum, val, cond, delay_us, timeout_us, \
delay_before_read) \
read_poll_timeout_atomic(kbase_reg_read64, val, cond, delay_us, timeout_us, \
delay_before_read, kbdev, reg_enum)
#endif /* _MALI_KBASE_HW_ACCESS_H_ */
|
