sound/soc/codecs/wm2000.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * wm2000.c  --  WM2000 ALSA Soc Audio driver
   4  *
   5  * Copyright 2008-2011 Wolfson Microelectronics PLC.
   6  *
   7  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
   8  *
   9 /*(DEBLOBBED)*/
  10
  11 #include <linux/module.h>
  12 #include <linux/moduleparam.h>
  13 #include <linux/kernel.h>
  14 #include <linux/init.h>
  15 #include <linux/firmware.h>
  16 #include <linux/clk.h>
  17 #include <linux/delay.h>
  18 #include <linux/pm.h>
  19 #include <linux/i2c.h>
  20 #include <linux/regmap.h>
  21 #include <linux/debugfs.h>
  22 #include <linux/regulator/consumer.h>
  23 #include <linux/slab.h>
  24 #include <sound/core.h>
  25 #include <sound/pcm.h>
  26 #include <sound/pcm_params.h>
  27 #include <sound/soc.h>
  28 #include <sound/initval.h>
  29 #include <sound/tlv.h>
  30
  31 #include <sound/wm2000.h>
  32
  33 #include "wm2000.h"
  34
  35 #define WM2000_NUM_SUPPLIES 3
  36
  37 static const char *wm2000_supplies[WM2000_NUM_SUPPLIES] = {
  38         "SPKVDD",
  39         "DBVDD",
  40         "DCVDD",
  41 };
  42
  43 enum wm2000_anc_mode {
  44         ANC_ACTIVE = 0,
  45         ANC_BYPASS = 1,
  46         ANC_STANDBY = 2,
  47         ANC_OFF = 3,
  48 };
  49
  50 struct wm2000_priv {
  51         struct i2c_client *i2c;
  52         struct regmap *regmap;
  53         struct clk *mclk;
  54
  55         struct regulator_bulk_data supplies[WM2000_NUM_SUPPLIES];
  56
  57         enum wm2000_anc_mode anc_mode;
  58
  59         unsigned int anc_active:1;
  60         unsigned int anc_eng_ena:1;
  61         unsigned int spk_ena:1;
  62
  63         unsigned int speech_clarity:1;
  64
  65         int anc_download_size;
  66         char *anc_download;
  67
  68         struct mutex lock;
  69 };
  70
  71 static int wm2000_write(struct i2c_client *i2c, unsigned int reg,
  72                         unsigned int value)
  73 {
  74         struct wm2000_priv *wm2000 = i2c_get_clientdata(i2c);
  75         return regmap_write(wm2000->regmap, reg, value);
  76 }
  77
  78 static void wm2000_reset(struct wm2000_priv *wm2000)
  79 {
  80         struct i2c_client *i2c = wm2000->i2c;
  81
  82         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_ENG_CLR);
  83         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_CLR);
  84         wm2000_write(i2c, WM2000_REG_ID1, 0);
  85
  86         wm2000->anc_mode = ANC_OFF;
  87 }
  88
  89 static int wm2000_poll_bit(struct i2c_client *i2c,
  90                            unsigned int reg, u8 mask)
  91 {
  92         struct wm2000_priv *wm2000 = i2c_get_clientdata(i2c);
  93         int timeout = 4000;
  94         unsigned int val;
  95
  96         regmap_read(wm2000->regmap, reg, &val);
  97
  98         while (!(val & mask) && --timeout) {
  99                 msleep(1);
 100                 regmap_read(wm2000->regmap, reg, &val);
 101         }
 102
 103         if (timeout == 0)
 104                 return 0;
 105         else
 106                 return 1;
 107 }
 108
 109 static int wm2000_power_up(struct i2c_client *i2c, int analogue)
 110 {
 111         struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
 112         unsigned long rate;
 113         unsigned int val;
 114         int ret;
 115
 116         if (WARN_ON(wm2000->anc_mode != ANC_OFF))
 117                 return -EINVAL;
 118
 119         dev_dbg(&i2c->dev, "Beginning power up\n");
 120
 121         ret = regulator_bulk_enable(WM2000_NUM_SUPPLIES, wm2000->supplies);
 122         if (ret != 0) {
 123                 dev_err(&i2c->dev, "Failed to enable supplies: %d\n", ret);
 124                 return ret;
 125         }
 126
 127         rate = clk_get_rate(wm2000->mclk);
 128         if (rate <= 13500000) {
 129                 dev_dbg(&i2c->dev, "Disabling MCLK divider\n");
 130                 wm2000_write(i2c, WM2000_REG_SYS_CTL2,
 131                              WM2000_MCLK_DIV2_ENA_CLR);
 132         } else {
 133                 dev_dbg(&i2c->dev, "Enabling MCLK divider\n");
 134                 wm2000_write(i2c, WM2000_REG_SYS_CTL2,
 135                              WM2000_MCLK_DIV2_ENA_SET);
 136         }
 137
 138         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_ENG_CLR);
 139         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_ENG_SET);
 140
 141         /* Wait for ANC engine to become ready */
 142         if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
 143                              WM2000_ANC_ENG_IDLE)) {
 144                 dev_err(&i2c->dev, "ANC engine failed to reset\n");
 145                 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
 146                 return -ETIMEDOUT;
 147         }
 148
 149         if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
 150                              WM2000_STATUS_BOOT_COMPLETE)) {
 151                 dev_err(&i2c->dev, "ANC engine failed to initialise\n");
 152                 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
 153                 return -ETIMEDOUT;
 154         }
 155
 156         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_SET);
 157
 158         /* Open code download of the data since it is the only bulk
 159          * write we do. */
 160         dev_dbg(&i2c->dev, "Downloading %d bytes\n",
 161                 wm2000->anc_download_size - 2);
 162
 163         ret = i2c_master_send(i2c, wm2000->anc_download,
 164                               wm2000->anc_download_size);
 165         if (ret < 0) {
 166                 dev_err(&i2c->dev, "i2c_transfer() failed: %d\n", ret);
 167                 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
 168                 return ret;
 169         }
 170         if (ret != wm2000->anc_download_size) {
 171                 dev_err(&i2c->dev, "i2c_transfer() failed, %d != %d\n",
 172                         ret, wm2000->anc_download_size);
 173                 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
 174                 return -EIO;
 175         }
 176
 177         dev_dbg(&i2c->dev, "Download complete\n");
 178
 179         if (analogue) {
 180                 wm2000_write(i2c, WM2000_REG_ANA_VMID_PU_TIME, 248 / 4);
 181
 182                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
 183                              WM2000_MODE_ANA_SEQ_INCLUDE |
 184                              WM2000_MODE_MOUSE_ENABLE |
 185                              WM2000_MODE_THERMAL_ENABLE);
 186         } else {
 187                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
 188                              WM2000_MODE_MOUSE_ENABLE |
 189                              WM2000_MODE_THERMAL_ENABLE);
 190         }
 191
 192         ret = regmap_read(wm2000->regmap, WM2000_REG_SPEECH_CLARITY, &val);
 193         if (ret != 0) {
 194                 dev_err(&i2c->dev, "Unable to read Speech Clarity: %d\n", ret);
 195                 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
 196                 return ret;
 197         }
 198         if (wm2000->speech_clarity)
 199                 val |= WM2000_SPEECH_CLARITY;
 200         else
 201                 val &= ~WM2000_SPEECH_CLARITY;
 202         wm2000_write(i2c, WM2000_REG_SPEECH_CLARITY, val);
 203
 204         wm2000_write(i2c, WM2000_REG_SYS_START0, 0x33);
 205         wm2000_write(i2c, WM2000_REG_SYS_START1, 0x02);
 206
 207         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);
 208
 209         if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
 210                              WM2000_STATUS_MOUSE_ACTIVE)) {
 211                 dev_err(&i2c->dev, "Timed out waiting for device\n");
 212                 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
 213                 return -ETIMEDOUT;
 214         }
 215
 216         dev_dbg(&i2c->dev, "ANC active\n");
 217         if (analogue)
 218                 dev_dbg(&i2c->dev, "Analogue active\n");
 219         wm2000->anc_mode = ANC_ACTIVE;
 220
 221         return 0;
 222 }
 223
 224 static int wm2000_power_down(struct i2c_client *i2c, int analogue)
 225 {
 226         struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
 227
 228         if (analogue) {
 229                 wm2000_write(i2c, WM2000_REG_ANA_VMID_PD_TIME, 248 / 4);
 230                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
 231                              WM2000_MODE_ANA_SEQ_INCLUDE |
 232                              WM2000_MODE_POWER_DOWN);
 233         } else {
 234                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
 235                              WM2000_MODE_POWER_DOWN);
 236         }
 237
 238         if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
 239                              WM2000_STATUS_POWER_DOWN_COMPLETE)) {
 240                 dev_err(&i2c->dev, "Timeout waiting for ANC power down\n");
 241                 return -ETIMEDOUT;
 242         }
 243
 244         if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
 245                              WM2000_ANC_ENG_IDLE)) {
 246                 dev_err(&i2c->dev, "Timeout waiting for ANC engine idle\n");
 247                 return -ETIMEDOUT;
 248         }
 249
 250         regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
 251
 252         dev_dbg(&i2c->dev, "powered off\n");
 253         wm2000->anc_mode = ANC_OFF;
 254
 255         return 0;
 256 }
 257
 258 static int wm2000_enter_bypass(struct i2c_client *i2c, int analogue)
 259 {
 260         struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
 261
 262         if (WARN_ON(wm2000->anc_mode != ANC_ACTIVE))
 263                 return -EINVAL;
 264
 265         if (analogue) {
 266                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
 267                              WM2000_MODE_ANA_SEQ_INCLUDE |
 268                              WM2000_MODE_THERMAL_ENABLE |
 269                              WM2000_MODE_BYPASS_ENTRY);
 270         } else {
 271                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
 272                              WM2000_MODE_THERMAL_ENABLE |
 273                              WM2000_MODE_BYPASS_ENTRY);
 274         }
 275
 276         if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
 277                              WM2000_STATUS_ANC_DISABLED)) {
 278                 dev_err(&i2c->dev, "Timeout waiting for ANC disable\n");
 279                 return -ETIMEDOUT;
 280         }
 281
 282         if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
 283                              WM2000_ANC_ENG_IDLE)) {
 284                 dev_err(&i2c->dev, "Timeout waiting for ANC engine idle\n");
 285                 return -ETIMEDOUT;
 286         }
 287
 288         wm2000_write(i2c, WM2000_REG_SYS_CTL1, WM2000_SYS_STBY);
 289         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_CLR);
 290
 291         wm2000->anc_mode = ANC_BYPASS;
 292         dev_dbg(&i2c->dev, "bypass enabled\n");
 293
 294         return 0;
 295 }
 296
 297 static int wm2000_exit_bypass(struct i2c_client *i2c, int analogue)
 298 {
 299         struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
 300
 301         if (WARN_ON(wm2000->anc_mode != ANC_BYPASS))
 302                 return -EINVAL;
 303
 304         wm2000_write(i2c, WM2000_REG_SYS_CTL1, 0);
 305
 306         if (analogue) {
 307                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
 308                              WM2000_MODE_ANA_SEQ_INCLUDE |
 309                              WM2000_MODE_MOUSE_ENABLE |
 310                              WM2000_MODE_THERMAL_ENABLE);
 311         } else {
 312                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
 313                              WM2000_MODE_MOUSE_ENABLE |
 314                              WM2000_MODE_THERMAL_ENABLE);
 315         }
 316
 317         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_SET);
 318         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);
 319
 320         if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
 321                              WM2000_STATUS_MOUSE_ACTIVE)) {
 322                 dev_err(&i2c->dev, "Timed out waiting for MOUSE\n");
 323                 return -ETIMEDOUT;
 324         }
 325
 326         wm2000->anc_mode = ANC_ACTIVE;
 327         dev_dbg(&i2c->dev, "MOUSE active\n");
 328
 329         return 0;
 330 }
 331
 332 static int wm2000_enter_standby(struct i2c_client *i2c, int analogue)
 333 {
 334         struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
 335
 336         if (WARN_ON(wm2000->anc_mode != ANC_ACTIVE))
 337                 return -EINVAL;
 338
 339         if (analogue) {
 340                 wm2000_write(i2c, WM2000_REG_ANA_VMID_PD_TIME, 248 / 4);
 341
 342                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
 343                              WM2000_MODE_ANA_SEQ_INCLUDE |
 344                              WM2000_MODE_THERMAL_ENABLE |
 345                              WM2000_MODE_STANDBY_ENTRY);
 346         } else {
 347                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
 348                              WM2000_MODE_THERMAL_ENABLE |
 349                              WM2000_MODE_STANDBY_ENTRY);
 350         }
 351
 352         if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
 353                              WM2000_STATUS_ANC_DISABLED)) {
 354                 dev_err(&i2c->dev,
 355                         "Timed out waiting for ANC disable after 1ms\n");
 356                 return -ETIMEDOUT;
 357         }
 358
 359         if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT, WM2000_ANC_ENG_IDLE)) {
 360                 dev_err(&i2c->dev,
 361                         "Timed out waiting for standby\n");
 362                 return -ETIMEDOUT;
 363         }
 364
 365         wm2000_write(i2c, WM2000_REG_SYS_CTL1, WM2000_SYS_STBY);
 366         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_CLR);
 367
 368         wm2000->anc_mode = ANC_STANDBY;
 369         dev_dbg(&i2c->dev, "standby\n");
 370         if (analogue)
 371                 dev_dbg(&i2c->dev, "Analogue disabled\n");
 372
 373         return 0;
 374 }
 375
 376 static int wm2000_exit_standby(struct i2c_client *i2c, int analogue)
 377 {
 378         struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
 379
 380         if (WARN_ON(wm2000->anc_mode != ANC_STANDBY))
 381                 return -EINVAL;
 382
 383         wm2000_write(i2c, WM2000_REG_SYS_CTL1, 0);
 384
 385         if (analogue) {
 386                 wm2000_write(i2c, WM2000_REG_ANA_VMID_PU_TIME, 248 / 4);
 387
 388                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
 389                              WM2000_MODE_ANA_SEQ_INCLUDE |
 390                              WM2000_MODE_THERMAL_ENABLE |
 391                              WM2000_MODE_MOUSE_ENABLE);
 392         } else {
 393                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
 394                              WM2000_MODE_THERMAL_ENABLE |
 395                              WM2000_MODE_MOUSE_ENABLE);
 396         }
 397
 398         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_SET);
 399         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);
 400
 401         if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
 402                              WM2000_STATUS_MOUSE_ACTIVE)) {
 403                 dev_err(&i2c->dev, "Timed out waiting for MOUSE\n");
 404                 return -ETIMEDOUT;
 405         }
 406
 407         wm2000->anc_mode = ANC_ACTIVE;
 408         dev_dbg(&i2c->dev, "MOUSE active\n");
 409         if (analogue)
 410                 dev_dbg(&i2c->dev, "Analogue enabled\n");
 411
 412         return 0;
 413 }
 414
 415 typedef int (*wm2000_mode_fn)(struct i2c_client *i2c, int analogue);
 416
 417 static struct {
 418         enum wm2000_anc_mode source;
 419         enum wm2000_anc_mode dest;
 420         int analogue;
 421         wm2000_mode_fn step[2];
 422 } anc_transitions[] = {
 423         {
 424                 .source = ANC_OFF,
 425                 .dest = ANC_ACTIVE,
 426                 .analogue = 1,
 427                 .step = {
 428                         wm2000_power_up,
 429                 },
 430         },
 431         {
 432                 .source = ANC_OFF,
 433                 .dest = ANC_STANDBY,
 434                 .step = {
 435                         wm2000_power_up,
 436                         wm2000_enter_standby,
 437                 },
 438         },
 439         {
 440                 .source = ANC_OFF,
 441                 .dest = ANC_BYPASS,
 442                 .analogue = 1,
 443                 .step = {
 444                         wm2000_power_up,
 445                         wm2000_enter_bypass,
 446                 },
 447         },
 448         {
 449                 .source = ANC_ACTIVE,
 450                 .dest = ANC_BYPASS,
 451                 .analogue = 1,
 452                 .step = {
 453                         wm2000_enter_bypass,
 454                 },
 455         },
 456         {
 457                 .source = ANC_ACTIVE,
 458                 .dest = ANC_STANDBY,
 459                 .analogue = 1,
 460                 .step = {
 461                         wm2000_enter_standby,
 462                 },
 463         },
 464         {
 465                 .source = ANC_ACTIVE,
 466                 .dest = ANC_OFF,
 467                 .analogue = 1,
 468                 .step = {
 469                         wm2000_power_down,
 470                 },
 471         },
 472         {
 473                 .source = ANC_BYPASS,
 474                 .dest = ANC_ACTIVE,
 475                 .analogue = 1,
 476                 .step = {
 477                         wm2000_exit_bypass,
 478                 },
 479         },
 480         {
 481                 .source = ANC_BYPASS,
 482                 .dest = ANC_STANDBY,
 483                 .analogue = 1,
 484                 .step = {
 485                         wm2000_exit_bypass,
 486                         wm2000_enter_standby,
 487                 },
 488         },
 489         {
 490                 .source = ANC_BYPASS,
 491                 .dest = ANC_OFF,
 492                 .step = {
 493                         wm2000_exit_bypass,
 494                         wm2000_power_down,
 495                 },
 496         },
 497         {
 498                 .source = ANC_STANDBY,
 499                 .dest = ANC_ACTIVE,
 500                 .analogue = 1,
 501                 .step = {
 502                         wm2000_exit_standby,
 503                 },
 504         },
 505         {
 506                 .source = ANC_STANDBY,
 507                 .dest = ANC_BYPASS,
 508                 .analogue = 1,
 509                 .step = {
 510                         wm2000_exit_standby,
 511                         wm2000_enter_bypass,
 512                 },
 513         },
 514         {
 515                 .source = ANC_STANDBY,
 516                 .dest = ANC_OFF,
 517                 .step = {
 518                         wm2000_exit_standby,
 519                         wm2000_power_down,
 520                 },
 521         },
 522 };
 523
 524 static int wm2000_anc_transition(struct wm2000_priv *wm2000,
 525                                  enum wm2000_anc_mode mode)
 526 {
 527         struct i2c_client *i2c = wm2000->i2c;
 528         int i, j;
 529         int ret = 0;
 530
 531         if (wm2000->anc_mode == mode)
 532                 return 0;
 533
 534         for (i = 0; i < ARRAY_SIZE(anc_transitions); i++)
 535                 if (anc_transitions[i].source == wm2000->anc_mode &&
 536                     anc_transitions[i].dest == mode)
 537                         break;
 538         if (i == ARRAY_SIZE(anc_transitions)) {
 539                 dev_err(&i2c->dev, "No transition for %d->%d\n",
 540                         wm2000->anc_mode, mode);
 541                 return -EINVAL;
 542         }
 543
 544         /* Maintain clock while active */
 545         if (anc_transitions[i].source == ANC_OFF) {
 546                 ret = clk_prepare_enable(wm2000->mclk);
 547                 if (ret != 0) {
 548                         dev_err(&i2c->dev, "Failed to enable MCLK: %d\n", ret);
 549                         return ret;
 550                 }
 551         }
 552
 553         for (j = 0; j < ARRAY_SIZE(anc_transitions[j].step); j++) {
 554                 if (!anc_transitions[i].step[j])
 555                         break;
 556                 ret = anc_transitions[i].step[j](i2c,
 557                                                  anc_transitions[i].analogue);
 558                 if (ret != 0)
 559                         break;
 560         }
 561
 562         if (anc_transitions[i].dest == ANC_OFF)
 563                 clk_disable_unprepare(wm2000->mclk);
 564
 565         return ret;
 566 }
 567
 568 static int wm2000_anc_set_mode(struct wm2000_priv *wm2000)
 569 {
 570         struct i2c_client *i2c = wm2000->i2c;
 571         enum wm2000_anc_mode mode;
 572
 573         if (wm2000->anc_eng_ena && wm2000->spk_ena)
 574                 if (wm2000->anc_active)
 575                         mode = ANC_ACTIVE;
 576                 else
 577                         mode = ANC_BYPASS;
 578         else
 579                 mode = ANC_STANDBY;
 580
 581         dev_dbg(&i2c->dev, "Set mode %d (enabled %d, mute %d, active %d)\n",
 582                 mode, wm2000->anc_eng_ena, !wm2000->spk_ena,
 583                 wm2000->anc_active);
 584
 585         return wm2000_anc_transition(wm2000, mode);
 586 }
 587
 588 static int wm2000_anc_mode_get(struct snd_kcontrol *kcontrol,
 589                                struct snd_ctl_elem_value *ucontrol)
 590 {
 591         struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 592         struct wm2000_priv *wm2000 = dev_get_drvdata(component->dev);
 593
 594         ucontrol->value.integer.value[0] = wm2000->anc_active;
 595
 596         return 0;
 597 }
 598
 599 static int wm2000_anc_mode_put(struct snd_kcontrol *kcontrol,
 600                                struct snd_ctl_elem_value *ucontrol)
 601 {
 602         struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 603         struct wm2000_priv *wm2000 = dev_get_drvdata(component->dev);
 604         unsigned int anc_active = ucontrol->value.integer.value[0];
 605         int ret;
 606
 607         if (anc_active > 1)
 608                 return -EINVAL;
 609
 610         mutex_lock(&wm2000->lock);
 611
 612         wm2000->anc_active = anc_active;
 613
 614         ret = wm2000_anc_set_mode(wm2000);
 615
 616         mutex_unlock(&wm2000->lock);
 617
 618         return ret;
 619 }
 620
 621 static int wm2000_speaker_get(struct snd_kcontrol *kcontrol,
 622                               struct snd_ctl_elem_value *ucontrol)
 623 {
 624         struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 625         struct wm2000_priv *wm2000 = dev_get_drvdata(component->dev);
 626
 627         ucontrol->value.integer.value[0] = wm2000->spk_ena;
 628
 629         return 0;
 630 }
 631
 632 static int wm2000_speaker_put(struct snd_kcontrol *kcontrol,
 633                               struct snd_ctl_elem_value *ucontrol)
 634 {
 635         struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 636         struct wm2000_priv *wm2000 = dev_get_drvdata(component->dev);
 637         unsigned int val = ucontrol->value.integer.value[0];
 638         int ret;
 639
 640         if (val > 1)
 641                 return -EINVAL;
 642
 643         mutex_lock(&wm2000->lock);
 644
 645         wm2000->spk_ena = val;
 646
 647         ret = wm2000_anc_set_mode(wm2000);
 648
 649         mutex_unlock(&wm2000->lock);
 650
 651         return ret;
 652 }
 653
 654 static const struct snd_kcontrol_new wm2000_controls[] = {
 655         SOC_SINGLE("ANC Volume", WM2000_REG_ANC_GAIN_CTRL, 0, 255, 0),
 656         SOC_SINGLE_BOOL_EXT("WM2000 ANC Switch", 0,
 657                             wm2000_anc_mode_get,
 658                             wm2000_anc_mode_put),
 659         SOC_SINGLE_BOOL_EXT("WM2000 Switch", 0,
 660                             wm2000_speaker_get,
 661                             wm2000_speaker_put),
 662 };
 663
 664 static int wm2000_anc_power_event(struct snd_soc_dapm_widget *w,
 665                                   struct snd_kcontrol *kcontrol, int event)
 666 {
 667         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 668         struct wm2000_priv *wm2000 = dev_get_drvdata(component->dev);
 669         int ret;
 670
 671         mutex_lock(&wm2000->lock);
 672
 673         if (SND_SOC_DAPM_EVENT_ON(event))
 674                 wm2000->anc_eng_ena = 1;
 675
 676         if (SND_SOC_DAPM_EVENT_OFF(event))
 677                 wm2000->anc_eng_ena = 0;
 678
 679         ret = wm2000_anc_set_mode(wm2000);
 680
 681         mutex_unlock(&wm2000->lock);
 682
 683         return ret;
 684 }
 685
 686 static const struct snd_soc_dapm_widget wm2000_dapm_widgets[] = {
 687 /* Externally visible pins */
 688 SND_SOC_DAPM_OUTPUT("SPKN"),
 689 SND_SOC_DAPM_OUTPUT("SPKP"),
 690
 691 SND_SOC_DAPM_INPUT("LINN"),
 692 SND_SOC_DAPM_INPUT("LINP"),
 693
 694 SND_SOC_DAPM_PGA_E("ANC Engine", SND_SOC_NOPM, 0, 0, NULL, 0,
 695                    wm2000_anc_power_event,
 696                    SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
 697 };
 698
 699 /* Target, Path, Source */
 700 static const struct snd_soc_dapm_route wm2000_audio_map[] = {
 701         { "SPKN", NULL, "ANC Engine" },
 702         { "SPKP", NULL, "ANC Engine" },
 703         { "ANC Engine", NULL, "LINN" },
 704         { "ANC Engine", NULL, "LINP" },
 705 };
 706
 707 #ifdef CONFIG_PM
 708 static int wm2000_suspend(struct snd_soc_component *component)
 709 {
 710         struct wm2000_priv *wm2000 = dev_get_drvdata(component->dev);
 711
 712         return wm2000_anc_transition(wm2000, ANC_OFF);
 713 }
 714
 715 static int wm2000_resume(struct snd_soc_component *component)
 716 {
 717         struct wm2000_priv *wm2000 = dev_get_drvdata(component->dev);
 718
 719         return wm2000_anc_set_mode(wm2000);
 720 }
 721 #else
 722 #define wm2000_suspend NULL
 723 #define wm2000_resume NULL
 724 #endif
 725
 726 static bool wm2000_readable_reg(struct device *dev, unsigned int reg)
 727 {
 728         switch (reg) {
 729         case WM2000_REG_SYS_START:
 730         case WM2000_REG_ANC_GAIN_CTRL:
 731         case WM2000_REG_MSE_TH1:
 732         case WM2000_REG_MSE_TH2:
 733         case WM2000_REG_SPEECH_CLARITY:
 734         case WM2000_REG_SYS_WATCHDOG:
 735         case WM2000_REG_ANA_VMID_PD_TIME:
 736         case WM2000_REG_ANA_VMID_PU_TIME:
 737         case WM2000_REG_CAT_FLTR_INDX:
 738         case WM2000_REG_CAT_GAIN_0:
 739         case WM2000_REG_SYS_STATUS:
 740         case WM2000_REG_SYS_MODE_CNTRL:
 741         case WM2000_REG_SYS_START0:
 742         case WM2000_REG_SYS_START1:
 743         case WM2000_REG_ID1:
 744         case WM2000_REG_ID2:
 745         case WM2000_REG_REVISON:
 746         case WM2000_REG_SYS_CTL1:
 747         case WM2000_REG_SYS_CTL2:
 748         case WM2000_REG_ANC_STAT:
 749         case WM2000_REG_IF_CTL:
 750         case WM2000_REG_ANA_MIC_CTL:
 751         case WM2000_REG_SPK_CTL:
 752                 return true;
 753         default:
 754                 return false;
 755         }
 756 }
 757
 758 static const struct regmap_config wm2000_regmap = {
 759         .reg_bits = 16,
 760         .val_bits = 8,
 761
 762         .max_register = WM2000_REG_SPK_CTL,
 763         .readable_reg = wm2000_readable_reg,
 764 };
 765
 766 static int wm2000_probe(struct snd_soc_component *component)
 767 {
 768         struct wm2000_priv *wm2000 = dev_get_drvdata(component->dev);
 769
 770         /* This will trigger a transition to standby mode by default */
 771         wm2000_anc_set_mode(wm2000);
 772
 773         return 0;
 774 }
 775
 776 static void wm2000_remove(struct snd_soc_component *component)
 777 {
 778         struct wm2000_priv *wm2000 = dev_get_drvdata(component->dev);
 779
 780         wm2000_anc_transition(wm2000, ANC_OFF);
 781 }
 782
 783 static const struct snd_soc_component_driver soc_component_dev_wm2000 = {
 784         .probe                  = wm2000_probe,
 785         .remove                 = wm2000_remove,
 786         .suspend                = wm2000_suspend,
 787         .resume                 = wm2000_resume,
 788         .controls               = wm2000_controls,
 789         .num_controls           = ARRAY_SIZE(wm2000_controls),
 790         .dapm_widgets           = wm2000_dapm_widgets,
 791         .num_dapm_widgets       = ARRAY_SIZE(wm2000_dapm_widgets),
 792         .dapm_routes            = wm2000_audio_map,
 793         .num_dapm_routes        = ARRAY_SIZE(wm2000_audio_map),
 794         .idle_bias_on           = 1,
 795         .use_pmdown_time        = 1,
 796         .non_legacy_dai_naming  = 1,
 797 };
 798
 799 static int wm2000_i2c_probe(struct i2c_client *i2c)
 800 {
 801         struct wm2000_priv *wm2000;
 802         struct wm2000_platform_data *pdata;
 803         const char *filename;
 804         const struct firmware *fw = NULL;
 805         int ret, i;
 806         unsigned int reg;
 807         u16 id;
 808
 809         wm2000 = devm_kzalloc(&i2c->dev, sizeof(*wm2000), GFP_KERNEL);
 810         if (!wm2000)
 811                 return -ENOMEM;
 812
 813         mutex_init(&wm2000->lock);
 814
 815         dev_set_drvdata(&i2c->dev, wm2000);
 816
 817         wm2000->regmap = devm_regmap_init_i2c(i2c, &wm2000_regmap);
 818         if (IS_ERR(wm2000->regmap)) {
 819                 ret = PTR_ERR(wm2000->regmap);
 820                 dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
 821                         ret);
 822                 goto out;
 823         }
 824
 825         for (i = 0; i < WM2000_NUM_SUPPLIES; i++)
 826                 wm2000->supplies[i].supply = wm2000_supplies[i];
 827
 828         ret = devm_regulator_bulk_get(&i2c->dev, WM2000_NUM_SUPPLIES,
 829                                       wm2000->supplies);
 830         if (ret != 0) {
 831                 dev_err(&i2c->dev, "Failed to get supplies: %d\n", ret);
 832                 return ret;
 833         }
 834
 835         ret = regulator_bulk_enable(WM2000_NUM_SUPPLIES, wm2000->supplies);
 836         if (ret != 0) {
 837                 dev_err(&i2c->dev, "Failed to enable supplies: %d\n", ret);
 838                 return ret;
 839         }
 840
 841         /* Verify that this is a WM2000 */
 842         ret = regmap_read(wm2000->regmap, WM2000_REG_ID1, &reg);
 843         if (ret != 0) {
 844                 dev_err(&i2c->dev, "Unable to read ID1: %d\n", ret);
 845                 return ret;
 846         }
 847         id = reg << 8;
 848         ret = regmap_read(wm2000->regmap, WM2000_REG_ID2, &reg);
 849         if (ret != 0) {
 850                 dev_err(&i2c->dev, "Unable to read ID2: %d\n", ret);
 851                 return ret;
 852         }
 853         id |= reg & 0xff;
 854
 855         if (id != 0x2000) {
 856                 dev_err(&i2c->dev, "Device is not a WM2000 - ID %x\n", id);
 857                 ret = -ENODEV;
 858                 goto err_supplies;
 859         }
 860
 861         ret = regmap_read(wm2000->regmap, WM2000_REG_REVISON, &reg);
 862         if (ret != 0) {
 863                 dev_err(&i2c->dev, "Unable to read Revision: %d\n", ret);
 864                 return ret;
 865         }
 866         dev_info(&i2c->dev, "revision %c\n", reg + 'A');
 867
 868         wm2000->mclk = devm_clk_get(&i2c->dev, "MCLK");
 869         if (IS_ERR(wm2000->mclk)) {
 870                 ret = PTR_ERR(wm2000->mclk);
 871                 dev_err(&i2c->dev, "Failed to get MCLK: %d\n", ret);
 872                 goto err_supplies;
 873         }
 874
 875         filename = "/*(DEBLOBBED)*/";
 876         pdata = dev_get_platdata(&i2c->dev);
 877         if (pdata) {
 878                 wm2000->speech_clarity = !pdata->speech_enh_disable;
 879
 880                 if (pdata->download_file)
 881                         filename = pdata->download_file;
 882         }
 883
 884         ret = reject_firmware(&fw, filename, &i2c->dev);
 885         if (ret != 0) {
 886                 dev_err(&i2c->dev, "Failed to acquire ANC data: %d\n", ret);
 887                 goto err_supplies;
 888         }
 889
 890         /* Pre-cook the concatenation of the register address onto the image */
 891         wm2000->anc_download_size = fw->size + 2;
 892         wm2000->anc_download = devm_kzalloc(&i2c->dev,
 893                                             wm2000->anc_download_size,
 894                                             GFP_KERNEL);
 895         if (wm2000->anc_download == NULL) {
 896                 ret = -ENOMEM;
 897                 goto err_supplies;
 898         }
 899
 900         wm2000->anc_download[0] = 0x80;
 901         wm2000->anc_download[1] = 0x00;
 902         memcpy(wm2000->anc_download + 2, fw->data, fw->size);
 903
 904         wm2000->anc_eng_ena = 1;
 905         wm2000->anc_active = 1;
 906         wm2000->spk_ena = 1;
 907         wm2000->i2c = i2c;
 908
 909         wm2000_reset(wm2000);
 910
 911         ret = devm_snd_soc_register_component(&i2c->dev,
 912                                         &soc_component_dev_wm2000, NULL, 0);
 913
 914 err_supplies:
 915         regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
 916
 917 out:
 918         release_firmware(fw);
 919         return ret;
 920 }
 921
 922 static const struct i2c_device_id wm2000_i2c_id[] = {
 923         { "wm2000", 0 },
 924         { }
 925 };
 926 MODULE_DEVICE_TABLE(i2c, wm2000_i2c_id);
 927
 928 static struct i2c_driver wm2000_i2c_driver = {
 929         .driver = {
 930                 .name = "wm2000",
 931         },
 932         .probe_new = wm2000_i2c_probe,
 933         .id_table = wm2000_i2c_id,
 934 };
 935
 936 module_i2c_driver(wm2000_i2c_driver);
 937
 938 MODULE_DESCRIPTION("ASoC WM2000 driver");
 939 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfonmicro.com>");
 940 MODULE_LICENSE("GPL");