xref: /linux/sound/pci/ctxfi/ctsrc.c (revision 1553a1c48281243359a9529a10ddb551f3b967ab) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved.
4  *
5  * @File	ctsrc.c
6  *
7  * @Brief
8  * This file contains the implementation of the Sample Rate Convertor
9  * resource management object.
10  *
11  * @Author	Liu Chun
12  * @Date 	May 13 2008
13  */
14 
15 #include "ctsrc.h"
16 #include "cthardware.h"
17 #include <linux/slab.h>
18 
19 #define SRC_RESOURCE_NUM	256
20 #define SRCIMP_RESOURCE_NUM	256
21 
22 static unsigned int conj_mask;
23 
24 static int src_default_config_memrd(struct src *src);
25 static int src_default_config_memwr(struct src *src);
26 static int src_default_config_arcrw(struct src *src);
27 
28 static int (*src_default_config[3])(struct src *) = {
29 	[MEMRD] = src_default_config_memrd,
30 	[MEMWR] = src_default_config_memwr,
31 	[ARCRW] = src_default_config_arcrw
32 };
33 
34 static int src_set_state(struct src *src, unsigned int state)
35 {
36 	struct hw *hw;
37 
38 	hw = src->rsc.hw;
39 	hw->src_set_state(src->rsc.ctrl_blk, state);
40 
41 	return 0;
42 }
43 
44 static int src_set_bm(struct src *src, unsigned int bm)
45 {
46 	struct hw *hw;
47 
48 	hw = src->rsc.hw;
49 	hw->src_set_bm(src->rsc.ctrl_blk, bm);
50 
51 	return 0;
52 }
53 
54 static int src_set_sf(struct src *src, unsigned int sf)
55 {
56 	struct hw *hw;
57 
58 	hw = src->rsc.hw;
59 	hw->src_set_sf(src->rsc.ctrl_blk, sf);
60 
61 	return 0;
62 }
63 
64 static int src_set_pm(struct src *src, unsigned int pm)
65 {
66 	struct hw *hw;
67 
68 	hw = src->rsc.hw;
69 	hw->src_set_pm(src->rsc.ctrl_blk, pm);
70 
71 	return 0;
72 }
73 
74 static int src_set_rom(struct src *src, unsigned int rom)
75 {
76 	struct hw *hw;
77 
78 	hw = src->rsc.hw;
79 	hw->src_set_rom(src->rsc.ctrl_blk, rom);
80 
81 	return 0;
82 }
83 
84 static int src_set_vo(struct src *src, unsigned int vo)
85 {
86 	struct hw *hw;
87 
88 	hw = src->rsc.hw;
89 	hw->src_set_vo(src->rsc.ctrl_blk, vo);
90 
91 	return 0;
92 }
93 
94 static int src_set_st(struct src *src, unsigned int st)
95 {
96 	struct hw *hw;
97 
98 	hw = src->rsc.hw;
99 	hw->src_set_st(src->rsc.ctrl_blk, st);
100 
101 	return 0;
102 }
103 
104 static int src_set_bp(struct src *src, unsigned int bp)
105 {
106 	struct hw *hw;
107 
108 	hw = src->rsc.hw;
109 	hw->src_set_bp(src->rsc.ctrl_blk, bp);
110 
111 	return 0;
112 }
113 
114 static int src_set_cisz(struct src *src, unsigned int cisz)
115 {
116 	struct hw *hw;
117 
118 	hw = src->rsc.hw;
119 	hw->src_set_cisz(src->rsc.ctrl_blk, cisz);
120 
121 	return 0;
122 }
123 
124 static int src_set_ca(struct src *src, unsigned int ca)
125 {
126 	struct hw *hw;
127 
128 	hw = src->rsc.hw;
129 	hw->src_set_ca(src->rsc.ctrl_blk, ca);
130 
131 	return 0;
132 }
133 
134 static int src_set_sa(struct src *src, unsigned int sa)
135 {
136 	struct hw *hw;
137 
138 	hw = src->rsc.hw;
139 	hw->src_set_sa(src->rsc.ctrl_blk, sa);
140 
141 	return 0;
142 }
143 
144 static int src_set_la(struct src *src, unsigned int la)
145 {
146 	struct hw *hw;
147 
148 	hw = src->rsc.hw;
149 	hw->src_set_la(src->rsc.ctrl_blk, la);
150 
151 	return 0;
152 }
153 
154 static int src_set_pitch(struct src *src, unsigned int pitch)
155 {
156 	struct hw *hw;
157 
158 	hw = src->rsc.hw;
159 	hw->src_set_pitch(src->rsc.ctrl_blk, pitch);
160 
161 	return 0;
162 }
163 
164 static int src_set_clear_zbufs(struct src *src)
165 {
166 	struct hw *hw;
167 
168 	hw = src->rsc.hw;
169 	hw->src_set_clear_zbufs(src->rsc.ctrl_blk, 1);
170 
171 	return 0;
172 }
173 
174 static int src_commit_write(struct src *src)
175 {
176 	struct hw *hw;
177 	int i;
178 	unsigned int dirty = 0;
179 
180 	hw = src->rsc.hw;
181 	src->rsc.ops->master(&src->rsc);
182 	if (src->rsc.msr > 1) {
183 		/* Save dirty flags for conjugate resource programming */
184 		dirty = hw->src_get_dirty(src->rsc.ctrl_blk) & conj_mask;
185 	}
186 	hw->src_commit_write(hw, src->rsc.ops->index(&src->rsc),
187 						src->rsc.ctrl_blk);
188 
189 	/* Program conjugate parameter mixer resources */
190 	if (MEMWR == src->mode)
191 		return 0;
192 
193 	for (i = 1; i < src->rsc.msr; i++) {
194 		src->rsc.ops->next_conj(&src->rsc);
195 		hw->src_set_dirty(src->rsc.ctrl_blk, dirty);
196 		hw->src_commit_write(hw, src->rsc.ops->index(&src->rsc),
197 							src->rsc.ctrl_blk);
198 	}
199 	src->rsc.ops->master(&src->rsc);
200 
201 	return 0;
202 }
203 
204 static int src_get_ca(struct src *src)
205 {
206 	struct hw *hw;
207 
208 	hw = src->rsc.hw;
209 	return hw->src_get_ca(hw, src->rsc.ops->index(&src->rsc),
210 						src->rsc.ctrl_blk);
211 }
212 
213 static int src_init(struct src *src)
214 {
215 	src_default_config[src->mode](src);
216 
217 	return 0;
218 }
219 
220 static struct src *src_next_interleave(struct src *src)
221 {
222 	return src->intlv;
223 }
224 
225 static int src_default_config_memrd(struct src *src)
226 {
227 	struct hw *hw = src->rsc.hw;
228 	unsigned int rsr, msr;
229 
230 	hw->src_set_state(src->rsc.ctrl_blk, SRC_STATE_OFF);
231 	hw->src_set_bm(src->rsc.ctrl_blk, 1);
232 	for (rsr = 0, msr = src->rsc.msr; msr > 1; msr >>= 1)
233 		rsr++;
234 
235 	hw->src_set_rsr(src->rsc.ctrl_blk, rsr);
236 	hw->src_set_sf(src->rsc.ctrl_blk, SRC_SF_S16);
237 	hw->src_set_wr(src->rsc.ctrl_blk, 0);
238 	hw->src_set_pm(src->rsc.ctrl_blk, 0);
239 	hw->src_set_rom(src->rsc.ctrl_blk, 0);
240 	hw->src_set_vo(src->rsc.ctrl_blk, 0);
241 	hw->src_set_st(src->rsc.ctrl_blk, 0);
242 	hw->src_set_ilsz(src->rsc.ctrl_blk, src->multi - 1);
243 	hw->src_set_cisz(src->rsc.ctrl_blk, 0x80);
244 	hw->src_set_sa(src->rsc.ctrl_blk, 0x0);
245 	hw->src_set_la(src->rsc.ctrl_blk, 0x1000);
246 	hw->src_set_ca(src->rsc.ctrl_blk, 0x80);
247 	hw->src_set_pitch(src->rsc.ctrl_blk, 0x1000000);
248 	hw->src_set_clear_zbufs(src->rsc.ctrl_blk, 1);
249 
250 	src->rsc.ops->master(&src->rsc);
251 	hw->src_commit_write(hw, src->rsc.ops->index(&src->rsc),
252 						src->rsc.ctrl_blk);
253 
254 	for (msr = 1; msr < src->rsc.msr; msr++) {
255 		src->rsc.ops->next_conj(&src->rsc);
256 		hw->src_set_pitch(src->rsc.ctrl_blk, 0x1000000);
257 		hw->src_commit_write(hw, src->rsc.ops->index(&src->rsc),
258 							src->rsc.ctrl_blk);
259 	}
260 	src->rsc.ops->master(&src->rsc);
261 
262 	return 0;
263 }
264 
265 static int src_default_config_memwr(struct src *src)
266 {
267 	struct hw *hw = src->rsc.hw;
268 
269 	hw->src_set_state(src->rsc.ctrl_blk, SRC_STATE_OFF);
270 	hw->src_set_bm(src->rsc.ctrl_blk, 1);
271 	hw->src_set_rsr(src->rsc.ctrl_blk, 0);
272 	hw->src_set_sf(src->rsc.ctrl_blk, SRC_SF_S16);
273 	hw->src_set_wr(src->rsc.ctrl_blk, 1);
274 	hw->src_set_pm(src->rsc.ctrl_blk, 0);
275 	hw->src_set_rom(src->rsc.ctrl_blk, 0);
276 	hw->src_set_vo(src->rsc.ctrl_blk, 0);
277 	hw->src_set_st(src->rsc.ctrl_blk, 0);
278 	hw->src_set_ilsz(src->rsc.ctrl_blk, 0);
279 	hw->src_set_cisz(src->rsc.ctrl_blk, 0x80);
280 	hw->src_set_sa(src->rsc.ctrl_blk, 0x0);
281 	hw->src_set_la(src->rsc.ctrl_blk, 0x1000);
282 	hw->src_set_ca(src->rsc.ctrl_blk, 0x80);
283 	hw->src_set_pitch(src->rsc.ctrl_blk, 0x1000000);
284 	hw->src_set_clear_zbufs(src->rsc.ctrl_blk, 1);
285 
286 	src->rsc.ops->master(&src->rsc);
287 	hw->src_commit_write(hw, src->rsc.ops->index(&src->rsc),
288 						src->rsc.ctrl_blk);
289 
290 	return 0;
291 }
292 
293 static int src_default_config_arcrw(struct src *src)
294 {
295 	struct hw *hw = src->rsc.hw;
296 	unsigned int rsr, msr;
297 	unsigned int dirty;
298 
299 	hw->src_set_state(src->rsc.ctrl_blk, SRC_STATE_OFF);
300 	hw->src_set_bm(src->rsc.ctrl_blk, 0);
301 	for (rsr = 0, msr = src->rsc.msr; msr > 1; msr >>= 1)
302 		rsr++;
303 
304 	hw->src_set_rsr(src->rsc.ctrl_blk, rsr);
305 	hw->src_set_sf(src->rsc.ctrl_blk, SRC_SF_F32);
306 	hw->src_set_wr(src->rsc.ctrl_blk, 0);
307 	hw->src_set_pm(src->rsc.ctrl_blk, 0);
308 	hw->src_set_rom(src->rsc.ctrl_blk, 0);
309 	hw->src_set_vo(src->rsc.ctrl_blk, 0);
310 	hw->src_set_st(src->rsc.ctrl_blk, 0);
311 	hw->src_set_ilsz(src->rsc.ctrl_blk, 0);
312 	hw->src_set_cisz(src->rsc.ctrl_blk, 0x80);
313 	hw->src_set_sa(src->rsc.ctrl_blk, 0x0);
314 	/*hw->src_set_sa(src->rsc.ctrl_blk, 0x100);*/
315 	hw->src_set_la(src->rsc.ctrl_blk, 0x1000);
316 	/*hw->src_set_la(src->rsc.ctrl_blk, 0x03ffffe0);*/
317 	hw->src_set_ca(src->rsc.ctrl_blk, 0x80);
318 	hw->src_set_pitch(src->rsc.ctrl_blk, 0x1000000);
319 	hw->src_set_clear_zbufs(src->rsc.ctrl_blk, 1);
320 
321 	dirty = hw->src_get_dirty(src->rsc.ctrl_blk);
322 	src->rsc.ops->master(&src->rsc);
323 	for (msr = 0; msr < src->rsc.msr; msr++) {
324 		hw->src_set_dirty(src->rsc.ctrl_blk, dirty);
325 		hw->src_commit_write(hw, src->rsc.ops->index(&src->rsc),
326 							src->rsc.ctrl_blk);
327 		src->rsc.ops->next_conj(&src->rsc);
328 	}
329 	src->rsc.ops->master(&src->rsc);
330 
331 	return 0;
332 }
333 
334 static const struct src_rsc_ops src_rsc_ops = {
335 	.set_state		= src_set_state,
336 	.set_bm			= src_set_bm,
337 	.set_sf			= src_set_sf,
338 	.set_pm			= src_set_pm,
339 	.set_rom		= src_set_rom,
340 	.set_vo			= src_set_vo,
341 	.set_st			= src_set_st,
342 	.set_bp			= src_set_bp,
343 	.set_cisz		= src_set_cisz,
344 	.set_ca			= src_set_ca,
345 	.set_sa			= src_set_sa,
346 	.set_la			= src_set_la,
347 	.set_pitch		= src_set_pitch,
348 	.set_clr_zbufs		= src_set_clear_zbufs,
349 	.commit_write		= src_commit_write,
350 	.get_ca			= src_get_ca,
351 	.init			= src_init,
352 	.next_interleave	= src_next_interleave,
353 };
354 
355 static int
356 src_rsc_init(struct src *src, u32 idx,
357 	     const struct src_desc *desc, struct src_mgr *mgr)
358 {
359 	int err;
360 	int i, n;
361 	struct src *p;
362 
363 	n = (MEMRD == desc->mode) ? desc->multi : 1;
364 	for (i = 0, p = src; i < n; i++, p++) {
365 		err = rsc_init(&p->rsc, idx + i, SRC, desc->msr, mgr->mgr.hw);
366 		if (err)
367 			goto error1;
368 
369 		/* Initialize src specific rsc operations */
370 		p->ops = &src_rsc_ops;
371 		p->multi = (0 == i) ? desc->multi : 1;
372 		p->mode = desc->mode;
373 		src_default_config[desc->mode](p);
374 		mgr->src_enable(mgr, p);
375 		p->intlv = p + 1;
376 	}
377 	(--p)->intlv = NULL;	/* Set @intlv of the last SRC to NULL */
378 
379 	mgr->commit_write(mgr);
380 
381 	return 0;
382 
383 error1:
384 	for (i--, p--; i >= 0; i--, p--) {
385 		mgr->src_disable(mgr, p);
386 		rsc_uninit(&p->rsc);
387 	}
388 	mgr->commit_write(mgr);
389 	return err;
390 }
391 
392 static int src_rsc_uninit(struct src *src, struct src_mgr *mgr)
393 {
394 	int i, n;
395 	struct src *p;
396 
397 	n = (MEMRD == src->mode) ? src->multi : 1;
398 	for (i = 0, p = src; i < n; i++, p++) {
399 		mgr->src_disable(mgr, p);
400 		rsc_uninit(&p->rsc);
401 		p->multi = 0;
402 		p->ops = NULL;
403 		p->mode = NUM_SRCMODES;
404 		p->intlv = NULL;
405 	}
406 	mgr->commit_write(mgr);
407 
408 	return 0;
409 }
410 
411 static int
412 get_src_rsc(struct src_mgr *mgr, const struct src_desc *desc, struct src **rsrc)
413 {
414 	unsigned int idx = SRC_RESOURCE_NUM;
415 	int err;
416 	struct src *src;
417 	unsigned long flags;
418 
419 	*rsrc = NULL;
420 
421 	/* Check whether there are sufficient src resources to meet request. */
422 	spin_lock_irqsave(&mgr->mgr_lock, flags);
423 	if (MEMRD == desc->mode)
424 		err = mgr_get_resource(&mgr->mgr, desc->multi, &idx);
425 	else
426 		err = mgr_get_resource(&mgr->mgr, 1, &idx);
427 
428 	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
429 	if (err) {
430 		dev_err(mgr->card->dev,
431 			"Can't meet SRC resource request!\n");
432 		return err;
433 	}
434 
435 	/* Allocate mem for master src resource */
436 	if (MEMRD == desc->mode)
437 		src = kcalloc(desc->multi, sizeof(*src), GFP_KERNEL);
438 	else
439 		src = kzalloc(sizeof(*src), GFP_KERNEL);
440 
441 	if (!src) {
442 		err = -ENOMEM;
443 		goto error1;
444 	}
445 
446 	err = src_rsc_init(src, idx, desc, mgr);
447 	if (err)
448 		goto error2;
449 
450 	*rsrc = src;
451 
452 	return 0;
453 
454 error2:
455 	kfree(src);
456 error1:
457 	spin_lock_irqsave(&mgr->mgr_lock, flags);
458 	if (MEMRD == desc->mode)
459 		mgr_put_resource(&mgr->mgr, desc->multi, idx);
460 	else
461 		mgr_put_resource(&mgr->mgr, 1, idx);
462 
463 	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
464 	return err;
465 }
466 
467 static int put_src_rsc(struct src_mgr *mgr, struct src *src)
468 {
469 	unsigned long flags;
470 
471 	spin_lock_irqsave(&mgr->mgr_lock, flags);
472 	src->rsc.ops->master(&src->rsc);
473 	if (MEMRD == src->mode)
474 		mgr_put_resource(&mgr->mgr, src->multi,
475 				 src->rsc.ops->index(&src->rsc));
476 	else
477 		mgr_put_resource(&mgr->mgr, 1, src->rsc.ops->index(&src->rsc));
478 
479 	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
480 	src_rsc_uninit(src, mgr);
481 	kfree(src);
482 
483 	return 0;
484 }
485 
486 static int src_enable_s(struct src_mgr *mgr, struct src *src)
487 {
488 	struct hw *hw = mgr->mgr.hw;
489 	int i;
490 
491 	src->rsc.ops->master(&src->rsc);
492 	for (i = 0; i < src->rsc.msr; i++) {
493 		hw->src_mgr_enbs_src(mgr->mgr.ctrl_blk,
494 				     src->rsc.ops->index(&src->rsc));
495 		src->rsc.ops->next_conj(&src->rsc);
496 	}
497 	src->rsc.ops->master(&src->rsc);
498 
499 	return 0;
500 }
501 
502 static int src_enable(struct src_mgr *mgr, struct src *src)
503 {
504 	struct hw *hw = mgr->mgr.hw;
505 	int i;
506 
507 	src->rsc.ops->master(&src->rsc);
508 	for (i = 0; i < src->rsc.msr; i++) {
509 		hw->src_mgr_enb_src(mgr->mgr.ctrl_blk,
510 				    src->rsc.ops->index(&src->rsc));
511 		src->rsc.ops->next_conj(&src->rsc);
512 	}
513 	src->rsc.ops->master(&src->rsc);
514 
515 	return 0;
516 }
517 
518 static int src_disable(struct src_mgr *mgr, struct src *src)
519 {
520 	struct hw *hw = mgr->mgr.hw;
521 	int i;
522 
523 	src->rsc.ops->master(&src->rsc);
524 	for (i = 0; i < src->rsc.msr; i++) {
525 		hw->src_mgr_dsb_src(mgr->mgr.ctrl_blk,
526 				    src->rsc.ops->index(&src->rsc));
527 		src->rsc.ops->next_conj(&src->rsc);
528 	}
529 	src->rsc.ops->master(&src->rsc);
530 
531 	return 0;
532 }
533 
534 static int src_mgr_commit_write(struct src_mgr *mgr)
535 {
536 	struct hw *hw = mgr->mgr.hw;
537 
538 	hw->src_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
539 
540 	return 0;
541 }
542 
543 int src_mgr_create(struct hw *hw, void **rsrc_mgr)
544 {
545 	int err, i;
546 	struct src_mgr *src_mgr;
547 
548 	*rsrc_mgr = NULL;
549 	src_mgr = kzalloc(sizeof(*src_mgr), GFP_KERNEL);
550 	if (!src_mgr)
551 		return -ENOMEM;
552 
553 	err = rsc_mgr_init(&src_mgr->mgr, SRC, SRC_RESOURCE_NUM, hw);
554 	if (err)
555 		goto error1;
556 
557 	spin_lock_init(&src_mgr->mgr_lock);
558 	conj_mask = hw->src_dirty_conj_mask();
559 
560 	src_mgr->get_src = get_src_rsc;
561 	src_mgr->put_src = put_src_rsc;
562 	src_mgr->src_enable_s = src_enable_s;
563 	src_mgr->src_enable = src_enable;
564 	src_mgr->src_disable = src_disable;
565 	src_mgr->commit_write = src_mgr_commit_write;
566 	src_mgr->card = hw->card;
567 
568 	/* Disable all SRC resources. */
569 	for (i = 0; i < 256; i++)
570 		hw->src_mgr_dsb_src(src_mgr->mgr.ctrl_blk, i);
571 
572 	hw->src_mgr_commit_write(hw, src_mgr->mgr.ctrl_blk);
573 
574 	*rsrc_mgr = src_mgr;
575 
576 	return 0;
577 
578 error1:
579 	kfree(src_mgr);
580 	return err;
581 }
582 
583 int src_mgr_destroy(void *ptr)
584 {
585 	struct src_mgr *src_mgr = ptr;
586 	rsc_mgr_uninit(&src_mgr->mgr);
587 	kfree(src_mgr);
588 
589 	return 0;
590 }
591 
592 /* SRCIMP resource manager operations */
593 
594 static void srcimp_master(struct rsc *rsc)
595 {
596 	rsc->conj = 0;
597 	rsc->idx = container_of(rsc, struct srcimp, rsc)->idx[0];
598 }
599 
600 static void srcimp_next_conj(struct rsc *rsc)
601 {
602 	rsc->conj++;
603 }
604 
605 static int srcimp_index(const struct rsc *rsc)
606 {
607 	return container_of(rsc, struct srcimp, rsc)->idx[rsc->conj];
608 }
609 
610 static const struct rsc_ops srcimp_basic_rsc_ops = {
611 	.master		= srcimp_master,
612 	.next_conj	= srcimp_next_conj,
613 	.index		= srcimp_index,
614 	.output_slot	= NULL,
615 };
616 
617 static int srcimp_map(struct srcimp *srcimp, struct src *src, struct rsc *input)
618 {
619 	struct imapper *entry;
620 	int i;
621 
622 	srcimp->rsc.ops->master(&srcimp->rsc);
623 	src->rsc.ops->master(&src->rsc);
624 	input->ops->master(input);
625 
626 	/* Program master and conjugate resources */
627 	for (i = 0; i < srcimp->rsc.msr; i++) {
628 		entry = &srcimp->imappers[i];
629 		entry->slot = input->ops->output_slot(input);
630 		entry->user = src->rsc.ops->index(&src->rsc);
631 		entry->addr = srcimp->rsc.ops->index(&srcimp->rsc);
632 		srcimp->mgr->imap_add(srcimp->mgr, entry);
633 		srcimp->mapped |= (0x1 << i);
634 
635 		srcimp->rsc.ops->next_conj(&srcimp->rsc);
636 		input->ops->next_conj(input);
637 	}
638 
639 	srcimp->rsc.ops->master(&srcimp->rsc);
640 	input->ops->master(input);
641 
642 	return 0;
643 }
644 
645 static int srcimp_unmap(struct srcimp *srcimp)
646 {
647 	int i;
648 
649 	/* Program master and conjugate resources */
650 	for (i = 0; i < srcimp->rsc.msr; i++) {
651 		if (srcimp->mapped & (0x1 << i)) {
652 			srcimp->mgr->imap_delete(srcimp->mgr,
653 						 &srcimp->imappers[i]);
654 			srcimp->mapped &= ~(0x1 << i);
655 		}
656 	}
657 
658 	return 0;
659 }
660 
661 static const struct srcimp_rsc_ops srcimp_ops = {
662 	.map = srcimp_map,
663 	.unmap = srcimp_unmap
664 };
665 
666 static int srcimp_rsc_init(struct srcimp *srcimp,
667 			   const struct srcimp_desc *desc,
668 			   struct srcimp_mgr *mgr)
669 {
670 	int err;
671 
672 	err = rsc_init(&srcimp->rsc, srcimp->idx[0],
673 		       SRCIMP, desc->msr, mgr->mgr.hw);
674 	if (err)
675 		return err;
676 
677 	/* Reserve memory for imapper nodes */
678 	srcimp->imappers = kcalloc(desc->msr, sizeof(struct imapper),
679 				   GFP_KERNEL);
680 	if (!srcimp->imappers) {
681 		err = -ENOMEM;
682 		goto error1;
683 	}
684 
685 	/* Set srcimp specific operations */
686 	srcimp->rsc.ops = &srcimp_basic_rsc_ops;
687 	srcimp->ops = &srcimp_ops;
688 	srcimp->mgr = mgr;
689 
690 	srcimp->rsc.ops->master(&srcimp->rsc);
691 
692 	return 0;
693 
694 error1:
695 	rsc_uninit(&srcimp->rsc);
696 	return err;
697 }
698 
699 static int srcimp_rsc_uninit(struct srcimp *srcimp)
700 {
701 	kfree(srcimp->imappers);
702 	srcimp->imappers = NULL;
703 	srcimp->ops = NULL;
704 	srcimp->mgr = NULL;
705 	rsc_uninit(&srcimp->rsc);
706 
707 	return 0;
708 }
709 
710 static int get_srcimp_rsc(struct srcimp_mgr *mgr,
711 			  const struct srcimp_desc *desc,
712 			  struct srcimp **rsrcimp)
713 {
714 	int err, i;
715 	unsigned int idx;
716 	struct srcimp *srcimp;
717 	unsigned long flags;
718 
719 	*rsrcimp = NULL;
720 
721 	/* Allocate mem for SRCIMP resource */
722 	srcimp = kzalloc(sizeof(*srcimp), GFP_KERNEL);
723 	if (!srcimp)
724 		return -ENOMEM;
725 
726 	/* Check whether there are sufficient SRCIMP resources. */
727 	err = 0;
728 	spin_lock_irqsave(&mgr->mgr_lock, flags);
729 	for (i = 0; i < desc->msr; i++) {
730 		err = mgr_get_resource(&mgr->mgr, 1, &idx);
731 		if (err)
732 			break;
733 
734 		srcimp->idx[i] = idx;
735 	}
736 	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
737 	if (err) {
738 		dev_err(mgr->card->dev,
739 			"Can't meet SRCIMP resource request!\n");
740 		goto error1;
741 	}
742 
743 	err = srcimp_rsc_init(srcimp, desc, mgr);
744 	if (err)
745 		goto error1;
746 
747 	*rsrcimp = srcimp;
748 
749 	return 0;
750 
751 error1:
752 	spin_lock_irqsave(&mgr->mgr_lock, flags);
753 	for (i--; i >= 0; i--)
754 		mgr_put_resource(&mgr->mgr, 1, srcimp->idx[i]);
755 
756 	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
757 	kfree(srcimp);
758 	return err;
759 }
760 
761 static int put_srcimp_rsc(struct srcimp_mgr *mgr, struct srcimp *srcimp)
762 {
763 	unsigned long flags;
764 	int i;
765 
766 	spin_lock_irqsave(&mgr->mgr_lock, flags);
767 	for (i = 0; i < srcimp->rsc.msr; i++)
768 		mgr_put_resource(&mgr->mgr, 1, srcimp->idx[i]);
769 
770 	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
771 	srcimp_rsc_uninit(srcimp);
772 	kfree(srcimp);
773 
774 	return 0;
775 }
776 
777 static int srcimp_map_op(void *data, struct imapper *entry)
778 {
779 	struct rsc_mgr *mgr = &((struct srcimp_mgr *)data)->mgr;
780 	struct hw *hw = mgr->hw;
781 
782 	hw->srcimp_mgr_set_imaparc(mgr->ctrl_blk, entry->slot);
783 	hw->srcimp_mgr_set_imapuser(mgr->ctrl_blk, entry->user);
784 	hw->srcimp_mgr_set_imapnxt(mgr->ctrl_blk, entry->next);
785 	hw->srcimp_mgr_set_imapaddr(mgr->ctrl_blk, entry->addr);
786 	hw->srcimp_mgr_commit_write(mgr->hw, mgr->ctrl_blk);
787 
788 	return 0;
789 }
790 
791 static int srcimp_imap_add(struct srcimp_mgr *mgr, struct imapper *entry)
792 {
793 	unsigned long flags;
794 	int err;
795 
796 	spin_lock_irqsave(&mgr->imap_lock, flags);
797 	if ((0 == entry->addr) && (mgr->init_imap_added)) {
798 		input_mapper_delete(&mgr->imappers,
799 				    mgr->init_imap, srcimp_map_op, mgr);
800 		mgr->init_imap_added = 0;
801 	}
802 	err = input_mapper_add(&mgr->imappers, entry, srcimp_map_op, mgr);
803 	spin_unlock_irqrestore(&mgr->imap_lock, flags);
804 
805 	return err;
806 }
807 
808 static int srcimp_imap_delete(struct srcimp_mgr *mgr, struct imapper *entry)
809 {
810 	unsigned long flags;
811 	int err;
812 
813 	spin_lock_irqsave(&mgr->imap_lock, flags);
814 	err = input_mapper_delete(&mgr->imappers, entry, srcimp_map_op, mgr);
815 	if (list_empty(&mgr->imappers)) {
816 		input_mapper_add(&mgr->imappers, mgr->init_imap,
817 				 srcimp_map_op, mgr);
818 		mgr->init_imap_added = 1;
819 	}
820 	spin_unlock_irqrestore(&mgr->imap_lock, flags);
821 
822 	return err;
823 }
824 
825 int srcimp_mgr_create(struct hw *hw, void **rsrcimp_mgr)
826 {
827 	int err;
828 	struct srcimp_mgr *srcimp_mgr;
829 	struct imapper *entry;
830 
831 	*rsrcimp_mgr = NULL;
832 	srcimp_mgr = kzalloc(sizeof(*srcimp_mgr), GFP_KERNEL);
833 	if (!srcimp_mgr)
834 		return -ENOMEM;
835 
836 	err = rsc_mgr_init(&srcimp_mgr->mgr, SRCIMP, SRCIMP_RESOURCE_NUM, hw);
837 	if (err)
838 		goto error1;
839 
840 	spin_lock_init(&srcimp_mgr->mgr_lock);
841 	spin_lock_init(&srcimp_mgr->imap_lock);
842 	INIT_LIST_HEAD(&srcimp_mgr->imappers);
843 	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
844 	if (!entry) {
845 		err = -ENOMEM;
846 		goto error2;
847 	}
848 	entry->slot = entry->addr = entry->next = entry->user = 0;
849 	list_add(&entry->list, &srcimp_mgr->imappers);
850 	srcimp_mgr->init_imap = entry;
851 	srcimp_mgr->init_imap_added = 1;
852 
853 	srcimp_mgr->get_srcimp = get_srcimp_rsc;
854 	srcimp_mgr->put_srcimp = put_srcimp_rsc;
855 	srcimp_mgr->imap_add = srcimp_imap_add;
856 	srcimp_mgr->imap_delete = srcimp_imap_delete;
857 	srcimp_mgr->card = hw->card;
858 
859 	*rsrcimp_mgr = srcimp_mgr;
860 
861 	return 0;
862 
863 error2:
864 	rsc_mgr_uninit(&srcimp_mgr->mgr);
865 error1:
866 	kfree(srcimp_mgr);
867 	return err;
868 }
869 
870 int srcimp_mgr_destroy(void *ptr)
871 {
872 	struct srcimp_mgr *srcimp_mgr = ptr;
873 	unsigned long flags;
874 
875 	/* free src input mapper list */
876 	spin_lock_irqsave(&srcimp_mgr->imap_lock, flags);
877 	free_input_mapper_list(&srcimp_mgr->imappers);
878 	spin_unlock_irqrestore(&srcimp_mgr->imap_lock, flags);
879 
880 	rsc_mgr_uninit(&srcimp_mgr->mgr);
881 	kfree(srcimp_mgr);
882 
883 	return 0;
884 }
885