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
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
src_set_state(struct src * src,unsigned int state)38 static 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
src_set_bm(struct src * src,unsigned int bm)48 static 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
src_set_sf(struct src * src,unsigned int sf)58 static 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
src_set_pm(struct src * src,unsigned int pm)68 static 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
src_set_rom(struct src * src,unsigned int rom)78 static 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
src_set_vo(struct src * src,unsigned int vo)88 static 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
src_set_st(struct src * src,unsigned int st)98 static 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
src_set_bp(struct src * src,unsigned int bp)108 static 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
src_set_cisz(struct src * src,unsigned int cisz)118 static 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
src_set_ca(struct src * src,unsigned int ca)128 static 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
src_set_sa(struct src * src,unsigned int sa)138 static 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
src_set_la(struct src * src,unsigned int la)148 static 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
src_set_pitch(struct src * src,unsigned int pitch)158 static 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
src_set_clear_zbufs(struct src * src)168 static 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
src_commit_write(struct src * src)178 static 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
src_get_ca(struct src * src)208 static 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
src_init(struct src * src)217 static int src_init(struct src *src)
218 {
219 src_default_config[src->mode](src);
220
221 return 0;
222 }
223
src_next_interleave(struct src * src)224 static struct src *src_next_interleave(struct src *src)
225 {
226 return src->intlv;
227 }
228
src_default_config_memrd(struct src * src)229 static 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
src_default_config_memwr(struct src * src)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
src_default_config_arcrw(struct src * src)297 static 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
338 static 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
359 static int
src_rsc_init(struct src * src,u32 idx,const struct src_desc * desc,struct src_mgr * mgr)360 src_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
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
src_rsc_uninit(struct src * src,struct src_mgr * mgr)396 static 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
415 static int
get_src_rsc(struct src_mgr * mgr,const struct src_desc * desc,struct src ** rsrc)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;
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
458 error2:
459 kfree(src);
460 error1:
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
put_src_rsc(struct src_mgr * mgr,struct src * src)471 static 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
src_enable_s(struct src_mgr * mgr,struct src * src)490 static 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
src_enable(struct src_mgr * mgr,struct src * src)506 static 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
src_disable(struct src_mgr * mgr,struct src * src)522 static 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
src_mgr_commit_write(struct src_mgr * mgr)538 static 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
src_mgr_create(struct hw * hw,struct src_mgr ** rsrc_mgr)547 int 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
582 error1:
583 kfree(src_mgr);
584 return err;
585 }
586
src_mgr_destroy(struct src_mgr * src_mgr)587 int 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
srcimp_master(struct rsc * rsc)597 static void srcimp_master(struct rsc *rsc)
598 {
599 rsc->conj = 0;
600 rsc->idx = container_of(rsc, struct srcimp, rsc)->idx[0];
601 }
602
srcimp_next_conj(struct rsc * rsc)603 static void srcimp_next_conj(struct rsc *rsc)
604 {
605 rsc->conj++;
606 }
607
srcimp_index(const struct rsc * rsc)608 static int srcimp_index(const struct rsc *rsc)
609 {
610 return container_of(rsc, struct srcimp, rsc)->idx[rsc->conj];
611 }
612
613 static const struct rsc_ops srcimp_basic_rsc_ops = {
614 .master = srcimp_master,
615 .next_conj = srcimp_next_conj,
616 .index = srcimp_index,
617 .output_slot = NULL,
618 };
619
srcimp_map(struct srcimp * srcimp,struct src * src,struct rsc * input)620 static int srcimp_map(struct srcimp *srcimp, struct src *src, struct rsc *input)
621 {
622 struct imapper *entry;
623 int i;
624
625 srcimp->rsc.ops->master(&srcimp->rsc);
626 src->rsc.ops->master(&src->rsc);
627 input->ops->master(input);
628
629 /* Program master and conjugate resources */
630 for (i = 0; i < srcimp->rsc.msr; i++) {
631 entry = &srcimp->imappers[i];
632 entry->slot = input->ops->output_slot(input);
633 entry->user = src->rsc.ops->index(&src->rsc);
634 entry->addr = srcimp->rsc.ops->index(&srcimp->rsc);
635 srcimp->mgr->imap_add(srcimp->mgr, entry);
636 srcimp->mapped |= (0x1 << i);
637
638 srcimp->rsc.ops->next_conj(&srcimp->rsc);
639 input->ops->next_conj(input);
640 }
641
642 srcimp->rsc.ops->master(&srcimp->rsc);
643 input->ops->master(input);
644
645 return 0;
646 }
647
srcimp_unmap(struct srcimp * srcimp)648 static int srcimp_unmap(struct srcimp *srcimp)
649 {
650 int i;
651
652 /* Program master and conjugate resources */
653 for (i = 0; i < srcimp->rsc.msr; i++) {
654 if (srcimp->mapped & (0x1 << i)) {
655 srcimp->mgr->imap_delete(srcimp->mgr,
656 &srcimp->imappers[i]);
657 srcimp->mapped &= ~(0x1 << i);
658 }
659 }
660
661 return 0;
662 }
663
664 static const struct srcimp_rsc_ops srcimp_ops = {
665 .map = srcimp_map,
666 .unmap = srcimp_unmap
667 };
668
srcimp_rsc_init(struct srcimp * srcimp,const struct srcimp_desc * desc,struct srcimp_mgr * mgr)669 static int srcimp_rsc_init(struct srcimp *srcimp,
670 const struct srcimp_desc *desc,
671 struct srcimp_mgr *mgr)
672 {
673 int err;
674
675 err = rsc_init(&srcimp->rsc, srcimp->idx[0],
676 SRCIMP, desc->msr, mgr->mgr.hw);
677 if (err)
678 return err;
679
680 /* Reserve memory for imapper nodes */
681 srcimp->imappers = kzalloc(sizeof(struct imapper)*desc->msr,
682 GFP_KERNEL);
683 if (!srcimp->imappers) {
684 err = -ENOMEM;
685 goto error1;
686 }
687
688 /* Set srcimp specific operations */
689 srcimp->rsc.ops = &srcimp_basic_rsc_ops;
690 srcimp->ops = &srcimp_ops;
691 srcimp->mgr = mgr;
692
693 srcimp->rsc.ops->master(&srcimp->rsc);
694
695 return 0;
696
697 error1:
698 rsc_uninit(&srcimp->rsc);
699 return err;
700 }
701
srcimp_rsc_uninit(struct srcimp * srcimp)702 static int srcimp_rsc_uninit(struct srcimp *srcimp)
703 {
704 if (NULL != srcimp->imappers) {
705 kfree(srcimp->imappers);
706 srcimp->imappers = NULL;
707 }
708 srcimp->ops = NULL;
709 srcimp->mgr = NULL;
710 rsc_uninit(&srcimp->rsc);
711
712 return 0;
713 }
714
get_srcimp_rsc(struct srcimp_mgr * mgr,const struct srcimp_desc * desc,struct srcimp ** rsrcimp)715 static int get_srcimp_rsc(struct srcimp_mgr *mgr,
716 const struct srcimp_desc *desc,
717 struct srcimp **rsrcimp)
718 {
719 int err, i;
720 unsigned int idx;
721 struct srcimp *srcimp;
722 unsigned long flags;
723
724 *rsrcimp = NULL;
725
726 /* Allocate mem for SRCIMP resource */
727 srcimp = kzalloc(sizeof(*srcimp), GFP_KERNEL);
728 if (!srcimp)
729 return -ENOMEM;
730
731 /* Check whether there are sufficient SRCIMP resources. */
732 err = 0;
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 dev_err(mgr->card->dev,
744 "Can't meet SRCIMP resource request!\n");
745 goto error1;
746 }
747
748 err = srcimp_rsc_init(srcimp, desc, mgr);
749 if (err)
750 goto error1;
751
752 *rsrcimp = srcimp;
753
754 return 0;
755
756 error1:
757 spin_lock_irqsave(&mgr->mgr_lock, flags);
758 for (i--; i >= 0; i--)
759 mgr_put_resource(&mgr->mgr, 1, srcimp->idx[i]);
760
761 spin_unlock_irqrestore(&mgr->mgr_lock, flags);
762 kfree(srcimp);
763 return err;
764 }
765
put_srcimp_rsc(struct srcimp_mgr * mgr,struct srcimp * srcimp)766 static int put_srcimp_rsc(struct srcimp_mgr *mgr, struct srcimp *srcimp)
767 {
768 unsigned long flags;
769 int i;
770
771 spin_lock_irqsave(&mgr->mgr_lock, flags);
772 for (i = 0; i < srcimp->rsc.msr; i++)
773 mgr_put_resource(&mgr->mgr, 1, srcimp->idx[i]);
774
775 spin_unlock_irqrestore(&mgr->mgr_lock, flags);
776 srcimp_rsc_uninit(srcimp);
777 kfree(srcimp);
778
779 return 0;
780 }
781
srcimp_map_op(void * data,struct imapper * entry)782 static int srcimp_map_op(void *data, struct imapper *entry)
783 {
784 struct rsc_mgr *mgr = &((struct srcimp_mgr *)data)->mgr;
785 struct hw *hw = mgr->hw;
786
787 hw->srcimp_mgr_set_imaparc(mgr->ctrl_blk, entry->slot);
788 hw->srcimp_mgr_set_imapuser(mgr->ctrl_blk, entry->user);
789 hw->srcimp_mgr_set_imapnxt(mgr->ctrl_blk, entry->next);
790 hw->srcimp_mgr_set_imapaddr(mgr->ctrl_blk, entry->addr);
791 hw->srcimp_mgr_commit_write(mgr->hw, mgr->ctrl_blk);
792
793 return 0;
794 }
795
srcimp_imap_add(struct srcimp_mgr * mgr,struct imapper * entry)796 static int srcimp_imap_add(struct srcimp_mgr *mgr, struct imapper *entry)
797 {
798 unsigned long flags;
799 int err;
800
801 spin_lock_irqsave(&mgr->imap_lock, flags);
802 if ((0 == entry->addr) && (mgr->init_imap_added)) {
803 input_mapper_delete(&mgr->imappers,
804 mgr->init_imap, srcimp_map_op, mgr);
805 mgr->init_imap_added = 0;
806 }
807 err = input_mapper_add(&mgr->imappers, entry, srcimp_map_op, mgr);
808 spin_unlock_irqrestore(&mgr->imap_lock, flags);
809
810 return err;
811 }
812
srcimp_imap_delete(struct srcimp_mgr * mgr,struct imapper * entry)813 static int srcimp_imap_delete(struct srcimp_mgr *mgr, struct imapper *entry)
814 {
815 unsigned long flags;
816 int err;
817
818 spin_lock_irqsave(&mgr->imap_lock, flags);
819 err = input_mapper_delete(&mgr->imappers, entry, srcimp_map_op, mgr);
820 if (list_empty(&mgr->imappers)) {
821 input_mapper_add(&mgr->imappers, mgr->init_imap,
822 srcimp_map_op, mgr);
823 mgr->init_imap_added = 1;
824 }
825 spin_unlock_irqrestore(&mgr->imap_lock, flags);
826
827 return err;
828 }
829
srcimp_mgr_create(struct hw * hw,struct srcimp_mgr ** rsrcimp_mgr)830 int srcimp_mgr_create(struct hw *hw, struct srcimp_mgr **rsrcimp_mgr)
831 {
832 int err;
833 struct srcimp_mgr *srcimp_mgr;
834 struct imapper *entry;
835
836 *rsrcimp_mgr = NULL;
837 srcimp_mgr = kzalloc(sizeof(*srcimp_mgr), GFP_KERNEL);
838 if (!srcimp_mgr)
839 return -ENOMEM;
840
841 err = rsc_mgr_init(&srcimp_mgr->mgr, SRCIMP, SRCIMP_RESOURCE_NUM, hw);
842 if (err)
843 goto error1;
844
845 spin_lock_init(&srcimp_mgr->mgr_lock);
846 spin_lock_init(&srcimp_mgr->imap_lock);
847 INIT_LIST_HEAD(&srcimp_mgr->imappers);
848 entry = kzalloc(sizeof(*entry), GFP_KERNEL);
849 if (!entry) {
850 err = -ENOMEM;
851 goto error2;
852 }
853 entry->slot = entry->addr = entry->next = entry->user = 0;
854 list_add(&entry->list, &srcimp_mgr->imappers);
855 srcimp_mgr->init_imap = entry;
856 srcimp_mgr->init_imap_added = 1;
857
858 srcimp_mgr->get_srcimp = get_srcimp_rsc;
859 srcimp_mgr->put_srcimp = put_srcimp_rsc;
860 srcimp_mgr->imap_add = srcimp_imap_add;
861 srcimp_mgr->imap_delete = srcimp_imap_delete;
862 srcimp_mgr->card = hw->card;
863
864 *rsrcimp_mgr = srcimp_mgr;
865
866 return 0;
867
868 error2:
869 rsc_mgr_uninit(&srcimp_mgr->mgr);
870 error1:
871 kfree(srcimp_mgr);
872 return err;
873 }
874
srcimp_mgr_destroy(struct srcimp_mgr * srcimp_mgr)875 int srcimp_mgr_destroy(struct srcimp_mgr *srcimp_mgr)
876 {
877 unsigned long flags;
878
879 /* free src input mapper list */
880 spin_lock_irqsave(&srcimp_mgr->imap_lock, flags);
881 free_input_mapper_list(&srcimp_mgr->imappers);
882 spin_unlock_irqrestore(&srcimp_mgr->imap_lock, flags);
883
884 rsc_mgr_uninit(&srcimp_mgr->mgr);
885 kfree(srcimp_mgr);
886
887 return 0;
888 }
889