1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
36static struct 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
47static struct 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
61
62
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 const 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 const 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 const 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 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 dao->hw->dao_set_spos(dao->ctrl_blk, spos);
150 return 0;
151}
152
153static int dao_commit_write(struct dao *dao)
154{
155 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
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
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
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
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 const 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 dai->hw->dai_srt_set_srcm(dai->ctrl_blk, src->ops->index(src));
281 return 0;
282}
283
284static int dai_set_srt_srcr(struct dai *dai, struct rsc *src)
285{
286 src->ops->master(src);
287 dai->hw->dai_srt_set_srco(dai->ctrl_blk, src->ops->index(src));
288 return 0;
289}
290
291static int dai_set_srt_msr(struct dai *dai, unsigned int msr)
292{
293 unsigned int rsr;
294
295 for (rsr = 0; msr > 1; msr >>= 1)
296 rsr++;
297
298 dai->hw->dai_srt_set_rsr(dai->ctrl_blk, rsr);
299 return 0;
300}
301
302static int dai_set_enb_src(struct dai *dai, unsigned int enb)
303{
304 dai->hw->dai_srt_set_ec(dai->ctrl_blk, enb);
305 return 0;
306}
307
308static int dai_set_enb_srt(struct dai *dai, unsigned int enb)
309{
310 dai->hw->dai_srt_set_et(dai->ctrl_blk, enb);
311 return 0;
312}
313
314static int dai_commit_write(struct dai *dai)
315{
316 dai->hw->dai_commit_write(dai->hw,
317 daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk);
318 return 0;
319}
320
321static const struct dai_rsc_ops dai_ops = {
322 .set_srt_srcl = dai_set_srt_srcl,
323 .set_srt_srcr = dai_set_srt_srcr,
324 .set_srt_msr = dai_set_srt_msr,
325 .set_enb_src = dai_set_enb_src,
326 .set_enb_srt = dai_set_enb_srt,
327 .commit_write = dai_commit_write,
328};
329
330static int daio_rsc_init(struct daio *daio,
331 const struct daio_desc *desc,
332 struct hw *hw)
333{
334 int err;
335 unsigned int idx_l, idx_r;
336
337 switch (hw->chip_type) {
338 case ATC20K1:
339 idx_l = idx_20k1[desc->type].left;
340 idx_r = idx_20k1[desc->type].right;
341 break;
342 case ATC20K2:
343 idx_l = idx_20k2[desc->type].left;
344 idx_r = idx_20k2[desc->type].right;
345 break;
346 default:
347 return -EINVAL;
348 }
349 err = rsc_init(&daio->rscl, idx_l, DAIO, desc->msr, hw);
350 if (err)
351 return err;
352
353 err = rsc_init(&daio->rscr, idx_r, DAIO, desc->msr, hw);
354 if (err)
355 goto error1;
356
357
358 if (desc->type <= DAIO_OUT_MAX) {
359 daio->rscl.ops = daio->rscr.ops = &daio_out_rsc_ops;
360 } else {
361 switch (hw->chip_type) {
362 case ATC20K1:
363 daio->rscl.ops = daio->rscr.ops = &daio_in_rsc_ops_20k1;
364 break;
365 case ATC20K2:
366 daio->rscl.ops = daio->rscr.ops = &daio_in_rsc_ops_20k2;
367 break;
368 default:
369 break;
370 }
371 }
372 daio->type = desc->type;
373
374 return 0;
375
376error1:
377 rsc_uninit(&daio->rscl);
378 return err;
379}
380
381static int daio_rsc_uninit(struct daio *daio)
382{
383 rsc_uninit(&daio->rscl);
384 rsc_uninit(&daio->rscr);
385
386 return 0;
387}
388
389static int dao_rsc_init(struct dao *dao,
390 const struct daio_desc *desc,
391 struct daio_mgr *mgr)
392{
393 struct hw *hw = mgr->mgr.hw;
394 unsigned int conf;
395 int err;
396
397 err = daio_rsc_init(&dao->daio, desc, mgr->mgr.hw);
398 if (err)
399 return err;
400
401 dao->imappers = kzalloc(sizeof(void *)*desc->msr*2, GFP_KERNEL);
402 if (!dao->imappers) {
403 err = -ENOMEM;
404 goto error1;
405 }
406 dao->ops = &dao_ops;
407 dao->mgr = mgr;
408 dao->hw = hw;
409 err = hw->dao_get_ctrl_blk(&dao->ctrl_blk);
410 if (err)
411 goto error2;
412
413 hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk,
414 daio_device_index(dao->daio.type, hw));
415 hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
416
417 conf = (desc->msr & 0x7) | (desc->passthru << 3);
418 hw->daio_mgr_dao_init(mgr->mgr.ctrl_blk,
419 daio_device_index(dao->daio.type, hw), conf);
420 hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk,
421 daio_device_index(dao->daio.type, hw));
422 hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
423
424 return 0;
425
426error2:
427 kfree(dao->imappers);
428 dao->imappers = NULL;
429error1:
430 daio_rsc_uninit(&dao->daio);
431 return err;
432}
433
434static int dao_rsc_uninit(struct dao *dao)
435{
436 if (dao->imappers) {
437 if (dao->imappers[0])
438 dao_clear_left_input(dao);
439
440 if (dao->imappers[dao->daio.rscl.msr])
441 dao_clear_right_input(dao);
442
443 kfree(dao->imappers);
444 dao->imappers = NULL;
445 }
446 dao->hw->dao_put_ctrl_blk(dao->ctrl_blk);
447 dao->hw = dao->ctrl_blk = NULL;
448 daio_rsc_uninit(&dao->daio);
449
450 return 0;
451}
452
453static int dao_rsc_reinit(struct dao *dao, const struct dao_desc *desc)
454{
455 struct daio_mgr *mgr = dao->mgr;
456 struct daio_desc dsc = {0};
457
458 dsc.type = dao->daio.type;
459 dsc.msr = desc->msr;
460 dsc.passthru = desc->passthru;
461 dao_rsc_uninit(dao);
462 return dao_rsc_init(dao, &dsc, mgr);
463}
464
465static int dai_rsc_init(struct dai *dai,
466 const struct daio_desc *desc,
467 struct daio_mgr *mgr)
468{
469 int err;
470 struct hw *hw = mgr->mgr.hw;
471 unsigned int rsr, msr;
472
473 err = daio_rsc_init(&dai->daio, desc, mgr->mgr.hw);
474 if (err)
475 return err;
476
477 dai->ops = &dai_ops;
478 dai->hw = mgr->mgr.hw;
479 err = hw->dai_get_ctrl_blk(&dai->ctrl_blk);
480 if (err)
481 goto error1;
482
483 for (rsr = 0, msr = desc->msr; msr > 1; msr >>= 1)
484 rsr++;
485
486 hw->dai_srt_set_rsr(dai->ctrl_blk, rsr);
487 hw->dai_srt_set_drat(dai->ctrl_blk, 0);
488
489 hw->dai_srt_set_ec(dai->ctrl_blk, 0);
490 hw->dai_srt_set_et(dai->ctrl_blk, 0);
491 hw->dai_commit_write(hw,
492 daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk);
493
494 return 0;
495
496error1:
497 daio_rsc_uninit(&dai->daio);
498 return err;
499}
500
501static int dai_rsc_uninit(struct dai *dai)
502{
503 dai->hw->dai_put_ctrl_blk(dai->ctrl_blk);
504 dai->hw = dai->ctrl_blk = NULL;
505 daio_rsc_uninit(&dai->daio);
506 return 0;
507}
508
509static int daio_mgr_get_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
510{
511 if (((struct daio_usage *)mgr->rscs)->data & (0x1 << type))
512 return -ENOENT;
513
514 ((struct daio_usage *)mgr->rscs)->data |= (0x1 << type);
515
516 return 0;
517}
518
519static int daio_mgr_put_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
520{
521 ((struct daio_usage *)mgr->rscs)->data &= ~(0x1 << type);
522
523 return 0;
524}
525
526static int get_daio_rsc(struct daio_mgr *mgr,
527 const struct daio_desc *desc,
528 struct daio **rdaio)
529{
530 int err;
531 unsigned long flags;
532
533 *rdaio = NULL;
534
535
536 spin_lock_irqsave(&mgr->mgr_lock, flags);
537 err = daio_mgr_get_rsc(&mgr->mgr, desc->type);
538 spin_unlock_irqrestore(&mgr->mgr_lock, flags);
539 if (err) {
540 dev_err(mgr->card->dev,
541 "Can't meet DAIO resource request!\n");
542 return err;
543 }
544
545 err = -ENOMEM;
546
547 if (desc->type <= DAIO_OUT_MAX) {
548 struct dao *dao = kzalloc(sizeof(*dao), GFP_KERNEL);
549 if (!dao)
550 goto error;
551
552 err = dao_rsc_init(dao, desc, mgr);
553 if (err) {
554 kfree(dao);
555 goto error;
556 }
557
558 *rdaio = &dao->daio;
559 } else {
560 struct dai *dai = kzalloc(sizeof(*dai), GFP_KERNEL);
561 if (!dai)
562 goto error;
563
564 err = dai_rsc_init(dai, desc, mgr);
565 if (err) {
566 kfree(dai);
567 goto error;
568 }
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 spin_lock_irqsave(&mgr->mgr_lock, flags);
580 daio_mgr_put_rsc(&mgr->mgr, desc->type);
581 spin_unlock_irqrestore(&mgr->mgr_lock, flags);
582 return err;
583}
584
585static int put_daio_rsc(struct daio_mgr *mgr, struct daio *daio)
586{
587 unsigned long flags;
588
589 mgr->daio_disable(mgr, daio);
590 mgr->commit_write(mgr);
591
592 spin_lock_irqsave(&mgr->mgr_lock, flags);
593 daio_mgr_put_rsc(&mgr->mgr, daio->type);
594 spin_unlock_irqrestore(&mgr->mgr_lock, flags);
595
596 if (daio->type <= DAIO_OUT_MAX) {
597 dao_rsc_uninit(container_of(daio, struct dao, daio));
598 kfree(container_of(daio, struct dao, daio));
599 } else {
600 dai_rsc_uninit(container_of(daio, struct dai, daio));
601 kfree(container_of(daio, struct dai, daio));
602 }
603
604 return 0;
605}
606
607static int daio_mgr_enb_daio(struct daio_mgr *mgr, struct daio *daio)
608{
609 struct hw *hw = mgr->mgr.hw;
610
611 if (DAIO_OUT_MAX >= daio->type) {
612 hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk,
613 daio_device_index(daio->type, hw));
614 } else {
615 hw->daio_mgr_enb_dai(mgr->mgr.ctrl_blk,
616 daio_device_index(daio->type, hw));
617 }
618 return 0;
619}
620
621static int daio_mgr_dsb_daio(struct daio_mgr *mgr, struct daio *daio)
622{
623 struct hw *hw = mgr->mgr.hw;
624
625 if (DAIO_OUT_MAX >= daio->type) {
626 hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk,
627 daio_device_index(daio->type, hw));
628 } else {
629 hw->daio_mgr_dsb_dai(mgr->mgr.ctrl_blk,
630 daio_device_index(daio->type, hw));
631 }
632 return 0;
633}
634
635static int daio_map_op(void *data, struct imapper *entry)
636{
637 struct rsc_mgr *mgr = &((struct daio_mgr *)data)->mgr;
638 struct hw *hw = mgr->hw;
639
640 hw->daio_mgr_set_imaparc(mgr->ctrl_blk, entry->slot);
641 hw->daio_mgr_set_imapnxt(mgr->ctrl_blk, entry->next);
642 hw->daio_mgr_set_imapaddr(mgr->ctrl_blk, entry->addr);
643 hw->daio_mgr_commit_write(mgr->hw, mgr->ctrl_blk);
644
645 return 0;
646}
647
648static int daio_imap_add(struct daio_mgr *mgr, struct imapper *entry)
649{
650 unsigned long flags;
651 int err;
652
653 spin_lock_irqsave(&mgr->imap_lock, flags);
654 if (!entry->addr && mgr->init_imap_added) {
655 input_mapper_delete(&mgr->imappers, mgr->init_imap,
656 daio_map_op, mgr);
657 mgr->init_imap_added = 0;
658 }
659 err = input_mapper_add(&mgr->imappers, entry, daio_map_op, mgr);
660 spin_unlock_irqrestore(&mgr->imap_lock, flags);
661
662 return err;
663}
664
665static int daio_imap_delete(struct daio_mgr *mgr, struct imapper *entry)
666{
667 unsigned long flags;
668 int err;
669
670 spin_lock_irqsave(&mgr->imap_lock, flags);
671 err = input_mapper_delete(&mgr->imappers, entry, daio_map_op, mgr);
672 if (list_empty(&mgr->imappers)) {
673 input_mapper_add(&mgr->imappers, mgr->init_imap,
674 daio_map_op, mgr);
675 mgr->init_imap_added = 1;
676 }
677 spin_unlock_irqrestore(&mgr->imap_lock, flags);
678
679 return err;
680}
681
682static int daio_mgr_commit_write(struct daio_mgr *mgr)
683{
684 struct hw *hw = mgr->mgr.hw;
685
686 hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
687 return 0;
688}
689
690int daio_mgr_create(struct hw *hw, struct daio_mgr **rdaio_mgr)
691{
692 int err, i;
693 struct daio_mgr *daio_mgr;
694 struct imapper *entry;
695
696 *rdaio_mgr = NULL;
697 daio_mgr = kzalloc(sizeof(*daio_mgr), GFP_KERNEL);
698 if (!daio_mgr)
699 return -ENOMEM;
700
701 err = rsc_mgr_init(&daio_mgr->mgr, DAIO, NUM_DAIOTYP, hw);
702 if (err)
703 goto error1;
704
705 spin_lock_init(&daio_mgr->mgr_lock);
706 spin_lock_init(&daio_mgr->imap_lock);
707 INIT_LIST_HEAD(&daio_mgr->imappers);
708 entry = kzalloc(sizeof(*entry), GFP_KERNEL);
709 if (!entry) {
710 err = -ENOMEM;
711 goto error2;
712 }
713 entry->slot = entry->addr = entry->next = entry->user = 0;
714 list_add(&entry->list, &daio_mgr->imappers);
715 daio_mgr->init_imap = entry;
716 daio_mgr->init_imap_added = 1;
717
718 daio_mgr->get_daio = get_daio_rsc;
719 daio_mgr->put_daio = put_daio_rsc;
720 daio_mgr->daio_enable = daio_mgr_enb_daio;
721 daio_mgr->daio_disable = daio_mgr_dsb_daio;
722 daio_mgr->imap_add = daio_imap_add;
723 daio_mgr->imap_delete = daio_imap_delete;
724 daio_mgr->commit_write = daio_mgr_commit_write;
725 daio_mgr->card = hw->card;
726
727 for (i = 0; i < 8; i++) {
728 hw->daio_mgr_dsb_dao(daio_mgr->mgr.ctrl_blk, i);
729 hw->daio_mgr_dsb_dai(daio_mgr->mgr.ctrl_blk, i);
730 }
731 hw->daio_mgr_commit_write(hw, daio_mgr->mgr.ctrl_blk);
732
733 *rdaio_mgr = daio_mgr;
734
735 return 0;
736
737error2:
738 rsc_mgr_uninit(&daio_mgr->mgr);
739error1:
740 kfree(daio_mgr);
741 return err;
742}
743
744int daio_mgr_destroy(struct daio_mgr *daio_mgr)
745{
746 unsigned long flags;
747
748
749 spin_lock_irqsave(&daio_mgr->imap_lock, flags);
750 free_input_mapper_list(&daio_mgr->imappers);
751 spin_unlock_irqrestore(&daio_mgr->imap_lock, flags);
752
753 rsc_mgr_uninit(&daio_mgr->mgr);
754 kfree(daio_mgr);
755
756 return 0;
757}
758
759
