a7y18lte-ubports/android_kernel_samsung_a7y18lte_3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
main
android_kernel_samsung_a7y1.../drivers/ccic/s2mm003.c
Waldemar Tomme b9959b7054 A750FNXXU4CTG1
2023-04-07 21:05:06 +02:00

1453 lines
47 KiB
C
Raw Permalink Blame History

/*
* driver/../s2mm003.c - S2MM003 USBPD device 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/s2mm003.h>
#include <linux/power_supply.h>
#include <linux/battery/sec_charger.h>
#if defined(CONFIG_BATTERY_NOTIFIER)
#include <linux/battery/battery_notifier.h>
#endif
#if defined(CONFIG_DUAL_ROLE_USB_INTF)
#include <linux/usb/class-dual-role.h>
#endif
/* switch device header */
#ifdef CONFIG_SWITCH
#include <linux/switch.h>
#endif /* CONFIG_SWITCH */
#ifdef CONFIG_SWITCH
static struct switch_dev switch_dock = {
.name = "ccic_dock",
};
#endif /* CONFIG_SWITCH */
/* CCIC Dock Observer Callback parameter */
enum {
CCIC_DOCK_DETACHED = 0,
CCIC_DOCK_HMT = 105,
CCIC_DOCK_ABNORMAL = 106,
};
extern struct device *ccic_device;
static void ccic_send_dock_intent(int type)
{
pr_info("%s: CCIC dock type(%d)\n", __func__, type);
#ifdef CONFIG_SWITCH
switch_set_state(&switch_dock, type);
#endif
}
static int ccic_dock_attach_notify(int type, const char *name)
{
pr_info("%s: %s\n", __func__, name);
ccic_send_dock_intent(type);
return NOTIFY_OK;
}
static int ccic_dock_detach_notify(void)
{
pr_info("%s\n", __func__);
ccic_send_dock_intent(CCIC_DOCK_DETACHED);
return NOTIFY_OK;
}
static int s2mm003_read_byte(const struct i2c_client *i2c, u8 reg, u8 *val)
{
int ret; u8 wbuf;
struct i2c_msg msg[2];
struct s2mm003_data *usbpd_data = i2c_get_clientdata(i2c);
mutex_lock(&usbpd_data->i2c_mutex);
msg[0].addr = i2c->addr;
msg[0].flags = i2c->flags;
msg[0].len = 1;
msg[0].buf = &wbuf;
msg[1].addr = i2c->addr;
msg[1].flags = I2C_M_RD;
msg[1].len = 2;
msg[1].buf = val;
wbuf = (reg & 0xFF);
ret = i2c_transfer(i2c->adapter, msg, 2);
if (ret < 0)
dev_err(&i2c->dev, "i2c reading fail reg(0x%x), error %d\n",
reg, ret);
mutex_unlock(&usbpd_data->i2c_mutex);
return ret;
}
static int s2mm003_read_byte_16(const struct i2c_client *i2c, u16 reg, u8 *val)
{
int ret; u8 wbuf[2], rbuf;
struct i2c_msg msg[2];
struct s2mm003_data *usbpd_data = i2c_get_clientdata(i2c);
mutex_lock(&usbpd_data->i2c_mutex);
msg[0].addr = 0x43;
msg[0].flags = i2c->flags;
msg[0].len = 2;
msg[0].buf = wbuf;
msg[1].addr = 0x43;
msg[1].flags = I2C_M_RD;
msg[1].len = 1;
msg[1].buf = &rbuf;
wbuf[0] = (reg & 0xFF00) >> 8;
wbuf[1] = (reg & 0xFF);
ret = i2c_transfer(i2c->adapter, msg, 2);
if (ret < 0)
dev_err(&i2c->dev, "i2c read16 fail reg(0x%x), error %d\n",
reg, ret);
mutex_unlock(&usbpd_data->i2c_mutex);
*val = rbuf;
return rbuf;
}
static int s2mm003_write_byte(const struct i2c_client *i2c, u8 reg, u8 val)
{
int ret = 0; u8 wbuf[2];
struct i2c_msg msg[1];
struct s2mm003_data *usbpd_data = i2c_get_clientdata(i2c);
mutex_lock(&usbpd_data->i2c_mutex);
msg[0].addr = i2c->addr;
msg[0].flags = 0;
msg[0].len = 2;
msg[0].buf = wbuf;
wbuf[0] = (reg & 0xFF);
wbuf[1] = (val & 0xFF);
ret = i2c_transfer(i2c->adapter, msg, 1);
if (ret < 0)
dev_err(&i2c->dev, "i2c write fail reg(0x%x:%x), error %d\n",
reg, val, ret);
mutex_unlock(&usbpd_data->i2c_mutex);
return ret;
}
static int s2mm003_write_byte_16(const struct i2c_client *i2c, u16 reg, u8 val)
{
int ret = 0; u8 wbuf[3];
struct i2c_msg msg[1];
struct s2mm003_data *usbpd_data = i2c_get_clientdata(i2c);
mutex_lock(&usbpd_data->i2c_mutex);
msg[0].addr = 0x43;
msg[0].flags = 0;
msg[0].len = 3;
msg[0].buf = wbuf;
wbuf[0] = (reg & 0xFF00) >> 8;
wbuf[1] = (reg & 0xFF);
wbuf[2] = (val & 0xFF);
ret = i2c_transfer(i2c->adapter, msg, 1);
if (ret < 0)
dev_err(&i2c->dev, "i2c write fail reg(0x%x:%x), error %d\n",
reg, val, ret);
mutex_unlock(&usbpd_data->i2c_mutex);
return ret;
}
static void s2mm003_int_clear(struct s2mm003_data *usbpd_data)
{
struct i2c_client *i2c = usbpd_data->i2c;
s2mm003_write_byte(i2c, I2C_SYSREG_SET, 0x1);
s2mm003_write_byte(i2c, IRQ_RD_ADDR, 0xFF);
s2mm003_write_byte(i2c, I2C_SYSREG_SET, 0x0);
}
static int s2mm003_indirect_read(struct s2mm003_data *usbpd_data, u8 address)
{
u8 value = 0;
int ret = 0;
struct i2c_client *i2c = usbpd_data->i2c;
s2mm003_write_byte(i2c, I2C_SYSREG_SET, 0x1);
s2mm003_write_byte(i2c, IRQ_RD_ADDR, address);
s2mm003_write_byte(i2c, I2C_SYSREG_SET, 0x0);
ret = s2mm003_read_byte(i2c, IRQ_RD_DATA, &value);
if (ret < 0)
dev_err(&i2c->dev, "indirect read error value:%02x ret:%d\n", value, ret);
return value;
}
static void s2mm003_indirect_write(struct s2mm003_data *usbpd_data, u8 address, u8 val)
{
struct i2c_client *i2c = usbpd_data->i2c;
s2mm003_write_byte(i2c, I2C_SYSREG_SET, 0x1);
s2mm003_write_byte(i2c, IRQ_WR_ADDR, address);
s2mm003_write_byte(i2c, IRQ_WR_DATA, val);
s2mm003_write_byte(i2c, I2C_SYSREG_SET, 0x0);
}
static int s2mm003_src_capacity_information(const struct i2c_client *i2c, uint32_t *RX_SRC_CAPA_MSG,
PDIC_SINK_STATUS * pd_sink_status)
{
uint32_t RdCnt;
uint32_t PDO_cnt;
uint32_t PDO_sel;
int available_pdo_num = 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;
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 );
for(PDO_cnt = 0;PDO_cnt < MSG_HDR->Number_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;
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\r");
dev_info(&i2c->dev, "\n\r");
return available_pdo_num;
}
#if 0
static void s2mm003_request_select_type(uint32_t * REQ_MSG , int num)
{
REQUEST_FIXED_SUPPLY_STRUCT_Typedef *REQ_FIXED_SPL;
REQ_FIXED_SPL = (REQUEST_FIXED_SUPPLY_STRUCT_Typedef *)REQ_MSG;
//REQ_FIXED_SPL->Reserved_2 = 0;
REQ_FIXED_SPL->Object_Position = (num & 0x7);
//REQ_FIXED_SPL->GiveBack_Flag = 0; // GiveBack Support set to 1
//REQ_FIXED_SPL->Capa_Mismatch = 0;
//REQ_FIXED_SPL->USB_Comm_Capable = 0;
//REQ_FIXED_SPL->No_USB_Suspend = 0;
//REQ_FIXED_SPL->Reserved_1 = 0; // Set to Zero
REQ_FIXED_SPL->OP_Current = 200; // 10mA
REQ_FIXED_SPL->Maximum_OP_Current = 200; // 10mA
}
#endif
static void Modify_TX_SRC_CAPA(struct s2mm003_data *usbpd_data)
{
uint32_t i;
U_MSG_HEADER_Type *MSG_HEADER;
U_SRC_FIXED_SUPPLY_Typedef *MSG_TX_SRC_FIXED_SUPPLY;
uint8_t data_arr[8]={0,};
// Set Message Index - TX Source Capability
s2mm003_indirect_write(usbpd_data, IND_REG_READ_MSG_INDEX, MSG_Idx_TX_SRC_CAPA);
// Read Default TX source Capability message - Size 8 Byte
for(i=0; i<8; i++)
data_arr[i] = s2mm003_indirect_read(usbpd_data, i+0x50);
// Link TX Source Capability Data struct
MSG_HEADER = (U_MSG_HEADER_Type *)&data_arr[0];
MSG_TX_SRC_FIXED_SUPPLY = (U_SRC_FIXED_SUPPLY_Typedef *)&data_arr[4];
// ===== For Debug Print
printk(KERN_ERR "MSG_TX_SRC_FIXED_SUPPLY->BITS.Maximum_Current) : %d\n", MSG_TX_SRC_FIXED_SUPPLY->BITS.Maximum_Current);
// =====================
// ===== For Modified Data Field
MSG_TX_SRC_FIXED_SUPPLY->BITS.Maximum_Current = 50; // 10mA unit * 50 (500mA)
// =====================
// Write TX source Capability message - Size 8 Byte
for(i=0; i<8; i++)
s2mm003_indirect_write(usbpd_data, (i+0x50), data_arr[i]);
return;
}
static void VBUS_TURN_ON_CTRL(bool enable)
{
union power_supply_propval val;
printk(KERN_ERR "%s -> enable : %d\n", __func__, enable);
val.intval = enable;
psy_do_property("otg", set,
POWER_SUPPLY_PROP_ONLINE, val);
}
static void PDIC_Function_State_for_VBUS(u8 val)
{
switch(val)
{
case 0: // PE_Initial_Detach
VBUS_TURN_ON_CTRL(0);
break;
// case 1: // PE_SRC_Startup
// VBUS_TURN_ON_CTRL(VBUS_ON);
// break;
// case 2: // PE_SRC_Discovery
// VBUS_TURN_ON_CTRL(VBUS_ON);
// break;
case 3: // PE_SRC_Send_Capabilities
VBUS_TURN_ON_CTRL(1);
break;
case 4: // PE_SRC_Negotiate_Capability
VBUS_TURN_ON_CTRL(1);
break;
case 5: // PE_SRC_Transition_Supply
VBUS_TURN_ON_CTRL(1);
break;
case 6: // PE_SRC_Ready
VBUS_TURN_ON_CTRL(1);
break;
case 7: // PE_SRC_Disabled
VBUS_TURN_ON_CTRL(1);
break;
// case 8: // PE_SRC_Capability_Response
// VBUS_TURN_ON_CTRL(VBUS_ON);
// break;
// case 9: // PE_SRC_Hard_Reset
// VBUS_TURN_ON_CTRL(VBUS_ON);
// break;
// case 10: // PE_SRC_Hard_Reset_Received
// VBUS_TURN_ON_CTRL(VBUS_ON);
// break;
// case 11: // PE_SRC_Transition_to_default
// VBUS_TURN_ON_CTRL(VBUS_ON);
// break;
// case 12: // PE_SRC_Give_Source_Cap
// VBUS_TURN_ON_CTRL(VBUS_ON);
// break;
// case 13: // PE_SRC_Get_Sink_Cap
// VBUS_TURN_ON_CTRL(VBUS_ON);
// break;
// case 14: // PE_SRC_Wait_New_Capabilities
// VBUS_TURN_ON_CTRL(VBUS_ON);
// break;
// case 15: // PE_SNK_Startup
// VBUS_TURN_ON_CTRL(VBUS_OFF);
// break;
// case 16: // PE_SNK_Discovery
// VBUS_TURN_ON_CTRL(VBUS_OFF);
// break;
case 17: // PE_SNK_Wait_for_Capabilities
VBUS_TURN_ON_CTRL(0);
break;
case 18: // PE_SNK_Evaluate_Capability
VBUS_TURN_ON_CTRL(0);
break;
case 19: // PE_SNK_Select_Capability
VBUS_TURN_ON_CTRL(0);
break;
case 20: // PE_SNK_Transition_Sink
VBUS_TURN_ON_CTRL(0);
break;
case 21: // PE_SNK_Ready
VBUS_TURN_ON_CTRL(0);
break;
// case 22: // PE_SNK_Hard_Reset
// VBUS_TURN_ON_CTRL(VBUS_OFF);
// break;
// case 23: // PE_SNK_Transition_to_default
// VBUS_TURN_ON_CTRL(VBUS_OFF);
// break;
// case 24: // PE_SNK_Give_Sink_Cap
// VBUS_TURN_ON_CTRL(VBUS_OFF);
// break;
// case 25: // PE_SNK_Get_Source_Cap
// VBUS_TURN_ON_CTRL(VBUS_OFF);
// break;
// case 26: // PE_SRC_CABLE_VDM_Identity_Request
// VBUS_TURN_ON_CTRL(VBUS_OFF);
// break;
// case 27: // PE_SRC_CABLE_VDM_Identity_ACKed
// VBUS_TURN_ON_CTRL(VBUS_OFF);
// break;
// case 28: // PE_SRC_CABLE_VDM_Identity_NAKed
// VBUS_TURN_ON_CTRL(VBUS_OFF);
// break;
case 29: // ErrorRecovery
VBUS_TURN_ON_CTRL(0);
break;
default:
VBUS_TURN_ON_CTRL(0);
break;
}
return;
}
static struct pdic_notifier_struct pd_noti;
static void send_usb_notify_message(struct s2mm003_data *usbpd_data, u8 mode)
{
CC_NOTI_USB_STATUS_TYPEDEF usb_status_notifier;
usb_status_notifier.id = CCIC_NOTIFY_ID_USB;
usb_status_notifier.src = CCIC_NOTIFY_DEV_CCIC;
usb_status_notifier.dest = CCIC_NOTIFY_DEV_USB;
if(mode == USB_STATUS_NOTIFY_DETACH)
usb_status_notifier.attach = CCIC_NOTIFY_DETACH;
else
usb_status_notifier.attach = CCIC_NOTIFY_ATTACH;
usb_status_notifier.drp = mode;
usbpd_data->Pdic_usb_state = mode;
ccic_notifier_notify((CC_NOTI_TYPEDEF*)&usb_status_notifier, NULL, 0);
#if defined(CONFIG_DUAL_ROLE_USB_INTF)
if (usbpd_data->try_state_change && (usbpd_data->Pdic_usb_state != USB_STATUS_NOTIFY_DETACH))
{
// Role change try and new mode detected
complete(&usbpd_data->reverse_completion);
}
dual_role_instance_changed(usbpd_data->dual_role);
#endif
}
/* for alternate mode */
#if defined(CONFIG_CCIC_ALTERNATE_MODE)
static void Msg_Read_Discover_Identity(struct s2mm003_data *usbpd_data)
{
uint32_t i;
U_MSG_HEADER_Type *MSG_HEADER;
U_DATA_MSG_VDM_HEADER_Type *DATA_MSG_VDM;
U_DATA_MSG_ID_HEADER_Type *DATA_MSG_ID;
U_CERT_STAT_VDO_Type *DATA_MSG_CERT;
U_PRODUCT_VDO_Type *DATA_MSG_PRODUCT;
uint8_t data_arr[32]={0,};
MSG_HEADER = (U_MSG_HEADER_Type *)&data_arr[0];
DATA_MSG_VDM = (U_DATA_MSG_VDM_HEADER_Type *)&data_arr[4];
DATA_MSG_ID = (U_DATA_MSG_ID_HEADER_Type *)&data_arr[8];
DATA_MSG_CERT = (U_CERT_STAT_VDO_Type *)&data_arr[12];
DATA_MSG_PRODUCT = (U_PRODUCT_VDO_Type *)&data_arr[16];
s2mm003_indirect_write(usbpd_data, IND_REG_READ_MSG_INDEX, MSG_Idx_RX_DISC_ID_RESP);
for(i=0; i<32; i++)
data_arr[i] = s2mm003_indirect_read(usbpd_data, i+0x50);
usbpd_data->Vendor_ID = DATA_MSG_ID->BITS.USB_Vendor_ID;
usbpd_data->Product_ID = DATA_MSG_PRODUCT->BITS.Product_ID;
printk(KERN_ERR "[%s] Vendor_ID : 0x%X, Product_ID : 0x%X\n", __func__, usbpd_data->Vendor_ID, usbpd_data->Product_ID);
if(usbpd_data->Vendor_ID ==0x04E8 && usbpd_data->Product_ID==0xA500) // Gear VR VID, PID
usbpd_data->acc_type = CCIC_DOCK_HMT;
if( (DATA_MSG_ID->BITS.Data_Capable_USB_Host == 0x01)
&& (DATA_MSG_ID->BITS.Data_Capable_USB_Device == 0x00)
&& (DATA_MSG_ID->BITS.Product_Type == 0x02)
){
printk(KERN_ERR "[%s] Working with USB Host Device.\n", __func__);
s2mm003_indirect_write(usbpd_data, 0x4C, 0x10); // Detach and re-attach
VBUS_TURN_ON_CTRL(0);
usbpd_data->Pdic_state_machine = b_Cmd_Intial_State;
usbpd_data->func_state = FUNCTION_STATUS_INITIAL_DETACH;
send_usb_notify_message(usbpd_data, USB_STATUS_NOTIFY_DETACH);
}
else
usbpd_data->Pdic_state_machine = b_Cmd_Discover_Identity;
}
static void Msg_Read_Discover_SVIDs(struct s2mm003_data *usbpd_data)
{
uint32_t i;
U_MSG_HEADER_Type *MSG_HEADER;
U_DATA_MSG_VDM_HEADER_Type *DATA_MSG_VDM;
U_VDO1_Type *DATA_MSG_VDO1;
uint8_t data_arr[32]={0,};
MSG_HEADER = (U_MSG_HEADER_Type *)&data_arr[0];
DATA_MSG_VDM = (U_DATA_MSG_VDM_HEADER_Type *)&data_arr[4];
DATA_MSG_VDO1 = (U_VDO1_Type *)&data_arr[8];
s2mm003_indirect_write(usbpd_data, IND_REG_READ_MSG_INDEX, MSG_Idx_RX_DISC_SVIDs_RESP);
for(i=0; i<32; i++)
data_arr[i] = s2mm003_indirect_read(usbpd_data, i+0x50);
usbpd_data->SVID_0 = DATA_MSG_VDO1->BITS.SVID_0;
usbpd_data->SVID_1 = DATA_MSG_VDO1->BITS.SVID_1;
printk(KERN_ERR "[%s] SVID_0 : 0x%X, SVID_1 : 0x%X\n", __func__, usbpd_data->SVID_0, usbpd_data->SVID_1);
usbpd_data->Pdic_state_machine = b_Cmd_Discover_SVIDs;
}
static void Msg_Read_Discover_Modes(struct s2mm003_data *usbpd_data)
{
uint32_t i;
U_MSG_HEADER_Type *MSG_HEADER;
U_DATA_MSG_VDM_HEADER_Type *DATA_MSG_VDM;
uint8_t data_arr[32]={0,};
MSG_HEADER = (U_MSG_HEADER_Type *)&data_arr[0];
DATA_MSG_VDM = (U_DATA_MSG_VDM_HEADER_Type *)&data_arr[4];
s2mm003_indirect_write(usbpd_data, IND_REG_READ_MSG_INDEX, MSG_Idx_RX_DISC_MODE_RESP);
for(i=0; i<32; i++)
data_arr[i] = s2mm003_indirect_read(usbpd_data, i+0x50);
printk(KERN_ERR "[%s]\n", __func__);
usbpd_data->Pdic_state_machine = b_Cmd_Discover_Modes;
}
static void Msg_Read_Enter_Mode(struct s2mm003_data *usbpd_data)
{
U_MSG_HEADER_Type *MSG_HEADER;
U_DATA_MSG_VDM_HEADER_Type *DATA_MSG_VDM;
int i;
uint8_t data_arr[32]={0,};
const char name[11] = "HMT Attach";
MSG_HEADER = (U_MSG_HEADER_Type *)&data_arr[0];
DATA_MSG_VDM = (U_DATA_MSG_VDM_HEADER_Type *)&data_arr[4];
s2mm003_indirect_write(usbpd_data, IND_REG_READ_MSG_INDEX, MSG_Idx_RX_DISC_ENTER_MODE_RESP);
for(i=0; i<32; i++)
data_arr[i] = s2mm003_indirect_read(usbpd_data, i+0x50);
if(DATA_MSG_VDM->BITS.VDM_command_type == 1)
printk(KERN_ERR "[%s] --> EnterMode Ack\n", __func__);
else
printk(KERN_ERR "[%s] --> EnterMode Nak\n", __func__);
usbpd_data->Pdic_state_machine = b_Cmd_Enter_Mode;
if (usbpd_data->acc_type != CCIC_DOCK_DETACHED)
ccic_dock_attach_notify(usbpd_data->acc_type, name);
}
static void Msg_Send_Discover_Idendity(struct s2mm003_data *usbpd_data)
{
uint32_t i=0;
U_MSG_HEADER_Type *MSG_HEADER;
U_DATA_MSG_VDM_HEADER_Type *DATA_MSG_VDM;
uint8_t data_arr[32]={0,};
printk(KERN_ERR "[%s]\n", __func__);
MSG_HEADER = (U_MSG_HEADER_Type *)&data_arr[0];
DATA_MSG_VDM = (U_DATA_MSG_VDM_HEADER_Type *)&data_arr[4];
s2mm003_indirect_write(usbpd_data, IND_REG_READ_MSG_INDEX, MSG_Idx_VDM_MSG_REQUEST);
for(i=0; i<8; i++)
data_arr[i] = s2mm003_indirect_read(usbpd_data, i+0x50);
MSG_HEADER->BITS.Number_of_obj = 1;
DATA_MSG_VDM->BITS.Standard_Vendor_ID = 0xFF00;
DATA_MSG_VDM->BITS.Object_Position = 0;
for(i = 0; i < 8; i++)
s2mm003_indirect_write(usbpd_data, i+0x50, data_arr[i]);
s2mm003_indirect_write(usbpd_data, 0x4E, 1);
}
static void Msg_Send_Discover_SVIDs(struct s2mm003_data *usbpd_data)
{
uint32_t i;
U_MSG_HEADER_Type *MSG_HEADER;
U_DATA_MSG_VDM_HEADER_Type *DATA_MSG_VDM;
uint8_t data_arr[32]={0,};
printk(KERN_ERR "[%s]\n", __func__);
MSG_HEADER = (U_MSG_HEADER_Type *)&data_arr[0];
DATA_MSG_VDM = (U_DATA_MSG_VDM_HEADER_Type *)&data_arr[4];
s2mm003_indirect_write(usbpd_data, IND_REG_READ_MSG_INDEX, MSG_Idx_VDM_MSG_REQUEST);
for(i=0; i<8; i++)
data_arr[i] = s2mm003_indirect_read(usbpd_data, i+0x50);
MSG_HEADER->BITS.Number_of_obj = 1;
DATA_MSG_VDM->BITS.Standard_Vendor_ID = 0xFF00;
DATA_MSG_VDM->BITS.Object_Position = 0;
for(i=0; i<8; i++)
s2mm003_indirect_write(usbpd_data, i+0x50, data_arr[i]);
s2mm003_indirect_write(usbpd_data, 0x4E, 2);
}
static void Msg_Send_Discover_Modes(struct s2mm003_data *usbpd_data)
{
uint32_t i;
U_MSG_HEADER_Type *MSG_HEADER;
U_DATA_MSG_VDM_HEADER_Type *DATA_MSG_VDM;
uint8_t data_arr[32]={0,};
printk(KERN_ERR "[%s]\n", __func__);
MSG_HEADER = (U_MSG_HEADER_Type *)&data_arr[0];
DATA_MSG_VDM = (U_DATA_MSG_VDM_HEADER_Type *)&data_arr[4];
s2mm003_indirect_write(usbpd_data, IND_REG_READ_MSG_INDEX, MSG_Idx_VDM_MSG_REQUEST);
for(i=0; i<8; i++)
data_arr[i] = s2mm003_indirect_read(usbpd_data, i+0x50);
MSG_HEADER->BITS.Number_of_obj = 1;
DATA_MSG_VDM->BITS.Standard_Vendor_ID = usbpd_data->SVID_1;
DATA_MSG_VDM->BITS.Object_Position = 0;
for(i=0; i<8; i++)
s2mm003_indirect_write(usbpd_data, i+0x50, data_arr[i]);
s2mm003_indirect_write(usbpd_data, 0x4E, 3);
}
static void Msg_Send_Enter_Mode(struct s2mm003_data *usbpd_data)
{
uint32_t i;
U_MSG_HEADER_Type *MSG_HEADER;
U_DATA_MSG_VDM_HEADER_Type *DATA_MSG_VDM;
uint8_t data_arr[32]={0,};
printk(KERN_ERR "[%s]\n", __func__);
MSG_HEADER = (U_MSG_HEADER_Type *)&data_arr[0];
DATA_MSG_VDM = (U_DATA_MSG_VDM_HEADER_Type *)&data_arr[4];
s2mm003_indirect_write(usbpd_data, IND_REG_READ_MSG_INDEX, MSG_Idx_VDM_MSG_REQUEST);
for(i=0; i<8; i++)
data_arr[i] = s2mm003_indirect_read(usbpd_data, i+0x50);
MSG_HEADER->BITS.Number_of_obj = 1;
DATA_MSG_VDM->BITS.Standard_Vendor_ID = usbpd_data->SVID_1;
DATA_MSG_VDM->BITS.Object_Position = 1;
for(i=0; i<8; i++)
s2mm003_indirect_write(usbpd_data, i+0x50, data_arr[i]);
s2mm003_indirect_write(usbpd_data, 0x4E, 4);
}
#endif
static irqreturn_t s2mm003_usbpd_irq_thread(int irq, void *data)
{
struct s2mm003_data *usbpd_data = data;
struct i2c_client *i2c = usbpd_data->i2c;
unsigned char rid, plug_state_monitor;
int cc1_valid, cc2_valid, plug_attach_done;
int value, usbpd_state;
int pdic_attach = 0;
int is_dr_swap = 0;
static CC_NOTI_ATTACH_TYPEDEF attach_notifier;
static CC_NOTI_RID_TYPEDEF rid_notifier;
REQUEST_FIXED_SUPPLY_STRUCT_Typedef *request_power_number;
dev_err(&i2c->dev, "%d times\n", ++usbpd_data->wq_times);
usbpd_state = s2mm003_indirect_read(usbpd_data, IND_REG_PDIC_PD_FUNC_STATE);
dev_info(&i2c->dev, "USBPD_STATE I2C read: 0x%02d\n", usbpd_state);
plug_state_monitor = s2mm003_indirect_read(usbpd_data, IND_REG_PDIC_PLUG_STATE);
cc1_valid = S2MM003_REG_MASK(plug_state_monitor, S_CC1_VALID);
cc2_valid = S2MM003_REG_MASK(plug_state_monitor, S_CC2_VALID);
usbpd_data->plug_rprd_sel = S2MM003_REG_MASK(plug_state_monitor, PLUG_RPRD_SEL_MONITOR);
plug_attach_done = S2MM003_REG_MASK(plug_state_monitor, PLUG_ATTACH_DONE);
dev_info(&i2c->dev, "PLUG_STATE_MONITOR I2C read:%x\n"
"CC1:%x CC2:%x rprd:%x attach:%x\n",
plug_state_monitor,
cc1_valid, cc2_valid, usbpd_data->plug_rprd_sel, plug_attach_done);
/* To confirm whether PD charger is attached or not */
value = s2mm003_indirect_read(usbpd_data, IND_REG_PDIC_MAIN_INT_NUM);
dev_info(&i2c->dev, "INT_STATUS I2C read: 0x%02X\n", value);
if((value & b_RESET_START) != 0x00)
{
dev_err(&i2c->dev, "START\n");
s2mm003_indirect_write(usbpd_data, IND_REG_HOST_CMD_ON, 0x01);
return IRQ_HANDLED;
}
if( (value & b_PD_FUNC_FLAG) != 0x00) { // Need PD Function State Read
int address = IND_REG_PDIC_PD_FUNC_STATE; // Function State Number Read
int ret = 0x00;
ret = s2mm003_indirect_read(usbpd_data, address);
usbpd_data->func_state = ret; // store the function status
PDIC_Function_State_for_VBUS(usbpd_data->func_state); // For VBUS control
/* If it isn't PD charger, return value is 29*/
dev_info(&i2c->dev, " %s : func_state = %d\n", __func__, usbpd_data->func_state);
#if defined(CONFIG_CCIC_ALTERNATE_MODE)
if(usbpd_data->func_state == FUNCTION_STATUS_INITIAL_DETACH)
{
usbpd_data->Pdic_state_machine = b_Cmd_Intial_State;
if(usbpd_data->acc_type != CCIC_DOCK_DETACHED)
{
ccic_dock_detach_notify();
usbpd_data->acc_type = CCIC_DOCK_DETACHED;
}
}
#endif
}
if( (value & b_INT_1_FLAG) != 0x00)
{
int INT_1_value = 0;
INT_1_value = s2mm003_indirect_read(usbpd_data, IND_REG_PDIC_1_INT); // Interrupt State 1 Read
dev_info(&i2c->dev, "INT_State1 = 0x%X\n", INT_1_value);
#if defined(CONFIG_CCIC_ALTERNATE_MODE)
if(INT_1_value & b_Cmd_Discover_Identity){
Msg_Read_Discover_Identity(usbpd_data);
Msg_Send_Discover_SVIDs(usbpd_data);
}else if(INT_1_value & b_Cmd_Discover_SVIDs){
Msg_Read_Discover_SVIDs(usbpd_data);
Msg_Send_Discover_Modes(usbpd_data);
}else if(INT_1_value & b_Cmd_Discover_Modes){
Msg_Read_Discover_Modes(usbpd_data);
Msg_Send_Enter_Mode(usbpd_data);
}else if(INT_1_value & b_Cmd_Enter_Mode){
Msg_Read_Enter_Mode(usbpd_data);
}
#endif
}
if( (value & b_INT_2_FLAG) != 0x00)
{
int INT_2_value = 0;
INT_2_value = s2mm003_indirect_read(usbpd_data, IND_REG_PDIC_2_INT); // Interrupt State 2 Read
dev_info(&i2c->dev, "INT_State2 = 0x%X\n", INT_2_value);
if(INT_2_value & b_Msg_PR_SWAP)
{
dev_err(&i2c->dev, "PR_Swap Wait Delay (Any)ms\n");
// msleep(300);
s2mm003_indirect_write(usbpd_data, 0x4C, 6); // Call PS_RDY Command
VBUS_TURN_ON_CTRL(0);
#if defined(CONFIG_DUAL_ROLE_USB_INTF)
usbpd_data->power_role = DUAL_ROLE_PROP_PR_SNK;
#endif
}
else if(INT_2_value & b_Msg_DR_SWAP)
{
dev_err(&i2c->dev, "DR_Swap\n");
is_dr_swap = 1;
// toggling the state for usb host and device
#if defined(CONFIG_CCIC_NOTIFIER)
if(usbpd_data->Pdic_usb_state == USB_STATUS_NOTIFY_ATTACH_DFP)
send_usb_notify_message(usbpd_data, USB_STATUS_NOTIFY_ATTACH_UFP);
else if(usbpd_data->Pdic_usb_state == USB_STATUS_NOTIFY_ATTACH_UFP)
send_usb_notify_message(usbpd_data, USB_STATUS_NOTIFY_ATTACH_DFP);
#endif
}
}
if((value & b_INT_3_FLAG) != 0x00)
{
int INT_3_value = 0;
INT_3_value = s2mm003_indirect_read(usbpd_data, IND_REG_PDIC_3_INT); // Interrupt State 3 Read
dev_info(&i2c->dev, "INT_State3 = 0x%X\n", INT_3_value);
if((INT_3_value & b_RID_Detect_done) != 0x00) // RID Message Detect
{
rid = s2mm003_indirect_read(usbpd_data, IND_REG_PDIC_RID); // RID Value Read
dev_info(&i2c->dev, "\nRID_Value = 0x%X\n", rid);
usbpd_data->cur_rid = rid;
if (usbpd_data->cur_rid == usbpd_data->prev_rid) {
dev_err(&i2c->dev, "same rid detected, -ignore-\n");
}
usbpd_data->p_prev_rid = usbpd_data->prev_rid;
usbpd_data->prev_rid = usbpd_data->cur_rid;
#if defined(CONFIG_CCIC_NOTIFIER)
rid_notifier.src = CCIC_NOTIFY_DEV_CCIC;
rid_notifier.dest = CCIC_NOTIFY_DEV_MUIC;
rid_notifier.id = CCIC_NOTIFY_ID_RID;
rid_notifier.rid = rid;
ccic_notifier_notify((CC_NOTI_TYPEDEF*)&rid_notifier, NULL, pdic_attach);
if(rid == RID_000K)
{
VBUS_TURN_ON_CTRL(1);
send_usb_notify_message(usbpd_data, USB_STATUS_NOTIFY_ATTACH_DFP);
}
else if(rid == RID_OPEN || rid == RID_UNDEFINED || rid == RID_523K || rid == RID_619K)
{
VBUS_TURN_ON_CTRL(0);
send_usb_notify_message(usbpd_data, USB_STATUS_NOTIFY_DETACH);
}
#endif
}
if((INT_3_value & b_Msg_SRC_CAP) != 0x00) // Read Source Capability MSG.
{
int cnt;
uint32_t ReadMSG[8];
int current_pdo_num;
u8 *p_MSG_BUF;
s2mm003_indirect_write(usbpd_data, IND_REG_READ_MSG_INDEX, MSG_Idx_RX_SRC_CAPA);// Idx Transceiver Request
// Select PDO
if(usbpd_data->func_state == FUNCTION_STATUS_SINK_READY)
{
p_MSG_BUF = (u8 *)ReadMSG;
for(cnt = 0; cnt < 32; cnt++)
{
*(p_MSG_BUF + cnt) = s2mm003_indirect_read(usbpd_data, IND_REG_MSG_ACCESS_BASE+cnt);
}
current_pdo_num = s2mm003_src_capacity_information(i2c, ReadMSG, &pd_noti.sink_status);
s2mm003_indirect_write(usbpd_data, IND_REG_READ_MSG_INDEX, MSG_Idx_TX_REQUEST);// Idx Transceiver Request
p_MSG_BUF = (u8 *)ReadMSG;
for(cnt = 0; cnt < MSG_BUF_REQUEST_SIZE; cnt++)
{
*(p_MSG_BUF + cnt) = s2mm003_indirect_read(usbpd_data, IND_REG_MSG_ACCESS_BASE+cnt);
}
request_power_number = (REQUEST_FIXED_SUPPLY_STRUCT_Typedef *)&p_MSG_BUF[4]; //
pr_info(" %s : Object_posision(%d),current pdo_num(%d), selected_pdo_num(%d) \n", __func__,
request_power_number->Object_Position, current_pdo_num, pd_noti.sink_status.selected_pdo_num);
if(current_pdo_num > 0) {
if((current_pdo_num != pd_noti.sink_status.selected_pdo_num) && (current_pdo_num > 0))
{
pd_noti.sink_status.selected_pdo_num = current_pdo_num;
// choice : 1, 2, 3
pr_info(" %s : PDO(%d) is selected\n", __func__, pd_noti.sink_status.selected_pdo_num);
/* Idx Transceiver Request */
s2mm003_indirect_write(usbpd_data, 0x40, pd_noti.sink_status.selected_pdo_num);
s2mm003_indirect_write(usbpd_data, 0x10, 0x11); // Function state 17 setting
} 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( (value & b_INT_4_FLAG) != 0x00)
{
int INT_4_value = 0;
INT_4_value = s2mm003_indirect_read(usbpd_data, IND_REG_PDIC_4_INT); // Interrupt State 4 Read
dev_info(&i2c->dev, "INT_State4 = 0x%X\n", INT_4_value);
}
if( (value & b_INT_5_FLAG) != 0x00)
{
int INT_5_value = 0;
INT_5_value = s2mm003_indirect_read(usbpd_data, IND_REG_PDIC_5_INT); // Interrupt State 5 Read
dev_info(&i2c->dev, "INT_State5 = 0x%X\n", INT_5_value);
}
#if defined(CONFIG_CCIC_ALTERNATE_MODE)
if (usbpd_data->func_state == FUNCTION_STATUS_SRC_READY && usbpd_data->Pdic_state_machine == b_Cmd_Intial_State){
Msg_Send_Discover_Idendity(usbpd_data);
}
#endif
#if defined(CONFIG_CCIC_NOTIFIER)
attach_notifier.attach = plug_attach_done;
#ifdef CONFIG_USB_TYPEC_MANAGER_NOTIFIER
if(pdic_attach)
attach_notifier.id = CCIC_NOTIFY_ID_POWER_STATUS;
else
attach_notifier.id = CCIC_NOTIFY_ID_ATTACH;
#else
attach_notifier.id = CCIC_NOTIFY_ID_ATTACH;
#endif
attach_notifier.src = CCIC_NOTIFY_DEV_CCIC;
attach_notifier.dest = CCIC_NOTIFY_DEV_MUIC;
attach_notifier.rprd = usbpd_data->plug_rprd_sel;
#ifdef CONFIG_USB_TYPEC_MANAGER_NOTIFIER
ccic_notifier_notify((CC_NOTI_TYPEDEF*)&attach_notifier, &pd_noti, pdic_attach);
#else
ccic_notifier_notify((CC_NOTI_TYPEDEF*)&attach_notifier, NULL, pdic_attach);
#endif
#if defined(CONFIG_DUAL_ROLE_USB_INTF)
if(usbpd_data->func_state == FUNCTION_STATUS_SRC_SEND_CAPABILITY && !is_dr_swap)
{
usbpd_data->power_role = DUAL_ROLE_PROP_PR_SRC;
send_usb_notify_message(usbpd_data, USB_STATUS_NOTIFY_ATTACH_DFP);
}
else if(usbpd_data->func_state == FUNCTION_STATUS_SINK_DISCOVERY && !is_dr_swap)
{
usbpd_data->power_role = DUAL_ROLE_PROP_PR_SNK;
send_usb_notify_message(usbpd_data, USB_STATUS_NOTIFY_ATTACH_UFP);
}
else if(usbpd_data->func_state == FUNCTION_STATUS_INITIAL_DETACH)
{
send_usb_notify_message(usbpd_data, USB_STATUS_NOTIFY_DETACH);
// OTP mode set to DRP when capble pluged out
if (!usbpd_data->try_state_change)
{
s2mm003_indirect_write(usbpd_data, IND_REG_PDIC_MODE, TYPE_C_ATTACH_DRP);
}
}
#else
if(usbpd_data->func_state == FUNCTION_STATUS_SRC_SEND_CAPABILITY && !is_dr_swap)
send_usb_notify_message(usbpd_data, USB_STATUS_NOTIFY_ATTACH_DFP);
else if(usbpd_data->func_state == FUNCTION_STATUS_SINK_DISCOVERY && !is_dr_swap)
send_usb_notify_message(usbpd_data, USB_STATUS_NOTIFY_ATTACH_UFP);
else if(usbpd_data->func_state == FUNCTION_STATUS_INITIAL_DETACH)
send_usb_notify_message(usbpd_data, USB_STATUS_NOTIFY_DETACH);
#endif
#ifndef CONFIG_USB_TYPEC_MANAGER_NOTIFIER
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
#endif
s2mm003_int_clear(usbpd_data);
return IRQ_HANDLED;
}
#if defined(CONFIG_OF)
static int of_s2mm003_usbpd_dt(struct device *dev,
struct s2mm003_data *usbpd_data)
{
struct device_node *np_usbpd = dev->of_node;
usbpd_data->irq_gpio = of_get_named_gpio(np_usbpd, "usbpd,usbpd_int", 0);
usbpd_data->redriver_en = of_get_named_gpio(np_usbpd, "usbpd,redriver_en", 0);
dev_err(dev, "usbpd_irq = %d redriver_en = %d\n",
usbpd_data->irq_gpio, usbpd_data->redriver_en);
return 0;
}
#endif /* CONFIG_OF */
#if defined(CONFIG_SEC_CCIC_FW_FIX)
void s2mm003_firmware_ver_check(struct s2mm003_data *usbpd_data, char *name)
{
struct i2c_client *i2c = usbpd_data->i2c;
usbpd_data->firm_ver[0] = (u8)s2mm003_indirect_read(usbpd_data, 0x01);
usbpd_data->firm_ver[1] = (u8)s2mm003_indirect_read(usbpd_data, 0x02);
usbpd_data->firm_ver[2] = (u8)s2mm003_indirect_read(usbpd_data, 0x03);
usbpd_data->firm_ver[3] = (u8)s2mm003_indirect_read(usbpd_data, 0x04);
dev_err(&i2c->dev, "%s %s version %02x %02x %02x %02x\n",
USBPD_DEV_NAME, name, usbpd_data->firm_ver[0], usbpd_data->firm_ver[1],
usbpd_data->firm_ver[2], usbpd_data->firm_ver[3]);
}
#endif
static int s2mm003_firmware_update(struct s2mm003_data *usbpd_data)
{
const struct firmware *fw_entry;
const unsigned char *p;
int ret, i;
struct i2c_client *i2c = usbpd_data->i2c;
u8 test, reg_check[3] = { 0, };
ret = s2mm003_read_byte(i2c, I2C_SYSREG_SET, &reg_check[0]);
ret = s2mm003_read_byte(i2c, I2C_SRAM_SET, &reg_check[1]);
ret = s2mm003_read_byte(i2c, IF_S_CODE_E, &reg_check[2]);
if ((reg_check[0] != 0) || (reg_check[1] != 0) || (reg_check[2] != 0))
{
dev_err(&usbpd_data->i2c->dev, "firmware register error %02x %02x %02x\n",
reg_check[0], reg_check[1], reg_check[2]);
s2mm003_write_byte(i2c, USB_PD_RST, 0x40); /*FULL RESET*/
msleep(20);
}
s2mm003_write_byte(i2c, I2C_SRAM_SET, 0x1); /* 32 */
s2mm003_read_byte_16(i2c, 0x1854, &test);
s2mm003_write_byte(i2c, I2C_SRAM_SET, 0x0); /* 32 */
if (test > 7 || test < 0)
dev_err(&usbpd_data->i2c->dev, "fw update err rid : %02x\n", test);
ret = request_firmware(&fw_entry,
FIRMWARE_PATH, usbpd_data->dev);
if (ret < 0)
goto done;
msleep(5);
s2mm003_write_byte(i2c, I2C_SYSREG_SET, 0x1); /* 31 */
s2mm003_write_byte(i2c, OTP_DUMP_DISABLE, 0x1); /* 30 */
s2mm003_write_byte(i2c, I2C_SYSREG_SET, 0x0); /* 31 */
msleep(10);
s2mm003_write_byte(i2c, I2C_SRAM_SET, 0x1); /* 32 */
s2mm003_write_byte(i2c, I2C_SYSREG_SET, 0x1); /* 31 */
s2mm003_write_byte(i2c, IF_S_CODE_E, 0x4); /* sram update enable */
s2mm003_write_byte(i2c, I2C_SYSREG_SET, 0x0); /* 31 */
/* update firmware */
for(p = fw_entry->data, i=0; i < fw_entry->size; p++, i++)
s2mm003_write_byte_16(i2c,(u16)i, *p);
s2mm003_write_byte(i2c, I2C_SYSREG_SET, 0x1); /* 31 */
s2mm003_write_byte(i2c, IF_S_CODE_E, 0x0);
s2mm003_write_byte(i2c, I2C_SYSREG_SET, 0x0); /* 31 */
s2mm003_write_byte(i2c, I2C_SRAM_SET, 0x0); /* 32 */
s2mm003_write_byte(i2c, I2C_SYSREG_SET, 0x1); /* 31 */
s2mm003_write_byte(i2c, USB_PD_RST, 0x80); /* 0D */
s2mm003_write_byte(i2c, OTP_BLK_RST, 0x1); /* 0C OTP controller
system register reset
to stop otp copy */
msleep(5);
s2mm003_write_byte(i2c, USB_PD_RST, 0x80); /* 0D */
s2mm003_write_byte(i2c, I2C_SYSREG_SET, 0x0); /* 31 */
done:
dev_err(&usbpd_data->i2c->dev, "firmware size: %d, error %d\n",
(int)fw_entry->size, ret);
if (fw_entry)
release_firmware(fw_entry);
return ret;
}
#if defined(CONFIG_DUAL_ROLE_USB_INTF)
static enum dual_role_property fusb_drp_properties[] = {
DUAL_ROLE_PROP_MODE,
DUAL_ROLE_PROP_PR,
DUAL_ROLE_PROP_DR,
};
/* Callback for "cat /sys/class/dual_role_usb/otg_default/<property>" */
static int dual_role_get_local_prop(struct dual_role_phy_instance *dual_role,
enum dual_role_property prop,
unsigned int *val)
{
struct s2mm003_data *usbpd_data = dual_role_get_drvdata(dual_role);
USB_STATUS attached_state;
int power_role;
if (!usbpd_data) {
pr_err("%s : usbpd_data is null : request prop = %d \n",\
__func__, prop);
return -EINVAL;
}
attached_state = usbpd_data->Pdic_usb_state;
power_role = usbpd_data->power_role;
pr_info("%s : request prop = %d , attached_state = %d, prop_mode =%d, prop_pr = %d \n",\
__func__, prop, attached_state,usbpd_data->Pdic_usb_state, power_role);
if (attached_state == USB_STATUS_NOTIFY_ATTACH_DFP) {
if (prop == DUAL_ROLE_PROP_MODE)
*val = DUAL_ROLE_PROP_MODE_DFP;
else if (prop == DUAL_ROLE_PROP_PR) {
if (power_role)
*val = DUAL_ROLE_PROP_PR_SNK;
else
*val = DUAL_ROLE_PROP_PR_SRC;
}
else if (prop == DUAL_ROLE_PROP_DR)
*val = DUAL_ROLE_PROP_DR_HOST;
else
return -EINVAL;
} else if (attached_state == USB_STATUS_NOTIFY_ATTACH_UFP) {
if (prop == DUAL_ROLE_PROP_MODE)
*val = DUAL_ROLE_PROP_MODE_UFP;
else if (prop == DUAL_ROLE_PROP_PR) {
if (power_role)
*val = DUAL_ROLE_PROP_PR_SNK;
else
*val = DUAL_ROLE_PROP_PR_SRC;
}
else if (prop == DUAL_ROLE_PROP_DR)
*val = DUAL_ROLE_PROP_DR_DEVICE;
else
return -EINVAL;
} else {
if (prop == DUAL_ROLE_PROP_MODE)
*val = DUAL_ROLE_PROP_MODE_NONE;
else if (prop == DUAL_ROLE_PROP_PR)
*val = DUAL_ROLE_PROP_PR_NONE;
else if (prop == DUAL_ROLE_PROP_DR)
*val = DUAL_ROLE_PROP_DR_NONE;
else
return -EINVAL;
}
return 0;
}
/* Decides whether userspace can change a specific property */
static int dual_role_is_writeable(struct dual_role_phy_instance *drp,
enum dual_role_property prop)
{
if (prop == DUAL_ROLE_PROP_MODE)
return 1;
else
return 0;
}
int set_data_role(struct dual_role_phy_instance *dual_role,
enum dual_role_property prop,
const unsigned int *val)
{
struct s2mm003_data *usbpd_data = dual_role_get_drvdata(dual_role);
struct i2c_client *i2c = usbpd_data->i2c;
USB_STATUS attached_state;
int mode;
int timeout = 0;
int ret = 0;
if (!usbpd_data) {
pr_err("%s : usbpd_data is null \n", __func__);
return -EINVAL;
}
attached_state = usbpd_data->Pdic_usb_state;
pr_info("%s: request prop = %d , attached_state = %d , %d \n",__func__,\
prop, attached_state, usbpd_data->Pdic_usb_state);
if (attached_state != USB_STATUS_NOTIFY_ATTACH_DFP
&& attached_state != USB_STATUS_NOTIFY_ATTACH_UFP) {
pr_info("%s : current mode : %d - just return \n",__func__,\
attached_state);
return 0;
}
if (attached_state == USB_STATUS_NOTIFY_ATTACH_DFP
&& *val == DUAL_ROLE_PROP_MODE_DFP) {
pr_info("%s : current mode : %d - request mode : %d just return \n",__func__, attached_state, *val);
return 0;
}
if (attached_state == USB_STATUS_NOTIFY_ATTACH_UFP
&& *val == DUAL_ROLE_PROP_MODE_UFP) {
pr_info("%s : current mode : %d - request mode : %d just return \n",__func__, attached_state, *val);
return 0;
}
/* Current mode DFP and Source */
if ( attached_state == USB_STATUS_NOTIFY_ATTACH_DFP)
{
pr_info("%s: try reversing, form Source to Sink\n", __func__);
disable_irq(usbpd_data->irq_gpio);
/* turns off VBUS first */
VBUS_TURN_ON_CTRL(0);
usbpd_data->power_role = 0;
/* exit from Disabled state and set mode to UFP */
mode = TYPE_C_ATTACH_UFP;
s2mm003_indirect_write(usbpd_data, IND_REG_PDIC_MODE, mode);
usbpd_data->try_state_change = TYPE_C_ATTACH_UFP;
enable_irq(usbpd_data->irq_gpio);
}
/* Current mode UFP and Sink */
else
{
pr_info("%s: try reversing, form Sink to Source\n", __func__);
/* transition to Disabled state */
disable_irq(usbpd_data->irq_gpio);
/* exit from Disabled state and set mode to UFP */
mode = TYPE_C_ATTACH_DFP;
s2mm003_indirect_write(usbpd_data, IND_REG_PDIC_MODE, mode);
usbpd_data->try_state_change = TYPE_C_ATTACH_DFP;
enable_irq(usbpd_data->irq_gpio);
}
reinit_completion(&usbpd_data->reverse_completion);
timeout =
wait_for_completion_timeout(&usbpd_data->reverse_completion,
msecs_to_jiffies
(DUAL_ROLE_SET_MODE_WAIT_MS));
// clear try_state_change
usbpd_data->try_state_change = 0;
if (!timeout) {
pr_err("%s: reverse failed, set mode to DRP\n", __func__);
disable_irq(usbpd_data->irq_gpio);
/* exit from Disabled state and set mode to DRP */
mode = TYPE_C_ATTACH_DRP;
s2mm003_indirect_write(usbpd_data, IND_REG_PDIC_MODE, mode);
usbpd_data->try_state_change = TYPE_C_ATTACH_DRP;
enable_irq(usbpd_data->irq_gpio);
pr_info("%s: wait for the attached state\n", __func__);
reinit_completion(&usbpd_data->reverse_completion);
wait_for_completion_timeout(&usbpd_data->reverse_completion,
msecs_to_jiffies
(DUAL_ROLE_SET_MODE_WAIT_MS));
usbpd_data->try_state_change = 0;
ret = -EIO;
}
dev_info(&i2c->dev, "%s -> data role : %d\n", __func__, *val);
return ret;
}
/* Callback for "echo <value> >
* /sys/class/dual_role_usb/<name>/<property>"
* Block until the entire final state is reached.
* Blocking is one of the better ways to signal when the operation
* is done.
* This function tries to switch to Attached.SRC or Attached.SNK
* by forcing the mode into SRC or SNK.
* On failure, we fall back to Try.SNK state machine.
*/
static int dual_role_set_prop(struct dual_role_phy_instance *dual_role,
enum dual_role_property prop,
const unsigned int *val)
{
if (prop == DUAL_ROLE_PROP_MODE)
return set_data_role(dual_role, prop, val);
else
return -EINVAL;
}
#endif
static int s2mm003_usbpd_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(i2c->dev.parent);
struct s2mm003_data *usbpd_data;
int ret = 0;
#if defined(CONFIG_DUAL_ROLE_USB_INTF)
struct dual_role_phy_desc *desc;
struct dual_role_phy_instance *dual_role;
#endif
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
dev_err(&i2c->dev, "i2c functionality check error\n");
return -EIO;
}
usbpd_data = devm_kzalloc(&i2c->dev, sizeof(struct s2mm003_data), GFP_KERNEL);
if (!usbpd_data) {
dev_err(&i2c->dev, "Failed to allocate driver data\n");
return -ENOMEM;
}
#if defined(CONFIG_OF)
if (i2c->dev.of_node)
of_s2mm003_usbpd_dt(&i2c->dev, usbpd_data);
else
dev_err(&i2c->dev, "not found ccic dt! ret:%d\n", ret);
#endif
ret = gpio_request(usbpd_data->irq_gpio, "s2mm003_irq");
if (ret)
goto err_free_irq_gpio;
ret = gpio_request(usbpd_data->redriver_en, "s2mm003_redriver_en");
if (ret)
goto err_free_redriver_gpio;
gpio_direction_input(usbpd_data->irq_gpio);
i2c->irq = gpio_to_irq(usbpd_data->irq_gpio);
dev_info(&i2c->dev, "%s:IRQ NUM %d\n", __func__, i2c->irq);
/* TODO REMOVE redriver always enable, Add sleep/resume */
ret = gpio_direction_output(usbpd_data->redriver_en, 1);
if (ret) {
dev_err(&i2c->dev, "Unable to set input gpio direction, error %d\n", ret);
goto err_free_redriver_gpio;
}
usbpd_data->i2c = i2c;
i2c_set_clientdata(i2c, usbpd_data);
dev_set_drvdata(ccic_device, usbpd_data);
device_init_wakeup(&i2c->dev, 1);
mutex_init(&usbpd_data->i2c_mutex);
/* Init */
usbpd_data->p_prev_rid = -1;
usbpd_data->prev_rid = -1;
usbpd_data->cur_rid = -1;
#if defined(CONFIG_CCIC_ALTERNATE_MODE)
usbpd_data->Pdic_state_machine = 0;
usbpd_data->acc_type = 0;
#endif
usbpd_data->func_state = 0;
usbpd_data->Pdic_usb_state = 0;
#if defined(CONFIG_SEC_CCIC_FW_FIX)
s2mm003_firmware_ver_check(usbpd_data, "otp");
#else
usbpd_data->firm_ver[0] = s2mm003_indirect_read(usbpd_data, 0x01);
usbpd_data->firm_ver[1] = s2mm003_indirect_read(usbpd_data, 0x02);
usbpd_data->firm_ver[2] = s2mm003_indirect_read(usbpd_data, 0x03);
usbpd_data->firm_ver[3] = s2mm003_indirect_read(usbpd_data, 0x04);
dev_err(&i2c->dev, "%s otp version %02x %02x %02x %02x\n",
USBPD_DEV_NAME, usbpd_data->firm_ver[0], usbpd_data->firm_ver[1],
usbpd_data->firm_ver[2], usbpd_data->firm_ver[3]);
#endif
s2mm003_firmware_update(usbpd_data);
#if defined(CONFIG_SEC_CCIC_FW_FIX)
s2mm003_firmware_ver_check(usbpd_data, "fw");
#else
usbpd_data->firm_ver[0] = s2mm003_indirect_read(usbpd_data, 0x01);
usbpd_data->firm_ver[1] = s2mm003_indirect_read(usbpd_data, 0x02);
usbpd_data->firm_ver[2] = s2mm003_indirect_read(usbpd_data, 0x03);
usbpd_data->firm_ver[3] = s2mm003_indirect_read(usbpd_data, 0x04);
dev_err(&i2c->dev, "%s fw version %02x %02x %02x %02x\n",
USBPD_DEV_NAME, usbpd_data->firm_ver[0], usbpd_data->firm_ver[1],
usbpd_data->firm_ver[2], usbpd_data->firm_ver[3]);
#endif
Modify_TX_SRC_CAPA(usbpd_data);
ret = request_threaded_irq(i2c->irq, NULL, s2mm003_usbpd_irq_thread,
(IRQF_TRIGGER_FALLING | IRQF_NO_SUSPEND | IRQF_ONESHOT), "s2mm003-usbpd", usbpd_data);
if (ret) {
dev_err(&i2c->dev, "Failed to request IRQ %d, error %d\n", i2c->irq, ret);
goto err_init_irq;
}
dev_err(&i2c->dev, "probed, irq %d\n", usbpd_data->irq_gpio);
#if defined(CONFIG_DUAL_ROLE_USB_INTF)
desc =
devm_kzalloc(&i2c->dev,
sizeof(struct dual_role_phy_desc), GFP_KERNEL);
if (!desc) {
pr_err("unable to allocate dual role descriptor\n");
goto err_init_irq;
}
desc->name = "otg_default";
desc->supported_modes = DUAL_ROLE_SUPPORTED_MODES_DFP_AND_UFP;
desc->get_property = dual_role_get_local_prop;
desc->set_property = dual_role_set_prop;
desc->properties = fusb_drp_properties;
desc->num_properties = ARRAY_SIZE(fusb_drp_properties);
desc->property_is_writeable = dual_role_is_writeable;
dual_role =
devm_dual_role_instance_register(&i2c->dev, desc);
dual_role->drv_data = usbpd_data;
usbpd_data->dual_role = dual_role;
usbpd_data->desc = desc;
init_completion(&usbpd_data->reverse_completion);
#endif
#ifdef CONFIG_SWITCH
/* for DockObserver */
ret = switch_dev_register(&switch_dock);
if (ret < 0) {
pr_err("%s: Failed to register dock switch(%d)\n",
__func__, ret);
return -ENODEV;
}
#endif /* CONFIG_SWITCH */
return ret;
err_init_irq:
if (i2c->irq)
free_irq(i2c->irq, usbpd_data);
err_free_redriver_gpio:
gpio_free(usbpd_data->redriver_en);
err_free_irq_gpio:
gpio_free(usbpd_data->irq_gpio);
kfree(usbpd_data);
return ret;
}
static int s2mm003_usbpd_remove(struct i2c_client *i2c)
{
#if defined(CONFIG_DUAL_ROLE_USB_INTF)
struct s2mm003_data *usbpd_data = dev_get_drvdata(ccic_device);
devm_dual_role_instance_unregister(usbpd_data->dev, usbpd_data->dual_role);
devm_kfree(usbpd_data->dev, usbpd_data->desc);
#endif
#ifdef CONFIG_SWITCH
/* for DockObserver */
switch_dev_unregister(&switch_dock);
#endif /* CONFIG_SWITCH */
return 0;
}
static const struct i2c_device_id s2mm003_usbpd_id[] = {
{ USBPD_DEV_NAME, 0 },
{}
};
MODULE_DEVICE_TABLE(i2c, s2mm003_usbpd_id);
#if defined(CONFIG_OF)
static struct of_device_id s2mm003_i2c_dt_ids[] = {
{ .compatible = "sec-s2mm003,i2c" },
{ }
};
#endif /* CONFIG_OF */
static struct i2c_driver s2mm003_usbpd_driver = {
.driver = {
.name = USBPD_DEV_NAME,
#if defined(CONFIG_OF)
.of_match_table = s2mm003_i2c_dt_ids,
#endif /* CONFIG_OF */
},
.probe = s2mm003_usbpd_probe,
//.remove = __devexit_p(s2mm003_usbpd_remove),
.remove = s2mm003_usbpd_remove,
.id_table = s2mm003_usbpd_id,
};
static int __init s2mm003_usbpd_init(void)
{
return i2c_add_driver(&s2mm003_usbpd_driver);
}
module_init(s2mm003_usbpd_init);
static void __exit s2mm003_usbpd_exit(void)
{
i2c_del_driver(&s2mm003_usbpd_driver);
}
module_exit(s2mm003_usbpd_exit);
MODULE_DESCRIPTION("S2MM003 USB PD driver");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink