1 // SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note
2 /*
3 *
4 * (C) COPYRIGHT 2014-2022 ARM Limited. All rights reserved.
5 *
6 * This program is free software and is provided to you under the terms of the
7 * GNU General Public License version 2 as published by the Free Software
8 * Foundation, and any use by you of this program is subject to the terms
9 * of such GNU license.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, you can access it online at
18 * http://www.gnu.org/licenses/gpl-2.0.html.
19 *
20 */
21
22 #include <linux/debugfs.h>
23 #include <linux/seq_file.h>
24
25 #include "mali_kbase_mem_pool_debugfs.h"
26 #include "mali_kbase_debugfs_helper.h"
27
kbase_mem_pool_debugfs_trim(void * const array,size_t const index,size_t const value)28 void kbase_mem_pool_debugfs_trim(void *const array, size_t const index,
29 size_t const value)
30 {
31 struct kbase_mem_pool *const mem_pools = array;
32
33 if (WARN_ON(!mem_pools) ||
34 WARN_ON(index >= MEMORY_GROUP_MANAGER_NR_GROUPS))
35 return;
36
37 kbase_mem_pool_trim(&mem_pools[index], value);
38 }
39
kbase_mem_pool_debugfs_set_max_size(void * const array,size_t const index,size_t const value)40 void kbase_mem_pool_debugfs_set_max_size(void *const array,
41 size_t const index, size_t const value)
42 {
43 struct kbase_mem_pool *const mem_pools = array;
44
45 if (WARN_ON(!mem_pools) ||
46 WARN_ON(index >= MEMORY_GROUP_MANAGER_NR_GROUPS))
47 return;
48
49 kbase_mem_pool_set_max_size(&mem_pools[index], value);
50 }
51
kbase_mem_pool_debugfs_size(void * const array,size_t const index)52 size_t kbase_mem_pool_debugfs_size(void *const array, size_t const index)
53 {
54 struct kbase_mem_pool *const mem_pools = array;
55
56 if (WARN_ON(!mem_pools) ||
57 WARN_ON(index >= MEMORY_GROUP_MANAGER_NR_GROUPS))
58 return 0;
59
60 return kbase_mem_pool_size(&mem_pools[index]);
61 }
62
kbase_mem_pool_debugfs_max_size(void * const array,size_t const index)63 size_t kbase_mem_pool_debugfs_max_size(void *const array, size_t const index)
64 {
65 struct kbase_mem_pool *const mem_pools = array;
66
67 if (WARN_ON(!mem_pools) ||
68 WARN_ON(index >= MEMORY_GROUP_MANAGER_NR_GROUPS))
69 return 0;
70
71 return kbase_mem_pool_max_size(&mem_pools[index]);
72 }
73
kbase_mem_pool_config_debugfs_set_max_size(void * const array,size_t const index,size_t const value)74 void kbase_mem_pool_config_debugfs_set_max_size(void *const array,
75 size_t const index, size_t const value)
76 {
77 struct kbase_mem_pool_config *const configs = array;
78
79 if (WARN_ON(!configs) ||
80 WARN_ON(index >= MEMORY_GROUP_MANAGER_NR_GROUPS))
81 return;
82
83 kbase_mem_pool_config_set_max_size(&configs[index], value);
84 }
85
kbase_mem_pool_config_debugfs_max_size(void * const array,size_t const index)86 size_t kbase_mem_pool_config_debugfs_max_size(void *const array,
87 size_t const index)
88 {
89 struct kbase_mem_pool_config *const configs = array;
90
91 if (WARN_ON(!configs) ||
92 WARN_ON(index >= MEMORY_GROUP_MANAGER_NR_GROUPS))
93 return 0;
94
95 return kbase_mem_pool_config_get_max_size(&configs[index]);
96 }
97
kbase_mem_pool_debugfs_size_show(struct seq_file * sfile,void * data)98 static int kbase_mem_pool_debugfs_size_show(struct seq_file *sfile, void *data)
99 {
100 CSTD_UNUSED(data);
101 return kbase_debugfs_helper_seq_read(sfile,
102 MEMORY_GROUP_MANAGER_NR_GROUPS, kbase_mem_pool_debugfs_size);
103 }
104
kbase_mem_pool_debugfs_write(struct file * file,const char __user * ubuf,size_t count,loff_t * ppos)105 static ssize_t kbase_mem_pool_debugfs_write(struct file *file,
106 const char __user *ubuf, size_t count, loff_t *ppos)
107 {
108 int err;
109
110 CSTD_UNUSED(ppos);
111 err = kbase_debugfs_helper_seq_write(file, ubuf, count,
112 MEMORY_GROUP_MANAGER_NR_GROUPS, kbase_mem_pool_debugfs_trim);
113 return err ? err : count;
114 }
115
kbase_mem_pool_debugfs_open(struct inode * in,struct file * file)116 static int kbase_mem_pool_debugfs_open(struct inode *in, struct file *file)
117 {
118 return single_open(file, kbase_mem_pool_debugfs_size_show,
119 in->i_private);
120 }
121
122 static const struct file_operations kbase_mem_pool_debugfs_fops = {
123 .owner = THIS_MODULE,
124 .open = kbase_mem_pool_debugfs_open,
125 .read = seq_read,
126 .write = kbase_mem_pool_debugfs_write,
127 .llseek = seq_lseek,
128 .release = single_release,
129 };
130
kbase_mem_pool_debugfs_max_size_show(struct seq_file * sfile,void * data)131 static int kbase_mem_pool_debugfs_max_size_show(struct seq_file *sfile,
132 void *data)
133 {
134 CSTD_UNUSED(data);
135 return kbase_debugfs_helper_seq_read(sfile,
136 MEMORY_GROUP_MANAGER_NR_GROUPS,
137 kbase_mem_pool_debugfs_max_size);
138 }
139
kbase_mem_pool_debugfs_max_size_write(struct file * file,const char __user * ubuf,size_t count,loff_t * ppos)140 static ssize_t kbase_mem_pool_debugfs_max_size_write(struct file *file,
141 const char __user *ubuf, size_t count, loff_t *ppos)
142 {
143 int err;
144
145 CSTD_UNUSED(ppos);
146 err = kbase_debugfs_helper_seq_write(file, ubuf, count,
147 MEMORY_GROUP_MANAGER_NR_GROUPS,
148 kbase_mem_pool_debugfs_set_max_size);
149 return err ? err : count;
150 }
151
kbase_mem_pool_debugfs_max_size_open(struct inode * in,struct file * file)152 static int kbase_mem_pool_debugfs_max_size_open(struct inode *in,
153 struct file *file)
154 {
155 return single_open(file, kbase_mem_pool_debugfs_max_size_show,
156 in->i_private);
157 }
158
159 static const struct file_operations kbase_mem_pool_debugfs_max_size_fops = {
160 .owner = THIS_MODULE,
161 .open = kbase_mem_pool_debugfs_max_size_open,
162 .read = seq_read,
163 .write = kbase_mem_pool_debugfs_max_size_write,
164 .llseek = seq_lseek,
165 .release = single_release,
166 };
167
kbase_mem_pool_debugfs_init(struct dentry * parent,struct kbase_context * kctx)168 void kbase_mem_pool_debugfs_init(struct dentry *parent,
169 struct kbase_context *kctx)
170 {
171 const mode_t mode = 0644;
172
173 debugfs_create_file("mem_pool_size", mode, parent,
174 &kctx->mem_pools.small, &kbase_mem_pool_debugfs_fops);
175
176 debugfs_create_file("mem_pool_max_size", mode, parent,
177 &kctx->mem_pools.small, &kbase_mem_pool_debugfs_max_size_fops);
178
179 debugfs_create_file("lp_mem_pool_size", mode, parent,
180 &kctx->mem_pools.large, &kbase_mem_pool_debugfs_fops);
181
182 debugfs_create_file("lp_mem_pool_max_size", mode, parent,
183 &kctx->mem_pools.large, &kbase_mem_pool_debugfs_max_size_fops);
184 }
185