Loading...
1/*
2 * Copyright 2016 Advanced Micro Devices, Inc.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 *
22 * Authors: Christian König
23 */
24
25#include <drm/drmP.h>
26#include "amdgpu.h"
27
28struct amdgpu_gtt_mgr {
29 struct drm_mm mm;
30 spinlock_t lock;
31 uint64_t available;
32};
33
34/**
35 * amdgpu_gtt_mgr_init - init GTT manager and DRM MM
36 *
37 * @man: TTM memory type manager
38 * @p_size: maximum size of GTT
39 *
40 * Allocate and initialize the GTT manager.
41 */
42static int amdgpu_gtt_mgr_init(struct ttm_mem_type_manager *man,
43 unsigned long p_size)
44{
45 struct amdgpu_gtt_mgr *mgr;
46
47 mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);
48 if (!mgr)
49 return -ENOMEM;
50
51 drm_mm_init(&mgr->mm, 0, p_size);
52 spin_lock_init(&mgr->lock);
53 mgr->available = p_size;
54 man->priv = mgr;
55 return 0;
56}
57
58/**
59 * amdgpu_gtt_mgr_fini - free and destroy GTT manager
60 *
61 * @man: TTM memory type manager
62 *
63 * Destroy and free the GTT manager, returns -EBUSY if ranges are still
64 * allocated inside it.
65 */
66static int amdgpu_gtt_mgr_fini(struct ttm_mem_type_manager *man)
67{
68 struct amdgpu_gtt_mgr *mgr = man->priv;
69
70 spin_lock(&mgr->lock);
71 if (!drm_mm_clean(&mgr->mm)) {
72 spin_unlock(&mgr->lock);
73 return -EBUSY;
74 }
75
76 drm_mm_takedown(&mgr->mm);
77 spin_unlock(&mgr->lock);
78 kfree(mgr);
79 man->priv = NULL;
80 return 0;
81}
82
83/**
84 * amdgpu_gtt_mgr_alloc - allocate new ranges
85 *
86 * @man: TTM memory type manager
87 * @tbo: TTM BO we need this range for
88 * @place: placement flags and restrictions
89 * @mem: the resulting mem object
90 *
91 * Allocate the address space for a node.
92 */
93int amdgpu_gtt_mgr_alloc(struct ttm_mem_type_manager *man,
94 struct ttm_buffer_object *tbo,
95 const struct ttm_place *place,
96 struct ttm_mem_reg *mem)
97{
98 struct amdgpu_gtt_mgr *mgr = man->priv;
99 struct drm_mm_node *node = mem->mm_node;
100 enum drm_mm_search_flags sflags = DRM_MM_SEARCH_BEST;
101 enum drm_mm_allocator_flags aflags = DRM_MM_CREATE_DEFAULT;
102 unsigned long fpfn, lpfn;
103 int r;
104
105 if (node->start != AMDGPU_BO_INVALID_OFFSET)
106 return 0;
107
108 if (place)
109 fpfn = place->fpfn;
110 else
111 fpfn = 0;
112
113 if (place && place->lpfn)
114 lpfn = place->lpfn;
115 else
116 lpfn = man->size;
117
118 if (place && place->flags & TTM_PL_FLAG_TOPDOWN) {
119 sflags = DRM_MM_SEARCH_BELOW;
120 aflags = DRM_MM_CREATE_TOP;
121 }
122
123 spin_lock(&mgr->lock);
124 r = drm_mm_insert_node_in_range_generic(&mgr->mm, node, mem->num_pages,
125 mem->page_alignment, 0,
126 fpfn, lpfn, sflags, aflags);
127 spin_unlock(&mgr->lock);
128
129 if (!r) {
130 mem->start = node->start;
131 if (&tbo->mem == mem)
132 tbo->offset = (tbo->mem.start << PAGE_SHIFT) +
133 tbo->bdev->man[tbo->mem.mem_type].gpu_offset;
134 }
135
136 return r;
137}
138
139/**
140 * amdgpu_gtt_mgr_new - allocate a new node
141 *
142 * @man: TTM memory type manager
143 * @tbo: TTM BO we need this range for
144 * @place: placement flags and restrictions
145 * @mem: the resulting mem object
146 *
147 * Dummy, allocate the node but no space for it yet.
148 */
149static int amdgpu_gtt_mgr_new(struct ttm_mem_type_manager *man,
150 struct ttm_buffer_object *tbo,
151 const struct ttm_place *place,
152 struct ttm_mem_reg *mem)
153{
154 struct amdgpu_gtt_mgr *mgr = man->priv;
155 struct drm_mm_node *node;
156 int r;
157
158 spin_lock(&mgr->lock);
159 if (mgr->available < mem->num_pages) {
160 spin_unlock(&mgr->lock);
161 return 0;
162 }
163 mgr->available -= mem->num_pages;
164 spin_unlock(&mgr->lock);
165
166 node = kzalloc(sizeof(*node), GFP_KERNEL);
167 if (!node) {
168 r = -ENOMEM;
169 goto err_out;
170 }
171
172 node->start = AMDGPU_BO_INVALID_OFFSET;
173 node->size = mem->num_pages;
174 mem->mm_node = node;
175
176 if (place->fpfn || place->lpfn || place->flags & TTM_PL_FLAG_TOPDOWN) {
177 r = amdgpu_gtt_mgr_alloc(man, tbo, place, mem);
178 if (unlikely(r)) {
179 kfree(node);
180 mem->mm_node = NULL;
181 r = 0;
182 goto err_out;
183 }
184 } else {
185 mem->start = node->start;
186 }
187
188 return 0;
189err_out:
190 spin_lock(&mgr->lock);
191 mgr->available += mem->num_pages;
192 spin_unlock(&mgr->lock);
193
194 return r;
195}
196
197/**
198 * amdgpu_gtt_mgr_del - free ranges
199 *
200 * @man: TTM memory type manager
201 * @tbo: TTM BO we need this range for
202 * @place: placement flags and restrictions
203 * @mem: TTM memory object
204 *
205 * Free the allocated GTT again.
206 */
207static void amdgpu_gtt_mgr_del(struct ttm_mem_type_manager *man,
208 struct ttm_mem_reg *mem)
209{
210 struct amdgpu_gtt_mgr *mgr = man->priv;
211 struct drm_mm_node *node = mem->mm_node;
212
213 if (!node)
214 return;
215
216 spin_lock(&mgr->lock);
217 if (node->start != AMDGPU_BO_INVALID_OFFSET)
218 drm_mm_remove_node(node);
219 mgr->available += mem->num_pages;
220 spin_unlock(&mgr->lock);
221
222 kfree(node);
223 mem->mm_node = NULL;
224}
225
226/**
227 * amdgpu_gtt_mgr_debug - dump VRAM table
228 *
229 * @man: TTM memory type manager
230 * @prefix: text prefix
231 *
232 * Dump the table content using printk.
233 */
234static void amdgpu_gtt_mgr_debug(struct ttm_mem_type_manager *man,
235 const char *prefix)
236{
237 struct amdgpu_gtt_mgr *mgr = man->priv;
238
239 spin_lock(&mgr->lock);
240 drm_mm_debug_table(&mgr->mm, prefix);
241 spin_unlock(&mgr->lock);
242}
243
244const struct ttm_mem_type_manager_func amdgpu_gtt_mgr_func = {
245 amdgpu_gtt_mgr_init,
246 amdgpu_gtt_mgr_fini,
247 amdgpu_gtt_mgr_new,
248 amdgpu_gtt_mgr_del,
249 amdgpu_gtt_mgr_debug
250};
1/*
2 * Copyright 2016 Advanced Micro Devices, Inc.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 *
22 * Authors: Christian König
23 */
24
25#include "amdgpu.h"
26
27struct amdgpu_gtt_mgr {
28 struct drm_mm mm;
29 spinlock_t lock;
30 atomic64_t available;
31};
32
33struct amdgpu_gtt_node {
34 struct drm_mm_node node;
35 struct ttm_buffer_object *tbo;
36};
37
38/**
39 * DOC: mem_info_gtt_total
40 *
41 * The amdgpu driver provides a sysfs API for reporting current total size of
42 * the GTT.
43 * The file mem_info_gtt_total is used for this, and returns the total size of
44 * the GTT block, in bytes
45 */
46static ssize_t amdgpu_mem_info_gtt_total_show(struct device *dev,
47 struct device_attribute *attr, char *buf)
48{
49 struct drm_device *ddev = dev_get_drvdata(dev);
50 struct amdgpu_device *adev = ddev->dev_private;
51
52 return snprintf(buf, PAGE_SIZE, "%llu\n",
53 (adev->mman.bdev.man[TTM_PL_TT].size) * PAGE_SIZE);
54}
55
56/**
57 * DOC: mem_info_gtt_used
58 *
59 * The amdgpu driver provides a sysfs API for reporting current total amount of
60 * used GTT.
61 * The file mem_info_gtt_used is used for this, and returns the current used
62 * size of the GTT block, in bytes
63 */
64static ssize_t amdgpu_mem_info_gtt_used_show(struct device *dev,
65 struct device_attribute *attr, char *buf)
66{
67 struct drm_device *ddev = dev_get_drvdata(dev);
68 struct amdgpu_device *adev = ddev->dev_private;
69
70 return snprintf(buf, PAGE_SIZE, "%llu\n",
71 amdgpu_gtt_mgr_usage(&adev->mman.bdev.man[TTM_PL_TT]));
72}
73
74static DEVICE_ATTR(mem_info_gtt_total, S_IRUGO,
75 amdgpu_mem_info_gtt_total_show, NULL);
76static DEVICE_ATTR(mem_info_gtt_used, S_IRUGO,
77 amdgpu_mem_info_gtt_used_show, NULL);
78
79/**
80 * amdgpu_gtt_mgr_init - init GTT manager and DRM MM
81 *
82 * @man: TTM memory type manager
83 * @p_size: maximum size of GTT
84 *
85 * Allocate and initialize the GTT manager.
86 */
87static int amdgpu_gtt_mgr_init(struct ttm_mem_type_manager *man,
88 unsigned long p_size)
89{
90 struct amdgpu_device *adev = amdgpu_ttm_adev(man->bdev);
91 struct amdgpu_gtt_mgr *mgr;
92 uint64_t start, size;
93 int ret;
94
95 mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);
96 if (!mgr)
97 return -ENOMEM;
98
99 start = AMDGPU_GTT_MAX_TRANSFER_SIZE * AMDGPU_GTT_NUM_TRANSFER_WINDOWS;
100 size = (adev->gmc.gart_size >> PAGE_SHIFT) - start;
101 drm_mm_init(&mgr->mm, start, size);
102 spin_lock_init(&mgr->lock);
103 atomic64_set(&mgr->available, p_size);
104 man->priv = mgr;
105
106 ret = device_create_file(adev->dev, &dev_attr_mem_info_gtt_total);
107 if (ret) {
108 DRM_ERROR("Failed to create device file mem_info_gtt_total\n");
109 return ret;
110 }
111 ret = device_create_file(adev->dev, &dev_attr_mem_info_gtt_used);
112 if (ret) {
113 DRM_ERROR("Failed to create device file mem_info_gtt_used\n");
114 return ret;
115 }
116
117 return 0;
118}
119
120/**
121 * amdgpu_gtt_mgr_fini - free and destroy GTT manager
122 *
123 * @man: TTM memory type manager
124 *
125 * Destroy and free the GTT manager, returns -EBUSY if ranges are still
126 * allocated inside it.
127 */
128static int amdgpu_gtt_mgr_fini(struct ttm_mem_type_manager *man)
129{
130 struct amdgpu_device *adev = amdgpu_ttm_adev(man->bdev);
131 struct amdgpu_gtt_mgr *mgr = man->priv;
132 spin_lock(&mgr->lock);
133 drm_mm_takedown(&mgr->mm);
134 spin_unlock(&mgr->lock);
135 kfree(mgr);
136 man->priv = NULL;
137
138 device_remove_file(adev->dev, &dev_attr_mem_info_gtt_total);
139 device_remove_file(adev->dev, &dev_attr_mem_info_gtt_used);
140
141 return 0;
142}
143
144/**
145 * amdgpu_gtt_mgr_has_gart_addr - Check if mem has address space
146 *
147 * @mem: the mem object to check
148 *
149 * Check if a mem object has already address space allocated.
150 */
151bool amdgpu_gtt_mgr_has_gart_addr(struct ttm_mem_reg *mem)
152{
153 return mem->mm_node != NULL;
154}
155
156/**
157 * amdgpu_gtt_mgr_new - allocate a new node
158 *
159 * @man: TTM memory type manager
160 * @tbo: TTM BO we need this range for
161 * @place: placement flags and restrictions
162 * @mem: the resulting mem object
163 *
164 * Dummy, allocate the node but no space for it yet.
165 */
166static int amdgpu_gtt_mgr_new(struct ttm_mem_type_manager *man,
167 struct ttm_buffer_object *tbo,
168 const struct ttm_place *place,
169 struct ttm_mem_reg *mem)
170{
171 struct amdgpu_gtt_mgr *mgr = man->priv;
172 struct amdgpu_gtt_node *node;
173 int r;
174
175 spin_lock(&mgr->lock);
176 if ((&tbo->mem == mem || tbo->mem.mem_type != TTM_PL_TT) &&
177 atomic64_read(&mgr->available) < mem->num_pages) {
178 spin_unlock(&mgr->lock);
179 return -ENOSPC;
180 }
181 atomic64_sub(mem->num_pages, &mgr->available);
182 spin_unlock(&mgr->lock);
183
184 if (!place->lpfn) {
185 mem->mm_node = NULL;
186 mem->start = AMDGPU_BO_INVALID_OFFSET;
187 return 0;
188 }
189
190 node = kzalloc(sizeof(*node), GFP_KERNEL);
191 if (!node) {
192 r = -ENOMEM;
193 goto err_out;
194 }
195
196 node->tbo = tbo;
197
198 spin_lock(&mgr->lock);
199 r = drm_mm_insert_node_in_range(&mgr->mm, &node->node, mem->num_pages,
200 mem->page_alignment, 0, place->fpfn,
201 place->lpfn, DRM_MM_INSERT_BEST);
202 spin_unlock(&mgr->lock);
203
204 if (unlikely(r))
205 goto err_free;
206
207 mem->mm_node = node;
208 mem->start = node->node.start;
209
210 return 0;
211
212err_free:
213 kfree(node);
214
215err_out:
216 atomic64_add(mem->num_pages, &mgr->available);
217
218 return r;
219}
220
221/**
222 * amdgpu_gtt_mgr_del - free ranges
223 *
224 * @man: TTM memory type manager
225 * @mem: TTM memory object
226 *
227 * Free the allocated GTT again.
228 */
229static void amdgpu_gtt_mgr_del(struct ttm_mem_type_manager *man,
230 struct ttm_mem_reg *mem)
231{
232 struct amdgpu_gtt_mgr *mgr = man->priv;
233 struct amdgpu_gtt_node *node = mem->mm_node;
234
235 if (node) {
236 spin_lock(&mgr->lock);
237 drm_mm_remove_node(&node->node);
238 spin_unlock(&mgr->lock);
239 kfree(node);
240 }
241
242 atomic64_add(mem->num_pages, &mgr->available);
243}
244
245/**
246 * amdgpu_gtt_mgr_usage - return usage of GTT domain
247 *
248 * @man: TTM memory type manager
249 *
250 * Return how many bytes are used in the GTT domain
251 */
252uint64_t amdgpu_gtt_mgr_usage(struct ttm_mem_type_manager *man)
253{
254 struct amdgpu_gtt_mgr *mgr = man->priv;
255 s64 result = man->size - atomic64_read(&mgr->available);
256
257 return (result > 0 ? result : 0) * PAGE_SIZE;
258}
259
260int amdgpu_gtt_mgr_recover(struct ttm_mem_type_manager *man)
261{
262 struct amdgpu_gtt_mgr *mgr = man->priv;
263 struct amdgpu_gtt_node *node;
264 struct drm_mm_node *mm_node;
265 int r = 0;
266
267 spin_lock(&mgr->lock);
268 drm_mm_for_each_node(mm_node, &mgr->mm) {
269 node = container_of(mm_node, struct amdgpu_gtt_node, node);
270 r = amdgpu_ttm_recover_gart(node->tbo);
271 if (r)
272 break;
273 }
274 spin_unlock(&mgr->lock);
275
276 return r;
277}
278
279/**
280 * amdgpu_gtt_mgr_debug - dump VRAM table
281 *
282 * @man: TTM memory type manager
283 * @printer: DRM printer to use
284 *
285 * Dump the table content using printk.
286 */
287static void amdgpu_gtt_mgr_debug(struct ttm_mem_type_manager *man,
288 struct drm_printer *printer)
289{
290 struct amdgpu_gtt_mgr *mgr = man->priv;
291
292 spin_lock(&mgr->lock);
293 drm_mm_print(&mgr->mm, printer);
294 spin_unlock(&mgr->lock);
295
296 drm_printf(printer, "man size:%llu pages, gtt available:%lld pages, usage:%lluMB\n",
297 man->size, (u64)atomic64_read(&mgr->available),
298 amdgpu_gtt_mgr_usage(man) >> 20);
299}
300
301const struct ttm_mem_type_manager_func amdgpu_gtt_mgr_func = {
302 .init = amdgpu_gtt_mgr_init,
303 .takedown = amdgpu_gtt_mgr_fini,
304 .get_node = amdgpu_gtt_mgr_new,
305 .put_node = amdgpu_gtt_mgr_del,
306 .debug = amdgpu_gtt_mgr_debug
307};