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