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