static int regulator_virtual_probe(struct platform_device *pdev)
{
char *reg_id = dev_get_platdata(&pdev->dev);
struct virtual_consumer_data *drvdata;
int ret;
drvdata = devm_kzalloc(&pdev->dev, sizeof(struct virtual_consumer_data),
GFP_KERNEL);
if (drvdata == NULL)
return -ENOMEM;
mutex_init(&drvdata->lock);
drvdata->regulator = devm_regulator_get(&pdev->dev, reg_id);
if (IS_ERR(drvdata->regulator)) {
ret = PTR_ERR(drvdata->regulator);
dev_err(&pdev->dev, "Failed to obtain supply '%s': %d\n",
reg_id, ret);
return ret;
}
ret = sysfs_create_group(&pdev->dev.kobj,
®ulator_virtual_attr_group);
if (ret != 0) {
dev_err(&pdev->dev,
"Failed to create attribute group: %d\n", ret);
return ret;
}
drvdata->mode = regulator_get_mode(drvdata->regulator);
platform_set_drvdata(pdev, drvdata);
return 0;
}
static ssize_t pt_mode_show(struct device *d, struct device_attribute *attr,
char *buf)
{
REG_GET();
if (regulator_get_mode(reg) == REGULATOR_MODE_FAST)
return snprintf(buf, 5, "fast\n");
else
return snprintf(buf, 7, "normal\n");
}
size_t ft6x06_dsm_record_basic_info(struct ft6x06_ts_data * ft6x06_data, struct dsm_client * dsm_client)
{
ssize_t size = 0;
ssize_t total_size = 0;
if(!ft6x06_data)
{
tp_log_err("%s %d: ft6x06_data is null!\n", __func__, __LINE__);
return -1;
}
if(!dsm_client)
{
tp_log_err("%s %d: dsm_client is null!\n", __func__, __LINE__);
return -1;
}
/* power status: mode, enable, voltage*/
size = dsm_client_record(dsm_client,
"[vbus power] mode:%d, enable:%d, vol:%d\n"
"[vdd power] mode:%d, enable:%d, vol:%d\n",
regulator_get_mode(vbus_focaltech),
regulator_is_enabled(vbus_focaltech),
regulator_get_voltage(vbus_focaltech),
regulator_get_mode(vdd_focaltech),
regulator_is_enabled(vdd_focaltech),
regulator_get_voltage(vdd_focaltech));
total_size += size;
/* gpio status: irq, reset*/
size =dsm_client_record(dsm_client,
"[irq gpio] num:%d, irq gpio status:%d\n"
"[reset gpio] num:%d, reset gpio status:%d\n",
ft6x06_data->pdata->irq, gpio_get_value(ft6x06_data->pdata->reset),
ft6x06_data->pdata->reset, gpio_get_value(ft6x06_data->pdata->reset));
total_size += size;
return total_size;
}
/* Test regulator set and get mode method */
static int dm_test_power_regulator_set_get_mode(struct unit_test_state *uts)
{
const char *platname;
struct udevice *dev;
int val_set = LDO_OM_SLEEP;
/* Set the mode id to LDO_OM_SLEEP of LDO1 - default is LDO_OM_OFF */
platname = regulator_names[LDO1][PLATNAME];
ut_assertok(regulator_get_by_platname(platname, &dev));
ut_assertok(regulator_set_mode(dev, val_set));
/* Get the mode id of LDO1 and compare it with the requested one */
ut_asserteq(regulator_get_mode(dev), val_set);
return 0;
}
static int __devinit vref_consumer_probe(struct platform_device *pdev)
{
struct vref_platform_data *pdata = pdev->dev.platform_data;
struct vref_consumer_data *drvdata;
int ret;
drvdata = kzalloc(sizeof(struct vref_consumer_data), GFP_KERNEL);
if (drvdata == NULL)
return -ENOMEM;
mutex_init(&drvdata->lock);
vref_info("platform device name %s\n", pdata->name);
drvdata->regulator = regulator_get(&pdev->dev, pdata->name);
if (IS_ERR(drvdata->regulator)) {
ret = PTR_ERR(drvdata->regulator);
vref_err("Failed to obtain supply '%s': %d\n",
pdata->name, ret);
goto err;
}
ret = sysfs_create_group(&pdev->dev.kobj,
&vref_consumer_attr_group);
if (ret != 0) {
vref_err("Failed to create attribute group: %d\n", ret);
goto err_regulator;
}
drvdata->mode = regulator_get_mode(drvdata->regulator);
platform_set_drvdata(pdev, drvdata);
#ifdef DEBUG
vref_info("vref probe ok\n");
#endif
return 0;
err_regulator:
regulator_put(drvdata->regulator);
err:
kfree(drvdata);
return ret;
}
static int regulator_virtual_consumer_probe(struct platform_device *pdev)
{
char *reg_id = pdev->dev.platform_data;
struct virtual_consumer_data *drvdata;
int ret, i;
drvdata = kzalloc(sizeof(struct virtual_consumer_data), GFP_KERNEL);
if (drvdata == NULL) {
ret = -ENOMEM;
goto err;
}
mutex_init(&drvdata->lock);
//drvdata->regulator = regulator_get(&pdev->dev, reg_id);
drvdata->regulator = regulator_get(NULL, reg_id);
//drvdata->regulator = regulator_get(NULL, "axp20_analog/fm");
if (IS_ERR(drvdata->regulator)) {
ret = PTR_ERR(drvdata->regulator);
printk(KERN_ERR "%s:can't get regulator: %s\n",__FUNCTION__,reg_id);
goto err;
}
printk(KERN_DEBUG "%s:get regulator:%s ok\n",__FUNCTION__,reg_id);
for (i = 0; i < ARRAY_SIZE(attributes_virtual); i++) {
ret = device_create_file(&pdev->dev, attributes_virtual[i]);
if (ret != 0)
goto err;
}
drvdata->mode = regulator_get_mode(drvdata->regulator);
platform_set_drvdata(pdev, drvdata);
return 0;
err:
for (i = 0; i < ARRAY_SIZE(attributes_virtual); i++)
device_remove_file(&pdev->dev, attributes_virtual[i]);
kfree(drvdata);
return ret;
}
static int regulator_virtual_consumer_probe(struct platform_device *pdev)
{
char *reg_id = pdev->dev.platform_data;
struct virtual_consumer_data *drvdata;
int ret, i;
drvdata = kzalloc(sizeof(struct virtual_consumer_data), GFP_KERNEL);
if (drvdata == NULL) {
ret = -ENOMEM;
goto err;
}
mutex_init(&drvdata->lock);
drvdata->regulator = regulator_get(NULL, reg_id);
if (IS_ERR(drvdata->regulator)) {
ret = PTR_ERR(drvdata->regulator);
goto err;
}
for (i = 0; i < ARRAY_SIZE(attributes_virtual); i++) {
ret = device_create_file(&pdev->dev, attributes_virtual[i]);
if (ret != 0)
goto err;
}
drvdata->mode = regulator_get_mode(drvdata->regulator);
platform_set_drvdata(pdev, drvdata);
return 0;
err:
for (i = 0; i < ARRAY_SIZE(attributes_virtual); i++)
device_remove_file(&pdev->dev, attributes_virtual[i]);
kfree(drvdata);
// printk("axp22 regulator virtual get drvdata->regulator = %d err\n",drvdata->regulator);
return ret;
}
static long tcmd_misc_ioctl( struct file *file,
unsigned int cmd, unsigned long arg)
{
#ifdef CONFIG_TCMD
void __user *argp = (void __user *)arg;
int gpio_enum = -1, irq = -1, gpio_state = -1, rc = 0;
pr_info("tcmd_misc_ioctl is called");
switch(cmd)
{
case TCMD_IOCTL_SET_REG:
case TCMD_IOCTL_GET_REG:
{
tcmd_reg_arg reg_arg;
struct regulator *reg_p;
printk("TCMD_IOCTL_SET_REG or GET");
if (copy_from_user(®_arg, argp, sizeof(tcmd_reg_arg)))
return -EFAULT;
reg_p = regulator_get(NULL,reg_arg.name );
if (IS_ERR(reg_p))
{
printk("%s: VREG reg_p get failed\n", __func__);
reg_p = NULL;
return -EFAULT;
}
if(cmd == TCMD_IOCTL_GET_REG ) {
printk("cmd == TCMD_IOCTL_GET_REG ");
if(TCMD_REG_GET_VOLTAGE == reg_arg.cmd)
{ printk("cmd == TCMD_REG_GET_VOLTAGE ");
reg_arg.param = regulator_get_voltage(reg_p);
} else if(TCMD_REG_GET_POWER_MODE == reg_arg.cmd)
{
reg_arg.param = regulator_get_mode(reg_p);
}
if(copy_to_user((tcmd_reg_arg *)argp, ®_arg, sizeof(tcmd_reg_arg )))
return -EFAULT;
}
else {
switch(reg_arg.cmd)
{
case TCMD_REG_ENABLE :
printk("TCMD_REGULATOR_ENABLE\n");
rc = regulator_enable(reg_p);
if (rc) {
pr_info( " regulator_enable failed:%d\n", rc);
return rc;
}
break;
case TCMD_REG_DISABLE:
printk("TCMD_REGULATOR_DISABLE\n");
rc = regulator_disable(reg_p);
if (rc) {
pr_info( " regulator_disable failed:%d\n", rc);
return rc;
}
break;
case TCMD_REG_SET_VOLTAGE :
pr_info("TCMD_REG_SET_VOLTAGE, reg_arg.param= %d\n",reg_arg.param);
rc = regulator_set_voltage(reg_p, reg_arg.param, reg_arg.param);
if (rc) {
pr_info( " regulator_set_voltage failed:%d\n", rc);
return rc;
}
break;
case TCMD_REG_SET_POWER_MODE :
pr_info("TCMD_REG_SET_POWER_MODE, reg_arg.param= %d\n",reg_arg.param);
rc = regulator_set_mode(reg_p, reg_arg.param);
if (rc) {
pr_info( " regulator_set_mode failed:%d\n", rc);
return rc;
}
break;
default:
return -EINVAL;
break;
}
}
break;
}
case TCMD_IOCTL_CHARGER:
{
unsigned char charger_enable;
pr_info("cmd == TCMD_IOCTL_CHARGER");
if (copy_from_user(&charger_enable, argp, sizeof(unsigned char )))
return -EFAULT;
switch(charger_enable)
{
case 0:
rc = qpnp_disable_source_current(true);
if (rc)
{
printk("TCMD :tcmd_driver : qpnp_disable_source_current failed:%d\n", rc);
return rc;
}
break;
case 1:
rc = qpnp_set_max_battery_charge_current(true);
if (rc)
{
pr_info("TCMD : tcmd_driver : qpnp_set_max_battery_charge_current(true) failed:%d\n", rc);
return rc;
}
rc = qpnp_disable_source_current(false);
if (rc)
{
pr_info("TCMD : tcmd_driver : qpnp_disable_source_current(false) failed:%d\n", rc);
return rc;
}
printk("TCMD : Enable charging with high current successful");
break;
case 2:
rc = qpnp_set_max_battery_charge_current(false);
if (rc)
{
printk("TCMD : tcmd_driver : qpnp_set_max_battery_charge_current(false) failed:%d\n", rc);
return rc;
}
rc = qpnp_disable_source_current(false);
if (rc)
{
pr_info("TCMD : tcmd_driver : qpnp_disable_source_current(false) failed:%d\n", rc);
return rc;
}
printk("TCMD : Enable charging with low current successful");
break;
break;
default:
return -EINVAL;
break;
}
break;
}
case TCMD_IOCTL_USB_CHRGING:
{
unsigned char usb_charger_enable;
pr_info("TCMD: cmd = TCMD_IOCTL_USB_CHRGING");
if(copy_from_user(&usb_charger_enable, argp, sizeof(unsigned char)))
return -EFAULT;
switch(usb_charger_enable)
{
case 0:
printk("TCMD: tcmd_driver : Disable USB charging\n");
rc = qpnp_disable_usb_charging(!usb_charger_enable);
if(rc) {
printk("TCMD: qpnp-charger disable usb charging failed:%d\n", rc);
return rc;
}
break;
case 1:
printk("TCMD: tcmd_driver : Enable USB charging\n");
rc = qpnp_disable_usb_charging(!usb_charger_enable);
if(rc) {
printk("TCMD: qpnp-charger enable usb charging failed:%d\n", rc);
return rc;
}
}
break;
}
case TCMD_IOCTL_CHGPTH_PRIORITY:
{
unsigned char charging_path_priority;
pr_info("TCMD: cmd = TCMD_IOCTL_CHGPTH_PRIORITY\n");
if(copy_from_user(&charging_path_priority, argp, sizeof(unsigned char)))
return -EFAULT;
switch(charging_path_priority)
{
case 0:
printk("TCMD: tcmd_driver : USB_IN priority \n");
rc = qpnp_chg_priority(charging_path_priority);
if(rc) {
printk("TCMD: qpnp_chg_priority USB_IN failed:%d\n", rc);
return rc;
}
break;
case 1:
printk("TCMD: tcmd_driver : DC_IN priority \n");
rc = qpnp_chg_priority(charging_path_priority);
if(rc) {
printk("TCMD: qpnp_chg_priority DC_IN failed:%d\n", rc);
return rc;
}
}
break;
}
/*case TCMD_IOCTL_SET_FLASH_LM3559:
{
int flash_lm3559_state;
pr_info("TCMD_IOCTL_SET_FLASH_LM3559\n");
if(copy_from_user(&flash_lm3559_state, argp, sizeof(int)))
return -EFAULT;
rc = lm3559_flash_set_led_state(flash_lm3559_state);
if(rc){
pr_info("Error on calling set_flash_lm3559\n");
return rc;
}
break;
}*/
case TCMD_IOCTL_POWER_DOWN:
{
pr_info("TCMD_IOCTL_POWER_DOWN\n");
kernel_power_off();
break;
}
case TCMD_IOCTL_GET_ADC:
{
TCMD_QPNP_VADC_CHAN_PARAM adc_arg;
//struct qpnp_vadc_chip *vadc;
int ibat_ua;
printk("TCMD_IOCTL_GET_ADC");
if (copy_from_user(&adc_arg, argp, sizeof(TCMD_QPNP_VADC_CHAN_PARAM)))
return -EFAULT;
printk("adc_arg.cmd: %d",adc_arg.cmd);
if(!vchip)
{
printk("vchip is NULL\n");
}
if (adc_arg.cmd == TCMD_PMIC_ADC_BATTERY_CURRENT) {
printk("adc_arg.cmd == TCMD_PMIC_ADC_BATTERY_CURRENT");
rc = tcmd_get_battery_current(&ibat_ua);
adc_arg.adc_config.physical = ibat_ua;
adc_arg.adc_config.measurement = adc_arg.adc_config.physical;
} else {
rc = qpnp_vadc_read(vchip, adc_arg.cmd, &adc_arg.adc_config);
}
if (rc) {
pr_info("Error on calling qpnp_vadc_read");
return rc;
}
if(copy_to_user((TCMD_QPNP_VADC_CHAN_PARAM *)argp, &adc_arg, sizeof(TCMD_QPNP_VADC_CHAN_PARAM)))
return -EFAULT;
break;
}
case TCMD_IOCTL_SET_GPIO:
{
TCMD_PM8XXX_GPIO_PARAM gpio_arg;
printk("TCMD_IOCTL_SET_GPIO");
if (copy_from_user(&gpio_arg, argp, sizeof(TCMD_PM8XXX_GPIO_PARAM)))
return -EFAULT;
printk("gpio_arg.cmd: %d", gpio_arg.cmd);
rc = pm8xxx_gpio_config(gpio_arg.cmd, &gpio_arg.gpio_config);
if (rc) {
pr_info("Error on calling pm8xxx_gpio_config");
return rc;
}
break;
}
case TCMD_IOCTL_GET_USB_BAT_CURRENT:
{
int rc = -1;
TCMD_REG_USB_BAT_CURRENT adc_arg;
printk("TCMD_IOCTL_GET_USB_BAT_CURRENT");
if (copy_from_user(&adc_arg, argp, sizeof(TCMD_REG_USB_BAT_CURRENT)))
{
return -EFAULT;
}
qpnp_get_usb_max_current(&adc_arg.usbPresentCurrent);
rc = qpnp_get_bat_max_current(&adc_arg.batPresentCurrent);
if(rc < 0)
{
return rc;
}
if(copy_to_user((TCMD_REG_USB_BAT_CURRENT *)argp, &adc_arg, sizeof(TCMD_REG_USB_BAT_CURRENT)))
return -EFAULT;
return rc;
}
case TCMD_IOCTL_SET_USB_BAT_CURRENT:
{
int rc = -1;
TCMD_REG_USB_BAT_CURRENT adc_arg;
printk("TCMD_IOCTL_GET_USB_BAT_CURRENT");
if (copy_from_user(&adc_arg, argp, sizeof(TCMD_REG_USB_BAT_CURRENT)))
{
return -EFAULT;
}
rc = qpnp_set_usb_max_current(adc_arg.usbPresentCurrent);
if(rc < 0)
{
return rc;
}
rc = qpnp_set_bat_max_current(adc_arg.batPresentCurrent);
return rc;
}
case TCMD_IOCTL_COINCELL_ENABLE_DISABLE:
{
int coincell_state;
pr_info("TCMD_IOCTL_COINCELL_ENABLE_DISABLE\n");
if(copy_from_user(&coincell_state, argp, sizeof(int)))
return -EFAULT;
printk("TCMD:Set charger state entering with value : %d",coincell_state);
rc = tcmd_qpnp_coincell_set_charger(coincell_state);
if(rc) {
pr_info("Error on calling tcmd_qpnp_coincell_set_charger\n");
printk("TCMD:Error on calling tcms_qpnp_coincell_set_charger : %d",rc);
return rc;
}
printk("TCMD:Set charger state out with value : %d",rc);
break;
}
case TCMD_IOCTL_SET_COINCELL:
{
TCMD_QPNP_CC_CHG_PARAM coincell_arg;
printk("TCMD_IOCTL_SET_COINCELL");
if (copy_from_user(&coincell_arg, argp, sizeof(TCMD_QPNP_CC_CHG_PARAM)))
return -EFAULT;
//rc = pm8xxx_coincell_chg_config(&coincell_arg);
printk("\nState - > %d \n Voltage - > %d \n Resistance -> %d \n",coincell_arg.state,coincell_arg.voltage,coincell_arg.resistance);
if((rc = tcmd_qpnp_coincell_set_charger(coincell_arg.state))) {
printk("Error in configuring the state : tcmd_qpnp_coincell_set_charger : rc= %d",rc);
return rc;
}
if((rc = tcmd_qpnp_coincell_set_voltage(coincell_arg.voltage))) {
printk("Error in configuring Voltage :tcmd_qpnp_coincell_set_voltage: rc= %d",rc);
return rc;
}
if((rc = tcmd_qpnp_coincell_set_resistance(coincell_arg.resistance))) {
printk("Error in configuring Resistance :tcmd_qpnp_coincell_set_resistance : rc= %d",rc);
return rc;
}
if (rc) {
pr_info("Error on calling pm8xxx_coincell_chg_config ");
printk("value of rc = %d",rc);
return rc;
}
break;
}
/* case TCMD_IOCTL_SET_VIBRATOR:
{
TCMD_PM8XXX_VIB_PARAM vib_arg;
printk("TCMD_IOCTL_SET_VIBRATOR");
if (copy_from_user(&vib_arg, argp, sizeof(TCMD_PM8XXX_VIB_PARAM)))
return -EFAULT;
rc = pm8xxx_vibrator_config(&vib_arg);
if (rc) {
pr_info("Error on calling pm8xxx_vibrator_config");
return rc;
}
break;
}*/
default:
{
struct tcmd_gpio_set_arg gpio_set_arg;
if (cmd == TCMD_IOCTL_SET_INT) {
if (copy_from_user(&gpio_set_arg, argp, 2))
return -EFAULT;
gpio_enum = gpio_set_arg.gpio;
gpio_state = gpio_set_arg.gpio_state;
}
else if (copy_from_user(&gpio_enum, argp, sizeof(int)))
return -EFAULT;
if (gpio_enum < 0)
return -EINVAL;
switch (cmd) {
case TCMD_IOCTL_MASK_INT:
case TCMD_IOCTL_UNMASK_INT:
irq = gpio_to_irq(gpio_enum);
if (irq < 0)
return -EINVAL;
break;
default:
break;
}
switch (cmd) {
case TCMD_IOCTL_MASK_INT:
pr_info("tcmd mask interrupt: gpio = %d, irq = %d.\n",
gpio_enum, irq);
disable_irq(irq);
break;
case TCMD_IOCTL_UNMASK_INT:
pr_info("tcmd unmask interrupt: gpio = %d, irq = %d.\n",
gpio_enum, irq);
enable_irq(irq);
break;
case TCMD_IOCTL_READ_INT:
gpio_state = gpio_get_value(gpio_enum);
pr_info("tcmd interrupt state: gpio = %d -> %d.\n",
gpio_enum, gpio_state);
if (copy_to_user(argp, &gpio_state, sizeof(int)))
return -EFAULT;
break;
case TCMD_IOCTL_SET_INT:
pr_info("tcmd set interrupt state: gpio = %d -> %d.\n",
gpio_enum, gpio_state);
gpio_set_value(gpio_enum, gpio_state);
break;
default:
return -EINVAL;
}
break;
}//default
}
#endif
return 0;
}
ssize_t cyttsp5_dsm_record_basic_err_info(struct device *dev)
{
ssize_t size = 0;
ssize_t total_size = 0;
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
/* power status,include mode, is enable, voltage */
if((cd->cpdata->power_config->vbus_type == CY_POWER_PMU)&&(cd->cpdata->power_config->vbus_reg)) {
tp_log_debug("%s: record power!\n", __func__);
size = dsm_client_record(tp_cyp_dclient,
"[vbus power] mode:%d, enable:%d, vol:%d\n",
regulator_get_mode(cd->cpdata->power_config->vbus_reg),
regulator_is_enabled(cd->cpdata->power_config->vbus_reg),
regulator_get_voltage(cd->cpdata->power_config->vbus_reg));
total_size += size;
tp_log_err("[vbus power] mode:%d, enable:%d, vol:%d\n",
regulator_get_mode(cd->cpdata->power_config->vbus_reg),
regulator_is_enabled(cd->cpdata->power_config->vbus_reg),
regulator_get_voltage(cd->cpdata->power_config->vbus_reg));
}
if((cd->cpdata->power_config->vdd_type == CY_POWER_PMU)&&(cd->cpdata->power_config->vdd_reg)) {
tp_log_debug("%s: record power!\n", __func__);
size = dsm_client_record(tp_cyp_dclient,
"[vdd power] mode:%d, enable:%d, vol:%d\n",
regulator_get_mode(cd->cpdata->power_config->vdd_reg),
regulator_is_enabled(cd->cpdata->power_config->vdd_reg),
regulator_get_voltage(cd->cpdata->power_config->vdd_reg));
total_size += size;
tp_log_err("[vdd power] mode:%d, enable:%d, vol:%d\n",
regulator_get_mode(cd->cpdata->power_config->vdd_reg),
regulator_is_enabled(cd->cpdata->power_config->vdd_reg),
regulator_get_voltage(cd->cpdata->power_config->vdd_reg));
}
if (cd->cpdata->power_config->vdd_type == CY_POWER_GPIO) {
tp_log_debug("%s: record power!\n", __func__);
size = dsm_client_record(tp_cyp_dclient,
"[vdd power] mode:%d, enable:%d\n",
cd->cpdata->power_config->vdd_type,
gpio_get_value(cd->cpdata->power_config->vdd_en_gpio));
total_size += size;
tp_log_err("[vdd power] mode:%d, enable:%d\n",
cd->cpdata->power_config->vdd_type,
gpio_get_value(cd->cpdata->power_config->vdd_en_gpio));
}
if (cd->cpdata->power_config->vbus_type == CY_POWER_GPIO) {
tp_log_debug("%s: record power!\n", __func__);
size = dsm_client_record(tp_cyp_dclient,
"[vdd power] mode:%d, enable:%d\n",
cd->cpdata->power_config->vdd_type,
gpio_get_value(cd->cpdata->power_config->vbus_en_gpio));
total_size += size;
tp_log_err("[vdd power] mode:%d, enable:%d\n",
cd->cpdata->power_config->vdd_type,
gpio_get_value(cd->cpdata->power_config->vbus_en_gpio));
}
/* record irq and reset gpio status */
tp_log_debug("%s: record irq and reset gpio!\n", __func__);
size = dsm_client_record(tp_cyp_dclient,
"[irq gpio] num:%d, irq gpio status:%d\n"
"[reset gpio] num:%d, reset gpio status:%d\n",
g_tp_dsm_info.irq_gpio, gpio_get_value(g_tp_dsm_info.irq_gpio),
g_tp_dsm_info.rst_gpio, gpio_get_value(g_tp_dsm_info.rst_gpio));
total_size += size;
tp_log_err("[irq gpio] num:%d, irq gpio status:%d\n"
"[reset gpio] num:%d, reset gpio status:%d\n",
g_tp_dsm_info.irq_gpio, gpio_get_value(g_tp_dsm_info.irq_gpio),
g_tp_dsm_info.rst_gpio, gpio_get_value(g_tp_dsm_info.rst_gpio));
return total_size;
}
