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