static void anx7808_chip_initial(void)
{
#ifdef EYE_TEST
sp_tx_eye_diagram_test();
#else
sp_tx_variable_init();
sp_tx_vbus_powerdown();
sp_tx_hardware_powerdown();
sp_tx_set_sys_state(STATE_CABLE_PLUG);
#endif
}
static int anx7816_system_init(void)
{
int ret = 0;
ret = slimport_chip_detect();
if (ret == 0) {
sp_tx_hardware_powerdown();
pr_err("%s : failed to detect anx7816\n", __func__);
return -ENODEV;
}
slimport_chip_initial();
return 0;
}
static void anx7808_chip_initial(void)
{
#ifdef EYE_TEST
sp_tx_eye_diagram_test();
#else
sp_tx_variable_init();
sp_tx_vbus_powerdown();
sp_tx_hardware_powerdown(anx7808_client);
//ASUS_BSP +++: workaround for turn off 1.0V after read chip id
msleep(5);
sp_tx_hardware_power_set(0);
//ASUS_BSP ---: workaround for turn off 1.0V after read chip id
sp_tx_set_sys_state(STATE_CABLE_PLUG);
#endif
}
static irqreturn_t anx7816_cbl_det_isr(int irq, void *data)
{
struct anx7816_data *anx7816 = data;
if (gpio_get_value(anx7816->pdata->gpio_cbl_det)) {
wake_lock(&anx7816->slimport_lock);
pr_info("%s %s : detect cable insertion\n", LOG_TAG, __func__);
queue_delayed_work(anx7816->workqueue, &anx7816->work, 0);
} else {
pr_info("%s %s : detect cable removal\n", LOG_TAG, __func__);
cancel_delayed_work_sync(&anx7816->work);
flush_workqueue(anx7816->workqueue);
sp_tx_hardware_powerdown();
sp_tx_clean_state_machine();
wake_unlock(&anx7816->slimport_lock);
wake_lock_timeout(&anx7816->slimport_lock, 2*HZ);
}
return IRQ_HANDLED;
}
static void slimport_cable_monitor(struct anx7808_data *anx7808)
{
if ((gpio_get_value_cansleep(anx7808->pdata->gpio_cbl_det))
&& (!sp_tx_pd_mode)) {
sp_tx_get_downstream_type();
if (sp_tx_rx_type_backup != sp_tx_rx_type) {
pr_info("cable changed!\n");
sp_tx_vbus_powerdown();
sp_tx_power_down(SP_TX_PWR_REG);
sp_tx_power_down(SP_TX_PWR_TOTAL);
sp_tx_hardware_powerdown();
sp_tx_pd_mode = 1;
sp_tx_link_config_done = 0;
sp_tx_hw_lt_enable = 0;
sp_tx_hw_lt_done = 0;
sp_tx_rx_type = RX_NULL;
sp_tx_rx_type_backup = RX_NULL;
sp_tx_set_sys_state(STATE_CABLE_PLUG);
}
}
}
static void slimport_cable_plug_proc(struct anx7808_data *anx7808)
{
struct anx7808_platform_data *pdata = anx7808->pdata;
if (gpio_get_value_cansleep(pdata->gpio_cbl_det)) {
mdelay(100);
if (gpio_get_value_cansleep(pdata->gpio_cbl_det)) {
if (sp_tx_pd_mode) {
sp_tx_pd_mode = 0;
#ifdef CONFIG_SLIMPORT_DYNAMIC_HPD
slimport_set_hdmi_hpd(1);
#endif
sp_tx_hardware_poweron();
sp_tx_power_on(SP_TX_PWR_REG);
sp_tx_power_on(SP_TX_PWR_TOTAL);
hdmi_rx_initialization();
sp_tx_initialization();
sp_tx_vbus_poweron();
msleep(200);
if (!sp_tx_get_cable_type()) {
pr_err("%s %s:AUX ERR\n",
LOG_TAG, __func__);
sp_tx_vbus_powerdown();
sp_tx_power_down(SP_TX_PWR_REG);
sp_tx_power_down(SP_TX_PWR_TOTAL);
sp_tx_hardware_powerdown();
sp_tx_pd_mode = 1;
sp_tx_link_config_done = 0;
sp_tx_hw_lt_enable = 0;
sp_tx_hw_lt_done = 0;
sp_tx_rx_type = RX_NULL;
sp_tx_rx_type_backup = RX_NULL;
sp_tx_set_sys_state(STATE_CABLE_PLUG);
return;
}
sp_tx_rx_type_backup = sp_tx_rx_type;
}
switch (sp_tx_rx_type) {
case RX_HDMI:
if (sp_tx_get_hdmi_connection())
sp_tx_set_sys_state(STATE_PARSE_EDID);
break;
case RX_DP:
if (sp_tx_get_dp_connection())
sp_tx_set_sys_state(STATE_PARSE_EDID);
break;
case RX_VGA_GEN:
if (sp_tx_get_vga_connection())
sp_tx_set_sys_state(STATE_PARSE_EDID);
break;
case RX_VGA_9832:
if (sp_tx_get_vga_connection()) {
sp_tx_send_message(MSG_CLEAR_IRQ);
sp_tx_set_sys_state(STATE_PARSE_EDID);
}
break;
case RX_NULL:
default:
break;
}
}
} else if (sp_tx_pd_mode == 0) {
sp_tx_vbus_powerdown();
sp_tx_power_down(SP_TX_PWR_REG);
sp_tx_power_down(SP_TX_PWR_TOTAL);
sp_tx_hardware_powerdown();
sp_tx_pd_mode = 1;
sp_tx_link_config_done = 0;
sp_tx_hw_lt_enable = 0;
sp_tx_hw_lt_done = 0;
sp_tx_rx_type = RX_NULL;
sp_tx_rx_type_backup = RX_NULL;
sp_tx_set_sys_state(STATE_CABLE_PLUG);
}
}
/*
int anx7816_get_sbl_cable_type(void)
{
int cable_type = 0;
unsigned int *p_cable_type = (unsigned int *)
(smem_get_entry(SMEM_ID_VENDOR1, &cable_smem_size));
if (p_cable_type)
cable_type = *p_cable_type;
else
cable_type = 0;
return cable_type;
}
*/
static int anx7816_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct anx7816_data *anx7816;
struct anx7816_platform_data *pdata;
int ret = 0;
//int sbl_cable_type = 0;
pr_err("%s %s start\n", LOG_TAG, __func__);
#ifdef SP_REGISTER_SET_TEST
val_SP_TX_LT_CTRL_REG0 = 0x01;
val_SP_TX_LT_CTRL_REG1 = 0x03;
val_SP_TX_LT_CTRL_REG2 = 0x57;
val_SP_TX_LT_CTRL_REG3 = 0x7f;
val_SP_TX_LT_CTRL_REG4 = 0x71;
val_SP_TX_LT_CTRL_REG5 = 0x6b;
val_SP_TX_LT_CTRL_REG6 = 0x7f;
val_SP_TX_LT_CTRL_REG7 = 0x73;
val_SP_TX_LT_CTRL_REG8 = 0x7f;
val_SP_TX_LT_CTRL_REG9 = 0x7f;
val_SP_TX_LT_CTRL_REG10 = 0x00;
val_SP_TX_LT_CTRL_REG11 = 0x00;
val_SP_TX_LT_CTRL_REG12 = 0x02;
val_SP_TX_LT_CTRL_REG13 = 0x00;
val_SP_TX_LT_CTRL_REG14 = 0x0c;
val_SP_TX_LT_CTRL_REG15 = 0x42;
val_SP_TX_LT_CTRL_REG16 = 0x2f;
val_SP_TX_LT_CTRL_REG17 = 0x3e;
val_SP_TX_LT_CTRL_REG18 = 0x77;
val_SP_TX_LT_CTRL_REG19 = 0x7e;
#endif
if (!i2c_check_functionality(client->adapter,
I2C_FUNC_SMBUS_I2C_BLOCK)) {
pr_err("%s: i2c bus does not support the anx7816\n", __func__);
ret = -ENODEV;
goto exit;
}
anx7816 = kzalloc(sizeof(struct anx7816_data), GFP_KERNEL);
if (!anx7816) {
pr_err("%s: failed to allocate driver data\n", __func__);
ret = -ENOMEM;
goto exit;
}
if (client->dev.of_node) {
pdata = devm_kzalloc(&client->dev,
sizeof(struct anx7816_platform_data),
GFP_KERNEL);
if (!pdata) {
pr_err("%s: Failed to allocate memory\n", __func__);
ret = -ENOMEM;
goto err0;
}
client->dev.platform_data = pdata;
/* device tree parsing function call */
ret = anx7816_parse_dt(&client->dev, pdata);
if (ret != 0) /* if occurs error */
goto err0;
anx7816->pdata = pdata;
} else {
anx7816->pdata = client->dev.platform_data;
}
/* to access global platform data */
g_pdata = anx7816->pdata;
anx7816_client = client;
mutex_init(&anx7816->lock);
if (!anx7816->pdata) {
ret = -EINVAL;
goto err0;
}
ret = anx7816_init_gpio(anx7816);
if (ret) {
pr_err("%s: failed to initialize gpio\n", __func__);
goto err0;
}
INIT_DELAYED_WORK(&anx7816->work, anx7816_work_func);
/* INIT_DELAYED_WORK(&anx7816->dwc3_ref_clk_work, dwc3_ref_clk_work_func); */
anx7816->workqueue = create_singlethread_workqueue("anx7816_work");
if (anx7816->workqueue == NULL) {
pr_err("%s: failed to create work queue\n", __func__);
ret = -ENOMEM;
goto err1;
}
//anx7816->pdata->avdd_power(1);
//anx7816->pdata->dvdd_power(1);
ret = anx7816_system_init();
if (ret) {
pr_err("%s: failed to initialize anx7816\n", __func__);
goto err2;
}
client->irq = gpio_to_irq(anx7816->pdata->gpio_cbl_det);
if (client->irq < 0) {
pr_err("%s : failed to get gpio irq\n", __func__);
goto err2;
}
wake_lock_init(&anx7816->slimport_lock,
WAKE_LOCK_SUSPEND,
"slimport_wake_lock");
#if 0
sbl_cable_type = anx7816_get_sbl_cable_type();
if ((lge_get_laf_mode() != LGE_LAF_MODE_LAF) &&
(sbl_cable_type != CBL_910K)) {
#else
if ((lge_get_boot_mode() != LGE_BOOT_MODE_QEM_910K) &&
(lge_get_boot_mode() != LGE_BOOT_MODE_PIF_910K)) {
#endif
ret = request_threaded_irq(client->irq, NULL, anx7816_cbl_det_isr,
IRQF_TRIGGER_RISING
| IRQF_TRIGGER_FALLING
| IRQF_ONESHOT,
"anx7816", anx7816);
if (ret < 0) {
pr_err("%s : failed to request irq\n", __func__);
goto err2;
}
ret = irq_set_irq_wake(client->irq, 1);
if (ret < 0) {
pr_err("%s : Request irq for cable detect", __func__);
pr_err("interrupt wake set fail\n");
goto err3;
}
ret = enable_irq_wake(client->irq);
if (ret < 0) {
pr_err("%s : Enable irq for cable detect", __func__);
pr_err("interrupt wake enable fail\n");
goto err3;
}
} else {
#if 0
pr_err("%s %s : %s, Disable cbl det irq!!\n", LOG_TAG, __func__,
sbl_cable_type == CBL_910K ? "910K Cable Connected" : "Laf Mode");
#else
pr_err("%s %s: 910K Cable Connected. Disable cbl det irq!!\n", LOG_TAG, __func__);
#endif
}
ret = create_sysfs_interfaces(&client->dev);
if (ret < 0) {
pr_err("%s : sysfs register failed", __func__);
goto err3;
}
#ifdef CONFIG_SLIMPORT_DYNAMIC_HPD
hdmi_slimport_ops = devm_kzalloc(&client->dev,
sizeof(struct msm_hdmi_slimport_ops),
GFP_KERNEL);
if (!hdmi_slimport_ops) {
pr_err("%s: alloc hdmi slimport ops failed\n", __func__);
ret = -ENOMEM;
goto err3;
}
if (anx7816->pdata->hdmi_pdev) {
ret = msm_hdmi_register_slimport(anx7816->pdata->hdmi_pdev,
hdmi_slimport_ops, anx7816);
if (ret) {
pr_err("%s: register with hdmi failed\n", __func__);
ret = -EPROBE_DEFER;
goto err3;
}
}
#endif
pr_info("%s %s end\n", LOG_TAG, __func__);
goto exit;
err3:
free_irq(client->irq, anx7816);
err2:
destroy_workqueue(anx7816->workqueue);
err1:
anx7816_free_gpio(anx7816);
err0:
anx7816_client = NULL;
kfree(anx7816);
exit:
return ret;
}
static int anx7816_i2c_remove(struct i2c_client *client)
{
struct anx7816_data *anx7816 = i2c_get_clientdata(client);
int i = 0;
for (i = 0; i < ARRAY_SIZE(slimport_device_attrs); i++)
device_remove_file(&client->dev, &slimport_device_attrs[i]);
pr_err("anx7816_i2c_remove\n");
sp_tx_clean_state_machine();
destroy_workqueue(anx7816->workqueue);
sp_tx_hardware_powerdown();
free_irq(client->irq, anx7816);
anx7816_free_gpio(anx7816);
wake_lock_destroy(&anx7816->slimport_lock);
kfree(anx7816);
return 0;
}
bool is_slimport_vga(void)
{
return ((sp_tx_cur_cable_type() == DWN_STRM_IS_VGA_9832)
|| (sp_tx_cur_cable_type() == DWN_STRM_IS_ANALOG)) ? 1 : 0;
}
/* 0x01: hdmi device is attached
0x02: DP device is attached
0x03: Old VGA device is attached // RX_VGA_9832
0x04: new combo VGA device is attached // RX_VGA_GEN
0x00: unknow device */
EXPORT_SYMBOL(is_slimport_vga);
bool is_slimport_dp(void)
{
return (sp_tx_cur_cable_type() == DWN_STRM_IS_DIGITAL) ? TRUE : FALSE;
}
EXPORT_SYMBOL(is_slimport_dp);
unchar sp_get_link_bw(void)
{
return sp_tx_cur_bw();
}
EXPORT_SYMBOL(sp_get_link_bw);
void sp_set_link_bw(unchar link_bw)
{
sp_tx_set_bw(link_bw);
}
static void slimport_cable_plug_proc(struct anx7808_data *anx7808)
{
if (gpio_get_value_cansleep(anx7808->pdata->gpio_cbl_det)) {
msleep(50);
if (gpio_get_value_cansleep(anx7808->pdata->gpio_cbl_det)) {
if (sp_tx_pd_mode) {
sp_tx_pd_mode = 0;
sp_tx_hardware_poweron();
sp_tx_power_on(SP_TX_PWR_REG);
sp_tx_power_on(SP_TX_PWR_TOTAL);
#ifdef CONFIG_CHARGER_SMB345
sp_tx_pull_down_id(TRUE);
#endif
hdmi_rx_initialization();
sp_tx_initialization();
sp_tx_vbus_poweron();
msleep(200);
if (!sp_tx_get_cable_type()) {
SP_DEV_ERR("%s:AUX ERR\n", __func__);
sp_tx_vbus_powerdown();
#ifdef CONFIG_CHARGER_SMB345
sp_tx_pull_down_id(FALSE);
#endif
sp_tx_power_down(SP_TX_PWR_REG);
sp_tx_power_down(SP_TX_PWR_TOTAL);
sp_tx_hardware_powerdown();
sp_tx_pd_mode = 1;
sp_tx_link_config_done = 0;
sp_tx_hw_lt_enable = 0;
sp_tx_hw_lt_done = 0;
sp_tx_rx_type = RX_NULL;
sp_tx_rx_type_backup = RX_NULL;
sp_tx_set_sys_state(STATE_CABLE_PLUG);
return;
}
sp_tx_rx_type_backup = sp_tx_rx_type;
}
switch (sp_tx_rx_type) {
case RX_HDMI:
if (sp_tx_get_hdmi_connection())
sp_tx_set_sys_state(STATE_PARSE_EDID);
break;
case RX_DP:
if (sp_tx_get_dp_connection())
sp_tx_set_sys_state(STATE_PARSE_EDID);
break;
case RX_VGA_GEN:
if (sp_tx_get_vga_connection())
sp_tx_set_sys_state(STATE_PARSE_EDID);
break;
case RX_VGA_9832:
if (sp_tx_get_vga_connection()) {
sp_tx_send_message(MSG_CLEAR_IRQ);
sp_tx_set_sys_state(STATE_PARSE_EDID);
}
break;
case RX_NULL:
default:
break;
}
}
} else if (sp_tx_pd_mode == 0) {
sp_tx_vbus_powerdown();
#ifdef CONFIG_CHARGER_SMB345
sp_tx_pull_down_id(FALSE);
#endif
sp_tx_power_down(SP_TX_PWR_REG);
sp_tx_power_down(SP_TX_PWR_TOTAL);
sp_tx_hardware_powerdown();
sp_tx_pd_mode = 1;
sp_tx_link_config_done = 0;
sp_tx_hw_lt_enable = 0;
sp_tx_hw_lt_done = 0;
sp_tx_rx_type = RX_NULL;
sp_tx_rx_type_backup = RX_NULL;
sp_tx_set_sys_state(STATE_CABLE_PLUG);
}
}
static void slimport_cable_plug_proc(struct anx7808_data *anx7808)
{
int Pad_HW_ID = 0;
/// printk("+++++++++++++slimport_cable_plug_proc+++++++++++++++++++\n");
if (gpio_get_value_cansleep(anx7808->pdata->gpio_cbl_det) ) {
msleep(50);
if (gpio_get_value_cansleep(anx7808->pdata->gpio_cbl_det) ) {
// printk("slimport_cable_plug_proc start\n");
if (sp_tx_pd_mode) {
/// printk("=================slimport_cable_plug_proc (1) ===============\n");
//ASUS_BSP +++ : larry lai for pad solution
if(sp_tx_get_asus_id())
{
#ifdef CONFIG_EEPROM_NUVOTON
Pad_HW_ID = AX_MicroP_IsMydpNewSKU();
#else
Pad_HW_ID = -1; // default TV mode
#endif
if (Pad_HW_ID == 1)
{
printk("### [myDP] DP Pad detect ###\n");
sp_tx_asus_pad = 1;
myDP_DP_Dongle = 1;
}
else if (Pad_HW_ID == 0)
{
printk("### [myDP] HDMI Pad detect ###\n");
sp_tx_asus_pad = 1;
myDP_DP_Dongle = 0;
}
else
{
if (myDP_force_pad_mode)
{
if (myDP_DP_Dongle)
{
printk("[myDP] DP Pad detect ###\n");
sp_tx_asus_pad = 1;
myDP_DP_Dongle = 1;
}
else
{
printk("[myDP] HDMI Pad detect ###\n");
sp_tx_asus_pad = 1;
myDP_DP_Dongle = 0;
}
}
else
{
printk("### [myDP] Fail detect Pad , force TV mode ###\n");
sp_tx_asus_pad = 0;
myDP_DP_Dongle = 0;
}
}
}
else
nv_touch_mode(4); //ASUS_BSP Deeo : notify touch while plug out HDMI 4: AC
//ASUS_BSP --- : larry lai for pad solution
//sp_tx_hardware_chip_enable(anx7808_client);
sp_tx_hardware_poweron(anx7808_client);
sp_tx_pd_mode = 0;
//ANX : (ver:20130105) diff with ANX slimport driver, comment it ???
//// msleep(200);
sp_tx_power_on(SP_TX_PWR_REG);
sp_tx_power_on(SP_TX_PWR_TOTAL);
/// printk("=================slimport_cable_plug_proc (2) ===============\n");
//ANX : (ver:0.2)
sp_tx_pull_down_id(TRUE);
hdmi_rx_initialization();
/// printk("=================slimport_cable_plug_proc (3) ===============\n");
sp_tx_initialization();
/// printk("=================slimport_cable_plug_proc (4) ===============\n");
//ASUS_BSP +++ : larry lai for pad solution
if (!sp_tx_asus_pad)
{
sp_tx_vbus_poweron();
msleep(200);
}
else
{
msleep(20);
}
//ASUS_BSP --- : larry lai for pad solution
if (!sp_tx_get_cable_type()) {
DEV_ERR("%s:AUX ERR\n", __func__);
sp_tx_vbus_powerdown();
//ANX : (ver:0.2)
sp_tx_pull_down_id(FALSE);
sp_tx_power_down(SP_TX_PWR_REG);
sp_tx_power_down(SP_TX_PWR_TOTAL);
// sp_tx_hardware_chip_disable(anx7808_client);
sp_tx_hardware_powerdown(anx7808_client);
sp_tx_pd_mode = 1;
sp_tx_link_config_done = 0;
sp_tx_hw_lt_enable = 0;
sp_tx_hw_lt_done = 0;
sp_tx_rx_type = RX_NULL;
sp_tx_rx_type_backup = RX_NULL;
//ANX +++: (ver:20130105) pad solution
sp_tx_asus_pad = 0;
//ANX ---: (ver:20130105) pad solution
sp_tx_set_sys_state(STATE_CABLE_PLUG);
return;
}
/// printk("=================slimport_cable_plug_proc (5) ===============\n");
sp_tx_rx_type_backup = sp_tx_rx_type;
}
switch(sp_tx_rx_type) {
case RX_HDMI:
/// printk("=================slimport_cable_plug_proc (RX_HDMI) ===============\n");
if(sp_tx_get_hdmi_connection()){
printk("==== (RX_HDMI) ===\n");
//ANX +++: (ver:20130105) pad solution
if(sp_tx_asus_pad) {
//skip EDID read
hdmi_rx_set_hpd(1);
hdmi_rx_set_termination(1);
sp_tx_set_sys_state(STATE_CONFIG_HDMI);
} else {
sp_tx_set_sys_state(STATE_PARSE_EDID);
}
//ANX ---: (ver:20130105) pad solution
}
break;
case RX_DP:
if(sp_tx_get_dp_connection())
{
printk("==== (RX_DP) ===\n");
if(sp_tx_asus_pad) {
//skip EDID read
hdmi_rx_set_hpd(1);
hdmi_rx_set_termination(1);
sp_tx_set_sys_state(STATE_CONFIG_HDMI);
} else {
sp_tx_set_sys_state(STATE_PARSE_EDID);
}
}
break;
case RX_VGA:
if(sp_tx_get_vga_connection()){
sp_tx_send_message(MSG_CLEAR_IRQ);
sp_tx_set_sys_state(STATE_PARSE_EDID);
}
break;
case RX_NULL:
default:
break;
}
}
} else if (sp_tx_pd_mode == 0) {
sp_tx_vbus_powerdown();
//ANX : (ver:0.2)
sp_tx_pull_down_id(FALSE);
sp_tx_power_down(SP_TX_PWR_REG);
sp_tx_power_down(SP_TX_PWR_TOTAL);
sp_tx_hardware_powerdown(anx7808_client);
// sp_tx_hardware_chip_disable(anx7808_client);
sp_tx_pd_mode = 1;
sp_tx_link_config_done = 0;
sp_tx_hw_lt_enable = 0;
sp_tx_hw_lt_done = 0;
sp_tx_rx_type = RX_NULL;
sp_tx_rx_type_backup = RX_NULL;
//ANX +++: (ver:20130105) pad solution
sp_tx_asus_pad = 0;
//ANX ---: (ver:20130105) pad solution
sp_tx_set_sys_state(STATE_CABLE_PLUG);
}
}
static int dp_reset_pd_function(const char *val, struct kernel_param *kp)
{
int ret=0;
int old_val = dp_pd_value;
struct anx7808_platform_data *pdata = anx7808_client->dev.platform_data;
if (ret)
return ret;
if (dp_pd_value > 0xf) {
dp_pd_value = old_val;
return -EINVAL;
}
ret = param_set_int(val, kp);
if(dp_pd_value==0){
/*
gpio_set_value(pdata->gpio_usb_select, 0);
msleep(20);
gpio_set_value(pdata->gpio_usb_select, 1);
msleep(500);
gpio_set_value(pdata->gpio_usb_select, 0);
msleep(20);
gpio_set_value(pdata->gpio_usb_select, 1);
msleep(500);
*/
unchar ch, cl;
uint n;
sp_read_reg(RX_P0, HDMI_RX_HTOTAL_LOW, &cl);
sp_read_reg(RX_P0, HDMI_RX_HTOTAL_HIGH, &ch);
n = ch;
n = (n << 8) + cl;
printk("ANX7808 RX cur_h_res = 0x%x\n", n);
sp_read_reg(RX_P0, HDMI_RX_VTOTAL_LOW, &cl);
sp_read_reg(RX_P0, HDMI_RX_VTOTAL_HIGH, &ch);
n = ch;
n = (n << 8) + cl;
printk("ANX7808 RX cur_v_res = 0x%x\n", n);
sp_read_reg(RX_P0, HDMI_RX_VID_PCLK_CNTR_REG, &cl);
printk("ANX7808 RX cur_pix_clk = 0x%x\n", cl);
sp_read_reg(RX_P0, HDMI_RX_HDMI_STATUS_REG, &cl);
printk("ANX7808 RX dvi_status = 0x%x\n", ((cl & HDMI_MODE) == HDMI_MODE));
}else if (dp_pd_value==1) {
gpio_set_value(pdata->gpio_usb_select, 0);
msleep(20);
gpio_set_value(pdata->gpio_usb_select, 1);
msleep(20);
gpio_set_value(pdata->gpio_usb_select, 0);
msleep(20);
gpio_set_value(pdata->gpio_usb_select, 1);
msleep(20);
gpio_set_value(pdata->gpio_usb_select, 0);
msleep(20);
gpio_set_value(pdata->gpio_usb_select, 1);
msleep(20);
gpio_set_value(pdata->gpio_usb_select, 0);
msleep(20);
gpio_set_value(pdata->gpio_usb_select, 1);
}
else if (dp_pd_value==2) {
sp_tx_hardware_power_set(1);
}
else if (dp_pd_value==3) {
sp_tx_hardware_power_set(0);
}
else if (dp_pd_value==4) {
sp_tx_hardware_poweron(anx7808_client);
}
else if (dp_pd_value==5) {
sp_tx_hardware_powerdown(anx7808_client);
}
else if (dp_pd_value==6) {
unchar c1=0;
/*
unchar addr_tmp = 0x50;
switch(addr_tmp)
{
case 0x50: c= 0; break;
case 0x8c: c= 1; break;
case 0x70: c= 7; break;
case 0x72: c = 5; break;
case 0x7a: c = 6; break;
default : break;
}
*/
i2c_master_read_reg(0, 0x0B, &c1);
printk("[myDP] 7730reg 0x50, 0x0B=%x\n", (uint)c1);
msleep(1);
i2c_master_read_reg(5, 0xE3, &c1);
printk("[myDP] 7730reg 0x72, 0xE3=%x\n", (uint)c1);
msleep(1);
i2c_master_read_reg(0, 0x06, &c1);
printk("[myDP] 7730reg 0x50, 0x06=%x\n", (uint)c1);
msleep(1);
i2c_master_read_reg(5, 0x06, &c1);
printk("[myDP] 7730reg 0x72, 0x06=%x\n", (uint)c1);
i2c_master_read_reg(0, 0x05, &c1);
printk("[myDP] 7730reg 0x50, 0x05=%x\n", (uint)c1);
}
else if (dp_pd_value==7) {
unchar c=0;
printk("[myDP] write 7730reg 0, 0x06 bit5\n");
i2c_master_read_reg(0,0x06, &c);
c = c | 0x20;
i2c_master_write_reg(0,0x06, c);
}
else if (dp_pd_value==8) {
unchar c=0;
printk("[myDP] write 7730reg 0, 0x06 bit3\n");
i2c_master_read_reg(0,0x06, &c);
c = c | 0x08;
i2c_master_write_reg(0,0x06, c);
}
else if (dp_pd_value==9) {
unchar c=0;
printk("[myDP] write 7730reg 0, 0x06 bit2\n");
i2c_master_read_reg(0,0x06, &c);
c = c | 0x04;
i2c_master_write_reg(0,0x06, c);
}
else if (dp_pd_value==10) {
unchar c=0;
printk("[myDP] write 7730reg 0, 0x06 bit0\n");
i2c_master_read_reg(0,0x06, &c);
c = c | 0x01;
i2c_master_write_reg(0,0x06, c);
}
else if (dp_pd_value==11) {
unchar c=0;
printk("[myDP] write 7730reg 5, 0x06 bit5\n");
i2c_master_read_reg(5,0x06, &c);
c = c | 0x20;
i2c_master_write_reg(5,0x06, c);
}
else if (dp_pd_value==12) {
myDP_TV_mode = 1;
}
else if (dp_pd_value==13) {
myDP_TV_mode = 0;
}
else if (dp_pd_value==14) {
// printk("[myDP shell] switch to myDP\n");
// gpio_set_value(pdata->gpio_usb_select, 1);
myDP_DP_Dongle = 1;
}
else if (dp_pd_value==15) {
// printk("[myDP shell] switch to USB\n");
// gpio_set_value(pdata->gpio_usb_select, 0);
myDP_DP_Dongle = 0;
}
return 0;
}
