sound/soc/codecs/max98095.c

   1 /*
   2  * max98095.c -- MAX98095 ALSA SoC Audio driver
   3  *
   4  * Copyright 2011 Maxim Integrated Products
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/moduleparam.h>
  13 #include <linux/kernel.h>
  14 #include <linux/init.h>
  15 #include <linux/delay.h>
  16 #include <linux/pm.h>
  17 #include <linux/i2c.h>
  18 #include <sound/core.h>
  19 #include <sound/pcm.h>
  20 #include <sound/pcm_params.h>
  21 #include <sound/soc.h>
  22 #include <sound/initval.h>
  23 #include <sound/tlv.h>
  24 #include <linux/slab.h>
  25 #include <asm/div64.h>
  26 #include <sound/max98095.h>
  27 #include <sound/jack.h>
  28 #include "max98095.h"
  29
  30 enum max98095_type {
  31         MAX98095,
  32 };
  33
  34 struct max98095_cdata {
  35         unsigned int rate;
  36         unsigned int fmt;
  37         int eq_sel;
  38         int bq_sel;
  39 };
  40
  41 struct max98095_priv {
  42         struct regmap *regmap;
  43         enum max98095_type devtype;
  44         struct max98095_pdata *pdata;
  45         unsigned int sysclk;
  46         struct max98095_cdata dai[3];
  47         const char **eq_texts;
  48         const char **bq_texts;
  49         struct soc_enum eq_enum;
  50         struct soc_enum bq_enum;
  51         int eq_textcnt;
  52         int bq_textcnt;
  53         u8 lin_state;
  54         unsigned int mic1pre;
  55         unsigned int mic2pre;
  56         struct snd_soc_jack *headphone_jack;
  57         struct snd_soc_jack *mic_jack;
  58 };
  59
  60 static const struct reg_default max98095_reg_def[] = {
  61         {  0xf, 0x00 }, /* 0F */
  62         { 0x10, 0x00 }, /* 10 */
  63         { 0x11, 0x00 }, /* 11 */
  64         { 0x12, 0x00 }, /* 12 */
  65         { 0x13, 0x00 }, /* 13 */
  66         { 0x14, 0x00 }, /* 14 */
  67         { 0x15, 0x00 }, /* 15 */
  68         { 0x16, 0x00 }, /* 16 */
  69         { 0x17, 0x00 }, /* 17 */
  70         { 0x18, 0x00 }, /* 18 */
  71         { 0x19, 0x00 }, /* 19 */
  72         { 0x1a, 0x00 }, /* 1A */
  73         { 0x1b, 0x00 }, /* 1B */
  74         { 0x1c, 0x00 }, /* 1C */
  75         { 0x1d, 0x00 }, /* 1D */
  76         { 0x1e, 0x00 }, /* 1E */
  77         { 0x1f, 0x00 }, /* 1F */
  78         { 0x20, 0x00 }, /* 20 */
  79         { 0x21, 0x00 }, /* 21 */
  80         { 0x22, 0x00 }, /* 22 */
  81         { 0x23, 0x00 }, /* 23 */
  82         { 0x24, 0x00 }, /* 24 */
  83         { 0x25, 0x00 }, /* 25 */
  84         { 0x26, 0x00 }, /* 26 */
  85         { 0x27, 0x00 }, /* 27 */
  86         { 0x28, 0x00 }, /* 28 */
  87         { 0x29, 0x00 }, /* 29 */
  88         { 0x2a, 0x00 }, /* 2A */
  89         { 0x2b, 0x00 }, /* 2B */
  90         { 0x2c, 0x00 }, /* 2C */
  91         { 0x2d, 0x00 }, /* 2D */
  92         { 0x2e, 0x00 }, /* 2E */
  93         { 0x2f, 0x00 }, /* 2F */
  94         { 0x30, 0x00 }, /* 30 */
  95         { 0x31, 0x00 }, /* 31 */
  96         { 0x32, 0x00 }, /* 32 */
  97         { 0x33, 0x00 }, /* 33 */
  98         { 0x34, 0x00 }, /* 34 */
  99         { 0x35, 0x00 }, /* 35 */
 100         { 0x36, 0x00 }, /* 36 */
 101         { 0x37, 0x00 }, /* 37 */
 102         { 0x38, 0x00 }, /* 38 */
 103         { 0x39, 0x00 }, /* 39 */
 104         { 0x3a, 0x00 }, /* 3A */
 105         { 0x3b, 0x00 }, /* 3B */
 106         { 0x3c, 0x00 }, /* 3C */
 107         { 0x3d, 0x00 }, /* 3D */
 108         { 0x3e, 0x00 }, /* 3E */
 109         { 0x3f, 0x00 }, /* 3F */
 110         { 0x40, 0x00 }, /* 40 */
 111         { 0x41, 0x00 }, /* 41 */
 112         { 0x42, 0x00 }, /* 42 */
 113         { 0x43, 0x00 }, /* 43 */
 114         { 0x44, 0x00 }, /* 44 */
 115         { 0x45, 0x00 }, /* 45 */
 116         { 0x46, 0x00 }, /* 46 */
 117         { 0x47, 0x00 }, /* 47 */
 118         { 0x48, 0x00 }, /* 48 */
 119         { 0x49, 0x00 }, /* 49 */
 120         { 0x4a, 0x00 }, /* 4A */
 121         { 0x4b, 0x00 }, /* 4B */
 122         { 0x4c, 0x00 }, /* 4C */
 123         { 0x4d, 0x00 }, /* 4D */
 124         { 0x4e, 0x00 }, /* 4E */
 125         { 0x4f, 0x00 }, /* 4F */
 126         { 0x50, 0x00 }, /* 50 */
 127         { 0x51, 0x00 }, /* 51 */
 128         { 0x52, 0x00 }, /* 52 */
 129         { 0x53, 0x00 }, /* 53 */
 130         { 0x54, 0x00 }, /* 54 */
 131         { 0x55, 0x00 }, /* 55 */
 132         { 0x56, 0x00 }, /* 56 */
 133         { 0x57, 0x00 }, /* 57 */
 134         { 0x58, 0x00 }, /* 58 */
 135         { 0x59, 0x00 }, /* 59 */
 136         { 0x5a, 0x00 }, /* 5A */
 137         { 0x5b, 0x00 }, /* 5B */
 138         { 0x5c, 0x00 }, /* 5C */
 139         { 0x5d, 0x00 }, /* 5D */
 140         { 0x5e, 0x00 }, /* 5E */
 141         { 0x5f, 0x00 }, /* 5F */
 142         { 0x60, 0x00 }, /* 60 */
 143         { 0x61, 0x00 }, /* 61 */
 144         { 0x62, 0x00 }, /* 62 */
 145         { 0x63, 0x00 }, /* 63 */
 146         { 0x64, 0x00 }, /* 64 */
 147         { 0x65, 0x00 }, /* 65 */
 148         { 0x66, 0x00 }, /* 66 */
 149         { 0x67, 0x00 }, /* 67 */
 150         { 0x68, 0x00 }, /* 68 */
 151         { 0x69, 0x00 }, /* 69 */
 152         { 0x6a, 0x00 }, /* 6A */
 153         { 0x6b, 0x00 }, /* 6B */
 154         { 0x6c, 0x00 }, /* 6C */
 155         { 0x6d, 0x00 }, /* 6D */
 156         { 0x6e, 0x00 }, /* 6E */
 157         { 0x6f, 0x00 }, /* 6F */
 158         { 0x70, 0x00 }, /* 70 */
 159         { 0x71, 0x00 }, /* 71 */
 160         { 0x72, 0x00 }, /* 72 */
 161         { 0x73, 0x00 }, /* 73 */
 162         { 0x74, 0x00 }, /* 74 */
 163         { 0x75, 0x00 }, /* 75 */
 164         { 0x76, 0x00 }, /* 76 */
 165         { 0x77, 0x00 }, /* 77 */
 166         { 0x78, 0x00 }, /* 78 */
 167         { 0x79, 0x00 }, /* 79 */
 168         { 0x7a, 0x00 }, /* 7A */
 169         { 0x7b, 0x00 }, /* 7B */
 170         { 0x7c, 0x00 }, /* 7C */
 171         { 0x7d, 0x00 }, /* 7D */
 172         { 0x7e, 0x00 }, /* 7E */
 173         { 0x7f, 0x00 }, /* 7F */
 174         { 0x80, 0x00 }, /* 80 */
 175         { 0x81, 0x00 }, /* 81 */
 176         { 0x82, 0x00 }, /* 82 */
 177         { 0x83, 0x00 }, /* 83 */
 178         { 0x84, 0x00 }, /* 84 */
 179         { 0x85, 0x00 }, /* 85 */
 180         { 0x86, 0x00 }, /* 86 */
 181         { 0x87, 0x00 }, /* 87 */
 182         { 0x88, 0x00 }, /* 88 */
 183         { 0x89, 0x00 }, /* 89 */
 184         { 0x8a, 0x00 }, /* 8A */
 185         { 0x8b, 0x00 }, /* 8B */
 186         { 0x8c, 0x00 }, /* 8C */
 187         { 0x8d, 0x00 }, /* 8D */
 188         { 0x8e, 0x00 }, /* 8E */
 189         { 0x8f, 0x00 }, /* 8F */
 190         { 0x90, 0x00 }, /* 90 */
 191         { 0x91, 0x00 }, /* 91 */
 192         { 0x92, 0x30 }, /* 92 */
 193         { 0x93, 0xF0 }, /* 93 */
 194         { 0x94, 0x00 }, /* 94 */
 195         { 0x95, 0x00 }, /* 95 */
 196         { 0x96, 0x3F }, /* 96 */
 197         { 0x97, 0x00 }, /* 97 */
 198         { 0xff, 0x00 }, /* FF */
 199 };
 200
 201 static struct {
 202         int readable;
 203         int writable;
 204 } max98095_access[M98095_REG_CNT] = {
 205         { 0x00, 0x00 }, /* 00 */
 206         { 0xFF, 0x00 }, /* 01 */
 207         { 0xFF, 0x00 }, /* 02 */
 208         { 0xFF, 0x00 }, /* 03 */
 209         { 0xFF, 0x00 }, /* 04 */
 210         { 0xFF, 0x00 }, /* 05 */
 211         { 0xFF, 0x00 }, /* 06 */
 212         { 0xFF, 0x00 }, /* 07 */
 213         { 0xFF, 0x00 }, /* 08 */
 214         { 0xFF, 0x00 }, /* 09 */
 215         { 0xFF, 0x00 }, /* 0A */
 216         { 0xFF, 0x00 }, /* 0B */
 217         { 0xFF, 0x00 }, /* 0C */
 218         { 0xFF, 0x00 }, /* 0D */
 219         { 0xFF, 0x00 }, /* 0E */
 220         { 0xFF, 0x9F }, /* 0F */
 221         { 0xFF, 0xFF }, /* 10 */
 222         { 0xFF, 0xFF }, /* 11 */
 223         { 0xFF, 0xFF }, /* 12 */
 224         { 0xFF, 0xFF }, /* 13 */
 225         { 0xFF, 0xFF }, /* 14 */
 226         { 0xFF, 0xFF }, /* 15 */
 227         { 0xFF, 0xFF }, /* 16 */
 228         { 0xFF, 0xFF }, /* 17 */
 229         { 0xFF, 0xFF }, /* 18 */
 230         { 0xFF, 0xFF }, /* 19 */
 231         { 0xFF, 0xFF }, /* 1A */
 232         { 0xFF, 0xFF }, /* 1B */
 233         { 0xFF, 0xFF }, /* 1C */
 234         { 0xFF, 0xFF }, /* 1D */
 235         { 0xFF, 0x77 }, /* 1E */
 236         { 0xFF, 0x77 }, /* 1F */
 237         { 0xFF, 0x77 }, /* 20 */
 238         { 0xFF, 0x77 }, /* 21 */
 239         { 0xFF, 0x77 }, /* 22 */
 240         { 0xFF, 0x77 }, /* 23 */
 241         { 0xFF, 0xFF }, /* 24 */
 242         { 0xFF, 0x7F }, /* 25 */
 243         { 0xFF, 0x31 }, /* 26 */
 244         { 0xFF, 0xFF }, /* 27 */
 245         { 0xFF, 0xFF }, /* 28 */
 246         { 0xFF, 0xFF }, /* 29 */
 247         { 0xFF, 0xF7 }, /* 2A */
 248         { 0xFF, 0x2F }, /* 2B */
 249         { 0xFF, 0xEF }, /* 2C */
 250         { 0xFF, 0xFF }, /* 2D */
 251         { 0xFF, 0xFF }, /* 2E */
 252         { 0xFF, 0xFF }, /* 2F */
 253         { 0xFF, 0xFF }, /* 30 */
 254         { 0xFF, 0xFF }, /* 31 */
 255         { 0xFF, 0xFF }, /* 32 */
 256         { 0xFF, 0xFF }, /* 33 */
 257         { 0xFF, 0xF7 }, /* 34 */
 258         { 0xFF, 0x2F }, /* 35 */
 259         { 0xFF, 0xCF }, /* 36 */
 260         { 0xFF, 0xFF }, /* 37 */
 261         { 0xFF, 0xFF }, /* 38 */
 262         { 0xFF, 0xFF }, /* 39 */
 263         { 0xFF, 0xFF }, /* 3A */
 264         { 0xFF, 0xFF }, /* 3B */
 265         { 0xFF, 0xFF }, /* 3C */
 266         { 0xFF, 0xFF }, /* 3D */
 267         { 0xFF, 0xF7 }, /* 3E */
 268         { 0xFF, 0x2F }, /* 3F */
 269         { 0xFF, 0xCF }, /* 40 */
 270         { 0xFF, 0xFF }, /* 41 */
 271         { 0xFF, 0x77 }, /* 42 */
 272         { 0xFF, 0xFF }, /* 43 */
 273         { 0xFF, 0xFF }, /* 44 */
 274         { 0xFF, 0xFF }, /* 45 */
 275         { 0xFF, 0xFF }, /* 46 */
 276         { 0xFF, 0xFF }, /* 47 */
 277         { 0xFF, 0xFF }, /* 48 */
 278         { 0xFF, 0x0F }, /* 49 */
 279         { 0xFF, 0xFF }, /* 4A */
 280         { 0xFF, 0xFF }, /* 4B */
 281         { 0xFF, 0x3F }, /* 4C */
 282         { 0xFF, 0x3F }, /* 4D */
 283         { 0xFF, 0x3F }, /* 4E */
 284         { 0xFF, 0xFF }, /* 4F */
 285         { 0xFF, 0x7F }, /* 50 */
 286         { 0xFF, 0x7F }, /* 51 */
 287         { 0xFF, 0x0F }, /* 52 */
 288         { 0xFF, 0x3F }, /* 53 */
 289         { 0xFF, 0x3F }, /* 54 */
 290         { 0xFF, 0x3F }, /* 55 */
 291         { 0xFF, 0xFF }, /* 56 */
 292         { 0xFF, 0xFF }, /* 57 */
 293         { 0xFF, 0xBF }, /* 58 */
 294         { 0xFF, 0x1F }, /* 59 */
 295         { 0xFF, 0xBF }, /* 5A */
 296         { 0xFF, 0x1F }, /* 5B */
 297         { 0xFF, 0xBF }, /* 5C */
 298         { 0xFF, 0x3F }, /* 5D */
 299         { 0xFF, 0x3F }, /* 5E */
 300         { 0xFF, 0x7F }, /* 5F */
 301         { 0xFF, 0x7F }, /* 60 */
 302         { 0xFF, 0x47 }, /* 61 */
 303         { 0xFF, 0x9F }, /* 62 */
 304         { 0xFF, 0x9F }, /* 63 */
 305         { 0xFF, 0x9F }, /* 64 */
 306         { 0xFF, 0x9F }, /* 65 */
 307         { 0xFF, 0x9F }, /* 66 */
 308         { 0xFF, 0xBF }, /* 67 */
 309         { 0xFF, 0xBF }, /* 68 */
 310         { 0xFF, 0xFF }, /* 69 */
 311         { 0xFF, 0xFF }, /* 6A */
 312         { 0xFF, 0x7F }, /* 6B */
 313         { 0xFF, 0xF7 }, /* 6C */
 314         { 0xFF, 0xFF }, /* 6D */
 315         { 0xFF, 0xFF }, /* 6E */
 316         { 0xFF, 0x1F }, /* 6F */
 317         { 0xFF, 0xF7 }, /* 70 */
 318         { 0xFF, 0xFF }, /* 71 */
 319         { 0xFF, 0xFF }, /* 72 */
 320         { 0xFF, 0x1F }, /* 73 */
 321         { 0xFF, 0xF7 }, /* 74 */
 322         { 0xFF, 0xFF }, /* 75 */
 323         { 0xFF, 0xFF }, /* 76 */
 324         { 0xFF, 0x1F }, /* 77 */
 325         { 0xFF, 0xF7 }, /* 78 */
 326         { 0xFF, 0xFF }, /* 79 */
 327         { 0xFF, 0xFF }, /* 7A */
 328         { 0xFF, 0x1F }, /* 7B */
 329         { 0xFF, 0xF7 }, /* 7C */
 330         { 0xFF, 0xFF }, /* 7D */
 331         { 0xFF, 0xFF }, /* 7E */
 332         { 0xFF, 0x1F }, /* 7F */
 333         { 0xFF, 0xF7 }, /* 80 */
 334         { 0xFF, 0xFF }, /* 81 */
 335         { 0xFF, 0xFF }, /* 82 */
 336         { 0xFF, 0x1F }, /* 83 */
 337         { 0xFF, 0x7F }, /* 84 */
 338         { 0xFF, 0x0F }, /* 85 */
 339         { 0xFF, 0xD8 }, /* 86 */
 340         { 0xFF, 0xFF }, /* 87 */
 341         { 0xFF, 0xEF }, /* 88 */
 342         { 0xFF, 0xFE }, /* 89 */
 343         { 0xFF, 0xFE }, /* 8A */
 344         { 0xFF, 0xFF }, /* 8B */
 345         { 0xFF, 0xFF }, /* 8C */
 346         { 0xFF, 0x3F }, /* 8D */
 347         { 0xFF, 0xFF }, /* 8E */
 348         { 0xFF, 0x3F }, /* 8F */
 349         { 0xFF, 0x8F }, /* 90 */
 350         { 0xFF, 0xFF }, /* 91 */
 351         { 0xFF, 0x3F }, /* 92 */
 352         { 0xFF, 0xFF }, /* 93 */
 353         { 0xFF, 0xFF }, /* 94 */
 354         { 0xFF, 0x0F }, /* 95 */
 355         { 0xFF, 0x3F }, /* 96 */
 356         { 0xFF, 0x8C }, /* 97 */
 357         { 0x00, 0x00 }, /* 98 */
 358         { 0x00, 0x00 }, /* 99 */
 359         { 0x00, 0x00 }, /* 9A */
 360         { 0x00, 0x00 }, /* 9B */
 361         { 0x00, 0x00 }, /* 9C */
 362         { 0x00, 0x00 }, /* 9D */
 363         { 0x00, 0x00 }, /* 9E */
 364         { 0x00, 0x00 }, /* 9F */
 365         { 0x00, 0x00 }, /* A0 */
 366         { 0x00, 0x00 }, /* A1 */
 367         { 0x00, 0x00 }, /* A2 */
 368         { 0x00, 0x00 }, /* A3 */
 369         { 0x00, 0x00 }, /* A4 */
 370         { 0x00, 0x00 }, /* A5 */
 371         { 0x00, 0x00 }, /* A6 */
 372         { 0x00, 0x00 }, /* A7 */
 373         { 0x00, 0x00 }, /* A8 */
 374         { 0x00, 0x00 }, /* A9 */
 375         { 0x00, 0x00 }, /* AA */
 376         { 0x00, 0x00 }, /* AB */
 377         { 0x00, 0x00 }, /* AC */
 378         { 0x00, 0x00 }, /* AD */
 379         { 0x00, 0x00 }, /* AE */
 380         { 0x00, 0x00 }, /* AF */
 381         { 0x00, 0x00 }, /* B0 */
 382         { 0x00, 0x00 }, /* B1 */
 383         { 0x00, 0x00 }, /* B2 */
 384         { 0x00, 0x00 }, /* B3 */
 385         { 0x00, 0x00 }, /* B4 */
 386         { 0x00, 0x00 }, /* B5 */
 387         { 0x00, 0x00 }, /* B6 */
 388         { 0x00, 0x00 }, /* B7 */
 389         { 0x00, 0x00 }, /* B8 */
 390         { 0x00, 0x00 }, /* B9 */
 391         { 0x00, 0x00 }, /* BA */
 392         { 0x00, 0x00 }, /* BB */
 393         { 0x00, 0x00 }, /* BC */
 394         { 0x00, 0x00 }, /* BD */
 395         { 0x00, 0x00 }, /* BE */
 396         { 0x00, 0x00 }, /* BF */
 397         { 0x00, 0x00 }, /* C0 */
 398         { 0x00, 0x00 }, /* C1 */
 399         { 0x00, 0x00 }, /* C2 */
 400         { 0x00, 0x00 }, /* C3 */
 401         { 0x00, 0x00 }, /* C4 */
 402         { 0x00, 0x00 }, /* C5 */
 403         { 0x00, 0x00 }, /* C6 */
 404         { 0x00, 0x00 }, /* C7 */
 405         { 0x00, 0x00 }, /* C8 */
 406         { 0x00, 0x00 }, /* C9 */
 407         { 0x00, 0x00 }, /* CA */
 408         { 0x00, 0x00 }, /* CB */
 409         { 0x00, 0x00 }, /* CC */
 410         { 0x00, 0x00 }, /* CD */
 411         { 0x00, 0x00 }, /* CE */
 412         { 0x00, 0x00 }, /* CF */
 413         { 0x00, 0x00 }, /* D0 */
 414         { 0x00, 0x00 }, /* D1 */
 415         { 0x00, 0x00 }, /* D2 */
 416         { 0x00, 0x00 }, /* D3 */
 417         { 0x00, 0x00 }, /* D4 */
 418         { 0x00, 0x00 }, /* D5 */
 419         { 0x00, 0x00 }, /* D6 */
 420         { 0x00, 0x00 }, /* D7 */
 421         { 0x00, 0x00 }, /* D8 */
 422         { 0x00, 0x00 }, /* D9 */
 423         { 0x00, 0x00 }, /* DA */
 424         { 0x00, 0x00 }, /* DB */
 425         { 0x00, 0x00 }, /* DC */
 426         { 0x00, 0x00 }, /* DD */
 427         { 0x00, 0x00 }, /* DE */
 428         { 0x00, 0x00 }, /* DF */
 429         { 0x00, 0x00 }, /* E0 */
 430         { 0x00, 0x00 }, /* E1 */
 431         { 0x00, 0x00 }, /* E2 */
 432         { 0x00, 0x00 }, /* E3 */
 433         { 0x00, 0x00 }, /* E4 */
 434         { 0x00, 0x00 }, /* E5 */
 435         { 0x00, 0x00 }, /* E6 */
 436         { 0x00, 0x00 }, /* E7 */
 437         { 0x00, 0x00 }, /* E8 */
 438         { 0x00, 0x00 }, /* E9 */
 439         { 0x00, 0x00 }, /* EA */
 440         { 0x00, 0x00 }, /* EB */
 441         { 0x00, 0x00 }, /* EC */
 442         { 0x00, 0x00 }, /* ED */
 443         { 0x00, 0x00 }, /* EE */
 444         { 0x00, 0x00 }, /* EF */
 445         { 0x00, 0x00 }, /* F0 */
 446         { 0x00, 0x00 }, /* F1 */
 447         { 0x00, 0x00 }, /* F2 */
 448         { 0x00, 0x00 }, /* F3 */
 449         { 0x00, 0x00 }, /* F4 */
 450         { 0x00, 0x00 }, /* F5 */
 451         { 0x00, 0x00 }, /* F6 */
 452         { 0x00, 0x00 }, /* F7 */
 453         { 0x00, 0x00 }, /* F8 */
 454         { 0x00, 0x00 }, /* F9 */
 455         { 0x00, 0x00 }, /* FA */
 456         { 0x00, 0x00 }, /* FB */
 457         { 0x00, 0x00 }, /* FC */
 458         { 0x00, 0x00 }, /* FD */
 459         { 0x00, 0x00 }, /* FE */
 460         { 0xFF, 0x00 }, /* FF */
 461 };
 462
 463 static bool max98095_readable(struct device *dev, unsigned int reg)
 464 {
 465         if (reg >= M98095_REG_CNT)
 466                 return 0;
 467         return max98095_access[reg].readable != 0;
 468 }
 469
 470 static bool max98095_volatile(struct device *dev, unsigned int reg)
 471 {
 472         if (reg > M98095_REG_MAX_CACHED)
 473                 return 1;
 474
 475         switch (reg) {
 476         case M98095_000_HOST_DATA:
 477         case M98095_001_HOST_INT_STS:
 478         case M98095_002_HOST_RSP_STS:
 479         case M98095_003_HOST_CMD_STS:
 480         case M98095_004_CODEC_STS:
 481         case M98095_005_DAI1_ALC_STS:
 482         case M98095_006_DAI2_ALC_STS:
 483         case M98095_007_JACK_AUTO_STS:
 484         case M98095_008_JACK_MANUAL_STS:
 485         case M98095_009_JACK_VBAT_STS:
 486         case M98095_00A_ACC_ADC_STS:
 487         case M98095_00B_MIC_NG_AGC_STS:
 488         case M98095_00C_SPK_L_VOLT_STS:
 489         case M98095_00D_SPK_R_VOLT_STS:
 490         case M98095_00E_TEMP_SENSOR_STS:
 491                 return 1;
 492         }
 493
 494         return 0;
 495 }
 496
 497 static const struct regmap_config max98095_regmap = {
 498         .reg_bits = 8,
 499         .val_bits = 8,
 500
 501         .reg_defaults = max98095_reg_def,
 502         .num_reg_defaults = ARRAY_SIZE(max98095_reg_def),
 503         .max_register = M98095_0FF_REV_ID,
 504         .cache_type = REGCACHE_RBTREE,
 505
 506         .readable_reg = max98095_readable,
 507         .volatile_reg = max98095_volatile,
 508 };
 509
 510 /*
 511  * Load equalizer DSP coefficient configurations registers
 512  */
 513 static void m98095_eq_band(struct snd_soc_codec *codec, unsigned int dai,
 514                     unsigned int band, u16 *coefs)
 515 {
 516         unsigned int eq_reg;
 517         unsigned int i;
 518
 519         BUG_ON(band > 4);
 520         BUG_ON(dai > 1);
 521
 522         /* Load the base register address */
 523         eq_reg = dai ? M98095_142_DAI2_EQ_BASE : M98095_110_DAI1_EQ_BASE;
 524
 525         /* Add the band address offset, note adjustment for word address */
 526         eq_reg += band * (M98095_COEFS_PER_BAND << 1);
 527
 528         /* Step through the registers and coefs */
 529         for (i = 0; i < M98095_COEFS_PER_BAND; i++) {
 530                 snd_soc_write(codec, eq_reg++, M98095_BYTE1(coefs[i]));
 531                 snd_soc_write(codec, eq_reg++, M98095_BYTE0(coefs[i]));
 532         }
 533 }
 534
 535 /*
 536  * Load biquad filter coefficient configurations registers
 537  */
 538 static void m98095_biquad_band(struct snd_soc_codec *codec, unsigned int dai,
 539                     unsigned int band, u16 *coefs)
 540 {
 541         unsigned int bq_reg;
 542         unsigned int i;
 543
 544         BUG_ON(band > 1);
 545         BUG_ON(dai > 1);
 546
 547         /* Load the base register address */
 548         bq_reg = dai ? M98095_17E_DAI2_BQ_BASE : M98095_174_DAI1_BQ_BASE;
 549
 550         /* Add the band address offset, note adjustment for word address */
 551         bq_reg += band * (M98095_COEFS_PER_BAND << 1);
 552
 553         /* Step through the registers and coefs */
 554         for (i = 0; i < M98095_COEFS_PER_BAND; i++) {
 555                 snd_soc_write(codec, bq_reg++, M98095_BYTE1(coefs[i]));
 556                 snd_soc_write(codec, bq_reg++, M98095_BYTE0(coefs[i]));
 557         }
 558 }
 559
 560 static const char * const max98095_fltr_mode[] = { "Voice", "Music" };
 561 static const struct soc_enum max98095_dai1_filter_mode_enum[] = {
 562         SOC_ENUM_SINGLE(M98095_02E_DAI1_FILTERS, 7, 2, max98095_fltr_mode),
 563 };
 564 static const struct soc_enum max98095_dai2_filter_mode_enum[] = {
 565         SOC_ENUM_SINGLE(M98095_038_DAI2_FILTERS, 7, 2, max98095_fltr_mode),
 566 };
 567
 568 static const char * const max98095_extmic_text[] = { "None", "MIC1", "MIC2" };
 569
 570 static const struct soc_enum max98095_extmic_enum =
 571         SOC_ENUM_SINGLE(M98095_087_CFG_MIC, 0, 3, max98095_extmic_text);
 572
 573 static const struct snd_kcontrol_new max98095_extmic_mux =
 574         SOC_DAPM_ENUM("External MIC Mux", max98095_extmic_enum);
 575
 576 static const char * const max98095_linein_text[] = { "INA", "INB" };
 577
 578 static const struct soc_enum max98095_linein_enum =
 579         SOC_ENUM_SINGLE(M98095_086_CFG_LINE, 6, 2, max98095_linein_text);
 580
 581 static const struct snd_kcontrol_new max98095_linein_mux =
 582         SOC_DAPM_ENUM("Linein Input Mux", max98095_linein_enum);
 583
 584 static const char * const max98095_line_mode_text[] = {
 585         "Stereo", "Differential"};
 586
 587 static const struct soc_enum max98095_linein_mode_enum =
 588         SOC_ENUM_SINGLE(M98095_086_CFG_LINE, 7, 2, max98095_line_mode_text);
 589
 590 static const struct soc_enum max98095_lineout_mode_enum =
 591         SOC_ENUM_SINGLE(M98095_086_CFG_LINE, 4, 2, max98095_line_mode_text);
 592
 593 static const char * const max98095_dai_fltr[] = {
 594         "Off", "Elliptical-HPF-16k", "Butterworth-HPF-16k",
 595         "Elliptical-HPF-8k", "Butterworth-HPF-8k", "Butterworth-HPF-Fs/240"};
 596 static const struct soc_enum max98095_dai1_dac_filter_enum[] = {
 597         SOC_ENUM_SINGLE(M98095_02E_DAI1_FILTERS, 0, 6, max98095_dai_fltr),
 598 };
 599 static const struct soc_enum max98095_dai2_dac_filter_enum[] = {
 600         SOC_ENUM_SINGLE(M98095_038_DAI2_FILTERS, 0, 6, max98095_dai_fltr),
 601 };
 602 static const struct soc_enum max98095_dai3_dac_filter_enum[] = {
 603         SOC_ENUM_SINGLE(M98095_042_DAI3_FILTERS, 0, 6, max98095_dai_fltr),
 604 };
 605
 606 static int max98095_mic1pre_set(struct snd_kcontrol *kcontrol,
 607                                 struct snd_ctl_elem_value *ucontrol)
 608 {
 609         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 610         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
 611         unsigned int sel = ucontrol->value.integer.value[0];
 612
 613         max98095->mic1pre = sel;
 614         snd_soc_update_bits(codec, M98095_05F_LVL_MIC1, M98095_MICPRE_MASK,
 615                 (1+sel)<<M98095_MICPRE_SHIFT);
 616
 617         return 0;
 618 }
 619
 620 static int max98095_mic1pre_get(struct snd_kcontrol *kcontrol,
 621                                 struct snd_ctl_elem_value *ucontrol)
 622 {
 623         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 624         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
 625
 626         ucontrol->value.integer.value[0] = max98095->mic1pre;
 627         return 0;
 628 }
 629
 630 static int max98095_mic2pre_set(struct snd_kcontrol *kcontrol,
 631                                 struct snd_ctl_elem_value *ucontrol)
 632 {
 633         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 634         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
 635         unsigned int sel = ucontrol->value.integer.value[0];
 636
 637         max98095->mic2pre = sel;
 638         snd_soc_update_bits(codec, M98095_060_LVL_MIC2, M98095_MICPRE_MASK,
 639                 (1+sel)<<M98095_MICPRE_SHIFT);
 640
 641         return 0;
 642 }
 643
 644 static int max98095_mic2pre_get(struct snd_kcontrol *kcontrol,
 645                                 struct snd_ctl_elem_value *ucontrol)
 646 {
 647         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 648         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
 649
 650         ucontrol->value.integer.value[0] = max98095->mic2pre;
 651         return 0;
 652 }
 653
 654 static const unsigned int max98095_micboost_tlv[] = {
 655         TLV_DB_RANGE_HEAD(2),
 656         0, 1, TLV_DB_SCALE_ITEM(0, 2000, 0),
 657         2, 2, TLV_DB_SCALE_ITEM(3000, 0, 0),
 658 };
 659
 660 static const DECLARE_TLV_DB_SCALE(max98095_mic_tlv, 0, 100, 0);
 661 static const DECLARE_TLV_DB_SCALE(max98095_adc_tlv, -1200, 100, 0);
 662 static const DECLARE_TLV_DB_SCALE(max98095_adcboost_tlv, 0, 600, 0);
 663
 664 static const unsigned int max98095_hp_tlv[] = {
 665         TLV_DB_RANGE_HEAD(5),
 666         0, 6, TLV_DB_SCALE_ITEM(-6700, 400, 0),
 667         7, 14, TLV_DB_SCALE_ITEM(-4000, 300, 0),
 668         15, 21, TLV_DB_SCALE_ITEM(-1700, 200, 0),
 669         22, 27, TLV_DB_SCALE_ITEM(-400, 100, 0),
 670         28, 31, TLV_DB_SCALE_ITEM(150, 50, 0),
 671 };
 672
 673 static const unsigned int max98095_spk_tlv[] = {
 674         TLV_DB_RANGE_HEAD(4),
 675         0, 10, TLV_DB_SCALE_ITEM(-5900, 400, 0),
 676         11, 18, TLV_DB_SCALE_ITEM(-1700, 200, 0),
 677         19, 27, TLV_DB_SCALE_ITEM(-200, 100, 0),
 678         28, 39, TLV_DB_SCALE_ITEM(650, 50, 0),
 679 };
 680
 681 static const unsigned int max98095_rcv_lout_tlv[] = {
 682         TLV_DB_RANGE_HEAD(5),
 683         0, 6, TLV_DB_SCALE_ITEM(-6200, 400, 0),
 684         7, 14, TLV_DB_SCALE_ITEM(-3500, 300, 0),
 685         15, 21, TLV_DB_SCALE_ITEM(-1200, 200, 0),
 686         22, 27, TLV_DB_SCALE_ITEM(100, 100, 0),
 687         28, 31, TLV_DB_SCALE_ITEM(650, 50, 0),
 688 };
 689
 690 static const unsigned int max98095_lin_tlv[] = {
 691         TLV_DB_RANGE_HEAD(3),
 692         0, 2, TLV_DB_SCALE_ITEM(-600, 300, 0),
 693         3, 3, TLV_DB_SCALE_ITEM(300, 1100, 0),
 694         4, 5, TLV_DB_SCALE_ITEM(1400, 600, 0),
 695 };
 696
 697 static const struct snd_kcontrol_new max98095_snd_controls[] = {
 698
 699         SOC_DOUBLE_R_TLV("Headphone Volume", M98095_064_LVL_HP_L,
 700                 M98095_065_LVL_HP_R, 0, 31, 0, max98095_hp_tlv),
 701
 702         SOC_DOUBLE_R_TLV("Speaker Volume", M98095_067_LVL_SPK_L,
 703                 M98095_068_LVL_SPK_R, 0, 39, 0, max98095_spk_tlv),
 704
 705         SOC_SINGLE_TLV("Receiver Volume", M98095_066_LVL_RCV,
 706                 0, 31, 0, max98095_rcv_lout_tlv),
 707
 708         SOC_DOUBLE_R_TLV("Lineout Volume", M98095_062_LVL_LINEOUT1,
 709                 M98095_063_LVL_LINEOUT2, 0, 31, 0, max98095_rcv_lout_tlv),
 710
 711         SOC_DOUBLE_R("Headphone Switch", M98095_064_LVL_HP_L,
 712                 M98095_065_LVL_HP_R, 7, 1, 1),
 713
 714         SOC_DOUBLE_R("Speaker Switch", M98095_067_LVL_SPK_L,
 715                 M98095_068_LVL_SPK_R, 7, 1, 1),
 716
 717         SOC_SINGLE("Receiver Switch", M98095_066_LVL_RCV, 7, 1, 1),
 718
 719         SOC_DOUBLE_R("Lineout Switch", M98095_062_LVL_LINEOUT1,
 720                 M98095_063_LVL_LINEOUT2, 7, 1, 1),
 721
 722         SOC_SINGLE_TLV("MIC1 Volume", M98095_05F_LVL_MIC1, 0, 20, 1,
 723                 max98095_mic_tlv),
 724
 725         SOC_SINGLE_TLV("MIC2 Volume", M98095_060_LVL_MIC2, 0, 20, 1,
 726                 max98095_mic_tlv),
 727
 728         SOC_SINGLE_EXT_TLV("MIC1 Boost Volume",
 729                         M98095_05F_LVL_MIC1, 5, 2, 0,
 730                         max98095_mic1pre_get, max98095_mic1pre_set,
 731                         max98095_micboost_tlv),
 732         SOC_SINGLE_EXT_TLV("MIC2 Boost Volume",
 733                         M98095_060_LVL_MIC2, 5, 2, 0,
 734                         max98095_mic2pre_get, max98095_mic2pre_set,
 735                         max98095_micboost_tlv),
 736
 737         SOC_SINGLE_TLV("Linein Volume", M98095_061_LVL_LINEIN, 0, 5, 1,
 738                 max98095_lin_tlv),
 739
 740         SOC_SINGLE_TLV("ADCL Volume", M98095_05D_LVL_ADC_L, 0, 15, 1,
 741                 max98095_adc_tlv),
 742         SOC_SINGLE_TLV("ADCR Volume", M98095_05E_LVL_ADC_R, 0, 15, 1,
 743                 max98095_adc_tlv),
 744
 745         SOC_SINGLE_TLV("ADCL Boost Volume", M98095_05D_LVL_ADC_L, 4, 3, 0,
 746                 max98095_adcboost_tlv),
 747         SOC_SINGLE_TLV("ADCR Boost Volume", M98095_05E_LVL_ADC_R, 4, 3, 0,
 748                 max98095_adcboost_tlv),
 749
 750         SOC_SINGLE("EQ1 Switch", M98095_088_CFG_LEVEL, 0, 1, 0),
 751         SOC_SINGLE("EQ2 Switch", M98095_088_CFG_LEVEL, 1, 1, 0),
 752
 753         SOC_SINGLE("Biquad1 Switch", M98095_088_CFG_LEVEL, 2, 1, 0),
 754         SOC_SINGLE("Biquad2 Switch", M98095_088_CFG_LEVEL, 3, 1, 0),
 755
 756         SOC_ENUM("DAI1 Filter Mode", max98095_dai1_filter_mode_enum),
 757         SOC_ENUM("DAI2 Filter Mode", max98095_dai2_filter_mode_enum),
 758         SOC_ENUM("DAI1 DAC Filter", max98095_dai1_dac_filter_enum),
 759         SOC_ENUM("DAI2 DAC Filter", max98095_dai2_dac_filter_enum),
 760         SOC_ENUM("DAI3 DAC Filter", max98095_dai3_dac_filter_enum),
 761
 762         SOC_ENUM("Linein Mode", max98095_linein_mode_enum),
 763         SOC_ENUM("Lineout Mode", max98095_lineout_mode_enum),
 764 };
 765
 766 /* Left speaker mixer switch */
 767 static const struct snd_kcontrol_new max98095_left_speaker_mixer_controls[] = {
 768         SOC_DAPM_SINGLE("Left DAC1 Switch", M98095_050_MIX_SPK_LEFT, 0, 1, 0),
 769         SOC_DAPM_SINGLE("Right DAC1 Switch", M98095_050_MIX_SPK_LEFT, 6, 1, 0),
 770         SOC_DAPM_SINGLE("Mono DAC2 Switch", M98095_050_MIX_SPK_LEFT, 3, 1, 0),
 771         SOC_DAPM_SINGLE("Mono DAC3 Switch", M98095_050_MIX_SPK_LEFT, 3, 1, 0),
 772         SOC_DAPM_SINGLE("MIC1 Switch", M98095_050_MIX_SPK_LEFT, 4, 1, 0),
 773         SOC_DAPM_SINGLE("MIC2 Switch", M98095_050_MIX_SPK_LEFT, 5, 1, 0),
 774         SOC_DAPM_SINGLE("IN1 Switch", M98095_050_MIX_SPK_LEFT, 1, 1, 0),
 775         SOC_DAPM_SINGLE("IN2 Switch", M98095_050_MIX_SPK_LEFT, 2, 1, 0),
 776 };
 777
 778 /* Right speaker mixer switch */
 779 static const struct snd_kcontrol_new max98095_right_speaker_mixer_controls[] = {
 780         SOC_DAPM_SINGLE("Left DAC1 Switch", M98095_051_MIX_SPK_RIGHT, 6, 1, 0),
 781         SOC_DAPM_SINGLE("Right DAC1 Switch", M98095_051_MIX_SPK_RIGHT, 0, 1, 0),
 782         SOC_DAPM_SINGLE("Mono DAC2 Switch", M98095_051_MIX_SPK_RIGHT, 3, 1, 0),
 783         SOC_DAPM_SINGLE("Mono DAC3 Switch", M98095_051_MIX_SPK_RIGHT, 3, 1, 0),
 784         SOC_DAPM_SINGLE("MIC1 Switch", M98095_051_MIX_SPK_RIGHT, 5, 1, 0),
 785         SOC_DAPM_SINGLE("MIC2 Switch", M98095_051_MIX_SPK_RIGHT, 4, 1, 0),
 786         SOC_DAPM_SINGLE("IN1 Switch", M98095_051_MIX_SPK_RIGHT, 1, 1, 0),
 787         SOC_DAPM_SINGLE("IN2 Switch", M98095_051_MIX_SPK_RIGHT, 2, 1, 0),
 788 };
 789
 790 /* Left headphone mixer switch */
 791 static const struct snd_kcontrol_new max98095_left_hp_mixer_controls[] = {
 792         SOC_DAPM_SINGLE("Left DAC1 Switch", M98095_04C_MIX_HP_LEFT, 0, 1, 0),
 793         SOC_DAPM_SINGLE("Right DAC1 Switch", M98095_04C_MIX_HP_LEFT, 5, 1, 0),
 794         SOC_DAPM_SINGLE("MIC1 Switch", M98095_04C_MIX_HP_LEFT, 3, 1, 0),
 795         SOC_DAPM_SINGLE("MIC2 Switch", M98095_04C_MIX_HP_LEFT, 4, 1, 0),
 796         SOC_DAPM_SINGLE("IN1 Switch", M98095_04C_MIX_HP_LEFT, 1, 1, 0),
 797         SOC_DAPM_SINGLE("IN2 Switch", M98095_04C_MIX_HP_LEFT, 2, 1, 0),
 798 };
 799
 800 /* Right headphone mixer switch */
 801 static const struct snd_kcontrol_new max98095_right_hp_mixer_controls[] = {
 802         SOC_DAPM_SINGLE("Left DAC1 Switch", M98095_04D_MIX_HP_RIGHT, 5, 1, 0),
 803         SOC_DAPM_SINGLE("Right DAC1 Switch", M98095_04D_MIX_HP_RIGHT, 0, 1, 0),
 804         SOC_DAPM_SINGLE("MIC1 Switch", M98095_04D_MIX_HP_RIGHT, 3, 1, 0),
 805         SOC_DAPM_SINGLE("MIC2 Switch", M98095_04D_MIX_HP_RIGHT, 4, 1, 0),
 806         SOC_DAPM_SINGLE("IN1 Switch", M98095_04D_MIX_HP_RIGHT, 1, 1, 0),
 807         SOC_DAPM_SINGLE("IN2 Switch", M98095_04D_MIX_HP_RIGHT, 2, 1, 0),
 808 };
 809
 810 /* Receiver earpiece mixer switch */
 811 static const struct snd_kcontrol_new max98095_mono_rcv_mixer_controls[] = {
 812         SOC_DAPM_SINGLE("Left DAC1 Switch", M98095_04F_MIX_RCV, 0, 1, 0),
 813         SOC_DAPM_SINGLE("Right DAC1 Switch", M98095_04F_MIX_RCV, 5, 1, 0),
 814         SOC_DAPM_SINGLE("MIC1 Switch", M98095_04F_MIX_RCV, 3, 1, 0),
 815         SOC_DAPM_SINGLE("MIC2 Switch", M98095_04F_MIX_RCV, 4, 1, 0),
 816         SOC_DAPM_SINGLE("IN1 Switch", M98095_04F_MIX_RCV, 1, 1, 0),
 817         SOC_DAPM_SINGLE("IN2 Switch", M98095_04F_MIX_RCV, 2, 1, 0),
 818 };
 819
 820 /* Left lineout mixer switch */
 821 static const struct snd_kcontrol_new max98095_left_lineout_mixer_controls[] = {
 822         SOC_DAPM_SINGLE("Left DAC1 Switch", M98095_053_MIX_LINEOUT1, 5, 1, 0),
 823         SOC_DAPM_SINGLE("Right DAC1 Switch", M98095_053_MIX_LINEOUT1, 0, 1, 0),
 824         SOC_DAPM_SINGLE("MIC1 Switch", M98095_053_MIX_LINEOUT1, 3, 1, 0),
 825         SOC_DAPM_SINGLE("MIC2 Switch", M98095_053_MIX_LINEOUT1, 4, 1, 0),
 826         SOC_DAPM_SINGLE("IN1 Switch", M98095_053_MIX_LINEOUT1, 1, 1, 0),
 827         SOC_DAPM_SINGLE("IN2 Switch", M98095_053_MIX_LINEOUT1, 2, 1, 0),
 828 };
 829
 830 /* Right lineout mixer switch */
 831 static const struct snd_kcontrol_new max98095_right_lineout_mixer_controls[] = {
 832         SOC_DAPM_SINGLE("Left DAC1 Switch", M98095_054_MIX_LINEOUT2, 0, 1, 0),
 833         SOC_DAPM_SINGLE("Right DAC1 Switch", M98095_054_MIX_LINEOUT2, 5, 1, 0),
 834         SOC_DAPM_SINGLE("MIC1 Switch", M98095_054_MIX_LINEOUT2, 3, 1, 0),
 835         SOC_DAPM_SINGLE("MIC2 Switch", M98095_054_MIX_LINEOUT2, 4, 1, 0),
 836         SOC_DAPM_SINGLE("IN1 Switch", M98095_054_MIX_LINEOUT2, 1, 1, 0),
 837         SOC_DAPM_SINGLE("IN2 Switch", M98095_054_MIX_LINEOUT2, 2, 1, 0),
 838 };
 839
 840 /* Left ADC mixer switch */
 841 static const struct snd_kcontrol_new max98095_left_ADC_mixer_controls[] = {
 842         SOC_DAPM_SINGLE("MIC1 Switch", M98095_04A_MIX_ADC_LEFT, 7, 1, 0),
 843         SOC_DAPM_SINGLE("MIC2 Switch", M98095_04A_MIX_ADC_LEFT, 6, 1, 0),
 844         SOC_DAPM_SINGLE("IN1 Switch", M98095_04A_MIX_ADC_LEFT, 3, 1, 0),
 845         SOC_DAPM_SINGLE("IN2 Switch", M98095_04A_MIX_ADC_LEFT, 2, 1, 0),
 846 };
 847
 848 /* Right ADC mixer switch */
 849 static const struct snd_kcontrol_new max98095_right_ADC_mixer_controls[] = {
 850         SOC_DAPM_SINGLE("MIC1 Switch", M98095_04B_MIX_ADC_RIGHT, 7, 1, 0),
 851         SOC_DAPM_SINGLE("MIC2 Switch", M98095_04B_MIX_ADC_RIGHT, 6, 1, 0),
 852         SOC_DAPM_SINGLE("IN1 Switch", M98095_04B_MIX_ADC_RIGHT, 3, 1, 0),
 853         SOC_DAPM_SINGLE("IN2 Switch", M98095_04B_MIX_ADC_RIGHT, 2, 1, 0),
 854 };
 855
 856 static int max98095_mic_event(struct snd_soc_dapm_widget *w,
 857                              struct snd_kcontrol *kcontrol, int event)
 858 {
 859         struct snd_soc_codec *codec = w->codec;
 860         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
 861
 862         switch (event) {
 863         case SND_SOC_DAPM_POST_PMU:
 864                 if (w->reg == M98095_05F_LVL_MIC1) {
 865                         snd_soc_update_bits(codec, w->reg, M98095_MICPRE_MASK,
 866                                 (1+max98095->mic1pre)<<M98095_MICPRE_SHIFT);
 867                 } else {
 868                         snd_soc_update_bits(codec, w->reg, M98095_MICPRE_MASK,
 869                                 (1+max98095->mic2pre)<<M98095_MICPRE_SHIFT);
 870                 }
 871                 break;
 872         case SND_SOC_DAPM_POST_PMD:
 873                 snd_soc_update_bits(codec, w->reg, M98095_MICPRE_MASK, 0);
 874                 break;
 875         default:
 876                 return -EINVAL;
 877         }
 878
 879         return 0;
 880 }
 881
 882 /*
 883  * The line inputs are stereo inputs with the left and right
 884  * channels sharing a common PGA power control signal.
 885  */
 886 static int max98095_line_pga(struct snd_soc_dapm_widget *w,
 887                              int event, u8 channel)
 888 {
 889         struct snd_soc_codec *codec = w->codec;
 890         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
 891         u8 *state;
 892
 893         BUG_ON(!((channel == 1) || (channel == 2)));
 894
 895         state = &max98095->lin_state;
 896
 897         switch (event) {
 898         case SND_SOC_DAPM_POST_PMU:
 899                 *state |= channel;
 900                 snd_soc_update_bits(codec, w->reg,
 901                         (1 << w->shift), (1 << w->shift));
 902                 break;
 903         case SND_SOC_DAPM_POST_PMD:
 904                 *state &= ~channel;
 905                 if (*state == 0) {
 906                         snd_soc_update_bits(codec, w->reg,
 907                                 (1 << w->shift), 0);
 908                 }
 909                 break;
 910         default:
 911                 return -EINVAL;
 912         }
 913
 914         return 0;
 915 }
 916
 917 static int max98095_pga_in1_event(struct snd_soc_dapm_widget *w,
 918                                    struct snd_kcontrol *k, int event)
 919 {
 920         return max98095_line_pga(w, event, 1);
 921 }
 922
 923 static int max98095_pga_in2_event(struct snd_soc_dapm_widget *w,
 924                                    struct snd_kcontrol *k, int event)
 925 {
 926         return max98095_line_pga(w, event, 2);
 927 }
 928
 929 /*
 930  * The stereo line out mixer outputs to two stereo line outs.
 931  * The 2nd pair has a separate set of enables.
 932  */
 933 static int max98095_lineout_event(struct snd_soc_dapm_widget *w,
 934                              struct snd_kcontrol *kcontrol, int event)
 935 {
 936         struct snd_soc_codec *codec = w->codec;
 937
 938         switch (event) {
 939         case SND_SOC_DAPM_POST_PMU:
 940                 snd_soc_update_bits(codec, w->reg,
 941                         (1 << (w->shift+2)), (1 << (w->shift+2)));
 942                 break;
 943         case SND_SOC_DAPM_POST_PMD:
 944                 snd_soc_update_bits(codec, w->reg,
 945                         (1 << (w->shift+2)), 0);
 946                 break;
 947         default:
 948                 return -EINVAL;
 949         }
 950
 951         return 0;
 952 }
 953
 954 static const struct snd_soc_dapm_widget max98095_dapm_widgets[] = {
 955
 956         SND_SOC_DAPM_ADC("ADCL", "HiFi Capture", M98095_090_PWR_EN_IN, 0, 0),
 957         SND_SOC_DAPM_ADC("ADCR", "HiFi Capture", M98095_090_PWR_EN_IN, 1, 0),
 958
 959         SND_SOC_DAPM_DAC("DACL1", "HiFi Playback",
 960                 M98095_091_PWR_EN_OUT, 0, 0),
 961         SND_SOC_DAPM_DAC("DACR1", "HiFi Playback",
 962                 M98095_091_PWR_EN_OUT, 1, 0),
 963         SND_SOC_DAPM_DAC("DACM2", "Aux Playback",
 964                 M98095_091_PWR_EN_OUT, 2, 0),
 965         SND_SOC_DAPM_DAC("DACM3", "Voice Playback",
 966                 M98095_091_PWR_EN_OUT, 2, 0),
 967
 968         SND_SOC_DAPM_PGA("HP Left Out", M98095_091_PWR_EN_OUT,
 969                 6, 0, NULL, 0),
 970         SND_SOC_DAPM_PGA("HP Right Out", M98095_091_PWR_EN_OUT,
 971                 7, 0, NULL, 0),
 972
 973         SND_SOC_DAPM_PGA("SPK Left Out", M98095_091_PWR_EN_OUT,
 974                 4, 0, NULL, 0),
 975         SND_SOC_DAPM_PGA("SPK Right Out", M98095_091_PWR_EN_OUT,
 976                 5, 0, NULL, 0),
 977
 978         SND_SOC_DAPM_PGA("RCV Mono Out", M98095_091_PWR_EN_OUT,
 979                 3, 0, NULL, 0),
 980
 981         SND_SOC_DAPM_PGA_E("LINE Left Out", M98095_092_PWR_EN_OUT,
 982                 0, 0, NULL, 0, max98095_lineout_event, SND_SOC_DAPM_PRE_PMD),
 983         SND_SOC_DAPM_PGA_E("LINE Right Out", M98095_092_PWR_EN_OUT,
 984                 1, 0, NULL, 0, max98095_lineout_event, SND_SOC_DAPM_PRE_PMD),
 985
 986         SND_SOC_DAPM_MUX("External MIC", SND_SOC_NOPM, 0, 0,
 987                 &max98095_extmic_mux),
 988
 989         SND_SOC_DAPM_MUX("Linein Mux", SND_SOC_NOPM, 0, 0,
 990                 &max98095_linein_mux),
 991
 992         SND_SOC_DAPM_MIXER("Left Headphone Mixer", SND_SOC_NOPM, 0, 0,
 993                 &max98095_left_hp_mixer_controls[0],
 994                 ARRAY_SIZE(max98095_left_hp_mixer_controls)),
 995
 996         SND_SOC_DAPM_MIXER("Right Headphone Mixer", SND_SOC_NOPM, 0, 0,
 997                 &max98095_right_hp_mixer_controls[0],
 998                 ARRAY_SIZE(max98095_right_hp_mixer_controls)),
 999
1000         SND_SOC_DAPM_MIXER("Left Speaker Mixer", SND_SOC_NOPM, 0, 0,
1001                 &max98095_left_speaker_mixer_controls[0],
1002                 ARRAY_SIZE(max98095_left_speaker_mixer_controls)),
1003
1004         SND_SOC_DAPM_MIXER("Right Speaker Mixer", SND_SOC_NOPM, 0, 0,
1005                 &max98095_right_speaker_mixer_controls[0],
1006                 ARRAY_SIZE(max98095_right_speaker_mixer_controls)),
1007
1008         SND_SOC_DAPM_MIXER("Receiver Mixer", SND_SOC_NOPM, 0, 0,
1009           &max98095_mono_rcv_mixer_controls[0],
1010                 ARRAY_SIZE(max98095_mono_rcv_mixer_controls)),
1011
1012         SND_SOC_DAPM_MIXER("Left Lineout Mixer", SND_SOC_NOPM, 0, 0,
1013                 &max98095_left_lineout_mixer_controls[0],
1014                 ARRAY_SIZE(max98095_left_lineout_mixer_controls)),
1015
1016         SND_SOC_DAPM_MIXER("Right Lineout Mixer", SND_SOC_NOPM, 0, 0,
1017                 &max98095_right_lineout_mixer_controls[0],
1018                 ARRAY_SIZE(max98095_right_lineout_mixer_controls)),
1019
1020         SND_SOC_DAPM_MIXER("Left ADC Mixer", SND_SOC_NOPM, 0, 0,
1021                 &max98095_left_ADC_mixer_controls[0],
1022                 ARRAY_SIZE(max98095_left_ADC_mixer_controls)),
1023
1024         SND_SOC_DAPM_MIXER("Right ADC Mixer", SND_SOC_NOPM, 0, 0,
1025                 &max98095_right_ADC_mixer_controls[0],
1026                 ARRAY_SIZE(max98095_right_ADC_mixer_controls)),
1027
1028         SND_SOC_DAPM_PGA_E("MIC1 Input", M98095_05F_LVL_MIC1,
1029                 5, 0, NULL, 0, max98095_mic_event,
1030                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1031
1032         SND_SOC_DAPM_PGA_E("MIC2 Input", M98095_060_LVL_MIC2,
1033                 5, 0, NULL, 0, max98095_mic_event,
1034                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1035
1036         SND_SOC_DAPM_PGA_E("IN1 Input", M98095_090_PWR_EN_IN,
1037                 7, 0, NULL, 0, max98095_pga_in1_event,
1038                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1039
1040         SND_SOC_DAPM_PGA_E("IN2 Input", M98095_090_PWR_EN_IN,
1041                 7, 0, NULL, 0, max98095_pga_in2_event,
1042                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1043
1044         SND_SOC_DAPM_MICBIAS("MICBIAS1", M98095_090_PWR_EN_IN, 2, 0),
1045         SND_SOC_DAPM_MICBIAS("MICBIAS2", M98095_090_PWR_EN_IN, 3, 0),
1046
1047         SND_SOC_DAPM_OUTPUT("HPL"),
1048         SND_SOC_DAPM_OUTPUT("HPR"),
1049         SND_SOC_DAPM_OUTPUT("SPKL"),
1050         SND_SOC_DAPM_OUTPUT("SPKR"),
1051         SND_SOC_DAPM_OUTPUT("RCV"),
1052         SND_SOC_DAPM_OUTPUT("OUT1"),
1053         SND_SOC_DAPM_OUTPUT("OUT2"),
1054         SND_SOC_DAPM_OUTPUT("OUT3"),
1055         SND_SOC_DAPM_OUTPUT("OUT4"),
1056
1057         SND_SOC_DAPM_INPUT("MIC1"),
1058         SND_SOC_DAPM_INPUT("MIC2"),
1059         SND_SOC_DAPM_INPUT("INA1"),
1060         SND_SOC_DAPM_INPUT("INA2"),
1061         SND_SOC_DAPM_INPUT("INB1"),
1062         SND_SOC_DAPM_INPUT("INB2"),
1063 };
1064
1065 static const struct snd_soc_dapm_route max98095_audio_map[] = {
1066         /* Left headphone output mixer */
1067         {"Left Headphone Mixer", "Left DAC1 Switch", "DACL1"},
1068         {"Left Headphone Mixer", "Right DAC1 Switch", "DACR1"},
1069         {"Left Headphone Mixer", "MIC1 Switch", "MIC1 Input"},
1070         {"Left Headphone Mixer", "MIC2 Switch", "MIC2 Input"},
1071         {"Left Headphone Mixer", "IN1 Switch", "IN1 Input"},
1072         {"Left Headphone Mixer", "IN2 Switch", "IN2 Input"},
1073
1074         /* Right headphone output mixer */
1075         {"Right Headphone Mixer", "Left DAC1 Switch", "DACL1"},
1076         {"Right Headphone Mixer", "Right DAC1 Switch", "DACR1"},
1077         {"Right Headphone Mixer", "MIC1 Switch", "MIC1 Input"},
1078         {"Right Headphone Mixer", "MIC2 Switch", "MIC2 Input"},
1079         {"Right Headphone Mixer", "IN1 Switch", "IN1 Input"},
1080         {"Right Headphone Mixer", "IN2 Switch", "IN2 Input"},
1081
1082         /* Left speaker output mixer */
1083         {"Left Speaker Mixer", "Left DAC1 Switch", "DACL1"},
1084         {"Left Speaker Mixer", "Right DAC1 Switch", "DACR1"},
1085         {"Left Speaker Mixer", "Mono DAC2 Switch", "DACM2"},
1086         {"Left Speaker Mixer", "Mono DAC3 Switch", "DACM3"},
1087         {"Left Speaker Mixer", "MIC1 Switch", "MIC1 Input"},
1088         {"Left Speaker Mixer", "MIC2 Switch", "MIC2 Input"},
1089         {"Left Speaker Mixer", "IN1 Switch", "IN1 Input"},
1090         {"Left Speaker Mixer", "IN2 Switch", "IN2 Input"},
1091
1092         /* Right speaker output mixer */
1093         {"Right Speaker Mixer", "Left DAC1 Switch", "DACL1"},
1094         {"Right Speaker Mixer", "Right DAC1 Switch", "DACR1"},
1095         {"Right Speaker Mixer", "Mono DAC2 Switch", "DACM2"},
1096         {"Right Speaker Mixer", "Mono DAC3 Switch", "DACM3"},
1097         {"Right Speaker Mixer", "MIC1 Switch", "MIC1 Input"},
1098         {"Right Speaker Mixer", "MIC2 Switch", "MIC2 Input"},
1099         {"Right Speaker Mixer", "IN1 Switch", "IN1 Input"},
1100         {"Right Speaker Mixer", "IN2 Switch", "IN2 Input"},
1101
1102         /* Earpiece/Receiver output mixer */
1103         {"Receiver Mixer", "Left DAC1 Switch", "DACL1"},
1104         {"Receiver Mixer", "Right DAC1 Switch", "DACR1"},
1105         {"Receiver Mixer", "MIC1 Switch", "MIC1 Input"},
1106         {"Receiver Mixer", "MIC2 Switch", "MIC2 Input"},
1107         {"Receiver Mixer", "IN1 Switch", "IN1 Input"},
1108         {"Receiver Mixer", "IN2 Switch", "IN2 Input"},
1109
1110         /* Left Lineout output mixer */
1111         {"Left Lineout Mixer", "Left DAC1 Switch", "DACL1"},
1112         {"Left Lineout Mixer", "Right DAC1 Switch", "DACR1"},
1113         {"Left Lineout Mixer", "MIC1 Switch", "MIC1 Input"},
1114         {"Left Lineout Mixer", "MIC2 Switch", "MIC2 Input"},
1115         {"Left Lineout Mixer", "IN1 Switch", "IN1 Input"},
1116         {"Left Lineout Mixer", "IN2 Switch", "IN2 Input"},
1117
1118         /* Right lineout output mixer */
1119         {"Right Lineout Mixer", "Left DAC1 Switch", "DACL1"},
1120         {"Right Lineout Mixer", "Right DAC1 Switch", "DACR1"},
1121         {"Right Lineout Mixer", "MIC1 Switch", "MIC1 Input"},
1122         {"Right Lineout Mixer", "MIC2 Switch", "MIC2 Input"},
1123         {"Right Lineout Mixer", "IN1 Switch", "IN1 Input"},
1124         {"Right Lineout Mixer", "IN2 Switch", "IN2 Input"},
1125
1126         {"HP Left Out", NULL, "Left Headphone Mixer"},
1127         {"HP Right Out", NULL, "Right Headphone Mixer"},
1128         {"SPK Left Out", NULL, "Left Speaker Mixer"},
1129         {"SPK Right Out", NULL, "Right Speaker Mixer"},
1130         {"RCV Mono Out", NULL, "Receiver Mixer"},
1131         {"LINE Left Out", NULL, "Left Lineout Mixer"},
1132         {"LINE Right Out", NULL, "Right Lineout Mixer"},
1133
1134         {"HPL", NULL, "HP Left Out"},
1135         {"HPR", NULL, "HP Right Out"},
1136         {"SPKL", NULL, "SPK Left Out"},
1137         {"SPKR", NULL, "SPK Right Out"},
1138         {"RCV", NULL, "RCV Mono Out"},
1139         {"OUT1", NULL, "LINE Left Out"},
1140         {"OUT2", NULL, "LINE Right Out"},
1141         {"OUT3", NULL, "LINE Left Out"},
1142         {"OUT4", NULL, "LINE Right Out"},
1143
1144         /* Left ADC input mixer */
1145         {"Left ADC Mixer", "MIC1 Switch", "MIC1 Input"},
1146         {"Left ADC Mixer", "MIC2 Switch", "MIC2 Input"},
1147         {"Left ADC Mixer", "IN1 Switch", "IN1 Input"},
1148         {"Left ADC Mixer", "IN2 Switch", "IN2 Input"},
1149
1150         /* Right ADC input mixer */
1151         {"Right ADC Mixer", "MIC1 Switch", "MIC1 Input"},
1152         {"Right ADC Mixer", "MIC2 Switch", "MIC2 Input"},
1153         {"Right ADC Mixer", "IN1 Switch", "IN1 Input"},
1154         {"Right ADC Mixer", "IN2 Switch", "IN2 Input"},
1155
1156         /* Inputs */
1157         {"ADCL", NULL, "Left ADC Mixer"},
1158         {"ADCR", NULL, "Right ADC Mixer"},
1159
1160         {"IN1 Input", NULL, "INA1"},
1161         {"IN2 Input", NULL, "INA2"},
1162
1163         {"MIC1 Input", NULL, "MIC1"},
1164         {"MIC2 Input", NULL, "MIC2"},
1165 };
1166
1167 /* codec mclk clock divider coefficients */
1168 static const struct {
1169         u32 rate;
1170         u8  sr;
1171 } rate_table[] = {
1172         {8000,  0x01},
1173         {11025, 0x02},
1174         {16000, 0x03},
1175         {22050, 0x04},
1176         {24000, 0x05},
1177         {32000, 0x06},
1178         {44100, 0x07},
1179         {48000, 0x08},
1180         {88200, 0x09},
1181         {96000, 0x0A},
1182 };
1183
1184 static int rate_value(int rate, u8 *value)
1185 {
1186         int i;
1187
1188         for (i = 0; i < ARRAY_SIZE(rate_table); i++) {
1189                 if (rate_table[i].rate >= rate) {
1190                         *value = rate_table[i].sr;
1191                         return 0;
1192                 }
1193         }
1194         *value = rate_table[0].sr;
1195         return -EINVAL;
1196 }
1197
1198 static int max98095_dai1_hw_params(struct snd_pcm_substream *substream,
1199                                    struct snd_pcm_hw_params *params,
1200                                    struct snd_soc_dai *dai)
1201 {
1202         struct snd_soc_codec *codec = dai->codec;
1203         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
1204         struct max98095_cdata *cdata;
1205         unsigned long long ni;
1206         unsigned int rate;
1207         u8 regval;
1208
1209         cdata = &max98095->dai[0];
1210
1211         rate = params_rate(params);
1212
1213         switch (params_format(params)) {
1214         case SNDRV_PCM_FORMAT_S16_LE:
1215                 snd_soc_update_bits(codec, M98095_02A_DAI1_FORMAT,
1216                         M98095_DAI_WS, 0);
1217                 break;
1218         case SNDRV_PCM_FORMAT_S24_LE:
1219                 snd_soc_update_bits(codec, M98095_02A_DAI1_FORMAT,
1220                         M98095_DAI_WS, M98095_DAI_WS);
1221                 break;
1222         default:
1223                 return -EINVAL;
1224         }
1225
1226         if (rate_value(rate, &regval))
1227                 return -EINVAL;
1228
1229         snd_soc_update_bits(codec, M98095_027_DAI1_CLKMODE,
1230                 M98095_CLKMODE_MASK, regval);
1231         cdata->rate = rate;
1232
1233         /* Configure NI when operating as master */
1234         if (snd_soc_read(codec, M98095_02A_DAI1_FORMAT) & M98095_DAI_MAS) {
1235                 if (max98095->sysclk == 0) {
1236                         dev_err(codec->dev, "Invalid system clock frequency\n");
1237                         return -EINVAL;
1238                 }
1239                 ni = 65536ULL * (rate < 50000 ? 96ULL : 48ULL)
1240                                 * (unsigned long long int)rate;
1241                 do_div(ni, (unsigned long long int)max98095->sysclk);
1242                 snd_soc_write(codec, M98095_028_DAI1_CLKCFG_HI,
1243                         (ni >> 8) & 0x7F);
1244                 snd_soc_write(codec, M98095_029_DAI1_CLKCFG_LO,
1245                         ni & 0xFF);
1246         }
1247
1248         /* Update sample rate mode */
1249         if (rate < 50000)
1250                 snd_soc_update_bits(codec, M98095_02E_DAI1_FILTERS,
1251                         M98095_DAI_DHF, 0);
1252         else
1253                 snd_soc_update_bits(codec, M98095_02E_DAI1_FILTERS,
1254                         M98095_DAI_DHF, M98095_DAI_DHF);
1255
1256         return 0;
1257 }
1258
1259 static int max98095_dai2_hw_params(struct snd_pcm_substream *substream,
1260                                    struct snd_pcm_hw_params *params,
1261                                    struct snd_soc_dai *dai)
1262 {
1263         struct snd_soc_codec *codec = dai->codec;
1264         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
1265         struct max98095_cdata *cdata;
1266         unsigned long long ni;
1267         unsigned int rate;
1268         u8 regval;
1269
1270         cdata = &max98095->dai[1];
1271
1272         rate = params_rate(params);
1273
1274         switch (params_format(params)) {
1275         case SNDRV_PCM_FORMAT_S16_LE:
1276                 snd_soc_update_bits(codec, M98095_034_DAI2_FORMAT,
1277                         M98095_DAI_WS, 0);
1278                 break;
1279         case SNDRV_PCM_FORMAT_S24_LE:
1280                 snd_soc_update_bits(codec, M98095_034_DAI2_FORMAT,
1281                         M98095_DAI_WS, M98095_DAI_WS);
1282                 break;
1283         default:
1284                 return -EINVAL;
1285         }
1286
1287         if (rate_value(rate, &regval))
1288                 return -EINVAL;
1289
1290         snd_soc_update_bits(codec, M98095_031_DAI2_CLKMODE,
1291                 M98095_CLKMODE_MASK, regval);
1292         cdata->rate = rate;
1293
1294         /* Configure NI when operating as master */
1295         if (snd_soc_read(codec, M98095_034_DAI2_FORMAT) & M98095_DAI_MAS) {
1296                 if (max98095->sysclk == 0) {
1297                         dev_err(codec->dev, "Invalid system clock frequency\n");
1298                         return -EINVAL;
1299                 }
1300                 ni = 65536ULL * (rate < 50000 ? 96ULL : 48ULL)
1301                                 * (unsigned long long int)rate;
1302                 do_div(ni, (unsigned long long int)max98095->sysclk);
1303                 snd_soc_write(codec, M98095_032_DAI2_CLKCFG_HI,
1304                         (ni >> 8) & 0x7F);
1305                 snd_soc_write(codec, M98095_033_DAI2_CLKCFG_LO,
1306                         ni & 0xFF);
1307         }
1308
1309         /* Update sample rate mode */
1310         if (rate < 50000)
1311                 snd_soc_update_bits(codec, M98095_038_DAI2_FILTERS,
1312                         M98095_DAI_DHF, 0);
1313         else
1314                 snd_soc_update_bits(codec, M98095_038_DAI2_FILTERS,
1315                         M98095_DAI_DHF, M98095_DAI_DHF);
1316
1317         return 0;
1318 }
1319
1320 static int max98095_dai3_hw_params(struct snd_pcm_substream *substream,
1321                                    struct snd_pcm_hw_params *params,
1322                                    struct snd_soc_dai *dai)
1323 {
1324         struct snd_soc_codec *codec = dai->codec;
1325         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
1326         struct max98095_cdata *cdata;
1327         unsigned long long ni;
1328         unsigned int rate;
1329         u8 regval;
1330
1331         cdata = &max98095->dai[2];
1332
1333         rate = params_rate(params);
1334
1335         switch (params_format(params)) {
1336         case SNDRV_PCM_FORMAT_S16_LE:
1337                 snd_soc_update_bits(codec, M98095_03E_DAI3_FORMAT,
1338                         M98095_DAI_WS, 0);
1339                 break;
1340         case SNDRV_PCM_FORMAT_S24_LE:
1341                 snd_soc_update_bits(codec, M98095_03E_DAI3_FORMAT,
1342                         M98095_DAI_WS, M98095_DAI_WS);
1343                 break;
1344         default:
1345                 return -EINVAL;
1346         }
1347
1348         if (rate_value(rate, &regval))
1349                 return -EINVAL;
1350
1351         snd_soc_update_bits(codec, M98095_03B_DAI3_CLKMODE,
1352                 M98095_CLKMODE_MASK, regval);
1353         cdata->rate = rate;
1354
1355         /* Configure NI when operating as master */
1356         if (snd_soc_read(codec, M98095_03E_DAI3_FORMAT) & M98095_DAI_MAS) {
1357                 if (max98095->sysclk == 0) {
1358                         dev_err(codec->dev, "Invalid system clock frequency\n");
1359                         return -EINVAL;
1360                 }
1361                 ni = 65536ULL * (rate < 50000 ? 96ULL : 48ULL)
1362                                 * (unsigned long long int)rate;
1363                 do_div(ni, (unsigned long long int)max98095->sysclk);
1364                 snd_soc_write(codec, M98095_03C_DAI3_CLKCFG_HI,
1365                         (ni >> 8) & 0x7F);
1366                 snd_soc_write(codec, M98095_03D_DAI3_CLKCFG_LO,
1367                         ni & 0xFF);
1368         }
1369
1370         /* Update sample rate mode */
1371         if (rate < 50000)
1372                 snd_soc_update_bits(codec, M98095_042_DAI3_FILTERS,
1373                         M98095_DAI_DHF, 0);
1374         else
1375                 snd_soc_update_bits(codec, M98095_042_DAI3_FILTERS,
1376                         M98095_DAI_DHF, M98095_DAI_DHF);
1377
1378         return 0;
1379 }
1380
1381 static int max98095_dai_set_sysclk(struct snd_soc_dai *dai,
1382                                    int clk_id, unsigned int freq, int dir)
1383 {
1384         struct snd_soc_codec *codec = dai->codec;
1385         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
1386
1387         /* Requested clock frequency is already setup */
1388         if (freq == max98095->sysclk)
1389                 return 0;
1390
1391         /* Setup clocks for slave mode, and using the PLL
1392          * PSCLK = 0x01 (when master clk is 10MHz to 20MHz)
1393          *         0x02 (when master clk is 20MHz to 40MHz)..
1394          *         0x03 (when master clk is 40MHz to 60MHz)..
1395          */
1396         if ((freq >= 10000000) && (freq < 20000000)) {
1397                 snd_soc_write(codec, M98095_026_SYS_CLK, 0x10);
1398         } else if ((freq >= 20000000) && (freq < 40000000)) {
1399                 snd_soc_write(codec, M98095_026_SYS_CLK, 0x20);
1400         } else if ((freq >= 40000000) && (freq < 60000000)) {
1401                 snd_soc_write(codec, M98095_026_SYS_CLK, 0x30);
1402         } else {
1403                 dev_err(codec->dev, "Invalid master clock frequency\n");
1404                 return -EINVAL;
1405         }
1406
1407         dev_dbg(dai->dev, "Clock source is %d at %uHz\n", clk_id, freq);
1408
1409         max98095->sysclk = freq;
1410         return 0;
1411 }
1412
1413 static int max98095_dai1_set_fmt(struct snd_soc_dai *codec_dai,
1414                                  unsigned int fmt)
1415 {
1416         struct snd_soc_codec *codec = codec_dai->codec;
1417         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
1418         struct max98095_cdata *cdata;
1419         u8 regval = 0;
1420
1421         cdata = &max98095->dai[0];
1422
1423         if (fmt != cdata->fmt) {
1424                 cdata->fmt = fmt;
1425
1426                 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1427                 case SND_SOC_DAIFMT_CBS_CFS:
1428                         /* Slave mode PLL */
1429                         snd_soc_write(codec, M98095_028_DAI1_CLKCFG_HI,
1430                                 0x80);
1431                         snd_soc_write(codec, M98095_029_DAI1_CLKCFG_LO,
1432                                 0x00);
1433                         break;
1434                 case SND_SOC_DAIFMT_CBM_CFM:
1435                         /* Set to master mode */
1436                         regval |= M98095_DAI_MAS;
1437                         break;
1438                 case SND_SOC_DAIFMT_CBS_CFM:
1439                 case SND_SOC_DAIFMT_CBM_CFS:
1440                 default:
1441                         dev_err(codec->dev, "Clock mode unsupported");
1442                         return -EINVAL;
1443                 }
1444
1445                 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1446                 case SND_SOC_DAIFMT_I2S:
1447                         regval |= M98095_DAI_DLY;
1448                         break;
1449                 case SND_SOC_DAIFMT_LEFT_J:
1450                         break;
1451                 default:
1452                         return -EINVAL;
1453                 }
1454
1455                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1456                 case SND_SOC_DAIFMT_NB_NF:
1457                         break;
1458                 case SND_SOC_DAIFMT_NB_IF:
1459                         regval |= M98095_DAI_WCI;
1460                         break;
1461                 case SND_SOC_DAIFMT_IB_NF:
1462                         regval |= M98095_DAI_BCI;
1463                         break;
1464                 case SND_SOC_DAIFMT_IB_IF:
1465                         regval |= M98095_DAI_BCI|M98095_DAI_WCI;
1466                         break;
1467                 default:
1468                         return -EINVAL;
1469                 }
1470
1471                 snd_soc_update_bits(codec, M98095_02A_DAI1_FORMAT,
1472                         M98095_DAI_MAS | M98095_DAI_DLY | M98095_DAI_BCI |
1473                         M98095_DAI_WCI, regval);
1474
1475                 snd_soc_write(codec, M98095_02B_DAI1_CLOCK, M98095_DAI_BSEL64);
1476         }
1477
1478         return 0;
1479 }
1480
1481 static int max98095_dai2_set_fmt(struct snd_soc_dai *codec_dai,
1482                                  unsigned int fmt)
1483 {
1484         struct snd_soc_codec *codec = codec_dai->codec;
1485         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
1486         struct max98095_cdata *cdata;
1487         u8 regval = 0;
1488
1489         cdata = &max98095->dai[1];
1490
1491         if (fmt != cdata->fmt) {
1492                 cdata->fmt = fmt;
1493
1494                 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1495                 case SND_SOC_DAIFMT_CBS_CFS:
1496                         /* Slave mode PLL */
1497                         snd_soc_write(codec, M98095_032_DAI2_CLKCFG_HI,
1498                                 0x80);
1499                         snd_soc_write(codec, M98095_033_DAI2_CLKCFG_LO,
1500                                 0x00);
1501                         break;
1502                 case SND_SOC_DAIFMT_CBM_CFM:
1503                         /* Set to master mode */
1504                         regval |= M98095_DAI_MAS;
1505                         break;
1506                 case SND_SOC_DAIFMT_CBS_CFM:
1507                 case SND_SOC_DAIFMT_CBM_CFS:
1508                 default:
1509                         dev_err(codec->dev, "Clock mode unsupported");
1510                         return -EINVAL;
1511                 }
1512
1513                 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1514                 case SND_SOC_DAIFMT_I2S:
1515                         regval |= M98095_DAI_DLY;
1516                         break;
1517                 case SND_SOC_DAIFMT_LEFT_J:
1518                         break;
1519                 default:
1520                         return -EINVAL;
1521                 }
1522
1523                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1524                 case SND_SOC_DAIFMT_NB_NF:
1525                         break;
1526                 case SND_SOC_DAIFMT_NB_IF:
1527                         regval |= M98095_DAI_WCI;
1528                         break;
1529                 case SND_SOC_DAIFMT_IB_NF:
1530                         regval |= M98095_DAI_BCI;
1531                         break;
1532                 case SND_SOC_DAIFMT_IB_IF:
1533                         regval |= M98095_DAI_BCI|M98095_DAI_WCI;
1534                         break;
1535                 default:
1536                         return -EINVAL;
1537                 }
1538
1539                 snd_soc_update_bits(codec, M98095_034_DAI2_FORMAT,
1540                         M98095_DAI_MAS | M98095_DAI_DLY | M98095_DAI_BCI |
1541                         M98095_DAI_WCI, regval);
1542
1543                 snd_soc_write(codec, M98095_035_DAI2_CLOCK,
1544                         M98095_DAI_BSEL64);
1545         }
1546
1547         return 0;
1548 }
1549
1550 static int max98095_dai3_set_fmt(struct snd_soc_dai *codec_dai,
1551                                  unsigned int fmt)
1552 {
1553         struct snd_soc_codec *codec = codec_dai->codec;
1554         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
1555         struct max98095_cdata *cdata;
1556         u8 regval = 0;
1557
1558         cdata = &max98095->dai[2];
1559
1560         if (fmt != cdata->fmt) {
1561                 cdata->fmt = fmt;
1562
1563                 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1564                 case SND_SOC_DAIFMT_CBS_CFS:
1565                         /* Slave mode PLL */
1566                         snd_soc_write(codec, M98095_03C_DAI3_CLKCFG_HI,
1567                                 0x80);
1568                         snd_soc_write(codec, M98095_03D_DAI3_CLKCFG_LO,
1569                                 0x00);
1570                         break;
1571                 case SND_SOC_DAIFMT_CBM_CFM:
1572                         /* Set to master mode */
1573                         regval |= M98095_DAI_MAS;
1574                         break;
1575                 case SND_SOC_DAIFMT_CBS_CFM:
1576                 case SND_SOC_DAIFMT_CBM_CFS:
1577                 default:
1578                         dev_err(codec->dev, "Clock mode unsupported");
1579                         return -EINVAL;
1580                 }
1581
1582                 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1583                 case SND_SOC_DAIFMT_I2S:
1584                         regval |= M98095_DAI_DLY;
1585                         break;
1586                 case SND_SOC_DAIFMT_LEFT_J:
1587                         break;
1588                 default:
1589                         return -EINVAL;
1590                 }
1591
1592                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1593                 case SND_SOC_DAIFMT_NB_NF:
1594                         break;
1595                 case SND_SOC_DAIFMT_NB_IF:
1596                         regval |= M98095_DAI_WCI;
1597                         break;
1598                 case SND_SOC_DAIFMT_IB_NF:
1599                         regval |= M98095_DAI_BCI;
1600                         break;
1601                 case SND_SOC_DAIFMT_IB_IF:
1602                         regval |= M98095_DAI_BCI|M98095_DAI_WCI;
1603                         break;
1604                 default:
1605                         return -EINVAL;
1606                 }
1607
1608                 snd_soc_update_bits(codec, M98095_03E_DAI3_FORMAT,
1609                         M98095_DAI_MAS | M98095_DAI_DLY | M98095_DAI_BCI |
1610                         M98095_DAI_WCI, regval);
1611
1612                 snd_soc_write(codec, M98095_03F_DAI3_CLOCK,
1613                         M98095_DAI_BSEL64);
1614         }
1615
1616         return 0;
1617 }
1618
1619 static int max98095_set_bias_level(struct snd_soc_codec *codec,
1620                                    enum snd_soc_bias_level level)
1621 {
1622         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
1623         int ret;
1624
1625         switch (level) {
1626         case SND_SOC_BIAS_ON:
1627                 break;
1628
1629         case SND_SOC_BIAS_PREPARE:
1630                 break;
1631
1632         case SND_SOC_BIAS_STANDBY:
1633                 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
1634                         ret = regcache_sync(max98095->regmap);
1635
1636                         if (ret != 0) {
1637                                 dev_err(codec->dev, "Failed to sync cache: %d\n", ret);
1638                                 return ret;
1639                         }
1640                 }
1641
1642                 snd_soc_update_bits(codec, M98095_090_PWR_EN_IN,
1643                                 M98095_MBEN, M98095_MBEN);
1644                 break;
1645
1646         case SND_SOC_BIAS_OFF:
1647                 snd_soc_update_bits(codec, M98095_090_PWR_EN_IN,
1648                                 M98095_MBEN, 0);
1649                 regcache_mark_dirty(max98095->regmap);
1650                 break;
1651         }
1652         codec->dapm.bias_level = level;
1653         return 0;
1654 }
1655
1656 #define MAX98095_RATES SNDRV_PCM_RATE_8000_96000
1657 #define MAX98095_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE)
1658
1659 static const struct snd_soc_dai_ops max98095_dai1_ops = {
1660         .set_sysclk = max98095_dai_set_sysclk,
1661         .set_fmt = max98095_dai1_set_fmt,
1662         .hw_params = max98095_dai1_hw_params,
1663 };
1664
1665 static const struct snd_soc_dai_ops max98095_dai2_ops = {
1666         .set_sysclk = max98095_dai_set_sysclk,
1667         .set_fmt = max98095_dai2_set_fmt,
1668         .hw_params = max98095_dai2_hw_params,
1669 };
1670
1671 static const struct snd_soc_dai_ops max98095_dai3_ops = {
1672         .set_sysclk = max98095_dai_set_sysclk,
1673         .set_fmt = max98095_dai3_set_fmt,
1674         .hw_params = max98095_dai3_hw_params,
1675 };
1676
1677 static struct snd_soc_dai_driver max98095_dai[] = {
1678 {
1679         .name = "HiFi",
1680         .playback = {
1681                 .stream_name = "HiFi Playback",
1682                 .channels_min = 1,
1683                 .channels_max = 2,
1684                 .rates = MAX98095_RATES,
1685                 .formats = MAX98095_FORMATS,
1686         },
1687         .capture = {
1688                 .stream_name = "HiFi Capture",
1689                 .channels_min = 1,
1690                 .channels_max = 2,
1691                 .rates = MAX98095_RATES,
1692                 .formats = MAX98095_FORMATS,
1693         },
1694          .ops = &max98095_dai1_ops,
1695 },
1696 {
1697         .name = "Aux",
1698         .playback = {
1699                 .stream_name = "Aux Playback",
1700                 .channels_min = 1,
1701                 .channels_max = 1,
1702                 .rates = MAX98095_RATES,
1703                 .formats = MAX98095_FORMATS,
1704         },
1705         .ops = &max98095_dai2_ops,
1706 },
1707 {
1708         .name = "Voice",
1709         .playback = {
1710                 .stream_name = "Voice Playback",
1711                 .channels_min = 1,
1712                 .channels_max = 1,
1713                 .rates = MAX98095_RATES,
1714                 .formats = MAX98095_FORMATS,
1715         },
1716         .ops = &max98095_dai3_ops,
1717 }
1718
1719 };
1720
1721 static int max98095_get_eq_channel(const char *name)
1722 {
1723         if (strcmp(name, "EQ1 Mode") == 0)
1724                 return 0;
1725         if (strcmp(name, "EQ2 Mode") == 0)
1726                 return 1;
1727         return -EINVAL;
1728 }
1729
1730 static int max98095_put_eq_enum(struct snd_kcontrol *kcontrol,
1731                                  struct snd_ctl_elem_value *ucontrol)
1732 {
1733         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1734         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
1735         struct max98095_pdata *pdata = max98095->pdata;
1736         int channel = max98095_get_eq_channel(kcontrol->id.name);
1737         struct max98095_cdata *cdata;
1738         unsigned int sel = ucontrol->value.integer.value[0];
1739         struct max98095_eq_cfg *coef_set;
1740         int fs, best, best_val, i;
1741         int regmask, regsave;
1742
1743         BUG_ON(channel > 1);
1744
1745         if (!pdata || !max98095->eq_textcnt)
1746                 return 0;
1747
1748         if (sel >= pdata->eq_cfgcnt)
1749                 return -EINVAL;
1750
1751         cdata = &max98095->dai[channel];
1752         cdata->eq_sel = sel;
1753         fs = cdata->rate;
1754
1755         /* Find the selected configuration with nearest sample rate */
1756         best = 0;
1757         best_val = INT_MAX;
1758         for (i = 0; i < pdata->eq_cfgcnt; i++) {
1759                 if (strcmp(pdata->eq_cfg[i].name, max98095->eq_texts[sel]) == 0 &&
1760                         abs(pdata->eq_cfg[i].rate - fs) < best_val) {
1761                         best = i;
1762                         best_val = abs(pdata->eq_cfg[i].rate - fs);
1763                 }
1764         }
1765
1766         dev_dbg(codec->dev, "Selected %s/%dHz for %dHz sample rate\n",
1767                 pdata->eq_cfg[best].name,
1768                 pdata->eq_cfg[best].rate, fs);
1769
1770         coef_set = &pdata->eq_cfg[best];
1771
1772         regmask = (channel == 0) ? M98095_EQ1EN : M98095_EQ2EN;
1773
1774         /* Disable filter while configuring, and save current on/off state */
1775         regsave = snd_soc_read(codec, M98095_088_CFG_LEVEL);
1776         snd_soc_update_bits(codec, M98095_088_CFG_LEVEL, regmask, 0);
1777
1778         mutex_lock(&codec->mutex);
1779         snd_soc_update_bits(codec, M98095_00F_HOST_CFG, M98095_SEG, M98095_SEG);
1780         m98095_eq_band(codec, channel, 0, coef_set->band1);
1781         m98095_eq_band(codec, channel, 1, coef_set->band2);
1782         m98095_eq_band(codec, channel, 2, coef_set->band3);
1783         m98095_eq_band(codec, channel, 3, coef_set->band4);
1784         m98095_eq_band(codec, channel, 4, coef_set->band5);
1785         snd_soc_update_bits(codec, M98095_00F_HOST_CFG, M98095_SEG, 0);
1786         mutex_unlock(&codec->mutex);
1787
1788         /* Restore the original on/off state */
1789         snd_soc_update_bits(codec, M98095_088_CFG_LEVEL, regmask, regsave);
1790         return 0;
1791 }
1792
1793 static int max98095_get_eq_enum(struct snd_kcontrol *kcontrol,
1794                                  struct snd_ctl_elem_value *ucontrol)
1795 {
1796         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1797         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
1798         int channel = max98095_get_eq_channel(kcontrol->id.name);
1799         struct max98095_cdata *cdata;
1800
1801         cdata = &max98095->dai[channel];
1802         ucontrol->value.enumerated.item[0] = cdata->eq_sel;
1803
1804         return 0;
1805 }
1806
1807 static void max98095_handle_eq_pdata(struct snd_soc_codec *codec)
1808 {
1809         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
1810         struct max98095_pdata *pdata = max98095->pdata;
1811         struct max98095_eq_cfg *cfg;
1812         unsigned int cfgcnt;
1813         int i, j;
1814         const char **t;
1815         int ret;
1816
1817         struct snd_kcontrol_new controls[] = {
1818                 SOC_ENUM_EXT("EQ1 Mode",
1819                         max98095->eq_enum,
1820                         max98095_get_eq_enum,
1821                         max98095_put_eq_enum),
1822                 SOC_ENUM_EXT("EQ2 Mode",
1823                         max98095->eq_enum,
1824                         max98095_get_eq_enum,
1825                         max98095_put_eq_enum),
1826         };
1827
1828         cfg = pdata->eq_cfg;
1829         cfgcnt = pdata->eq_cfgcnt;
1830
1831         /* Setup an array of texts for the equalizer enum.
1832          * This is based on Mark Brown's equalizer driver code.
1833          */
1834         max98095->eq_textcnt = 0;
1835         max98095->eq_texts = NULL;
1836         for (i = 0; i < cfgcnt; i++) {
1837                 for (j = 0; j < max98095->eq_textcnt; j++) {
1838                         if (strcmp(cfg[i].name, max98095->eq_texts[j]) == 0)
1839                                 break;
1840                 }
1841
1842                 if (j != max98095->eq_textcnt)
1843                         continue;
1844
1845                 /* Expand the array */
1846                 t = krealloc(max98095->eq_texts,
1847                              sizeof(char *) * (max98095->eq_textcnt + 1),
1848                              GFP_KERNEL);
1849                 if (t == NULL)
1850                         continue;
1851
1852                 /* Store the new entry */
1853                 t[max98095->eq_textcnt] = cfg[i].name;
1854                 max98095->eq_textcnt++;
1855                 max98095->eq_texts = t;
1856         }
1857
1858         /* Now point the soc_enum to .texts array items */
1859         max98095->eq_enum.texts = max98095->eq_texts;
1860         max98095->eq_enum.max = max98095->eq_textcnt;
1861
1862         ret = snd_soc_add_codec_controls(codec, controls, ARRAY_SIZE(controls));
1863         if (ret != 0)
1864                 dev_err(codec->dev, "Failed to add EQ control: %d\n", ret);
1865 }
1866
1867 static const char *bq_mode_name[] = {"Biquad1 Mode", "Biquad2 Mode"};
1868
1869 static int max98095_get_bq_channel(struct snd_soc_codec *codec,
1870                                    const char *name)
1871 {
1872         int i;
1873
1874         for (i = 0; i < ARRAY_SIZE(bq_mode_name); i++)
1875                 if (strcmp(name, bq_mode_name[i]) == 0)
1876                         return i;
1877
1878         /* Shouldn't happen */
1879         dev_err(codec->dev, "Bad biquad channel name '%s'\n", name);
1880         return -EINVAL;
1881 }
1882
1883 static int max98095_put_bq_enum(struct snd_kcontrol *kcontrol,
1884                                  struct snd_ctl_elem_value *ucontrol)
1885 {
1886         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1887         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
1888         struct max98095_pdata *pdata = max98095->pdata;
1889         int channel = max98095_get_bq_channel(codec, kcontrol->id.name);
1890         struct max98095_cdata *cdata;
1891         unsigned int sel = ucontrol->value.integer.value[0];
1892         struct max98095_biquad_cfg *coef_set;
1893         int fs, best, best_val, i;
1894         int regmask, regsave;
1895
1896         if (channel < 0)
1897                 return channel;
1898
1899         if (!pdata || !max98095->bq_textcnt)
1900                 return 0;
1901
1902         if (sel >= pdata->bq_cfgcnt)
1903                 return -EINVAL;
1904
1905         cdata = &max98095->dai[channel];
1906         cdata->bq_sel = sel;
1907         fs = cdata->rate;
1908
1909         /* Find the selected configuration with nearest sample rate */
1910         best = 0;
1911         best_val = INT_MAX;
1912         for (i = 0; i < pdata->bq_cfgcnt; i++) {
1913                 if (strcmp(pdata->bq_cfg[i].name, max98095->bq_texts[sel]) == 0 &&
1914                         abs(pdata->bq_cfg[i].rate - fs) < best_val) {
1915                         best = i;
1916                         best_val = abs(pdata->bq_cfg[i].rate - fs);
1917                 }
1918         }
1919
1920         dev_dbg(codec->dev, "Selected %s/%dHz for %dHz sample rate\n",
1921                 pdata->bq_cfg[best].name,
1922                 pdata->bq_cfg[best].rate, fs);
1923
1924         coef_set = &pdata->bq_cfg[best];
1925
1926         regmask = (channel == 0) ? M98095_BQ1EN : M98095_BQ2EN;
1927
1928         /* Disable filter while configuring, and save current on/off state */
1929         regsave = snd_soc_read(codec, M98095_088_CFG_LEVEL);
1930         snd_soc_update_bits(codec, M98095_088_CFG_LEVEL, regmask, 0);
1931
1932         mutex_lock(&codec->mutex);
1933         snd_soc_update_bits(codec, M98095_00F_HOST_CFG, M98095_SEG, M98095_SEG);
1934         m98095_biquad_band(codec, channel, 0, coef_set->band1);
1935         m98095_biquad_band(codec, channel, 1, coef_set->band2);
1936         snd_soc_update_bits(codec, M98095_00F_HOST_CFG, M98095_SEG, 0);
1937         mutex_unlock(&codec->mutex);
1938
1939         /* Restore the original on/off state */
1940         snd_soc_update_bits(codec, M98095_088_CFG_LEVEL, regmask, regsave);
1941         return 0;
1942 }
1943
1944 static int max98095_get_bq_enum(struct snd_kcontrol *kcontrol,
1945                                  struct snd_ctl_elem_value *ucontrol)
1946 {
1947         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1948         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
1949         int channel = max98095_get_bq_channel(codec, kcontrol->id.name);
1950         struct max98095_cdata *cdata;
1951
1952         if (channel < 0)
1953                 return channel;
1954
1955         cdata = &max98095->dai[channel];
1956         ucontrol->value.enumerated.item[0] = cdata->bq_sel;
1957
1958         return 0;
1959 }
1960
1961 static void max98095_handle_bq_pdata(struct snd_soc_codec *codec)
1962 {
1963         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
1964         struct max98095_pdata *pdata = max98095->pdata;
1965         struct max98095_biquad_cfg *cfg;
1966         unsigned int cfgcnt;
1967         int i, j;
1968         const char **t;
1969         int ret;
1970
1971         struct snd_kcontrol_new controls[] = {
1972                 SOC_ENUM_EXT((char *)bq_mode_name[0],
1973                         max98095->bq_enum,
1974                         max98095_get_bq_enum,
1975                         max98095_put_bq_enum),
1976                 SOC_ENUM_EXT((char *)bq_mode_name[1],
1977                         max98095->bq_enum,
1978                         max98095_get_bq_enum,
1979                         max98095_put_bq_enum),
1980         };
1981         BUILD_BUG_ON(ARRAY_SIZE(controls) != ARRAY_SIZE(bq_mode_name));
1982
1983         cfg = pdata->bq_cfg;
1984         cfgcnt = pdata->bq_cfgcnt;
1985
1986         /* Setup an array of texts for the biquad enum.
1987          * This is based on Mark Brown's equalizer driver code.
1988          */
1989         max98095->bq_textcnt = 0;
1990         max98095->bq_texts = NULL;
1991         for (i = 0; i < cfgcnt; i++) {
1992                 for (j = 0; j < max98095->bq_textcnt; j++) {
1993                         if (strcmp(cfg[i].name, max98095->bq_texts[j]) == 0)
1994                                 break;
1995                 }
1996
1997                 if (j != max98095->bq_textcnt)
1998                         continue;
1999
2000                 /* Expand the array */
2001                 t = krealloc(max98095->bq_texts,
2002                              sizeof(char *) * (max98095->bq_textcnt + 1),
2003                              GFP_KERNEL);
2004                 if (t == NULL)
2005                         continue;
2006
2007                 /* Store the new entry */
2008                 t[max98095->bq_textcnt] = cfg[i].name;
2009                 max98095->bq_textcnt++;
2010                 max98095->bq_texts = t;
2011         }
2012
2013         /* Now point the soc_enum to .texts array items */
2014         max98095->bq_enum.texts = max98095->bq_texts;
2015         max98095->bq_enum.max = max98095->bq_textcnt;
2016
2017         ret = snd_soc_add_codec_controls(codec, controls, ARRAY_SIZE(controls));
2018         if (ret != 0)
2019                 dev_err(codec->dev, "Failed to add Biquad control: %d\n", ret);
2020 }
2021
2022 static void max98095_handle_pdata(struct snd_soc_codec *codec)
2023 {
2024         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
2025         struct max98095_pdata *pdata = max98095->pdata;
2026         u8 regval = 0;
2027
2028         if (!pdata) {
2029                 dev_dbg(codec->dev, "No platform data\n");
2030                 return;
2031         }
2032
2033         /* Configure mic for analog/digital mic mode */
2034         if (pdata->digmic_left_mode)
2035                 regval |= M98095_DIGMIC_L;
2036
2037         if (pdata->digmic_right_mode)
2038                 regval |= M98095_DIGMIC_R;
2039
2040         snd_soc_write(codec, M98095_087_CFG_MIC, regval);
2041
2042         /* Configure equalizers */
2043         if (pdata->eq_cfgcnt)
2044                 max98095_handle_eq_pdata(codec);
2045
2046         /* Configure bi-quad filters */
2047         if (pdata->bq_cfgcnt)
2048                 max98095_handle_bq_pdata(codec);
2049 }
2050
2051 static irqreturn_t max98095_report_jack(int irq, void *data)
2052 {
2053         struct snd_soc_codec *codec = data;
2054         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
2055         unsigned int value;
2056         int hp_report = 0;
2057         int mic_report = 0;
2058
2059         /* Read the Jack Status Register */
2060         value = snd_soc_read(codec, M98095_007_JACK_AUTO_STS);
2061
2062         /* If ddone is not set, then detection isn't finished yet */
2063         if ((value & M98095_DDONE) == 0)
2064                 return IRQ_NONE;
2065
2066         /* if hp, check its bit, and if set, clear it */
2067         if ((value & M98095_HP_IN || value & M98095_LO_IN) &&
2068                 max98095->headphone_jack)
2069                 hp_report |= SND_JACK_HEADPHONE;
2070
2071         /* if mic, check its bit, and if set, clear it */
2072         if ((value & M98095_MIC_IN) && max98095->mic_jack)
2073                 mic_report |= SND_JACK_MICROPHONE;
2074
2075         if (max98095->headphone_jack == max98095->mic_jack) {
2076                 snd_soc_jack_report(max98095->headphone_jack,
2077                                         hp_report | mic_report,
2078                                         SND_JACK_HEADSET);
2079         } else {
2080                 if (max98095->headphone_jack)
2081                         snd_soc_jack_report(max98095->headphone_jack,
2082                                         hp_report, SND_JACK_HEADPHONE);
2083                 if (max98095->mic_jack)
2084                         snd_soc_jack_report(max98095->mic_jack,
2085                                         mic_report, SND_JACK_MICROPHONE);
2086         }
2087
2088         return IRQ_HANDLED;
2089 }
2090
2091 static int max98095_jack_detect_enable(struct snd_soc_codec *codec)
2092 {
2093         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
2094         int ret = 0;
2095         int detect_enable = M98095_JDEN;
2096         unsigned int slew = M98095_DEFAULT_SLEW_DELAY;
2097
2098         if (max98095->pdata->jack_detect_pin5en)
2099                 detect_enable |= M98095_PIN5EN;
2100
2101         if (max98095->pdata->jack_detect_delay)
2102                 slew = max98095->pdata->jack_detect_delay;
2103
2104         ret = snd_soc_write(codec, M98095_08E_JACK_DC_SLEW, slew);
2105         if (ret < 0) {
2106                 dev_err(codec->dev, "Failed to cfg auto detect %d\n", ret);
2107                 return ret;
2108         }
2109
2110         /* configure auto detection to be enabled */
2111         ret = snd_soc_write(codec, M98095_089_JACK_DET_AUTO, detect_enable);
2112         if (ret < 0) {
2113                 dev_err(codec->dev, "Failed to cfg auto detect %d\n", ret);
2114                 return ret;
2115         }
2116
2117         return ret;
2118 }
2119
2120 static int max98095_jack_detect_disable(struct snd_soc_codec *codec)
2121 {
2122         int ret = 0;
2123
2124         /* configure auto detection to be disabled */
2125         ret = snd_soc_write(codec, M98095_089_JACK_DET_AUTO, 0x0);
2126         if (ret < 0) {
2127                 dev_err(codec->dev, "Failed to cfg auto detect %d\n", ret);
2128                 return ret;
2129         }
2130
2131         return ret;
2132 }
2133
2134 int max98095_jack_detect(struct snd_soc_codec *codec,
2135         struct snd_soc_jack *hp_jack, struct snd_soc_jack *mic_jack)
2136 {
2137         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
2138         struct i2c_client *client = to_i2c_client(codec->dev);
2139         int ret = 0;
2140
2141         max98095->headphone_jack = hp_jack;
2142         max98095->mic_jack = mic_jack;
2143
2144         /* only progress if we have at least 1 jack pointer */
2145         if (!hp_jack && !mic_jack)
2146                 return -EINVAL;
2147
2148         max98095_jack_detect_enable(codec);
2149
2150         /* enable interrupts for headphone jack detection */
2151         ret = snd_soc_update_bits(codec, M98095_013_JACK_INT_EN,
2152                 M98095_IDDONE, M98095_IDDONE);
2153         if (ret < 0) {
2154                 dev_err(codec->dev, "Failed to cfg jack irqs %d\n", ret);
2155                 return ret;
2156         }
2157
2158         max98095_report_jack(client->irq, codec);
2159         return 0;
2160 }
2161 EXPORT_SYMBOL_GPL(max98095_jack_detect);
2162
2163 #ifdef CONFIG_PM
2164 static int max98095_suspend(struct snd_soc_codec *codec)
2165 {
2166         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
2167
2168         if (max98095->headphone_jack || max98095->mic_jack)
2169                 max98095_jack_detect_disable(codec);
2170
2171         max98095_set_bias_level(codec, SND_SOC_BIAS_OFF);
2172
2173         return 0;
2174 }
2175
2176 static int max98095_resume(struct snd_soc_codec *codec)
2177 {
2178         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
2179         struct i2c_client *client = to_i2c_client(codec->dev);
2180
2181         max98095_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
2182
2183         if (max98095->headphone_jack || max98095->mic_jack) {
2184                 max98095_jack_detect_enable(codec);
2185                 max98095_report_jack(client->irq, codec);
2186         }
2187
2188         return 0;
2189 }
2190 #else
2191 #define max98095_suspend NULL
2192 #define max98095_resume NULL
2193 #endif
2194
2195 static int max98095_reset(struct snd_soc_codec *codec)
2196 {
2197         int i, ret;
2198
2199         /* Gracefully reset the DSP core and the codec hardware
2200          * in a proper sequence */
2201         ret = snd_soc_write(codec, M98095_00F_HOST_CFG, 0);
2202         if (ret < 0) {
2203                 dev_err(codec->dev, "Failed to reset DSP: %d\n", ret);
2204                 return ret;
2205         }
2206
2207         ret = snd_soc_write(codec, M98095_097_PWR_SYS, 0);
2208         if (ret < 0) {
2209                 dev_err(codec->dev, "Failed to reset codec: %d\n", ret);
2210                 return ret;
2211         }
2212
2213         /* Reset to hardware default for registers, as there is not
2214          * a soft reset hardware control register */
2215         for (i = M98095_010_HOST_INT_CFG; i < M98095_REG_MAX_CACHED; i++) {
2216                 ret = snd_soc_write(codec, i, snd_soc_read(codec, i));
2217                 if (ret < 0) {
2218                         dev_err(codec->dev, "Failed to reset: %d\n", ret);
2219                         return ret;
2220                 }
2221         }
2222
2223         return ret;
2224 }
2225
2226 static int max98095_probe(struct snd_soc_codec *codec)
2227 {
2228         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
2229         struct max98095_cdata *cdata;
2230         struct i2c_client *client;
2231         int ret = 0;
2232
2233         ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_REGMAP);
2234         if (ret != 0) {
2235                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
2236                 return ret;
2237         }
2238
2239         /* reset the codec, the DSP core, and disable all interrupts */
2240         max98095_reset(codec);
2241
2242         client = to_i2c_client(codec->dev);
2243
2244         /* initialize private data */
2245
2246         max98095->sysclk = (unsigned)-1;
2247         max98095->eq_textcnt = 0;
2248         max98095->bq_textcnt = 0;
2249
2250         cdata = &max98095->dai[0];
2251         cdata->rate = (unsigned)-1;
2252         cdata->fmt  = (unsigned)-1;
2253         cdata->eq_sel = 0;
2254         cdata->bq_sel = 0;
2255
2256         cdata = &max98095->dai[1];
2257         cdata->rate = (unsigned)-1;
2258         cdata->fmt  = (unsigned)-1;
2259         cdata->eq_sel = 0;
2260         cdata->bq_sel = 0;
2261
2262         cdata = &max98095->dai[2];
2263         cdata->rate = (unsigned)-1;
2264         cdata->fmt  = (unsigned)-1;
2265         cdata->eq_sel = 0;
2266         cdata->bq_sel = 0;
2267
2268         max98095->lin_state = 0;
2269         max98095->mic1pre = 0;
2270         max98095->mic2pre = 0;
2271
2272         if (client->irq) {
2273                 /* register an audio interrupt */
2274                 ret = request_threaded_irq(client->irq, NULL,
2275                         max98095_report_jack,
2276                         IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
2277                         "max98095", codec);
2278                 if (ret) {
2279                         dev_err(codec->dev, "Failed to request IRQ: %d\n", ret);
2280                         goto err_access;
2281                 }
2282         }
2283
2284         ret = snd_soc_read(codec, M98095_0FF_REV_ID);
2285         if (ret < 0) {
2286                 dev_err(codec->dev, "Failure reading hardware revision: %d\n",
2287                         ret);
2288                 goto err_irq;
2289         }
2290         dev_info(codec->dev, "Hardware revision: %c\n", ret - 0x40 + 'A');
2291
2292         snd_soc_write(codec, M98095_097_PWR_SYS, M98095_PWRSV);
2293
2294         /* initialize registers cache to hardware default */
2295         max98095_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
2296
2297         snd_soc_write(codec, M98095_048_MIX_DAC_LR,
2298                 M98095_DAI1L_TO_DACL|M98095_DAI1R_TO_DACR);
2299
2300         snd_soc_write(codec, M98095_049_MIX_DAC_M,
2301                 M98095_DAI2M_TO_DACM|M98095_DAI3M_TO_DACM);
2302
2303         snd_soc_write(codec, M98095_092_PWR_EN_OUT, M98095_SPK_SPREADSPECTRUM);
2304         snd_soc_write(codec, M98095_045_CFG_DSP, M98095_DSPNORMAL);
2305         snd_soc_write(codec, M98095_04E_CFG_HP, M98095_HPNORMAL);
2306
2307         snd_soc_write(codec, M98095_02C_DAI1_IOCFG,
2308                 M98095_S1NORMAL|M98095_SDATA);
2309
2310         snd_soc_write(codec, M98095_036_DAI2_IOCFG,
2311                 M98095_S2NORMAL|M98095_SDATA);
2312
2313         snd_soc_write(codec, M98095_040_DAI3_IOCFG,
2314                 M98095_S3NORMAL|M98095_SDATA);
2315
2316         max98095_handle_pdata(codec);
2317
2318         /* take the codec out of the shut down */
2319         snd_soc_update_bits(codec, M98095_097_PWR_SYS, M98095_SHDNRUN,
2320                 M98095_SHDNRUN);
2321
2322         return 0;
2323
2324 err_irq:
2325         if (client->irq)
2326                 free_irq(client->irq, codec);
2327 err_access:
2328         return ret;
2329 }
2330
2331 static int max98095_remove(struct snd_soc_codec *codec)
2332 {
2333         struct max98095_priv *max98095 = snd_soc_codec_get_drvdata(codec);
2334         struct i2c_client *client = to_i2c_client(codec->dev);
2335
2336         max98095_set_bias_level(codec, SND_SOC_BIAS_OFF);
2337
2338         if (max98095->headphone_jack || max98095->mic_jack)
2339                 max98095_jack_detect_disable(codec);
2340
2341         if (client->irq)
2342                 free_irq(client->irq, codec);
2343
2344         return 0;
2345 }
2346
2347 static struct snd_soc_codec_driver soc_codec_dev_max98095 = {
2348         .probe   = max98095_probe,
2349         .remove  = max98095_remove,
2350         .suspend = max98095_suspend,
2351         .resume  = max98095_resume,
2352         .set_bias_level = max98095_set_bias_level,
2353         .controls = max98095_snd_controls,
2354         .num_controls = ARRAY_SIZE(max98095_snd_controls),
2355         .dapm_widgets     = max98095_dapm_widgets,
2356         .num_dapm_widgets = ARRAY_SIZE(max98095_dapm_widgets),
2357         .dapm_routes     = max98095_audio_map,
2358         .num_dapm_routes = ARRAY_SIZE(max98095_audio_map),
2359 };
2360
2361 static int max98095_i2c_probe(struct i2c_client *i2c,
2362                              const struct i2c_device_id *id)
2363 {
2364         struct max98095_priv *max98095;
2365         int ret;
2366
2367         max98095 = devm_kzalloc(&i2c->dev, sizeof(struct max98095_priv),
2368                                 GFP_KERNEL);
2369         if (max98095 == NULL)
2370                 return -ENOMEM;
2371
2372         max98095->regmap = devm_regmap_init_i2c(i2c, &max98095_regmap);
2373         if (IS_ERR(max98095->regmap)) {
2374                 ret = PTR_ERR(max98095->regmap);
2375                 dev_err(&i2c->dev, "Failed to allocate regmap: %d\n", ret);
2376                 return ret;
2377         }
2378
2379         max98095->devtype = id->driver_data;
2380         i2c_set_clientdata(i2c, max98095);
2381         max98095->pdata = i2c->dev.platform_data;
2382
2383         ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_max98095,
2384                                      max98095_dai, ARRAY_SIZE(max98095_dai));
2385         return ret;
2386 }
2387
2388 static int max98095_i2c_remove(struct i2c_client *client)
2389 {
2390         snd_soc_unregister_codec(&client->dev);
2391         return 0;
2392 }
2393
2394 static const struct i2c_device_id max98095_i2c_id[] = {
2395         { "max98095", MAX98095 },
2396         { }
2397 };
2398 MODULE_DEVICE_TABLE(i2c, max98095_i2c_id);
2399
2400 static struct i2c_driver max98095_i2c_driver = {
2401         .driver = {
2402                 .name = "max98095",
2403                 .owner = THIS_MODULE,
2404         },
2405         .probe  = max98095_i2c_probe,
2406         .remove = max98095_i2c_remove,
2407         .id_table = max98095_i2c_id,
2408 };
2409
2410 module_i2c_driver(max98095_i2c_driver);
2411
2412 MODULE_DESCRIPTION("ALSA SoC MAX98095 driver");
2413 MODULE_AUTHOR("Peter Hsiang");
2414 MODULE_LICENSE("GPL");