1/*	$NetBSD: intel_engine_pool.c,v 1.2 2021/12/18 23:45:30 riastradh Exp $	*/
2
3/*
4 * SPDX-License-Identifier: MIT
5 *
6 * Copyright �� 2014-2018 Intel Corporation
7 */
8
9#include <sys/cdefs.h>
10__KERNEL_RCSID(0, "$NetBSD: intel_engine_pool.c,v 1.2 2021/12/18 23:45:30 riastradh Exp $");
11
12#include "gem/i915_gem_object.h"
13
14#include "i915_drv.h"
15#include "intel_engine_pm.h"
16#include "intel_engine_pool.h"
17
18static struct intel_engine_cs *to_engine(struct intel_engine_pool *pool)
19{
20	return container_of(pool, struct intel_engine_cs, pool);
21}
22
23static struct list_head *
24bucket_for_size(struct intel_engine_pool *pool, size_t sz)
25{
26	int n;
27
28	/*
29	 * Compute a power-of-two bucket, but throw everything greater than
30	 * 16KiB into the same bucket: i.e. the buckets hold objects of
31	 * (1 page, 2 pages, 4 pages, 8+ pages).
32	 */
33	n = fls(sz >> PAGE_SHIFT) - 1;
34	if (n >= ARRAY_SIZE(pool->cache_list))
35		n = ARRAY_SIZE(pool->cache_list) - 1;
36
37	return &pool->cache_list[n];
38}
39
40static void node_free(struct intel_engine_pool_node *node)
41{
42	i915_gem_object_put(node->obj);
43	i915_active_fini(&node->active);
44	kfree(node);
45}
46
47static int pool_active(struct i915_active *ref)
48{
49	struct intel_engine_pool_node *node =
50		container_of(ref, typeof(*node), active);
51	struct dma_resv *resv = node->obj->base.resv;
52	int err;
53
54	if (dma_resv_trylock(resv)) {
55		dma_resv_add_excl_fence(resv, NULL);
56		dma_resv_unlock(resv);
57	}
58
59	err = i915_gem_object_pin_pages(node->obj);
60	if (err)
61		return err;
62
63	/* Hide this pinned object from the shrinker until retired */
64	i915_gem_object_make_unshrinkable(node->obj);
65
66	return 0;
67}
68
69__i915_active_call
70static void pool_retire(struct i915_active *ref)
71{
72	struct intel_engine_pool_node *node =
73		container_of(ref, typeof(*node), active);
74	struct intel_engine_pool *pool = node->pool;
75	struct list_head *list = bucket_for_size(pool, node->obj->base.size);
76	unsigned long flags;
77
78	GEM_BUG_ON(!intel_engine_pm_is_awake(to_engine(pool)));
79
80	i915_gem_object_unpin_pages(node->obj);
81
82	/* Return this object to the shrinker pool */
83	i915_gem_object_make_purgeable(node->obj);
84
85	spin_lock_irqsave(&pool->lock, flags);
86	list_add(&node->link, list);
87	spin_unlock_irqrestore(&pool->lock, flags);
88}
89
90static struct intel_engine_pool_node *
91node_create(struct intel_engine_pool *pool, size_t sz)
92{
93	struct intel_engine_cs *engine = to_engine(pool);
94	struct intel_engine_pool_node *node;
95	struct drm_i915_gem_object *obj;
96
97	node = kmalloc(sizeof(*node),
98		       GFP_KERNEL | __GFP_RETRY_MAYFAIL | __GFP_NOWARN);
99	if (!node)
100		return ERR_PTR(-ENOMEM);
101
102	node->pool = pool;
103	i915_active_init(&node->active, pool_active, pool_retire);
104
105	obj = i915_gem_object_create_internal(engine->i915, sz);
106	if (IS_ERR(obj)) {
107		i915_active_fini(&node->active);
108		kfree(node);
109		return ERR_CAST(obj);
110	}
111
112	i915_gem_object_set_readonly(obj);
113
114	node->obj = obj;
115	return node;
116}
117
118static struct intel_engine_pool *lookup_pool(struct intel_engine_cs *engine)
119{
120	if (intel_engine_is_virtual(engine))
121		engine = intel_virtual_engine_get_sibling(engine, 0);
122
123	GEM_BUG_ON(!engine);
124	return &engine->pool;
125}
126
127struct intel_engine_pool_node *
128intel_engine_get_pool(struct intel_engine_cs *engine, size_t size)
129{
130	struct intel_engine_pool *pool = lookup_pool(engine);
131	struct intel_engine_pool_node *node;
132	struct list_head *list;
133	unsigned long flags;
134	int ret;
135
136	GEM_BUG_ON(!intel_engine_pm_is_awake(to_engine(pool)));
137
138	size = PAGE_ALIGN(size);
139	list = bucket_for_size(pool, size);
140
141	spin_lock_irqsave(&pool->lock, flags);
142	list_for_each_entry(node, list, link) {
143		if (node->obj->base.size < size)
144			continue;
145		list_del(&node->link);
146		break;
147	}
148	spin_unlock_irqrestore(&pool->lock, flags);
149
150	if (&node->link == list) {
151		node = node_create(pool, size);
152		if (IS_ERR(node))
153			return node;
154	}
155
156	ret = i915_active_acquire(&node->active);
157	if (ret) {
158		node_free(node);
159		return ERR_PTR(ret);
160	}
161
162	return node;
163}
164
165void intel_engine_pool_init(struct intel_engine_pool *pool)
166{
167	int n;
168
169	spin_lock_init(&pool->lock);
170	for (n = 0; n < ARRAY_SIZE(pool->cache_list); n++)
171		INIT_LIST_HEAD(&pool->cache_list[n]);
172}
173
174void intel_engine_pool_park(struct intel_engine_pool *pool)
175{
176	int n;
177
178	for (n = 0; n < ARRAY_SIZE(pool->cache_list); n++) {
179		struct list_head *list = &pool->cache_list[n];
180		struct intel_engine_pool_node *node, *nn;
181
182		list_for_each_entry_safe(node, nn, list, link)
183			node_free(node);
184
185		INIT_LIST_HEAD(list);
186	}
187}
188
189void intel_engine_pool_fini(struct intel_engine_pool *pool)
190{
191	int n;
192
193	for (n = 0; n < ARRAY_SIZE(pool->cache_list); n++)
194		GEM_BUG_ON(!list_empty(&pool->cache_list[n]));
195}
196