tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

ASoC: codecs: Add calibration function to aw88399 chip

Add calibration functionality to the aw88399 chip.
When the chip is in calibration condition, calibration
can be achieved by configuring the chip's internal DSP
and save the calibration values in cali_re.

Signed-off-by: Weidong Wang <wangweidong.a@awinic.com>
Link: https://patch.msgid.link/20250627110306.23488-1-wangweidong.a@awinic.com
Signed-off-by: Mark Brown <broonie@kernel.org>

authored by

Weidong Wang and committed by
Mark Brown 29ddce17 086d0960

+493 -2
+21
sound/soc/codecs/aw88395/aw88395_device.h
··· 102 102 unsigned int cur_mode; 103 103 }; 104 104 105 + enum { 106 + CALI_RESULT_NORMAL, 107 + CALI_RESULT_ERROR, 108 + }; 109 + 105 110 struct aw_volume_desc { 106 111 unsigned int init_volume; 107 112 unsigned int mute_volume; ··· 129 124 unsigned int delay; 130 125 }; 131 126 127 + #define AW_CALI_CFG_NUM (4) 128 + struct cali_cfg { 129 + uint32_t data[AW_CALI_CFG_NUM]; 130 + }; 131 + 132 + struct aw_cali_backup_desc { 133 + unsigned int dsp_ng_cfg; 134 + unsigned int dsp_lp_cfg; 135 + }; 136 + 132 137 struct aw_cali_desc { 133 138 u32 cali_re; 134 139 u32 ra; 140 + bool cali_switch; 141 + bool cali_running; 142 + uint16_t cali_result; 143 + uint16_t store_vol; 144 + struct cali_cfg cali_cfg; 145 + struct aw_cali_backup_desc backup_info; 135 146 }; 136 147 137 148 struct aw_container {
+438 -2
sound/soc/codecs/aw88399.c
··· 13 13 #include <linux/firmware.h> 14 14 #include <linux/minmax.h> 15 15 #include <linux/regmap.h> 16 + #include <linux/sort.h> 16 17 #include <sound/soc.h> 17 18 #include "aw88399.h" 18 19 #include "aw88395/aw88395_device.h" ··· 44 43 } 45 44 46 45 return 0; 46 + } 47 + 48 + static int aw_dev_dsp_write_32bit(struct aw_device *aw_dev, 49 + unsigned short dsp_addr, unsigned int dsp_data) 50 + { 51 + unsigned int temp_data; 52 + int ret; 53 + 54 + ret = regmap_write(aw_dev->regmap, AW88399_DSPMADD_REG, dsp_addr); 55 + if (ret) { 56 + dev_err(aw_dev->dev, "%s write addr error, ret=%d", __func__, ret); 57 + return ret; 58 + } 59 + 60 + temp_data = dsp_data & AW88395_DSP_16_DATA_MASK; 61 + ret = regmap_write(aw_dev->regmap, AW88399_DSPMDAT_REG, temp_data); 62 + if (ret) { 63 + dev_err(aw_dev->dev, "%s write datal error, ret=%d", __func__, ret); 64 + return ret; 65 + } 66 + 67 + temp_data = dsp_data >> 16; 68 + ret = regmap_write(aw_dev->regmap, AW88399_DSPMDAT_REG, temp_data); 69 + if (ret) 70 + dev_err(aw_dev->dev, "%s write datah error, ret=%d", __func__, ret); 71 + 72 + return ret; 73 + } 74 + 75 + static int aw_dev_dsp_write(struct aw_device *aw_dev, 76 + unsigned short dsp_addr, unsigned int dsp_data, unsigned char data_type) 77 + { 78 + unsigned int reg_value; 79 + int ret; 80 + 81 + mutex_lock(&aw_dev->dsp_lock); 82 + switch (data_type) { 83 + case AW88395_DSP_16_DATA: 84 + ret = aw_dev_dsp_write_16bit(aw_dev, dsp_addr, dsp_data); 85 + if (ret) 86 + dev_err(aw_dev->dev, "write dsp_addr[0x%x] 16-bit dsp_data[0x%x] failed", 87 + dsp_addr, dsp_data); 88 + break; 89 + case AW88395_DSP_32_DATA: 90 + ret = aw_dev_dsp_write_32bit(aw_dev, dsp_addr, dsp_data); 91 + if (ret) 92 + dev_err(aw_dev->dev, "write dsp_addr[0x%x] 32-bit dsp_data[0x%x] failed", 93 + dsp_addr, dsp_data); 94 + break; 95 + default: 96 + dev_err(aw_dev->dev, "data type[%d] unsupported", data_type); 97 + ret = -EINVAL; 98 + break; 99 + } 100 + 101 + /* clear dsp chip select state */ 102 + if (regmap_read(aw_dev->regmap, 0x00, &reg_value)) 103 + dev_err(aw_dev->dev, "%s fail to clear chip state. Err=%d\n", __func__, ret); 104 + mutex_unlock(&aw_dev->dsp_lock); 105 + 106 + return ret; 47 107 } 48 108 49 109 static int aw_dev_dsp_read_16bit(struct aw_device *aw_dev, ··· 514 452 case AW88399_DEV_VDSEL_VSENSE: 515 453 ret = aw88399_dev_get_vcalk(aw88399, &vcalk); 516 454 vcal_k = vcalk * AW88399_VCABLK_FACTOR + AW88399_CABL_BASE_VALUE; 517 - vcalb = AW88399_VCALB_ACCURACY * AW88399_VSCAL_FACTOR / AW88399_ISCAL_FACTOR / 455 + vcalb = AW88399_VCALB_ACCURACY * AW88399_VSCAL_FACTOR / AW88399_ISCAL_FACTOR * 518 456 ical_k / vcal_k * aw88399->vcalb_init_val; 519 457 break; 520 458 case AW88399_DEV_VDSEL_DAC: 521 459 ret = aw88399_dev_get_internal_vcalk(aw88399, &vcalk); 522 460 vcal_k = vcalk * AW88399_VCABLK_DAC_FACTOR + AW88399_CABL_BASE_VALUE; 523 461 vcalb = AW88399_VCALB_ACCURACY * AW88399_VSCAL_DAC_FACTOR / 524 - AW88399_ISCAL_DAC_FACTOR / ical_k / 462 + AW88399_ISCAL_DAC_FACTOR * ical_k / 525 463 vcal_k * aw88399->vcalb_init_val; 526 464 break; 527 465 default: ··· 1418 1356 }, 1419 1357 }; 1420 1358 1359 + static void aw_cali_svc_run_mute(struct aw_device *aw_dev, uint16_t cali_result) 1360 + { 1361 + if (cali_result == CALI_RESULT_ERROR) 1362 + aw88399_dev_mute(aw_dev, true); 1363 + else if (cali_result == CALI_RESULT_NORMAL) 1364 + aw88399_dev_mute(aw_dev, false); 1365 + } 1366 + 1367 + static int aw_cali_svc_get_cali_cfg(struct aw_device *aw_dev) 1368 + { 1369 + struct cali_cfg *cali_cfg = &aw_dev->cali_desc.cali_cfg; 1370 + int ret; 1371 + 1372 + ret = aw_dev_dsp_read(aw_dev, AW88399_DSP_REG_CFG_MBMEC_ACTAMPTH, 1373 + &cali_cfg->data[0], AW88399_DSP_32_DATA); 1374 + if (ret) 1375 + return ret; 1376 + 1377 + ret = aw_dev_dsp_read(aw_dev, AW88399_DSP_REG_CFG_MBMEC_NOISEAMPTH, 1378 + &cali_cfg->data[1], AW88399_DSP_32_DATA); 1379 + if (ret) 1380 + return ret; 1381 + 1382 + ret = aw_dev_dsp_read(aw_dev, AW88399_DSP_REG_CFG_ADPZ_USTEPN, 1383 + &cali_cfg->data[2], AW88399_DSP_16_DATA); 1384 + if (ret) 1385 + return ret; 1386 + 1387 + ret = aw_dev_dsp_read(aw_dev, AW88399_DSP_REG_CFG_RE_ALPHA, 1388 + &cali_cfg->data[3], AW88399_DSP_16_DATA); 1389 + 1390 + return ret; 1391 + } 1392 + 1393 + static int aw_cali_svc_set_cali_cfg(struct aw_device *aw_dev, 1394 + struct cali_cfg cali_cfg) 1395 + { 1396 + int ret; 1397 + 1398 + ret = aw_dev_dsp_write(aw_dev, AW88399_DSP_REG_CFG_MBMEC_ACTAMPTH, 1399 + cali_cfg.data[0], AW88399_DSP_32_DATA); 1400 + if (ret) 1401 + return ret; 1402 + 1403 + ret = aw_dev_dsp_write(aw_dev, AW88399_DSP_REG_CFG_MBMEC_NOISEAMPTH, 1404 + cali_cfg.data[1], AW88399_DSP_32_DATA); 1405 + if (ret) 1406 + return ret; 1407 + 1408 + ret = aw_dev_dsp_write(aw_dev, AW88399_DSP_REG_CFG_ADPZ_USTEPN, 1409 + cali_cfg.data[2], AW88399_DSP_16_DATA); 1410 + if (ret) 1411 + return ret; 1412 + 1413 + ret = aw_dev_dsp_write(aw_dev, AW88399_DSP_REG_CFG_RE_ALPHA, 1414 + cali_cfg.data[3], AW88399_DSP_16_DATA); 1415 + 1416 + return ret; 1417 + } 1418 + 1419 + static int aw_cali_svc_cali_en(struct aw_device *aw_dev, bool cali_en) 1420 + { 1421 + struct cali_cfg set_cfg; 1422 + int ret; 1423 + 1424 + aw_dev_dsp_enable(aw_dev, false); 1425 + if (cali_en) { 1426 + regmap_update_bits(aw_dev->regmap, AW88399_DBGCTRL_REG, 1427 + ~AW883XX_DSP_NG_EN_MASK, AW883XX_DSP_NG_EN_DISABLE_VALUE); 1428 + aw_dev_dsp_write(aw_dev, AW88399_DSP_LOW_POWER_SWITCH_CFG_ADDR, 1429 + AW88399_DSP_LOW_POWER_SWITCH_DISABLE, AW88399_DSP_16_DATA); 1430 + 1431 + ret = aw_cali_svc_get_cali_cfg(aw_dev); 1432 + if (ret) { 1433 + dev_err(aw_dev->dev, "get cali cfg failed\n"); 1434 + aw_dev_dsp_enable(aw_dev, true); 1435 + return ret; 1436 + } 1437 + set_cfg.data[0] = 0; 1438 + set_cfg.data[1] = 0; 1439 + set_cfg.data[2] = -1; 1440 + set_cfg.data[3] = 1; 1441 + 1442 + ret = aw_cali_svc_set_cali_cfg(aw_dev, set_cfg); 1443 + if (ret) { 1444 + dev_err(aw_dev->dev, "set cali cfg failed\n"); 1445 + aw_cali_svc_set_cali_cfg(aw_dev, aw_dev->cali_desc.cali_cfg); 1446 + aw_dev_dsp_enable(aw_dev, true); 1447 + return ret; 1448 + } 1449 + } else { 1450 + aw_cali_svc_set_cali_cfg(aw_dev, aw_dev->cali_desc.cali_cfg); 1451 + } 1452 + 1453 + aw_dev_dsp_enable(aw_dev, true); 1454 + 1455 + return 0; 1456 + } 1457 + 1458 + static int aw_cali_svc_cali_run_dsp_vol(struct aw_device *aw_dev, bool enable) 1459 + { 1460 + unsigned int reg_val; 1461 + int ret; 1462 + 1463 + if (enable) { 1464 + ret = regmap_read(aw_dev->regmap, AW88399_DSPCFG_REG, &reg_val); 1465 + if (ret) { 1466 + dev_err(aw_dev->dev, "read reg 0x%x failed\n", AW88399_DSPCFG_REG); 1467 + return ret; 1468 + } 1469 + 1470 + aw_dev->cali_desc.store_vol = reg_val & (~AW88399_DSP_VOL_MASK); 1471 + ret = regmap_update_bits(aw_dev->regmap, AW88399_DSPCFG_REG, 1472 + ~AW88399_DSP_VOL_MASK, AW88399_DSP_VOL_MUTE); 1473 + } else { 1474 + ret = regmap_update_bits(aw_dev->regmap, AW88399_DSPCFG_REG, 1475 + ~AW88399_DSP_VOL_MASK, aw_dev->cali_desc.store_vol); 1476 + } 1477 + 1478 + return ret; 1479 + } 1480 + 1481 + static void aw_cali_svc_backup_info(struct aw_device *aw_dev) 1482 + { 1483 + struct aw_cali_backup_desc *backup_desc = &aw_dev->cali_desc.backup_info; 1484 + unsigned int reg_val, dsp_val; 1485 + 1486 + regmap_read(aw_dev->regmap, AW88399_DBGCTRL_REG, &reg_val); 1487 + backup_desc->dsp_ng_cfg = reg_val & (~AW883XX_DSP_NG_EN_MASK); 1488 + 1489 + aw_dev_dsp_read(aw_dev, AW88399_DSP_LOW_POWER_SWITCH_CFG_ADDR, 1490 + &dsp_val, AW88399_DSP_16_DATA); 1491 + 1492 + backup_desc->dsp_lp_cfg = dsp_val; 1493 + } 1494 + 1495 + static void aw_cali_svc_recover_info(struct aw_device *aw_dev) 1496 + { 1497 + struct aw_cali_backup_desc *backup_desc = &aw_dev->cali_desc.backup_info; 1498 + 1499 + regmap_update_bits(aw_dev->regmap, AW88399_DBGCTRL_REG, 1500 + ~AW883XX_DSP_NG_EN_MASK, backup_desc->dsp_ng_cfg); 1501 + 1502 + aw_dev_dsp_write(aw_dev, AW88399_DSP_LOW_POWER_SWITCH_CFG_ADDR, 1503 + backup_desc->dsp_lp_cfg, AW88399_DSP_16_DATA); 1504 + } 1505 + 1506 + static int aw_cali_svc_cali_re_mode_enable(struct aw_device *aw_dev, bool is_enable) 1507 + { 1508 + int ret; 1509 + 1510 + if (is_enable) { 1511 + ret = aw_dev_check_syspll(aw_dev); 1512 + if (ret) { 1513 + dev_err(aw_dev->dev, "pll check failed cannot start\n"); 1514 + return ret; 1515 + } 1516 + 1517 + ret = aw_dev_get_dsp_status(aw_dev); 1518 + if (ret) { 1519 + dev_err(aw_dev->dev, "dsp status error\n"); 1520 + return ret; 1521 + } 1522 + 1523 + aw_cali_svc_backup_info(aw_dev); 1524 + ret = aw_cali_svc_cali_en(aw_dev, true); 1525 + if (ret) { 1526 + dev_err(aw_dev->dev, "aw_cali_svc_cali_en failed\n"); 1527 + return ret; 1528 + } 1529 + 1530 + ret = aw_cali_svc_cali_run_dsp_vol(aw_dev, true); 1531 + if (ret) { 1532 + aw_cali_svc_cali_en(aw_dev, false); 1533 + return ret; 1534 + } 1535 + 1536 + } else { 1537 + aw_cali_svc_cali_run_dsp_vol(aw_dev, false); 1538 + aw_cali_svc_recover_info(aw_dev); 1539 + aw_cali_svc_cali_en(aw_dev, false); 1540 + } 1541 + 1542 + return 0; 1543 + } 1544 + 1545 + static int aw_cali_svc_get_dev_re(struct aw_device *aw_dev, uint32_t *re) 1546 + { 1547 + uint32_t dsp_re, show_re; 1548 + int ret; 1549 + 1550 + ret = aw_dev_dsp_read(aw_dev, AW88399_DSP_REG_CALRE, &dsp_re, AW88399_DSP_16_DATA); 1551 + if (ret) 1552 + return ret; 1553 + 1554 + show_re = AW88399_DSP_RE_TO_SHOW_RE(dsp_re, AW88399_DSP_REG_CALRE_SHIFT); 1555 + 1556 + *re = (uint32_t)(show_re - aw_dev->cali_desc.ra); 1557 + 1558 + return 0; 1559 + } 1560 + 1561 + static void aw_cali_svc_del_max_min_ave_algo(uint32_t *data, int data_size, uint32_t *dsp_re) 1562 + { 1563 + int sum = 0, i; 1564 + 1565 + for (i = 1; i < data_size - 1; i++) 1566 + sum += data[i]; 1567 + 1568 + *dsp_re = sum / (data_size - AW_CALI_DATA_SUM_RM); 1569 + } 1570 + 1571 + static int aw_cali_svc_get_iv_st(struct aw_device *aw_dev) 1572 + { 1573 + unsigned int reg_data; 1574 + int ret, i; 1575 + 1576 + for (i = 0; i < AW_GET_IV_CNT_MAX; i++) { 1577 + ret = regmap_read(aw_dev->regmap, AW88399_ASR1_REG, &reg_data); 1578 + if (ret) { 1579 + dev_err(aw_dev->dev, "read 0x%x failed\n", AW88399_ASR1_REG); 1580 + return ret; 1581 + } 1582 + 1583 + reg_data &= (~AW88399_REABS_MASK); 1584 + if (!reg_data) 1585 + return 0; 1586 + msleep(30); 1587 + } 1588 + 1589 + dev_err(aw_dev->dev, "IV data abnormal, please check\n"); 1590 + 1591 + return -EINVAL; 1592 + } 1593 + 1594 + static int compare_ints(const void *a, const void *b) 1595 + { 1596 + return *(int *)a - *(int *)b; 1597 + } 1598 + 1599 + static int aw_cali_svc_get_smooth_cali_re(struct aw_device *aw_dev) 1600 + { 1601 + uint32_t re_temp[AW_CALI_READ_CNT_MAX]; 1602 + uint32_t dsp_re; 1603 + int ret, i; 1604 + 1605 + for (i = 0; i < AW_CALI_READ_CNT_MAX; i++) { 1606 + ret = aw_cali_svc_get_dev_re(aw_dev, &re_temp[i]); 1607 + if (ret) 1608 + goto cali_re_fail; 1609 + msleep(30); 1610 + } 1611 + 1612 + sort(re_temp, AW_CALI_READ_CNT_MAX, sizeof(uint32_t), compare_ints, NULL); 1613 + 1614 + aw_cali_svc_del_max_min_ave_algo(re_temp, AW_CALI_READ_CNT_MAX, &dsp_re); 1615 + 1616 + ret = aw_cali_svc_get_iv_st(aw_dev); 1617 + if (ret) { 1618 + dev_err(aw_dev->dev, "get iv data failed"); 1619 + goto cali_re_fail; 1620 + } 1621 + 1622 + if (dsp_re < AW88399_CALI_RE_MIN || dsp_re > AW88399_CALI_RE_MAX) { 1623 + dev_err(aw_dev->dev, "out range re value: [%d]mohm\n", dsp_re); 1624 + aw_dev->cali_desc.cali_re = dsp_re; 1625 + aw_dev->cali_desc.cali_result = CALI_RESULT_ERROR; 1626 + aw_cali_svc_run_mute(aw_dev, aw_dev->cali_desc.cali_result); 1627 + 1628 + return 0; 1629 + } 1630 + 1631 + aw_dev->cali_desc.cali_result = CALI_RESULT_NORMAL; 1632 + 1633 + aw_dev->cali_desc.cali_re = dsp_re; 1634 + dev_dbg(aw_dev->dev, "re[%d]mohm\n", aw_dev->cali_desc.cali_re); 1635 + 1636 + aw_dev_dsp_enable(aw_dev, false); 1637 + aw_dev_update_cali_re(&aw_dev->cali_desc); 1638 + aw_dev_dsp_enable(aw_dev, true); 1639 + 1640 + return 0; 1641 + 1642 + cali_re_fail: 1643 + aw_dev->cali_desc.cali_result = CALI_RESULT_ERROR; 1644 + aw_cali_svc_run_mute(aw_dev, aw_dev->cali_desc.cali_result); 1645 + return -EINVAL; 1646 + } 1647 + 1648 + static int aw_cali_svc_dev_cali_re(struct aw88399 *aw88399) 1649 + { 1650 + struct aw_device *aw_dev = aw88399->aw_pa; 1651 + struct aw_cali_desc *cali_desc = &aw_dev->cali_desc; 1652 + int ret; 1653 + 1654 + if (cali_desc->cali_running) { 1655 + dev_err(aw_dev->dev, "calibration in progress\n"); 1656 + return -EINVAL; 1657 + } 1658 + 1659 + cali_desc->cali_running = true; 1660 + aw_cali_svc_run_mute(aw_dev, CALI_RESULT_NORMAL); 1661 + 1662 + ret = aw_cali_svc_cali_re_mode_enable(aw_dev, true); 1663 + if (ret) { 1664 + dev_err(aw_dev->dev, "start cali re failed\n"); 1665 + goto re_mode_err; 1666 + } 1667 + 1668 + msleep(1000); 1669 + 1670 + ret = aw_cali_svc_get_smooth_cali_re(aw_dev); 1671 + if (ret) 1672 + dev_err(aw_dev->dev, "get cali re failed\n"); 1673 + 1674 + aw_cali_svc_cali_re_mode_enable(aw_dev, false); 1675 + 1676 + re_mode_err: 1677 + cali_desc->cali_running = false; 1678 + 1679 + return ret; 1680 + } 1681 + 1421 1682 static int aw88399_get_fade_in_time(struct snd_kcontrol *kcontrol, 1422 1683 struct snd_ctl_elem_value *ucontrol) 1423 1684 { ··· 2001 1616 return 0; 2002 1617 } 2003 1618 1619 + static int aw88399_calib_switch_get(struct snd_kcontrol *kcontrol, 1620 + struct snd_ctl_elem_value *ucontrol) 1621 + { 1622 + struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol); 1623 + struct aw88399 *aw88399 = snd_soc_component_get_drvdata(codec); 1624 + struct aw_device *aw_dev = aw88399->aw_pa; 1625 + 1626 + ucontrol->value.integer.value[0] = aw_dev->cali_desc.cali_switch; 1627 + 1628 + return 0; 1629 + } 1630 + 1631 + static int aw88399_calib_switch_set(struct snd_kcontrol *kcontrol, 1632 + struct snd_ctl_elem_value *ucontrol) 1633 + { 1634 + struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol); 1635 + struct aw88399 *aw88399 = snd_soc_component_get_drvdata(codec); 1636 + struct aw_device *aw_dev = aw88399->aw_pa; 1637 + 1638 + if (aw_dev->cali_desc.cali_switch == ucontrol->value.integer.value[0]) 1639 + return 0; 1640 + 1641 + aw_dev->cali_desc.cali_switch = ucontrol->value.integer.value[0]; 1642 + 1643 + return 1; 1644 + } 1645 + 1646 + static int aw88399_calib_get(struct snd_kcontrol *kcontrol, 1647 + struct snd_ctl_elem_value *ucontrol) 1648 + { 1649 + /* do nothing */ 1650 + return 0; 1651 + } 1652 + 1653 + static int aw88399_calib_set(struct snd_kcontrol *kcontrol, 1654 + struct snd_ctl_elem_value *ucontrol) 1655 + { 1656 + struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol); 1657 + struct aw88399 *aw88399 = snd_soc_component_get_drvdata(codec); 1658 + struct aw_device *aw_dev = aw88399->aw_pa; 1659 + 1660 + if (aw_dev->status && aw_dev->cali_desc.cali_switch) 1661 + aw_cali_svc_dev_cali_re(aw88399); 1662 + 1663 + return 0; 1664 + } 1665 + 2004 1666 static int aw88399_dev_init(struct aw88399 *aw88399, struct aw_container *aw_cfg) 2005 1667 { 2006 1668 struct aw_device *aw_dev = aw88399->aw_pa; ··· 2140 1708 aw88399_get_fade_out_time, aw88399_set_fade_out_time), 2141 1709 SOC_SINGLE_EXT("Calib", 0, 0, AW88399_CALI_RE_MAX, 0, 2142 1710 aw88399_re_get, aw88399_re_set), 1711 + SOC_SINGLE_BOOL_EXT("Calib Switch", 0, 1712 + aw88399_calib_switch_get, aw88399_calib_switch_set), 1713 + SOC_SINGLE_EXT("Trigger Calib", SND_SOC_NOPM, 0, 1, 0, 1714 + aw88399_calib_get, aw88399_calib_set), 2143 1715 AW88399_PROFILE_EXT("AW88399 Profile Set", aw88399_profile_info, 2144 1716 aw88399_profile_get, aw88399_profile_set), 2145 1717 };
+34
sound/soc/codecs/aw88399.h
··· 451 451 #define AW88399_WDT_CNT_MASK \ 452 452 (~(((1<<AW88399_WDT_CNT_BITS_LEN)-1) << AW88399_WDT_CNT_START_BIT)) 453 453 454 + #define AW88399_REABS_START_BIT (3) 455 + #define AW88399_REABS_BITS_LEN (1) 456 + #define AW88399_REABS_MASK \ 457 + (~(((1<<AW88399_REABS_BITS_LEN)-1) << AW88399_REABS_START_BIT)) 458 + 459 + #define AW88399_DSP_VOL_START_BIT (8) 460 + #define AW88399_DSP_VOL_BITS_LEN (8) 461 + #define AW88399_DSP_VOL_MASK \ 462 + (~(((1<<AW88399_DSP_VOL_BITS_LEN)-1) << AW88399_DSP_VOL_START_BIT)) 463 + 464 + #define AW883XX_DSP_NG_EN_START (13) 465 + #define AW883XX_DSP_NG_EN_LEN (1) 466 + #define AW883XX_DSP_NG_EN_MASK \ 467 + (~(((1 << AW883XX_DSP_NG_EN_LEN) - 1) << AW883XX_DSP_NG_EN_START)) 468 + #define AW883XX_DSP_NG_EN_DISABLE (0) 469 + #define AW883XX_DSP_NG_EN_DISABLE_VALUE \ 470 + (AW883XX_DSP_NG_EN_DISABLE << AW883XX_DSP_NG_EN_START) 471 + 454 472 #define AW88399_VOLUME_STEP_DB (64) 455 473 #define AW88399_VOL_DEFAULT_VALUE (0) 456 474 #define AW88399_DSP_ODD_NUM_BIT_TEST (0x5555) ··· 524 506 525 507 #define FADE_TIME_MAX 100000 526 508 #define FADE_TIME_MIN 0 509 + 510 + #define AW_CALI_READ_CNT_MAX (8) 511 + #define AW88399_DSP_REG_CALRE (0x8141) 512 + #define AW88399_DSP_REG_CALRE_SHIFT (10) 513 + #define AW_CALI_DATA_SUM_RM (2) 514 + 515 + #define AW88399_DSP_REG_CFG_MBMEC_ACTAMPTH (0x9B4C) 516 + #define AW88399_DSP_REG_CFG_MBMEC_NOISEAMPTH (0x9B4E) 517 + #define AW88399_DSP_REG_CFG_ADPZ_USTEPN (0x9B6E) 518 + #define AW88399_DSP_REG_CFG_RE_ALPHA (0x9BD4) 519 + #define AW_GET_IV_CNT_MAX (6) 520 + 521 + #define AW88399_DSP_VOL_MUTE (0XFF00) 522 + 523 + #define AW88399_DSP_LOW_POWER_SWITCH_CFG_ADDR (0x9BEC) 524 + #define AW88399_DSP_LOW_POWER_SWITCH_DISABLE (0x110b) 527 525 528 526 #define AW88399_PROFILE_EXT(xname, profile_info, profile_get, profile_set) \ 529 527 { \