ALSA: ctxfi: More constifications
[muen/linux.git] / sound / pci / ctxfi / ctresource.c
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 int 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         return rsc->conj;
119 }
120
121 static int rsc_master(struct rsc *rsc)
122 {
123         return rsc->conj = rsc->idx;
124 }
125
126 static const struct rsc_ops rsc_generic_ops = {
127         .index          = rsc_index,
128         .output_slot    = audio_ring_slot,
129         .master         = rsc_master,
130         .next_conj      = rsc_next_conj,
131 };
132
133 int
134 rsc_init(struct rsc *rsc, u32 idx, enum RSCTYP type, u32 msr, struct hw *hw)
135 {
136         int err = 0;
137
138         rsc->idx = idx;
139         rsc->conj = idx;
140         rsc->type = type;
141         rsc->msr = msr;
142         rsc->hw = hw;
143         rsc->ops = &rsc_generic_ops;
144         if (!hw) {
145                 rsc->ctrl_blk = NULL;
146                 return 0;
147         }
148
149         switch (type) {
150         case SRC:
151                 err = hw->src_rsc_get_ctrl_blk(&rsc->ctrl_blk);
152                 break;
153         case AMIXER:
154                 err = hw->amixer_rsc_get_ctrl_blk(&rsc->ctrl_blk);
155                 break;
156         case SRCIMP:
157         case SUM:
158         case DAIO:
159                 break;
160         default:
161                 dev_err(((struct hw *)hw)->card->dev,
162                         "Invalid resource type value %d!\n", type);
163                 return -EINVAL;
164         }
165
166         if (err) {
167                 dev_err(((struct hw *)hw)->card->dev,
168                         "Failed to get resource control block!\n");
169                 return err;
170         }
171
172         return 0;
173 }
174
175 int rsc_uninit(struct rsc *rsc)
176 {
177         if ((NULL != rsc->hw) && (NULL != rsc->ctrl_blk)) {
178                 switch (rsc->type) {
179                 case SRC:
180                         rsc->hw->src_rsc_put_ctrl_blk(rsc->ctrl_blk);
181                         break;
182                 case AMIXER:
183                         rsc->hw->amixer_rsc_put_ctrl_blk(rsc->ctrl_blk);
184                         break;
185                 case SUM:
186                 case DAIO:
187                         break;
188                 default:
189                         dev_err(((struct hw *)rsc->hw)->card->dev,
190                                 "Invalid resource type value %d!\n",
191                                 rsc->type);
192                         break;
193                 }
194
195                 rsc->hw = rsc->ctrl_blk = NULL;
196         }
197
198         rsc->idx = rsc->conj = 0;
199         rsc->type = NUM_RSCTYP;
200         rsc->msr = 0;
201
202         return 0;
203 }
204
205 int rsc_mgr_init(struct rsc_mgr *mgr, enum RSCTYP type,
206                  unsigned int amount, struct hw *hw)
207 {
208         int err = 0;
209
210         mgr->type = NUM_RSCTYP;
211
212         mgr->rscs = kzalloc(((amount + 8 - 1) / 8), GFP_KERNEL);
213         if (!mgr->rscs)
214                 return -ENOMEM;
215
216         switch (type) {
217         case SRC:
218                 err = hw->src_mgr_get_ctrl_blk(&mgr->ctrl_blk);
219                 break;
220         case SRCIMP:
221                 err = hw->srcimp_mgr_get_ctrl_blk(&mgr->ctrl_blk);
222                 break;
223         case AMIXER:
224                 err = hw->amixer_mgr_get_ctrl_blk(&mgr->ctrl_blk);
225                 break;
226         case DAIO:
227                 err = hw->daio_mgr_get_ctrl_blk(hw, &mgr->ctrl_blk);
228                 break;
229         case SUM:
230                 break;
231         default:
232                 dev_err(hw->card->dev,
233                         "Invalid resource type value %d!\n", type);
234                 err = -EINVAL;
235                 goto error;
236         }
237
238         if (err) {
239                 dev_err(hw->card->dev,
240                         "Failed to get manager control block!\n");
241                 goto error;
242         }
243
244         mgr->type = type;
245         mgr->avail = mgr->amount = amount;
246         mgr->hw = hw;
247
248         return 0;
249
250 error:
251         kfree(mgr->rscs);
252         return err;
253 }
254
255 int rsc_mgr_uninit(struct rsc_mgr *mgr)
256 {
257         kfree(mgr->rscs);
258         mgr->rscs = NULL;
259
260         if ((NULL != mgr->hw) && (NULL != mgr->ctrl_blk)) {
261                 switch (mgr->type) {
262                 case SRC:
263                         mgr->hw->src_mgr_put_ctrl_blk(mgr->ctrl_blk);
264                         break;
265                 case SRCIMP:
266                         mgr->hw->srcimp_mgr_put_ctrl_blk(mgr->ctrl_blk);
267                         break;
268                 case AMIXER:
269                         mgr->hw->amixer_mgr_put_ctrl_blk(mgr->ctrl_blk);
270                         break;
271                 case DAIO:
272                         mgr->hw->daio_mgr_put_ctrl_blk(mgr->ctrl_blk);
273                         break;
274                 case SUM:
275                         break;
276                 default:
277                         dev_err(((struct hw *)mgr->hw)->card->dev,
278                                 "Invalid resource type value %d!\n",
279                                 mgr->type);
280                         break;
281                 }
282
283                 mgr->hw = mgr->ctrl_blk = NULL;
284         }
285
286         mgr->type = NUM_RSCTYP;
287         mgr->avail = mgr->amount = 0;
288
289         return 0;
290 }