1 /* 2 * File: sound/soc/codecs/ssm2602.c 3 * Author: Cliff Cai <Cliff.Cai@analog.com> 4 * 5 * Created: Tue June 06 2008 6 * Description: Driver for ssm2602 sound chip 7 * 8 * Modified: 9 * Copyright 2008 Analog Devices Inc. 10 * 11 * Bugs: Enter bugs at http://blackfin.uclinux.org/ 12 * 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License as published by 15 * the Free Software Foundation; either version 2 of the License, or 16 * (at your option) any later version. 17 * 18 * This program is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 * GNU General Public License for more details. 22 * 23 * You should have received a copy of the GNU General Public License 24 * along with this program; if not, see the file COPYING, or write 25 * to the Free Software Foundation, Inc., 26 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 27 */ 28 29 #include <linux/module.h> 30 #include <linux/moduleparam.h> 31 #include <linux/init.h> 32 #include <linux/delay.h> 33 #include <linux/pm.h> 34 #include <linux/i2c.h> 35 #include <linux/platform_device.h> 36 #include <sound/core.h> 37 #include <sound/pcm.h> 38 #include <sound/pcm_params.h> 39 #include <sound/soc.h> 40 #include <sound/soc-dapm.h> 41 #include <sound/initval.h> 42 43 #include "ssm2602.h" 44 45 #define SSM2602_VERSION "0.1" 46 47 struct snd_soc_codec_device soc_codec_dev_ssm2602; 48 49 /* codec private data */ 50 struct ssm2602_priv { 51 unsigned int sysclk; 52 struct snd_pcm_substream *master_substream; 53 struct snd_pcm_substream *slave_substream; 54 }; 55 56 /* 57 * ssm2602 register cache 58 * We can't read the ssm2602 register space when we are 59 * using 2 wire for device control, so we cache them instead. 60 * There is no point in caching the reset register 61 */ 62 static const u16 ssm2602_reg[SSM2602_CACHEREGNUM] = { 63 0x0017, 0x0017, 0x0079, 0x0079, 64 0x0000, 0x0000, 0x0000, 0x000a, 65 0x0000, 0x0000 66 }; 67 68 /* 69 * read ssm2602 register cache 70 */ 71 static inline unsigned int ssm2602_read_reg_cache(struct snd_soc_codec *codec, 72 unsigned int reg) 73 { 74 u16 *cache = codec->reg_cache; 75 if (reg == SSM2602_RESET) 76 return 0; 77 if (reg >= SSM2602_CACHEREGNUM) 78 return -1; 79 return cache[reg]; 80 } 81 82 /* 83 * write ssm2602 register cache 84 */ 85 static inline void ssm2602_write_reg_cache(struct snd_soc_codec *codec, 86 u16 reg, unsigned int value) 87 { 88 u16 *cache = codec->reg_cache; 89 if (reg >= SSM2602_CACHEREGNUM) 90 return; 91 cache[reg] = value; 92 } 93 94 /* 95 * write to the ssm2602 register space 96 */ 97 static int ssm2602_write(struct snd_soc_codec *codec, unsigned int reg, 98 unsigned int value) 99 { 100 u8 data[2]; 101 102 /* data is 103 * D15..D9 ssm2602 register offset 104 * D8...D0 register data 105 */ 106 data[0] = (reg << 1) | ((value >> 8) & 0x0001); 107 data[1] = value & 0x00ff; 108 109 ssm2602_write_reg_cache(codec, reg, value); 110 if (codec->hw_write(codec->control_data, data, 2) == 2) 111 return 0; 112 else 113 return -EIO; 114 } 115 116 #define ssm2602_reset(c) ssm2602_write(c, SSM2602_RESET, 0) 117 118 /*Appending several "None"s just for OSS mixer use*/ 119 static const char *ssm2602_input_select[] = { 120 "Line", "Mic", "None", "None", "None", 121 "None", "None", "None", 122 }; 123 124 static const char *ssm2602_deemph[] = {"None", "32Khz", "44.1Khz", "48Khz"}; 125 126 static const struct soc_enum ssm2602_enum[] = { 127 SOC_ENUM_SINGLE(SSM2602_APANA, 2, 2, ssm2602_input_select), 128 SOC_ENUM_SINGLE(SSM2602_APDIGI, 1, 4, ssm2602_deemph), 129 }; 130 131 static const struct snd_kcontrol_new ssm2602_snd_controls[] = { 132 133 SOC_DOUBLE_R("Master Playback Volume", SSM2602_LOUT1V, SSM2602_ROUT1V, 134 0, 127, 0), 135 SOC_DOUBLE_R("Master Playback ZC Switch", SSM2602_LOUT1V, SSM2602_ROUT1V, 136 7, 1, 0), 137 138 SOC_DOUBLE_R("Capture Volume", SSM2602_LINVOL, SSM2602_RINVOL, 0, 31, 0), 139 SOC_DOUBLE_R("Capture Switch", SSM2602_LINVOL, SSM2602_RINVOL, 7, 1, 1), 140 141 SOC_SINGLE("Mic Boost (+20dB)", SSM2602_APANA, 0, 1, 0), 142 SOC_SINGLE("Mic Switch", SSM2602_APANA, 1, 1, 1), 143 144 SOC_SINGLE("Sidetone Playback Volume", SSM2602_APANA, 6, 3, 1), 145 146 SOC_SINGLE("ADC High Pass Filter Switch", SSM2602_APDIGI, 0, 1, 1), 147 SOC_SINGLE("Store DC Offset Switch", SSM2602_APDIGI, 4, 1, 0), 148 149 SOC_ENUM("Capture Source", ssm2602_enum[0]), 150 151 SOC_ENUM("Playback De-emphasis", ssm2602_enum[1]), 152 }; 153 154 /* Output Mixer */ 155 static const struct snd_kcontrol_new ssm2602_output_mixer_controls[] = { 156 SOC_DAPM_SINGLE("Line Bypass Switch", SSM2602_APANA, 3, 1, 0), 157 SOC_DAPM_SINGLE("Mic Sidetone Switch", SSM2602_APANA, 5, 1, 0), 158 SOC_DAPM_SINGLE("HiFi Playback Switch", SSM2602_APANA, 4, 1, 0), 159 }; 160 161 /* Input mux */ 162 static const struct snd_kcontrol_new ssm2602_input_mux_controls = 163 SOC_DAPM_ENUM("Input Select", ssm2602_enum[0]); 164 165 static const struct snd_soc_dapm_widget ssm2602_dapm_widgets[] = { 166 SND_SOC_DAPM_MIXER("Output Mixer", SSM2602_PWR, 4, 1, 167 &ssm2602_output_mixer_controls[0], 168 ARRAY_SIZE(ssm2602_output_mixer_controls)), 169 SND_SOC_DAPM_DAC("DAC", "HiFi Playback", SSM2602_PWR, 3, 1), 170 SND_SOC_DAPM_OUTPUT("LOUT"), 171 SND_SOC_DAPM_OUTPUT("LHPOUT"), 172 SND_SOC_DAPM_OUTPUT("ROUT"), 173 SND_SOC_DAPM_OUTPUT("RHPOUT"), 174 SND_SOC_DAPM_ADC("ADC", "HiFi Capture", SSM2602_PWR, 2, 1), 175 SND_SOC_DAPM_MUX("Input Mux", SND_SOC_NOPM, 0, 0, &ssm2602_input_mux_controls), 176 SND_SOC_DAPM_PGA("Line Input", SSM2602_PWR, 0, 1, NULL, 0), 177 SND_SOC_DAPM_MICBIAS("Mic Bias", SSM2602_PWR, 1, 1), 178 SND_SOC_DAPM_INPUT("MICIN"), 179 SND_SOC_DAPM_INPUT("RLINEIN"), 180 SND_SOC_DAPM_INPUT("LLINEIN"), 181 }; 182 183 static const struct snd_soc_dapm_route audio_conn[] = { 184 /* output mixer */ 185 {"Output Mixer", "Line Bypass Switch", "Line Input"}, 186 {"Output Mixer", "HiFi Playback Switch", "DAC"}, 187 {"Output Mixer", "Mic Sidetone Switch", "Mic Bias"}, 188 189 /* outputs */ 190 {"RHPOUT", NULL, "Output Mixer"}, 191 {"ROUT", NULL, "Output Mixer"}, 192 {"LHPOUT", NULL, "Output Mixer"}, 193 {"LOUT", NULL, "Output Mixer"}, 194 195 /* input mux */ 196 {"Input Mux", "Line", "Line Input"}, 197 {"Input Mux", "Mic", "Mic Bias"}, 198 {"ADC", NULL, "Input Mux"}, 199 200 /* inputs */ 201 {"Line Input", NULL, "LLINEIN"}, 202 {"Line Input", NULL, "RLINEIN"}, 203 {"Mic Bias", NULL, "MICIN"}, 204 }; 205 206 static int ssm2602_add_widgets(struct snd_soc_codec *codec) 207 { 208 snd_soc_dapm_new_controls(codec, ssm2602_dapm_widgets, 209 ARRAY_SIZE(ssm2602_dapm_widgets)); 210 211 snd_soc_dapm_add_routes(codec, audio_conn, ARRAY_SIZE(audio_conn)); 212 213 snd_soc_dapm_new_widgets(codec); 214 return 0; 215 } 216 217 struct _coeff_div { 218 u32 mclk; 219 u32 rate; 220 u16 fs; 221 u8 sr:4; 222 u8 bosr:1; 223 u8 usb:1; 224 }; 225 226 /* codec mclk clock divider coefficients */ 227 static const struct _coeff_div coeff_div[] = { 228 /* 48k */ 229 {12288000, 48000, 256, 0x0, 0x0, 0x0}, 230 {18432000, 48000, 384, 0x0, 0x1, 0x0}, 231 {12000000, 48000, 250, 0x0, 0x0, 0x1}, 232 233 /* 32k */ 234 {12288000, 32000, 384, 0x6, 0x0, 0x0}, 235 {18432000, 32000, 576, 0x6, 0x1, 0x0}, 236 {12000000, 32000, 375, 0x6, 0x0, 0x1}, 237 238 /* 8k */ 239 {12288000, 8000, 1536, 0x3, 0x0, 0x0}, 240 {18432000, 8000, 2304, 0x3, 0x1, 0x0}, 241 {11289600, 8000, 1408, 0xb, 0x0, 0x0}, 242 {16934400, 8000, 2112, 0xb, 0x1, 0x0}, 243 {12000000, 8000, 1500, 0x3, 0x0, 0x1}, 244 245 /* 96k */ 246 {12288000, 96000, 128, 0x7, 0x0, 0x0}, 247 {18432000, 96000, 192, 0x7, 0x1, 0x0}, 248 {12000000, 96000, 125, 0x7, 0x0, 0x1}, 249 250 /* 44.1k */ 251 {11289600, 44100, 256, 0x8, 0x0, 0x0}, 252 {16934400, 44100, 384, 0x8, 0x1, 0x0}, 253 {12000000, 44100, 272, 0x8, 0x1, 0x1}, 254 255 /* 88.2k */ 256 {11289600, 88200, 128, 0xf, 0x0, 0x0}, 257 {16934400, 88200, 192, 0xf, 0x1, 0x0}, 258 {12000000, 88200, 136, 0xf, 0x1, 0x1}, 259 }; 260 261 static inline int get_coeff(int mclk, int rate) 262 { 263 int i; 264 265 for (i = 0; i < ARRAY_SIZE(coeff_div); i++) { 266 if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk) 267 return i; 268 } 269 return i; 270 } 271 272 static int ssm2602_hw_params(struct snd_pcm_substream *substream, 273 struct snd_pcm_hw_params *params, 274 struct snd_soc_dai *dai) 275 { 276 u16 srate; 277 struct snd_soc_pcm_runtime *rtd = substream->private_data; 278 struct snd_soc_device *socdev = rtd->socdev; 279 struct snd_soc_codec *codec = socdev->card->codec; 280 struct ssm2602_priv *ssm2602 = codec->private_data; 281 struct i2c_client *i2c = codec->control_data; 282 u16 iface = ssm2602_read_reg_cache(codec, SSM2602_IFACE) & 0xfff3; 283 int i = get_coeff(ssm2602->sysclk, params_rate(params)); 284 285 if (substream == ssm2602->slave_substream) { 286 dev_dbg(&i2c->dev, "Ignoring hw_params for slave substream\n"); 287 return 0; 288 } 289 290 /*no match is found*/ 291 if (i == ARRAY_SIZE(coeff_div)) 292 return -EINVAL; 293 294 srate = (coeff_div[i].sr << 2) | 295 (coeff_div[i].bosr << 1) | coeff_div[i].usb; 296 297 ssm2602_write(codec, SSM2602_ACTIVE, 0); 298 ssm2602_write(codec, SSM2602_SRATE, srate); 299 300 /* bit size */ 301 switch (params_format(params)) { 302 case SNDRV_PCM_FORMAT_S16_LE: 303 break; 304 case SNDRV_PCM_FORMAT_S20_3LE: 305 iface |= 0x0004; 306 break; 307 case SNDRV_PCM_FORMAT_S24_LE: 308 iface |= 0x0008; 309 break; 310 case SNDRV_PCM_FORMAT_S32_LE: 311 iface |= 0x000c; 312 break; 313 } 314 ssm2602_write(codec, SSM2602_IFACE, iface); 315 ssm2602_write(codec, SSM2602_ACTIVE, ACTIVE_ACTIVATE_CODEC); 316 return 0; 317 } 318 319 static int ssm2602_startup(struct snd_pcm_substream *substream, 320 struct snd_soc_dai *dai) 321 { 322 struct snd_soc_pcm_runtime *rtd = substream->private_data; 323 struct snd_soc_device *socdev = rtd->socdev; 324 struct snd_soc_codec *codec = socdev->card->codec; 325 struct ssm2602_priv *ssm2602 = codec->private_data; 326 struct i2c_client *i2c = codec->control_data; 327 struct snd_pcm_runtime *master_runtime; 328 329 /* The DAI has shared clocks so if we already have a playback or 330 * capture going then constrain this substream to match it. 331 * TODO: the ssm2602 allows pairs of non-matching PB/REC rates 332 */ 333 if (ssm2602->master_substream) { 334 master_runtime = ssm2602->master_substream->runtime; 335 dev_dbg(&i2c->dev, "Constraining to %d bits at %dHz\n", 336 master_runtime->sample_bits, 337 master_runtime->rate); 338 339 snd_pcm_hw_constraint_minmax(substream->runtime, 340 SNDRV_PCM_HW_PARAM_RATE, 341 master_runtime->rate, 342 master_runtime->rate); 343 344 snd_pcm_hw_constraint_minmax(substream->runtime, 345 SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 346 master_runtime->sample_bits, 347 master_runtime->sample_bits); 348 349 ssm2602->slave_substream = substream; 350 } else 351 ssm2602->master_substream = substream; 352 353 return 0; 354 } 355 356 static int ssm2602_pcm_prepare(struct snd_pcm_substream *substream, 357 struct snd_soc_dai *dai) 358 { 359 struct snd_soc_pcm_runtime *rtd = substream->private_data; 360 struct snd_soc_device *socdev = rtd->socdev; 361 struct snd_soc_codec *codec = socdev->card->codec; 362 /* set active */ 363 ssm2602_write(codec, SSM2602_ACTIVE, ACTIVE_ACTIVATE_CODEC); 364 365 return 0; 366 } 367 368 static void ssm2602_shutdown(struct snd_pcm_substream *substream, 369 struct snd_soc_dai *dai) 370 { 371 struct snd_soc_pcm_runtime *rtd = substream->private_data; 372 struct snd_soc_device *socdev = rtd->socdev; 373 struct snd_soc_codec *codec = socdev->card->codec; 374 struct ssm2602_priv *ssm2602 = codec->private_data; 375 /* deactivate */ 376 if (!codec->active) 377 ssm2602_write(codec, SSM2602_ACTIVE, 0); 378 379 if (ssm2602->master_substream == substream) 380 ssm2602->master_substream = ssm2602->slave_substream; 381 382 ssm2602->slave_substream = NULL; 383 } 384 385 static int ssm2602_mute(struct snd_soc_dai *dai, int mute) 386 { 387 struct snd_soc_codec *codec = dai->codec; 388 u16 mute_reg = ssm2602_read_reg_cache(codec, SSM2602_APDIGI) & ~APDIGI_ENABLE_DAC_MUTE; 389 if (mute) 390 ssm2602_write(codec, SSM2602_APDIGI, 391 mute_reg | APDIGI_ENABLE_DAC_MUTE); 392 else 393 ssm2602_write(codec, SSM2602_APDIGI, mute_reg); 394 return 0; 395 } 396 397 static int ssm2602_set_dai_sysclk(struct snd_soc_dai *codec_dai, 398 int clk_id, unsigned int freq, int dir) 399 { 400 struct snd_soc_codec *codec = codec_dai->codec; 401 struct ssm2602_priv *ssm2602 = codec->private_data; 402 switch (freq) { 403 case 11289600: 404 case 12000000: 405 case 12288000: 406 case 16934400: 407 case 18432000: 408 ssm2602->sysclk = freq; 409 return 0; 410 } 411 return -EINVAL; 412 } 413 414 static int ssm2602_set_dai_fmt(struct snd_soc_dai *codec_dai, 415 unsigned int fmt) 416 { 417 struct snd_soc_codec *codec = codec_dai->codec; 418 u16 iface = 0; 419 420 /* set master/slave audio interface */ 421 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { 422 case SND_SOC_DAIFMT_CBM_CFM: 423 iface |= 0x0040; 424 break; 425 case SND_SOC_DAIFMT_CBS_CFS: 426 break; 427 default: 428 return -EINVAL; 429 } 430 431 /* interface format */ 432 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 433 case SND_SOC_DAIFMT_I2S: 434 iface |= 0x0002; 435 break; 436 case SND_SOC_DAIFMT_RIGHT_J: 437 break; 438 case SND_SOC_DAIFMT_LEFT_J: 439 iface |= 0x0001; 440 break; 441 case SND_SOC_DAIFMT_DSP_A: 442 iface |= 0x0013; 443 break; 444 case SND_SOC_DAIFMT_DSP_B: 445 iface |= 0x0003; 446 break; 447 default: 448 return -EINVAL; 449 } 450 451 /* clock inversion */ 452 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 453 case SND_SOC_DAIFMT_NB_NF: 454 break; 455 case SND_SOC_DAIFMT_IB_IF: 456 iface |= 0x0090; 457 break; 458 case SND_SOC_DAIFMT_IB_NF: 459 iface |= 0x0080; 460 break; 461 case SND_SOC_DAIFMT_NB_IF: 462 iface |= 0x0010; 463 break; 464 default: 465 return -EINVAL; 466 } 467 468 /* set iface */ 469 ssm2602_write(codec, SSM2602_IFACE, iface); 470 return 0; 471 } 472 473 static int ssm2602_set_bias_level(struct snd_soc_codec *codec, 474 enum snd_soc_bias_level level) 475 { 476 u16 reg = ssm2602_read_reg_cache(codec, SSM2602_PWR) & 0xff7f; 477 478 switch (level) { 479 case SND_SOC_BIAS_ON: 480 /* vref/mid, osc on, dac unmute */ 481 ssm2602_write(codec, SSM2602_PWR, reg); 482 break; 483 case SND_SOC_BIAS_PREPARE: 484 break; 485 case SND_SOC_BIAS_STANDBY: 486 /* everything off except vref/vmid, */ 487 ssm2602_write(codec, SSM2602_PWR, reg | PWR_CLK_OUT_PDN); 488 break; 489 case SND_SOC_BIAS_OFF: 490 /* everything off, dac mute, inactive */ 491 ssm2602_write(codec, SSM2602_ACTIVE, 0); 492 ssm2602_write(codec, SSM2602_PWR, 0xffff); 493 break; 494 495 } 496 codec->bias_level = level; 497 return 0; 498 } 499 500 #define SSM2602_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\ 501 SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |\ 502 SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |\ 503 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 |\ 504 SNDRV_PCM_RATE_96000) 505 506 #define SSM2602_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\ 507 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE) 508 509 static struct snd_soc_dai_ops ssm2602_dai_ops = { 510 .startup = ssm2602_startup, 511 .prepare = ssm2602_pcm_prepare, 512 .hw_params = ssm2602_hw_params, 513 .shutdown = ssm2602_shutdown, 514 .digital_mute = ssm2602_mute, 515 .set_sysclk = ssm2602_set_dai_sysclk, 516 .set_fmt = ssm2602_set_dai_fmt, 517 }; 518 519 struct snd_soc_dai ssm2602_dai = { 520 .name = "SSM2602", 521 .playback = { 522 .stream_name = "Playback", 523 .channels_min = 2, 524 .channels_max = 2, 525 .rates = SSM2602_RATES, 526 .formats = SSM2602_FORMATS,}, 527 .capture = { 528 .stream_name = "Capture", 529 .channels_min = 2, 530 .channels_max = 2, 531 .rates = SSM2602_RATES, 532 .formats = SSM2602_FORMATS,}, 533 .ops = &ssm2602_dai_ops, 534 }; 535 EXPORT_SYMBOL_GPL(ssm2602_dai); 536 537 static int ssm2602_suspend(struct platform_device *pdev, pm_message_t state) 538 { 539 struct snd_soc_device *socdev = platform_get_drvdata(pdev); 540 struct snd_soc_codec *codec = socdev->card->codec; 541 542 ssm2602_set_bias_level(codec, SND_SOC_BIAS_OFF); 543 return 0; 544 } 545 546 static int ssm2602_resume(struct platform_device *pdev) 547 { 548 struct snd_soc_device *socdev = platform_get_drvdata(pdev); 549 struct snd_soc_codec *codec = socdev->card->codec; 550 int i; 551 u8 data[2]; 552 u16 *cache = codec->reg_cache; 553 554 /* Sync reg_cache with the hardware */ 555 for (i = 0; i < ARRAY_SIZE(ssm2602_reg); i++) { 556 data[0] = (i << 1) | ((cache[i] >> 8) & 0x0001); 557 data[1] = cache[i] & 0x00ff; 558 codec->hw_write(codec->control_data, data, 2); 559 } 560 ssm2602_set_bias_level(codec, SND_SOC_BIAS_STANDBY); 561 ssm2602_set_bias_level(codec, codec->suspend_bias_level); 562 return 0; 563 } 564 565 /* 566 * initialise the ssm2602 driver 567 * register the mixer and dsp interfaces with the kernel 568 */ 569 static int ssm2602_init(struct snd_soc_device *socdev) 570 { 571 struct snd_soc_codec *codec = socdev->card->codec; 572 int reg, ret = 0; 573 574 codec->name = "SSM2602"; 575 codec->owner = THIS_MODULE; 576 codec->read = ssm2602_read_reg_cache; 577 codec->write = ssm2602_write; 578 codec->set_bias_level = ssm2602_set_bias_level; 579 codec->dai = &ssm2602_dai; 580 codec->num_dai = 1; 581 codec->reg_cache_size = sizeof(ssm2602_reg); 582 codec->reg_cache = kmemdup(ssm2602_reg, sizeof(ssm2602_reg), 583 GFP_KERNEL); 584 if (codec->reg_cache == NULL) 585 return -ENOMEM; 586 587 ssm2602_reset(codec); 588 589 /* register pcms */ 590 ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1); 591 if (ret < 0) { 592 pr_err("ssm2602: failed to create pcms\n"); 593 goto pcm_err; 594 } 595 /*power on device*/ 596 ssm2602_write(codec, SSM2602_ACTIVE, 0); 597 /* set the update bits */ 598 reg = ssm2602_read_reg_cache(codec, SSM2602_LINVOL); 599 ssm2602_write(codec, SSM2602_LINVOL, reg | LINVOL_LRIN_BOTH); 600 reg = ssm2602_read_reg_cache(codec, SSM2602_RINVOL); 601 ssm2602_write(codec, SSM2602_RINVOL, reg | RINVOL_RLIN_BOTH); 602 reg = ssm2602_read_reg_cache(codec, SSM2602_LOUT1V); 603 ssm2602_write(codec, SSM2602_LOUT1V, reg | LOUT1V_LRHP_BOTH); 604 reg = ssm2602_read_reg_cache(codec, SSM2602_ROUT1V); 605 ssm2602_write(codec, SSM2602_ROUT1V, reg | ROUT1V_RLHP_BOTH); 606 /*select Line in as default input*/ 607 ssm2602_write(codec, SSM2602_APANA, 608 APANA_ENABLE_MIC_BOOST2 | APANA_SELECT_DAC | 609 APANA_ENABLE_MIC_BOOST); 610 ssm2602_write(codec, SSM2602_PWR, 0); 611 612 snd_soc_add_controls(codec, ssm2602_snd_controls, 613 ARRAY_SIZE(ssm2602_snd_controls)); 614 ssm2602_add_widgets(codec); 615 ret = snd_soc_init_card(socdev); 616 if (ret < 0) { 617 pr_err("ssm2602: failed to register card\n"); 618 goto card_err; 619 } 620 621 return ret; 622 623 card_err: 624 snd_soc_free_pcms(socdev); 625 snd_soc_dapm_free(socdev); 626 pcm_err: 627 kfree(codec->reg_cache); 628 return ret; 629 } 630 631 static struct snd_soc_device *ssm2602_socdev; 632 633 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) 634 /* 635 * ssm2602 2 wire address is determined by GPIO5 636 * state during powerup. 637 * low = 0x1a 638 * high = 0x1b 639 */ 640 static int ssm2602_i2c_probe(struct i2c_client *i2c, 641 const struct i2c_device_id *id) 642 { 643 struct snd_soc_device *socdev = ssm2602_socdev; 644 struct snd_soc_codec *codec = socdev->card->codec; 645 int ret; 646 647 i2c_set_clientdata(i2c, codec); 648 codec->control_data = i2c; 649 650 ret = ssm2602_init(socdev); 651 if (ret < 0) 652 pr_err("failed to initialise SSM2602\n"); 653 654 return ret; 655 } 656 657 static int ssm2602_i2c_remove(struct i2c_client *client) 658 { 659 struct snd_soc_codec *codec = i2c_get_clientdata(client); 660 kfree(codec->reg_cache); 661 return 0; 662 } 663 664 static const struct i2c_device_id ssm2602_i2c_id[] = { 665 { "ssm2602", 0 }, 666 { } 667 }; 668 MODULE_DEVICE_TABLE(i2c, ssm2602_i2c_id); 669 /* corgi i2c codec control layer */ 670 static struct i2c_driver ssm2602_i2c_driver = { 671 .driver = { 672 .name = "SSM2602 I2C Codec", 673 .owner = THIS_MODULE, 674 }, 675 .probe = ssm2602_i2c_probe, 676 .remove = ssm2602_i2c_remove, 677 .id_table = ssm2602_i2c_id, 678 }; 679 680 static int ssm2602_add_i2c_device(struct platform_device *pdev, 681 const struct ssm2602_setup_data *setup) 682 { 683 struct i2c_board_info info; 684 struct i2c_adapter *adapter; 685 struct i2c_client *client; 686 int ret; 687 688 ret = i2c_add_driver(&ssm2602_i2c_driver); 689 if (ret != 0) { 690 dev_err(&pdev->dev, "can't add i2c driver\n"); 691 return ret; 692 } 693 memset(&info, 0, sizeof(struct i2c_board_info)); 694 info.addr = setup->i2c_address; 695 strlcpy(info.type, "ssm2602", I2C_NAME_SIZE); 696 adapter = i2c_get_adapter(setup->i2c_bus); 697 if (!adapter) { 698 dev_err(&pdev->dev, "can't get i2c adapter %d\n", 699 setup->i2c_bus); 700 goto err_driver; 701 } 702 client = i2c_new_device(adapter, &info); 703 i2c_put_adapter(adapter); 704 if (!client) { 705 dev_err(&pdev->dev, "can't add i2c device at 0x%x\n", 706 (unsigned int)info.addr); 707 goto err_driver; 708 } 709 return 0; 710 err_driver: 711 i2c_del_driver(&ssm2602_i2c_driver); 712 return -ENODEV; 713 } 714 #endif 715 716 static int ssm2602_probe(struct platform_device *pdev) 717 { 718 struct snd_soc_device *socdev = platform_get_drvdata(pdev); 719 struct ssm2602_setup_data *setup; 720 struct snd_soc_codec *codec; 721 struct ssm2602_priv *ssm2602; 722 int ret = 0; 723 724 pr_info("ssm2602 Audio Codec %s", SSM2602_VERSION); 725 726 setup = socdev->codec_data; 727 codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL); 728 if (codec == NULL) 729 return -ENOMEM; 730 731 ssm2602 = kzalloc(sizeof(struct ssm2602_priv), GFP_KERNEL); 732 if (ssm2602 == NULL) { 733 kfree(codec); 734 return -ENOMEM; 735 } 736 737 codec->private_data = ssm2602; 738 socdev->card->codec = codec; 739 mutex_init(&codec->mutex); 740 INIT_LIST_HEAD(&codec->dapm_widgets); 741 INIT_LIST_HEAD(&codec->dapm_paths); 742 743 ssm2602_socdev = socdev; 744 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) 745 if (setup->i2c_address) { 746 codec->hw_write = (hw_write_t)i2c_master_send; 747 ret = ssm2602_add_i2c_device(pdev, setup); 748 } 749 #else 750 /* other interfaces */ 751 #endif 752 return ret; 753 } 754 755 /* remove everything here */ 756 static int ssm2602_remove(struct platform_device *pdev) 757 { 758 struct snd_soc_device *socdev = platform_get_drvdata(pdev); 759 struct snd_soc_codec *codec = socdev->card->codec; 760 761 if (codec->control_data) 762 ssm2602_set_bias_level(codec, SND_SOC_BIAS_OFF); 763 764 snd_soc_free_pcms(socdev); 765 snd_soc_dapm_free(socdev); 766 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) 767 i2c_unregister_device(codec->control_data); 768 i2c_del_driver(&ssm2602_i2c_driver); 769 #endif 770 kfree(codec->private_data); 771 kfree(codec); 772 773 return 0; 774 } 775 776 struct snd_soc_codec_device soc_codec_dev_ssm2602 = { 777 .probe = ssm2602_probe, 778 .remove = ssm2602_remove, 779 .suspend = ssm2602_suspend, 780 .resume = ssm2602_resume, 781 }; 782 EXPORT_SYMBOL_GPL(soc_codec_dev_ssm2602); 783 784 static int __init ssm2602_modinit(void) 785 { 786 return snd_soc_register_dai(&ssm2602_dai); 787 } 788 module_init(ssm2602_modinit); 789 790 static void __exit ssm2602_exit(void) 791 { 792 snd_soc_unregister_dai(&ssm2602_dai); 793 } 794 module_exit(ssm2602_exit); 795 796 MODULE_DESCRIPTION("ASoC ssm2602 driver"); 797 MODULE_AUTHOR("Cliff Cai"); 798 MODULE_LICENSE("GPL"); 799