1152 lines
29 KiB
C
1152 lines
29 KiB
C
/*
|
|
* ccic_sysfs.c
|
|
*
|
|
* Copyright (C) 2016 Samsung Electronics
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/device.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/uaccess.h>
|
|
#include <linux/ccic/ccic_sysfs.h>
|
|
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
#include <linux/ccic/s2mm005.h>
|
|
#include <linux/ccic/s2mm005_ext.h>
|
|
#include <linux/ccic/s2mm005_fw.h>
|
|
#include <linux/regulator/consumer.h>
|
|
#endif
|
|
|
|
#ifdef CONFIG_CCIC_S2MU004
|
|
#include <linux/ccic/usbpd.h>
|
|
#include <linux/ccic/usbpd-s2mu004.h>
|
|
#endif
|
|
|
|
#ifdef CONFIG_CCIC_S2MU106
|
|
#include <linux/ccic/usbpd.h>
|
|
#include <linux/ccic/usbpd-s2mu106.h>
|
|
#endif
|
|
|
|
#ifdef CONFIG_CCIC_S2MU205
|
|
#include <linux/ccic/usbpd.h>
|
|
#include <linux/ccic/usbpd-s2mu205.h>
|
|
#endif
|
|
|
|
#if defined(CONFIG_CCIC_ALTERNATE_MODE)
|
|
#include <linux/ccic/ccic_alternate.h>
|
|
#endif
|
|
static ssize_t ccic_cur_ver_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
struct s2mm005_version chip_swver;
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
|
|
s2mm005_get_chip_swversion(usbpd_data, &chip_swver);
|
|
pr_err("%s CHIP SWversion %2x %2x %2x %2x\n", __func__,
|
|
chip_swver.main[2] , chip_swver.main[1], chip_swver.main[0], chip_swver.boot);
|
|
|
|
usbpd_data->firm_ver[0] = chip_swver.main[2];
|
|
usbpd_data->firm_ver[1] = chip_swver.main[1];
|
|
usbpd_data->firm_ver[2] = chip_swver.main[0];
|
|
usbpd_data->firm_ver[3] = chip_swver.boot;
|
|
|
|
return sprintf(buf, "%02X %02X %02X %02X\n",
|
|
usbpd_data->firm_ver[0], usbpd_data->firm_ver[1],
|
|
usbpd_data->firm_ver[2], usbpd_data->firm_ver[3]);
|
|
#else
|
|
printk("Need implementation \n");
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
static DEVICE_ATTR(cur_version, 0444, ccic_cur_ver_show, NULL);
|
|
|
|
#ifdef CONFIG_CCIC_S2MU205
|
|
static ssize_t ccic_chip_name_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct s2mu205_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
return sprintf(buf, "%s\n", usbpd_data->name);
|
|
}
|
|
static DEVICE_ATTR(chip_name, 0444, ccic_chip_name_show, NULL);
|
|
#endif
|
|
|
|
static ssize_t ccic_src_ver_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
struct s2mm005_version fw_swver;
|
|
|
|
s2mm005_get_fw_version(usbpd_data->s2mm005_fw_product_id,
|
|
&fw_swver, usbpd_data->firm_ver[3], usbpd_data->hw_rev);
|
|
return sprintf(buf, "%02X %02X %02X %02X\n",
|
|
fw_swver.main[2], fw_swver.main[1], fw_swver.main[0], fw_swver.boot);
|
|
#else
|
|
printk("Need implementation \n");
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
static DEVICE_ATTR(src_version, 0444, ccic_src_ver_show, NULL);
|
|
|
|
static ssize_t ccic_show_manual_lpm_mode(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("usbpd_data is NULL\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
return sprintf(buf, "%d\n", usbpd_data->manual_lpm_mode);
|
|
#else
|
|
#ifdef CONFIG_CCIC_S2MU004
|
|
struct s2mu004_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU106
|
|
struct s2mu106_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU205
|
|
struct s2mu205_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
if (!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
return sprintf(buf, "%d\n", usbpd_data->lpm_mode);
|
|
#endif
|
|
|
|
|
|
}
|
|
static ssize_t ccic_store_manual_lpm_mode(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
int mode;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("usbpd_data is NULL\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
sscanf(buf, "%d", &mode);
|
|
pr_info("usb: %s mode=%d\n", __func__, mode);
|
|
|
|
switch(mode){
|
|
case 0:
|
|
/* Disable Low Power Mode for App (SW JIGON Disable) */
|
|
s2mm005_manual_JIGON(usbpd_data, 0);
|
|
usbpd_data->manual_lpm_mode = 0;
|
|
break;
|
|
case 1:
|
|
/* Enable Low Power Mode for App (SW JIGON Enable) */
|
|
s2mm005_manual_JIGON(usbpd_data, 1);
|
|
usbpd_data->manual_lpm_mode = 1;
|
|
break;
|
|
case 2:
|
|
/* SW JIGON Enable */
|
|
s2mm005_manual_JIGON(usbpd_data, 1);
|
|
// s2mm005_manual_LPM(usbpd_data, 0x1);
|
|
usbpd_data->manual_lpm_mode = 1;
|
|
break;
|
|
default:
|
|
/* SW JIGON Disable */
|
|
s2mm005_manual_JIGON(usbpd_data, 0);
|
|
usbpd_data->manual_lpm_mode = 0;
|
|
break;
|
|
}
|
|
|
|
return size;
|
|
#else
|
|
#ifdef CONFIG_CCIC_S2MU004
|
|
struct s2mu004_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU106
|
|
struct s2mu106_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU205
|
|
struct s2mu205_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
int mode;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
sscanf(buf, "%d", &mode);
|
|
pr_info("usb: %s mode=%d\n", __func__, mode);
|
|
|
|
mutex_lock(&usbpd_data->lpm_mutex);
|
|
|
|
#ifdef CONFIG_SEC_FACTORY
|
|
if (mode != 1 && mode != 2) {
|
|
#ifdef CONFIG_CCIC_S2MU004
|
|
s2mu004_set_normal_mode(usbpd_data);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU106
|
|
s2mu106_set_normal_mode(usbpd_data);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU205
|
|
s2mu205_set_normal_mode(usbpd_data);
|
|
#endif
|
|
}
|
|
#else
|
|
if (mode == 1 || mode == 2) {
|
|
#ifdef CONFIG_CCIC_S2MU004
|
|
s2mu004_set_lpm_mode(usbpd_data);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU106
|
|
s2mu106_set_lpm_mode(usbpd_data);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU205
|
|
s2mu205_set_lpm_mode(usbpd_data);
|
|
#endif
|
|
}
|
|
else {
|
|
#ifdef CONFIG_CCIC_S2MU004
|
|
s2mu004_set_normal_mode(usbpd_data);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU106
|
|
s2mu106_set_normal_mode(usbpd_data);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU205
|
|
s2mu205_set_normal_mode(usbpd_data);
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
mutex_unlock(&usbpd_data->lpm_mutex);
|
|
|
|
return size;
|
|
#endif
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR(lpm_mode, 0664,
|
|
ccic_show_manual_lpm_mode, ccic_store_manual_lpm_mode);
|
|
|
|
static ssize_t ccic_state_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
return sprintf(buf, "%d\n", usbpd_data->pd_state);
|
|
#else
|
|
#ifdef CONFIG_CCIC_S2MU004
|
|
struct s2mu004_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU106
|
|
struct s2mu106_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU205
|
|
struct s2mu205_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
} else {
|
|
struct usbpd_data *pd_data = dev_get_drvdata(usbpd_data->dev);
|
|
|
|
if (!pd_data) {
|
|
pr_err("%s pd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
return sprintf(buf, "%d\n", pd_data->policy.plug_valid);
|
|
}
|
|
#endif
|
|
}
|
|
static DEVICE_ATTR(state, 0444, ccic_state_show, NULL);
|
|
|
|
#if defined(CONFIG_SEC_FACTORY)
|
|
static ssize_t ccic_rid_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
return sprintf(buf, "%d\n", usbpd_data->cur_rid);
|
|
#else
|
|
#ifdef CONFIG_CCIC_S2MU004
|
|
struct s2mu004_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU106
|
|
struct s2mu106_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU205
|
|
struct s2mu205_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
return sprintf(buf, "%d\n", usbpd_data->rid == REG_RID_MAX ? REG_RID_OPEN : usbpd_data->rid);
|
|
|
|
#endif
|
|
|
|
}
|
|
static DEVICE_ATTR(rid, 0444, ccic_rid_show, NULL);
|
|
|
|
static ssize_t ccic_store_control_option_command(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
int cmd;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
sscanf(buf, "%d", &cmd);
|
|
pr_info("usb: %s mode=%d\n", __func__, cmd);
|
|
|
|
s2mm005_control_option_command(usbpd_data, cmd);
|
|
|
|
return size;
|
|
#else
|
|
#ifdef CONFIG_CCIC_S2MU004
|
|
struct s2mu004_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU106
|
|
struct s2mu106_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU205
|
|
struct s2mu205_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
int cmd;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
sscanf(buf, "%d", &cmd);
|
|
pr_info("usb: %s mode=%d\n", __func__, cmd);
|
|
|
|
#ifdef CONFIG_CCIC_S2MU004
|
|
s2mu004_control_option_command(usbpd_data, cmd);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU106
|
|
s2mu106_control_option_command(usbpd_data, cmd);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU205
|
|
s2mu205_control_option_command(usbpd_data, cmd);
|
|
#endif
|
|
return size;
|
|
|
|
#endif
|
|
|
|
|
|
}
|
|
static DEVICE_ATTR(ccic_control_option, 0220, NULL, ccic_store_control_option_command);
|
|
|
|
static ssize_t ccic_booting_dry_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
|
|
if(!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
pr_info("%s booting_run_dry=%d\n", __func__,
|
|
usbpd_data->fac_booting_dry_check);
|
|
|
|
return sprintf(buf, "%d\n", (usbpd_data->fac_booting_dry_check));
|
|
#else
|
|
pr_info("%s booting_run_dry is not supported \n", __func__);
|
|
return 0;
|
|
#endif
|
|
}
|
|
static DEVICE_ATTR(booting_dry, 0444, ccic_booting_dry_show, NULL);
|
|
#endif
|
|
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
static int ccic_firmware_update_built_in(struct device *dev)
|
|
{
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
struct s2mm005_version chip_swver, fw_swver;
|
|
|
|
s2mm005_get_chip_swversion(usbpd_data, &chip_swver);
|
|
pr_err("%s CHIP SWversion %2x %2x %2x %2x - before\n", __func__,
|
|
chip_swver.main[2] , chip_swver.main[1], chip_swver.main[0], chip_swver.boot);
|
|
s2mm005_get_fw_version(usbpd_data->s2mm005_fw_product_id,
|
|
&fw_swver, chip_swver.boot, usbpd_data->hw_rev);
|
|
pr_err("%s SRC SWversion:%2x,%2x,%2x,%2x\n",__func__,
|
|
fw_swver.main[2], fw_swver.main[1], fw_swver.main[0], fw_swver.boot);
|
|
|
|
pr_err("%s: FW UPDATE boot:%01d hw_rev:%02d\n", __func__, chip_swver.boot, usbpd_data->hw_rev);
|
|
|
|
if(chip_swver.main[0] == fw_swver.main[0]) {
|
|
pr_err("%s: FW version is same. Stop FW update. src:%2x chip:%2x\n",
|
|
__func__, chip_swver.main[0], fw_swver.main[0]);
|
|
goto done;
|
|
}
|
|
|
|
s2mm005_flash_fw(usbpd_data, chip_swver.boot);
|
|
|
|
done:
|
|
return 0;
|
|
}
|
|
|
|
static int ccic_firmware_update_ums(struct device *dev)
|
|
{
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
unsigned char *fw_data;
|
|
struct s2mm005_fw *fw_hd;
|
|
struct file *fp;
|
|
mm_segment_t old_fs;
|
|
long fw_size, nread;
|
|
int error = 0;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
old_fs = get_fs();
|
|
set_fs(KERNEL_DS);
|
|
|
|
fp = filp_open(CCIC_DEFAULT_UMS_FW, O_RDONLY, S_IRUSR);
|
|
if (IS_ERR(fp)) {
|
|
pr_err("%s: failed to open %s.\n", __func__,
|
|
CCIC_DEFAULT_UMS_FW);
|
|
error = -ENOENT;
|
|
goto open_err;
|
|
}
|
|
|
|
fw_size = fp->f_path.dentry->d_inode->i_size;
|
|
|
|
if (0 < fw_size) {
|
|
fw_data = kzalloc(fw_size, GFP_KERNEL);
|
|
nread = vfs_read(fp, (char __user *)fw_data, fw_size, &fp->f_pos);
|
|
|
|
pr_info("%s: start, file path %s, size %ld Bytes\n",
|
|
__func__, CCIC_DEFAULT_UMS_FW, fw_size);
|
|
filp_close(fp, NULL);
|
|
|
|
if (nread != fw_size) {
|
|
pr_err("%s: failed to read firmware file, nread %ld Bytes\n",
|
|
__func__, nread);
|
|
error = -EIO;
|
|
} else {
|
|
fw_hd = (struct s2mm005_fw *)fw_data;
|
|
pr_info("CCIC FW ver - cur:%02X %02X %02X %02X / bin:%02X %02X %02X %02X\n",
|
|
usbpd_data->firm_ver[0], usbpd_data->firm_ver[1], usbpd_data->firm_ver[2], usbpd_data->firm_ver[3],
|
|
fw_hd->boot, fw_hd->main[0], fw_hd->main[1], fw_hd->main[2]);
|
|
|
|
if (fw_hd->boot == usbpd_data->firm_ver[3]) {
|
|
if (s2mm005_flash_fw(usbpd_data, FLASH_WRITE_UMS) >= 0)
|
|
goto done;
|
|
} else {
|
|
pr_err("error : Didn't match to CCIC FW firmware version\n");
|
|
error = -EINVAL;
|
|
}
|
|
}
|
|
if (error < 0)
|
|
pr_err("%s: failed update firmware\n", __func__);
|
|
done:
|
|
kfree(fw_data);
|
|
}
|
|
|
|
open_err:
|
|
set_fs(old_fs);
|
|
return error;
|
|
}
|
|
|
|
static ssize_t ccic_store_firmware_status_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
u8 val = 0;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
s2mm005_read_byte_flash(usbpd_data->i2c, FLASH_STATUS_0x24, &val, 1);
|
|
pr_err("%s flash mode: %s\n", __func__, flashmode_to_string(val));
|
|
|
|
return sprintf(buf, "%s\n", flashmode_to_string(val));
|
|
}
|
|
static DEVICE_ATTR(fw_update_status, 0444, ccic_store_firmware_status_show, NULL);
|
|
|
|
static ssize_t ccic_store_firmware_update(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
struct s2mm005_version version;
|
|
int mode = 0, ret = 1;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("usbpd_data is NULL\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
sscanf(buf, "%d", &mode);
|
|
pr_info("%s mode=%d\n", __func__, mode);
|
|
|
|
s2mm005_get_chip_swversion(usbpd_data, &version);
|
|
pr_err("%s CHIP SWversion %2x %2x %2x %2x - before\n", __func__,
|
|
version.main[2] , version.main[1], version.main[0], version.boot);
|
|
|
|
/* Factory cmd for firmware update
|
|
* argument represent what is source of firmware like below.
|
|
* 0 : [BUILT_IN] Getting firmware from source.
|
|
* 1 : [UMS] Getting firmware from sd card.
|
|
*/
|
|
|
|
switch (mode) {
|
|
case BUILT_IN:
|
|
ret = ccic_firmware_update_built_in(dev);
|
|
break;
|
|
case UMS:
|
|
ret = ccic_firmware_update_ums(dev);
|
|
break;
|
|
default:
|
|
pr_err("%s: Not support command[%d]\n",
|
|
__func__, mode);
|
|
break;
|
|
}
|
|
|
|
s2mm005_get_chip_swversion(usbpd_data, &version);
|
|
pr_err("%s CHIP SWversion %2x %2x %2x %2x - after\n", __func__,
|
|
version.main[2] , version.main[1], version.main[0], version.boot);
|
|
|
|
return size;
|
|
}
|
|
static DEVICE_ATTR(fw_update, 0220, NULL, ccic_store_firmware_update);
|
|
|
|
static ssize_t ccic_store_sink_pdo_update(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
uint32_t data = 0;
|
|
uint16_t REG_ADD;
|
|
uint8_t MSG_BUF[32] = {0,};
|
|
SINK_VAR_SUPPLY_Typedef *pSINK_MSG;
|
|
MSG_HEADER_Typedef *pMSG_HEADER;
|
|
uint32_t * MSG_DATA;
|
|
uint8_t cnt;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("usbpd_data is NULL\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
sscanf(buf, "%x\n", &data);
|
|
if (data == 0)
|
|
data = 0x8F019032; // 5V~12V, 500mA
|
|
pr_info("%s data=0x%x\n", __func__, data);
|
|
|
|
/* update Sink PDO */
|
|
REG_ADD = REG_TX_SINK_CAPA_MSG;
|
|
s2mm005_read_byte(usbpd_data->i2c, REG_ADD, MSG_BUF, 32);
|
|
|
|
MSG_DATA = (uint32_t *)&MSG_BUF[0];
|
|
pr_err("--- Read Data on TX_SNK_CAPA_MSG(0x220)\n");
|
|
for(cnt = 0; cnt < 8; cnt++) {
|
|
pr_err(" 0x%08X\n", MSG_DATA[cnt]);
|
|
}
|
|
|
|
pMSG_HEADER = (MSG_HEADER_Typedef *)&MSG_BUF[0];
|
|
pMSG_HEADER->BITS.Number_of_obj += 1;
|
|
pSINK_MSG = (SINK_VAR_SUPPLY_Typedef *)&MSG_BUF[8];
|
|
pSINK_MSG->DATA = data;
|
|
pr_err("--- Write DATA\n");
|
|
for (cnt = 0; cnt < 8; cnt++) {
|
|
pr_err(" 0x%08X\n", MSG_DATA[cnt]);
|
|
}
|
|
|
|
s2mm005_write_byte(usbpd_data->i2c, REG_ADD, &MSG_BUF[0], 32);
|
|
|
|
for (cnt = 0; cnt < 32; cnt++) {
|
|
MSG_BUF[cnt] = 0;
|
|
}
|
|
|
|
for (cnt = 0; cnt < 8; cnt++) {
|
|
pr_err(" 0x%08X\n", MSG_DATA[cnt]);
|
|
}
|
|
s2mm005_read_byte(usbpd_data->i2c, REG_ADD, MSG_BUF, 32);
|
|
|
|
pr_err("--- Read 2 new Data on TX_SNK_CAPA_MSG(0x220)\n");
|
|
for(cnt = 0; cnt < 8; cnt++) {
|
|
pr_err(" 0x%08X\n", MSG_DATA[cnt]);
|
|
}
|
|
|
|
return size;
|
|
}
|
|
static DEVICE_ATTR(sink_pdo_update, 0220, NULL, ccic_store_sink_pdo_update);
|
|
#endif
|
|
|
|
#if defined(CONFIG_CCIC_ALTERNATE_MODE)
|
|
static ssize_t ccic_send_samsung_uVDM_message(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
int ret = 0;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("usbpd_data is NULL\n");
|
|
return -ENODEV;
|
|
}
|
|
ret = send_samsung_unstructured_vdm_message(usbpd_data, buf, size);
|
|
if( ret < 0 )
|
|
return ret;
|
|
else
|
|
return size;
|
|
}
|
|
static DEVICE_ATTR(samsung_uvdm, 0220, NULL, ccic_send_samsung_uVDM_message);
|
|
|
|
static ssize_t ccic_send_uVDM_message(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
int cmd = 0;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("usbpd_data is NULL\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
sscanf(buf, "%d", &cmd);
|
|
pr_info("%s cmd=%d\n", __func__, cmd);
|
|
|
|
send_unstructured_vdm_message(usbpd_data, cmd);
|
|
|
|
return size;
|
|
}
|
|
static DEVICE_ATTR(uvdm, 0220, NULL, ccic_send_uVDM_message);
|
|
|
|
static ssize_t ccic_send_dna_audio_uVDM_message(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
int cmd = 0;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("usbpd_data is NULL\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
sscanf(buf, "%d", &cmd);
|
|
pr_info("%s cmd=%d\n", __func__, cmd);
|
|
|
|
send_dna_audio_unstructured_vdm_message(usbpd_data, cmd);
|
|
|
|
return size;
|
|
}
|
|
static DEVICE_ATTR(dna_audio_uvdm, 0220, NULL, ccic_send_dna_audio_uVDM_message);
|
|
|
|
static ssize_t ccic_send_dex_fan_uVDM_message(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
int cmd = 0;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("usbpd_data is NULL\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
sscanf(buf, "%d", &cmd);
|
|
pr_info("%s cmd=%d\n", __func__, cmd);
|
|
|
|
send_dex_fan_unstructured_vdm_message(usbpd_data, cmd);
|
|
|
|
return size;
|
|
}
|
|
static DEVICE_ATTR(dex_fan_uvdm, 0220, NULL, ccic_send_dex_fan_uVDM_message);
|
|
|
|
static ssize_t ccic_send_attention_message(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
int cmd = 0;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("usbpd_data is NULL\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
sscanf(buf, "%d", &cmd);
|
|
pr_info("%s cmd=%d\n", __func__, cmd);
|
|
|
|
send_attention_message(usbpd_data, cmd);
|
|
|
|
return size;
|
|
}
|
|
static DEVICE_ATTR(attention, 0220, NULL, ccic_send_attention_message);
|
|
|
|
static ssize_t ccic_send_role_swap_message(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
int cmd = 0;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("usbpd_data is NULL\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
sscanf(buf, "%d", &cmd);
|
|
pr_info("%s cmd=%d\n", __func__, cmd);
|
|
|
|
send_role_swap_message(usbpd_data, cmd);
|
|
|
|
return size;
|
|
}
|
|
static DEVICE_ATTR(role_swap, 0220, NULL, ccic_send_role_swap_message);
|
|
#endif
|
|
|
|
static ssize_t ccic_acc_device_version_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
pr_info("%s 0x%04x\n", __func__, usbpd_data->Device_Version);
|
|
|
|
return sprintf(buf, "%04x\n", usbpd_data->Device_Version);
|
|
#else
|
|
#ifdef CONFIG_CCIC_S2MU004
|
|
struct s2mu004_usbpd_data *pdic_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU106
|
|
struct s2mu106_usbpd_data *pdic_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU205
|
|
struct s2mu205_usbpd_data *pdic_data = dev_get_drvdata(dev);
|
|
#endif
|
|
struct usbpd_data *pd_data;
|
|
struct usbpd_manager_data *manager;
|
|
|
|
if (!pdic_data) {
|
|
pr_err("%s data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
pd_data = dev_get_drvdata(pdic_data->dev);
|
|
if (!pd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
manager = &pd_data->manager;
|
|
if (!manager) {
|
|
pr_err("%s manager_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
pr_info("%s 0x%04x\n", __func__, manager->Device_Version);
|
|
|
|
return sprintf(buf, "%04x\n", manager->Device_Version);
|
|
#endif
|
|
}
|
|
static DEVICE_ATTR(acc_device_version, 0444, ccic_acc_device_version_show,NULL);
|
|
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
static ssize_t ccic_set_gpio(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
int mode;
|
|
u8 W_DATA[2];
|
|
u8 REG_ADD;
|
|
u8 R_DATA;
|
|
int i;
|
|
struct device_node *np = NULL;
|
|
const char *ss_vdd;
|
|
int ret = 0;
|
|
struct regulator *vdd085_usb;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("usbpd_data is NULL\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
sscanf(buf, "%d", &mode);
|
|
pr_info("usb: %s mode=%d\n", __func__, mode);
|
|
|
|
/* VDD_USB_3P0_AP is on for DP SWITCH */
|
|
np = of_find_compatible_node(NULL, NULL, "samsung,usb-notifier");
|
|
if (!np) {
|
|
pr_err("%s: failed to get the battery device node\n", __func__);
|
|
return 0;
|
|
} else {
|
|
if(of_property_read_string(np, "hs-regulator", (char const **)&ss_vdd) < 0) {
|
|
pr_err("%s - get ss_vdd error\n", __func__);
|
|
}
|
|
|
|
vdd085_usb = regulator_get(NULL, ss_vdd);
|
|
if (IS_ERR(vdd085_usb) || vdd085_usb == NULL) {
|
|
pr_err("%s - vdd085_usb regulator_get fail\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
/* for Wake up*/
|
|
for(i=0; i<5; i++){
|
|
R_DATA = 0x00;
|
|
REG_ADD = 0x8;
|
|
s2mm005_read_byte(usbpd_data->i2c, REG_ADD, &R_DATA, 1); //dummy read
|
|
}
|
|
udelay(10);
|
|
|
|
switch(mode){
|
|
case 0:
|
|
if (!regulator_is_enabled(vdd085_usb)) {
|
|
ret = regulator_enable(vdd085_usb);
|
|
if (ret) {
|
|
pr_err("%s - enable vdd085_usb ldo enable failed, ret=%d\n",
|
|
__func__, ret);
|
|
regulator_put(vdd085_usb);
|
|
return 0;
|
|
}
|
|
}
|
|
regulator_put(vdd085_usb);
|
|
|
|
/* SBU1/SBU2 set as open-drain status*/
|
|
// SBU1/2 Open command ON
|
|
REG_ADD = 0x10;
|
|
W_DATA[0] = 0x03;
|
|
W_DATA[1] = 0x85;
|
|
s2mm005_write_byte(usbpd_data->i2c, REG_ADD, &W_DATA[0], 2);
|
|
|
|
break;
|
|
case 1:
|
|
/* SBU1/SBU2 set as default status */
|
|
// SBU1/2 Open command OFF
|
|
REG_ADD = 0x10;
|
|
W_DATA[0] = 0x03;
|
|
W_DATA[1] = 0x86;
|
|
s2mm005_write_byte(usbpd_data->i2c, REG_ADD, &W_DATA[0], 2);
|
|
|
|
if (regulator_is_enabled(vdd085_usb)) {
|
|
ret = regulator_disable(vdd085_usb);
|
|
if (ret) {
|
|
pr_err("%s - enable vdd085_usb ldo enable failed, ret=%d\n",
|
|
__func__, ret);
|
|
regulator_put(vdd085_usb);
|
|
return 0;
|
|
}
|
|
}
|
|
regulator_put(vdd085_usb);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
static ssize_t ccic_get_gpio(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
u8 W_DATA[4];
|
|
u8 REG_ADD;
|
|
u8 R_DATA;
|
|
int i;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("usbpd_data is NULL\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
/* for Wake up*/
|
|
for(i=0; i<5; i++){
|
|
R_DATA = 0x00;
|
|
REG_ADD = 0x8;
|
|
s2mm005_read_byte(usbpd_data->i2c, REG_ADD, &R_DATA, 1); //dummy read
|
|
}
|
|
udelay(10);
|
|
|
|
W_DATA[0] =0x2;
|
|
W_DATA[1] =0x10;
|
|
|
|
W_DATA[2] =0x84;
|
|
W_DATA[3] =0x10;
|
|
|
|
s2mm005_write_byte(usbpd_data->i2c, 0x10, &W_DATA[0], 4);
|
|
s2mm005_read_byte(usbpd_data->i2c, 0x14, &R_DATA, 1);
|
|
|
|
pr_err("%s SBU1 status = %2x , SBU2 status = %2x \n", __func__,
|
|
(R_DATA & 0x10) >> 4,(R_DATA & 0x20) >> 5);
|
|
|
|
return sprintf(buf, "%d %d\n", (R_DATA & 0x10) >> 4,(R_DATA & 0x20) >> 5);
|
|
|
|
}
|
|
static DEVICE_ATTR(control_gpio, 0664, ccic_get_gpio, ccic_set_gpio);
|
|
#endif
|
|
|
|
#if defined(CONFIG_SEC_FACTORY)
|
|
#if defined(CONFIG_CCIC_S2MU106) || defined(CONFIG_CCIC_S2MU205)
|
|
static ssize_t ccic_power_off_water_check_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
#if defined(CONFIG_CCIC_S2MU106)
|
|
struct s2mu106_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#elif defined(CONFIG_CCIC_S2MU205)
|
|
struct s2mu205_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
int ret = 0;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
#if defined(CONFIG_CCIC_S2MU106)
|
|
ret = s2mu106_sys_power_off_water_check(usbpd_data);
|
|
#elif defined(CONFIG_CCIC_S2MU205)
|
|
ret = s2mu205_power_off_water_check(usbpd_data);
|
|
#endif
|
|
|
|
return sprintf(buf, "%d\n", ret);
|
|
}
|
|
|
|
static DEVICE_ATTR(water_check, 0444, ccic_power_off_water_check_show, NULL);
|
|
#endif
|
|
#endif /* CONFIG_SEC_FACTORY */
|
|
|
|
static ssize_t ccic_usbpd_ids_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
int retval = 0;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
retval = sprintf(buf, "%04x:%04x\n",
|
|
le16_to_cpu(usbpd_data->Vendor_ID),
|
|
le16_to_cpu(usbpd_data->Product_ID));
|
|
pr_info("usb: %s : %s",
|
|
__func__, buf);
|
|
#else
|
|
#ifdef CONFIG_CCIC_S2MU004
|
|
struct s2mu004_usbpd_data *pdic_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU106
|
|
struct s2mu106_usbpd_data *pdic_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU205
|
|
struct s2mu205_usbpd_data *pdic_data = dev_get_drvdata(dev);
|
|
#endif
|
|
struct usbpd_data *pd_data;
|
|
struct usbpd_manager_data *manager;
|
|
int retval = 0;
|
|
|
|
if (!pdic_data) {
|
|
pr_err("%s data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
pd_data = dev_get_drvdata(pdic_data->dev);
|
|
if (!pd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
manager = &pd_data->manager;
|
|
if (!manager) {
|
|
pr_err("%s manager_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
retval = sprintf(buf, "%04x:%04x\n",
|
|
le16_to_cpu(manager->Vendor_ID),
|
|
le16_to_cpu(manager->Product_ID));
|
|
pr_info("usb: %s : %s",
|
|
__func__, buf);
|
|
#endif
|
|
return retval;
|
|
}
|
|
static DEVICE_ATTR(usbpd_ids, 0444, ccic_usbpd_ids_show, NULL);
|
|
|
|
static ssize_t ccic_usbpd_type_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
int retval = 0;
|
|
|
|
if (!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
retval = sprintf(buf, "%d\n", usbpd_data->acc_type);
|
|
pr_info("usb: %s : %d",
|
|
__func__, usbpd_data->acc_type);
|
|
#else
|
|
#ifdef CONFIG_CCIC_S2MU004
|
|
struct s2mu004_usbpd_data *pdic_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU106
|
|
struct s2mu106_usbpd_data *pdic_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU205
|
|
struct s2mu205_usbpd_data *pdic_data = dev_get_drvdata(dev);
|
|
#endif
|
|
struct usbpd_data *pd_data;
|
|
struct usbpd_manager_data *manager;
|
|
int retval = 0;
|
|
|
|
if (!pdic_data) {
|
|
pr_err("%s data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
pd_data = dev_get_drvdata(pdic_data->dev);
|
|
if (!pd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
manager = &pd_data->manager;
|
|
if (!manager) {
|
|
pr_err("%s manager_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
retval = sprintf(buf, "%d\n", manager->acc_type);
|
|
pr_info("usb: %s : %d",
|
|
__func__, manager->acc_type);
|
|
#endif
|
|
return retval;
|
|
}
|
|
static DEVICE_ATTR(usbpd_type, 0444, ccic_usbpd_type_show, NULL);
|
|
|
|
static ssize_t ccic_water_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
struct s2mm005_data *usbpd_data = dev_get_drvdata(dev);
|
|
|
|
if(!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
pr_info("%s water=%d, run_dry=%d\n", __func__,
|
|
usbpd_data->water_det, usbpd_data->run_dry);
|
|
|
|
return sprintf(buf, "%d\n", (usbpd_data->water_det | !usbpd_data->run_dry));
|
|
#else
|
|
#ifdef CONFIG_CCIC_S2MU004
|
|
struct s2mu004_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU106
|
|
struct s2mu106_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MU205
|
|
struct s2mu205_usbpd_data *usbpd_data = dev_get_drvdata(dev);
|
|
#endif
|
|
|
|
if(!usbpd_data) {
|
|
pr_err("%s usbpd_data is null!!\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
pr_info("%s is_water_detect=%d\n", __func__,
|
|
(int)usbpd_data->is_water_detect);
|
|
|
|
return sprintf(buf, "%d\n", usbpd_data->is_water_detect);
|
|
#endif
|
|
}
|
|
static DEVICE_ATTR(water, 0444, ccic_water_show, NULL);
|
|
|
|
static struct attribute *ccic_attributes[] = {
|
|
&dev_attr_cur_version.attr,
|
|
&dev_attr_src_version.attr,
|
|
&dev_attr_lpm_mode.attr,
|
|
&dev_attr_state.attr,
|
|
#if defined(CONFIG_SEC_FACTORY)
|
|
&dev_attr_rid.attr,
|
|
&dev_attr_ccic_control_option.attr,
|
|
&dev_attr_booting_dry.attr,
|
|
#endif
|
|
#if (defined(CONFIG_CCIC_S2MU106) || defined(CONFIG_CCIC_S2MU205)) && defined(CONFIG_SEC_FACTORY)
|
|
&dev_attr_water_check.attr,
|
|
#endif
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
&dev_attr_fw_update.attr,
|
|
&dev_attr_fw_update_status.attr,
|
|
&dev_attr_sink_pdo_update.attr,
|
|
#endif
|
|
#if defined(CONFIG_CCIC_ALTERNATE_MODE)
|
|
&dev_attr_uvdm.attr,
|
|
&dev_attr_attention.attr,
|
|
&dev_attr_role_swap.attr,
|
|
&dev_attr_samsung_uvdm.attr,
|
|
&dev_attr_dna_audio_uvdm.attr,
|
|
&dev_attr_dex_fan_uvdm.attr,
|
|
#endif
|
|
&dev_attr_acc_device_version.attr,
|
|
&dev_attr_usbpd_ids.attr,
|
|
&dev_attr_usbpd_type.attr,
|
|
#ifdef CONFIG_CCIC_S2MM005
|
|
&dev_attr_control_gpio.attr,
|
|
#endif
|
|
&dev_attr_water.attr,
|
|
#ifdef CONFIG_CCIC_S2MU205
|
|
&dev_attr_chip_name.attr,
|
|
#endif
|
|
NULL
|
|
};
|
|
|
|
const struct attribute_group ccic_sysfs_group = {
|
|
.attrs = ccic_attributes,
|
|
};
|
|
|