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