xref: /linux/sound/pci/ctxfi/ctamixer.c (revision 79790b6818e96c58fe2bffee1b418c16e64e7b80)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved.
4  *
5  * @File	ctamixer.c
6  *
7  * @Brief
8  * This file contains the implementation of the Audio Mixer
9  * resource management object.
10  *
11  * @Author	Liu Chun
12  * @Date 	May 21 2008
13  */
14 
15 #include "ctamixer.h"
16 #include "cthardware.h"
17 #include <linux/slab.h>
18 
19 #define AMIXER_RESOURCE_NUM	256
20 #define SUM_RESOURCE_NUM	256
21 
22 #define AMIXER_Y_IMMEDIATE	1
23 
24 #define BLANK_SLOT		4094
25 
amixer_master(struct rsc * rsc)26 static void amixer_master(struct rsc *rsc)
27 {
28 	rsc->conj = 0;
29 	rsc->idx = container_of(rsc, struct amixer, rsc)->idx[0];
30 }
31 
amixer_next_conj(struct rsc * rsc)32 static void amixer_next_conj(struct rsc *rsc)
33 {
34 	rsc->conj++;
35 }
36 
amixer_index(const struct rsc * rsc)37 static int amixer_index(const struct rsc *rsc)
38 {
39 	return container_of(rsc, struct amixer, rsc)->idx[rsc->conj];
40 }
41 
amixer_output_slot(const struct rsc * rsc)42 static int amixer_output_slot(const struct rsc *rsc)
43 {
44 	return (amixer_index(rsc) << 4) + 0x4;
45 }
46 
47 static const struct rsc_ops amixer_basic_rsc_ops = {
48 	.master		= amixer_master,
49 	.next_conj	= amixer_next_conj,
50 	.index		= amixer_index,
51 	.output_slot	= amixer_output_slot,
52 };
53 
amixer_set_input(struct amixer * amixer,struct rsc * rsc)54 static int amixer_set_input(struct amixer *amixer, struct rsc *rsc)
55 {
56 	struct hw *hw;
57 
58 	hw = amixer->rsc.hw;
59 	hw->amixer_set_mode(amixer->rsc.ctrl_blk, AMIXER_Y_IMMEDIATE);
60 	amixer->input = rsc;
61 	if (!rsc)
62 		hw->amixer_set_x(amixer->rsc.ctrl_blk, BLANK_SLOT);
63 	else
64 		hw->amixer_set_x(amixer->rsc.ctrl_blk,
65 					rsc->ops->output_slot(rsc));
66 
67 	return 0;
68 }
69 
70 /* y is a 14-bit immediate constant */
amixer_set_y(struct amixer * amixer,unsigned int y)71 static int amixer_set_y(struct amixer *amixer, unsigned int y)
72 {
73 	struct hw *hw;
74 
75 	hw = amixer->rsc.hw;
76 	hw->amixer_set_y(amixer->rsc.ctrl_blk, y);
77 
78 	return 0;
79 }
80 
amixer_set_invalid_squash(struct amixer * amixer,unsigned int iv)81 static int amixer_set_invalid_squash(struct amixer *amixer, unsigned int iv)
82 {
83 	struct hw *hw;
84 
85 	hw = amixer->rsc.hw;
86 	hw->amixer_set_iv(amixer->rsc.ctrl_blk, iv);
87 
88 	return 0;
89 }
90 
amixer_set_sum(struct amixer * amixer,struct sum * sum)91 static int amixer_set_sum(struct amixer *amixer, struct sum *sum)
92 {
93 	struct hw *hw;
94 
95 	hw = amixer->rsc.hw;
96 	amixer->sum = sum;
97 	if (!sum) {
98 		hw->amixer_set_se(amixer->rsc.ctrl_blk, 0);
99 	} else {
100 		hw->amixer_set_se(amixer->rsc.ctrl_blk, 1);
101 		hw->amixer_set_sadr(amixer->rsc.ctrl_blk,
102 					sum->rsc.ops->index(&sum->rsc));
103 	}
104 
105 	return 0;
106 }
107 
amixer_commit_write(struct amixer * amixer)108 static int amixer_commit_write(struct amixer *amixer)
109 {
110 	struct hw *hw;
111 	unsigned int index;
112 	int i;
113 	struct rsc *input;
114 	struct sum *sum;
115 
116 	hw = amixer->rsc.hw;
117 	input = amixer->input;
118 	sum = amixer->sum;
119 
120 	/* Program master and conjugate resources */
121 	amixer->rsc.ops->master(&amixer->rsc);
122 	if (input)
123 		input->ops->master(input);
124 
125 	if (sum)
126 		sum->rsc.ops->master(&sum->rsc);
127 
128 	for (i = 0; i < amixer->rsc.msr; i++) {
129 		hw->amixer_set_dirty_all(amixer->rsc.ctrl_blk);
130 		if (input) {
131 			hw->amixer_set_x(amixer->rsc.ctrl_blk,
132 						input->ops->output_slot(input));
133 			input->ops->next_conj(input);
134 		}
135 		if (sum) {
136 			hw->amixer_set_sadr(amixer->rsc.ctrl_blk,
137 						sum->rsc.ops->index(&sum->rsc));
138 			sum->rsc.ops->next_conj(&sum->rsc);
139 		}
140 		index = amixer->rsc.ops->output_slot(&amixer->rsc);
141 		hw->amixer_commit_write(hw, index, amixer->rsc.ctrl_blk);
142 		amixer->rsc.ops->next_conj(&amixer->rsc);
143 	}
144 	amixer->rsc.ops->master(&amixer->rsc);
145 	if (input)
146 		input->ops->master(input);
147 
148 	if (sum)
149 		sum->rsc.ops->master(&sum->rsc);
150 
151 	return 0;
152 }
153 
amixer_commit_raw_write(struct amixer * amixer)154 static int amixer_commit_raw_write(struct amixer *amixer)
155 {
156 	struct hw *hw;
157 	unsigned int index;
158 
159 	hw = amixer->rsc.hw;
160 	index = amixer->rsc.ops->output_slot(&amixer->rsc);
161 	hw->amixer_commit_write(hw, index, amixer->rsc.ctrl_blk);
162 
163 	return 0;
164 }
165 
amixer_get_y(struct amixer * amixer)166 static int amixer_get_y(struct amixer *amixer)
167 {
168 	struct hw *hw;
169 
170 	hw = amixer->rsc.hw;
171 	return hw->amixer_get_y(amixer->rsc.ctrl_blk);
172 }
173 
amixer_setup(struct amixer * amixer,struct rsc * input,unsigned int scale,struct sum * sum)174 static int amixer_setup(struct amixer *amixer, struct rsc *input,
175 			unsigned int scale, struct sum *sum)
176 {
177 	amixer_set_input(amixer, input);
178 	amixer_set_y(amixer, scale);
179 	amixer_set_sum(amixer, sum);
180 	amixer_commit_write(amixer);
181 	return 0;
182 }
183 
184 static const struct amixer_rsc_ops amixer_ops = {
185 	.set_input		= amixer_set_input,
186 	.set_invalid_squash	= amixer_set_invalid_squash,
187 	.set_scale		= amixer_set_y,
188 	.set_sum		= amixer_set_sum,
189 	.commit_write		= amixer_commit_write,
190 	.commit_raw_write	= amixer_commit_raw_write,
191 	.setup			= amixer_setup,
192 	.get_scale		= amixer_get_y,
193 };
194 
amixer_rsc_init(struct amixer * amixer,const struct amixer_desc * desc,struct amixer_mgr * mgr)195 static int amixer_rsc_init(struct amixer *amixer,
196 			   const struct amixer_desc *desc,
197 			   struct amixer_mgr *mgr)
198 {
199 	int err;
200 
201 	err = rsc_init(&amixer->rsc, amixer->idx[0],
202 			AMIXER, desc->msr, mgr->mgr.hw);
203 	if (err)
204 		return err;
205 
206 	/* Set amixer specific operations */
207 	amixer->rsc.ops = &amixer_basic_rsc_ops;
208 	amixer->ops = &amixer_ops;
209 	amixer->input = NULL;
210 	amixer->sum = NULL;
211 
212 	amixer_setup(amixer, NULL, 0, NULL);
213 
214 	return 0;
215 }
216 
amixer_rsc_uninit(struct amixer * amixer)217 static int amixer_rsc_uninit(struct amixer *amixer)
218 {
219 	amixer_setup(amixer, NULL, 0, NULL);
220 	rsc_uninit(&amixer->rsc);
221 	amixer->ops = NULL;
222 	amixer->input = NULL;
223 	amixer->sum = NULL;
224 	return 0;
225 }
226 
get_amixer_rsc(struct amixer_mgr * mgr,const struct amixer_desc * desc,struct amixer ** ramixer)227 static int get_amixer_rsc(struct amixer_mgr *mgr,
228 			  const struct amixer_desc *desc,
229 			  struct amixer **ramixer)
230 {
231 	int err, i;
232 	unsigned int idx;
233 	struct amixer *amixer;
234 	unsigned long flags;
235 
236 	*ramixer = NULL;
237 
238 	/* Allocate mem for amixer resource */
239 	amixer = kzalloc(sizeof(*amixer), GFP_KERNEL);
240 	if (!amixer)
241 		return -ENOMEM;
242 
243 	/* Check whether there are sufficient
244 	 * amixer resources to meet request. */
245 	err = 0;
246 	spin_lock_irqsave(&mgr->mgr_lock, flags);
247 	for (i = 0; i < desc->msr; i++) {
248 		err = mgr_get_resource(&mgr->mgr, 1, &idx);
249 		if (err)
250 			break;
251 
252 		amixer->idx[i] = idx;
253 	}
254 	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
255 	if (err) {
256 		dev_err(mgr->card->dev,
257 			"Can't meet AMIXER resource request!\n");
258 		goto error;
259 	}
260 
261 	err = amixer_rsc_init(amixer, desc, mgr);
262 	if (err)
263 		goto error;
264 
265 	*ramixer = amixer;
266 
267 	return 0;
268 
269 error:
270 	spin_lock_irqsave(&mgr->mgr_lock, flags);
271 	for (i--; i >= 0; i--)
272 		mgr_put_resource(&mgr->mgr, 1, amixer->idx[i]);
273 
274 	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
275 	kfree(amixer);
276 	return err;
277 }
278 
put_amixer_rsc(struct amixer_mgr * mgr,struct amixer * amixer)279 static int put_amixer_rsc(struct amixer_mgr *mgr, struct amixer *amixer)
280 {
281 	unsigned long flags;
282 	int i;
283 
284 	spin_lock_irqsave(&mgr->mgr_lock, flags);
285 	for (i = 0; i < amixer->rsc.msr; i++)
286 		mgr_put_resource(&mgr->mgr, 1, amixer->idx[i]);
287 
288 	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
289 	amixer_rsc_uninit(amixer);
290 	kfree(amixer);
291 
292 	return 0;
293 }
294 
amixer_mgr_create(struct hw * hw,void ** ramixer_mgr)295 int amixer_mgr_create(struct hw *hw, void **ramixer_mgr)
296 {
297 	int err;
298 	struct amixer_mgr *amixer_mgr;
299 
300 	*ramixer_mgr = NULL;
301 	amixer_mgr = kzalloc(sizeof(*amixer_mgr), GFP_KERNEL);
302 	if (!amixer_mgr)
303 		return -ENOMEM;
304 
305 	err = rsc_mgr_init(&amixer_mgr->mgr, AMIXER, AMIXER_RESOURCE_NUM, hw);
306 	if (err)
307 		goto error;
308 
309 	spin_lock_init(&amixer_mgr->mgr_lock);
310 
311 	amixer_mgr->get_amixer = get_amixer_rsc;
312 	amixer_mgr->put_amixer = put_amixer_rsc;
313 	amixer_mgr->card = hw->card;
314 
315 	*ramixer_mgr = amixer_mgr;
316 
317 	return 0;
318 
319 error:
320 	kfree(amixer_mgr);
321 	return err;
322 }
323 
amixer_mgr_destroy(void * ptr)324 int amixer_mgr_destroy(void *ptr)
325 {
326 	struct amixer_mgr *amixer_mgr = ptr;
327 	rsc_mgr_uninit(&amixer_mgr->mgr);
328 	kfree(amixer_mgr);
329 	return 0;
330 }
331 
332 /* SUM resource management */
333 
sum_master(struct rsc * rsc)334 static void sum_master(struct rsc *rsc)
335 {
336 	rsc->conj = 0;
337 	rsc->idx = container_of(rsc, struct sum, rsc)->idx[0];
338 }
339 
sum_next_conj(struct rsc * rsc)340 static void sum_next_conj(struct rsc *rsc)
341 {
342 	rsc->conj++;
343 }
344 
sum_index(const struct rsc * rsc)345 static int sum_index(const struct rsc *rsc)
346 {
347 	return container_of(rsc, struct sum, rsc)->idx[rsc->conj];
348 }
349 
sum_output_slot(const struct rsc * rsc)350 static int sum_output_slot(const struct rsc *rsc)
351 {
352 	return (sum_index(rsc) << 4) + 0xc;
353 }
354 
355 static const struct rsc_ops sum_basic_rsc_ops = {
356 	.master		= sum_master,
357 	.next_conj	= sum_next_conj,
358 	.index		= sum_index,
359 	.output_slot	= sum_output_slot,
360 };
361 
sum_rsc_init(struct sum * sum,const struct sum_desc * desc,struct sum_mgr * mgr)362 static int sum_rsc_init(struct sum *sum,
363 			const struct sum_desc *desc,
364 			struct sum_mgr *mgr)
365 {
366 	int err;
367 
368 	err = rsc_init(&sum->rsc, sum->idx[0], SUM, desc->msr, mgr->mgr.hw);
369 	if (err)
370 		return err;
371 
372 	sum->rsc.ops = &sum_basic_rsc_ops;
373 
374 	return 0;
375 }
376 
sum_rsc_uninit(struct sum * sum)377 static int sum_rsc_uninit(struct sum *sum)
378 {
379 	rsc_uninit(&sum->rsc);
380 	return 0;
381 }
382 
get_sum_rsc(struct sum_mgr * mgr,const struct sum_desc * desc,struct sum ** rsum)383 static int get_sum_rsc(struct sum_mgr *mgr,
384 		       const struct sum_desc *desc,
385 		       struct sum **rsum)
386 {
387 	int err, i;
388 	unsigned int idx;
389 	struct sum *sum;
390 	unsigned long flags;
391 
392 	*rsum = NULL;
393 
394 	/* Allocate mem for sum resource */
395 	sum = kzalloc(sizeof(*sum), GFP_KERNEL);
396 	if (!sum)
397 		return -ENOMEM;
398 
399 	/* Check whether there are sufficient sum resources to meet request. */
400 	err = 0;
401 	spin_lock_irqsave(&mgr->mgr_lock, flags);
402 	for (i = 0; i < desc->msr; i++) {
403 		err = mgr_get_resource(&mgr->mgr, 1, &idx);
404 		if (err)
405 			break;
406 
407 		sum->idx[i] = idx;
408 	}
409 	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
410 	if (err) {
411 		dev_err(mgr->card->dev,
412 			"Can't meet SUM resource request!\n");
413 		goto error;
414 	}
415 
416 	err = sum_rsc_init(sum, desc, mgr);
417 	if (err)
418 		goto error;
419 
420 	*rsum = sum;
421 
422 	return 0;
423 
424 error:
425 	spin_lock_irqsave(&mgr->mgr_lock, flags);
426 	for (i--; i >= 0; i--)
427 		mgr_put_resource(&mgr->mgr, 1, sum->idx[i]);
428 
429 	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
430 	kfree(sum);
431 	return err;
432 }
433 
put_sum_rsc(struct sum_mgr * mgr,struct sum * sum)434 static int put_sum_rsc(struct sum_mgr *mgr, struct sum *sum)
435 {
436 	unsigned long flags;
437 	int i;
438 
439 	spin_lock_irqsave(&mgr->mgr_lock, flags);
440 	for (i = 0; i < sum->rsc.msr; i++)
441 		mgr_put_resource(&mgr->mgr, 1, sum->idx[i]);
442 
443 	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
444 	sum_rsc_uninit(sum);
445 	kfree(sum);
446 
447 	return 0;
448 }
449 
sum_mgr_create(struct hw * hw,void ** rsum_mgr)450 int sum_mgr_create(struct hw *hw, void **rsum_mgr)
451 {
452 	int err;
453 	struct sum_mgr *sum_mgr;
454 
455 	*rsum_mgr = NULL;
456 	sum_mgr = kzalloc(sizeof(*sum_mgr), GFP_KERNEL);
457 	if (!sum_mgr)
458 		return -ENOMEM;
459 
460 	err = rsc_mgr_init(&sum_mgr->mgr, SUM, SUM_RESOURCE_NUM, hw);
461 	if (err)
462 		goto error;
463 
464 	spin_lock_init(&sum_mgr->mgr_lock);
465 
466 	sum_mgr->get_sum = get_sum_rsc;
467 	sum_mgr->put_sum = put_sum_rsc;
468 	sum_mgr->card = hw->card;
469 
470 	*rsum_mgr = sum_mgr;
471 
472 	return 0;
473 
474 error:
475 	kfree(sum_mgr);
476 	return err;
477 }
478 
sum_mgr_destroy(void * ptr)479 int sum_mgr_destroy(void *ptr)
480 {
481 	struct sum_mgr *sum_mgr = ptr;
482 	rsc_mgr_uninit(&sum_mgr->mgr);
483 	kfree(sum_mgr);
484 	return 0;
485 }
486 
487