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(array3_size(sizeof(void *), desc->msr, 2), 402 GFP_KERNEL); 403 if (!dao->imappers) { 404 err = -ENOMEM; 405 goto error1; 406 } 407 dao->ops = &dao_ops; 408 dao->mgr = mgr; 409 dao->hw = hw; 410 err = hw->dao_get_ctrl_blk(&dao->ctrl_blk); 411 if (err) 412 goto error2; 413 414 hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk, 415 daio_device_index(dao->daio.type, hw)); 416 hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk); 417 418 conf = (desc->msr & 0x7) | (desc->passthru << 3); 419 hw->daio_mgr_dao_init(mgr->mgr.ctrl_blk, 420 daio_device_index(dao->daio.type, hw), conf); 421 hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk, 422 daio_device_index(dao->daio.type, hw)); 423 hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk); 424 425 return 0; 426 427 error2: 428 kfree(dao->imappers); 429 dao->imappers = NULL; 430 error1: 431 daio_rsc_uninit(&dao->daio); 432 return err; 433 } 434 435 static int dao_rsc_uninit(struct dao *dao) 436 { 437 if (dao->imappers) { 438 if (dao->imappers[0]) 439 dao_clear_left_input(dao); 440 441 if (dao->imappers[dao->daio.rscl.msr]) 442 dao_clear_right_input(dao); 443 444 kfree(dao->imappers); 445 dao->imappers = NULL; 446 } 447 dao->hw->dao_put_ctrl_blk(dao->ctrl_blk); 448 dao->hw = dao->ctrl_blk = NULL; 449 daio_rsc_uninit(&dao->daio); 450 451 return 0; 452 } 453 454 static int dao_rsc_reinit(struct dao *dao, const struct dao_desc *desc) 455 { 456 struct daio_mgr *mgr = dao->mgr; 457 struct daio_desc dsc = {0}; 458 459 dsc.type = dao->daio.type; 460 dsc.msr = desc->msr; 461 dsc.passthru = desc->passthru; 462 dao_rsc_uninit(dao); 463 return dao_rsc_init(dao, &dsc, mgr); 464 } 465 466 static int dai_rsc_init(struct dai *dai, 467 const struct daio_desc *desc, 468 struct daio_mgr *mgr) 469 { 470 int err; 471 struct hw *hw = mgr->mgr.hw; 472 unsigned int rsr, msr; 473 474 err = daio_rsc_init(&dai->daio, desc, mgr->mgr.hw); 475 if (err) 476 return err; 477 478 dai->ops = &dai_ops; 479 dai->hw = mgr->mgr.hw; 480 err = hw->dai_get_ctrl_blk(&dai->ctrl_blk); 481 if (err) 482 goto error1; 483 484 for (rsr = 0, msr = desc->msr; msr > 1; msr >>= 1) 485 rsr++; 486 487 hw->dai_srt_set_rsr(dai->ctrl_blk, rsr); 488 hw->dai_srt_set_drat(dai->ctrl_blk, 0); 489 /* default to disabling control of a SRC */ 490 hw->dai_srt_set_ec(dai->ctrl_blk, 0); 491 hw->dai_srt_set_et(dai->ctrl_blk, 0); /* default to disabling SRT */ 492 hw->dai_commit_write(hw, 493 daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk); 494 495 return 0; 496 497 error1: 498 daio_rsc_uninit(&dai->daio); 499 return err; 500 } 501 502 static int dai_rsc_uninit(struct dai *dai) 503 { 504 dai->hw->dai_put_ctrl_blk(dai->ctrl_blk); 505 dai->hw = dai->ctrl_blk = NULL; 506 daio_rsc_uninit(&dai->daio); 507 return 0; 508 } 509 510 static int daio_mgr_get_rsc(struct rsc_mgr *mgr, enum DAIOTYP type) 511 { 512 if (((struct daio_usage *)mgr->rscs)->data & (0x1 << type)) 513 return -ENOENT; 514 515 ((struct daio_usage *)mgr->rscs)->data |= (0x1 << type); 516 517 return 0; 518 } 519 520 static int daio_mgr_put_rsc(struct rsc_mgr *mgr, enum DAIOTYP type) 521 { 522 ((struct daio_usage *)mgr->rscs)->data &= ~(0x1 << type); 523 524 return 0; 525 } 526 527 static int get_daio_rsc(struct daio_mgr *mgr, 528 const struct daio_desc *desc, 529 struct daio **rdaio) 530 { 531 int err; 532 unsigned long flags; 533 534 *rdaio = NULL; 535 536 /* Check whether there are sufficient daio resources to meet request. */ 537 spin_lock_irqsave(&mgr->mgr_lock, flags); 538 err = daio_mgr_get_rsc(&mgr->mgr, desc->type); 539 spin_unlock_irqrestore(&mgr->mgr_lock, flags); 540 if (err) { 541 dev_err(mgr->card->dev, 542 "Can't meet DAIO resource request!\n"); 543 return err; 544 } 545 546 err = -ENOMEM; 547 /* Allocate mem for daio resource */ 548 if (desc->type <= DAIO_OUT_MAX) { 549 struct dao *dao = kzalloc(sizeof(*dao), GFP_KERNEL); 550 if (!dao) 551 goto error; 552 553 err = dao_rsc_init(dao, desc, mgr); 554 if (err) { 555 kfree(dao); 556 goto error; 557 } 558 559 *rdaio = &dao->daio; 560 } else { 561 struct dai *dai = kzalloc(sizeof(*dai), GFP_KERNEL); 562 if (!dai) 563 goto error; 564 565 err = dai_rsc_init(dai, desc, mgr); 566 if (err) { 567 kfree(dai); 568 goto error; 569 } 570 571 *rdaio = &dai->daio; 572 } 573 574 mgr->daio_enable(mgr, *rdaio); 575 mgr->commit_write(mgr); 576 577 return 0; 578 579 error: 580 spin_lock_irqsave(&mgr->mgr_lock, flags); 581 daio_mgr_put_rsc(&mgr->mgr, desc->type); 582 spin_unlock_irqrestore(&mgr->mgr_lock, flags); 583 return err; 584 } 585 586 static int put_daio_rsc(struct daio_mgr *mgr, struct daio *daio) 587 { 588 unsigned long flags; 589 590 mgr->daio_disable(mgr, daio); 591 mgr->commit_write(mgr); 592 593 spin_lock_irqsave(&mgr->mgr_lock, flags); 594 daio_mgr_put_rsc(&mgr->mgr, daio->type); 595 spin_unlock_irqrestore(&mgr->mgr_lock, flags); 596 597 if (daio->type <= DAIO_OUT_MAX) { 598 dao_rsc_uninit(container_of(daio, struct dao, daio)); 599 kfree(container_of(daio, struct dao, daio)); 600 } else { 601 dai_rsc_uninit(container_of(daio, struct dai, daio)); 602 kfree(container_of(daio, struct dai, daio)); 603 } 604 605 return 0; 606 } 607 608 static int daio_mgr_enb_daio(struct daio_mgr *mgr, struct daio *daio) 609 { 610 struct hw *hw = mgr->mgr.hw; 611 612 if (DAIO_OUT_MAX >= daio->type) { 613 hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk, 614 daio_device_index(daio->type, hw)); 615 } else { 616 hw->daio_mgr_enb_dai(mgr->mgr.ctrl_blk, 617 daio_device_index(daio->type, hw)); 618 } 619 return 0; 620 } 621 622 static int daio_mgr_dsb_daio(struct daio_mgr *mgr, struct daio *daio) 623 { 624 struct hw *hw = mgr->mgr.hw; 625 626 if (DAIO_OUT_MAX >= daio->type) { 627 hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk, 628 daio_device_index(daio->type, hw)); 629 } else { 630 hw->daio_mgr_dsb_dai(mgr->mgr.ctrl_blk, 631 daio_device_index(daio->type, hw)); 632 } 633 return 0; 634 } 635 636 static int daio_map_op(void *data, struct imapper *entry) 637 { 638 struct rsc_mgr *mgr = &((struct daio_mgr *)data)->mgr; 639 struct hw *hw = mgr->hw; 640 641 hw->daio_mgr_set_imaparc(mgr->ctrl_blk, entry->slot); 642 hw->daio_mgr_set_imapnxt(mgr->ctrl_blk, entry->next); 643 hw->daio_mgr_set_imapaddr(mgr->ctrl_blk, entry->addr); 644 hw->daio_mgr_commit_write(mgr->hw, mgr->ctrl_blk); 645 646 return 0; 647 } 648 649 static int daio_imap_add(struct daio_mgr *mgr, struct imapper *entry) 650 { 651 unsigned long flags; 652 int err; 653 654 spin_lock_irqsave(&mgr->imap_lock, flags); 655 if (!entry->addr && mgr->init_imap_added) { 656 input_mapper_delete(&mgr->imappers, mgr->init_imap, 657 daio_map_op, mgr); 658 mgr->init_imap_added = 0; 659 } 660 err = input_mapper_add(&mgr->imappers, entry, daio_map_op, mgr); 661 spin_unlock_irqrestore(&mgr->imap_lock, flags); 662 663 return err; 664 } 665 666 static int daio_imap_delete(struct daio_mgr *mgr, struct imapper *entry) 667 { 668 unsigned long flags; 669 int err; 670 671 spin_lock_irqsave(&mgr->imap_lock, flags); 672 err = input_mapper_delete(&mgr->imappers, entry, daio_map_op, mgr); 673 if (list_empty(&mgr->imappers)) { 674 input_mapper_add(&mgr->imappers, mgr->init_imap, 675 daio_map_op, mgr); 676 mgr->init_imap_added = 1; 677 } 678 spin_unlock_irqrestore(&mgr->imap_lock, flags); 679 680 return err; 681 } 682 683 static int daio_mgr_commit_write(struct daio_mgr *mgr) 684 { 685 struct hw *hw = mgr->mgr.hw; 686 687 hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk); 688 return 0; 689 } 690 691 int daio_mgr_create(struct hw *hw, struct daio_mgr **rdaio_mgr) 692 { 693 int err, i; 694 struct daio_mgr *daio_mgr; 695 struct imapper *entry; 696 697 *rdaio_mgr = NULL; 698 daio_mgr = kzalloc(sizeof(*daio_mgr), GFP_KERNEL); 699 if (!daio_mgr) 700 return -ENOMEM; 701 702 err = rsc_mgr_init(&daio_mgr->mgr, DAIO, NUM_DAIOTYP, hw); 703 if (err) 704 goto error1; 705 706 spin_lock_init(&daio_mgr->mgr_lock); 707 spin_lock_init(&daio_mgr->imap_lock); 708 INIT_LIST_HEAD(&daio_mgr->imappers); 709 entry = kzalloc(sizeof(*entry), GFP_KERNEL); 710 if (!entry) { 711 err = -ENOMEM; 712 goto error2; 713 } 714 entry->slot = entry->addr = entry->next = entry->user = 0; 715 list_add(&entry->list, &daio_mgr->imappers); 716 daio_mgr->init_imap = entry; 717 daio_mgr->init_imap_added = 1; 718 719 daio_mgr->get_daio = get_daio_rsc; 720 daio_mgr->put_daio = put_daio_rsc; 721 daio_mgr->daio_enable = daio_mgr_enb_daio; 722 daio_mgr->daio_disable = daio_mgr_dsb_daio; 723 daio_mgr->imap_add = daio_imap_add; 724 daio_mgr->imap_delete = daio_imap_delete; 725 daio_mgr->commit_write = daio_mgr_commit_write; 726 daio_mgr->card = hw->card; 727 728 for (i = 0; i < 8; i++) { 729 hw->daio_mgr_dsb_dao(daio_mgr->mgr.ctrl_blk, i); 730 hw->daio_mgr_dsb_dai(daio_mgr->mgr.ctrl_blk, i); 731 } 732 hw->daio_mgr_commit_write(hw, daio_mgr->mgr.ctrl_blk); 733 734 *rdaio_mgr = daio_mgr; 735 736 return 0; 737 738 error2: 739 rsc_mgr_uninit(&daio_mgr->mgr); 740 error1: 741 kfree(daio_mgr); 742 return err; 743 } 744 745 int daio_mgr_destroy(struct daio_mgr *daio_mgr) 746 { 747 unsigned long flags; 748 749 /* free daio input mapper list */ 750 spin_lock_irqsave(&daio_mgr->imap_lock, flags); 751 free_input_mapper_list(&daio_mgr->imappers); 752 spin_unlock_irqrestore(&daio_mgr->imap_lock, flags); 753 754 rsc_mgr_uninit(&daio_mgr->mgr); 755 kfree(daio_mgr); 756 757 return 0; 758 } 759 760