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 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 36 static 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 47 static 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 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 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 93 static 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 100 static 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 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 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 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 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 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 277 static 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 284 static 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 291 static 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 302 static 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 308 static 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 314 static 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 321 static 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 330 static 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 /* Set daio->rscl/r->ops to daio specific ones */ 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 376 error1: 377 rsc_uninit(&daio->rscl); 378 return err; 379 } 380 381 static int daio_rsc_uninit(struct daio *daio) 382 { 383 rsc_uninit(&daio->rscl); 384 rsc_uninit(&daio->rscr); 385 386 return 0; 387 } 388 389 static 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 426 error2: 427 kfree(dao->imappers); 428 dao->imappers = NULL; 429 error1: 430 daio_rsc_uninit(&dao->daio); 431 return err; 432 } 433 434 static 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 453 static 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 465 static 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 /* default to disabling control of a SRC */ 489 hw->dai_srt_set_ec(dai->ctrl_blk, 0); 490 hw->dai_srt_set_et(dai->ctrl_blk, 0); /* default to disabling SRT */ 491 hw->dai_commit_write(hw, 492 daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk); 493 494 return 0; 495 496 error1: 497 daio_rsc_uninit(&dai->daio); 498 return err; 499 } 500 501 static 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 509 static 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 519 static 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 526 static 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 /* Check whether there are sufficient daio resources to meet request. */ 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 /* Allocate mem for daio resource */ 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 578 error: 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 585 static 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 607 static 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 621 static 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 635 static 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 648 static 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 665 static 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 682 static 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 690 int 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 737 error2: 738 rsc_mgr_uninit(&daio_mgr->mgr); 739 error1: 740 kfree(daio_mgr); 741 return err; 742 } 743 744 int daio_mgr_destroy(struct daio_mgr *daio_mgr) 745 { 746 unsigned long flags; 747 748 /* free daio input mapper list */ 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