432 lines
16 KiB
C
432 lines
16 KiB
C
/*
|
|
* driver/../s2mm005.c - S2MM005 USB PD function driver
|
|
*
|
|
* Copyright (C) 2015 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/ccic/s2mm005_ext.h>
|
|
#include <linux/power_supply.h>
|
|
#if defined(CONFIG_BATTERY_NOTIFIER)
|
|
#include <linux/battery/battery_notifier.h>
|
|
#endif
|
|
#if defined(CONFIG_USB_HOST_NOTIFY)
|
|
#include <linux/usb_notify.h>
|
|
#endif
|
|
#if defined(CONFIG_CCIC_ALTERNATE_MODE)
|
|
#include <linux/ccic/ccic_alternate.h>
|
|
#endif
|
|
|
|
struct pdic_notifier_struct pd_noti;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// function definition
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
void select_pdo(int num);
|
|
void s2mm005_select_pdo(int num);
|
|
void select_pdo(int num);
|
|
void (*fp_select_pdo)(int num);
|
|
void vbus_turn_on_ctrl(bool enable);
|
|
void process_pd(void *data, u8 plug_attach_done, u8 *pdic_attach, MSG_IRQ_STATUS_Type *MSG_IRQ_State);
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// PD function will be merged
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
static inline struct power_supply *get_power_supply_by_name(char *name)
|
|
{
|
|
if (!name)
|
|
return (struct power_supply *)NULL;
|
|
else
|
|
return power_supply_get_by_name(name);
|
|
}
|
|
|
|
void s2mm005_select_pdo(int num)
|
|
{
|
|
uint8_t CMD_DATA[3];
|
|
|
|
if (pd_noti.sink_status.selected_pdo_num == num)
|
|
return;
|
|
else if (num > pd_noti.sink_status.available_pdo_num)
|
|
pd_noti.sink_status.selected_pdo_num = pd_noti.sink_status.available_pdo_num;
|
|
else if (num < 1)
|
|
pd_noti.sink_status.selected_pdo_num = 1;
|
|
else
|
|
pd_noti.sink_status.selected_pdo_num = num;
|
|
pr_info(" %s : PDO(%d) is selected to change\n", __func__, pd_noti.sink_status.selected_pdo_num);
|
|
|
|
CMD_DATA[0] = 0x3;
|
|
CMD_DATA[1] = 0x3;
|
|
CMD_DATA[2] = pd_noti.sink_status.selected_pdo_num;
|
|
s2mm005_write_byte(pd_noti.pusbpd->i2c, REG_I2C_SLV_CMD, &CMD_DATA[0], 3);
|
|
|
|
CMD_DATA[0] = 0x3;
|
|
CMD_DATA[1] = 0x2;
|
|
CMD_DATA[2] = State_PE_SNK_Wait_for_Capabilities;
|
|
s2mm005_write_byte(pd_noti.pusbpd->i2c, REG_I2C_SLV_CMD, &CMD_DATA[0], 3);
|
|
}
|
|
|
|
void select_pdo(int num)
|
|
{
|
|
if (fp_select_pdo)
|
|
fp_select_pdo(num);
|
|
}
|
|
|
|
void vbus_turn_on_ctrl(bool enable)
|
|
{
|
|
struct power_supply *psy_otg;
|
|
union power_supply_propval val;
|
|
int on = !!enable;
|
|
int ret = 0;
|
|
|
|
#if defined(CONFIG_USB_HOST_NOTIFY)
|
|
struct otg_notify *o_notify = get_otg_notify();
|
|
bool must_block_host = 0;
|
|
bool unsupport_host = 0;
|
|
if (o_notify)
|
|
must_block_host = is_blocked(o_notify, NOTIFY_BLOCK_TYPE_HOST);
|
|
|
|
pr_info("%s : enable=%d, must_block_host=%d\n",
|
|
__func__, enable, must_block_host);
|
|
|
|
if (enable) {
|
|
if (o_notify)
|
|
unsupport_host = !is_usb_host(o_notify);
|
|
pr_info("%s : unsupport_host=%d\n", __func__, unsupport_host);
|
|
|
|
if (must_block_host || unsupport_host) {
|
|
enable = false;
|
|
pr_info("%s : turn off vbus because of blocked host\n",
|
|
__func__);
|
|
}
|
|
} else {
|
|
// don't turn off because of blocked (already off)
|
|
if (must_block_host)
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
pr_info("%s %d, enable=%d\n", __func__, __LINE__, enable);
|
|
psy_otg = get_power_supply_by_name("otg");
|
|
if (psy_otg) {
|
|
val.intval = enable;
|
|
ret = psy_otg->desc->set_property(psy_otg, POWER_SUPPLY_PROP_ONLINE, &val);
|
|
} else {
|
|
pr_err("%s: Fail to get psy battery\n", __func__);
|
|
}
|
|
if (ret) {
|
|
pr_err("%s: fail to set power_suppy ONLINE property(%d)\n",
|
|
__func__, ret);
|
|
} else {
|
|
pr_info("otg accessory power = %d\n", on);
|
|
}
|
|
|
|
}
|
|
|
|
static int s2mm005_src_capacity_information(const struct i2c_client *i2c, uint32_t *RX_SRC_CAPA_MSG,
|
|
PDIC_SINK_STATUS * pd_sink_status, uint8_t *do_power_nego)
|
|
{
|
|
uint32_t RdCnt;
|
|
uint32_t PDO_cnt;
|
|
uint32_t PDO_sel;
|
|
int available_pdo_num = 0;
|
|
int num_of_obj = 0;
|
|
|
|
MSG_HEADER_Type *MSG_HDR;
|
|
SRC_FIXED_SUPPLY_Typedef *MSG_FIXED_SUPPLY;
|
|
SRC_VAR_SUPPLY_Typedef *MSG_VAR_SUPPLY;
|
|
SRC_BAT_SUPPLY_Typedef *MSG_BAT_SUPPLY;
|
|
|
|
dev_info(&i2c->dev, "\n");
|
|
for(RdCnt=0;RdCnt<8;RdCnt++)
|
|
{
|
|
dev_info(&i2c->dev, "Rd_SRC_CAPA_%d : 0x%X\n", RdCnt, RX_SRC_CAPA_MSG[RdCnt]);
|
|
}
|
|
|
|
MSG_HDR = (MSG_HEADER_Type *)&RX_SRC_CAPA_MSG[0];
|
|
dev_info(&i2c->dev, "=======================================\n");
|
|
dev_info(&i2c->dev, " MSG Header\n");
|
|
|
|
dev_info(&i2c->dev, " Rsvd_msg_header : %d\n",MSG_HDR->Rsvd_msg_header );
|
|
dev_info(&i2c->dev, " Number_of_obj : %d\n",MSG_HDR->Number_of_obj );
|
|
dev_info(&i2c->dev, " Message_ID : %d\n",MSG_HDR->Message_ID );
|
|
dev_info(&i2c->dev, " Port_Power_Role : %d\n",MSG_HDR->Port_Power_Role );
|
|
dev_info(&i2c->dev, " Specification_Revision : %d\n",MSG_HDR->Specification_Revision );
|
|
dev_info(&i2c->dev, " Port_Data_Role : %d\n",MSG_HDR->Port_Data_Role );
|
|
dev_info(&i2c->dev, " Rsvd2_msg_header : %d\n",MSG_HDR->Rsvd2_msg_header );
|
|
dev_info(&i2c->dev, " Message_Type : %d\n",MSG_HDR->Message_Type );
|
|
|
|
num_of_obj = MSG_HDR->Number_of_obj > MAX_PDO_NUM ? MAX_PDO_NUM : MSG_HDR->Number_of_obj;
|
|
for(PDO_cnt = 0;PDO_cnt < num_of_obj;PDO_cnt++)
|
|
{
|
|
PDO_sel = (RX_SRC_CAPA_MSG[PDO_cnt + 1] >> 30) & 0x3;
|
|
dev_info(&i2c->dev, " =================\n");
|
|
dev_info(&i2c->dev, " PDO_Num : %d\n", (PDO_cnt + 1));
|
|
|
|
if(PDO_sel == 0) // *MSG_FIXED_SUPPLY
|
|
{
|
|
MSG_FIXED_SUPPLY = (SRC_FIXED_SUPPLY_Typedef *)&RX_SRC_CAPA_MSG[PDO_cnt + 1];
|
|
if(MSG_FIXED_SUPPLY->Voltage_Unit <= (AVAILABLE_VOLTAGE/UNIT_FOR_VOLTAGE))
|
|
available_pdo_num = PDO_cnt + 1;
|
|
if (!(*do_power_nego) &&
|
|
(pd_sink_status->power_list[PDO_cnt+1].max_voltage != MSG_FIXED_SUPPLY->Voltage_Unit * UNIT_FOR_VOLTAGE ||
|
|
pd_sink_status->power_list[PDO_cnt+1].max_current != MSG_FIXED_SUPPLY->Maximum_Current * UNIT_FOR_CURRENT))
|
|
*do_power_nego = 1;
|
|
pd_sink_status->power_list[PDO_cnt+1].max_voltage = MSG_FIXED_SUPPLY->Voltage_Unit * UNIT_FOR_VOLTAGE;
|
|
pd_sink_status->power_list[PDO_cnt+1].max_current = MSG_FIXED_SUPPLY->Maximum_Current * UNIT_FOR_CURRENT;
|
|
|
|
dev_info(&i2c->dev, " PDO_Parameter(FIXED_SUPPLY) : %d\n",MSG_FIXED_SUPPLY->PDO_Parameter );
|
|
dev_info(&i2c->dev, " Dual_Role_Power : %d\n",MSG_FIXED_SUPPLY->Dual_Role_Power );
|
|
dev_info(&i2c->dev, " USB_Suspend_Support : %d\n",MSG_FIXED_SUPPLY->USB_Suspend_Support );
|
|
dev_info(&i2c->dev, " Externally_POW : %d\n",MSG_FIXED_SUPPLY->Externally_POW );
|
|
dev_info(&i2c->dev, " USB_Comm_Capable : %d\n",MSG_FIXED_SUPPLY->USB_Comm_Capable );
|
|
dev_info(&i2c->dev, " Data_Role_Swap : %d\n",MSG_FIXED_SUPPLY->Data_Role_Swap );
|
|
dev_info(&i2c->dev, " Reserved : %d\n",MSG_FIXED_SUPPLY->Reserved );
|
|
dev_info(&i2c->dev, " Peak_Current : %d\n",MSG_FIXED_SUPPLY->Peak_Current );
|
|
dev_info(&i2c->dev, " Voltage_Unit : %d\n",MSG_FIXED_SUPPLY->Voltage_Unit );
|
|
dev_info(&i2c->dev, " Maximum_Current : %d\n",MSG_FIXED_SUPPLY->Maximum_Current );
|
|
}
|
|
else if(PDO_sel == 2) // *MSG_VAR_SUPPLY
|
|
{
|
|
MSG_VAR_SUPPLY = (SRC_VAR_SUPPLY_Typedef *)&RX_SRC_CAPA_MSG[PDO_cnt + 1];
|
|
|
|
dev_info(&i2c->dev, " PDO_Parameter(VAR_SUPPLY) : %d\n",MSG_VAR_SUPPLY->PDO_Parameter );
|
|
dev_info(&i2c->dev, " Maximum_Voltage : %d\n",MSG_VAR_SUPPLY->Maximum_Voltage );
|
|
dev_info(&i2c->dev, " Minimum_Voltage : %d\n",MSG_VAR_SUPPLY->Minimum_Voltage );
|
|
dev_info(&i2c->dev, " Maximum_Current : %d\n",MSG_VAR_SUPPLY->Maximum_Current );
|
|
}
|
|
else if(PDO_sel == 1) // *MSG_BAT_SUPPLY
|
|
{
|
|
MSG_BAT_SUPPLY = (SRC_BAT_SUPPLY_Typedef *)&RX_SRC_CAPA_MSG[PDO_cnt + 1];
|
|
|
|
dev_info(&i2c->dev, " PDO_Parameter(BAT_SUPPLY) : %d\n",MSG_BAT_SUPPLY->PDO_Parameter );
|
|
dev_info(&i2c->dev, " Maximum_Voltage : %d\n",MSG_BAT_SUPPLY->Maximum_Voltage );
|
|
dev_info(&i2c->dev, " Minimum_Voltage : %d\n",MSG_BAT_SUPPLY->Minimum_Voltage );
|
|
dev_info(&i2c->dev, " Maximum_Allow_Power : %d\n",MSG_BAT_SUPPLY->Maximum_Allow_Power );
|
|
}
|
|
|
|
}
|
|
|
|
/* the number of available pdo list */
|
|
pd_sink_status->available_pdo_num = available_pdo_num;
|
|
dev_info(&i2c->dev, "=======================================\n");
|
|
return available_pdo_num;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Processing message role
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
void process_message_role(void *data)
|
|
{
|
|
struct s2mm005_data *usbpd_data = data;
|
|
struct otg_notify *o_notify = get_otg_notify();
|
|
int is_dfp = 0;
|
|
int is_src = 0;
|
|
|
|
// 1. read pd state
|
|
is_dfp = usbpd_data->func_state & (0x1 << 26) ? 1 : 0;
|
|
is_src = usbpd_data->func_state & (0x1 << 25) ? 1 : 0;
|
|
pr_info("%s func_state :0x%X, is_dfp : %d, is_src : %d\n", __func__,
|
|
usbpd_data->func_state, is_dfp, is_src);
|
|
#if defined(CONFIG_TYPEC)
|
|
pr_info("%s current port data_role : %d, power_role : %d\n", __func__,
|
|
usbpd_data->typec_data_role, usbpd_data->typec_power_role);
|
|
|
|
if (is_src == usbpd_data->typec_power_role) {
|
|
pr_info("%s skip. already power role is set.\n", __func__);
|
|
return;
|
|
}
|
|
#endif
|
|
// 2. process power role
|
|
if (usbpd_data->pd_state != State_PE_PRS_SNK_SRC_Source_on) {
|
|
pr_info("%s pd_state is not PE_PRS_SNK_SRC_Source_on\n", __func__);
|
|
#if defined(CONFIG_DUAL_ROLE_USB_INTF)
|
|
if (is_src && (usbpd_data->power_role == DUAL_ROLE_PROP_PR_SNK)) {
|
|
ccic_event_work(usbpd_data, CCIC_NOTIFY_DEV_BATTERY,
|
|
CCIC_NOTIFY_ID_ATTACH, 0, 0, 0);
|
|
}
|
|
#elif defined (CONFIG_TYPEC)
|
|
if (is_src && (usbpd_data->typec_power_role == TYPEC_SINK)) {
|
|
pd_noti.event = PDIC_NOTIFY_EVENT_PD_PRSWAP_SNKTOSRC;
|
|
pd_noti.sink_status.selected_pdo_num = 0;
|
|
pd_noti.sink_status.available_pdo_num = 0;
|
|
pd_noti.sink_status.current_pdo_num = 0;
|
|
ccic_event_work(usbpd_data, CCIC_NOTIFY_DEV_BATTERY,
|
|
CCIC_NOTIFY_ID_POWER_STATUS, 0, 0, 0);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if defined(CONFIG_USB_HOST_NOTIFY)
|
|
if (is_src)
|
|
send_otg_notify(o_notify, NOTIFY_EVENT_POWER_SOURCE, 1);
|
|
else
|
|
send_otg_notify(o_notify, NOTIFY_EVENT_POWER_SOURCE, 0);
|
|
#endif
|
|
vbus_turn_on_ctrl(is_src);
|
|
|
|
#if defined(CONFIG_DUAL_ROLE_USB_INTF)
|
|
usbpd_data->power_role = is_src ?
|
|
DUAL_ROLE_PROP_PR_SRC : DUAL_ROLE_PROP_PR_SNK;
|
|
ccic_event_work(usbpd_data, CCIC_NOTIFY_DEV_PDIC,
|
|
CCIC_NOTIFY_ID_ROLE_SWAP, 0, 0, 0);
|
|
#elif defined (CONFIG_TYPEC)
|
|
usbpd_data->typec_power_role = is_src ? TYPEC_SOURCE : TYPEC_SINK;
|
|
typec_set_pwr_role(usbpd_data->port, usbpd_data->typec_power_role);
|
|
|
|
if (usbpd_data->typec_try_state_change == TRY_ROLE_SWAP_PR) {
|
|
pr_info("%s : power role is changed %s\n",
|
|
__func__, is_src ? "SOURCE" : "SINK");
|
|
usbpd_data->typec_try_state_change = TRY_ROLE_SWAP_NONE;
|
|
complete(&usbpd_data->typec_reverse_completion);
|
|
pr_info("%s typec_reverse_completion!\n", __func__);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void process_pd(void *data, u8 plug_attach_done, u8 *pdic_attach, MSG_IRQ_STATUS_Type *MSG_IRQ_State)
|
|
{
|
|
struct s2mm005_data *usbpd_data = data;
|
|
struct i2c_client *i2c = usbpd_data->i2c;
|
|
uint16_t REG_ADD;
|
|
uint8_t rp_currentlvl, is_src, i;
|
|
REQUEST_FIXED_SUPPLY_STRUCT_Typedef *request_power_number;
|
|
|
|
pr_info("%s\n",__func__);
|
|
rp_currentlvl = ((usbpd_data->func_state >> 27) & 0x3);
|
|
is_src = (usbpd_data->func_state & (0x1 << 25) ? 1 : 0);
|
|
dev_info(&i2c->dev, "rp_currentlvl:0x%02X, is_source:0x%02X\n", rp_currentlvl, is_src);
|
|
|
|
if (MSG_IRQ_State->BITS.Ctrl_Flag_PR_Swap)
|
|
{
|
|
usbpd_data->is_pr_swap++;
|
|
dev_info(&i2c->dev, "PR_Swap requested to %s, receive\n", is_src ? "SOURCE" : "SINK");
|
|
process_message_role(usbpd_data);
|
|
}
|
|
#if defined(CONFIG_TYPEC)
|
|
else if (usbpd_data->typec_try_state_change == TRY_ROLE_SWAP_PR) {
|
|
dev_info(&i2c->dev, "PR_Swap requested to %s, send\n", is_src ? "SOURCE" : "SINK");
|
|
process_message_role(usbpd_data);
|
|
}
|
|
#endif
|
|
else ;
|
|
|
|
if (MSG_IRQ_State->BITS.Data_Flag_SRC_Capability)
|
|
{
|
|
uint8_t ReadMSG[32];
|
|
int available_pdo_num;
|
|
uint8_t do_power_nego = 0;
|
|
pd_noti.event = PDIC_NOTIFY_EVENT_PD_SINK;
|
|
|
|
REG_ADD = REG_RX_SRC_CAPA_MSG;
|
|
s2mm005_read_byte(i2c, REG_ADD, ReadMSG, 32);
|
|
available_pdo_num = s2mm005_src_capacity_information(i2c, (uint32_t *)ReadMSG, &pd_noti.sink_status, &do_power_nego);
|
|
|
|
REG_ADD = REG_TX_REQUEST_MSG;
|
|
s2mm005_read_byte(i2c, REG_ADD, ReadMSG, 32);
|
|
request_power_number = (REQUEST_FIXED_SUPPLY_STRUCT_Typedef *)&ReadMSG[4];
|
|
|
|
pr_info(" %s : Object_posision(%d), available_pdo_num(%d), selected_pdo_num(%d) \n", __func__,
|
|
request_power_number->Object_Position, available_pdo_num, pd_noti.sink_status.selected_pdo_num);
|
|
pd_noti.sink_status.current_pdo_num = request_power_number->Object_Position;
|
|
|
|
if(available_pdo_num > 0)
|
|
{
|
|
if(request_power_number->Object_Position != pd_noti.sink_status.selected_pdo_num)
|
|
{
|
|
if (pd_noti.sink_status.selected_pdo_num == 0)
|
|
{
|
|
pr_info(" %s : PDO is not selected yet by default\n", __func__);
|
|
pd_noti.sink_status.selected_pdo_num = pd_noti.sink_status.current_pdo_num;
|
|
}
|
|
} else {
|
|
if (do_power_nego) {
|
|
pr_info(" %s : PDO(%d) is selected, but power negotiation is requested\n",
|
|
__func__, pd_noti.sink_status.selected_pdo_num);
|
|
pd_noti.sink_status.selected_pdo_num = 0;
|
|
pd_noti.event = PDIC_NOTIFY_EVENT_PD_SINK_CAP;
|
|
} else {
|
|
pr_info(" %s : PDO(%d) is selected, but same with previous list, so skip\n",
|
|
__func__, pd_noti.sink_status.selected_pdo_num);
|
|
}
|
|
}
|
|
*pdic_attach = 1;
|
|
} else {
|
|
pr_info(" %s : PDO is not selected\n", __func__);
|
|
}
|
|
}
|
|
|
|
if (MSG_IRQ_State->BITS.Ctrl_Flag_Get_Sink_Cap)
|
|
{
|
|
pr_info(" %s : SRC requested SINK Cap\n", __func__);
|
|
}
|
|
|
|
/* notify to battery */
|
|
#ifdef CONFIG_USB_TYPEC_MANAGER_NOTIFIER
|
|
if (plug_attach_done) {
|
|
if (*pdic_attach) {
|
|
/* PD charger is detected by PDIC */
|
|
} else if (!is_src && (usbpd_data->pd_state == State_PE_SNK_Wait_for_Capabilities ||
|
|
usbpd_data->pd_state == State_ErrorRecovery) &&
|
|
rp_currentlvl != pd_noti.sink_status.rp_currentlvl &&
|
|
rp_currentlvl >= RP_CURRENT_LEVEL_DEFAULT) {
|
|
if (rp_currentlvl == RP_CURRENT_LEVEL3) {
|
|
/* 5V/3A RP charger is detected by CCIC */
|
|
pd_noti.sink_status.rp_currentlvl = RP_CURRENT_LEVEL3;
|
|
pd_noti.event = PDIC_NOTIFY_EVENT_CCIC_ATTACH;
|
|
} else if (rp_currentlvl == RP_CURRENT_LEVEL2) {
|
|
/* 5V/1.5A RP charger is detected by CCIC */
|
|
pd_noti.sink_status.rp_currentlvl = RP_CURRENT_LEVEL2;
|
|
pd_noti.event = PDIC_NOTIFY_EVENT_CCIC_ATTACH;
|
|
} else if (rp_currentlvl == RP_CURRENT_LEVEL_DEFAULT) {
|
|
/* 5V/0.5A RP charger is detected by CCIC */
|
|
pd_noti.sink_status.rp_currentlvl = RP_CURRENT_LEVEL_DEFAULT;
|
|
pd_noti.event = PDIC_NOTIFY_EVENT_CCIC_ATTACH;
|
|
} else
|
|
return;
|
|
} else
|
|
return;
|
|
#ifdef CONFIG_SEC_FACTORY
|
|
pr_info(" %s : debug pdic_attach(%d) event(%d)\n", __func__, *pdic_attach, pd_noti.event);
|
|
#endif
|
|
ccic_event_work(usbpd_data, CCIC_NOTIFY_DEV_BATTERY, CCIC_NOTIFY_ID_POWER_STATUS, *pdic_attach, 0, 0);
|
|
} else {
|
|
for (i = 0; i < MAX_PDO_NUM + 1; i++) {
|
|
pd_noti.sink_status.power_list[i].max_current = 0;
|
|
pd_noti.sink_status.power_list[i].max_voltage = 0;
|
|
}
|
|
pd_noti.sink_status.rp_currentlvl = RP_CURRENT_LEVEL_NONE;
|
|
pd_noti.sink_status.available_pdo_num = 0;
|
|
pd_noti.sink_status.selected_pdo_num = 0;
|
|
pd_noti.sink_status.current_pdo_num = 0;
|
|
pd_noti.event = PDIC_NOTIFY_EVENT_DETACH;
|
|
}
|
|
#else
|
|
if(plug_attach_done)
|
|
{
|
|
/* PD notify */
|
|
if(*pdic_attach)
|
|
pd_noti.event = PDIC_NOTIFY_EVENT_PD_SINK;
|
|
else
|
|
pd_noti.event = PDIC_NOTIFY_EVENT_CCIC_ATTACH;
|
|
}
|
|
else
|
|
{
|
|
pd_noti.sink_status.selected_pdo_num = 0;
|
|
pd_noti.event = PDIC_NOTIFY_EVENT_DETACH;
|
|
}
|
|
pdic_notifier_call(pd_noti);
|
|
#endif
|
|
}
|