Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/**
3 * Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved.
4 *
5 * @File ctdaio.c
6 *
7 * @Brief
8 * This file contains the implementation of Digital Audio Input Output
9 * resource management object.
10 *
11 * @Author Liu Chun
12 * @Date May 23 2008
13 */
14
15#include "ctdaio.h"
16#include "cthardware.h"
17#include "ctimap.h"
18#include <linux/slab.h>
19#include <linux/kernel.h>
20
21#define DAIO_OUT_MAX SPDIFOO
22
23struct daio_usage {
24 unsigned short data;
25};
26
27struct daio_rsc_idx {
28 unsigned short left;
29 unsigned short right;
30};
31
32static const struct daio_rsc_idx idx_20k1[NUM_DAIOTYP] = {
33 [LINEO1] = {.left = 0x00, .right = 0x01},
34 [LINEO2] = {.left = 0x18, .right = 0x19},
35 [LINEO3] = {.left = 0x08, .right = 0x09},
36 [LINEO4] = {.left = 0x10, .right = 0x11},
37 [LINEIM] = {.left = 0x1b5, .right = 0x1bd},
38 [SPDIFOO] = {.left = 0x20, .right = 0x21},
39 [SPDIFIO] = {.left = 0x15, .right = 0x1d},
40 [SPDIFI1] = {.left = 0x95, .right = 0x9d},
41};
42
43static const struct daio_rsc_idx idx_20k2[NUM_DAIOTYP] = {
44 [LINEO1] = {.left = 0x40, .right = 0x41},
45 [LINEO2] = {.left = 0x60, .right = 0x61},
46 [LINEO3] = {.left = 0x50, .right = 0x51},
47 [LINEO4] = {.left = 0x70, .right = 0x71},
48 [LINEIM] = {.left = 0x45, .right = 0xc5},
49 [MIC] = {.left = 0x55, .right = 0xd5},
50 [SPDIFOO] = {.left = 0x00, .right = 0x01},
51 [SPDIFIO] = {.left = 0x05, .right = 0x85},
52};
53
54static int daio_master(struct rsc *rsc)
55{
56 /* Actually, this is not the resource index of DAIO.
57 * For DAO, it is the input mapper index. And, for DAI,
58 * it is the output time-slot index. */
59 return rsc->conj = rsc->idx;
60}
61
62static int daio_index(const struct rsc *rsc)
63{
64 return rsc->conj;
65}
66
67static int daio_out_next_conj(struct rsc *rsc)
68{
69 return rsc->conj += 2;
70}
71
72static int daio_in_next_conj_20k1(struct rsc *rsc)
73{
74 return rsc->conj += 0x200;
75}
76
77static int daio_in_next_conj_20k2(struct rsc *rsc)
78{
79 return rsc->conj += 0x100;
80}
81
82static const struct rsc_ops daio_out_rsc_ops = {
83 .master = daio_master,
84 .next_conj = daio_out_next_conj,
85 .index = daio_index,
86 .output_slot = NULL,
87};
88
89static const struct rsc_ops daio_in_rsc_ops_20k1 = {
90 .master = daio_master,
91 .next_conj = daio_in_next_conj_20k1,
92 .index = NULL,
93 .output_slot = daio_index,
94};
95
96static const struct rsc_ops daio_in_rsc_ops_20k2 = {
97 .master = daio_master,
98 .next_conj = daio_in_next_conj_20k2,
99 .index = NULL,
100 .output_slot = daio_index,
101};
102
103static unsigned int daio_device_index(enum DAIOTYP type, struct hw *hw)
104{
105 switch (hw->chip_type) {
106 case ATC20K1:
107 switch (type) {
108 case SPDIFOO: return 0;
109 case SPDIFIO: return 0;
110 case SPDIFI1: return 1;
111 case LINEO1: return 4;
112 case LINEO2: return 7;
113 case LINEO3: return 5;
114 case LINEO4: return 6;
115 case LINEIM: return 7;
116 default: return -EINVAL;
117 }
118 case ATC20K2:
119 switch (type) {
120 case SPDIFOO: return 0;
121 case SPDIFIO: return 0;
122 case LINEO1: return 4;
123 case LINEO2: return 7;
124 case LINEO3: return 5;
125 case LINEO4: return 6;
126 case LINEIM: return 4;
127 case MIC: return 5;
128 default: return -EINVAL;
129 }
130 default:
131 return -EINVAL;
132 }
133}
134
135static int dao_rsc_reinit(struct dao *dao, const struct dao_desc *desc);
136
137static int dao_spdif_get_spos(struct dao *dao, unsigned int *spos)
138{
139 dao->hw->dao_get_spos(dao->ctrl_blk, spos);
140 return 0;
141}
142
143static int dao_spdif_set_spos(struct dao *dao, unsigned int spos)
144{
145 dao->hw->dao_set_spos(dao->ctrl_blk, spos);
146 return 0;
147}
148
149static int dao_commit_write(struct dao *dao)
150{
151 dao->hw->dao_commit_write(dao->hw,
152 daio_device_index(dao->daio.type, dao->hw), dao->ctrl_blk);
153 return 0;
154}
155
156static int dao_set_left_input(struct dao *dao, struct rsc *input)
157{
158 struct imapper *entry;
159 struct daio *daio = &dao->daio;
160 int i;
161
162 entry = kzalloc((sizeof(*entry) * daio->rscl.msr), GFP_KERNEL);
163 if (!entry)
164 return -ENOMEM;
165
166 dao->ops->clear_left_input(dao);
167 /* Program master and conjugate resources */
168 input->ops->master(input);
169 daio->rscl.ops->master(&daio->rscl);
170 for (i = 0; i < daio->rscl.msr; i++, entry++) {
171 entry->slot = input->ops->output_slot(input);
172 entry->user = entry->addr = daio->rscl.ops->index(&daio->rscl);
173 dao->mgr->imap_add(dao->mgr, entry);
174 dao->imappers[i] = entry;
175
176 input->ops->next_conj(input);
177 daio->rscl.ops->next_conj(&daio->rscl);
178 }
179 input->ops->master(input);
180 daio->rscl.ops->master(&daio->rscl);
181
182 return 0;
183}
184
185static int dao_set_right_input(struct dao *dao, struct rsc *input)
186{
187 struct imapper *entry;
188 struct daio *daio = &dao->daio;
189 int i;
190
191 entry = kzalloc((sizeof(*entry) * daio->rscr.msr), GFP_KERNEL);
192 if (!entry)
193 return -ENOMEM;
194
195 dao->ops->clear_right_input(dao);
196 /* Program master and conjugate resources */
197 input->ops->master(input);
198 daio->rscr.ops->master(&daio->rscr);
199 for (i = 0; i < daio->rscr.msr; i++, entry++) {
200 entry->slot = input->ops->output_slot(input);
201 entry->user = entry->addr = daio->rscr.ops->index(&daio->rscr);
202 dao->mgr->imap_add(dao->mgr, entry);
203 dao->imappers[daio->rscl.msr + i] = entry;
204
205 input->ops->next_conj(input);
206 daio->rscr.ops->next_conj(&daio->rscr);
207 }
208 input->ops->master(input);
209 daio->rscr.ops->master(&daio->rscr);
210
211 return 0;
212}
213
214static int dao_clear_left_input(struct dao *dao)
215{
216 struct imapper *entry;
217 struct daio *daio = &dao->daio;
218 int i;
219
220 if (!dao->imappers[0])
221 return 0;
222
223 entry = dao->imappers[0];
224 dao->mgr->imap_delete(dao->mgr, entry);
225 /* Program conjugate resources */
226 for (i = 1; i < daio->rscl.msr; i++) {
227 entry = dao->imappers[i];
228 dao->mgr->imap_delete(dao->mgr, entry);
229 dao->imappers[i] = NULL;
230 }
231
232 kfree(dao->imappers[0]);
233 dao->imappers[0] = NULL;
234
235 return 0;
236}
237
238static int dao_clear_right_input(struct dao *dao)
239{
240 struct imapper *entry;
241 struct daio *daio = &dao->daio;
242 int i;
243
244 if (!dao->imappers[daio->rscl.msr])
245 return 0;
246
247 entry = dao->imappers[daio->rscl.msr];
248 dao->mgr->imap_delete(dao->mgr, entry);
249 /* Program conjugate resources */
250 for (i = 1; i < daio->rscr.msr; i++) {
251 entry = dao->imappers[daio->rscl.msr + i];
252 dao->mgr->imap_delete(dao->mgr, entry);
253 dao->imappers[daio->rscl.msr + i] = NULL;
254 }
255
256 kfree(dao->imappers[daio->rscl.msr]);
257 dao->imappers[daio->rscl.msr] = NULL;
258
259 return 0;
260}
261
262static const struct dao_rsc_ops dao_ops = {
263 .set_spos = dao_spdif_set_spos,
264 .commit_write = dao_commit_write,
265 .get_spos = dao_spdif_get_spos,
266 .reinit = dao_rsc_reinit,
267 .set_left_input = dao_set_left_input,
268 .set_right_input = dao_set_right_input,
269 .clear_left_input = dao_clear_left_input,
270 .clear_right_input = dao_clear_right_input,
271};
272
273static int dai_set_srt_srcl(struct dai *dai, struct rsc *src)
274{
275 src->ops->master(src);
276 dai->hw->dai_srt_set_srcm(dai->ctrl_blk, src->ops->index(src));
277 return 0;
278}
279
280static int dai_set_srt_srcr(struct dai *dai, struct rsc *src)
281{
282 src->ops->master(src);
283 dai->hw->dai_srt_set_srco(dai->ctrl_blk, src->ops->index(src));
284 return 0;
285}
286
287static int dai_set_srt_msr(struct dai *dai, unsigned int msr)
288{
289 unsigned int rsr;
290
291 for (rsr = 0; msr > 1; msr >>= 1)
292 rsr++;
293
294 dai->hw->dai_srt_set_rsr(dai->ctrl_blk, rsr);
295 return 0;
296}
297
298static int dai_set_enb_src(struct dai *dai, unsigned int enb)
299{
300 dai->hw->dai_srt_set_ec(dai->ctrl_blk, enb);
301 return 0;
302}
303
304static int dai_set_enb_srt(struct dai *dai, unsigned int enb)
305{
306 dai->hw->dai_srt_set_et(dai->ctrl_blk, enb);
307 return 0;
308}
309
310static int dai_commit_write(struct dai *dai)
311{
312 dai->hw->dai_commit_write(dai->hw,
313 daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk);
314 return 0;
315}
316
317static const struct dai_rsc_ops dai_ops = {
318 .set_srt_srcl = dai_set_srt_srcl,
319 .set_srt_srcr = dai_set_srt_srcr,
320 .set_srt_msr = dai_set_srt_msr,
321 .set_enb_src = dai_set_enb_src,
322 .set_enb_srt = dai_set_enb_srt,
323 .commit_write = dai_commit_write,
324};
325
326static int daio_rsc_init(struct daio *daio,
327 const struct daio_desc *desc,
328 struct hw *hw)
329{
330 int err;
331 unsigned int idx_l, idx_r;
332
333 switch (hw->chip_type) {
334 case ATC20K1:
335 idx_l = idx_20k1[desc->type].left;
336 idx_r = idx_20k1[desc->type].right;
337 break;
338 case ATC20K2:
339 idx_l = idx_20k2[desc->type].left;
340 idx_r = idx_20k2[desc->type].right;
341 break;
342 default:
343 return -EINVAL;
344 }
345 err = rsc_init(&daio->rscl, idx_l, DAIO, desc->msr, hw);
346 if (err)
347 return err;
348
349 err = rsc_init(&daio->rscr, idx_r, DAIO, desc->msr, hw);
350 if (err)
351 goto error1;
352
353 /* Set daio->rscl/r->ops to daio specific ones */
354 if (desc->type <= DAIO_OUT_MAX) {
355 daio->rscl.ops = daio->rscr.ops = &daio_out_rsc_ops;
356 } else {
357 switch (hw->chip_type) {
358 case ATC20K1:
359 daio->rscl.ops = daio->rscr.ops = &daio_in_rsc_ops_20k1;
360 break;
361 case ATC20K2:
362 daio->rscl.ops = daio->rscr.ops = &daio_in_rsc_ops_20k2;
363 break;
364 default:
365 break;
366 }
367 }
368 daio->type = desc->type;
369
370 return 0;
371
372error1:
373 rsc_uninit(&daio->rscl);
374 return err;
375}
376
377static int daio_rsc_uninit(struct daio *daio)
378{
379 rsc_uninit(&daio->rscl);
380 rsc_uninit(&daio->rscr);
381
382 return 0;
383}
384
385static int dao_rsc_init(struct dao *dao,
386 const struct daio_desc *desc,
387 struct daio_mgr *mgr)
388{
389 struct hw *hw = mgr->mgr.hw;
390 unsigned int conf;
391 int err;
392
393 err = daio_rsc_init(&dao->daio, desc, mgr->mgr.hw);
394 if (err)
395 return err;
396
397 dao->imappers = kzalloc(array3_size(sizeof(void *), desc->msr, 2),
398 GFP_KERNEL);
399 if (!dao->imappers) {
400 err = -ENOMEM;
401 goto error1;
402 }
403 dao->ops = &dao_ops;
404 dao->mgr = mgr;
405 dao->hw = hw;
406 err = hw->dao_get_ctrl_blk(&dao->ctrl_blk);
407 if (err)
408 goto error2;
409
410 hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk,
411 daio_device_index(dao->daio.type, hw));
412 hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
413
414 conf = (desc->msr & 0x7) | (desc->passthru << 3);
415 hw->daio_mgr_dao_init(mgr->mgr.ctrl_blk,
416 daio_device_index(dao->daio.type, hw), conf);
417 hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk,
418 daio_device_index(dao->daio.type, hw));
419 hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
420
421 return 0;
422
423error2:
424 kfree(dao->imappers);
425 dao->imappers = NULL;
426error1:
427 daio_rsc_uninit(&dao->daio);
428 return err;
429}
430
431static int dao_rsc_uninit(struct dao *dao)
432{
433 if (dao->imappers) {
434 if (dao->imappers[0])
435 dao_clear_left_input(dao);
436
437 if (dao->imappers[dao->daio.rscl.msr])
438 dao_clear_right_input(dao);
439
440 kfree(dao->imappers);
441 dao->imappers = NULL;
442 }
443 dao->hw->dao_put_ctrl_blk(dao->ctrl_blk);
444 dao->hw = dao->ctrl_blk = NULL;
445 daio_rsc_uninit(&dao->daio);
446
447 return 0;
448}
449
450static int dao_rsc_reinit(struct dao *dao, const struct dao_desc *desc)
451{
452 struct daio_mgr *mgr = dao->mgr;
453 struct daio_desc dsc = {0};
454
455 dsc.type = dao->daio.type;
456 dsc.msr = desc->msr;
457 dsc.passthru = desc->passthru;
458 dao_rsc_uninit(dao);
459 return dao_rsc_init(dao, &dsc, mgr);
460}
461
462static int dai_rsc_init(struct dai *dai,
463 const struct daio_desc *desc,
464 struct daio_mgr *mgr)
465{
466 int err;
467 struct hw *hw = mgr->mgr.hw;
468 unsigned int rsr, msr;
469
470 err = daio_rsc_init(&dai->daio, desc, mgr->mgr.hw);
471 if (err)
472 return err;
473
474 dai->ops = &dai_ops;
475 dai->hw = mgr->mgr.hw;
476 err = hw->dai_get_ctrl_blk(&dai->ctrl_blk);
477 if (err)
478 goto error1;
479
480 for (rsr = 0, msr = desc->msr; msr > 1; msr >>= 1)
481 rsr++;
482
483 hw->dai_srt_set_rsr(dai->ctrl_blk, rsr);
484 hw->dai_srt_set_drat(dai->ctrl_blk, 0);
485 /* default to disabling control of a SRC */
486 hw->dai_srt_set_ec(dai->ctrl_blk, 0);
487 hw->dai_srt_set_et(dai->ctrl_blk, 0); /* default to disabling SRT */
488 hw->dai_commit_write(hw,
489 daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk);
490
491 return 0;
492
493error1:
494 daio_rsc_uninit(&dai->daio);
495 return err;
496}
497
498static int dai_rsc_uninit(struct dai *dai)
499{
500 dai->hw->dai_put_ctrl_blk(dai->ctrl_blk);
501 dai->hw = dai->ctrl_blk = NULL;
502 daio_rsc_uninit(&dai->daio);
503 return 0;
504}
505
506static int daio_mgr_get_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
507{
508 if (((struct daio_usage *)mgr->rscs)->data & (0x1 << type))
509 return -ENOENT;
510
511 ((struct daio_usage *)mgr->rscs)->data |= (0x1 << type);
512
513 return 0;
514}
515
516static int daio_mgr_put_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
517{
518 ((struct daio_usage *)mgr->rscs)->data &= ~(0x1 << type);
519
520 return 0;
521}
522
523static int get_daio_rsc(struct daio_mgr *mgr,
524 const struct daio_desc *desc,
525 struct daio **rdaio)
526{
527 int err;
528 unsigned long flags;
529
530 *rdaio = NULL;
531
532 /* Check whether there are sufficient daio resources to meet request. */
533 spin_lock_irqsave(&mgr->mgr_lock, flags);
534 err = daio_mgr_get_rsc(&mgr->mgr, desc->type);
535 spin_unlock_irqrestore(&mgr->mgr_lock, flags);
536 if (err) {
537 dev_err(mgr->card->dev,
538 "Can't meet DAIO resource request!\n");
539 return err;
540 }
541
542 err = -ENOMEM;
543 /* Allocate mem for daio resource */
544 if (desc->type <= DAIO_OUT_MAX) {
545 struct dao *dao = kzalloc(sizeof(*dao), GFP_KERNEL);
546 if (!dao)
547 goto error;
548
549 err = dao_rsc_init(dao, desc, mgr);
550 if (err) {
551 kfree(dao);
552 goto error;
553 }
554
555 *rdaio = &dao->daio;
556 } else {
557 struct dai *dai = kzalloc(sizeof(*dai), GFP_KERNEL);
558 if (!dai)
559 goto error;
560
561 err = dai_rsc_init(dai, desc, mgr);
562 if (err) {
563 kfree(dai);
564 goto error;
565 }
566
567 *rdaio = &dai->daio;
568 }
569
570 mgr->daio_enable(mgr, *rdaio);
571 mgr->commit_write(mgr);
572
573 return 0;
574
575error:
576 spin_lock_irqsave(&mgr->mgr_lock, flags);
577 daio_mgr_put_rsc(&mgr->mgr, desc->type);
578 spin_unlock_irqrestore(&mgr->mgr_lock, flags);
579 return err;
580}
581
582static int put_daio_rsc(struct daio_mgr *mgr, struct daio *daio)
583{
584 unsigned long flags;
585
586 mgr->daio_disable(mgr, daio);
587 mgr->commit_write(mgr);
588
589 spin_lock_irqsave(&mgr->mgr_lock, flags);
590 daio_mgr_put_rsc(&mgr->mgr, daio->type);
591 spin_unlock_irqrestore(&mgr->mgr_lock, flags);
592
593 if (daio->type <= DAIO_OUT_MAX) {
594 dao_rsc_uninit(container_of(daio, struct dao, daio));
595 kfree(container_of(daio, struct dao, daio));
596 } else {
597 dai_rsc_uninit(container_of(daio, struct dai, daio));
598 kfree(container_of(daio, struct dai, daio));
599 }
600
601 return 0;
602}
603
604static int daio_mgr_enb_daio(struct daio_mgr *mgr, struct daio *daio)
605{
606 struct hw *hw = mgr->mgr.hw;
607
608 if (DAIO_OUT_MAX >= daio->type) {
609 hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk,
610 daio_device_index(daio->type, hw));
611 } else {
612 hw->daio_mgr_enb_dai(mgr->mgr.ctrl_blk,
613 daio_device_index(daio->type, hw));
614 }
615 return 0;
616}
617
618static int daio_mgr_dsb_daio(struct daio_mgr *mgr, struct daio *daio)
619{
620 struct hw *hw = mgr->mgr.hw;
621
622 if (DAIO_OUT_MAX >= daio->type) {
623 hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk,
624 daio_device_index(daio->type, hw));
625 } else {
626 hw->daio_mgr_dsb_dai(mgr->mgr.ctrl_blk,
627 daio_device_index(daio->type, hw));
628 }
629 return 0;
630}
631
632static int daio_map_op(void *data, struct imapper *entry)
633{
634 struct rsc_mgr *mgr = &((struct daio_mgr *)data)->mgr;
635 struct hw *hw = mgr->hw;
636
637 hw->daio_mgr_set_imaparc(mgr->ctrl_blk, entry->slot);
638 hw->daio_mgr_set_imapnxt(mgr->ctrl_blk, entry->next);
639 hw->daio_mgr_set_imapaddr(mgr->ctrl_blk, entry->addr);
640 hw->daio_mgr_commit_write(mgr->hw, mgr->ctrl_blk);
641
642 return 0;
643}
644
645static int daio_imap_add(struct daio_mgr *mgr, struct imapper *entry)
646{
647 unsigned long flags;
648 int err;
649
650 spin_lock_irqsave(&mgr->imap_lock, flags);
651 if (!entry->addr && mgr->init_imap_added) {
652 input_mapper_delete(&mgr->imappers, mgr->init_imap,
653 daio_map_op, mgr);
654 mgr->init_imap_added = 0;
655 }
656 err = input_mapper_add(&mgr->imappers, entry, daio_map_op, mgr);
657 spin_unlock_irqrestore(&mgr->imap_lock, flags);
658
659 return err;
660}
661
662static int daio_imap_delete(struct daio_mgr *mgr, struct imapper *entry)
663{
664 unsigned long flags;
665 int err;
666
667 spin_lock_irqsave(&mgr->imap_lock, flags);
668 err = input_mapper_delete(&mgr->imappers, entry, daio_map_op, mgr);
669 if (list_empty(&mgr->imappers)) {
670 input_mapper_add(&mgr->imappers, mgr->init_imap,
671 daio_map_op, mgr);
672 mgr->init_imap_added = 1;
673 }
674 spin_unlock_irqrestore(&mgr->imap_lock, flags);
675
676 return err;
677}
678
679static int daio_mgr_commit_write(struct daio_mgr *mgr)
680{
681 struct hw *hw = mgr->mgr.hw;
682
683 hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
684 return 0;
685}
686
687int daio_mgr_create(struct hw *hw, struct daio_mgr **rdaio_mgr)
688{
689 int err, i;
690 struct daio_mgr *daio_mgr;
691 struct imapper *entry;
692
693 *rdaio_mgr = NULL;
694 daio_mgr = kzalloc(sizeof(*daio_mgr), GFP_KERNEL);
695 if (!daio_mgr)
696 return -ENOMEM;
697
698 err = rsc_mgr_init(&daio_mgr->mgr, DAIO, NUM_DAIOTYP, hw);
699 if (err)
700 goto error1;
701
702 spin_lock_init(&daio_mgr->mgr_lock);
703 spin_lock_init(&daio_mgr->imap_lock);
704 INIT_LIST_HEAD(&daio_mgr->imappers);
705 entry = kzalloc(sizeof(*entry), GFP_KERNEL);
706 if (!entry) {
707 err = -ENOMEM;
708 goto error2;
709 }
710 entry->slot = entry->addr = entry->next = entry->user = 0;
711 list_add(&entry->list, &daio_mgr->imappers);
712 daio_mgr->init_imap = entry;
713 daio_mgr->init_imap_added = 1;
714
715 daio_mgr->get_daio = get_daio_rsc;
716 daio_mgr->put_daio = put_daio_rsc;
717 daio_mgr->daio_enable = daio_mgr_enb_daio;
718 daio_mgr->daio_disable = daio_mgr_dsb_daio;
719 daio_mgr->imap_add = daio_imap_add;
720 daio_mgr->imap_delete = daio_imap_delete;
721 daio_mgr->commit_write = daio_mgr_commit_write;
722 daio_mgr->card = hw->card;
723
724 for (i = 0; i < 8; i++) {
725 hw->daio_mgr_dsb_dao(daio_mgr->mgr.ctrl_blk, i);
726 hw->daio_mgr_dsb_dai(daio_mgr->mgr.ctrl_blk, i);
727 }
728 hw->daio_mgr_commit_write(hw, daio_mgr->mgr.ctrl_blk);
729
730 *rdaio_mgr = daio_mgr;
731
732 return 0;
733
734error2:
735 rsc_mgr_uninit(&daio_mgr->mgr);
736error1:
737 kfree(daio_mgr);
738 return err;
739}
740
741int daio_mgr_destroy(struct daio_mgr *daio_mgr)
742{
743 unsigned long flags;
744
745 /* free daio input mapper list */
746 spin_lock_irqsave(&daio_mgr->imap_lock, flags);
747 free_input_mapper_list(&daio_mgr->imappers);
748 spin_unlock_irqrestore(&daio_mgr->imap_lock, flags);
749
750 rsc_mgr_uninit(&daio_mgr->mgr);
751 kfree(daio_mgr);
752
753 return 0;
754}
755
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 ctdaio.c
9 *
10 * @Brief
11 * This file contains the implementation of Digital Audio Input Output
12 * resource management object.
13 *
14 * @Author Liu Chun
15 * @Date May 23 2008
16 *
17 */
18
19#include "ctdaio.h"
20#include "cthardware.h"
21#include "ctimap.h"
22#include <linux/slab.h>
23#include <linux/kernel.h>
24
25#define DAIO_OUT_MAX SPDIFOO
26
27struct daio_usage {
28 unsigned short data;
29};
30
31struct daio_rsc_idx {
32 unsigned short left;
33 unsigned short right;
34};
35
36struct daio_rsc_idx idx_20k1[NUM_DAIOTYP] = {
37 [LINEO1] = {.left = 0x00, .right = 0x01},
38 [LINEO2] = {.left = 0x18, .right = 0x19},
39 [LINEO3] = {.left = 0x08, .right = 0x09},
40 [LINEO4] = {.left = 0x10, .right = 0x11},
41 [LINEIM] = {.left = 0x1b5, .right = 0x1bd},
42 [SPDIFOO] = {.left = 0x20, .right = 0x21},
43 [SPDIFIO] = {.left = 0x15, .right = 0x1d},
44 [SPDIFI1] = {.left = 0x95, .right = 0x9d},
45};
46
47struct daio_rsc_idx idx_20k2[NUM_DAIOTYP] = {
48 [LINEO1] = {.left = 0x40, .right = 0x41},
49 [LINEO2] = {.left = 0x60, .right = 0x61},
50 [LINEO3] = {.left = 0x50, .right = 0x51},
51 [LINEO4] = {.left = 0x70, .right = 0x71},
52 [LINEIM] = {.left = 0x45, .right = 0xc5},
53 [MIC] = {.left = 0x55, .right = 0xd5},
54 [SPDIFOO] = {.left = 0x00, .right = 0x01},
55 [SPDIFIO] = {.left = 0x05, .right = 0x85},
56};
57
58static int daio_master(struct rsc *rsc)
59{
60 /* Actually, this is not the resource index of DAIO.
61 * For DAO, it is the input mapper index. And, for DAI,
62 * it is the output time-slot index. */
63 return rsc->conj = rsc->idx;
64}
65
66static int daio_index(const struct rsc *rsc)
67{
68 return rsc->conj;
69}
70
71static int daio_out_next_conj(struct rsc *rsc)
72{
73 return rsc->conj += 2;
74}
75
76static int daio_in_next_conj_20k1(struct rsc *rsc)
77{
78 return rsc->conj += 0x200;
79}
80
81static int daio_in_next_conj_20k2(struct rsc *rsc)
82{
83 return rsc->conj += 0x100;
84}
85
86static struct rsc_ops daio_out_rsc_ops = {
87 .master = daio_master,
88 .next_conj = daio_out_next_conj,
89 .index = daio_index,
90 .output_slot = NULL,
91};
92
93static struct rsc_ops daio_in_rsc_ops_20k1 = {
94 .master = daio_master,
95 .next_conj = daio_in_next_conj_20k1,
96 .index = NULL,
97 .output_slot = daio_index,
98};
99
100static struct rsc_ops daio_in_rsc_ops_20k2 = {
101 .master = daio_master,
102 .next_conj = daio_in_next_conj_20k2,
103 .index = NULL,
104 .output_slot = daio_index,
105};
106
107static unsigned int daio_device_index(enum DAIOTYP type, struct hw *hw)
108{
109 switch (hw->chip_type) {
110 case ATC20K1:
111 switch (type) {
112 case SPDIFOO: return 0;
113 case SPDIFIO: return 0;
114 case SPDIFI1: return 1;
115 case LINEO1: return 4;
116 case LINEO2: return 7;
117 case LINEO3: return 5;
118 case LINEO4: return 6;
119 case LINEIM: return 7;
120 default: return -EINVAL;
121 }
122 case ATC20K2:
123 switch (type) {
124 case SPDIFOO: return 0;
125 case SPDIFIO: return 0;
126 case LINEO1: return 4;
127 case LINEO2: return 7;
128 case LINEO3: return 5;
129 case LINEO4: return 6;
130 case LINEIM: return 4;
131 case MIC: return 5;
132 default: return -EINVAL;
133 }
134 default:
135 return -EINVAL;
136 }
137}
138
139static int dao_rsc_reinit(struct dao *dao, const struct dao_desc *desc);
140
141static int dao_spdif_get_spos(struct dao *dao, unsigned int *spos)
142{
143 ((struct hw *)dao->hw)->dao_get_spos(dao->ctrl_blk, spos);
144 return 0;
145}
146
147static int dao_spdif_set_spos(struct dao *dao, unsigned int spos)
148{
149 ((struct hw *)dao->hw)->dao_set_spos(dao->ctrl_blk, spos);
150 return 0;
151}
152
153static int dao_commit_write(struct dao *dao)
154{
155 ((struct hw *)dao->hw)->dao_commit_write(dao->hw,
156 daio_device_index(dao->daio.type, dao->hw), dao->ctrl_blk);
157 return 0;
158}
159
160static int dao_set_left_input(struct dao *dao, struct rsc *input)
161{
162 struct imapper *entry;
163 struct daio *daio = &dao->daio;
164 int i;
165
166 entry = kzalloc((sizeof(*entry) * daio->rscl.msr), GFP_KERNEL);
167 if (!entry)
168 return -ENOMEM;
169
170 dao->ops->clear_left_input(dao);
171 /* Program master and conjugate resources */
172 input->ops->master(input);
173 daio->rscl.ops->master(&daio->rscl);
174 for (i = 0; i < daio->rscl.msr; i++, entry++) {
175 entry->slot = input->ops->output_slot(input);
176 entry->user = entry->addr = daio->rscl.ops->index(&daio->rscl);
177 dao->mgr->imap_add(dao->mgr, entry);
178 dao->imappers[i] = entry;
179
180 input->ops->next_conj(input);
181 daio->rscl.ops->next_conj(&daio->rscl);
182 }
183 input->ops->master(input);
184 daio->rscl.ops->master(&daio->rscl);
185
186 return 0;
187}
188
189static int dao_set_right_input(struct dao *dao, struct rsc *input)
190{
191 struct imapper *entry;
192 struct daio *daio = &dao->daio;
193 int i;
194
195 entry = kzalloc((sizeof(*entry) * daio->rscr.msr), GFP_KERNEL);
196 if (!entry)
197 return -ENOMEM;
198
199 dao->ops->clear_right_input(dao);
200 /* Program master and conjugate resources */
201 input->ops->master(input);
202 daio->rscr.ops->master(&daio->rscr);
203 for (i = 0; i < daio->rscr.msr; i++, entry++) {
204 entry->slot = input->ops->output_slot(input);
205 entry->user = entry->addr = daio->rscr.ops->index(&daio->rscr);
206 dao->mgr->imap_add(dao->mgr, entry);
207 dao->imappers[daio->rscl.msr + i] = entry;
208
209 input->ops->next_conj(input);
210 daio->rscr.ops->next_conj(&daio->rscr);
211 }
212 input->ops->master(input);
213 daio->rscr.ops->master(&daio->rscr);
214
215 return 0;
216}
217
218static int dao_clear_left_input(struct dao *dao)
219{
220 struct imapper *entry;
221 struct daio *daio = &dao->daio;
222 int i;
223
224 if (!dao->imappers[0])
225 return 0;
226
227 entry = dao->imappers[0];
228 dao->mgr->imap_delete(dao->mgr, entry);
229 /* Program conjugate resources */
230 for (i = 1; i < daio->rscl.msr; i++) {
231 entry = dao->imappers[i];
232 dao->mgr->imap_delete(dao->mgr, entry);
233 dao->imappers[i] = NULL;
234 }
235
236 kfree(dao->imappers[0]);
237 dao->imappers[0] = NULL;
238
239 return 0;
240}
241
242static int dao_clear_right_input(struct dao *dao)
243{
244 struct imapper *entry;
245 struct daio *daio = &dao->daio;
246 int i;
247
248 if (!dao->imappers[daio->rscl.msr])
249 return 0;
250
251 entry = dao->imappers[daio->rscl.msr];
252 dao->mgr->imap_delete(dao->mgr, entry);
253 /* Program conjugate resources */
254 for (i = 1; i < daio->rscr.msr; i++) {
255 entry = dao->imappers[daio->rscl.msr + i];
256 dao->mgr->imap_delete(dao->mgr, entry);
257 dao->imappers[daio->rscl.msr + i] = NULL;
258 }
259
260 kfree(dao->imappers[daio->rscl.msr]);
261 dao->imappers[daio->rscl.msr] = NULL;
262
263 return 0;
264}
265
266static struct dao_rsc_ops dao_ops = {
267 .set_spos = dao_spdif_set_spos,
268 .commit_write = dao_commit_write,
269 .get_spos = dao_spdif_get_spos,
270 .reinit = dao_rsc_reinit,
271 .set_left_input = dao_set_left_input,
272 .set_right_input = dao_set_right_input,
273 .clear_left_input = dao_clear_left_input,
274 .clear_right_input = dao_clear_right_input,
275};
276
277static int dai_set_srt_srcl(struct dai *dai, struct rsc *src)
278{
279 src->ops->master(src);
280 ((struct hw *)dai->hw)->dai_srt_set_srcm(dai->ctrl_blk,
281 src->ops->index(src));
282 return 0;
283}
284
285static int dai_set_srt_srcr(struct dai *dai, struct rsc *src)
286{
287 src->ops->master(src);
288 ((struct hw *)dai->hw)->dai_srt_set_srco(dai->ctrl_blk,
289 src->ops->index(src));
290 return 0;
291}
292
293static int dai_set_srt_msr(struct dai *dai, unsigned int msr)
294{
295 unsigned int rsr;
296
297 for (rsr = 0; msr > 1; msr >>= 1)
298 rsr++;
299
300 ((struct hw *)dai->hw)->dai_srt_set_rsr(dai->ctrl_blk, rsr);
301 return 0;
302}
303
304static int dai_set_enb_src(struct dai *dai, unsigned int enb)
305{
306 ((struct hw *)dai->hw)->dai_srt_set_ec(dai->ctrl_blk, enb);
307 return 0;
308}
309
310static int dai_set_enb_srt(struct dai *dai, unsigned int enb)
311{
312 ((struct hw *)dai->hw)->dai_srt_set_et(dai->ctrl_blk, enb);
313 return 0;
314}
315
316static int dai_commit_write(struct dai *dai)
317{
318 ((struct hw *)dai->hw)->dai_commit_write(dai->hw,
319 daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk);
320 return 0;
321}
322
323static struct dai_rsc_ops dai_ops = {
324 .set_srt_srcl = dai_set_srt_srcl,
325 .set_srt_srcr = dai_set_srt_srcr,
326 .set_srt_msr = dai_set_srt_msr,
327 .set_enb_src = dai_set_enb_src,
328 .set_enb_srt = dai_set_enb_srt,
329 .commit_write = dai_commit_write,
330};
331
332static int daio_rsc_init(struct daio *daio,
333 const struct daio_desc *desc,
334 void *hw)
335{
336 int err;
337 unsigned int idx_l, idx_r;
338
339 switch (((struct hw *)hw)->chip_type) {
340 case ATC20K1:
341 idx_l = idx_20k1[desc->type].left;
342 idx_r = idx_20k1[desc->type].right;
343 break;
344 case ATC20K2:
345 idx_l = idx_20k2[desc->type].left;
346 idx_r = idx_20k2[desc->type].right;
347 break;
348 default:
349 return -EINVAL;
350 }
351 err = rsc_init(&daio->rscl, idx_l, DAIO, desc->msr, hw);
352 if (err)
353 return err;
354
355 err = rsc_init(&daio->rscr, idx_r, DAIO, desc->msr, hw);
356 if (err)
357 goto error1;
358
359 /* Set daio->rscl/r->ops to daio specific ones */
360 if (desc->type <= DAIO_OUT_MAX) {
361 daio->rscl.ops = daio->rscr.ops = &daio_out_rsc_ops;
362 } else {
363 switch (((struct hw *)hw)->chip_type) {
364 case ATC20K1:
365 daio->rscl.ops = daio->rscr.ops = &daio_in_rsc_ops_20k1;
366 break;
367 case ATC20K2:
368 daio->rscl.ops = daio->rscr.ops = &daio_in_rsc_ops_20k2;
369 break;
370 default:
371 break;
372 }
373 }
374 daio->type = desc->type;
375
376 return 0;
377
378error1:
379 rsc_uninit(&daio->rscl);
380 return err;
381}
382
383static int daio_rsc_uninit(struct daio *daio)
384{
385 rsc_uninit(&daio->rscl);
386 rsc_uninit(&daio->rscr);
387
388 return 0;
389}
390
391static int dao_rsc_init(struct dao *dao,
392 const struct daio_desc *desc,
393 struct daio_mgr *mgr)
394{
395 struct hw *hw = mgr->mgr.hw;
396 unsigned int conf;
397 int err;
398
399 err = daio_rsc_init(&dao->daio, desc, mgr->mgr.hw);
400 if (err)
401 return err;
402
403 dao->imappers = kzalloc(sizeof(void *)*desc->msr*2, GFP_KERNEL);
404 if (!dao->imappers) {
405 err = -ENOMEM;
406 goto error1;
407 }
408 dao->ops = &dao_ops;
409 dao->mgr = mgr;
410 dao->hw = hw;
411 err = hw->dao_get_ctrl_blk(&dao->ctrl_blk);
412 if (err)
413 goto error2;
414
415 hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk,
416 daio_device_index(dao->daio.type, hw));
417 hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
418
419 conf = (desc->msr & 0x7) | (desc->passthru << 3);
420 hw->daio_mgr_dao_init(mgr->mgr.ctrl_blk,
421 daio_device_index(dao->daio.type, hw), conf);
422 hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk,
423 daio_device_index(dao->daio.type, hw));
424 hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
425
426 return 0;
427
428error2:
429 kfree(dao->imappers);
430 dao->imappers = NULL;
431error1:
432 daio_rsc_uninit(&dao->daio);
433 return err;
434}
435
436static int dao_rsc_uninit(struct dao *dao)
437{
438 if (dao->imappers) {
439 if (dao->imappers[0])
440 dao_clear_left_input(dao);
441
442 if (dao->imappers[dao->daio.rscl.msr])
443 dao_clear_right_input(dao);
444
445 kfree(dao->imappers);
446 dao->imappers = NULL;
447 }
448 ((struct hw *)dao->hw)->dao_put_ctrl_blk(dao->ctrl_blk);
449 dao->hw = dao->ctrl_blk = NULL;
450 daio_rsc_uninit(&dao->daio);
451
452 return 0;
453}
454
455static int dao_rsc_reinit(struct dao *dao, const struct dao_desc *desc)
456{
457 struct daio_mgr *mgr = dao->mgr;
458 struct daio_desc dsc = {0};
459
460 dsc.type = dao->daio.type;
461 dsc.msr = desc->msr;
462 dsc.passthru = desc->passthru;
463 dao_rsc_uninit(dao);
464 return dao_rsc_init(dao, &dsc, mgr);
465}
466
467static int dai_rsc_init(struct dai *dai,
468 const struct daio_desc *desc,
469 struct daio_mgr *mgr)
470{
471 int err;
472 struct hw *hw = mgr->mgr.hw;
473 unsigned int rsr, msr;
474
475 err = daio_rsc_init(&dai->daio, desc, mgr->mgr.hw);
476 if (err)
477 return err;
478
479 dai->ops = &dai_ops;
480 dai->hw = mgr->mgr.hw;
481 err = hw->dai_get_ctrl_blk(&dai->ctrl_blk);
482 if (err)
483 goto error1;
484
485 for (rsr = 0, msr = desc->msr; msr > 1; msr >>= 1)
486 rsr++;
487
488 hw->dai_srt_set_rsr(dai->ctrl_blk, rsr);
489 hw->dai_srt_set_drat(dai->ctrl_blk, 0);
490 /* default to disabling control of a SRC */
491 hw->dai_srt_set_ec(dai->ctrl_blk, 0);
492 hw->dai_srt_set_et(dai->ctrl_blk, 0); /* default to disabling SRT */
493 hw->dai_commit_write(hw,
494 daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk);
495
496 return 0;
497
498error1:
499 daio_rsc_uninit(&dai->daio);
500 return err;
501}
502
503static int dai_rsc_uninit(struct dai *dai)
504{
505 ((struct hw *)dai->hw)->dai_put_ctrl_blk(dai->ctrl_blk);
506 dai->hw = dai->ctrl_blk = NULL;
507 daio_rsc_uninit(&dai->daio);
508 return 0;
509}
510
511static int daio_mgr_get_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
512{
513 if (((struct daio_usage *)mgr->rscs)->data & (0x1 << type))
514 return -ENOENT;
515
516 ((struct daio_usage *)mgr->rscs)->data |= (0x1 << type);
517
518 return 0;
519}
520
521static int daio_mgr_put_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
522{
523 ((struct daio_usage *)mgr->rscs)->data &= ~(0x1 << type);
524
525 return 0;
526}
527
528static int get_daio_rsc(struct daio_mgr *mgr,
529 const struct daio_desc *desc,
530 struct daio **rdaio)
531{
532 int err;
533 struct dai *dai = NULL;
534 struct dao *dao = NULL;
535 unsigned long flags;
536
537 *rdaio = NULL;
538
539 /* Check whether there are sufficient daio resources to meet request. */
540 spin_lock_irqsave(&mgr->mgr_lock, flags);
541 err = daio_mgr_get_rsc(&mgr->mgr, desc->type);
542 spin_unlock_irqrestore(&mgr->mgr_lock, flags);
543 if (err) {
544 printk(KERN_ERR "Can't meet DAIO resource request!\n");
545 return err;
546 }
547
548 /* Allocate mem for daio resource */
549 if (desc->type <= DAIO_OUT_MAX) {
550 dao = kzalloc(sizeof(*dao), GFP_KERNEL);
551 if (!dao) {
552 err = -ENOMEM;
553 goto error;
554 }
555 err = dao_rsc_init(dao, desc, mgr);
556 if (err)
557 goto error;
558
559 *rdaio = &dao->daio;
560 } else {
561 dai = kzalloc(sizeof(*dai), GFP_KERNEL);
562 if (!dai) {
563 err = -ENOMEM;
564 goto error;
565 }
566 err = dai_rsc_init(dai, desc, mgr);
567 if (err)
568 goto error;
569
570 *rdaio = &dai->daio;
571 }
572
573 mgr->daio_enable(mgr, *rdaio);
574 mgr->commit_write(mgr);
575
576 return 0;
577
578error:
579 if (dao)
580 kfree(dao);
581 else if (dai)
582 kfree(dai);
583
584 spin_lock_irqsave(&mgr->mgr_lock, flags);
585 daio_mgr_put_rsc(&mgr->mgr, desc->type);
586 spin_unlock_irqrestore(&mgr->mgr_lock, flags);
587 return err;
588}
589
590static int put_daio_rsc(struct daio_mgr *mgr, struct daio *daio)
591{
592 unsigned long flags;
593
594 mgr->daio_disable(mgr, daio);
595 mgr->commit_write(mgr);
596
597 spin_lock_irqsave(&mgr->mgr_lock, flags);
598 daio_mgr_put_rsc(&mgr->mgr, daio->type);
599 spin_unlock_irqrestore(&mgr->mgr_lock, flags);
600
601 if (daio->type <= DAIO_OUT_MAX) {
602 dao_rsc_uninit(container_of(daio, struct dao, daio));
603 kfree(container_of(daio, struct dao, daio));
604 } else {
605 dai_rsc_uninit(container_of(daio, struct dai, daio));
606 kfree(container_of(daio, struct dai, daio));
607 }
608
609 return 0;
610}
611
612static int daio_mgr_enb_daio(struct daio_mgr *mgr, struct daio *daio)
613{
614 struct hw *hw = mgr->mgr.hw;
615
616 if (DAIO_OUT_MAX >= daio->type) {
617 hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk,
618 daio_device_index(daio->type, hw));
619 } else {
620 hw->daio_mgr_enb_dai(mgr->mgr.ctrl_blk,
621 daio_device_index(daio->type, hw));
622 }
623 return 0;
624}
625
626static int daio_mgr_dsb_daio(struct daio_mgr *mgr, struct daio *daio)
627{
628 struct hw *hw = mgr->mgr.hw;
629
630 if (DAIO_OUT_MAX >= daio->type) {
631 hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk,
632 daio_device_index(daio->type, hw));
633 } else {
634 hw->daio_mgr_dsb_dai(mgr->mgr.ctrl_blk,
635 daio_device_index(daio->type, hw));
636 }
637 return 0;
638}
639
640static int daio_map_op(void *data, struct imapper *entry)
641{
642 struct rsc_mgr *mgr = &((struct daio_mgr *)data)->mgr;
643 struct hw *hw = mgr->hw;
644
645 hw->daio_mgr_set_imaparc(mgr->ctrl_blk, entry->slot);
646 hw->daio_mgr_set_imapnxt(mgr->ctrl_blk, entry->next);
647 hw->daio_mgr_set_imapaddr(mgr->ctrl_blk, entry->addr);
648 hw->daio_mgr_commit_write(mgr->hw, mgr->ctrl_blk);
649
650 return 0;
651}
652
653static int daio_imap_add(struct daio_mgr *mgr, struct imapper *entry)
654{
655 unsigned long flags;
656 int err;
657
658 spin_lock_irqsave(&mgr->imap_lock, flags);
659 if (!entry->addr && mgr->init_imap_added) {
660 input_mapper_delete(&mgr->imappers, mgr->init_imap,
661 daio_map_op, mgr);
662 mgr->init_imap_added = 0;
663 }
664 err = input_mapper_add(&mgr->imappers, entry, daio_map_op, mgr);
665 spin_unlock_irqrestore(&mgr->imap_lock, flags);
666
667 return err;
668}
669
670static int daio_imap_delete(struct daio_mgr *mgr, struct imapper *entry)
671{
672 unsigned long flags;
673 int err;
674
675 spin_lock_irqsave(&mgr->imap_lock, flags);
676 err = input_mapper_delete(&mgr->imappers, entry, daio_map_op, mgr);
677 if (list_empty(&mgr->imappers)) {
678 input_mapper_add(&mgr->imappers, mgr->init_imap,
679 daio_map_op, mgr);
680 mgr->init_imap_added = 1;
681 }
682 spin_unlock_irqrestore(&mgr->imap_lock, flags);
683
684 return err;
685}
686
687static int daio_mgr_commit_write(struct daio_mgr *mgr)
688{
689 struct hw *hw = mgr->mgr.hw;
690
691 hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
692 return 0;
693}
694
695int daio_mgr_create(void *hw, struct daio_mgr **rdaio_mgr)
696{
697 int err, i;
698 struct daio_mgr *daio_mgr;
699 struct imapper *entry;
700
701 *rdaio_mgr = NULL;
702 daio_mgr = kzalloc(sizeof(*daio_mgr), GFP_KERNEL);
703 if (!daio_mgr)
704 return -ENOMEM;
705
706 err = rsc_mgr_init(&daio_mgr->mgr, DAIO, NUM_DAIOTYP, hw);
707 if (err)
708 goto error1;
709
710 spin_lock_init(&daio_mgr->mgr_lock);
711 spin_lock_init(&daio_mgr->imap_lock);
712 INIT_LIST_HEAD(&daio_mgr->imappers);
713 entry = kzalloc(sizeof(*entry), GFP_KERNEL);
714 if (!entry) {
715 err = -ENOMEM;
716 goto error2;
717 }
718 entry->slot = entry->addr = entry->next = entry->user = 0;
719 list_add(&entry->list, &daio_mgr->imappers);
720 daio_mgr->init_imap = entry;
721 daio_mgr->init_imap_added = 1;
722
723 daio_mgr->get_daio = get_daio_rsc;
724 daio_mgr->put_daio = put_daio_rsc;
725 daio_mgr->daio_enable = daio_mgr_enb_daio;
726 daio_mgr->daio_disable = daio_mgr_dsb_daio;
727 daio_mgr->imap_add = daio_imap_add;
728 daio_mgr->imap_delete = daio_imap_delete;
729 daio_mgr->commit_write = daio_mgr_commit_write;
730
731 for (i = 0; i < 8; i++) {
732 ((struct hw *)hw)->daio_mgr_dsb_dao(daio_mgr->mgr.ctrl_blk, i);
733 ((struct hw *)hw)->daio_mgr_dsb_dai(daio_mgr->mgr.ctrl_blk, i);
734 }
735 ((struct hw *)hw)->daio_mgr_commit_write(hw, daio_mgr->mgr.ctrl_blk);
736
737 *rdaio_mgr = daio_mgr;
738
739 return 0;
740
741error2:
742 rsc_mgr_uninit(&daio_mgr->mgr);
743error1:
744 kfree(daio_mgr);
745 return err;
746}
747
748int daio_mgr_destroy(struct daio_mgr *daio_mgr)
749{
750 unsigned long flags;
751
752 /* free daio input mapper list */
753 spin_lock_irqsave(&daio_mgr->imap_lock, flags);
754 free_input_mapper_list(&daio_mgr->imappers);
755 spin_unlock_irqrestore(&daio_mgr->imap_lock, flags);
756
757 rsc_mgr_uninit(&daio_mgr->mgr);
758 kfree(daio_mgr);
759
760 return 0;
761}
762