1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved.
4 *
5 * @File ctresource.c
6 *
7 * @Brief
8 * This file contains the implementation of some generic helper functions.
9 *
10 * @Author Liu Chun
11 * @Date May 15 2008
12 */
13
14 #include "ctresource.h"
15 #include "cthardware.h"
16 #include <linux/err.h>
17 #include <linux/slab.h>
18
19 #define AUDIO_SLOT_BLOCK_NUM 256
20
21 /* Resource allocation based on bit-map management mechanism */
22 static int
23 get_resource(u8 *rscs, unsigned int amount,
24 unsigned int multi, unsigned int *ridx)
25 {
26 int i, j, k, n;
27
28 /* Check whether there are sufficient resources to meet request. */
29 for (i = 0, n = multi; i < amount; i++) {
30 j = i / 8;
31 k = i % 8;
32 if (rscs[j] & ((u8)1 << k)) {
33 n = multi;
34 continue;
35 }
36 if (!(--n))
37 break; /* found sufficient contiguous resources */
38 }
39
40 if (i >= amount) {
41 /* Can not find sufficient contiguous resources */
42 return -ENOENT;
43 }
44
45 /* Mark the contiguous bits in resource bit-map as used */
46 for (n = multi; n > 0; n--) {
47 j = i / 8;
48 k = i % 8;
49 rscs[j] |= ((u8)1 << k);
50 i--;
51 }
52
53 *ridx = i + 1;
54
55 return 0;
56 }
57
58 static int put_resource(u8 *rscs, unsigned int multi, unsigned int idx)
59 {
60 unsigned int i, j, k, n;
61
62 /* Mark the contiguous bits in resource bit-map as used */
63 for (n = multi, i = idx; n > 0; n--) {
64 j = i / 8;
65 k = i % 8;
66 rscs[j] &= ~((u8)1 << k);
67 i++;
68 }
69
70 return 0;
71 }
72
73 int mgr_get_resource(struct rsc_mgr *mgr, unsigned int n, unsigned int *ridx)
74 {
75 int err;
76
77 if (n > mgr->avail)
78 return -ENOENT;
79
80 err = get_resource(mgr->rscs, mgr->amount, n, ridx);
81 if (!err)
82 mgr->avail -= n;
83
84 return err;
85 }
86
87 int mgr_put_resource(struct rsc_mgr *mgr, unsigned int n, unsigned int idx)
88 {
89 put_resource(mgr->rscs, n, idx);
90 mgr->avail += n;
91
92 return 0;
93 }
94
95 static const unsigned char offset_in_audio_slot_block[NUM_RSCTYP] = {
96 /* SRC channel is at Audio Ring slot 1 every 16 slots. */
97 [SRC] = 0x1,
98 [AMIXER] = 0x4,
99 [SUM] = 0xc,
100 };
101
102 static int rsc_index(const struct rsc *rsc)
103 {
104 return rsc->conj;
105 }
106
107 static int audio_ring_slot(const struct rsc *rsc)
108 {
109 return (rsc->conj << 4) + offset_in_audio_slot_block[rsc->type];
110 }
111
112 static void rsc_next_conj(struct rsc *rsc)
113 {
114 unsigned int i;
115 for (i = 0; (i < 8) && (!(rsc->msr & (0x1 << i))); )
116 i++;
117 rsc->conj += (AUDIO_SLOT_BLOCK_NUM >> i);
118 }
119
120 static void rsc_master(struct rsc *rsc)
121 {
122 rsc->conj = rsc->idx;
123 }
124
125 static const struct rsc_ops rsc_generic_ops = {
126 .index = rsc_index,
127 .output_slot = audio_ring_slot,
128 .master = rsc_master,
129 .next_conj = rsc_next_conj,
130 };
131
132 int
133 rsc_init(struct rsc *rsc, u32 idx, enum RSCTYP type, u32 msr, struct hw *hw)
134 {
135 int err = 0;
136
137 rsc->idx = idx;
138 rsc->conj = idx;
139 rsc->type = type;
140 rsc->msr = msr;
141 rsc->hw = hw;
142 rsc->ops = &rsc_generic_ops;
143 if (!hw) {
144 rsc->ctrl_blk = NULL;
145 return 0;
146 }
147
148 switch (type) {
149 case SRC:
150 err = hw->src_rsc_get_ctrl_blk(&rsc->ctrl_blk);
151 break;
152 case AMIXER:
153 err = hw->amixer_rsc_get_ctrl_blk(&rsc->ctrl_blk);
154 break;
155 case SRCIMP:
156 case SUM:
157 case DAIO:
158 break;
159 default:
160 dev_err(((struct hw *)hw)->card->dev,
161 "Invalid resource type value %d!\n", type);
162 return -EINVAL;
163 }
164
165 if (err) {
166 dev_err(((struct hw *)hw)->card->dev,
167 "Failed to get resource control block!\n");
168 return err;
169 }
170
171 return 0;
172 }
173
174 int rsc_uninit(struct rsc *rsc)
175 {
176 if ((NULL != rsc->hw) && (NULL != rsc->ctrl_blk)) {
177 switch (rsc->type) {
178 case SRC:
179 rsc->hw->src_rsc_put_ctrl_blk(rsc->ctrl_blk);
180 break;
181 case AMIXER:
182 rsc->hw->amixer_rsc_put_ctrl_blk(rsc->ctrl_blk);
183 break;
184 case SUM:
185 case DAIO:
186 break;
187 default:
188 dev_err(((struct hw *)rsc->hw)->card->dev,
189 "Invalid resource type value %d!\n",
190 rsc->type);
191 break;
192 }
193
194 rsc->hw = rsc->ctrl_blk = NULL;
195 }
196
197 rsc->idx = rsc->conj = 0;
198 rsc->type = NUM_RSCTYP;
199 rsc->msr = 0;
200
201 return 0;
202 }
203
204 int rsc_mgr_init(struct rsc_mgr *mgr, enum RSCTYP type,
205 unsigned int amount, struct hw *hw)
206 {
207 int err = 0;
208
209 mgr->type = NUM_RSCTYP;
210
211 mgr->rscs = kzalloc(DIV_ROUND_UP(amount, 8), GFP_KERNEL);
212 if (!mgr->rscs)
213 return -ENOMEM;
214
215 switch (type) {
216 case SRC:
217 err = hw->src_mgr_get_ctrl_blk(&mgr->ctrl_blk);
218 break;
219 case SRCIMP:
220 err = hw->srcimp_mgr_get_ctrl_blk(&mgr->ctrl_blk);
221 break;
222 case AMIXER:
223 err = hw->amixer_mgr_get_ctrl_blk(&mgr->ctrl_blk);
224 break;
225 case DAIO:
226 err = hw->daio_mgr_get_ctrl_blk(hw, &mgr->ctrl_blk);
227 break;
228 case SUM:
229 break;
230 default:
231 dev_err(hw->card->dev,
232 "Invalid resource type value %d!\n", type);
233 err = -EINVAL;
234 goto error;
235 }
236
237 if (err) {
238 dev_err(hw->card->dev,
239 "Failed to get manager control block!\n");
240 goto error;
241 }
242
243 mgr->type = type;
244 mgr->avail = mgr->amount = amount;
245 mgr->hw = hw;
246
247 return 0;
248
249 error:
250 kfree(mgr->rscs);
251 return err;
252 }
253
254 int rsc_mgr_uninit(struct rsc_mgr *mgr)
255 {
256 kfree(mgr->rscs);
257 mgr->rscs = NULL;
258
259 if ((NULL != mgr->hw) && (NULL != mgr->ctrl_blk)) {
260 switch (mgr->type) {
261 case SRC:
262 mgr->hw->src_mgr_put_ctrl_blk(mgr->ctrl_blk);
263 break;
264 case SRCIMP:
265 mgr->hw->srcimp_mgr_put_ctrl_blk(mgr->ctrl_blk);
266 break;
267 case AMIXER:
268 mgr->hw->amixer_mgr_put_ctrl_blk(mgr->ctrl_blk);
269 break;
270 case DAIO:
271 mgr->hw->daio_mgr_put_ctrl_blk(mgr->ctrl_blk);
272 break;
273 case SUM:
274 break;
275 default:
276 dev_err(((struct hw *)mgr->hw)->card->dev,
277 "Invalid resource type value %d!\n",
278 mgr->type);
279 break;
280 }
281
282 mgr->hw = mgr->ctrl_blk = NULL;
283 }
284
285 mgr->type = NUM_RSCTYP;
286 mgr->avail = mgr->amount = 0;
287
288 return 0;
289 }
290
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.