lib/list_sort: simplify and remove MAX_LIST_LENGTH_BITS
[sfrench/cifs-2.6.git] / drivers / tee / tee_shm_pool.c
1 /*
2  * Copyright (c) 2015, Linaro Limited
3  *
4  * This software is licensed under the terms of the GNU General Public
5  * License version 2, as published by the Free Software Foundation, and
6  * may be copied, distributed, and modified under those terms.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  *
13  */
14 #include <linux/device.h>
15 #include <linux/dma-buf.h>
16 #include <linux/genalloc.h>
17 #include <linux/slab.h>
18 #include <linux/tee_drv.h>
19 #include "tee_private.h"
20
21 static int pool_op_gen_alloc(struct tee_shm_pool_mgr *poolm,
22                              struct tee_shm *shm, size_t size)
23 {
24         unsigned long va;
25         struct gen_pool *genpool = poolm->private_data;
26         size_t s = roundup(size, 1 << genpool->min_alloc_order);
27
28         va = gen_pool_alloc(genpool, s);
29         if (!va)
30                 return -ENOMEM;
31
32         memset((void *)va, 0, s);
33         shm->kaddr = (void *)va;
34         shm->paddr = gen_pool_virt_to_phys(genpool, va);
35         shm->size = s;
36         return 0;
37 }
38
39 static void pool_op_gen_free(struct tee_shm_pool_mgr *poolm,
40                              struct tee_shm *shm)
41 {
42         gen_pool_free(poolm->private_data, (unsigned long)shm->kaddr,
43                       shm->size);
44         shm->kaddr = NULL;
45 }
46
47 static void pool_op_gen_destroy_poolmgr(struct tee_shm_pool_mgr *poolm)
48 {
49         gen_pool_destroy(poolm->private_data);
50         kfree(poolm);
51 }
52
53 static const struct tee_shm_pool_mgr_ops pool_ops_generic = {
54         .alloc = pool_op_gen_alloc,
55         .free = pool_op_gen_free,
56         .destroy_poolmgr = pool_op_gen_destroy_poolmgr,
57 };
58
59 /**
60  * tee_shm_pool_alloc_res_mem() - Create a shared memory pool from reserved
61  * memory range
62  * @priv_info:  Information for driver private shared memory pool
63  * @dmabuf_info: Information for dma-buf shared memory pool
64  *
65  * Start and end of pools will must be page aligned.
66  *
67  * Allocation with the flag TEE_SHM_DMA_BUF set will use the range supplied
68  * in @dmabuf, others will use the range provided by @priv.
69  *
70  * @returns pointer to a 'struct tee_shm_pool' or an ERR_PTR on failure.
71  */
72 struct tee_shm_pool *
73 tee_shm_pool_alloc_res_mem(struct tee_shm_pool_mem_info *priv_info,
74                            struct tee_shm_pool_mem_info *dmabuf_info)
75 {
76         struct tee_shm_pool_mgr *priv_mgr;
77         struct tee_shm_pool_mgr *dmabuf_mgr;
78         void *rc;
79
80         /*
81          * Create the pool for driver private shared memory
82          */
83         rc = tee_shm_pool_mgr_alloc_res_mem(priv_info->vaddr, priv_info->paddr,
84                                             priv_info->size,
85                                             3 /* 8 byte aligned */);
86         if (IS_ERR(rc))
87                 return rc;
88         priv_mgr = rc;
89
90         /*
91          * Create the pool for dma_buf shared memory
92          */
93         rc = tee_shm_pool_mgr_alloc_res_mem(dmabuf_info->vaddr,
94                                             dmabuf_info->paddr,
95                                             dmabuf_info->size, PAGE_SHIFT);
96         if (IS_ERR(rc))
97                 goto err_free_priv_mgr;
98         dmabuf_mgr = rc;
99
100         rc = tee_shm_pool_alloc(priv_mgr, dmabuf_mgr);
101         if (IS_ERR(rc))
102                 goto err_free_dmabuf_mgr;
103
104         return rc;
105
106 err_free_dmabuf_mgr:
107         tee_shm_pool_mgr_destroy(dmabuf_mgr);
108 err_free_priv_mgr:
109         tee_shm_pool_mgr_destroy(priv_mgr);
110
111         return rc;
112 }
113 EXPORT_SYMBOL_GPL(tee_shm_pool_alloc_res_mem);
114
115 struct tee_shm_pool_mgr *tee_shm_pool_mgr_alloc_res_mem(unsigned long vaddr,
116                                                         phys_addr_t paddr,
117                                                         size_t size,
118                                                         int min_alloc_order)
119 {
120         const size_t page_mask = PAGE_SIZE - 1;
121         struct tee_shm_pool_mgr *mgr;
122         int rc;
123
124         /* Start and end must be page aligned */
125         if (vaddr & page_mask || paddr & page_mask || size & page_mask)
126                 return ERR_PTR(-EINVAL);
127
128         mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);
129         if (!mgr)
130                 return ERR_PTR(-ENOMEM);
131
132         mgr->private_data = gen_pool_create(min_alloc_order, -1);
133         if (!mgr->private_data) {
134                 rc = -ENOMEM;
135                 goto err;
136         }
137
138         gen_pool_set_algo(mgr->private_data, gen_pool_best_fit, NULL);
139         rc = gen_pool_add_virt(mgr->private_data, vaddr, paddr, size, -1);
140         if (rc) {
141                 gen_pool_destroy(mgr->private_data);
142                 goto err;
143         }
144
145         mgr->ops = &pool_ops_generic;
146
147         return mgr;
148 err:
149         kfree(mgr);
150
151         return ERR_PTR(rc);
152 }
153 EXPORT_SYMBOL_GPL(tee_shm_pool_mgr_alloc_res_mem);
154
155 static bool check_mgr_ops(struct tee_shm_pool_mgr *mgr)
156 {
157         return mgr && mgr->ops && mgr->ops->alloc && mgr->ops->free &&
158                 mgr->ops->destroy_poolmgr;
159 }
160
161 struct tee_shm_pool *tee_shm_pool_alloc(struct tee_shm_pool_mgr *priv_mgr,
162                                         struct tee_shm_pool_mgr *dmabuf_mgr)
163 {
164         struct tee_shm_pool *pool;
165
166         if (!check_mgr_ops(priv_mgr) || !check_mgr_ops(dmabuf_mgr))
167                 return ERR_PTR(-EINVAL);
168
169         pool = kzalloc(sizeof(*pool), GFP_KERNEL);
170         if (!pool)
171                 return ERR_PTR(-ENOMEM);
172
173         pool->private_mgr = priv_mgr;
174         pool->dma_buf_mgr = dmabuf_mgr;
175
176         return pool;
177 }
178 EXPORT_SYMBOL_GPL(tee_shm_pool_alloc);
179
180 /**
181  * tee_shm_pool_free() - Free a shared memory pool
182  * @pool:       The shared memory pool to free
183  *
184  * There must be no remaining shared memory allocated from this pool when
185  * this function is called.
186  */
187 void tee_shm_pool_free(struct tee_shm_pool *pool)
188 {
189         if (pool->private_mgr)
190                 tee_shm_pool_mgr_destroy(pool->private_mgr);
191         if (pool->dma_buf_mgr)
192                 tee_shm_pool_mgr_destroy(pool->dma_buf_mgr);
193         kfree(pool);
194 }
195 EXPORT_SYMBOL_GPL(tee_shm_pool_free);