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_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 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 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 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) {
 660                 input_mapper_delete(&mgr->imappers, mgr->init_imap,
 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
 748 int daio_mgr_destroy(struct daio_mgr *daio_mgr)
 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