sound/pci/ctxfi/ctamixer.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        ctamixer.c
   9  *
  10  * @Brief
  11  * This file contains the implementation of the Audio Mixer
  12  * resource management object.
  13  *
  14  * @Author      Liu Chun
  15  * @Date        May 21 2008
  16  *
  17  */
  18
  19 #include "ctamixer.h"
  20 #include "cthardware.h"
  21 #include <linux/slab.h>
  22
  23 #define AMIXER_RESOURCE_NUM     256
  24 #define SUM_RESOURCE_NUM        256
  25
  26 #define AMIXER_Y_IMMEDIATE      1
  27
  28 #define BLANK_SLOT              4094
  29
  30 static void amixer_master(struct rsc *rsc)
  31 {
  32         rsc->conj = 0;
  33         rsc->idx = container_of(rsc, struct amixer, rsc)->idx[0];
  34 }
  35
  36 static void amixer_next_conj(struct rsc *rsc)
  37 {
  38         rsc->conj++;
  39 }
  40
  41 static int amixer_index(const struct rsc *rsc)
  42 {
  43         return container_of(rsc, struct amixer, rsc)->idx[rsc->conj];
  44 }
  45
  46 static int amixer_output_slot(const struct rsc *rsc)
  47 {
  48         return (amixer_index(rsc) << 4) + 0x4;
  49 }
  50
  51 static const struct rsc_ops amixer_basic_rsc_ops = {
  52         .master         = amixer_master,
  53         .next_conj      = amixer_next_conj,
  54         .index          = amixer_index,
  55         .output_slot    = amixer_output_slot,
  56 };
  57
  58 static int amixer_set_input(struct amixer *amixer, struct rsc *rsc)
  59 {
  60         struct hw *hw;
  61
  62         hw = amixer->rsc.hw;
  63         hw->amixer_set_mode(amixer->rsc.ctrl_blk, AMIXER_Y_IMMEDIATE);
  64         amixer->input = rsc;
  65         if (!rsc)
  66                 hw->amixer_set_x(amixer->rsc.ctrl_blk, BLANK_SLOT);
  67         else
  68                 hw->amixer_set_x(amixer->rsc.ctrl_blk,
  69                                         rsc->ops->output_slot(rsc));
  70
  71         return 0;
  72 }
  73
  74 /* y is a 14-bit immediate constant */
  75 static int amixer_set_y(struct amixer *amixer, unsigned int y)
  76 {
  77         struct hw *hw;
  78
  79         hw = amixer->rsc.hw;
  80         hw->amixer_set_y(amixer->rsc.ctrl_blk, y);
  81
  82         return 0;
  83 }
  84
  85 static int amixer_set_invalid_squash(struct amixer *amixer, unsigned int iv)
  86 {
  87         struct hw *hw;
  88
  89         hw = amixer->rsc.hw;
  90         hw->amixer_set_iv(amixer->rsc.ctrl_blk, iv);
  91
  92         return 0;
  93 }
  94
  95 static int amixer_set_sum(struct amixer *amixer, struct sum *sum)
  96 {
  97         struct hw *hw;
  98
  99         hw = amixer->rsc.hw;
 100         amixer->sum = sum;
 101         if (!sum) {
 102                 hw->amixer_set_se(amixer->rsc.ctrl_blk, 0);
 103         } else {
 104                 hw->amixer_set_se(amixer->rsc.ctrl_blk, 1);
 105                 hw->amixer_set_sadr(amixer->rsc.ctrl_blk,
 106                                         sum->rsc.ops->index(&sum->rsc));
 107         }
 108
 109         return 0;
 110 }
 111
 112 static int amixer_commit_write(struct amixer *amixer)
 113 {
 114         struct hw *hw;
 115         unsigned int index;
 116         int i;
 117         struct rsc *input;
 118         struct sum *sum;
 119
 120         hw = amixer->rsc.hw;
 121         input = amixer->input;
 122         sum = amixer->sum;
 123
 124         /* Program master and conjugate resources */
 125         amixer->rsc.ops->master(&amixer->rsc);
 126         if (input)
 127                 input->ops->master(input);
 128
 129         if (sum)
 130                 sum->rsc.ops->master(&sum->rsc);
 131
 132         for (i = 0; i < amixer->rsc.msr; i++) {
 133                 hw->amixer_set_dirty_all(amixer->rsc.ctrl_blk);
 134                 if (input) {
 135                         hw->amixer_set_x(amixer->rsc.ctrl_blk,
 136                                                 input->ops->output_slot(input));
 137                         input->ops->next_conj(input);
 138                 }
 139                 if (sum) {
 140                         hw->amixer_set_sadr(amixer->rsc.ctrl_blk,
 141                                                 sum->rsc.ops->index(&sum->rsc));
 142                         sum->rsc.ops->next_conj(&sum->rsc);
 143                 }
 144                 index = amixer->rsc.ops->output_slot(&amixer->rsc);
 145                 hw->amixer_commit_write(hw, index, amixer->rsc.ctrl_blk);
 146                 amixer->rsc.ops->next_conj(&amixer->rsc);
 147         }
 148         amixer->rsc.ops->master(&amixer->rsc);
 149         if (input)
 150                 input->ops->master(input);
 151
 152         if (sum)
 153                 sum->rsc.ops->master(&sum->rsc);
 154
 155         return 0;
 156 }
 157
 158 static int amixer_commit_raw_write(struct amixer *amixer)
 159 {
 160         struct hw *hw;
 161         unsigned int index;
 162
 163         hw = amixer->rsc.hw;
 164         index = amixer->rsc.ops->output_slot(&amixer->rsc);
 165         hw->amixer_commit_write(hw, index, amixer->rsc.ctrl_blk);
 166
 167         return 0;
 168 }
 169
 170 static int amixer_get_y(struct amixer *amixer)
 171 {
 172         struct hw *hw;
 173
 174         hw = amixer->rsc.hw;
 175         return hw->amixer_get_y(amixer->rsc.ctrl_blk);
 176 }
 177
 178 static int amixer_setup(struct amixer *amixer, struct rsc *input,
 179                         unsigned int scale, struct sum *sum)
 180 {
 181         amixer_set_input(amixer, input);
 182         amixer_set_y(amixer, scale);
 183         amixer_set_sum(amixer, sum);
 184         amixer_commit_write(amixer);
 185         return 0;
 186 }
 187
 188 static const struct amixer_rsc_ops amixer_ops = {
 189         .set_input              = amixer_set_input,
 190         .set_invalid_squash     = amixer_set_invalid_squash,
 191         .set_scale              = amixer_set_y,
 192         .set_sum                = amixer_set_sum,
 193         .commit_write           = amixer_commit_write,
 194         .commit_raw_write       = amixer_commit_raw_write,
 195         .setup                  = amixer_setup,
 196         .get_scale              = amixer_get_y,
 197 };
 198
 199 static int amixer_rsc_init(struct amixer *amixer,
 200                            const struct amixer_desc *desc,
 201                            struct amixer_mgr *mgr)
 202 {
 203         int err;
 204
 205         err = rsc_init(&amixer->rsc, amixer->idx[0],
 206                         AMIXER, desc->msr, mgr->mgr.hw);
 207         if (err)
 208                 return err;
 209
 210         /* Set amixer specific operations */
 211         amixer->rsc.ops = &amixer_basic_rsc_ops;
 212         amixer->ops = &amixer_ops;
 213         amixer->input = NULL;
 214         amixer->sum = NULL;
 215
 216         amixer_setup(amixer, NULL, 0, NULL);
 217
 218         return 0;
 219 }
 220
 221 static int amixer_rsc_uninit(struct amixer *amixer)
 222 {
 223         amixer_setup(amixer, NULL, 0, NULL);
 224         rsc_uninit(&amixer->rsc);
 225         amixer->ops = NULL;
 226         amixer->input = NULL;
 227         amixer->sum = NULL;
 228         return 0;
 229 }
 230
 231 static int get_amixer_rsc(struct amixer_mgr *mgr,
 232                           const struct amixer_desc *desc,
 233                           struct amixer **ramixer)
 234 {
 235         int err, i;
 236         unsigned int idx;
 237         struct amixer *amixer;
 238         unsigned long flags;
 239
 240         *ramixer = NULL;
 241
 242         /* Allocate mem for amixer resource */
 243         amixer = kzalloc(sizeof(*amixer), GFP_KERNEL);
 244         if (!amixer)
 245                 return -ENOMEM;
 246
 247         /* Check whether there are sufficient
 248          * amixer resources to meet request. */
 249         err = 0;
 250         spin_lock_irqsave(&mgr->mgr_lock, flags);
 251         for (i = 0; i < desc->msr; i++) {
 252                 err = mgr_get_resource(&mgr->mgr, 1, &idx);
 253                 if (err)
 254                         break;
 255
 256                 amixer->idx[i] = idx;
 257         }
 258         spin_unlock_irqrestore(&mgr->mgr_lock, flags);
 259         if (err) {
 260                 dev_err(mgr->card->dev,
 261                         "Can't meet AMIXER resource request!\n");
 262                 goto error;
 263         }
 264
 265         err = amixer_rsc_init(amixer, desc, mgr);
 266         if (err)
 267                 goto error;
 268
 269         *ramixer = amixer;
 270
 271         return 0;
 272
 273 error:
 274         spin_lock_irqsave(&mgr->mgr_lock, flags);
 275         for (i--; i >= 0; i--)
 276                 mgr_put_resource(&mgr->mgr, 1, amixer->idx[i]);
 277
 278         spin_unlock_irqrestore(&mgr->mgr_lock, flags);
 279         kfree(amixer);
 280         return err;
 281 }
 282
 283 static int put_amixer_rsc(struct amixer_mgr *mgr, struct amixer *amixer)
 284 {
 285         unsigned long flags;
 286         int i;
 287
 288         spin_lock_irqsave(&mgr->mgr_lock, flags);
 289         for (i = 0; i < amixer->rsc.msr; i++)
 290                 mgr_put_resource(&mgr->mgr, 1, amixer->idx[i]);
 291
 292         spin_unlock_irqrestore(&mgr->mgr_lock, flags);
 293         amixer_rsc_uninit(amixer);
 294         kfree(amixer);
 295
 296         return 0;
 297 }
 298
 299 int amixer_mgr_create(struct hw *hw, struct amixer_mgr **ramixer_mgr)
 300 {
 301         int err;
 302         struct amixer_mgr *amixer_mgr;
 303
 304         *ramixer_mgr = NULL;
 305         amixer_mgr = kzalloc(sizeof(*amixer_mgr), GFP_KERNEL);
 306         if (!amixer_mgr)
 307                 return -ENOMEM;
 308
 309         err = rsc_mgr_init(&amixer_mgr->mgr, AMIXER, AMIXER_RESOURCE_NUM, hw);
 310         if (err)
 311                 goto error;
 312
 313         spin_lock_init(&amixer_mgr->mgr_lock);
 314
 315         amixer_mgr->get_amixer = get_amixer_rsc;
 316         amixer_mgr->put_amixer = put_amixer_rsc;
 317         amixer_mgr->card = hw->card;
 318
 319         *ramixer_mgr = amixer_mgr;
 320
 321         return 0;
 322
 323 error:
 324         kfree(amixer_mgr);
 325         return err;
 326 }
 327
 328 int amixer_mgr_destroy(struct amixer_mgr *amixer_mgr)
 329 {
 330         rsc_mgr_uninit(&amixer_mgr->mgr);
 331         kfree(amixer_mgr);
 332         return 0;
 333 }
 334
 335 /* SUM resource management */
 336
 337 static void sum_master(struct rsc *rsc)
 338 {
 339         rsc->conj = 0;
 340         rsc->idx = container_of(rsc, struct sum, rsc)->idx[0];
 341 }
 342
 343 static void sum_next_conj(struct rsc *rsc)
 344 {
 345         rsc->conj++;
 346 }
 347
 348 static int sum_index(const struct rsc *rsc)
 349 {
 350         return container_of(rsc, struct sum, rsc)->idx[rsc->conj];
 351 }
 352
 353 static int sum_output_slot(const struct rsc *rsc)
 354 {
 355         return (sum_index(rsc) << 4) + 0xc;
 356 }
 357
 358 static const struct rsc_ops sum_basic_rsc_ops = {
 359         .master         = sum_master,
 360         .next_conj      = sum_next_conj,
 361         .index          = sum_index,
 362         .output_slot    = sum_output_slot,
 363 };
 364
 365 static int sum_rsc_init(struct sum *sum,
 366                         const struct sum_desc *desc,
 367                         struct sum_mgr *mgr)
 368 {
 369         int err;
 370
 371         err = rsc_init(&sum->rsc, sum->idx[0], SUM, desc->msr, mgr->mgr.hw);
 372         if (err)
 373                 return err;
 374
 375         sum->rsc.ops = &sum_basic_rsc_ops;
 376
 377         return 0;
 378 }
 379
 380 static int sum_rsc_uninit(struct sum *sum)
 381 {
 382         rsc_uninit(&sum->rsc);
 383         return 0;
 384 }
 385
 386 static int get_sum_rsc(struct sum_mgr *mgr,
 387                        const struct sum_desc *desc,
 388                        struct sum **rsum)
 389 {
 390         int err, i;
 391         unsigned int idx;
 392         struct sum *sum;
 393         unsigned long flags;
 394
 395         *rsum = NULL;
 396
 397         /* Allocate mem for sum resource */
 398         sum = kzalloc(sizeof(*sum), GFP_KERNEL);
 399         if (!sum)
 400                 return -ENOMEM;
 401
 402         /* Check whether there are sufficient sum resources to meet request. */
 403         err = 0;
 404         spin_lock_irqsave(&mgr->mgr_lock, flags);
 405         for (i = 0; i < desc->msr; i++) {
 406                 err = mgr_get_resource(&mgr->mgr, 1, &idx);
 407                 if (err)
 408                         break;
 409
 410                 sum->idx[i] = idx;
 411         }
 412         spin_unlock_irqrestore(&mgr->mgr_lock, flags);
 413         if (err) {
 414                 dev_err(mgr->card->dev,
 415                         "Can't meet SUM resource request!\n");
 416                 goto error;
 417         }
 418
 419         err = sum_rsc_init(sum, desc, mgr);
 420         if (err)
 421                 goto error;
 422
 423         *rsum = sum;
 424
 425         return 0;
 426
 427 error:
 428         spin_lock_irqsave(&mgr->mgr_lock, flags);
 429         for (i--; i >= 0; i--)
 430                 mgr_put_resource(&mgr->mgr, 1, sum->idx[i]);
 431
 432         spin_unlock_irqrestore(&mgr->mgr_lock, flags);
 433         kfree(sum);
 434         return err;
 435 }
 436
 437 static int put_sum_rsc(struct sum_mgr *mgr, struct sum *sum)
 438 {
 439         unsigned long flags;
 440         int i;
 441
 442         spin_lock_irqsave(&mgr->mgr_lock, flags);
 443         for (i = 0; i < sum->rsc.msr; i++)
 444                 mgr_put_resource(&mgr->mgr, 1, sum->idx[i]);
 445
 446         spin_unlock_irqrestore(&mgr->mgr_lock, flags);
 447         sum_rsc_uninit(sum);
 448         kfree(sum);
 449
 450         return 0;
 451 }
 452
 453 int sum_mgr_create(struct hw *hw, struct sum_mgr **rsum_mgr)
 454 {
 455         int err;
 456         struct sum_mgr *sum_mgr;
 457
 458         *rsum_mgr = NULL;
 459         sum_mgr = kzalloc(sizeof(*sum_mgr), GFP_KERNEL);
 460         if (!sum_mgr)
 461                 return -ENOMEM;
 462
 463         err = rsc_mgr_init(&sum_mgr->mgr, SUM, SUM_RESOURCE_NUM, hw);
 464         if (err)
 465                 goto error;
 466
 467         spin_lock_init(&sum_mgr->mgr_lock);
 468
 469         sum_mgr->get_sum = get_sum_rsc;
 470         sum_mgr->put_sum = put_sum_rsc;
 471         sum_mgr->card = hw->card;
 472
 473         *rsum_mgr = sum_mgr;
 474
 475         return 0;
 476
 477 error:
 478         kfree(sum_mgr);
 479         return err;
 480 }
 481
 482 int sum_mgr_destroy(struct sum_mgr *sum_mgr)
 483 {
 484         rsc_mgr_uninit(&sum_mgr->mgr);
 485         kfree(sum_mgr);
 486         return 0;
 487 }
 488