1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // ALSA SoC Texas Instruments PCM6240 Family Audio ADC/DAC Device 4 // 5 // Copyright (C) 2022 - 2024 Texas Instruments Incorporated 6 // https://www.ti.com 7 // 8 // The PCM6240 driver implements a flexible and configurable 9 // algo coefficient setting for one, two, or even multiple 10 // PCM6240 Family chips. 11 // 12 // Author: Shenghao Ding <shenghao-ding@ti.com> 13 // 14 15 #include <linux/unaligned.h> 16 #include <linux/firmware.h> 17 #include <linux/gpio/consumer.h> 18 #include <linux/i2c.h> 19 #include <linux/module.h> 20 #include <linux/of_irq.h> 21 #include <linux/of_address.h> 22 #include <linux/regmap.h> 23 #include <sound/pcm_params.h> 24 #include <sound/soc.h> 25 #include <sound/tlv.h> 26 27 #include "pcm6240.h" 28 29 static const struct i2c_device_id pcmdevice_i2c_id[] = { 30 { .name = "adc3120", .driver_data = ADC3120 }, 31 { .name = "adc5120", .driver_data = ADC5120 }, 32 { .name = "adc6120", .driver_data = ADC6120 }, 33 { .name = "dix4192", .driver_data = DIX4192 }, 34 { .name = "pcm1690", .driver_data = PCM1690 }, 35 { .name = "pcm3120", .driver_data = PCM3120 }, 36 { .name = "pcm3140", .driver_data = PCM3140 }, 37 { .name = "pcm5120", .driver_data = PCM5120 }, 38 { .name = "pcm5140", .driver_data = PCM5140 }, 39 { .name = "pcm6120", .driver_data = PCM6120 }, 40 { .name = "pcm6140", .driver_data = PCM6140 }, 41 { .name = "pcm6240", .driver_data = PCM6240 }, 42 { .name = "pcm6260", .driver_data = PCM6260 }, 43 { .name = "pcm9211", .driver_data = PCM9211 }, 44 { .name = "pcmd3140", .driver_data = PCMD3140 }, 45 { .name = "pcmd3180", .driver_data = PCMD3180 }, 46 { .name = "pcmd512x", .driver_data = PCMD512X }, 47 { .name = "taa5212", .driver_data = TAA5212 }, 48 { .name = "taa5412", .driver_data = TAA5412 }, 49 { .name = "tad5212", .driver_data = TAD5212 }, 50 { .name = "tad5412", .driver_data = TAD5412 }, 51 { } 52 }; 53 MODULE_DEVICE_TABLE(i2c, pcmdevice_i2c_id); 54 55 static const char *const pcmdev_ctrl_name[] = { 56 "%s i2c%d Dev%d Ch%d Ana Volume", 57 "%s i2c%d Dev%d Ch%d Digi Volume", 58 "%s i2c%d Dev%d Ch%d Fine Volume", 59 }; 60 61 static const struct pcmdevice_mixer_control adc5120_analog_gain_ctl[] = { 62 { 63 .shift = 1, 64 .reg = ADC5120_REG_CH1_ANALOG_GAIN, 65 .max = 0x54, 66 .invert = 0, 67 }, 68 { 69 .shift = 1, 70 .reg = ADC5120_REG_CH2_ANALOG_GAIN, 71 .max = 0x54, 72 .invert = 0, 73 } 74 }; 75 76 static const struct pcmdevice_mixer_control adc5120_digi_gain_ctl[] = { 77 { 78 .shift = 0, 79 .reg = ADC5120_REG_CH1_DIGITAL_GAIN, 80 .max = 0xff, 81 .invert = 0, 82 }, 83 { 84 .shift = 0, 85 .reg = ADC5120_REG_CH2_DIGITAL_GAIN, 86 .max = 0xff, 87 .invert = 0, 88 } 89 }; 90 91 static const struct pcmdevice_mixer_control pcm1690_digi_gain_ctl[] = { 92 { 93 .shift = 0, 94 .reg = PCM1690_REG_CH1_DIGITAL_GAIN, 95 .max = 0xff, 96 .invert = 0, 97 }, 98 { 99 .shift = 0, 100 .reg = PCM1690_REG_CH2_DIGITAL_GAIN, 101 .max = 0xff, 102 .invert = 0, 103 }, 104 { 105 .shift = 0, 106 .reg = PCM1690_REG_CH3_DIGITAL_GAIN, 107 .max = 0xff, 108 .invert = 0, 109 }, 110 { 111 .shift = 0, 112 .reg = PCM1690_REG_CH4_DIGITAL_GAIN, 113 .max = 0xff, 114 .invert = 0, 115 }, 116 { 117 .shift = 0, 118 .reg = PCM1690_REG_CH5_DIGITAL_GAIN, 119 .max = 0xff, 120 .invert = 0, 121 }, 122 { 123 .shift = 0, 124 .reg = PCM1690_REG_CH6_DIGITAL_GAIN, 125 .max = 0xff, 126 .invert = 0, 127 }, 128 { 129 .shift = 0, 130 .reg = PCM1690_REG_CH7_DIGITAL_GAIN, 131 .max = 0xff, 132 .invert = 0, 133 }, 134 { 135 .shift = 0, 136 .reg = PCM1690_REG_CH8_DIGITAL_GAIN, 137 .max = 0xff, 138 .invert = 0, 139 } 140 }; 141 142 static const struct pcmdevice_mixer_control pcm6240_analog_gain_ctl[] = { 143 { 144 .shift = 2, 145 .reg = PCM6240_REG_CH1_ANALOG_GAIN, 146 .max = 0x42, 147 .invert = 0, 148 }, 149 { 150 .shift = 2, 151 .reg = PCM6240_REG_CH2_ANALOG_GAIN, 152 .max = 0x42, 153 .invert = 0, 154 }, 155 { 156 .shift = 2, 157 .reg = PCM6240_REG_CH3_ANALOG_GAIN, 158 .max = 0x42, 159 .invert = 0, 160 }, 161 { 162 .shift = 2, 163 .reg = PCM6240_REG_CH4_ANALOG_GAIN, 164 .max = 0x42, 165 .invert = 0, 166 } 167 }; 168 169 static const struct pcmdevice_mixer_control pcm6240_digi_gain_ctl[] = { 170 { 171 .shift = 0, 172 .reg = PCM6240_REG_CH1_DIGITAL_GAIN, 173 .max = 0xff, 174 .invert = 0, 175 }, 176 { 177 .shift = 0, 178 .reg = PCM6240_REG_CH2_DIGITAL_GAIN, 179 .max = 0xff, 180 .invert = 0, 181 }, 182 { 183 .shift = 0, 184 .reg = PCM6240_REG_CH3_DIGITAL_GAIN, 185 .max = 0xff, 186 .invert = 0, 187 }, 188 { 189 .shift = 0, 190 .reg = PCM6240_REG_CH4_DIGITAL_GAIN, 191 .max = 0xff, 192 .invert = 0, 193 } 194 }; 195 196 static const struct pcmdevice_mixer_control pcm6260_analog_gain_ctl[] = { 197 { 198 .shift = 2, 199 .reg = PCM6260_REG_CH1_ANALOG_GAIN, 200 .max = 0x42, 201 .invert = 0, 202 }, 203 { 204 .shift = 2, 205 .reg = PCM6260_REG_CH2_ANALOG_GAIN, 206 .max = 0x42, 207 .invert = 0, 208 }, 209 { 210 .shift = 2, 211 .reg = PCM6260_REG_CH3_ANALOG_GAIN, 212 .max = 0x42, 213 .invert = 0, 214 }, 215 { 216 .shift = 2, 217 .reg = PCM6260_REG_CH4_ANALOG_GAIN, 218 .max = 0x42, 219 .invert = 0, 220 }, 221 { 222 .shift = 2, 223 .reg = PCM6260_REG_CH5_ANALOG_GAIN, 224 .max = 0x42, 225 .invert = 0, 226 }, 227 { 228 .shift = 2, 229 .reg = PCM6260_REG_CH6_ANALOG_GAIN, 230 .max = 0x42, 231 .invert = 0, 232 } 233 }; 234 235 static const struct pcmdevice_mixer_control pcm6260_digi_gain_ctl[] = { 236 { 237 .shift = 0, 238 .reg = PCM6260_REG_CH1_DIGITAL_GAIN, 239 .max = 0xff, 240 .invert = 0, 241 }, 242 { 243 .shift = 0, 244 .reg = PCM6260_REG_CH2_DIGITAL_GAIN, 245 .max = 0xff, 246 .invert = 0, 247 }, 248 { 249 .shift = 0, 250 .reg = PCM6260_REG_CH3_DIGITAL_GAIN, 251 .max = 0xff, 252 .invert = 0, 253 }, 254 { 255 .shift = 0, 256 .reg = PCM6260_REG_CH4_DIGITAL_GAIN, 257 .max = 0xff, 258 .invert = 0, 259 }, 260 { 261 .shift = 0, 262 .reg = PCM6260_REG_CH5_DIGITAL_GAIN, 263 .max = 0xff, 264 .invert = 0, 265 }, 266 { 267 .shift = 0, 268 .reg = PCM6260_REG_CH6_DIGITAL_GAIN, 269 .max = 0xff, 270 .invert = 0, 271 } 272 }; 273 274 static const struct pcmdevice_mixer_control pcm9211_digi_gain_ctl[] = { 275 { 276 .shift = 0, 277 .reg = PCM9211_REG_CH1_DIGITAL_GAIN, 278 .max = 0xff, 279 .invert = 0, 280 }, 281 { 282 .shift = 0, 283 .reg = PCM9211_REG_CH2_DIGITAL_GAIN, 284 .max = 0xff, 285 .invert = 0, 286 } 287 }; 288 289 static const struct pcmdevice_mixer_control pcmd3140_digi_gain_ctl[] = { 290 { 291 .shift = 0, 292 .reg = PCMD3140_REG_CH1_DIGITAL_GAIN, 293 .max = 0xff, 294 .invert = 0, 295 }, 296 { 297 .shift = 0, 298 .reg = PCMD3140_REG_CH2_DIGITAL_GAIN, 299 .max = 0xff, 300 .invert = 0, 301 }, 302 { 303 .shift = 0, 304 .reg = PCMD3140_REG_CH3_DIGITAL_GAIN, 305 .max = 0xff, 306 .invert = 0, 307 }, 308 { 309 .shift = 0, 310 .reg = PCMD3140_REG_CH4_DIGITAL_GAIN, 311 .max = 0xff, 312 .invert = 0, 313 } 314 }; 315 316 static const struct pcmdevice_mixer_control pcmd3140_fine_gain_ctl[] = { 317 { 318 .shift = 4, 319 .reg = PCMD3140_REG_CH1_FINE_GAIN, 320 .max = 0xf, 321 .invert = 0, 322 }, 323 { 324 .shift = 4, 325 .reg = PCMD3140_REG_CH2_FINE_GAIN, 326 .max = 0xf, 327 .invert = 0, 328 }, 329 { 330 .shift = 4, 331 .reg = PCMD3140_REG_CH3_FINE_GAIN, 332 .max = 0xf, 333 .invert = 0, 334 }, 335 { 336 .shift = 4, 337 .reg = PCMD3140_REG_CH4_FINE_GAIN, 338 .max = 0xf, 339 .invert = 0, 340 } 341 }; 342 343 static const struct pcmdevice_mixer_control pcmd3180_digi_gain_ctl[] = { 344 { 345 .shift = 0, 346 .reg = PCMD3180_REG_CH1_DIGITAL_GAIN, 347 .max = 0xff, 348 .invert = 0, 349 }, 350 { 351 .shift = 0, 352 .reg = PCMD3180_REG_CH2_DIGITAL_GAIN, 353 .max = 0xff, 354 .invert = 0, 355 }, 356 { 357 .shift = 0, 358 .reg = PCMD3180_REG_CH3_DIGITAL_GAIN, 359 .max = 0xff, 360 .invert = 0, 361 }, 362 { 363 .shift = 0, 364 .reg = PCMD3180_REG_CH4_DIGITAL_GAIN, 365 .max = 0xff, 366 .invert = 0, 367 }, 368 { 369 .shift = 0, 370 .reg = PCMD3180_REG_CH5_DIGITAL_GAIN, 371 .max = 0xff, 372 .invert = 0, 373 }, 374 { 375 .shift = 0, 376 .reg = PCMD3180_REG_CH6_DIGITAL_GAIN, 377 .max = 0xff, 378 .invert = 0, 379 }, 380 { 381 .shift = 0, 382 .reg = PCMD3180_REG_CH7_DIGITAL_GAIN, 383 .max = 0xff, 384 .invert = 0, 385 }, 386 { 387 .shift = 0, 388 .reg = PCMD3180_REG_CH8_DIGITAL_GAIN, 389 .max = 0xff, 390 .invert = 0, 391 } 392 }; 393 394 static const struct pcmdevice_mixer_control pcmd3180_fine_gain_ctl[] = { 395 { 396 .shift = 4, 397 .reg = PCMD3180_REG_CH1_FINE_GAIN, 398 .max = 0xf, 399 .invert = 0, 400 }, 401 { 402 .shift = 4, 403 .reg = PCMD3180_REG_CH2_FINE_GAIN, 404 .max = 0xf, 405 .invert = 0, 406 }, 407 { 408 .shift = 4, 409 .reg = PCMD3180_REG_CH3_FINE_GAIN, 410 .max = 0xf, 411 .invert = 0, 412 }, 413 { 414 .shift = 4, 415 .reg = PCMD3180_REG_CH4_FINE_GAIN, 416 .max = 0xf, 417 .invert = 0, 418 }, 419 { 420 .shift = 4, 421 .reg = PCMD3180_REG_CH5_FINE_GAIN, 422 .max = 0xf, 423 .invert = 0, 424 }, 425 { 426 .shift = 4, 427 .reg = PCMD3180_REG_CH6_FINE_GAIN, 428 .max = 0xf, 429 .invert = 0, 430 }, 431 { 432 .shift = 4, 433 .reg = PCMD3180_REG_CH7_FINE_GAIN, 434 .max = 0xf, 435 .invert = 0, 436 }, 437 { 438 .shift = 4, 439 .reg = PCMD3180_REG_CH8_FINE_GAIN, 440 .max = 0xf, 441 .invert = 0, 442 } 443 }; 444 445 static const struct pcmdevice_mixer_control taa5412_digi_vol_ctl[] = { 446 { 447 .shift = 0, 448 .reg = TAA5412_REG_CH1_DIGITAL_VOLUME, 449 .max = 0xff, 450 .invert = 0, 451 }, 452 { 453 .shift = 0, 454 .reg = TAA5412_REG_CH2_DIGITAL_VOLUME, 455 .max = 0xff, 456 .invert = 0, 457 }, 458 { 459 .shift = 0, 460 .reg = TAA5412_REG_CH3_DIGITAL_VOLUME, 461 .max = 0xff, 462 .invert = 0, 463 }, 464 { 465 .shift = 0, 466 .reg = TAA5412_REG_CH4_DIGITAL_VOLUME, 467 .max = 0xff, 468 .invert = 0, 469 } 470 }; 471 472 static const struct pcmdevice_mixer_control taa5412_fine_gain_ctl[] = { 473 { 474 .shift = 4, 475 .reg = TAA5412_REG_CH1_FINE_GAIN, 476 .max = 0xf, 477 .invert = 0, 478 }, 479 { 480 .shift = 4, 481 .reg = TAA5412_REG_CH2_FINE_GAIN, 482 .max = 0xf, 483 .invert = 0, 484 }, 485 { 486 .shift = 4, 487 .reg = TAA5412_REG_CH3_FINE_GAIN, 488 .max = 0xf, 489 .invert = 4, 490 }, 491 { 492 .shift = 0, 493 .reg = TAA5412_REG_CH4_FINE_GAIN, 494 .max = 0xf, 495 .invert = 4, 496 } 497 }; 498 499 static const DECLARE_TLV_DB_MINMAX_MUTE(pcmd3140_dig_gain_tlv, 500 -10000, 2700); 501 static const DECLARE_TLV_DB_MINMAX_MUTE(pcm1690_fine_dig_gain_tlv, 502 -12750, 0); 503 static const DECLARE_TLV_DB_MINMAX_MUTE(pcm1690_dig_gain_tlv, 504 -25500, 0); 505 static const DECLARE_TLV_DB_MINMAX_MUTE(pcm9211_dig_gain_tlv, 506 -11450, 2000); 507 static const DECLARE_TLV_DB_MINMAX_MUTE(adc5120_fgain_tlv, 508 -10050, 2700); 509 static const DECLARE_TLV_DB_LINEAR(adc5120_chgain_tlv, 0, 4200); 510 static const DECLARE_TLV_DB_MINMAX_MUTE(pcm6260_fgain_tlv, 511 -10000, 2700); 512 static const DECLARE_TLV_DB_LINEAR(pcm6260_chgain_tlv, 0, 4200); 513 static const DECLARE_TLV_DB_MINMAX_MUTE(taa5412_dig_vol_tlv, 514 -8050, 4700); 515 static const DECLARE_TLV_DB_LINEAR(taa5412_fine_gain_tlv, 516 -80, 70); 517 518 static int pcmdev_change_dev(struct pcmdevice_priv *pcm_priv, 519 unsigned short dev_no) 520 { 521 struct i2c_client *client = (struct i2c_client *)pcm_priv->client; 522 struct regmap *map = pcm_priv->regmap; 523 int ret; 524 525 if (client->addr == pcm_priv->addr[dev_no]) 526 return 0; 527 528 client->addr = pcm_priv->addr[dev_no]; 529 /* All pcmdevices share the same regmap, clear the page 530 * inside regmap once switching to another pcmdevice. 531 * Register 0 at any pages inside pcmdevice is the same 532 * one for page-switching. 533 */ 534 ret = regmap_write(map, PCMDEVICE_PAGE_SELECT, 0); 535 if (ret < 0) 536 dev_err(pcm_priv->dev, "%s: err = %d\n", __func__, ret); 537 538 return ret; 539 } 540 541 static int pcmdev_dev_read(struct pcmdevice_priv *pcm_dev, 542 unsigned int dev_no, unsigned int reg, unsigned int *val) 543 { 544 struct regmap *map = pcm_dev->regmap; 545 int ret; 546 547 if (dev_no >= pcm_dev->ndev) { 548 dev_err(pcm_dev->dev, "%s: no such channel(%d)\n", __func__, 549 dev_no); 550 return -EINVAL; 551 } 552 553 ret = pcmdev_change_dev(pcm_dev, dev_no); 554 if (ret < 0) { 555 dev_err(pcm_dev->dev, "%s: chg dev err = %d\n", __func__, ret); 556 return ret; 557 } 558 559 ret = regmap_read(map, reg, val); 560 if (ret < 0) 561 dev_err(pcm_dev->dev, "%s: err = %d\n", __func__, ret); 562 563 return ret; 564 } 565 566 static int pcmdev_dev_update_bits(struct pcmdevice_priv *pcm_dev, 567 unsigned int dev_no, unsigned int reg, unsigned int mask, 568 unsigned int value) 569 { 570 struct regmap *map = pcm_dev->regmap; 571 int ret; 572 573 if (dev_no >= pcm_dev->ndev) { 574 dev_err(pcm_dev->dev, "%s: no such channel(%d)\n", __func__, 575 dev_no); 576 return -EINVAL; 577 } 578 579 ret = pcmdev_change_dev(pcm_dev, dev_no); 580 if (ret < 0) { 581 dev_err(pcm_dev->dev, "%s: chg dev err = %d\n", __func__, ret); 582 return ret; 583 } 584 585 ret = regmap_update_bits(map, reg, mask, value); 586 if (ret < 0) 587 dev_err(pcm_dev->dev, "%s: update_bits err=%d\n", 588 __func__, ret); 589 590 return ret; 591 } 592 593 static int pcmdev_get_volsw(struct snd_kcontrol *kcontrol, 594 struct snd_ctl_elem_value *ucontrol, int vol_ctrl_type) 595 { 596 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 597 struct pcmdevice_priv *pcm_dev = 598 snd_soc_component_get_drvdata(component); 599 struct pcmdevice_mixer_control *mc = 600 (struct pcmdevice_mixer_control *)kcontrol->private_value; 601 int max = mc->max, ret; 602 unsigned int mask = BIT(fls(max)) - 1; 603 unsigned int dev_no = mc->dev_no; 604 unsigned int shift = mc->shift; 605 unsigned int reg = mc->reg; 606 unsigned int val; 607 608 mutex_lock(&pcm_dev->codec_lock); 609 610 if (pcm_dev->chip_id == PCM1690) { 611 ret = pcmdev_dev_read(pcm_dev, dev_no, PCM1690_REG_MODE_CTRL, 612 &val); 613 if (ret) { 614 dev_err(pcm_dev->dev, "%s: read mode err=%d\n", 615 __func__, ret); 616 goto out; 617 } 618 val &= PCM1690_REG_MODE_CTRL_DAMS_MSK; 619 /* Set to wide-range mode, before using vol ctrl. */ 620 if (!val && vol_ctrl_type == PCMDEV_PCM1690_VOL_CTRL) { 621 ucontrol->value.integer.value[0] = -25500; 622 goto out; 623 } 624 /* Set to fine mode, before using fine vol ctrl. */ 625 if (val && vol_ctrl_type == PCMDEV_PCM1690_FINE_VOL_CTRL) { 626 ucontrol->value.integer.value[0] = -12750; 627 goto out; 628 } 629 } 630 631 ret = pcmdev_dev_read(pcm_dev, dev_no, reg, &val); 632 if (ret) { 633 dev_err(pcm_dev->dev, "%s: read err=%d\n", 634 __func__, ret); 635 goto out; 636 } 637 638 val = (val >> shift) & mask; 639 val = (val > max) ? max : val; 640 val = mc->invert ? max - val : val; 641 ucontrol->value.integer.value[0] = val; 642 out: 643 mutex_unlock(&pcm_dev->codec_lock); 644 return ret; 645 } 646 647 static int pcmdevice_get_volsw(struct snd_kcontrol *kcontrol, 648 struct snd_ctl_elem_value *ucontrol) 649 { 650 return pcmdev_get_volsw(kcontrol, ucontrol, PCMDEV_GENERIC_VOL_CTRL); 651 } 652 653 static int pcm1690_get_volsw(struct snd_kcontrol *kcontrol, 654 struct snd_ctl_elem_value *ucontrol) 655 { 656 return pcmdev_get_volsw(kcontrol, ucontrol, PCMDEV_PCM1690_VOL_CTRL); 657 } 658 659 static int pcm1690_get_finevolsw(struct snd_kcontrol *kcontrol, 660 struct snd_ctl_elem_value *ucontrol) 661 { 662 return pcmdev_get_volsw(kcontrol, ucontrol, 663 PCMDEV_PCM1690_FINE_VOL_CTRL); 664 } 665 666 static int pcmdev_put_volsw(struct snd_kcontrol *kcontrol, 667 struct snd_ctl_elem_value *ucontrol, int vol_ctrl_type) 668 { 669 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 670 struct pcmdevice_priv *pcm_dev = 671 snd_soc_component_get_drvdata(component); 672 struct pcmdevice_mixer_control *mc = 673 (struct pcmdevice_mixer_control *)kcontrol->private_value; 674 int max = mc->max, rc; 675 unsigned int mask = BIT(fls(max)) - 1; 676 unsigned int dev_no = mc->dev_no; 677 unsigned int shift = mc->shift; 678 unsigned int val, val_mask; 679 unsigned int reg = mc->reg; 680 681 mutex_lock(&pcm_dev->codec_lock); 682 val = ucontrol->value.integer.value[0] & mask; 683 val = (val > max) ? max : val; 684 val = mc->invert ? max - val : val; 685 val_mask = mask << shift; 686 val = val << shift; 687 688 switch (vol_ctrl_type) { 689 case PCMDEV_PCM1690_VOL_CTRL: 690 val_mask |= PCM1690_REG_MODE_CTRL_DAMS_MSK; 691 val |= PCM1690_REG_MODE_CTRL_DAMS_WIDE_RANGE; 692 break; 693 case PCMDEV_PCM1690_FINE_VOL_CTRL: 694 val_mask |= PCM1690_REG_MODE_CTRL_DAMS_MSK; 695 val |= PCM1690_REG_MODE_CTRL_DAMS_FINE_STEP; 696 break; 697 } 698 699 rc = pcmdev_dev_update_bits(pcm_dev, dev_no, reg, val_mask, val); 700 if (rc < 0) 701 dev_err(pcm_dev->dev, "%s: update_bits err = %d\n", 702 __func__, rc); 703 else 704 rc = 1; 705 mutex_unlock(&pcm_dev->codec_lock); 706 return rc; 707 } 708 709 static int pcmdevice_put_volsw(struct snd_kcontrol *kcontrol, 710 struct snd_ctl_elem_value *ucontrol) 711 { 712 return pcmdev_put_volsw(kcontrol, ucontrol, PCMDEV_GENERIC_VOL_CTRL); 713 } 714 715 static int pcm1690_put_volsw(struct snd_kcontrol *kcontrol, 716 struct snd_ctl_elem_value *ucontrol) 717 { 718 return pcmdev_put_volsw(kcontrol, ucontrol, PCMDEV_PCM1690_VOL_CTRL); 719 } 720 721 static int pcm1690_put_finevolsw(struct snd_kcontrol *kcontrol, 722 struct snd_ctl_elem_value *ucontrol) 723 { 724 return pcmdev_put_volsw(kcontrol, ucontrol, 725 PCMDEV_PCM1690_FINE_VOL_CTRL); 726 } 727 728 static const struct pcmdev_ctrl_info pcmdev_gain_ctl_info[][2] = { 729 // ADC3120 730 { 731 { 732 .gain = adc5120_chgain_tlv, 733 .pcmdev_ctrl = adc5120_analog_gain_ctl, 734 .ctrl_array_size = ARRAY_SIZE(adc5120_analog_gain_ctl), 735 .get = pcmdevice_get_volsw, 736 .put = pcmdevice_put_volsw, 737 .pcmdev_ctrl_name_id = 0, 738 }, 739 { 740 .gain = adc5120_fgain_tlv, 741 .pcmdev_ctrl = adc5120_digi_gain_ctl, 742 .ctrl_array_size = ARRAY_SIZE(adc5120_digi_gain_ctl), 743 .get = pcmdevice_get_volsw, 744 .put = pcmdevice_put_volsw, 745 .pcmdev_ctrl_name_id = 1, 746 }, 747 }, 748 // ADC5120 749 { 750 { 751 .gain = adc5120_chgain_tlv, 752 .pcmdev_ctrl = adc5120_analog_gain_ctl, 753 .ctrl_array_size = ARRAY_SIZE(adc5120_analog_gain_ctl), 754 .get = pcmdevice_get_volsw, 755 .put = pcmdevice_put_volsw, 756 .pcmdev_ctrl_name_id = 0, 757 }, 758 { 759 .gain = adc5120_fgain_tlv, 760 .pcmdev_ctrl = adc5120_digi_gain_ctl, 761 .ctrl_array_size = ARRAY_SIZE(adc5120_digi_gain_ctl), 762 .get = pcmdevice_get_volsw, 763 .put = pcmdevice_put_volsw, 764 .pcmdev_ctrl_name_id = 1, 765 }, 766 }, 767 // ADC6120 768 { 769 { 770 .gain = adc5120_chgain_tlv, 771 .pcmdev_ctrl = adc5120_analog_gain_ctl, 772 .ctrl_array_size = ARRAY_SIZE(adc5120_analog_gain_ctl), 773 .get = pcmdevice_get_volsw, 774 .put = pcmdevice_put_volsw, 775 .pcmdev_ctrl_name_id = 0, 776 }, 777 { 778 .gain = adc5120_fgain_tlv, 779 .pcmdev_ctrl = adc5120_digi_gain_ctl, 780 .ctrl_array_size = ARRAY_SIZE(adc5120_digi_gain_ctl), 781 .get = pcmdevice_get_volsw, 782 .put = pcmdevice_put_volsw, 783 .pcmdev_ctrl_name_id = 1, 784 }, 785 }, 786 // DIX4192 787 { 788 { 789 .ctrl_array_size = 0, 790 }, 791 { 792 .ctrl_array_size = 0, 793 }, 794 }, 795 // PCM1690 796 { 797 { 798 .gain = pcm1690_fine_dig_gain_tlv, 799 .pcmdev_ctrl = pcm1690_digi_gain_ctl, 800 .ctrl_array_size = ARRAY_SIZE(pcm1690_digi_gain_ctl), 801 .get = pcm1690_get_volsw, 802 .put = pcm1690_put_volsw, 803 .pcmdev_ctrl_name_id = 1, 804 }, 805 { 806 .gain = pcm1690_dig_gain_tlv, 807 .pcmdev_ctrl = pcm1690_digi_gain_ctl, 808 .ctrl_array_size = ARRAY_SIZE(pcm1690_digi_gain_ctl), 809 .get = pcm1690_get_finevolsw, 810 .put = pcm1690_put_finevolsw, 811 .pcmdev_ctrl_name_id = 2, 812 }, 813 }, 814 // PCM3120 815 { 816 { 817 .gain = adc5120_chgain_tlv, 818 .pcmdev_ctrl = adc5120_analog_gain_ctl, 819 .ctrl_array_size = ARRAY_SIZE(adc5120_analog_gain_ctl), 820 .get = pcmdevice_get_volsw, 821 .put = pcmdevice_put_volsw, 822 .pcmdev_ctrl_name_id = 0, 823 }, 824 { 825 .gain = adc5120_fgain_tlv, 826 .pcmdev_ctrl = adc5120_digi_gain_ctl, 827 .ctrl_array_size = ARRAY_SIZE(adc5120_digi_gain_ctl), 828 .get = pcmdevice_get_volsw, 829 .put = pcmdevice_put_volsw, 830 .pcmdev_ctrl_name_id = 1, 831 }, 832 }, 833 // PCM3140 834 { 835 { 836 .gain = pcm6260_chgain_tlv, 837 .pcmdev_ctrl = pcm6240_analog_gain_ctl, 838 .ctrl_array_size = ARRAY_SIZE(pcm6240_analog_gain_ctl), 839 .get = pcmdevice_get_volsw, 840 .put = pcmdevice_put_volsw, 841 .pcmdev_ctrl_name_id = 0, 842 }, 843 { 844 .gain = pcm6260_fgain_tlv, 845 .pcmdev_ctrl = pcm6240_digi_gain_ctl, 846 .ctrl_array_size = ARRAY_SIZE(pcm6240_digi_gain_ctl), 847 .get = pcmdevice_get_volsw, 848 .put = pcmdevice_put_volsw, 849 .pcmdev_ctrl_name_id = 1, 850 }, 851 }, 852 // PCM5120 853 { 854 { 855 .gain = adc5120_chgain_tlv, 856 .pcmdev_ctrl = adc5120_analog_gain_ctl, 857 .ctrl_array_size = ARRAY_SIZE(adc5120_analog_gain_ctl), 858 .get = pcmdevice_get_volsw, 859 .put = pcmdevice_put_volsw, 860 .pcmdev_ctrl_name_id = 0, 861 }, 862 { 863 .gain = adc5120_fgain_tlv, 864 .pcmdev_ctrl = adc5120_digi_gain_ctl, 865 .ctrl_array_size = ARRAY_SIZE(adc5120_digi_gain_ctl), 866 .get = pcmdevice_get_volsw, 867 .put = pcmdevice_put_volsw, 868 .pcmdev_ctrl_name_id = 1, 869 }, 870 }, 871 // PCM5140 872 { 873 { 874 .gain = pcm6260_chgain_tlv, 875 .pcmdev_ctrl = pcm6240_analog_gain_ctl, 876 .ctrl_array_size = ARRAY_SIZE(pcm6240_analog_gain_ctl), 877 .get = pcmdevice_get_volsw, 878 .put = pcmdevice_put_volsw, 879 .pcmdev_ctrl_name_id = 0, 880 }, 881 { 882 .gain = pcm6260_fgain_tlv, 883 .pcmdev_ctrl = pcm6240_digi_gain_ctl, 884 .ctrl_array_size = ARRAY_SIZE(pcm6240_digi_gain_ctl), 885 .get = pcmdevice_get_volsw, 886 .put = pcmdevice_put_volsw, 887 .pcmdev_ctrl_name_id = 1, 888 }, 889 }, 890 // PCM6120 891 { 892 { 893 .gain = adc5120_chgain_tlv, 894 .pcmdev_ctrl = adc5120_analog_gain_ctl, 895 .ctrl_array_size = ARRAY_SIZE(adc5120_analog_gain_ctl), 896 .get = pcmdevice_get_volsw, 897 .put = pcmdevice_put_volsw, 898 .pcmdev_ctrl_name_id = 0, 899 }, 900 { 901 .gain = adc5120_fgain_tlv, 902 .pcmdev_ctrl = adc5120_digi_gain_ctl, 903 .ctrl_array_size = ARRAY_SIZE(adc5120_digi_gain_ctl), 904 .get = pcmdevice_get_volsw, 905 .put = pcmdevice_put_volsw, 906 .pcmdev_ctrl_name_id = 1, 907 }, 908 }, 909 // PCM6140 910 { 911 { 912 .gain = pcm6260_chgain_tlv, 913 .pcmdev_ctrl = pcm6240_analog_gain_ctl, 914 .ctrl_array_size = ARRAY_SIZE(pcm6240_analog_gain_ctl), 915 .get = pcmdevice_get_volsw, 916 .put = pcmdevice_put_volsw, 917 .pcmdev_ctrl_name_id = 0, 918 }, 919 { 920 .gain = pcm6260_fgain_tlv, 921 .pcmdev_ctrl = pcm6240_digi_gain_ctl, 922 .ctrl_array_size = ARRAY_SIZE(pcm6240_digi_gain_ctl), 923 .get = pcmdevice_get_volsw, 924 .put = pcmdevice_put_volsw, 925 .pcmdev_ctrl_name_id = 1, 926 }, 927 }, 928 // PCM6240 929 { 930 { 931 .gain = pcm6260_chgain_tlv, 932 .pcmdev_ctrl = pcm6240_analog_gain_ctl, 933 .ctrl_array_size = ARRAY_SIZE(pcm6240_analog_gain_ctl), 934 .get = pcmdevice_get_volsw, 935 .put = pcmdevice_put_volsw, 936 .pcmdev_ctrl_name_id = 0, 937 }, 938 { 939 .gain = pcm6260_fgain_tlv, 940 .pcmdev_ctrl = pcm6240_digi_gain_ctl, 941 .ctrl_array_size = ARRAY_SIZE(pcm6240_digi_gain_ctl), 942 .get = pcmdevice_get_volsw, 943 .put = pcmdevice_put_volsw, 944 .pcmdev_ctrl_name_id = 1, 945 }, 946 }, 947 // PCM6260 948 { 949 { 950 .gain = pcm6260_chgain_tlv, 951 .pcmdev_ctrl = pcm6260_analog_gain_ctl, 952 .ctrl_array_size = ARRAY_SIZE(pcm6260_analog_gain_ctl), 953 .get = pcmdevice_get_volsw, 954 .put = pcmdevice_put_volsw, 955 .pcmdev_ctrl_name_id = 0, 956 }, 957 { 958 .gain = pcm6260_fgain_tlv, 959 .pcmdev_ctrl = pcm6260_digi_gain_ctl, 960 .ctrl_array_size = ARRAY_SIZE(pcm6260_digi_gain_ctl), 961 .get = pcmdevice_get_volsw, 962 .put = pcmdevice_put_volsw, 963 .pcmdev_ctrl_name_id = 1, 964 }, 965 }, 966 // PCM9211 967 { 968 { 969 .ctrl_array_size = 0, 970 }, 971 { 972 .gain = pcm9211_dig_gain_tlv, 973 .pcmdev_ctrl = pcm9211_digi_gain_ctl, 974 .ctrl_array_size = ARRAY_SIZE(pcm9211_digi_gain_ctl), 975 .get = pcmdevice_get_volsw, 976 .put = pcmdevice_put_volsw, 977 .pcmdev_ctrl_name_id = 1, 978 }, 979 980 }, 981 // PCMD3140 982 { 983 { 984 .gain = taa5412_fine_gain_tlv, 985 .pcmdev_ctrl = pcmd3140_fine_gain_ctl, 986 .ctrl_array_size = ARRAY_SIZE(pcmd3140_fine_gain_ctl), 987 .get = pcmdevice_get_volsw, 988 .put = pcmdevice_put_volsw, 989 .pcmdev_ctrl_name_id = 2, 990 }, 991 { 992 .gain = pcmd3140_dig_gain_tlv, 993 .pcmdev_ctrl = pcmd3140_digi_gain_ctl, 994 .ctrl_array_size = ARRAY_SIZE(pcmd3140_digi_gain_ctl), 995 .get = pcmdevice_get_volsw, 996 .put = pcmdevice_put_volsw, 997 .pcmdev_ctrl_name_id = 1, 998 }, 999 }, 1000 // PCMD3180 1001 { 1002 { 1003 .gain = taa5412_fine_gain_tlv, 1004 .pcmdev_ctrl = pcmd3180_fine_gain_ctl, 1005 .ctrl_array_size = ARRAY_SIZE(pcmd3180_fine_gain_ctl), 1006 .get = pcmdevice_get_volsw, 1007 .put = pcmdevice_put_volsw, 1008 .pcmdev_ctrl_name_id = 2, 1009 }, 1010 { 1011 .gain = pcmd3140_dig_gain_tlv, 1012 .pcmdev_ctrl = pcmd3180_digi_gain_ctl, 1013 .ctrl_array_size = ARRAY_SIZE(pcmd3180_digi_gain_ctl), 1014 .get = pcmdevice_get_volsw, 1015 .put = pcmdevice_put_volsw, 1016 .pcmdev_ctrl_name_id = 1, 1017 }, 1018 }, 1019 // PCMD512X 1020 { 1021 { 1022 .ctrl_array_size = 0, 1023 }, 1024 { 1025 .ctrl_array_size = 0, 1026 }, 1027 }, 1028 // TAA5212 1029 { 1030 { 1031 .gain = taa5412_fine_gain_tlv, 1032 .pcmdev_ctrl = taa5412_fine_gain_ctl, 1033 .ctrl_array_size = ARRAY_SIZE(taa5412_fine_gain_ctl), 1034 .get = pcmdevice_get_volsw, 1035 .put = pcmdevice_put_volsw, 1036 .pcmdev_ctrl_name_id = 2, 1037 }, 1038 { 1039 .gain = taa5412_dig_vol_tlv, 1040 .pcmdev_ctrl = taa5412_digi_vol_ctl, 1041 .ctrl_array_size = ARRAY_SIZE(taa5412_digi_vol_ctl), 1042 .get = pcmdevice_get_volsw, 1043 .put = pcmdevice_put_volsw, 1044 .pcmdev_ctrl_name_id = 1, 1045 }, 1046 }, 1047 // TAA5412 1048 { 1049 { 1050 .gain = taa5412_fine_gain_tlv, 1051 .pcmdev_ctrl = taa5412_fine_gain_ctl, 1052 .ctrl_array_size = ARRAY_SIZE(taa5412_fine_gain_ctl), 1053 .get = pcmdevice_get_volsw, 1054 .put = pcmdevice_put_volsw, 1055 .pcmdev_ctrl_name_id = 2, 1056 }, 1057 { 1058 .gain = taa5412_dig_vol_tlv, 1059 .pcmdev_ctrl = taa5412_digi_vol_ctl, 1060 .ctrl_array_size = ARRAY_SIZE(taa5412_digi_vol_ctl), 1061 .get = pcmdevice_get_volsw, 1062 .put = pcmdevice_put_volsw, 1063 .pcmdev_ctrl_name_id = 1, 1064 }, 1065 }, 1066 // TAD5212 1067 { 1068 { 1069 .ctrl_array_size = 0, 1070 }, 1071 { 1072 .ctrl_array_size = 0, 1073 }, 1074 }, 1075 // TAD5412 1076 { 1077 { 1078 .ctrl_array_size = 0, 1079 }, 1080 { 1081 .ctrl_array_size = 0, 1082 }, 1083 }, 1084 }; 1085 1086 static int pcmdev_dev_bulk_write(struct pcmdevice_priv *pcm_dev, 1087 unsigned int dev_no, unsigned int reg, unsigned char *data, 1088 unsigned int len) 1089 { 1090 struct regmap *map = pcm_dev->regmap; 1091 int ret; 1092 1093 if (dev_no >= pcm_dev->ndev) { 1094 dev_err(pcm_dev->dev, "%s: no such channel(%d)\n", __func__, 1095 dev_no); 1096 return -EINVAL; 1097 } 1098 1099 ret = pcmdev_change_dev(pcm_dev, dev_no); 1100 if (ret < 0) { 1101 dev_err(pcm_dev->dev, "%s: chg dev err = %d\n", __func__, ret); 1102 return ret; 1103 } 1104 1105 ret = regmap_bulk_write(map, reg, data, len); 1106 if (ret < 0) 1107 dev_err(pcm_dev->dev, "%s: bulk_write err = %d\n", __func__, 1108 ret); 1109 1110 return ret; 1111 } 1112 1113 static int pcmdev_dev_write(struct pcmdevice_priv *pcm_dev, 1114 unsigned int dev_no, unsigned int reg, unsigned int value) 1115 { 1116 struct regmap *map = pcm_dev->regmap; 1117 int ret; 1118 1119 if (dev_no >= pcm_dev->ndev) { 1120 dev_err(pcm_dev->dev, "%s: no such channel(%d)\n", __func__, 1121 dev_no); 1122 return -EINVAL; 1123 } 1124 1125 ret = pcmdev_change_dev(pcm_dev, dev_no); 1126 if (ret < 0) { 1127 dev_err(pcm_dev->dev, "%s: chg dev err = %d\n", __func__, ret); 1128 return ret; 1129 } 1130 1131 ret = regmap_write(map, reg, value); 1132 if (ret < 0) 1133 dev_err(pcm_dev->dev, "%s: err = %d\n", __func__, ret); 1134 1135 return ret; 1136 } 1137 1138 static int pcmdevice_info_profile( 1139 struct snd_kcontrol *kcontrol, 1140 struct snd_ctl_elem_info *uinfo) 1141 { 1142 struct snd_soc_component *codec = snd_kcontrol_chip(kcontrol); 1143 struct pcmdevice_priv *pcm_dev = 1144 snd_soc_component_get_drvdata(codec); 1145 1146 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1147 uinfo->count = 1; 1148 uinfo->value.integer.min = 0; 1149 uinfo->value.integer.max = max(0, pcm_dev->regbin.ncfgs - 1); 1150 1151 return 0; 1152 } 1153 1154 static int pcmdevice_get_profile_id( 1155 struct snd_kcontrol *kcontrol, 1156 struct snd_ctl_elem_value *ucontrol) 1157 { 1158 struct snd_soc_component *codec = snd_kcontrol_chip(kcontrol); 1159 struct pcmdevice_priv *pcm_dev = 1160 snd_soc_component_get_drvdata(codec); 1161 1162 ucontrol->value.integer.value[0] = pcm_dev->cur_conf; 1163 1164 return 0; 1165 } 1166 1167 static int pcmdevice_set_profile_id( 1168 struct snd_kcontrol *kcontrol, 1169 struct snd_ctl_elem_value *ucontrol) 1170 { 1171 struct snd_soc_component *codec = snd_kcontrol_chip(kcontrol); 1172 struct pcmdevice_priv *pcm_dev = 1173 snd_soc_component_get_drvdata(codec); 1174 int nr_profile = ucontrol->value.integer.value[0]; 1175 int max = pcm_dev->regbin.ncfgs - 1; 1176 int ret = 0; 1177 1178 nr_profile = clamp(nr_profile, 0, max); 1179 1180 if (pcm_dev->cur_conf != nr_profile) { 1181 pcm_dev->cur_conf = nr_profile; 1182 ret = 1; 1183 } 1184 1185 return ret; 1186 } 1187 1188 static int pcmdevice_info_volsw(struct snd_kcontrol *kcontrol, 1189 struct snd_ctl_elem_info *uinfo) 1190 { 1191 struct pcmdevice_mixer_control *mc = 1192 (struct pcmdevice_mixer_control *)kcontrol->private_value; 1193 1194 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1195 uinfo->count = 1; 1196 uinfo->value.integer.min = 0; 1197 uinfo->value.integer.max = mc->max; 1198 return 0; 1199 } 1200 1201 static void pcm9211_sw_rst(struct pcmdevice_priv *pcm_dev) 1202 { 1203 int ret, i; 1204 1205 for (i = 0; i < pcm_dev->ndev; i++) { 1206 ret = pcmdev_dev_update_bits(pcm_dev, i, 1207 PCM9211_REG_SW_CTRL, PCM9211_REG_SW_CTRL_MRST_MSK, 1208 PCM9211_REG_SW_CTRL_MRST); 1209 if (ret < 0) 1210 dev_err(pcm_dev->dev, "%s: dev %d swreset fail %d\n", 1211 __func__, i, ret); 1212 } 1213 } 1214 1215 static void pcmdevice_sw_rst(struct pcmdevice_priv *pcm_dev) 1216 { 1217 int ret, i; 1218 1219 for (i = 0; i < pcm_dev->ndev; i++) { 1220 ret = pcmdev_dev_write(pcm_dev, i, PCMDEVICE_REG_SWRESET, 1221 PCMDEVICE_REG_SWRESET_RESET); 1222 if (ret < 0) 1223 dev_err(pcm_dev->dev, "%s: dev %d swreset fail %d\n", 1224 __func__, i, ret); 1225 } 1226 } 1227 1228 static struct pcmdevice_config_info *pcmdevice_add_config(void *ctxt, 1229 const unsigned char *config_data, unsigned int config_size, 1230 int *status) 1231 { 1232 struct pcmdevice_priv *pcm_dev = (struct pcmdevice_priv *)ctxt; 1233 struct pcmdevice_config_info *cfg_info = NULL; 1234 struct pcmdevice_block_data **bk_da; 1235 char cfg_name[64] = {}; 1236 unsigned int config_offset = 0, i; 1237 unsigned int nblocks; 1238 1239 if (pcm_dev->regbin.fw_hdr.binary_version_num >= 0x105) { 1240 if (config_offset + 64 > (int)config_size) { 1241 *status = -EINVAL; 1242 dev_err(pcm_dev->dev, 1243 "%s: cfg_name out of boundary\n", __func__); 1244 goto out; 1245 } 1246 memcpy(cfg_name, &config_data[config_offset], 64); 1247 config_offset += 64; 1248 } 1249 1250 if (config_offset + 4 > config_size) { 1251 *status = -EINVAL; 1252 dev_err(pcm_dev->dev, "%s: nblocks out of boundary\n", 1253 __func__); 1254 goto out; 1255 } 1256 nblocks = get_unaligned_be32(&config_data[config_offset]); 1257 config_offset += 4; 1258 1259 cfg_info = kzalloc_flex(*cfg_info, blk_data, nblocks); 1260 if (!cfg_info) { 1261 *status = -ENOMEM; 1262 goto out; 1263 } 1264 cfg_info->nblocks = nblocks; 1265 memcpy(cfg_info->cfg_name, cfg_name, sizeof(cfg_info->cfg_name)); 1266 bk_da = cfg_info->blk_data; 1267 cfg_info->real_nblocks = 0; 1268 for (i = 0; i < cfg_info->nblocks; i++) { 1269 if (config_offset + 12 > config_size) { 1270 *status = -EINVAL; 1271 dev_err(pcm_dev->dev, 1272 "%s: out of boundary i = %d nblocks = %u\n", 1273 __func__, i, cfg_info->nblocks); 1274 break; 1275 } 1276 bk_da[i] = kzalloc_obj(struct pcmdevice_block_data); 1277 if (!bk_da[i]) { 1278 *status = -ENOMEM; 1279 break; 1280 } 1281 bk_da[i]->dev_idx = config_data[config_offset]; 1282 config_offset++; 1283 1284 bk_da[i]->block_type = config_data[config_offset]; 1285 config_offset++; 1286 1287 if (bk_da[i]->block_type == PCMDEVICE_BIN_BLK_PRE_POWER_UP) { 1288 if (bk_da[i]->dev_idx == 0) 1289 cfg_info->active_dev = 1290 (1 << pcm_dev->ndev) - 1; 1291 else 1292 cfg_info->active_dev = 1293 1 << (bk_da[i]->dev_idx - 1); 1294 } 1295 1296 bk_da[i]->yram_checksum = 1297 get_unaligned_be16(&config_data[config_offset]); 1298 config_offset += 2; 1299 bk_da[i]->block_size = 1300 get_unaligned_be32(&config_data[config_offset]); 1301 config_offset += 4; 1302 1303 bk_da[i]->n_subblks = 1304 get_unaligned_be32(&config_data[config_offset]); 1305 1306 config_offset += 4; 1307 1308 if (config_offset + bk_da[i]->block_size > config_size) { 1309 *status = -EINVAL; 1310 dev_err(pcm_dev->dev, 1311 "%s: out of boundary: i = %d blks = %u\n", 1312 __func__, i, cfg_info->nblocks); 1313 break; 1314 } 1315 1316 bk_da[i]->regdata = kmemdup(&config_data[config_offset], 1317 bk_da[i]->block_size, GFP_KERNEL); 1318 if (!bk_da[i]->regdata) { 1319 *status = -ENOMEM; 1320 goto out; 1321 } 1322 config_offset += bk_da[i]->block_size; 1323 cfg_info->real_nblocks += 1; 1324 } 1325 out: 1326 return cfg_info; 1327 } 1328 1329 static int pcmdev_gain_ctrl_add(struct pcmdevice_priv *pcm_dev, 1330 int dev_no, int ctl_id) 1331 { 1332 struct i2c_adapter *adap = pcm_dev->client->adapter; 1333 struct snd_soc_component *comp = pcm_dev->component; 1334 struct pcmdevice_mixer_control *pcmdev_ctrl; 1335 struct snd_kcontrol_new *pcmdev_controls; 1336 int ret, mix_index = 0, name_id, chn; 1337 unsigned int id = pcm_dev->chip_id; 1338 const int nr_chn = 1339 pcmdev_gain_ctl_info[id][ctl_id].ctrl_array_size; 1340 const char *ctrl_name; 1341 char *name; 1342 1343 if (!nr_chn) { 1344 dev_dbg(pcm_dev->dev, "%s: no gain ctrl for %s\n", __func__, 1345 pcm_dev->dev_name); 1346 return 0; 1347 } 1348 1349 pcmdev_controls = devm_kcalloc(pcm_dev->dev, nr_chn, 1350 sizeof(struct snd_kcontrol_new), GFP_KERNEL); 1351 if (!pcmdev_controls) 1352 return -ENOMEM; 1353 1354 name_id = pcmdev_gain_ctl_info[id][ctl_id].pcmdev_ctrl_name_id; 1355 1356 ctrl_name = pcmdev_ctrl_name[name_id]; 1357 1358 for (chn = 1; chn <= nr_chn; chn++) { 1359 name = devm_kzalloc(pcm_dev->dev, 1360 SNDRV_CTL_ELEM_ID_NAME_MAXLEN, GFP_KERNEL); 1361 if (!name) { 1362 ret = -ENOMEM; 1363 goto out; 1364 } 1365 scnprintf(name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, 1366 ctrl_name, pcm_dev->upper_dev_name, adap->nr, 1367 dev_no, chn); 1368 pcmdev_controls[mix_index].tlv.p = 1369 pcmdev_gain_ctl_info[id][ctl_id].gain; 1370 pcmdev_ctrl = devm_kmemdup(pcm_dev->dev, 1371 &pcmdev_gain_ctl_info[id][ctl_id].pcmdev_ctrl[chn - 1], 1372 sizeof(*pcmdev_ctrl), GFP_KERNEL); 1373 if (!pcmdev_ctrl) { 1374 ret = -ENOMEM; 1375 goto out; 1376 } 1377 pcmdev_ctrl->dev_no = dev_no; 1378 pcmdev_controls[mix_index].private_value = 1379 (unsigned long)pcmdev_ctrl; 1380 pcmdev_controls[mix_index].name = name; 1381 pcmdev_controls[mix_index].access = 1382 SNDRV_CTL_ELEM_ACCESS_TLV_READ | 1383 SNDRV_CTL_ELEM_ACCESS_READWRITE; 1384 pcmdev_controls[mix_index].iface = 1385 SNDRV_CTL_ELEM_IFACE_MIXER; 1386 pcmdev_controls[mix_index].info = pcmdevice_info_volsw; 1387 pcmdev_controls[mix_index].get = 1388 pcmdev_gain_ctl_info[id][ctl_id].get; 1389 pcmdev_controls[mix_index].put = 1390 pcmdev_gain_ctl_info[id][ctl_id].put; 1391 mix_index++; 1392 } 1393 1394 ret = snd_soc_add_component_controls(comp, pcmdev_controls, mix_index); 1395 if (ret) 1396 dev_err(pcm_dev->dev, "%s: add_controls err = %d\n", 1397 __func__, ret); 1398 out: 1399 return ret; 1400 } 1401 1402 static int pcmdev_profile_ctrl_add(struct pcmdevice_priv *pcm_dev) 1403 { 1404 struct snd_soc_component *comp = pcm_dev->component; 1405 struct i2c_adapter *adap = pcm_dev->client->adapter; 1406 struct snd_kcontrol_new *pcmdev_ctrl; 1407 char *name; 1408 int ret; 1409 1410 pcmdev_ctrl = devm_kzalloc(pcm_dev->dev, 1411 sizeof(struct snd_kcontrol_new), GFP_KERNEL); 1412 if (!pcmdev_ctrl) 1413 return -ENOMEM; 1414 1415 /* Create a mixer item for selecting the active profile */ 1416 name = devm_kzalloc(pcm_dev->dev, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, 1417 GFP_KERNEL); 1418 if (!name) 1419 return -ENOMEM; 1420 1421 scnprintf(name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN, 1422 "%s i2c%d Profile id", pcm_dev->upper_dev_name, adap->nr); 1423 pcmdev_ctrl->name = name; 1424 pcmdev_ctrl->iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1425 pcmdev_ctrl->info = pcmdevice_info_profile; 1426 pcmdev_ctrl->get = pcmdevice_get_profile_id; 1427 pcmdev_ctrl->put = pcmdevice_set_profile_id; 1428 1429 ret = snd_soc_add_component_controls(comp, pcmdev_ctrl, 1); 1430 if (ret) 1431 dev_err(pcm_dev->dev, "%s: add_controls err = %d\n", 1432 __func__, ret); 1433 1434 return ret; 1435 } 1436 1437 static void pcmdevice_config_info_remove(void *ctxt) 1438 { 1439 struct pcmdevice_priv *pcm_dev = (struct pcmdevice_priv *) ctxt; 1440 struct pcmdevice_regbin *regbin = &(pcm_dev->regbin); 1441 struct pcmdevice_config_info **cfg_info = regbin->cfg_info; 1442 int i, j; 1443 1444 if (!cfg_info) 1445 return; 1446 for (i = 0; i < regbin->ncfgs; i++) { 1447 if (!cfg_info[i]) 1448 continue; 1449 for (j = 0; j < (int)cfg_info[i]->real_nblocks; j++) { 1450 if (!cfg_info[i]->blk_data[j]) 1451 continue; 1452 kfree(cfg_info[i]->blk_data[j]->regdata); 1453 kfree(cfg_info[i]->blk_data[j]); 1454 } 1455 kfree(cfg_info[i]); 1456 } 1457 kfree(cfg_info); 1458 } 1459 1460 static int pcmdev_regbin_ready(const struct firmware *fmw, void *ctxt) 1461 { 1462 struct pcmdevice_config_info **cfg_info; 1463 struct pcmdevice_priv *pcm_dev = ctxt; 1464 struct pcmdevice_regbin_hdr *fw_hdr; 1465 struct pcmdevice_regbin *regbin; 1466 unsigned int total_config_sz = 0; 1467 int offset = 0, ret = 0, i; 1468 unsigned char *buf; 1469 1470 regbin = &(pcm_dev->regbin); 1471 fw_hdr = &(regbin->fw_hdr); 1472 if (!fmw || !fmw->data) { 1473 dev_err(pcm_dev->dev, "%s: failed to read %s\n", 1474 __func__, pcm_dev->bin_name); 1475 pcm_dev->fw_state = PCMDEVICE_FW_LOAD_FAILED; 1476 ret = -EINVAL; 1477 goto out; 1478 } 1479 buf = (unsigned char *)fmw->data; 1480 1481 fw_hdr->img_sz = get_unaligned_be32(&buf[offset]); 1482 offset += 4; 1483 if (fw_hdr->img_sz != fmw->size) { 1484 dev_err(pcm_dev->dev, "%s: file size(%d) not match %u", 1485 __func__, (int)fmw->size, fw_hdr->img_sz); 1486 pcm_dev->fw_state = PCMDEVICE_FW_LOAD_FAILED; 1487 ret = -EINVAL; 1488 goto out; 1489 } 1490 1491 fw_hdr->checksum = get_unaligned_be32(&buf[offset]); 1492 offset += 4; 1493 fw_hdr->binary_version_num = get_unaligned_be32(&buf[offset]); 1494 if (fw_hdr->binary_version_num < 0x103) { 1495 dev_err(pcm_dev->dev, "%s: bin version 0x%04x is out of date", 1496 __func__, fw_hdr->binary_version_num); 1497 pcm_dev->fw_state = PCMDEVICE_FW_LOAD_FAILED; 1498 ret = -EINVAL; 1499 goto out; 1500 } 1501 offset += 4; 1502 fw_hdr->drv_fw_version = get_unaligned_be32(&buf[offset]); 1503 offset += 8; 1504 fw_hdr->plat_type = buf[offset]; 1505 offset += 1; 1506 fw_hdr->dev_family = buf[offset]; 1507 offset += 1; 1508 fw_hdr->reserve = buf[offset]; 1509 offset += 1; 1510 fw_hdr->ndev = buf[offset]; 1511 offset += 1; 1512 if (fw_hdr->ndev != pcm_dev->ndev) { 1513 dev_err(pcm_dev->dev, "%s: invalid ndev(%u)\n", __func__, 1514 fw_hdr->ndev); 1515 pcm_dev->fw_state = PCMDEVICE_FW_LOAD_FAILED; 1516 ret = -EINVAL; 1517 goto out; 1518 } 1519 1520 if (offset + PCMDEVICE_MAX_REGBIN_DEVICES > fw_hdr->img_sz) { 1521 dev_err(pcm_dev->dev, "%s: devs out of boundary!\n", __func__); 1522 pcm_dev->fw_state = PCMDEVICE_FW_LOAD_FAILED; 1523 ret = -EINVAL; 1524 goto out; 1525 } 1526 1527 for (i = 0; i < PCMDEVICE_MAX_REGBIN_DEVICES; i++, offset++) 1528 fw_hdr->devs[i] = buf[offset]; 1529 1530 fw_hdr->nconfig = get_unaligned_be32(&buf[offset]); 1531 offset += 4; 1532 1533 for (i = 0; i < PCMDEVICE_CONFIG_SUM; i++) { 1534 fw_hdr->config_size[i] = get_unaligned_be32(&buf[offset]); 1535 offset += 4; 1536 total_config_sz += fw_hdr->config_size[i]; 1537 } 1538 1539 if (fw_hdr->img_sz - total_config_sz != (unsigned int)offset) { 1540 dev_err(pcm_dev->dev, "%s: bin file error!\n", __func__); 1541 pcm_dev->fw_state = PCMDEVICE_FW_LOAD_FAILED; 1542 ret = -EINVAL; 1543 goto out; 1544 } 1545 cfg_info = kzalloc_objs(*cfg_info, fw_hdr->nconfig); 1546 if (!cfg_info) { 1547 pcm_dev->fw_state = PCMDEVICE_FW_LOAD_FAILED; 1548 ret = -ENOMEM; 1549 goto out; 1550 } 1551 regbin->cfg_info = cfg_info; 1552 regbin->ncfgs = 0; 1553 for (i = 0; i < (int)fw_hdr->nconfig; i++) { 1554 cfg_info[i] = pcmdevice_add_config(ctxt, &buf[offset], 1555 fw_hdr->config_size[i], &ret); 1556 if (ret) { 1557 /* In case the bin file is partially destroyed. */ 1558 if (regbin->ncfgs == 0) 1559 pcm_dev->fw_state = PCMDEVICE_FW_LOAD_FAILED; 1560 break; 1561 } 1562 offset += (int)fw_hdr->config_size[i]; 1563 regbin->ncfgs += 1; 1564 } 1565 1566 out: 1567 if (pcm_dev->fw_state == PCMDEVICE_FW_LOAD_FAILED) { 1568 dev_err(pcm_dev->dev, 1569 "%s: remove config due to fw load error!\n", __func__); 1570 pcmdevice_config_info_remove(pcm_dev); 1571 } 1572 1573 return ret; 1574 } 1575 1576 static int pcmdevice_comp_probe(struct snd_soc_component *comp) 1577 { 1578 struct pcmdevice_priv *pcm_dev = snd_soc_component_get_drvdata(comp); 1579 struct i2c_adapter *adap = pcm_dev->client->adapter; 1580 const struct firmware *fw_entry = NULL; 1581 int ret, i, j; 1582 1583 mutex_lock(&pcm_dev->codec_lock); 1584 1585 pcm_dev->component = comp; 1586 1587 for (i = 0; i < pcm_dev->ndev; i++) { 1588 for (j = 0; j < 2; j++) { 1589 ret = pcmdev_gain_ctrl_add(pcm_dev, i, j); 1590 if (ret < 0) 1591 goto out; 1592 } 1593 } 1594 1595 if (comp->name_prefix) { 1596 /* There's name_prefix defined in DTS. Bin file name will be 1597 * name_prefix.bin stores the firmware including register 1598 * setting and params for different filters inside chips, it 1599 * must be copied into firmware folder. The same types of 1600 * pcmdevices sitting on the same i2c bus will be aggregated as 1601 * one single codec, all of them share the same bin file. 1602 */ 1603 scnprintf(pcm_dev->bin_name, PCMDEVICE_BIN_FILENAME_LEN, 1604 "%s.bin", comp->name_prefix); 1605 } else { 1606 /* There's NO name_prefix defined in DTS. Bin file name will be 1607 * device-name[defined in pcmdevice_i2c_id]-i2c-bus_id 1608 * [0,1,...,N]-sum[1,...,4]dev.bin stores the firmware 1609 * including register setting and params for different filters 1610 * inside chips, it must be copied into firmware folder. The 1611 * same types of pcmdevices sitting on the same i2c bus will be 1612 * aggregated as one single codec, all of them share the same 1613 * bin file. 1614 */ 1615 scnprintf(pcm_dev->bin_name, PCMDEVICE_BIN_FILENAME_LEN, 1616 "%s-i2c-%d-%udev.bin", pcm_dev->dev_name, adap->nr, 1617 pcm_dev->ndev); 1618 } 1619 1620 ret = request_firmware(&fw_entry, pcm_dev->bin_name, pcm_dev->dev); 1621 if (ret) { 1622 dev_err(pcm_dev->dev, "%s: request %s err = %d\n", __func__, 1623 pcm_dev->bin_name, ret); 1624 goto out; 1625 } 1626 1627 ret = pcmdev_regbin_ready(fw_entry, pcm_dev); 1628 if (ret) { 1629 dev_err(pcm_dev->dev, "%s: %s parse err = %d\n", __func__, 1630 pcm_dev->bin_name, ret); 1631 goto out; 1632 } 1633 ret = pcmdev_profile_ctrl_add(pcm_dev); 1634 out: 1635 release_firmware(fw_entry); 1636 1637 mutex_unlock(&pcm_dev->codec_lock); 1638 return ret; 1639 } 1640 1641 1642 static void pcmdevice_comp_remove(struct snd_soc_component *codec) 1643 { 1644 struct pcmdevice_priv *pcm_dev = snd_soc_component_get_drvdata(codec); 1645 1646 if (!pcm_dev) 1647 return; 1648 mutex_lock(&pcm_dev->codec_lock); 1649 pcmdevice_config_info_remove(pcm_dev); 1650 mutex_unlock(&pcm_dev->codec_lock); 1651 } 1652 1653 static const struct snd_soc_dapm_widget pcmdevice_dapm_widgets[] = { 1654 SND_SOC_DAPM_AIF_IN("ASI", "ASI Playback", 0, SND_SOC_NOPM, 0, 0), 1655 SND_SOC_DAPM_AIF_OUT("ASI1 OUT", "ASI1 Capture", 1656 0, SND_SOC_NOPM, 0, 0), 1657 SND_SOC_DAPM_OUTPUT("OUT"), 1658 SND_SOC_DAPM_INPUT("MIC"), 1659 }; 1660 1661 static const struct snd_soc_dapm_route pcmdevice_audio_map[] = { 1662 {"OUT", NULL, "ASI"}, 1663 {"ASI1 OUT", NULL, "MIC"}, 1664 }; 1665 1666 static const struct snd_soc_component_driver 1667 soc_codec_driver_pcmdevice = { 1668 .probe = pcmdevice_comp_probe, 1669 .remove = pcmdevice_comp_remove, 1670 .dapm_widgets = pcmdevice_dapm_widgets, 1671 .num_dapm_widgets = ARRAY_SIZE(pcmdevice_dapm_widgets), 1672 .dapm_routes = pcmdevice_audio_map, 1673 .num_dapm_routes = ARRAY_SIZE(pcmdevice_audio_map), 1674 .suspend_bias_off = 1, 1675 .idle_bias_on = 0, 1676 .use_pmdown_time = 1, 1677 .endianness = 1, 1678 }; 1679 1680 static int pcmdev_single_byte_wr(struct pcmdevice_priv *pcm_dev, 1681 unsigned char *data, int devn, int sublocksize) 1682 { 1683 unsigned short len = get_unaligned_be16(&data[2]); 1684 int offset = 2; 1685 int i, ret; 1686 1687 offset += 2; 1688 if (offset + 4 * len > sublocksize) { 1689 dev_err(pcm_dev->dev, "%s: dev-%d byt wr out of boundary\n", 1690 __func__, devn); 1691 return -EINVAL; 1692 } 1693 1694 for (i = 0; i < len; i++) { 1695 ret = pcmdev_dev_write(pcm_dev, devn, 1696 PCMDEVICE_REG(data[offset + 1], data[offset + 2]), 1697 data[offset + 3]); 1698 /* skip this error for next operation or next devices */ 1699 if (ret < 0) 1700 dev_err(pcm_dev->dev, "%s: dev-%d single write err\n", 1701 __func__, devn); 1702 1703 offset += 4; 1704 } 1705 1706 return offset; 1707 } 1708 1709 static int pcmdev_burst_wr(struct pcmdevice_priv *pcm_dev, 1710 unsigned char *data, int devn, int sublocksize) 1711 { 1712 unsigned short len = get_unaligned_be16(&data[2]); 1713 int offset = 2; 1714 int ret; 1715 1716 offset += 2; 1717 if (offset + 4 + len > sublocksize) { 1718 dev_err(pcm_dev->dev, "%s: dev-%d burst Out of boundary\n", 1719 __func__, devn); 1720 return -EINVAL; 1721 } 1722 if (len % 4) { 1723 dev_err(pcm_dev->dev, "%s: dev-%d bst-len(%u) not div by 4\n", 1724 __func__, devn, len); 1725 return -EINVAL; 1726 } 1727 ret = pcmdev_dev_bulk_write(pcm_dev, devn, 1728 PCMDEVICE_REG(data[offset + 1], data[offset + 2]), 1729 &(data[offset + 4]), len); 1730 /* skip this error for next devices */ 1731 if (ret < 0) 1732 dev_err(pcm_dev->dev, "%s: dev-%d bulk_write err = %d\n", 1733 __func__, devn, ret); 1734 1735 offset += (len + 4); 1736 1737 return offset; 1738 } 1739 1740 static int pcmdev_delay(struct pcmdevice_priv *pcm_dev, 1741 unsigned char *data, int devn, int sublocksize) 1742 { 1743 unsigned int delay_time = 0; 1744 int offset = 2; 1745 1746 if (offset + 2 > sublocksize) { 1747 dev_err(pcm_dev->dev, "%s: dev-%d delay out of boundary\n", 1748 __func__, devn); 1749 return -EINVAL; 1750 } 1751 delay_time = get_unaligned_be16(&data[2]) * 1000; 1752 usleep_range(delay_time, delay_time + 50); 1753 offset += 2; 1754 1755 return offset; 1756 } 1757 1758 static int pcmdev_bits_wr(struct pcmdevice_priv *pcm_dev, 1759 unsigned char *data, int devn, int sublocksize) 1760 { 1761 int offset = 2; 1762 int ret; 1763 1764 if (offset + 6 > sublocksize) { 1765 dev_err(pcm_dev->dev, "%s: dev-%d bit write out of memory\n", 1766 __func__, devn); 1767 return -EINVAL; 1768 } 1769 ret = pcmdev_dev_update_bits(pcm_dev, devn, 1770 PCMDEVICE_REG(data[offset + 3], data[offset + 4]), 1771 data[offset + 1], data[offset + 5]); 1772 /* skip this error for next devices */ 1773 if (ret < 0) 1774 dev_err(pcm_dev->dev, "%s: dev-%d update_bits err = %d\n", 1775 __func__, devn, ret); 1776 1777 offset += 6; 1778 1779 return offset; 1780 } 1781 1782 static int pcmdevice_process_block(void *ctxt, unsigned char *data, 1783 unsigned char dev_idx, int sublocksize) 1784 { 1785 struct pcmdevice_priv *pcm_dev = (struct pcmdevice_priv *)ctxt; 1786 int devn, dev_end, ret = 0; 1787 unsigned char subblk_typ = data[1]; 1788 1789 if (dev_idx) { 1790 devn = dev_idx - 1; 1791 dev_end = dev_idx; 1792 } else { 1793 devn = 0; 1794 dev_end = pcm_dev->ndev; 1795 } 1796 1797 /* loop in case of several devices sharing the same sub-block */ 1798 for (; devn < dev_end; devn++) { 1799 switch (subblk_typ) { 1800 case PCMDEVICE_CMD_SING_W: 1801 ret = pcmdev_single_byte_wr(pcm_dev, data, devn, sublocksize); 1802 break; 1803 case PCMDEVICE_CMD_BURST: 1804 ret = pcmdev_burst_wr(pcm_dev, data, devn, sublocksize); 1805 break; 1806 case PCMDEVICE_CMD_DELAY: 1807 ret = pcmdev_delay(pcm_dev, data, devn, sublocksize); 1808 break; 1809 case PCMDEVICE_CMD_FIELD_W: 1810 ret = pcmdev_bits_wr(pcm_dev, data, devn, sublocksize); 1811 break; 1812 default: 1813 break; 1814 } 1815 /* 1816 * In case of sub-block error, break the loop for the rest of 1817 * devices. 1818 */ 1819 if (ret < 0) 1820 break; 1821 } 1822 1823 return ret; 1824 } 1825 1826 static void pcmdevice_select_cfg_blk(void *ctxt, int conf_no, 1827 unsigned char block_type) 1828 { 1829 struct pcmdevice_priv *pcm_dev = (struct pcmdevice_priv *)ctxt; 1830 struct pcmdevice_regbin *regbin = &(pcm_dev->regbin); 1831 struct pcmdevice_config_info **cfg_info = regbin->cfg_info; 1832 struct pcmdevice_block_data **blk_data; 1833 int j, k; 1834 1835 if (conf_no >= regbin->ncfgs || conf_no < 0 || NULL == cfg_info) { 1836 dev_err(pcm_dev->dev, "%s: conf_no should be less than %u\n", 1837 __func__, regbin->ncfgs); 1838 goto out; 1839 } 1840 blk_data = cfg_info[conf_no]->blk_data; 1841 1842 for (j = 0; j < (int)cfg_info[conf_no]->real_nblocks; j++) { 1843 unsigned int length = 0, ret; 1844 1845 if (block_type > 5 || block_type < 2) { 1846 dev_err(pcm_dev->dev, 1847 "%s: block_type should be out of range\n", 1848 __func__); 1849 goto out; 1850 } 1851 if (block_type != blk_data[j]->block_type) 1852 continue; 1853 1854 for (k = 0; k < (int)blk_data[j]->n_subblks; k++) { 1855 ret = pcmdevice_process_block(pcm_dev, 1856 blk_data[j]->regdata + length, 1857 blk_data[j]->dev_idx, 1858 blk_data[j]->block_size - length); 1859 length += ret; 1860 if (blk_data[j]->block_size < length) { 1861 dev_err(pcm_dev->dev, 1862 "%s: %u %u out of boundary\n", 1863 __func__, length, 1864 blk_data[j]->block_size); 1865 break; 1866 } 1867 } 1868 if (length != blk_data[j]->block_size) 1869 dev_err(pcm_dev->dev, "%s: %u %u size is not same\n", 1870 __func__, length, blk_data[j]->block_size); 1871 } 1872 1873 out: 1874 return; 1875 } 1876 1877 static int pcmdevice_mute(struct snd_soc_dai *dai, int mute, int stream) 1878 { 1879 struct snd_soc_component *codec = dai->component; 1880 struct pcmdevice_priv *pcm_dev = snd_soc_component_get_drvdata(codec); 1881 unsigned char block_type; 1882 1883 if (pcm_dev->fw_state == PCMDEVICE_FW_LOAD_FAILED) { 1884 dev_err(pcm_dev->dev, "%s: bin file not loaded\n", __func__); 1885 return -EINVAL; 1886 } 1887 1888 if (mute) 1889 block_type = PCMDEVICE_BIN_BLK_PRE_SHUTDOWN; 1890 else 1891 block_type = PCMDEVICE_BIN_BLK_PRE_POWER_UP; 1892 1893 mutex_lock(&pcm_dev->codec_lock); 1894 pcmdevice_select_cfg_blk(pcm_dev, pcm_dev->cur_conf, block_type); 1895 mutex_unlock(&pcm_dev->codec_lock); 1896 return 0; 1897 } 1898 1899 static int pcmdevice_hw_params(struct snd_pcm_substream *substream, 1900 struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) 1901 { 1902 struct pcmdevice_priv *pcm_dev = snd_soc_dai_get_drvdata(dai); 1903 unsigned int fsrate; 1904 unsigned int slot_width; 1905 int bclk_rate; 1906 int ret = 0; 1907 1908 fsrate = params_rate(params); 1909 switch (fsrate) { 1910 case 48000: 1911 break; 1912 case 44100: 1913 break; 1914 default: 1915 dev_err(pcm_dev->dev, "%s: incorrect sample rate = %u\n", 1916 __func__, fsrate); 1917 ret = -EINVAL; 1918 goto out; 1919 } 1920 1921 slot_width = params_width(params); 1922 switch (slot_width) { 1923 case 16: 1924 break; 1925 case 20: 1926 break; 1927 case 24: 1928 break; 1929 case 32: 1930 break; 1931 default: 1932 dev_err(pcm_dev->dev, "%s: incorrect slot width = %u\n", 1933 __func__, slot_width); 1934 ret = -EINVAL; 1935 goto out; 1936 } 1937 1938 bclk_rate = snd_soc_params_to_bclk(params); 1939 if (bclk_rate < 0) { 1940 dev_err(pcm_dev->dev, "%s: incorrect bclk rate = %d\n", 1941 __func__, bclk_rate); 1942 ret = bclk_rate; 1943 } 1944 1945 out: 1946 return ret; 1947 } 1948 1949 static const struct snd_soc_dai_ops pcmdevice_dai_ops = { 1950 .mute_stream = pcmdevice_mute, 1951 .hw_params = pcmdevice_hw_params, 1952 }; 1953 1954 static struct snd_soc_dai_driver pcmdevice_dai_driver[] = { 1955 { 1956 .name = "pcmdevice-codec", 1957 .capture = { 1958 .stream_name = "Capture", 1959 .channels_min = 2, 1960 .channels_max = PCMDEVICE_MAX_CHANNELS, 1961 .rates = PCMDEVICE_RATES, 1962 .formats = PCMDEVICE_FORMATS, 1963 }, 1964 .playback = { 1965 .stream_name = "Playback", 1966 .channels_min = 2, 1967 .channels_max = PCMDEVICE_MAX_CHANNELS, 1968 .rates = PCMDEVICE_RATES, 1969 .formats = PCMDEVICE_FORMATS, 1970 }, 1971 .ops = &pcmdevice_dai_ops, 1972 .symmetric_rate = 1, 1973 } 1974 }; 1975 1976 #ifdef CONFIG_OF 1977 static const struct of_device_id pcmdevice_of_match[] = { 1978 { .compatible = "ti,adc3120" }, 1979 { .compatible = "ti,adc5120" }, 1980 { .compatible = "ti,adc6120" }, 1981 { .compatible = "ti,dix4192" }, 1982 { .compatible = "ti,pcm1690" }, 1983 { .compatible = "ti,pcm3120" }, 1984 { .compatible = "ti,pcm3140" }, 1985 { .compatible = "ti,pcm5120" }, 1986 { .compatible = "ti,pcm5140" }, 1987 { .compatible = "ti,pcm6120" }, 1988 { .compatible = "ti,pcm6140" }, 1989 { .compatible = "ti,pcm6240" }, 1990 { .compatible = "ti,pcm6260" }, 1991 { .compatible = "ti,pcm9211" }, 1992 { .compatible = "ti,pcmd3140" }, 1993 { .compatible = "ti,pcmd3180" }, 1994 { .compatible = "ti,pcmd512x" }, 1995 { .compatible = "ti,taa5212" }, 1996 { .compatible = "ti,taa5412" }, 1997 { .compatible = "ti,tad5212" }, 1998 { .compatible = "ti,tad5412" }, 1999 {}, 2000 }; 2001 MODULE_DEVICE_TABLE(of, pcmdevice_of_match); 2002 #endif 2003 2004 static const struct regmap_range_cfg pcmdevice_ranges[] = { 2005 { 2006 .range_min = 0, 2007 .range_max = 256 * 128, 2008 .selector_reg = PCMDEVICE_PAGE_SELECT, 2009 .selector_mask = 0xff, 2010 .selector_shift = 0, 2011 .window_start = 0, 2012 .window_len = 128, 2013 }, 2014 }; 2015 2016 static const struct regmap_config pcmdevice_i2c_regmap = { 2017 .reg_bits = 8, 2018 .val_bits = 8, 2019 .cache_type = REGCACHE_MAPLE, 2020 .ranges = pcmdevice_ranges, 2021 .num_ranges = ARRAY_SIZE(pcmdevice_ranges), 2022 .max_register = 256 * 128, 2023 }; 2024 2025 static void pcmdevice_remove(struct pcmdevice_priv *pcm_dev) 2026 { 2027 if (pcm_dev->irq) 2028 free_irq(pcm_dev->irq, pcm_dev); 2029 mutex_destroy(&pcm_dev->codec_lock); 2030 } 2031 2032 static char *str_to_upper(char *str) 2033 { 2034 char *orig = str; 2035 2036 if (!str) 2037 return NULL; 2038 2039 while (*str) { 2040 *str = toupper(*str); 2041 str++; 2042 } 2043 2044 return orig; 2045 } 2046 2047 static int pcmdevice_i2c_probe(struct i2c_client *i2c) 2048 { 2049 struct pcmdevice_priv *pcm_dev; 2050 struct device_node *np; 2051 unsigned int dev_addrs[PCMDEVICE_MAX_I2C_DEVICES]; 2052 int ret = 0, i = 0, ndev = 0; 2053 2054 pcm_dev = devm_kzalloc(&i2c->dev, sizeof(*pcm_dev), GFP_KERNEL); 2055 if (!pcm_dev) 2056 return -ENOMEM; 2057 2058 pcm_dev->chip_id = (uintptr_t)i2c_get_match_data(i2c); 2059 2060 pcm_dev->dev = &i2c->dev; 2061 pcm_dev->client = i2c; 2062 2063 if (pcm_dev->chip_id >= MAX_DEVICE) 2064 pcm_dev->chip_id = 0; 2065 2066 strscpy(pcm_dev->dev_name, pcmdevice_i2c_id[pcm_dev->chip_id].name, 2067 sizeof(pcm_dev->dev_name)); 2068 2069 strscpy(pcm_dev->upper_dev_name, 2070 pcmdevice_i2c_id[pcm_dev->chip_id].name, 2071 sizeof(pcm_dev->upper_dev_name)); 2072 2073 str_to_upper(pcm_dev->upper_dev_name); 2074 2075 pcm_dev->regmap = devm_regmap_init_i2c(i2c, &pcmdevice_i2c_regmap); 2076 if (IS_ERR(pcm_dev->regmap)) { 2077 ret = PTR_ERR(pcm_dev->regmap); 2078 dev_err(&i2c->dev, "%s: failed to allocate register map: %d\n", 2079 __func__, ret); 2080 goto out; 2081 } 2082 2083 i2c_set_clientdata(i2c, pcm_dev); 2084 mutex_init(&pcm_dev->codec_lock); 2085 np = pcm_dev->dev->of_node; 2086 2087 if (IS_ENABLED(CONFIG_OF)) { 2088 u64 addr; 2089 2090 for (i = 0; i < PCMDEVICE_MAX_I2C_DEVICES; i++) { 2091 if (of_property_read_reg(np, i, &addr, NULL)) 2092 break; 2093 dev_addrs[ndev++] = addr; 2094 } 2095 } else { 2096 ndev = 1; 2097 dev_addrs[0] = i2c->addr; 2098 } 2099 pcm_dev->irq = of_irq_get(np, 0); 2100 2101 for (i = 0; i < ndev; i++) 2102 pcm_dev->addr[i] = dev_addrs[i]; 2103 2104 pcm_dev->ndev = ndev; 2105 2106 pcm_dev->hw_rst = devm_gpiod_get_optional(&i2c->dev, 2107 "reset-gpios", GPIOD_OUT_HIGH); 2108 /* No reset GPIO, no side-effect */ 2109 if (IS_ERR(pcm_dev->hw_rst)) { 2110 if (pcm_dev->chip_id == PCM9211 || pcm_dev->chip_id == PCM1690) 2111 pcm9211_sw_rst(pcm_dev); 2112 else 2113 pcmdevice_sw_rst(pcm_dev); 2114 } else { 2115 gpiod_set_value_cansleep(pcm_dev->hw_rst, 0); 2116 usleep_range(500, 1000); 2117 gpiod_set_value_cansleep(pcm_dev->hw_rst, 1); 2118 } 2119 2120 if (pcm_dev->chip_id == PCM1690) 2121 goto skip_interrupt; 2122 if (pcm_dev->irq) { 2123 dev_dbg(pcm_dev->dev, "irq = %d", pcm_dev->irq); 2124 } else 2125 dev_err(pcm_dev->dev, "No irq provided\n"); 2126 2127 skip_interrupt: 2128 ret = devm_snd_soc_register_component(&i2c->dev, 2129 &soc_codec_driver_pcmdevice, pcmdevice_dai_driver, 2130 ARRAY_SIZE(pcmdevice_dai_driver)); 2131 if (ret < 0) 2132 dev_err(&i2c->dev, "probe register comp failed %d\n", ret); 2133 2134 out: 2135 if (ret < 0) 2136 pcmdevice_remove(pcm_dev); 2137 return ret; 2138 } 2139 2140 static void pcmdevice_i2c_remove(struct i2c_client *i2c) 2141 { 2142 struct pcmdevice_priv *pcm_dev = i2c_get_clientdata(i2c); 2143 2144 pcmdevice_remove(pcm_dev); 2145 } 2146 2147 static struct i2c_driver pcmdevice_i2c_driver = { 2148 .driver = { 2149 .name = "pcmdevice-codec", 2150 .of_match_table = of_match_ptr(pcmdevice_of_match), 2151 }, 2152 .probe = pcmdevice_i2c_probe, 2153 .remove = pcmdevice_i2c_remove, 2154 .id_table = pcmdevice_i2c_id, 2155 }; 2156 module_i2c_driver(pcmdevice_i2c_driver); 2157 2158 MODULE_AUTHOR("Shenghao Ding <shenghao-ding@ti.com>"); 2159 MODULE_DESCRIPTION("ASoC PCM6240 Family Audio ADC/DAC Driver"); 2160 MODULE_LICENSE("GPL"); 2161