diff options
Diffstat (limited to 'sound/pci/ctxfi/ctsrc.c')
-rw-r--r-- | sound/pci/ctxfi/ctsrc.c | 886 |
1 files changed, 886 insertions, 0 deletions
diff --git a/sound/pci/ctxfi/ctsrc.c b/sound/pci/ctxfi/ctsrc.c new file mode 100644 index 000000000000..d3e0ad5ed9fb --- /dev/null +++ b/sound/pci/ctxfi/ctsrc.c | |||
@@ -0,0 +1,886 @@ | |||
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 64 | ||
24 | #define SRCIMP_RESOURCE_NUM 256 | ||
25 | |||
26 | static unsigned int conj_mask; | ||
27 | |||
28 | static int src_default_config_memrd(struct src *src); | ||
29 | static int src_default_config_memwr(struct src *src); | ||
30 | static int src_default_config_arcrw(struct src *src); | ||
31 | |||
32 | static 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 | |||
38 | static int src_set_state(struct src *src, unsigned int state) | ||
39 | { | ||
40 | struct hw *hw = NULL; | ||
41 | |||
42 | hw = (struct hw *)src->rsc.hw; | ||
43 | hw->src_set_state(src->rsc.ctrl_blk, state); | ||
44 | |||
45 | return 0; | ||
46 | } | ||
47 | |||
48 | static int src_set_bm(struct src *src, unsigned int bm) | ||
49 | { | ||
50 | struct hw *hw = NULL; | ||
51 | |||
52 | hw = (struct hw *)src->rsc.hw; | ||
53 | hw->src_set_bm(src->rsc.ctrl_blk, bm); | ||
54 | |||
55 | return 0; | ||
56 | } | ||
57 | |||
58 | static int src_set_sf(struct src *src, unsigned int sf) | ||
59 | { | ||
60 | struct hw *hw = NULL; | ||
61 | |||
62 | hw = (struct hw *)src->rsc.hw; | ||
63 | hw->src_set_sf(src->rsc.ctrl_blk, sf); | ||
64 | |||
65 | return 0; | ||
66 | } | ||
67 | |||
68 | static int src_set_pm(struct src *src, unsigned int pm) | ||
69 | { | ||
70 | struct hw *hw = NULL; | ||
71 | |||
72 | hw = (struct hw *)src->rsc.hw; | ||
73 | hw->src_set_pm(src->rsc.ctrl_blk, pm); | ||
74 | |||
75 | return 0; | ||
76 | } | ||
77 | |||
78 | static int src_set_rom(struct src *src, unsigned int rom) | ||
79 | { | ||
80 | struct hw *hw = NULL; | ||
81 | |||
82 | hw = (struct hw *)src->rsc.hw; | ||
83 | hw->src_set_rom(src->rsc.ctrl_blk, rom); | ||
84 | |||
85 | return 0; | ||
86 | } | ||
87 | |||
88 | static int src_set_vo(struct src *src, unsigned int vo) | ||
89 | { | ||
90 | struct hw *hw = NULL; | ||
91 | |||
92 | hw = (struct hw *)src->rsc.hw; | ||
93 | hw->src_set_vo(src->rsc.ctrl_blk, vo); | ||
94 | |||
95 | return 0; | ||
96 | } | ||
97 | |||
98 | static int src_set_st(struct src *src, unsigned int st) | ||
99 | { | ||
100 | struct hw *hw = NULL; | ||
101 | |||
102 | hw = (struct hw *)src->rsc.hw; | ||
103 | hw->src_set_st(src->rsc.ctrl_blk, st); | ||
104 | |||
105 | return 0; | ||
106 | } | ||
107 | |||
108 | static int src_set_bp(struct src *src, unsigned int bp) | ||
109 | { | ||
110 | struct hw *hw = NULL; | ||
111 | |||
112 | hw = (struct hw *)src->rsc.hw; | ||
113 | hw->src_set_bp(src->rsc.ctrl_blk, bp); | ||
114 | |||
115 | return 0; | ||
116 | } | ||
117 | |||
118 | static int src_set_cisz(struct src *src, unsigned int cisz) | ||
119 | { | ||
120 | struct hw *hw = NULL; | ||
121 | |||
122 | hw = (struct hw *)src->rsc.hw; | ||
123 | hw->src_set_cisz(src->rsc.ctrl_blk, cisz); | ||
124 | |||
125 | return 0; | ||
126 | } | ||
127 | |||
128 | static int src_set_ca(struct src *src, unsigned int ca) | ||
129 | { | ||
130 | struct hw *hw = NULL; | ||
131 | |||
132 | hw = (struct hw *)src->rsc.hw; | ||
133 | hw->src_set_ca(src->rsc.ctrl_blk, ca); | ||
134 | |||
135 | return 0; | ||
136 | } | ||
137 | |||
138 | static int src_set_sa(struct src *src, unsigned int sa) | ||
139 | { | ||
140 | struct hw *hw = NULL; | ||
141 | |||
142 | hw = (struct hw *)src->rsc.hw; | ||
143 | hw->src_set_sa(src->rsc.ctrl_blk, sa); | ||
144 | |||
145 | return 0; | ||
146 | } | ||
147 | |||
148 | static int src_set_la(struct src *src, unsigned int la) | ||
149 | { | ||
150 | struct hw *hw = NULL; | ||
151 | |||
152 | hw = (struct hw *)src->rsc.hw; | ||
153 | hw->src_set_la(src->rsc.ctrl_blk, la); | ||
154 | |||
155 | return 0; | ||
156 | } | ||
157 | |||
158 | static int src_set_pitch(struct src *src, unsigned int pitch) | ||
159 | { | ||
160 | struct hw *hw = NULL; | ||
161 | |||
162 | hw = (struct hw *)src->rsc.hw; | ||
163 | hw->src_set_pitch(src->rsc.ctrl_blk, pitch); | ||
164 | |||
165 | return 0; | ||
166 | } | ||
167 | |||
168 | static int src_set_clear_zbufs(struct src *src) | ||
169 | { | ||
170 | struct hw *hw = NULL; | ||
171 | |||
172 | hw = (struct hw *)src->rsc.hw; | ||
173 | hw->src_set_clear_zbufs(src->rsc.ctrl_blk, 1); | ||
174 | |||
175 | return 0; | ||
176 | } | ||
177 | |||
178 | static int src_commit_write(struct src *src) | ||
179 | { | ||
180 | struct hw *hw = NULL; | ||
181 | int i = 0; | ||
182 | unsigned int dirty = 0; | ||
183 | |||
184 | hw = (struct 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 | |||
208 | static int src_get_ca(struct src *src) | ||
209 | { | ||
210 | struct hw *hw = NULL; | ||
211 | |||
212 | hw = (struct hw *)src->rsc.hw; | ||
213 | return hw->src_get_ca(hw, src->rsc.ops->index(&src->rsc), | ||
214 | src->rsc.ctrl_blk); | ||
215 | } | ||
216 | |||
217 | static int src_init(struct src *src) | ||
218 | { | ||
219 | src_default_config[src->mode](src); | ||
220 | |||
221 | return 0; | ||
222 | } | ||
223 | |||
224 | static struct src *src_next_interleave(struct src *src) | ||
225 | { | ||
226 | return src->intlv; | ||
227 | } | ||
228 | |||
229 | static int src_default_config_memrd(struct src *src) | ||
230 | { | ||
231 | struct hw *hw = src->rsc.hw; | ||
232 | unsigned int rsr = 0, msr = 0; | ||
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 | |||
269 | static 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 | |||
297 | static int src_default_config_arcrw(struct src *src) | ||
298 | { | ||
299 | struct hw *hw = src->rsc.hw; | ||
300 | unsigned int rsr = 0, msr = 0; | ||
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 | |||
338 | static 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 | |||
359 | static int | ||
360 | src_rsc_init(struct src *src, u32 idx, | ||
361 | const struct src_desc *desc, struct src_mgr *mgr) | ||
362 | { | ||
363 | int err = 0; | ||
364 | int i = 0, n = 0; | ||
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 | |||
387 | error1: | ||
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 | |||
396 | static int src_rsc_uninit(struct src *src, struct src_mgr *mgr) | ||
397 | { | ||
398 | int i = 0, n = 0; | ||
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 | |||
415 | static int | ||
416 | get_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 = 0; | ||
420 | struct src *src = NULL; | ||
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 | printk(KERN_ERR "Can't meet SRC resource request!\n"); | ||
435 | return err; | ||
436 | } | ||
437 | |||
438 | /* Allocate mem for master src resource */ | ||
439 | if (MEMRD == desc->mode) | ||
440 | src = kzalloc(sizeof(*src)*desc->multi, GFP_KERNEL); | ||
441 | else | ||
442 | src = kzalloc(sizeof(*src), GFP_KERNEL); | ||
443 | |||
444 | if (NULL == src) { | ||
445 | err = -ENOMEM; | ||
446 | goto error1; | ||
447 | } | ||
448 | |||
449 | err = src_rsc_init(src, idx, desc, mgr); | ||
450 | if (err) | ||
451 | goto error2; | ||
452 | |||
453 | *rsrc = src; | ||
454 | |||
455 | return 0; | ||
456 | |||
457 | error2: | ||
458 | kfree(src); | ||
459 | error1: | ||
460 | spin_lock_irqsave(&mgr->mgr_lock, flags); | ||
461 | if (MEMRD == desc->mode) | ||
462 | mgr_put_resource(&mgr->mgr, desc->multi, idx); | ||
463 | else | ||
464 | mgr_put_resource(&mgr->mgr, 1, idx); | ||
465 | |||
466 | spin_unlock_irqrestore(&mgr->mgr_lock, flags); | ||
467 | return err; | ||
468 | } | ||
469 | |||
470 | static int put_src_rsc(struct src_mgr *mgr, struct src *src) | ||
471 | { | ||
472 | unsigned long flags; | ||
473 | |||
474 | spin_lock_irqsave(&mgr->mgr_lock, flags); | ||
475 | src->rsc.ops->master(&src->rsc); | ||
476 | if (MEMRD == src->mode) | ||
477 | mgr_put_resource(&mgr->mgr, src->multi, | ||
478 | src->rsc.ops->index(&src->rsc)); | ||
479 | else | ||
480 | mgr_put_resource(&mgr->mgr, 1, src->rsc.ops->index(&src->rsc)); | ||
481 | |||
482 | spin_unlock_irqrestore(&mgr->mgr_lock, flags); | ||
483 | src_rsc_uninit(src, mgr); | ||
484 | kfree(src); | ||
485 | |||
486 | return 0; | ||
487 | } | ||
488 | |||
489 | static int src_enable_s(struct src_mgr *mgr, struct src *src) | ||
490 | { | ||
491 | struct hw *hw = mgr->mgr.hw; | ||
492 | int i = 0; | ||
493 | |||
494 | src->rsc.ops->master(&src->rsc); | ||
495 | for (i = 0; i < src->rsc.msr; i++) { | ||
496 | hw->src_mgr_enbs_src(mgr->mgr.ctrl_blk, | ||
497 | src->rsc.ops->index(&src->rsc)); | ||
498 | src->rsc.ops->next_conj(&src->rsc); | ||
499 | } | ||
500 | src->rsc.ops->master(&src->rsc); | ||
501 | |||
502 | return 0; | ||
503 | } | ||
504 | |||
505 | static int src_enable(struct src_mgr *mgr, struct src *src) | ||
506 | { | ||
507 | struct hw *hw = mgr->mgr.hw; | ||
508 | int i = 0; | ||
509 | |||
510 | src->rsc.ops->master(&src->rsc); | ||
511 | for (i = 0; i < src->rsc.msr; i++) { | ||
512 | hw->src_mgr_enb_src(mgr->mgr.ctrl_blk, | ||
513 | src->rsc.ops->index(&src->rsc)); | ||
514 | src->rsc.ops->next_conj(&src->rsc); | ||
515 | } | ||
516 | src->rsc.ops->master(&src->rsc); | ||
517 | |||
518 | return 0; | ||
519 | } | ||
520 | |||
521 | static int src_disable(struct src_mgr *mgr, struct src *src) | ||
522 | { | ||
523 | struct hw *hw = mgr->mgr.hw; | ||
524 | int i = 0; | ||
525 | |||
526 | src->rsc.ops->master(&src->rsc); | ||
527 | for (i = 0; i < src->rsc.msr; i++) { | ||
528 | hw->src_mgr_dsb_src(mgr->mgr.ctrl_blk, | ||
529 | src->rsc.ops->index(&src->rsc)); | ||
530 | src->rsc.ops->next_conj(&src->rsc); | ||
531 | } | ||
532 | src->rsc.ops->master(&src->rsc); | ||
533 | |||
534 | return 0; | ||
535 | } | ||
536 | |||
537 | static int src_mgr_commit_write(struct src_mgr *mgr) | ||
538 | { | ||
539 | struct hw *hw = mgr->mgr.hw; | ||
540 | |||
541 | hw->src_mgr_commit_write(hw, mgr->mgr.ctrl_blk); | ||
542 | |||
543 | return 0; | ||
544 | } | ||
545 | |||
546 | int src_mgr_create(void *hw, struct src_mgr **rsrc_mgr) | ||
547 | { | ||
548 | int err = 0, i = 0; | ||
549 | struct src_mgr *src_mgr; | ||
550 | |||
551 | *rsrc_mgr = NULL; | ||
552 | src_mgr = kzalloc(sizeof(*src_mgr), GFP_KERNEL); | ||
553 | if (NULL == src_mgr) | ||
554 | return -ENOMEM; | ||
555 | |||
556 | err = rsc_mgr_init(&src_mgr->mgr, SRC, SRC_RESOURCE_NUM, hw); | ||
557 | if (err) | ||
558 | goto error1; | ||
559 | |||
560 | spin_lock_init(&src_mgr->mgr_lock); | ||
561 | conj_mask = ((struct hw *)hw)->src_dirty_conj_mask(); | ||
562 | |||
563 | src_mgr->get_src = get_src_rsc; | ||
564 | src_mgr->put_src = put_src_rsc; | ||
565 | src_mgr->src_enable_s = src_enable_s; | ||
566 | src_mgr->src_enable = src_enable; | ||
567 | src_mgr->src_disable = src_disable; | ||
568 | src_mgr->commit_write = src_mgr_commit_write; | ||
569 | |||
570 | /* Disable all SRC resources. */ | ||
571 | for (i = 0; i < 256; i++) | ||
572 | ((struct hw *)hw)->src_mgr_dsb_src(src_mgr->mgr.ctrl_blk, i); | ||
573 | |||
574 | ((struct hw *)hw)->src_mgr_commit_write(hw, src_mgr->mgr.ctrl_blk); | ||
575 | |||
576 | *rsrc_mgr = src_mgr; | ||
577 | |||
578 | return 0; | ||
579 | |||
580 | error1: | ||
581 | kfree(src_mgr); | ||
582 | return err; | ||
583 | } | ||
584 | |||
585 | int src_mgr_destroy(struct src_mgr *src_mgr) | ||
586 | { | ||
587 | rsc_mgr_uninit(&src_mgr->mgr); | ||
588 | kfree(src_mgr); | ||
589 | |||
590 | return 0; | ||
591 | } | ||
592 | |||
593 | /* SRCIMP resource manager operations */ | ||
594 | |||
595 | static int srcimp_master(struct rsc *rsc) | ||
596 | { | ||
597 | rsc->conj = 0; | ||
598 | return rsc->idx = container_of(rsc, struct srcimp, rsc)->idx[0]; | ||
599 | } | ||
600 | |||
601 | static int srcimp_next_conj(struct rsc *rsc) | ||
602 | { | ||
603 | rsc->conj++; | ||
604 | return container_of(rsc, struct srcimp, rsc)->idx[rsc->conj]; | ||
605 | } | ||
606 | |||
607 | static int srcimp_index(const struct rsc *rsc) | ||
608 | { | ||
609 | return container_of(rsc, struct srcimp, rsc)->idx[rsc->conj]; | ||
610 | } | ||
611 | |||
612 | static struct rsc_ops srcimp_basic_rsc_ops = { | ||
613 | .master = srcimp_master, | ||
614 | .next_conj = srcimp_next_conj, | ||
615 | .index = srcimp_index, | ||
616 | .output_slot = NULL, | ||
617 | }; | ||
618 | |||
619 | static int srcimp_map(struct srcimp *srcimp, struct src *src, struct rsc *input) | ||
620 | { | ||
621 | struct imapper *entry = NULL; | ||
622 | int i = 0; | ||
623 | |||
624 | srcimp->rsc.ops->master(&srcimp->rsc); | ||
625 | src->rsc.ops->master(&src->rsc); | ||
626 | input->ops->master(input); | ||
627 | |||
628 | /* Program master and conjugate resources */ | ||
629 | for (i = 0; i < srcimp->rsc.msr; i++) { | ||
630 | entry = &srcimp->imappers[i]; | ||
631 | entry->slot = input->ops->output_slot(input); | ||
632 | entry->user = src->rsc.ops->index(&src->rsc); | ||
633 | entry->addr = srcimp->rsc.ops->index(&srcimp->rsc); | ||
634 | srcimp->mgr->imap_add(srcimp->mgr, entry); | ||
635 | srcimp->mapped |= (0x1 << i); | ||
636 | |||
637 | srcimp->rsc.ops->next_conj(&srcimp->rsc); | ||
638 | input->ops->next_conj(input); | ||
639 | } | ||
640 | |||
641 | srcimp->rsc.ops->master(&srcimp->rsc); | ||
642 | input->ops->master(input); | ||
643 | |||
644 | return 0; | ||
645 | } | ||
646 | |||
647 | static int srcimp_unmap(struct srcimp *srcimp) | ||
648 | { | ||
649 | int i = 0; | ||
650 | |||
651 | /* Program master and conjugate resources */ | ||
652 | for (i = 0; i < srcimp->rsc.msr; i++) { | ||
653 | if (srcimp->mapped & (0x1 << i)) { | ||
654 | srcimp->mgr->imap_delete(srcimp->mgr, | ||
655 | &srcimp->imappers[i]); | ||
656 | srcimp->mapped &= ~(0x1 << i); | ||
657 | } | ||
658 | } | ||
659 | |||
660 | return 0; | ||
661 | } | ||
662 | |||
663 | static struct srcimp_rsc_ops srcimp_ops = { | ||
664 | .map = srcimp_map, | ||
665 | .unmap = srcimp_unmap | ||
666 | }; | ||
667 | |||
668 | static int srcimp_rsc_init(struct srcimp *srcimp, | ||
669 | const struct srcimp_desc *desc, | ||
670 | struct srcimp_mgr *mgr) | ||
671 | { | ||
672 | int err = 0; | ||
673 | |||
674 | err = rsc_init(&srcimp->rsc, srcimp->idx[0], | ||
675 | SRCIMP, desc->msr, mgr->mgr.hw); | ||
676 | if (err) | ||
677 | return err; | ||
678 | |||
679 | /* Reserve memory for imapper nodes */ | ||
680 | srcimp->imappers = kzalloc(sizeof(struct imapper)*desc->msr, | ||
681 | GFP_KERNEL); | ||
682 | if (NULL == srcimp->imappers) { | ||
683 | err = -ENOMEM; | ||
684 | goto error1; | ||
685 | } | ||
686 | |||
687 | /* Set srcimp specific operations */ | ||
688 | srcimp->rsc.ops = &srcimp_basic_rsc_ops; | ||
689 | srcimp->ops = &srcimp_ops; | ||
690 | srcimp->mgr = mgr; | ||
691 | |||
692 | srcimp->rsc.ops->master(&srcimp->rsc); | ||
693 | |||
694 | return 0; | ||
695 | |||
696 | error1: | ||
697 | rsc_uninit(&srcimp->rsc); | ||
698 | return err; | ||
699 | } | ||
700 | |||
701 | static int srcimp_rsc_uninit(struct srcimp *srcimp) | ||
702 | { | ||
703 | if (NULL != srcimp->imappers) { | ||
704 | kfree(srcimp->imappers); | ||
705 | srcimp->imappers = NULL; | ||
706 | } | ||
707 | srcimp->ops = NULL; | ||
708 | srcimp->mgr = NULL; | ||
709 | rsc_uninit(&srcimp->rsc); | ||
710 | |||
711 | return 0; | ||
712 | } | ||
713 | |||
714 | static int get_srcimp_rsc(struct srcimp_mgr *mgr, | ||
715 | const struct srcimp_desc *desc, | ||
716 | struct srcimp **rsrcimp) | ||
717 | { | ||
718 | int err = 0, i = 0; | ||
719 | unsigned int idx = 0; | ||
720 | struct srcimp *srcimp = NULL; | ||
721 | unsigned long flags; | ||
722 | |||
723 | *rsrcimp = NULL; | ||
724 | |||
725 | /* Allocate mem for SRCIMP resource */ | ||
726 | srcimp = kzalloc(sizeof(*srcimp), GFP_KERNEL); | ||
727 | if (NULL == srcimp) { | ||
728 | err = -ENOMEM; | ||
729 | return err; | ||
730 | } | ||
731 | |||
732 | /* Check whether there are sufficient SRCIMP resources. */ | ||
733 | spin_lock_irqsave(&mgr->mgr_lock, flags); | ||
734 | for (i = 0; i < desc->msr; i++) { | ||
735 | err = mgr_get_resource(&mgr->mgr, 1, &idx); | ||
736 | if (err) | ||
737 | break; | ||
738 | |||
739 | srcimp->idx[i] = idx; | ||
740 | } | ||
741 | spin_unlock_irqrestore(&mgr->mgr_lock, flags); | ||
742 | if (err) { | ||
743 | printk(KERN_ERR "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 | |||
755 | error1: | ||
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 | |||
765 | static int put_srcimp_rsc(struct srcimp_mgr *mgr, struct srcimp *srcimp) | ||
766 | { | ||
767 | unsigned long flags; | ||
768 | int i = 0; | ||
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 | |||
781 | static 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 | |||
795 | static int srcimp_imap_add(struct srcimp_mgr *mgr, struct imapper *entry) | ||
796 | { | ||
797 | unsigned long flags; | ||
798 | int err = 0; | ||
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 | |||
812 | static int srcimp_imap_delete(struct srcimp_mgr *mgr, struct imapper *entry) | ||
813 | { | ||
814 | unsigned long flags; | ||
815 | int err = 0; | ||
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 | |||
829 | int srcimp_mgr_create(void *hw, struct srcimp_mgr **rsrcimp_mgr) | ||
830 | { | ||
831 | int err = 0; | ||
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 (NULL == 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 (NULL == 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 | |||
862 | *rsrcimp_mgr = srcimp_mgr; | ||
863 | |||
864 | return 0; | ||
865 | |||
866 | error2: | ||
867 | rsc_mgr_uninit(&srcimp_mgr->mgr); | ||
868 | error1: | ||
869 | kfree(srcimp_mgr); | ||
870 | return err; | ||
871 | } | ||
872 | |||
873 | int srcimp_mgr_destroy(struct srcimp_mgr *srcimp_mgr) | ||
874 | { | ||
875 | unsigned long flags; | ||
876 | |||
877 | /* free src input mapper list */ | ||
878 | spin_lock_irqsave(&srcimp_mgr->imap_lock, flags); | ||
879 | free_input_mapper_list(&srcimp_mgr->imappers); | ||
880 | spin_unlock_irqrestore(&srcimp_mgr->imap_lock, flags); | ||
881 | |||
882 | rsc_mgr_uninit(&srcimp_mgr->mgr); | ||
883 | kfree(srcimp_mgr); | ||
884 | |||
885 | return 0; | ||
886 | } | ||