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