Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ctdaio.c
Go to the documentation of this file.
1 
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 
27 struct daio_usage {
28  unsigned short data;
29 };
30 
31 struct daio_rsc_idx {
32  unsigned short left;
33  unsigned short right;
34 };
35 
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 
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 
58 static 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 
66 static int daio_index(const struct rsc *rsc)
67 {
68  return rsc->conj;
69 }
70 
71 static int daio_out_next_conj(struct rsc *rsc)
72 {
73  return rsc->conj += 2;
74 }
75 
76 static int daio_in_next_conj_20k1(struct rsc *rsc)
77 {
78  return rsc->conj += 0x200;
79 }
80 
81 static int daio_in_next_conj_20k2(struct rsc *rsc)
82 {
83  return rsc->conj += 0x100;
84 }
85 
86 static 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 
93 static 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 
100 static 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 
107 static 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 
139 static int dao_rsc_reinit(struct dao *dao, const struct dao_desc *desc);
140 
141 static 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 
147 static 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 
153 static 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 
160 static 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 
189 static 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 
218 static 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 
242 static 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 
266 static 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 
277 static 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 
285 static 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 
293 static 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 
304 static 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 
310 static 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 
316 static 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 
323 static 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 
332 static 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 
378 error1:
379  rsc_uninit(&daio->rscl);
380  return err;
381 }
382 
383 static int daio_rsc_uninit(struct daio *daio)
384 {
385  rsc_uninit(&daio->rscl);
386  rsc_uninit(&daio->rscr);
387 
388  return 0;
389 }
390 
391 static 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 
428 error2:
429  kfree(dao->imappers);
430  dao->imappers = NULL;
431 error1:
432  daio_rsc_uninit(&dao->daio);
433  return err;
434 }
435 
436 static 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 
455 static 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 
467 static 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 
498 error1:
499  daio_rsc_uninit(&dai->daio);
500  return err;
501 }
502 
503 static 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 
511 static 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 
521 static 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 
528 static 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 
578 error:
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 
590 static 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 
612 static 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 
626 static 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 
640 static 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 
653 static 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) {
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 
670 static 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 
687 static 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 
695 int 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 
741 error2:
742  rsc_mgr_uninit(&daio_mgr->mgr);
743 error1:
744  kfree(daio_mgr);
745  return err;
746 }
747 
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