sound/oss/dmasound/tas3001c.c

   1 /*
   2  * Driver for the i2c/i2s based TA3004 sound chip used
   3  * on some Apple hardware. Also known as "snapper".
   4  *
   5  * Tobias Sargeant <tobias.sargeant@bigpond.com>
   6  * Based upon, tas3001c.c by Christopher C. Chimelis <chris@debian.org>:
   7  *
   8  *   TODO:
   9  *   -----
  10  *   * Enable control over input line 2 (is this connected?)
  11  *   * Implement sleep support (at least mute everything and
  12  *   * set gains to minimum during sleep)
  13  *   * Look into some of Darwin's tweaks regarding the mute
  14  *   * lines (delays & different behaviour on some HW)
  15  *
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/slab.h>
  20 #include <linux/proc_fs.h>
  21 #include <linux/ioport.h>
  22 #include <linux/sysctl.h>
  23 #include <linux/types.h>
  24 #include <linux/i2c.h>
  25 #include <linux/init.h>
  26 #include <linux/soundcard.h>
  27 #include <linux/workqueue.h>
  28 #include <asm/uaccess.h>
  29 #include <asm/errno.h>
  30 #include <asm/io.h>
  31 #include <asm/prom.h>
  32
  33 #include "dmasound.h"
  34 #include "tas_common.h"
  35 #include "tas3001c.h"
  36
  37 #include "tas_ioctl.h"
  38
  39 #define TAS3001C_BIQUAD_FILTER_COUNT  6
  40 #define TAS3001C_BIQUAD_CHANNEL_COUNT 2
  41
  42 #define VOL_DEFAULT     (100 * 4 / 5)
  43 #define INPUT_DEFAULT   (100 * 4 / 5)
  44 #define BASS_DEFAULT    (100 / 2)
  45 #define TREBLE_DEFAULT  (100 / 2)
  46
  47 struct tas3001c_data_t {
  48         struct tas_data_t super;
  49         int device_id;
  50         int output_id;
  51         int speaker_id;
  52         struct tas_drce_t drce_state;
  53 };
  54
  55
  56 static const union tas_biquad_t
  57 tas3001c_eq_unity={
  58         .buf = { 0x100000, 0x000000, 0x000000, 0x000000, 0x000000 }
  59 };
  60
  61
  62 static inline unsigned char db_to_regval(short db) {
  63         int r=0;
  64
  65         r=(db+0x59a0) / 0x60;
  66
  67         if (r < 0x91) return 0x91;
  68         if (r > 0xef) return 0xef;
  69         return r;
  70 }
  71
  72 static inline short quantize_db(short db) {
  73         return db_to_regval(db) * 0x60 - 0x59a0;
  74 }
  75
  76
  77 static inline int
  78 register_width(enum tas3001c_reg_t r)
  79 {
  80         switch(r) {
  81         case TAS3001C_REG_MCR:
  82         case TAS3001C_REG_TREBLE:
  83         case TAS3001C_REG_BASS:
  84                 return 1;
  85
  86         case TAS3001C_REG_DRC:
  87                 return 2;
  88
  89         case TAS3001C_REG_MIXER1:
  90         case TAS3001C_REG_MIXER2:
  91                 return 3;
  92
  93         case TAS3001C_REG_VOLUME:
  94                 return 6;
  95
  96         case TAS3001C_REG_LEFT_BIQUAD0:
  97         case TAS3001C_REG_LEFT_BIQUAD1:
  98         case TAS3001C_REG_LEFT_BIQUAD2:
  99         case TAS3001C_REG_LEFT_BIQUAD3:
 100         case TAS3001C_REG_LEFT_BIQUAD4:
 101         case TAS3001C_REG_LEFT_BIQUAD5:
 102         case TAS3001C_REG_LEFT_BIQUAD6:
 103
 104         case TAS3001C_REG_RIGHT_BIQUAD0:
 105         case TAS3001C_REG_RIGHT_BIQUAD1:
 106         case TAS3001C_REG_RIGHT_BIQUAD2:
 107         case TAS3001C_REG_RIGHT_BIQUAD3:
 108         case TAS3001C_REG_RIGHT_BIQUAD4:
 109         case TAS3001C_REG_RIGHT_BIQUAD5:
 110         case TAS3001C_REG_RIGHT_BIQUAD6:
 111                 return 15;
 112
 113         default:
 114                 return 0;
 115         }
 116 }
 117
 118 static int
 119 tas3001c_write_register(        struct tas3001c_data_t *self,
 120                                 enum tas3001c_reg_t reg_num,
 121                                 char *data,
 122                                 uint write_mode)
 123 {
 124         if (reg_num==TAS3001C_REG_MCR ||
 125             reg_num==TAS3001C_REG_BASS ||
 126             reg_num==TAS3001C_REG_TREBLE) {
 127                 return tas_write_byte_register(&self->super,
 128                                                (uint)reg_num,
 129                                                *data,
 130                                                write_mode);
 131         } else {
 132                 return tas_write_register(&self->super,
 133                                           (uint)reg_num,
 134                                           register_width(reg_num),
 135                                           data,
 136                                           write_mode);
 137         }
 138 }
 139
 140 static int
 141 tas3001c_sync_register( struct tas3001c_data_t *self,
 142                         enum tas3001c_reg_t reg_num)
 143 {
 144         if (reg_num==TAS3001C_REG_MCR ||
 145             reg_num==TAS3001C_REG_BASS ||
 146             reg_num==TAS3001C_REG_TREBLE) {
 147                 return tas_sync_byte_register(&self->super,
 148                                               (uint)reg_num,
 149                                               register_width(reg_num));
 150         } else {
 151                 return tas_sync_register(&self->super,
 152                                          (uint)reg_num,
 153                                          register_width(reg_num));
 154         }
 155 }
 156
 157 static int
 158 tas3001c_read_register( struct tas3001c_data_t *self,
 159                         enum tas3001c_reg_t reg_num,
 160                         char *data,
 161                         uint write_mode)
 162 {
 163         return tas_read_register(&self->super,
 164                                  (uint)reg_num,
 165                                  register_width(reg_num),
 166                                  data);
 167 }
 168
 169 static inline int
 170 tas3001c_fast_load(struct tas3001c_data_t *self, int fast)
 171 {
 172         if (fast)
 173                 self->super.shadow[TAS3001C_REG_MCR][0] |= 0x80;
 174         else
 175                 self->super.shadow[TAS3001C_REG_MCR][0] &= 0x7f;
 176         return tas3001c_sync_register(self,TAS3001C_REG_MCR);
 177 }
 178
 179 static uint
 180 tas3001c_supported_mixers(struct tas3001c_data_t *self)
 181 {
 182         return SOUND_MASK_VOLUME |
 183                 SOUND_MASK_PCM |
 184                 SOUND_MASK_ALTPCM |
 185                 SOUND_MASK_TREBLE |
 186                 SOUND_MASK_BASS;
 187 }
 188
 189 static int
 190 tas3001c_mixer_is_stereo(struct tas3001c_data_t *self,int mixer)
 191 {
 192         switch(mixer) {
 193         case SOUND_MIXER_VOLUME:
 194                 return 1;
 195         default:
 196                 return 0;
 197         }
 198 }
 199
 200 static uint
 201 tas3001c_stereo_mixers(struct tas3001c_data_t *self)
 202 {
 203         uint r=tas3001c_supported_mixers(self);
 204         uint i;
 205
 206         for (i=1; i<SOUND_MIXER_NRDEVICES; i++)
 207                 if (r&(1<<i) && !tas3001c_mixer_is_stereo(self,i))
 208                         r &= ~(1<<i);
 209         return r;
 210 }
 211
 212 static int
 213 tas3001c_get_mixer_level(struct tas3001c_data_t *self,int mixer,uint *level)
 214 {
 215         if (!self)
 216                 return -1;
 217
 218         *level=self->super.mixer[mixer];
 219
 220         return 0;
 221 }
 222
 223 static int
 224 tas3001c_set_mixer_level(struct tas3001c_data_t *self,int mixer,uint level)
 225 {
 226         int rc;
 227         tas_shadow_t *shadow;
 228
 229         uint temp;
 230         uint offset=0;
 231
 232         if (!self)
 233                 return -1;
 234
 235         shadow=self->super.shadow;
 236
 237         if (!tas3001c_mixer_is_stereo(self,mixer))
 238                 level = tas_mono_to_stereo(level);
 239
 240         switch(mixer) {
 241         case SOUND_MIXER_VOLUME:
 242                 temp = tas3001c_gain.master[level&0xff];
 243                 shadow[TAS3001C_REG_VOLUME][0] = (temp >> 16) & 0xff;
 244                 shadow[TAS3001C_REG_VOLUME][1] = (temp >> 8)  & 0xff;
 245                 shadow[TAS3001C_REG_VOLUME][2] = (temp >> 0)  & 0xff;
 246                 temp = tas3001c_gain.master[(level>>8)&0xff];
 247                 shadow[TAS3001C_REG_VOLUME][3] = (temp >> 16) & 0xff;
 248                 shadow[TAS3001C_REG_VOLUME][4] = (temp >> 8)  & 0xff;
 249                 shadow[TAS3001C_REG_VOLUME][5] = (temp >> 0)  & 0xff;
 250                 rc = tas3001c_sync_register(self,TAS3001C_REG_VOLUME);
 251                 break;
 252         case SOUND_MIXER_ALTPCM:
 253                 /* tas3001c_fast_load(self, 1); */
 254                 level = tas_mono_to_stereo(level);
 255                 temp = tas3001c_gain.mixer[level&0xff];
 256                 shadow[TAS3001C_REG_MIXER2][offset+0] = (temp >> 16) & 0xff;
 257                 shadow[TAS3001C_REG_MIXER2][offset+1] = (temp >> 8)  & 0xff;
 258                 shadow[TAS3001C_REG_MIXER2][offset+2] = (temp >> 0)  & 0xff;
 259                 rc = tas3001c_sync_register(self,TAS3001C_REG_MIXER2);
 260                 /* tas3001c_fast_load(self, 0); */
 261                 break;
 262         case SOUND_MIXER_PCM:
 263                 /* tas3001c_fast_load(self, 1); */
 264                 level = tas_mono_to_stereo(level);
 265                 temp = tas3001c_gain.mixer[level&0xff];
 266                 shadow[TAS3001C_REG_MIXER1][offset+0] = (temp >> 16) & 0xff;
 267                 shadow[TAS3001C_REG_MIXER1][offset+1] = (temp >> 8)  & 0xff;
 268                 shadow[TAS3001C_REG_MIXER1][offset+2] = (temp >> 0)  & 0xff;
 269                 rc = tas3001c_sync_register(self,TAS3001C_REG_MIXER1);
 270                 /* tas3001c_fast_load(self, 0); */
 271                 break;
 272         case SOUND_MIXER_TREBLE:
 273                 temp = tas3001c_gain.treble[level&0xff];
 274                 shadow[TAS3001C_REG_TREBLE][0]=temp&0xff;
 275                 rc = tas3001c_sync_register(self,TAS3001C_REG_TREBLE);
 276                 break;
 277         case SOUND_MIXER_BASS:
 278                 temp = tas3001c_gain.bass[level&0xff];
 279                 shadow[TAS3001C_REG_BASS][0]=temp&0xff;
 280                 rc = tas3001c_sync_register(self,TAS3001C_REG_BASS);
 281                 break;
 282         default:
 283                 rc = -1;
 284                 break;
 285         }
 286         if (rc < 0)
 287                 return rc;
 288         self->super.mixer[mixer]=level;
 289         return 0;
 290 }
 291
 292 static int
 293 tas3001c_leave_sleep(struct tas3001c_data_t *self)
 294 {
 295         unsigned char mcr = (1<<6)+(2<<4)+(2<<2);
 296
 297         if (!self)
 298                 return -1;
 299
 300         /* Make sure something answers on the i2c bus */
 301         if (tas3001c_write_register(self, TAS3001C_REG_MCR, &mcr,
 302             WRITE_NORMAL|FORCE_WRITE) < 0)
 303                 return -1;
 304
 305         tas3001c_fast_load(self, 1);
 306
 307         (void)tas3001c_sync_register(self,TAS3001C_REG_RIGHT_BIQUAD0);
 308         (void)tas3001c_sync_register(self,TAS3001C_REG_RIGHT_BIQUAD1);
 309         (void)tas3001c_sync_register(self,TAS3001C_REG_RIGHT_BIQUAD2);
 310         (void)tas3001c_sync_register(self,TAS3001C_REG_RIGHT_BIQUAD3);
 311         (void)tas3001c_sync_register(self,TAS3001C_REG_RIGHT_BIQUAD4);
 312         (void)tas3001c_sync_register(self,TAS3001C_REG_RIGHT_BIQUAD5);
 313
 314         (void)tas3001c_sync_register(self,TAS3001C_REG_LEFT_BIQUAD0);
 315         (void)tas3001c_sync_register(self,TAS3001C_REG_LEFT_BIQUAD1);
 316         (void)tas3001c_sync_register(self,TAS3001C_REG_LEFT_BIQUAD2);
 317         (void)tas3001c_sync_register(self,TAS3001C_REG_LEFT_BIQUAD3);
 318         (void)tas3001c_sync_register(self,TAS3001C_REG_LEFT_BIQUAD4);
 319         (void)tas3001c_sync_register(self,TAS3001C_REG_LEFT_BIQUAD5);
 320
 321         tas3001c_fast_load(self, 0);
 322
 323         (void)tas3001c_sync_register(self,TAS3001C_REG_BASS);
 324         (void)tas3001c_sync_register(self,TAS3001C_REG_TREBLE);
 325         (void)tas3001c_sync_register(self,TAS3001C_REG_MIXER1);
 326         (void)tas3001c_sync_register(self,TAS3001C_REG_MIXER2);
 327         (void)tas3001c_sync_register(self,TAS3001C_REG_VOLUME);
 328
 329         return 0;
 330 }
 331
 332 static int
 333 tas3001c_enter_sleep(struct tas3001c_data_t *self)
 334 {
 335         /* Stub for now, but I have the details on low-power mode */
 336         if (!self)
 337                 return -1;
 338         return 0;
 339 }
 340
 341 static int
 342 tas3001c_sync_biquad(   struct tas3001c_data_t *self,
 343                         u_int channel,
 344                         u_int filter)
 345 {
 346         enum tas3001c_reg_t reg;
 347
 348         if (channel >= TAS3001C_BIQUAD_CHANNEL_COUNT ||
 349             filter  >= TAS3001C_BIQUAD_FILTER_COUNT) return -EINVAL;
 350
 351         reg=( channel ? TAS3001C_REG_RIGHT_BIQUAD0 : TAS3001C_REG_LEFT_BIQUAD0 ) + filter;
 352
 353         return tas3001c_sync_register(self,reg);
 354 }
 355
 356 static int
 357 tas3001c_write_biquad_shadow(   struct tas3001c_data_t *self,
 358                                 u_int channel,
 359                                 u_int filter,
 360                                 const union tas_biquad_t *biquad)
 361 {
 362         tas_shadow_t *shadow=self->super.shadow;
 363         enum tas3001c_reg_t reg;
 364
 365         if (channel >= TAS3001C_BIQUAD_CHANNEL_COUNT ||
 366             filter  >= TAS3001C_BIQUAD_FILTER_COUNT) return -EINVAL;
 367
 368         reg=( channel ? TAS3001C_REG_RIGHT_BIQUAD0 : TAS3001C_REG_LEFT_BIQUAD0 ) + filter;
 369
 370         SET_4_20(shadow[reg], 0,biquad->coeff.b0);
 371         SET_4_20(shadow[reg], 3,biquad->coeff.b1);
 372         SET_4_20(shadow[reg], 6,biquad->coeff.b2);
 373         SET_4_20(shadow[reg], 9,biquad->coeff.a1);
 374         SET_4_20(shadow[reg],12,biquad->coeff.a2);
 375
 376         return 0;
 377 }
 378
 379 static int
 380 tas3001c_write_biquad(  struct tas3001c_data_t *self,
 381                         u_int channel,
 382                         u_int filter,
 383                         const union tas_biquad_t *biquad)
 384 {
 385         int rc;
 386
 387         rc=tas3001c_write_biquad_shadow(self, channel, filter, biquad);
 388         if (rc < 0) return rc;
 389
 390         return tas3001c_sync_biquad(self, channel, filter);
 391 }
 392
 393 static int
 394 tas3001c_write_biquad_list(     struct tas3001c_data_t *self,
 395                                 u_int filter_count,
 396                                 u_int flags,
 397                                 struct tas_biquad_ctrl_t *biquads)
 398 {
 399         int i;
 400         int rc;
 401
 402         if (flags & TAS_BIQUAD_FAST_LOAD) tas3001c_fast_load(self,1);
 403
 404         for (i=0; i<filter_count; i++) {
 405                 rc=tas3001c_write_biquad(self,
 406                                          biquads[i].channel,
 407                                          biquads[i].filter,
 408                                          &biquads[i].data);
 409                 if (rc < 0) break;
 410         }
 411
 412         if (flags & TAS_BIQUAD_FAST_LOAD) {
 413                 tas3001c_fast_load(self,0);
 414
 415                 (void)tas3001c_sync_register(self,TAS3001C_REG_BASS);
 416                 (void)tas3001c_sync_register(self,TAS3001C_REG_TREBLE);
 417                 (void)tas3001c_sync_register(self,TAS3001C_REG_MIXER1);
 418                 (void)tas3001c_sync_register(self,TAS3001C_REG_MIXER2);
 419                 (void)tas3001c_sync_register(self,TAS3001C_REG_VOLUME);
 420         }
 421
 422         return rc;
 423 }
 424
 425 static int
 426 tas3001c_read_biquad(   struct tas3001c_data_t *self,
 427                         u_int channel,
 428                         u_int filter,
 429                         union tas_biquad_t *biquad)
 430 {
 431         tas_shadow_t *shadow=self->super.shadow;
 432         enum tas3001c_reg_t reg;
 433
 434         if (channel >= TAS3001C_BIQUAD_CHANNEL_COUNT ||
 435             filter  >= TAS3001C_BIQUAD_FILTER_COUNT) return -EINVAL;
 436
 437         reg=( channel ? TAS3001C_REG_RIGHT_BIQUAD0 : TAS3001C_REG_LEFT_BIQUAD0 ) + filter;
 438
 439         biquad->coeff.b0=GET_4_20(shadow[reg], 0);
 440         biquad->coeff.b1=GET_4_20(shadow[reg], 3);
 441         biquad->coeff.b2=GET_4_20(shadow[reg], 6);
 442         biquad->coeff.a1=GET_4_20(shadow[reg], 9);
 443         biquad->coeff.a2=GET_4_20(shadow[reg],12);
 444
 445         return 0;
 446 }
 447
 448 static int
 449 tas3001c_eq_rw( struct tas3001c_data_t *self,
 450                 u_int cmd,
 451                 u_long arg)
 452 {
 453         int rc;
 454         struct tas_biquad_ctrl_t biquad;
 455
 456         if (copy_from_user((void *)&biquad, (const void *)arg, sizeof(struct tas_biquad_ctrl_t))) {
 457                 return -EFAULT;
 458         }
 459
 460         if (cmd & SIOC_IN) {
 461                 rc=tas3001c_write_biquad(self, biquad.channel, biquad.filter, &biquad.data);
 462                 if (rc != 0) return rc;
 463         }
 464
 465         if (cmd & SIOC_OUT) {
 466                 rc=tas3001c_read_biquad(self, biquad.channel, biquad.filter, &biquad.data);
 467                 if (rc != 0) return rc;
 468
 469                 if (copy_to_user((void *)arg, (const void *)&biquad, sizeof(struct tas_biquad_ctrl_t))) {
 470                         return -EFAULT;
 471                 }
 472
 473         }
 474         return 0;
 475 }
 476
 477 static int
 478 tas3001c_eq_list_rw(    struct tas3001c_data_t *self,
 479                         u_int cmd,
 480                         u_long arg)
 481 {
 482         int rc;
 483         int filter_count;
 484         int flags;
 485         int i,j;
 486         char sync_required[2][6];
 487         struct tas_biquad_ctrl_t biquad;
 488
 489         memset(sync_required,0,sizeof(sync_required));
 490
 491         if (copy_from_user((void *)&filter_count,
 492                            (const void *)arg + offsetof(struct tas_biquad_ctrl_list_t,filter_count),
 493                            sizeof(int))) {
 494                 return -EFAULT;
 495         }
 496
 497         if (copy_from_user((void *)&flags,
 498                            (const void *)arg + offsetof(struct tas_biquad_ctrl_list_t,flags),
 499                            sizeof(int))) {
 500                 return -EFAULT;
 501         }
 502
 503         if (cmd & SIOC_IN) {
 504         }
 505
 506         for (i=0; i < filter_count; i++) {
 507                 if (copy_from_user((void *)&biquad,
 508                                    (const void *)arg + offsetof(struct tas_biquad_ctrl_list_t, biquads[i]),
 509                                    sizeof(struct tas_biquad_ctrl_t))) {
 510                         return -EFAULT;
 511                 }
 512
 513                 if (cmd & SIOC_IN) {
 514                         sync_required[biquad.channel][biquad.filter]=1;
 515                         rc=tas3001c_write_biquad_shadow(self, biquad.channel, biquad.filter, &biquad.data);
 516                         if (rc != 0) return rc;
 517                 }
 518
 519                 if (cmd & SIOC_OUT) {
 520                         rc=tas3001c_read_biquad(self, biquad.channel, biquad.filter, &biquad.data);
 521                         if (rc != 0) return rc;
 522
 523                         if (copy_to_user((void *)arg + offsetof(struct tas_biquad_ctrl_list_t, biquads[i]),
 524                                          (const void *)&biquad,
 525                                          sizeof(struct tas_biquad_ctrl_t))) {
 526                                 return -EFAULT;
 527                         }
 528                 }
 529         }
 530
 531         if (cmd & SIOC_IN) {
 532                 if (flags & TAS_BIQUAD_FAST_LOAD) tas3001c_fast_load(self,1);
 533                 for (i=0; i<2; i++) {
 534                         for (j=0; j<6; j++) {
 535                                 if (sync_required[i][j]) {
 536                                         rc=tas3001c_sync_biquad(self, i, j);
 537                                         if (rc < 0) return rc;
 538                                 }
 539                         }
 540                 }
 541                 if (flags & TAS_BIQUAD_FAST_LOAD) {
 542                         tas3001c_fast_load(self,0);
 543                         /* now we need to set up the mixers again,
 544                            because leaving fast mode resets them. */
 545                         (void)tas3001c_sync_register(self,TAS3001C_REG_BASS);
 546                         (void)tas3001c_sync_register(self,TAS3001C_REG_TREBLE);
 547                         (void)tas3001c_sync_register(self,TAS3001C_REG_MIXER1);
 548                         (void)tas3001c_sync_register(self,TAS3001C_REG_MIXER2);
 549                         (void)tas3001c_sync_register(self,TAS3001C_REG_VOLUME);
 550                 }
 551         }
 552
 553         return 0;
 554 }
 555
 556 static int
 557 tas3001c_update_drce(   struct tas3001c_data_t *self,
 558                         int flags,
 559                         struct tas_drce_t *drce)
 560 {
 561         tas_shadow_t *shadow;
 562         shadow=self->super.shadow;
 563
 564         shadow[TAS3001C_REG_DRC][1] = 0xc1;
 565
 566         if (flags & TAS_DRCE_THRESHOLD) {
 567                 self->drce_state.threshold=quantize_db(drce->threshold);
 568                 shadow[TAS3001C_REG_DRC][2] = db_to_regval(self->drce_state.threshold);
 569         }
 570
 571         if (flags & TAS_DRCE_ENABLE) {
 572                 self->drce_state.enable = drce->enable;
 573         }
 574
 575         if (!self->drce_state.enable) {
 576                 shadow[TAS3001C_REG_DRC][0] = 0xf0;
 577         }
 578
 579 #ifdef DEBUG_DRCE
 580         printk("DRCE IOCTL: set [ ENABLE:%x THRESH:%x\n",
 581                self->drce_state.enable,
 582                self->drce_state.threshold);
 583
 584         printk("DRCE IOCTL: reg [ %02x %02x ]\n",
 585                (unsigned char)shadow[TAS3001C_REG_DRC][0],
 586                (unsigned char)shadow[TAS3001C_REG_DRC][1]);
 587 #endif
 588
 589         return tas3001c_sync_register(self, TAS3001C_REG_DRC);
 590 }
 591
 592 static int
 593 tas3001c_drce_rw(       struct tas3001c_data_t *self,
 594                         u_int cmd,
 595                         u_long arg)
 596 {
 597         int rc;
 598         struct tas_drce_ctrl_t drce_ctrl;
 599
 600         if (copy_from_user((void *)&drce_ctrl,
 601                            (const void *)arg,
 602                            sizeof(struct tas_drce_ctrl_t))) {
 603                 return -EFAULT;
 604         }
 605
 606 #ifdef DEBUG_DRCE
 607         printk("DRCE IOCTL: input [ FLAGS:%x ENABLE:%x THRESH:%x\n",
 608                drce_ctrl.flags,
 609                drce_ctrl.data.enable,
 610                drce_ctrl.data.threshold);
 611 #endif
 612
 613         if (cmd & SIOC_IN) {
 614                 rc = tas3001c_update_drce(self, drce_ctrl.flags, &drce_ctrl.data);
 615                 if (rc < 0)
 616                         return rc;
 617         }
 618
 619         if (cmd & SIOC_OUT) {
 620                 if (drce_ctrl.flags & TAS_DRCE_ENABLE)
 621                         drce_ctrl.data.enable = self->drce_state.enable;
 622
 623                 if (drce_ctrl.flags & TAS_DRCE_THRESHOLD)
 624                         drce_ctrl.data.threshold = self->drce_state.threshold;
 625
 626                 if (copy_to_user((void *)arg,
 627                                  (const void *)&drce_ctrl,
 628                                  sizeof(struct tas_drce_ctrl_t))) {
 629                         return -EFAULT;
 630                 }
 631         }
 632
 633         return 0;
 634 }
 635
 636 static void
 637 tas3001c_update_device_parameters(struct tas3001c_data_t *self)
 638 {
 639         int i,j;
 640
 641         if (!self) return;
 642
 643         if (self->output_id == TAS_OUTPUT_HEADPHONES) {
 644                 tas3001c_fast_load(self, 1);
 645
 646                 for (i=0; i<TAS3001C_BIQUAD_CHANNEL_COUNT; i++) {
 647                         for (j=0; j<TAS3001C_BIQUAD_FILTER_COUNT; j++) {
 648                                 tas3001c_write_biquad(self, i, j, &tas3001c_eq_unity);
 649                         }
 650                 }
 651
 652                 tas3001c_fast_load(self, 0);
 653
 654                 (void)tas3001c_sync_register(self,TAS3001C_REG_BASS);
 655                 (void)tas3001c_sync_register(self,TAS3001C_REG_TREBLE);
 656                 (void)tas3001c_sync_register(self,TAS3001C_REG_MIXER1);
 657                 (void)tas3001c_sync_register(self,TAS3001C_REG_MIXER2);
 658                 (void)tas3001c_sync_register(self,TAS3001C_REG_VOLUME);
 659
 660                 return;
 661         }
 662
 663         for (i=0; tas3001c_eq_prefs[i]; i++) {
 664                 struct tas_eq_pref_t *eq = tas3001c_eq_prefs[i];
 665
 666                 if (eq->device_id == self->device_id &&
 667                     (eq->output_id == 0 || eq->output_id == self->output_id) &&
 668                     (eq->speaker_id == 0 || eq->speaker_id == self->speaker_id)) {
 669
 670                         tas3001c_update_drce(self, TAS_DRCE_ALL, eq->drce);
 671                         tas3001c_write_biquad_list(self, eq->filter_count, TAS_BIQUAD_FAST_LOAD, eq->biquads);
 672
 673                         break;
 674                 }
 675         }
 676 }
 677
 678 static void
 679 tas3001c_device_change_handler(void *self)
 680 {
 681         if (self)
 682                 tas3001c_update_device_parameters(self);
 683 }
 684
 685 static struct work_struct device_change;
 686
 687 static int
 688 tas3001c_output_device_change(  struct tas3001c_data_t *self,
 689                                 int device_id,
 690                                 int output_id,
 691                                 int speaker_id)
 692 {
 693         self->device_id=device_id;
 694         self->output_id=output_id;
 695         self->speaker_id=speaker_id;
 696
 697         schedule_work(&device_change);
 698         return 0;
 699 }
 700
 701 static int
 702 tas3001c_device_ioctl(  struct tas3001c_data_t *self,
 703                         u_int cmd,
 704                         u_long arg)
 705 {
 706         switch (cmd) {
 707         case TAS_READ_EQ:
 708         case TAS_WRITE_EQ:
 709                 return tas3001c_eq_rw(self, cmd, arg);
 710
 711         case TAS_READ_EQ_LIST:
 712         case TAS_WRITE_EQ_LIST:
 713                 return tas3001c_eq_list_rw(self, cmd, arg);
 714
 715         case TAS_READ_EQ_FILTER_COUNT:
 716                 put_user(TAS3001C_BIQUAD_FILTER_COUNT, (uint *)(arg));
 717                 return 0;
 718
 719         case TAS_READ_EQ_CHANNEL_COUNT:
 720                 put_user(TAS3001C_BIQUAD_CHANNEL_COUNT, (uint *)(arg));
 721                 return 0;
 722
 723         case TAS_READ_DRCE:
 724         case TAS_WRITE_DRCE:
 725                 return tas3001c_drce_rw(self, cmd, arg);
 726
 727         case TAS_READ_DRCE_CAPS:
 728                 put_user(TAS_DRCE_ENABLE | TAS_DRCE_THRESHOLD, (uint *)(arg));
 729                 return 0;
 730
 731         case TAS_READ_DRCE_MIN:
 732         case TAS_READ_DRCE_MAX: {
 733                 struct tas_drce_ctrl_t drce_ctrl;
 734
 735                 if (copy_from_user((void *)&drce_ctrl,
 736                                    (const void *)arg,
 737                                    sizeof(struct tas_drce_ctrl_t))) {
 738                         return -EFAULT;
 739                 }
 740
 741                 if (drce_ctrl.flags & TAS_DRCE_THRESHOLD) {
 742                         if (cmd == TAS_READ_DRCE_MIN) {
 743                                 drce_ctrl.data.threshold=-36<<8;
 744                         } else {
 745                                 drce_ctrl.data.threshold=-6<<8;
 746                         }
 747                 }
 748
 749                 if (copy_to_user((void *)arg,
 750                                  (const void *)&drce_ctrl,
 751                                  sizeof(struct tas_drce_ctrl_t))) {
 752                         return -EFAULT;
 753                 }
 754         }
 755         }
 756
 757         return -EINVAL;
 758 }
 759
 760 static int
 761 tas3001c_init_mixer(struct tas3001c_data_t *self)
 762 {
 763         unsigned char mcr = (1<<6)+(2<<4)+(2<<2);
 764
 765         /* Make sure something answers on the i2c bus */
 766         if (tas3001c_write_register(self, TAS3001C_REG_MCR, &mcr,
 767             WRITE_NORMAL|FORCE_WRITE) < 0)
 768                 return -1;
 769
 770         tas3001c_fast_load(self, 1);
 771
 772         (void)tas3001c_sync_register(self,TAS3001C_REG_RIGHT_BIQUAD0);
 773         (void)tas3001c_sync_register(self,TAS3001C_REG_RIGHT_BIQUAD1);
 774         (void)tas3001c_sync_register(self,TAS3001C_REG_RIGHT_BIQUAD2);
 775         (void)tas3001c_sync_register(self,TAS3001C_REG_RIGHT_BIQUAD3);
 776         (void)tas3001c_sync_register(self,TAS3001C_REG_RIGHT_BIQUAD4);
 777         (void)tas3001c_sync_register(self,TAS3001C_REG_RIGHT_BIQUAD5);
 778         (void)tas3001c_sync_register(self,TAS3001C_REG_RIGHT_BIQUAD6);
 779
 780         (void)tas3001c_sync_register(self,TAS3001C_REG_LEFT_BIQUAD0);
 781         (void)tas3001c_sync_register(self,TAS3001C_REG_LEFT_BIQUAD1);
 782         (void)tas3001c_sync_register(self,TAS3001C_REG_LEFT_BIQUAD2);
 783         (void)tas3001c_sync_register(self,TAS3001C_REG_LEFT_BIQUAD3);
 784         (void)tas3001c_sync_register(self,TAS3001C_REG_LEFT_BIQUAD4);
 785         (void)tas3001c_sync_register(self,TAS3001C_REG_LEFT_BIQUAD5);
 786         (void)tas3001c_sync_register(self,TAS3001C_REG_LEFT_BIQUAD6);
 787
 788         tas3001c_fast_load(self, 0);
 789
 790         tas3001c_set_mixer_level(self, SOUND_MIXER_VOLUME, VOL_DEFAULT<<8 | VOL_DEFAULT);
 791         tas3001c_set_mixer_level(self, SOUND_MIXER_PCM, INPUT_DEFAULT<<8 | INPUT_DEFAULT);
 792         tas3001c_set_mixer_level(self, SOUND_MIXER_ALTPCM, 0);
 793
 794         tas3001c_set_mixer_level(self, SOUND_MIXER_BASS, BASS_DEFAULT);
 795         tas3001c_set_mixer_level(self, SOUND_MIXER_TREBLE, TREBLE_DEFAULT);
 796
 797         return 0;
 798 }
 799
 800 static int
 801 tas3001c_uninit_mixer(struct tas3001c_data_t *self)
 802 {
 803         tas3001c_set_mixer_level(self, SOUND_MIXER_VOLUME, 0);
 804         tas3001c_set_mixer_level(self, SOUND_MIXER_PCM,    0);
 805         tas3001c_set_mixer_level(self, SOUND_MIXER_ALTPCM, 0);
 806
 807         tas3001c_set_mixer_level(self, SOUND_MIXER_BASS,   0);
 808         tas3001c_set_mixer_level(self, SOUND_MIXER_TREBLE, 0);
 809
 810         return 0;
 811 }
 812
 813 static int
 814 tas3001c_init(struct i2c_client *client)
 815 {
 816         struct tas3001c_data_t *self;
 817         size_t sz = sizeof(*self) + (TAS3001C_REG_MAX*sizeof(tas_shadow_t));
 818         int i, j;
 819
 820         self = kmalloc(sz, GFP_KERNEL);
 821         if (!self)
 822                 return -ENOMEM;
 823         memset(self, 0, sz);
 824
 825         self->super.client = client;
 826         self->super.shadow = (tas_shadow_t *)(self+1);
 827         self->output_id = TAS_OUTPUT_HEADPHONES;
 828
 829         dev_set_drvdata(&client->dev, self);
 830
 831         for (i = 0; i < TAS3001C_BIQUAD_CHANNEL_COUNT; i++)
 832                 for (j = 0; j < TAS3001C_BIQUAD_FILTER_COUNT; j++)
 833                         tas3001c_write_biquad_shadow(self, i, j,
 834                                 &tas3001c_eq_unity);
 835
 836         INIT_WORK(&device_change, tas3001c_device_change_handler, self);
 837         return 0;
 838 }
 839
 840 static void
 841 tas3001c_uninit(struct tas3001c_data_t *self)
 842 {
 843         tas3001c_uninit_mixer(self);
 844         kfree(self);
 845 }
 846
 847 struct tas_driver_hooks_t tas3001c_hooks = {
 848         .init                   = (tas_hook_init_t)tas3001c_init,
 849         .post_init              = (tas_hook_post_init_t)tas3001c_init_mixer,
 850         .uninit                 = (tas_hook_uninit_t)tas3001c_uninit,
 851         .get_mixer_level        = (tas_hook_get_mixer_level_t)tas3001c_get_mixer_level,
 852         .set_mixer_level        = (tas_hook_set_mixer_level_t)tas3001c_set_mixer_level,
 853         .enter_sleep            = (tas_hook_enter_sleep_t)tas3001c_enter_sleep,
 854         .leave_sleep            = (tas_hook_leave_sleep_t)tas3001c_leave_sleep,
 855         .supported_mixers       = (tas_hook_supported_mixers_t)tas3001c_supported_mixers,
 856         .mixer_is_stereo        = (tas_hook_mixer_is_stereo_t)tas3001c_mixer_is_stereo,
 857         .stereo_mixers          = (tas_hook_stereo_mixers_t)tas3001c_stereo_mixers,
 858         .output_device_change   = (tas_hook_output_device_change_t)tas3001c_output_device_change,
 859         .device_ioctl           = (tas_hook_device_ioctl_t)tas3001c_device_ioctl
 860 };