1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // fs210x.c -- Driver for the FS2104/5S Audio Amplifier 4 // 5 // Copyright (C) 2016-2025 Shanghai FourSemi Semiconductor Co.,Ltd. 6 7 #include <linux/clk.h> 8 #include <linux/delay.h> 9 #include <linux/i2c.h> 10 #include <linux/gpio/consumer.h> 11 #include <linux/module.h> 12 #include <linux/mutex.h> 13 #include <linux/of.h> 14 #include <linux/regmap.h> 15 #include <linux/regulator/consumer.h> 16 #include <linux/workqueue.h> 17 #include <sound/soc.h> 18 #include <sound/tlv.h> 19 20 #include "fs210x.h" 21 #include "fs-amp-lib.h" 22 23 #define FS210X_DEFAULT_FWM_NAME "fs210x_fwm.bin" 24 #define FS210X_DEFAULT_DAI_NAME "fs210x-aif" 25 #define FS2105S_DEVICE_ID 0x20 /* FS2105S */ 26 #define FS210X_DEVICE_ID 0x45 /* FS2104 */ 27 #define FS210X_REG_MAX 0xF8 28 #define FS210X_INIT_SCENE 0 29 #define FS210X_DEFAULT_SCENE 1 30 #define FS210X_START_DELAY_MS 5 31 #define FS210X_FAULT_CHECK_INTERVAL_MS 2000 32 #define FS2105S_RATES (SNDRV_PCM_RATE_32000 | \ 33 SNDRV_PCM_RATE_44100 | \ 34 SNDRV_PCM_RATE_48000 | \ 35 SNDRV_PCM_RATE_88200 | \ 36 SNDRV_PCM_RATE_96000) 37 #define FS210X_RATES (SNDRV_PCM_RATE_16000 | FS2105S_RATES) 38 #define FS210X_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | \ 39 SNDRV_PCM_FMTBIT_S24_LE | \ 40 SNDRV_PCM_FMTBIT_S24_3LE | \ 41 SNDRV_PCM_FMTBIT_S32_LE) 42 #define FS210X_NUM_SUPPLIES ARRAY_SIZE(fs210x_supply_names) 43 44 static const char *const fs210x_supply_names[] = { 45 "pvdd", 46 "dvdd", 47 }; 48 49 struct fs210x_platform_data { 50 const char *fwm_name; 51 }; 52 53 struct fs210x_priv { 54 struct i2c_client *i2c; 55 struct device *dev; 56 struct regmap *regmap; 57 struct fs210x_platform_data pdata; 58 struct regulator_bulk_data supplies[FS210X_NUM_SUPPLIES]; 59 struct gpio_desc *gpio_sdz; 60 struct delayed_work start_work; 61 struct delayed_work fault_check_work; 62 struct fs_amp_lib amp_lib; 63 const struct fs_amp_scene *cur_scene; 64 struct clk *clk_bclk; 65 /* 66 * @lock: Mutex ensuring exclusive access for critical device operations 67 * 68 * This lock serializes access between the following actions: 69 * - Device initialization procedures(probe) 70 * - Enable/disable device(DAPM event) 71 * - Suspend/resume device(PM) 72 * - Runtime scene switching(control) 73 * - Scheduling/execution of delayed works items(delayed works) 74 */ 75 struct mutex lock; 76 unsigned int check_interval_ms; 77 unsigned int bclk; 78 unsigned int srate; 79 int scene_id; 80 u16 devid; 81 bool is_inited; 82 bool is_suspended; 83 bool is_bclk_on; 84 bool is_playing; 85 }; 86 87 static const unsigned int fs2105s_rates[] = { 88 32000, 44100, 48000, 88200, 96000 89 }; 90 91 static const struct snd_pcm_hw_constraint_list fs2105s_constraints = { 92 .count = ARRAY_SIZE(fs2105s_rates), 93 .list = fs2105s_rates, 94 }; 95 96 static const unsigned int fs210x_rates[] = { 97 16000, 32000, 44100, 48000, 88200, 96000 98 }; 99 100 static const struct snd_pcm_hw_constraint_list fs210x_constraints = { 101 .count = ARRAY_SIZE(fs210x_rates), 102 .list = fs210x_rates, 103 }; 104 105 static const struct fs_pll_div fs210x_pll_div[] = { 106 /* bclk, pll1, pll2, pll3 */ 107 { 512000, 0x006C, 0x0120, 0x0001 }, 108 { 768000, 0x016C, 0x00C0, 0x0001 }, 109 { 1024000, 0x016C, 0x0090, 0x0001 }, 110 { 1536000, 0x016C, 0x0060, 0x0001 }, 111 { 2048000, 0x016C, 0x0090, 0x0002 }, 112 { 2304000, 0x016C, 0x0080, 0x0002 }, 113 { 3072000, 0x016C, 0x0090, 0x0003 }, 114 { 4096000, 0x016C, 0x0090, 0x0004 }, 115 { 4608000, 0x016C, 0x0080, 0x0004 }, 116 { 6144000, 0x016C, 0x0090, 0x0006 }, 117 { 8192000, 0x016C, 0x0090, 0x0008 }, 118 { 9216000, 0x016C, 0x0090, 0x0009 }, 119 { 12288000, 0x016C, 0x0090, 0x000C }, 120 { 16384000, 0x016C, 0x0090, 0x0010 }, 121 { 18432000, 0x016C, 0x0090, 0x0012 }, 122 { 24576000, 0x016C, 0x0090, 0x0018 }, 123 { 1411200, 0x016C, 0x0060, 0x0001 }, 124 { 2116800, 0x016C, 0x0080, 0x0002 }, 125 { 2822400, 0x016C, 0x0090, 0x0003 }, 126 { 4233600, 0x016C, 0x0080, 0x0004 }, 127 { 5644800, 0x016C, 0x0090, 0x0006 }, 128 { 8467200, 0x016C, 0x0090, 0x0009 }, 129 { 11289600, 0x016C, 0x0090, 0x000C }, 130 { 16934400, 0x016C, 0x0090, 0x0012 }, 131 { 22579200, 0x016C, 0x0090, 0x0018 }, 132 { 2000000, 0x017C, 0x0093, 0x0002 }, 133 }; 134 135 static int fs210x_bclk_set(struct fs210x_priv *fs210x, bool on) 136 { 137 int ret = 0; 138 139 if (!fs210x || !fs210x->dev) 140 return -EINVAL; 141 142 if ((fs210x->is_bclk_on ^ on) == 0) 143 return 0; 144 145 if (on) { 146 clk_set_rate(fs210x->clk_bclk, fs210x->bclk); 147 ret = clk_prepare_enable(fs210x->clk_bclk); 148 fs210x->is_bclk_on = true; 149 fsleep(2000); /* >= 2ms */ 150 } else { 151 clk_disable_unprepare(fs210x->clk_bclk); 152 fs210x->is_bclk_on = false; 153 } 154 155 return ret; 156 } 157 158 static int fs210x_reg_write(struct fs210x_priv *fs210x, 159 u8 reg, u16 val) 160 { 161 int ret; 162 163 ret = regmap_write(fs210x->regmap, reg, val); 164 if (ret) { 165 dev_err(fs210x->dev, "Failed to write %02Xh: %d\n", reg, ret); 166 return ret; 167 } 168 169 return 0; 170 } 171 172 static int fs210x_reg_read(struct fs210x_priv *fs210x, 173 u8 reg, u16 *pval) 174 { 175 unsigned int val; 176 int ret; 177 178 ret = regmap_read(fs210x->regmap, reg, &val); 179 if (ret) { 180 dev_err(fs210x->dev, "Failed to read %02Xh: %d\n", reg, ret); 181 return ret; 182 } 183 184 *pval = (u16)val; 185 186 return 0; 187 } 188 189 static int fs210x_reg_update_bits(struct fs210x_priv *fs210x, 190 u8 reg, u16 mask, u16 val) 191 { 192 int ret; 193 194 ret = regmap_update_bits(fs210x->regmap, reg, mask, val); 195 if (ret) { 196 dev_err(fs210x->dev, "Failed to update %02Xh: %d\n", reg, ret); 197 return ret; 198 } 199 200 return 0; 201 } 202 203 static int fs210x_reg_bulk_write(struct fs210x_priv *fs210x, 204 u8 reg, const void *val, u32 size) 205 { 206 int ret; 207 208 ret = regmap_bulk_write(fs210x->regmap, reg, val, size / 2); 209 if (ret) { 210 dev_err(fs210x->dev, "Failed to bulk write %02Xh: %d\n", 211 reg, ret); 212 return ret; 213 } 214 215 return 0; 216 } 217 218 static inline int fs210x_write_reg_val(struct fs210x_priv *fs210x, 219 const struct fs_reg_val *regv) 220 { 221 return fs210x_reg_write(fs210x, regv->reg, regv->val); 222 } 223 224 static inline int fs210x_write_reg_bits(struct fs210x_priv *fs210x, 225 const struct fs_reg_bits *regu) 226 { 227 return fs210x_reg_update_bits(fs210x, 228 regu->reg, 229 regu->mask, 230 regu->val); 231 } 232 233 static inline int fs210x_set_cmd_pkg(struct fs210x_priv *fs210x, 234 const struct fs_cmd_pkg *pkg, 235 unsigned int *offset) 236 { 237 int delay_us; 238 239 if (pkg->cmd >= 0x00 && pkg->cmd <= FS210X_REG_MAX) { 240 *offset = sizeof(pkg->regv); 241 return fs210x_write_reg_val(fs210x, &pkg->regv); 242 } else if (pkg->cmd == FS_CMD_UPDATE) { 243 *offset = sizeof(pkg->regb); 244 return fs210x_write_reg_bits(fs210x, &pkg->regb); 245 } else if (pkg->cmd == FS_CMD_DELAY) { 246 if (pkg->regv.val > FS_CMD_DELAY_MS_MAX) 247 return -EOPNOTSUPP; 248 delay_us = pkg->regv.val * 1000; /* ms -> us */ 249 fsleep(delay_us); 250 *offset = sizeof(pkg->regv); 251 return 0; 252 } 253 254 dev_err(fs210x->dev, "Invalid pkg cmd: %d\n", pkg->cmd); 255 256 return -EOPNOTSUPP; 257 } 258 259 static int fs210x_reg_write_table(struct fs210x_priv *fs210x, 260 const struct fs_reg_table *reg) 261 { 262 const struct fs_cmd_pkg *pkg; 263 unsigned int index, offset; 264 int ret; 265 266 if (!fs210x || !fs210x->dev) 267 return -EINVAL; 268 269 if (!reg || reg->size == 0) 270 return -EFAULT; 271 272 for (index = 0; index < reg->size; index += offset) { 273 pkg = (struct fs_cmd_pkg *)(reg->buf + index); 274 ret = fs210x_set_cmd_pkg(fs210x, pkg, &offset); 275 if (ret) { 276 dev_err(fs210x->dev, "Failed to set cmd pkg: %02X-%d\n", 277 pkg->cmd, ret); 278 return ret; 279 } 280 } 281 282 if (index != reg->size) { 283 dev_err(fs210x->dev, "Invalid reg table size: %d-%d\n", 284 index, reg->size); 285 return -EFAULT; 286 } 287 288 return 0; 289 } 290 291 static int fs210x_dev_play(struct fs210x_priv *fs210x) 292 { 293 int ret; 294 295 if (!fs210x->is_inited) 296 return -EFAULT; 297 298 if (fs210x->is_playing) 299 return 0; 300 301 ret = fs210x_reg_write(fs210x, FS210X_11H_SYSCTRL, 302 FS210X_11H_DPS_PLAY); 303 if (!ret) 304 fs210x->is_playing = true; 305 306 fsleep(10000); /* >= 10ms */ 307 308 return ret; 309 } 310 311 static int fs210x_dev_stop(struct fs210x_priv *fs210x) 312 { 313 int ret; 314 315 if (!fs210x->is_inited) 316 return -EFAULT; 317 318 if (!fs210x->is_playing) 319 return 0; 320 321 ret = fs210x_reg_write(fs210x, FS210X_11H_SYSCTRL, 322 FS210X_11H_DPS_PWDN); 323 fs210x->is_playing = false; 324 325 fsleep(30000); /* >= 30ms */ 326 327 return ret; 328 } 329 330 static int fs210x_set_reg_table(struct fs210x_priv *fs210x, 331 const struct fs_amp_scene *scene) 332 { 333 const struct fs_amp_scene *cur_scene; 334 const struct fs_reg_table *reg; 335 336 if (!fs210x || !fs210x->dev || !scene) 337 return -EINVAL; 338 339 cur_scene = fs210x->cur_scene; 340 if (!scene->reg || cur_scene == scene) { 341 dev_dbg(fs210x->dev, "Skip writing reg table\n"); 342 return 0; 343 } 344 345 reg = scene->reg; 346 dev_dbg(fs210x->dev, "reg table size: %d\n", reg->size); 347 348 return fs210x_reg_write_table(fs210x, reg); 349 } 350 351 static int fs210x_set_woofer_table(struct fs210x_priv *fs210x) 352 { 353 const struct fs_file_table *woofer; 354 const struct fs_fwm_table *table; 355 int ret; 356 357 if (!fs210x || !fs210x->dev) 358 return -EINVAL; 359 360 /* NOTE: fs2105s has woofer ram only */ 361 if (fs210x->devid != FS2105S_DEVICE_ID) 362 return 0; 363 364 table = fs210x->amp_lib.table[FS_INDEX_WOOFER]; 365 if (!table) { 366 dev_dbg(fs210x->dev, "Skip writing woofer table\n"); 367 return 0; 368 } 369 370 woofer = (struct fs_file_table *)table->buf; 371 dev_dbg(fs210x->dev, "woofer table size: %d\n", woofer->size); 372 /* Unit of woofer data is u32(4 bytes) */ 373 if (woofer->size == 0 || (woofer->size & 0x3)) { 374 dev_err(fs210x->dev, "Invalid woofer size: %d\n", 375 woofer->size); 376 return -EINVAL; 377 } 378 379 ret = fs210x_reg_write(fs210x, FS210X_46H_DACEQA, 380 FS2105S_46H_CAM_BURST_W); 381 ret |= fs210x_reg_bulk_write(fs210x, FS210X_42H_DACEQWL, 382 woofer->buf, woofer->size); 383 384 return ret; 385 } 386 387 static int fs210x_set_effect_table(struct fs210x_priv *fs210x, 388 const struct fs_amp_scene *scene) 389 { 390 const struct fs_amp_scene *cur_scene; 391 const struct fs_file_table *effect; 392 int half_size; 393 int ret; 394 395 if (!fs210x || !fs210x->dev || !scene) 396 return -EINVAL; 397 398 cur_scene = fs210x->cur_scene; 399 if (!scene->effect || cur_scene == scene) { 400 dev_dbg(fs210x->dev, "Skip writing effect table\n"); 401 return 0; 402 } 403 404 effect = scene->effect; 405 dev_dbg(fs210x->dev, "effect table size: %d\n", effect->size); 406 407 /* Unit of effect data is u32(4 bytes), 2 channels */ 408 if (effect->size == 0 || (effect->size & 0x7)) { 409 dev_err(fs210x->dev, "Invalid effect size: %d\n", 410 effect->size); 411 return -EINVAL; 412 } 413 414 half_size = effect->size / 2; 415 416 /* Left channel */ 417 ret = fs210x_reg_write(fs210x, FS210X_46H_DACEQA, 418 FS210X_46H_CAM_BURST_L); 419 ret |= fs210x_reg_bulk_write(fs210x, FS210X_42H_DACEQWL, 420 effect->buf, half_size); 421 if (ret) 422 return ret; 423 424 /* Right channel */ 425 ret = fs210x_reg_write(fs210x, FS210X_46H_DACEQA, 426 FS210X_46H_CAM_BURST_R); 427 ret |= fs210x_reg_bulk_write(fs210x, FS210X_42H_DACEQWL, 428 effect->buf + half_size, half_size); 429 430 return ret; 431 } 432 433 static int fs210x_access_dsp_ram(struct fs210x_priv *fs210x, bool enable) 434 { 435 int ret; 436 437 if (!fs210x || !fs210x->dev) 438 return -EINVAL; 439 440 if (enable) { 441 ret = fs210x_reg_write(fs210x, FS210X_11H_SYSCTRL, 442 FS210X_11H_DPS_HIZ); 443 ret |= fs210x_reg_write(fs210x, FS210X_0BH_ACCKEY, 444 FS210X_0BH_ACCKEY_ON); 445 } else { 446 ret = fs210x_reg_write(fs210x, FS210X_0BH_ACCKEY, 447 FS210X_0BH_ACCKEY_OFF); 448 ret |= fs210x_reg_write(fs210x, FS210X_11H_SYSCTRL, 449 FS210X_11H_DPS_PWDN); 450 } 451 452 fsleep(10000); /* >= 10ms */ 453 454 return ret; 455 } 456 457 static int fs210x_write_dsp_effect(struct fs210x_priv *fs210x, 458 const struct fs_amp_scene *scene, 459 int scene_id) 460 { 461 int ret; 462 463 if (!fs210x || !scene) 464 return -EINVAL; 465 466 ret = fs210x_access_dsp_ram(fs210x, true); 467 if (ret) { 468 dev_err(fs210x->dev, "Failed to access dsp: %d\n", ret); 469 goto tag_exit; 470 } 471 472 ret = fs210x_set_effect_table(fs210x, scene); 473 if (ret) { 474 dev_err(fs210x->dev, "Failed to set effect: %d\n", ret); 475 goto tag_exit; 476 } 477 478 if (scene_id == FS210X_INIT_SCENE) 479 ret = fs210x_set_woofer_table(fs210x); 480 481 tag_exit: 482 fs210x_reg_write(fs210x, FS210X_46H_DACEQA, 483 FS210X_46H_CAM_CLEAR); 484 fs210x_access_dsp_ram(fs210x, false); 485 486 return ret; 487 } 488 489 static int fs210x_check_scene(struct fs210x_priv *fs210x, 490 int scene_id, bool *skip_set) 491 { 492 struct fs_amp_lib *amp_lib; 493 494 if (!fs210x || !skip_set) 495 return -EINVAL; 496 497 amp_lib = &fs210x->amp_lib; 498 if (amp_lib->scene_count == 0 || !amp_lib->scene) { 499 dev_err(fs210x->dev, "There's no scene data\n"); 500 return -EINVAL; 501 } 502 503 if (scene_id < 0 || scene_id >= amp_lib->scene_count) { 504 dev_err(fs210x->dev, "Invalid scene_id: %d\n", scene_id); 505 return -EINVAL; 506 } 507 508 if (fs210x->scene_id == scene_id) { 509 dev_dbg(fs210x->dev, "Skip to set same scene\n"); 510 return 0; 511 } 512 513 *skip_set = false; 514 515 return 0; 516 } 517 518 static int fs210x_set_scene(struct fs210x_priv *fs210x, int scene_id) 519 { 520 const struct fs_amp_scene *scene; 521 bool skip_set = true; 522 bool is_playing; 523 int ret; 524 525 if (!fs210x || !fs210x->dev) 526 return -EINVAL; 527 528 ret = fs210x_check_scene(fs210x, scene_id, &skip_set); 529 if (ret || skip_set) 530 return ret; 531 532 scene = fs210x->amp_lib.scene + scene_id; 533 dev_info(fs210x->dev, "Switch scene.%d: %s\n", 534 scene_id, scene->name); 535 536 is_playing = fs210x->is_playing; 537 if (is_playing) 538 fs210x_dev_stop(fs210x); 539 540 ret = fs210x_set_reg_table(fs210x, scene); 541 if (ret) { 542 dev_err(fs210x->dev, "Failed to set reg: %d\n", ret); 543 return ret; 544 } 545 546 ret = fs210x_write_dsp_effect(fs210x, scene, scene_id); 547 if (ret) { 548 dev_err(fs210x->dev, "Failed to write ram: %d\n", ret); 549 return ret; 550 } 551 552 fs210x->cur_scene = scene; 553 fs210x->scene_id = scene_id; 554 555 if (is_playing) 556 fs210x_dev_play(fs210x); 557 558 return 0; 559 } 560 561 static int fs210x_init_chip(struct fs210x_priv *fs210x) 562 { 563 int scene_id; 564 int ret; 565 566 regcache_cache_bypass(fs210x->regmap, true); 567 568 if (!fs210x->gpio_sdz) { 569 /* Gpio is not found, i2c reset */ 570 ret = fs210x_reg_write(fs210x, FS210X_10H_PWRCTRL, 571 FS210X_10H_I2C_RESET); 572 if (ret) 573 goto tag_power_down; 574 } else { 575 /* gpio reset, deactivate */ 576 gpiod_set_value_cansleep(fs210x->gpio_sdz, 0); 577 } 578 579 fsleep(10000); /* >= 10ms */ 580 581 /* Backup scene id */ 582 scene_id = fs210x->scene_id; 583 fs210x->scene_id = -1; 584 585 /* Init registers/RAM by init scene */ 586 ret = fs210x_set_scene(fs210x, FS210X_INIT_SCENE); 587 if (ret) 588 goto tag_power_down; 589 590 /* 591 * If the firmware has effect scene(s), 592 * we load effect scene by default scene or scene_id 593 */ 594 if (fs210x->amp_lib.scene_count > 1) { 595 if (scene_id < FS210X_DEFAULT_SCENE) 596 scene_id = FS210X_DEFAULT_SCENE; 597 ret = fs210x_set_scene(fs210x, scene_id); 598 if (ret) 599 goto tag_power_down; 600 } 601 602 tag_power_down: 603 /* Power down the device */ 604 ret |= fs210x_reg_write(fs210x, FS210X_11H_SYSCTRL, 605 FS210X_11H_DPS_PWDN); 606 fsleep(10000); /* >= 10ms */ 607 608 regcache_cache_bypass(fs210x->regmap, false); 609 if (!ret) { 610 regcache_cache_only(fs210x->regmap, false); 611 regcache_mark_dirty(fs210x->regmap); 612 regcache_sync(fs210x->regmap); 613 fs210x->is_inited = true; 614 } 615 616 return ret; 617 } 618 619 static int fs210x_set_i2s_params(struct fs210x_priv *fs210x) 620 { 621 const struct fs_i2s_srate params[] = { 622 { 16000, 0x3 }, 623 { 32000, 0x7 }, 624 { 44100, 0x8 }, 625 { 48000, 0x9 }, 626 { 88200, 0xA }, 627 { 96000, 0xB }, 628 }; 629 u16 val; 630 int i, ret; 631 632 for (i = 0; i < ARRAY_SIZE(params); i++) { 633 if (params[i].srate != fs210x->srate) 634 continue; 635 val = params[i].i2ssr << FS210X_17H_I2SSR_SHIFT; 636 ret = fs210x_reg_update_bits(fs210x, 637 FS210X_17H_I2SCTRL, 638 FS210X_17H_I2SSR_MASK, 639 val); 640 return ret; 641 } 642 643 dev_err(fs210x->dev, "Invalid sample rate: %d\n", fs210x->srate); 644 645 return -EINVAL; 646 } 647 648 static int fs210x_get_pll_div(struct fs210x_priv *fs210x, 649 const struct fs_pll_div **pll_div) 650 { 651 int i; 652 653 if (!fs210x || !pll_div) 654 return -EINVAL; 655 656 for (i = 0; i < ARRAY_SIZE(fs210x_pll_div); i++) { 657 if (fs210x_pll_div[i].bclk != fs210x->bclk) 658 continue; 659 *pll_div = fs210x_pll_div + i; 660 return 0; 661 } 662 663 dev_err(fs210x->dev, "No PLL table for bclk: %d\n", fs210x->bclk); 664 665 return -EFAULT; 666 } 667 668 static int fs210x_set_hw_params(struct fs210x_priv *fs210x) 669 { 670 const struct fs_pll_div *pll_div; 671 int ret; 672 673 ret = fs210x_set_i2s_params(fs210x); 674 if (ret) { 675 dev_err(fs210x->dev, "Failed to set i2s params: %d\n", ret); 676 return ret; 677 } 678 679 /* Set pll params */ 680 ret = fs210x_get_pll_div(fs210x, &pll_div); 681 if (ret) 682 return ret; 683 684 ret = fs210x_reg_write(fs210x, FS210X_A1H_PLLCTRL1, pll_div->pll1); 685 ret |= fs210x_reg_write(fs210x, FS210X_A2H_PLLCTRL2, pll_div->pll2); 686 ret |= fs210x_reg_write(fs210x, FS210X_A3H_PLLCTRL3, pll_div->pll3); 687 688 return ret; 689 } 690 691 static int fs210x_dai_startup(struct snd_pcm_substream *substream, 692 struct snd_soc_dai *dai) 693 { 694 const struct snd_pcm_hw_constraint_list *list; 695 struct fs210x_priv *fs210x; 696 int ret; 697 698 fs210x = snd_soc_component_get_drvdata(dai->component); 699 if (!fs210x) { 700 pr_err("dai_startup: fs210x is null\n"); 701 return -EINVAL; 702 } 703 704 if (!substream->runtime) 705 return 0; 706 707 ret = snd_pcm_hw_constraint_mask64(substream->runtime, 708 SNDRV_PCM_HW_PARAM_FORMAT, 709 FS210X_FORMATS); 710 if (ret < 0) { 711 dev_err(fs210x->dev, 712 "Failed to set hw param format: %d\n", ret); 713 return ret; 714 } 715 716 if (fs210x->devid == FS2105S_DEVICE_ID) 717 list = &fs2105s_constraints; 718 else 719 list = &fs210x_constraints; 720 721 ret = snd_pcm_hw_constraint_list(substream->runtime, 0, 722 SNDRV_PCM_HW_PARAM_RATE, 723 list); 724 if (ret < 0) { 725 dev_err(fs210x->dev, 726 "Failed to set hw param rate: %d\n", ret); 727 return ret; 728 } 729 730 return 0; 731 } 732 733 static int fs210x_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) 734 { 735 struct fs210x_priv *fs210x; 736 737 fs210x = snd_soc_component_get_drvdata(dai->component); 738 739 switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) { 740 case SND_SOC_DAIFMT_CBC_CFC: 741 /* Only supports consumer mode */ 742 break; 743 default: 744 dev_err(fs210x->dev, "Only supports consumer mode\n"); 745 return -EINVAL; 746 } 747 748 return 0; 749 } 750 751 static int fs210x_dai_hw_params(struct snd_pcm_substream *substream, 752 struct snd_pcm_hw_params *params, 753 struct snd_soc_dai *dai) 754 { 755 struct fs210x_priv *fs210x; 756 int chn_num; 757 int ret; 758 759 if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK) 760 return 0; 761 762 fs210x = snd_soc_component_get_drvdata(dai->component); 763 764 fs210x->srate = params_rate(params); 765 fs210x->bclk = snd_soc_params_to_bclk(params); 766 chn_num = params_channels(params); 767 if (chn_num == 1) /* mono */ 768 fs210x->bclk *= 2; /* I2S bus has 2 channels */ 769 770 /* The FS2105S can't support 16kHz sample rate. */ 771 if (fs210x->devid == FS2105S_DEVICE_ID && fs210x->srate == 16000) 772 return -EOPNOTSUPP; 773 774 mutex_lock(&fs210x->lock); 775 ret = fs210x_set_hw_params(fs210x); 776 mutex_unlock(&fs210x->lock); 777 if (ret) 778 dev_err(fs210x->dev, "Failed to set hw params: %d\n", ret); 779 780 return ret; 781 } 782 783 static int fs210x_dai_mute(struct snd_soc_dai *dai, int mute, int stream) 784 { 785 struct fs210x_priv *fs210x; 786 unsigned long delay; 787 788 if (stream != SNDRV_PCM_STREAM_PLAYBACK) 789 return 0; 790 791 fs210x = snd_soc_component_get_drvdata(dai->component); 792 793 mutex_lock(&fs210x->lock); 794 795 if (!fs210x->is_inited || fs210x->is_suspended) { 796 mutex_unlock(&fs210x->lock); 797 return 0; 798 } 799 800 mutex_unlock(&fs210x->lock); 801 802 if (mute) { 803 cancel_delayed_work_sync(&fs210x->fault_check_work); 804 cancel_delayed_work_sync(&fs210x->start_work); 805 } else { 806 delay = msecs_to_jiffies(fs210x->check_interval_ms); 807 schedule_delayed_work(&fs210x->fault_check_work, delay); 808 } 809 810 return 0; 811 } 812 813 static int fs210x_dai_trigger(struct snd_pcm_substream *substream, 814 int cmd, struct snd_soc_dai *dai) 815 { 816 struct fs210x_priv *fs210x; 817 818 fs210x = snd_soc_component_get_drvdata(dai->component); 819 820 mutex_lock(&fs210x->lock); 821 822 if (!fs210x->is_inited || fs210x->is_suspended || fs210x->is_playing) { 823 mutex_unlock(&fs210x->lock); 824 return 0; 825 } 826 827 mutex_unlock(&fs210x->lock); 828 829 switch (cmd) { 830 case SNDRV_PCM_TRIGGER_START: 831 case SNDRV_PCM_TRIGGER_RESUME: 832 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 833 /* 834 * According to the power up/down sequence of FS210x, 835 * it requests the I2S clock has been present 836 * and stable(>= 2ms) before playing. 837 */ 838 schedule_delayed_work(&fs210x->start_work, 839 msecs_to_jiffies(FS210X_START_DELAY_MS)); 840 break; 841 842 default: 843 break; 844 } 845 846 return 0; 847 } 848 849 static void fs210x_start_work(struct work_struct *work) 850 { 851 struct fs210x_priv *fs210x; 852 int ret; 853 854 fs210x = container_of(work, struct fs210x_priv, start_work.work); 855 856 mutex_lock(&fs210x->lock); 857 858 ret = fs210x_dev_play(fs210x); 859 if (ret) 860 dev_err(fs210x->dev, "Failed to start playing: %d\n", ret); 861 862 mutex_unlock(&fs210x->lock); 863 } 864 865 static void fs210x_fault_check_work(struct work_struct *work) 866 { 867 struct fs210x_priv *fs210x; 868 u16 status; 869 int ret; 870 871 fs210x = container_of(work, struct fs210x_priv, fault_check_work.work); 872 873 mutex_lock(&fs210x->lock); 874 875 if (!fs210x->is_inited || fs210x->is_suspended || !fs210x->is_playing) { 876 mutex_unlock(&fs210x->lock); 877 return; 878 } 879 880 ret = fs210x_reg_read(fs210x, FS210X_05H_ANASTAT, &status); 881 mutex_unlock(&fs210x->lock); 882 if (ret) 883 return; 884 885 if (!(status & FS210X_05H_PVDD_MASK)) 886 dev_err(fs210x->dev, "PVDD fault\n"); 887 if (status & FS210X_05H_OCDL_MASK) 888 dev_err(fs210x->dev, "OC detected\n"); 889 if (status & FS210X_05H_UVDL_MASK) 890 dev_err(fs210x->dev, "UV detected\n"); 891 if (status & FS210X_05H_OVDL_MASK) 892 dev_err(fs210x->dev, "OV detected\n"); 893 if (status & FS210X_05H_OTPDL_MASK) 894 dev_err(fs210x->dev, "OT detected\n"); 895 if (status & FS210X_05H_OCRDL_MASK) 896 dev_err(fs210x->dev, "OCR detected\n"); 897 if (status & FS210X_05H_OCLDL_MASK) 898 dev_err(fs210x->dev, "OCL detected\n"); 899 if (status & FS210X_05H_DCRDL_MASK) 900 dev_err(fs210x->dev, "DCR detected\n"); 901 if (status & FS210X_05H_DCLDL_MASK) 902 dev_err(fs210x->dev, "DCL detected\n"); 903 if (status & FS210X_05H_SRDL_MASK) 904 dev_err(fs210x->dev, "SR detected\n"); 905 if (status & FS210X_05H_OTWDL_MASK) 906 dev_err(fs210x->dev, "OTW detected\n"); 907 if (!(status & FS210X_05H_AMPS_MASK)) 908 dev_dbg(fs210x->dev, "Amplifier unready\n"); 909 if (!(status & FS210X_05H_PLLS_MASK)) 910 dev_err(fs210x->dev, "PLL unlock\n"); 911 if (!(status & FS210X_05H_ANAS_MASK)) 912 dev_err(fs210x->dev, "Analog power fault\n"); 913 914 schedule_delayed_work(&fs210x->fault_check_work, 915 msecs_to_jiffies(fs210x->check_interval_ms)); 916 } 917 918 static int fs210x_get_drvdata_from_kctrl(struct snd_kcontrol *kctrl, 919 struct fs210x_priv **fs210x) 920 { 921 struct snd_soc_component *cmpnt; 922 923 if (!kctrl) { 924 pr_err("fs210x: kcontrol is null\n"); 925 return -EINVAL; 926 } 927 928 cmpnt = snd_kcontrol_chip(kctrl); 929 if (!cmpnt) { 930 pr_err("fs210x: component is null\n"); 931 return -EINVAL; 932 } 933 934 *fs210x = snd_soc_component_get_drvdata(cmpnt); 935 936 return 0; 937 } 938 939 static int fs210x_effect_scene_info(struct snd_kcontrol *kcontrol, 940 struct snd_ctl_elem_info *uinfo) 941 { 942 const struct fs_amp_scene *scene; 943 struct fs210x_priv *fs210x; 944 const char *name = "N/A"; 945 int idx, count; 946 int ret; 947 948 ret = fs210x_get_drvdata_from_kctrl(kcontrol, &fs210x); 949 if (ret || !fs210x->dev) { 950 pr_err("scene_effect_info: fs210x is null\n"); 951 return -EINVAL; 952 } 953 954 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 955 uinfo->count = 1; 956 957 count = fs210x->amp_lib.scene_count - 1; /* Skip init scene */ 958 if (count < 1) { 959 uinfo->value.enumerated.items = 0; 960 return 0; 961 } 962 963 uinfo->value.enumerated.items = count; 964 if (uinfo->value.enumerated.item >= count) 965 uinfo->value.enumerated.item = count - 1; 966 967 idx = uinfo->value.enumerated.item; 968 scene = fs210x->amp_lib.scene + idx + 1; 969 if (scene->name) 970 name = scene->name; 971 972 strscpy(uinfo->value.enumerated.name, name); 973 974 return 0; 975 } 976 977 static int fs210x_effect_scene_get(struct snd_kcontrol *kcontrol, 978 struct snd_ctl_elem_value *ucontrol) 979 { 980 struct fs210x_priv *fs210x; 981 int index; 982 int ret; 983 984 ret = fs210x_get_drvdata_from_kctrl(kcontrol, &fs210x); 985 if (ret || !fs210x->dev) { 986 pr_err("scene_effect_get: fs210x is null\n"); 987 return -EINVAL; 988 } 989 990 /* The id of effect scene is from 1 to N. */ 991 if (fs210x->scene_id < 1) 992 return -EINVAL; 993 994 mutex_lock(&fs210x->lock); 995 /* 996 * FS210x has scene(s) as below: 997 * init scene: id = 0 998 * effect scene(s): id = 1~N (optional) 999 * effect_index = scene_id - 1 1000 */ 1001 index = fs210x->scene_id - 1; 1002 ucontrol->value.integer.value[0] = index; 1003 mutex_unlock(&fs210x->lock); 1004 1005 return 0; 1006 } 1007 1008 static int fs210x_effect_scene_put(struct snd_kcontrol *kcontrol, 1009 struct snd_ctl_elem_value *ucontrol) 1010 { 1011 struct fs210x_priv *fs210x; 1012 int scene_id, scene_count; 1013 bool is_changed = false; 1014 int ret; 1015 1016 ret = fs210x_get_drvdata_from_kctrl(kcontrol, &fs210x); 1017 if (ret || !fs210x->dev) { 1018 pr_err("scene_effect_put: fs210x is null\n"); 1019 return -EINVAL; 1020 } 1021 1022 mutex_lock(&fs210x->lock); 1023 1024 /* 1025 * FS210x has scene(s) as below: 1026 * init scene: id = 0 (It's set in fs210x_init_chip() only) 1027 * effect scene(s): id = 1~N (optional) 1028 * scene_id = effect_index + 1. 1029 */ 1030 scene_id = ucontrol->value.integer.value[0] + 1; 1031 scene_count = fs210x->amp_lib.scene_count - 1; /* Skip init scene */ 1032 if (scene_id < 1 || scene_id > scene_count) { 1033 mutex_unlock(&fs210x->lock); 1034 return -ERANGE; 1035 } 1036 1037 if (scene_id != fs210x->scene_id) 1038 is_changed = true; 1039 1040 if (fs210x->is_suspended) { 1041 fs210x->scene_id = scene_id; 1042 mutex_unlock(&fs210x->lock); 1043 return is_changed; 1044 } 1045 1046 ret = fs210x_set_scene(fs210x, scene_id); 1047 if (ret) 1048 dev_err(fs210x->dev, "Failed to set scene: %d\n", ret); 1049 1050 mutex_unlock(&fs210x->lock); 1051 1052 if (!ret && is_changed) 1053 return 1; 1054 1055 return ret; 1056 } 1057 1058 static int fs210x_playback_event(struct snd_soc_dapm_widget *w, 1059 struct snd_kcontrol *kc, int event) 1060 { 1061 struct snd_soc_component *cmpnt = snd_soc_dapm_to_component(w->dapm); 1062 struct fs210x_priv *fs210x = snd_soc_component_get_drvdata(cmpnt); 1063 int ret = 0; 1064 1065 mutex_lock(&fs210x->lock); 1066 1067 if (fs210x->is_suspended) { 1068 mutex_unlock(&fs210x->lock); 1069 return 0; 1070 } 1071 1072 switch (event) { 1073 case SND_SOC_DAPM_PRE_PMU: 1074 /* 1075 * If there is no bclk for us to set the clock output, 1076 * we will enable the device(start_work) in dai trigger. 1077 */ 1078 if (!fs210x->clk_bclk) 1079 break; 1080 fs210x_bclk_set(fs210x, true); 1081 ret = fs210x_dev_play(fs210x); 1082 break; 1083 case SND_SOC_DAPM_POST_PMD: 1084 ret = fs210x_dev_stop(fs210x); 1085 fs210x_bclk_set(fs210x, false); 1086 break; 1087 default: 1088 break; 1089 } 1090 1091 mutex_unlock(&fs210x->lock); 1092 1093 return ret; 1094 } 1095 1096 static const struct snd_soc_dai_ops fs210x_dai_ops = { 1097 .startup = fs210x_dai_startup, 1098 .set_fmt = fs210x_dai_set_fmt, 1099 .hw_params = fs210x_dai_hw_params, 1100 .mute_stream = fs210x_dai_mute, 1101 .trigger = fs210x_dai_trigger, 1102 }; 1103 1104 static const struct snd_soc_dai_driver fs210x_dai = { 1105 .name = FS210X_DEFAULT_DAI_NAME, 1106 .playback = { 1107 .stream_name = "Playback", 1108 .channels_min = 1, 1109 .channels_max = 2, 1110 .rates = FS210X_RATES, 1111 .formats = FS210X_FORMATS, 1112 }, 1113 .capture = { 1114 .stream_name = "Capture", 1115 .channels_min = 1, 1116 .channels_max = 2, 1117 .rates = FS210X_RATES, 1118 .formats = FS210X_FORMATS, 1119 }, 1120 .ops = &fs210x_dai_ops, 1121 .symmetric_rate = 1, 1122 .symmetric_sample_bits = 1, 1123 }; 1124 1125 static const DECLARE_TLV_DB_SCALE(fs2105s_vol_tlv, -9709, 19, 1); 1126 static const DECLARE_TLV_DB_SCALE(fs210x_vol_tlv, -13357, 19, 1); 1127 1128 static const struct snd_kcontrol_new fs2105s_vol_control[] = { 1129 SOC_DOUBLE_R_TLV("PCM Playback Volume", 1130 FS210X_39H_LVOLCTRL, FS210X_3AH_RVOLCTRL, 1131 7, 0x1FF, 0, fs2105s_vol_tlv), 1132 }; 1133 1134 static const struct snd_kcontrol_new fs210x_vol_control[] = { 1135 SOC_DOUBLE_R_TLV("PCM Playback Volume", 1136 FS210X_39H_LVOLCTRL, FS210X_3AH_RVOLCTRL, 1137 6, 0x2BF, 0, fs210x_vol_tlv), 1138 }; 1139 1140 static const struct snd_kcontrol_new fs210x_controls[] = { 1141 SOC_DOUBLE("DAC Mute Switch", FS210X_30H_DACCTRL, 4, 8, 1, 0), 1142 SOC_DOUBLE("DAC Fade Switch", FS210X_30H_DACCTRL, 5, 9, 1, 0), 1143 }; 1144 1145 static const struct snd_kcontrol_new fs210x_scene_control[] = { 1146 FS_SOC_ENUM_EXT("Effect Scene", 1147 fs210x_effect_scene_info, 1148 fs210x_effect_scene_get, 1149 fs210x_effect_scene_put), 1150 }; 1151 1152 static const struct snd_soc_dapm_widget fs210x_dapm_widgets[] = { 1153 SND_SOC_DAPM_AIF_IN_E("AIF IN", "Playback", 0, SND_SOC_NOPM, 0, 0, 1154 fs210x_playback_event, 1155 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD), 1156 SND_SOC_DAPM_AIF_OUT("AIF OUT", "Capture", 0, SND_SOC_NOPM, 0, 0), 1157 SND_SOC_DAPM_OUTPUT("OUTL"), 1158 SND_SOC_DAPM_OUTPUT("OUTR"), 1159 SND_SOC_DAPM_INPUT("SDO"), 1160 }; 1161 1162 static const struct snd_soc_dapm_route fs210x_dapm_routes[] = { 1163 { "OUTL", NULL, "AIF IN" }, 1164 { "OUTR", NULL, "AIF IN" }, 1165 { "AIF OUT", NULL, "SDO" }, 1166 }; 1167 1168 static int fs210x_add_mixer_controls(struct fs210x_priv *fs210x, 1169 struct snd_soc_component *cmpnt) 1170 { 1171 const struct snd_kcontrol_new *kctrl; 1172 int count; 1173 int ret; 1174 1175 if (!fs210x || !cmpnt) 1176 return -EINVAL; 1177 1178 if (fs210x->devid == FS2105S_DEVICE_ID) { 1179 kctrl = fs2105s_vol_control; 1180 count = ARRAY_SIZE(fs2105s_vol_control); 1181 } else { 1182 kctrl = fs210x_vol_control; 1183 count = ARRAY_SIZE(fs210x_vol_control); 1184 } 1185 1186 ret = snd_soc_add_component_controls(cmpnt, kctrl, count); 1187 if (ret) 1188 return ret; 1189 1190 /* 1191 * If the firmware has no scene or only init scene, 1192 * we skip adding this mixer control. 1193 */ 1194 if (fs210x->amp_lib.scene_count < 2) 1195 return 0; 1196 1197 kctrl = fs210x_scene_control; 1198 count = ARRAY_SIZE(fs210x_scene_control); 1199 1200 return snd_soc_add_component_controls(cmpnt, kctrl, count); 1201 } 1202 1203 static int fs210x_probe(struct snd_soc_component *cmpnt) 1204 { 1205 struct fs210x_priv *fs210x; 1206 int ret; 1207 1208 fs210x = snd_soc_component_get_drvdata(cmpnt); 1209 if (!fs210x || !fs210x->dev) 1210 return -EINVAL; 1211 1212 fs210x->amp_lib.dev = fs210x->dev; 1213 fs210x->amp_lib.devid = fs210x->devid; 1214 1215 ret = fs_amp_load_firmware(&fs210x->amp_lib, fs210x->pdata.fwm_name); 1216 if (ret) 1217 return ret; 1218 1219 ret = fs210x_add_mixer_controls(fs210x, cmpnt); 1220 if (ret) 1221 return ret; 1222 1223 mutex_lock(&fs210x->lock); 1224 ret = fs210x_init_chip(fs210x); 1225 mutex_unlock(&fs210x->lock); 1226 1227 return ret; 1228 } 1229 1230 static void fs210x_remove(struct snd_soc_component *cmpnt) 1231 { 1232 struct fs210x_priv *fs210x; 1233 1234 fs210x = snd_soc_component_get_drvdata(cmpnt); 1235 if (!fs210x || !fs210x->dev) 1236 return; 1237 1238 cancel_delayed_work_sync(&fs210x->start_work); 1239 cancel_delayed_work_sync(&fs210x->fault_check_work); 1240 } 1241 1242 #ifdef CONFIG_PM 1243 static int fs210x_suspend(struct snd_soc_component *cmpnt) 1244 { 1245 struct fs210x_priv *fs210x; 1246 int ret; 1247 1248 fs210x = snd_soc_component_get_drvdata(cmpnt); 1249 if (!fs210x || !fs210x->dev) 1250 return -EINVAL; 1251 1252 regcache_cache_only(fs210x->regmap, true); 1253 1254 mutex_lock(&fs210x->lock); 1255 fs210x->cur_scene = NULL; 1256 fs210x->is_inited = false; 1257 fs210x->is_playing = false; 1258 fs210x->is_suspended = true; 1259 1260 gpiod_set_value_cansleep(fs210x->gpio_sdz, 1); /* Active */ 1261 fsleep(30000); /* >= 30ms */ 1262 mutex_unlock(&fs210x->lock); 1263 1264 cancel_delayed_work_sync(&fs210x->start_work); 1265 cancel_delayed_work_sync(&fs210x->fault_check_work); 1266 1267 ret = regulator_bulk_disable(FS210X_NUM_SUPPLIES, fs210x->supplies); 1268 if (ret) { 1269 dev_err(fs210x->dev, "Failed to suspend: %d\n", ret); 1270 return ret; 1271 } 1272 1273 return 0; 1274 } 1275 1276 static int fs210x_resume(struct snd_soc_component *cmpnt) 1277 { 1278 struct fs210x_priv *fs210x; 1279 int ret; 1280 1281 fs210x = snd_soc_component_get_drvdata(cmpnt); 1282 if (!fs210x || !fs210x->dev) 1283 return -EINVAL; 1284 1285 ret = regulator_bulk_enable(FS210X_NUM_SUPPLIES, fs210x->supplies); 1286 if (ret) { 1287 dev_err(fs210x->dev, "Failed to enable supplies: %d\n", ret); 1288 return ret; 1289 } 1290 1291 mutex_lock(&fs210x->lock); 1292 1293 fs210x->is_suspended = false; 1294 ret = fs210x_init_chip(fs210x); 1295 1296 mutex_unlock(&fs210x->lock); 1297 1298 return ret; 1299 } 1300 #else 1301 #define fs210x_suspend NULL 1302 #define fs210x_resume NULL 1303 #endif // CONFIG_PM 1304 1305 static bool fs210x_volatile_registers(struct device *dev, unsigned int reg) 1306 { 1307 switch (reg) { 1308 case FS210X_00H_STATUS ... FS210X_0FH_I2CADDR: 1309 case FS210X_ABH_INTSTAT: 1310 case FS210X_ACH_INTSTATR: 1311 return true; 1312 default: 1313 return false; 1314 } 1315 } 1316 1317 static const struct snd_soc_component_driver fs210x_soc_component_dev = { 1318 .probe = fs210x_probe, 1319 .remove = fs210x_remove, 1320 .suspend = fs210x_suspend, 1321 .resume = fs210x_resume, 1322 .controls = fs210x_controls, 1323 .num_controls = ARRAY_SIZE(fs210x_controls), 1324 .dapm_widgets = fs210x_dapm_widgets, 1325 .num_dapm_widgets = ARRAY_SIZE(fs210x_dapm_widgets), 1326 .dapm_routes = fs210x_dapm_routes, 1327 .num_dapm_routes = ARRAY_SIZE(fs210x_dapm_routes), 1328 }; 1329 1330 static const struct regmap_config fs210x_regmap = { 1331 .reg_bits = 8, 1332 .val_bits = 16, 1333 .max_register = FS210X_REG_MAX, 1334 .val_format_endian = REGMAP_ENDIAN_BIG, 1335 .cache_type = REGCACHE_MAPLE, 1336 .volatile_reg = fs210x_volatile_registers, 1337 }; 1338 1339 static int fs210x_detect_device(struct fs210x_priv *fs210x) 1340 { 1341 u16 devid; 1342 int ret; 1343 1344 ret = fs210x_reg_read(fs210x, FS210X_03H_DEVID, &devid); 1345 if (ret) 1346 return ret; 1347 1348 fs210x->devid = HI_U16(devid); 1349 1350 switch (fs210x->devid) { 1351 case FS210X_DEVICE_ID: 1352 dev_info(fs210x->dev, "FS2104 detected\n"); 1353 break; 1354 case FS2105S_DEVICE_ID: 1355 dev_info(fs210x->dev, "FS2105S detected\n"); 1356 break; 1357 default: 1358 dev_err(fs210x->dev, "DEVID: 0x%04X dismatch\n", devid); 1359 return -ENODEV; 1360 } 1361 1362 return 0; 1363 } 1364 1365 static int fs210x_parse_dts(struct fs210x_priv *fs210x, 1366 struct fs210x_platform_data *pdata) 1367 { 1368 struct device_node *node = fs210x->dev->of_node; 1369 int i, ret; 1370 1371 if (!node) 1372 return 0; 1373 1374 ret = of_property_read_string(node, "firmware-name", &pdata->fwm_name); 1375 if (ret) 1376 pdata->fwm_name = FS210X_DEFAULT_FWM_NAME; 1377 1378 fs210x->gpio_sdz = devm_gpiod_get_optional(fs210x->dev, 1379 "reset", GPIOD_OUT_HIGH); 1380 if (IS_ERR(fs210x->gpio_sdz)) 1381 return dev_err_probe(fs210x->dev, PTR_ERR(fs210x->gpio_sdz), 1382 "Failed to get reset-gpios\n"); 1383 1384 for (i = 0; i < FS210X_NUM_SUPPLIES; i++) 1385 fs210x->supplies[i].supply = fs210x_supply_names[i]; 1386 1387 ret = devm_regulator_bulk_get(fs210x->dev, 1388 ARRAY_SIZE(fs210x->supplies), 1389 fs210x->supplies); 1390 if (ret) 1391 return dev_err_probe(fs210x->dev, ret, 1392 "Failed to get supplies\n"); 1393 1394 return 0; 1395 } 1396 1397 static void fs210x_deinit(struct fs210x_priv *fs210x) 1398 { 1399 gpiod_set_value_cansleep(fs210x->gpio_sdz, 1); /* Active */ 1400 fsleep(10000); /* >= 10ms */ 1401 1402 regulator_bulk_disable(FS210X_NUM_SUPPLIES, fs210x->supplies); 1403 } 1404 1405 static int fs210x_init(struct fs210x_priv *fs210x) 1406 { 1407 int ret; 1408 1409 ret = fs210x_parse_dts(fs210x, &fs210x->pdata); 1410 if (ret) 1411 return ret; 1412 1413 fs210x->clk_bclk = devm_clk_get_optional(fs210x->dev, "bclk"); 1414 if (IS_ERR(fs210x->clk_bclk)) 1415 return dev_err_probe(fs210x->dev, PTR_ERR(fs210x->clk_bclk), 1416 "Failed to get bclk\n"); 1417 1418 ret = regulator_bulk_enable(FS210X_NUM_SUPPLIES, fs210x->supplies); 1419 if (ret) 1420 return dev_err_probe(fs210x->dev, ret, 1421 "Failed to enable supplies\n"); 1422 1423 /* Make sure the SDZ pin is pulled down enough time. */ 1424 fsleep(10000); /* >= 10ms */ 1425 gpiod_set_value_cansleep(fs210x->gpio_sdz, 0); /* Deactivate */ 1426 fsleep(10000); /* >= 10ms */ 1427 1428 ret = fs210x_detect_device(fs210x); 1429 if (ret) { 1430 fs210x_deinit(fs210x); 1431 return ret; 1432 } 1433 1434 fs210x->scene_id = -1; /* Invalid scene */ 1435 fs210x->cur_scene = NULL; 1436 fs210x->is_playing = false; 1437 fs210x->is_inited = false; 1438 fs210x->is_suspended = false; 1439 fs210x->check_interval_ms = FS210X_FAULT_CHECK_INTERVAL_MS; 1440 1441 INIT_DELAYED_WORK(&fs210x->fault_check_work, fs210x_fault_check_work); 1442 INIT_DELAYED_WORK(&fs210x->start_work, fs210x_start_work); 1443 mutex_init(&fs210x->lock); 1444 1445 return 0; 1446 } 1447 1448 static int fs210x_register_snd_component(struct fs210x_priv *fs210x) 1449 { 1450 struct snd_soc_dai_driver *dai_drv; 1451 static int instance_id; 1452 int ret; 1453 1454 dai_drv = devm_kmemdup(fs210x->dev, &fs210x_dai, 1455 sizeof(fs210x_dai), GFP_KERNEL); 1456 if (!dai_drv) 1457 return -ENOMEM; 1458 1459 dai_drv->name = devm_kasprintf(fs210x->dev, 1460 GFP_KERNEL, "%s-%d", 1461 dai_drv->name, instance_id); 1462 if (!dai_drv->name) 1463 return -ENOMEM; 1464 1465 instance_id++; 1466 1467 if (fs210x->devid == FS2105S_DEVICE_ID) { 1468 dai_drv->playback.rates = FS2105S_RATES; 1469 dai_drv->capture.rates = FS2105S_RATES; 1470 } 1471 1472 ret = snd_soc_register_component(fs210x->dev, 1473 &fs210x_soc_component_dev, 1474 dai_drv, 1); 1475 return ret; 1476 } 1477 1478 static ssize_t check_interval_ms_show(struct device *dev, 1479 struct device_attribute *devattr, 1480 char *buf) 1481 { 1482 struct fs210x_priv *fs210x = dev_get_drvdata(dev); 1483 1484 return sysfs_emit(buf, "%d\n", fs210x->check_interval_ms); 1485 } 1486 1487 static ssize_t check_interval_ms_store(struct device *dev, 1488 struct device_attribute *devattr, 1489 const char *buf, 1490 size_t count) 1491 { 1492 struct fs210x_priv *fs210x = dev_get_drvdata(dev); 1493 int ret; 1494 1495 ret = kstrtouint(buf, 10, &fs210x->check_interval_ms); 1496 if (ret) 1497 return -EINVAL; 1498 1499 return (ssize_t)count; 1500 } 1501 1502 static DEVICE_ATTR_RW(check_interval_ms); 1503 1504 static struct attribute *fs210x_attrs[] = { 1505 &dev_attr_check_interval_ms.attr, 1506 NULL, 1507 }; 1508 1509 static struct attribute_group fs210x_attr_group = { 1510 .attrs = fs210x_attrs, 1511 }; 1512 1513 static int fs210x_i2c_probe(struct i2c_client *client) 1514 { 1515 struct fs210x_priv *fs210x; 1516 int ret; 1517 1518 fs210x = devm_kzalloc(&client->dev, sizeof(*fs210x), GFP_KERNEL); 1519 if (!fs210x) 1520 return -ENOMEM; 1521 1522 fs210x->i2c = client; 1523 fs210x->dev = &client->dev; 1524 i2c_set_clientdata(client, fs210x); 1525 1526 fs210x->regmap = devm_regmap_init_i2c(client, &fs210x_regmap); 1527 if (IS_ERR(fs210x->regmap)) 1528 return dev_err_probe(fs210x->dev, PTR_ERR(fs210x->regmap), 1529 "Failed to get regmap\n"); 1530 1531 ret = fs210x_init(fs210x); 1532 if (ret) 1533 return ret; 1534 1535 ret = devm_device_add_group(fs210x->dev, &fs210x_attr_group); 1536 if (ret) { 1537 fs210x_deinit(fs210x); 1538 return dev_err_probe(fs210x->dev, ret, 1539 "Failed to create sysfs group\n"); 1540 } 1541 1542 ret = fs210x_register_snd_component(fs210x); 1543 if (ret) { 1544 fs210x_deinit(fs210x); 1545 return dev_err_probe(fs210x->dev, ret, 1546 "Failed to register component\n"); 1547 } 1548 1549 return 0; 1550 } 1551 1552 static void fs210x_i2c_remove(struct i2c_client *client) 1553 { 1554 struct fs210x_priv *fs210x = i2c_get_clientdata(client); 1555 1556 snd_soc_unregister_component(fs210x->dev); 1557 fs210x_deinit(fs210x); 1558 } 1559 1560 static const struct i2c_device_id fs210x_i2c_id[] = { 1561 { .name = "fs2104" }, 1562 { .name = "fs2105s" }, 1563 { } 1564 }; 1565 MODULE_DEVICE_TABLE(i2c, fs210x_i2c_id); 1566 1567 static const struct of_device_id fs210x_of_match[] = { 1568 { .compatible = "foursemi,fs2105s", }, 1569 {}, 1570 }; 1571 MODULE_DEVICE_TABLE(of, fs210x_of_match); 1572 1573 static struct i2c_driver fs210x_i2c_driver = { 1574 .driver = { 1575 .name = "fs210x", 1576 .of_match_table = fs210x_of_match, 1577 }, 1578 .id_table = fs210x_i2c_id, 1579 .probe = fs210x_i2c_probe, 1580 .remove = fs210x_i2c_remove, 1581 }; 1582 1583 module_i2c_driver(fs210x_i2c_driver); 1584 1585 MODULE_AUTHOR("Nick Li <nick.li@foursemi.com>"); 1586 MODULE_DESCRIPTION("FS2104/5S Audio Amplifier Driver"); 1587 MODULE_LICENSE("GPL"); 1588