static ssize_t hdmi_3d_rda_format_3d(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t ret = snprintf(buf, PAGE_SIZE, "%d\n", external_common_state->format_3d); DEV_DBG("%s: '%d'\n", __func__, external_common_state->format_3d); return ret; }
static ssize_t external_common_rda_video_mode_str(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t ret = snprintf(buf, PAGE_SIZE, "%s\n", video_format_2string(external_common_state->video_resolution)); DEV_DBG("%s: '%s'\n", __func__, video_format_2string(external_common_state->video_resolution)); return ret; }
static ssize_t external_common_rda_video_mode(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t ret = snprintf(buf, PAGE_SIZE, "%d\n", external_common_state->video_resolution+1); DEV_DBG("%s: '%d'\n", __func__, external_common_state->video_resolution+1); return ret; }
static int nfcsim_activate_target(struct nfc_dev *nfc_dev, struct nfc_target *target, u32 protocol) { struct nfcsim *dev = nfc_get_drvdata(nfc_dev); DEV_DBG(dev, "\n"); return -ENOTSUPP; }
static int nfcsim_dep_link_down(struct nfc_dev *nfc_dev) { struct nfcsim *dev = nfc_get_drvdata(nfc_dev); DEV_DBG(dev, "\n"); nfcsim_cleanup_dev(dev, 0); return 0; }
static void adv7520_hdcp_enable(struct work_struct *work) { DEV_INFO("HDCP: Start reg[0xaf]=%02x (mute audio)\n", reg[0xaf]); adv7520_comm_power(1, 1); adv7520_write_reg(hclient, 0x0C, (u8)0xC3); msleep(200); reg[0xBF] = adv7520_read_reg(hclient, 0xBF); reg[0xC0] = adv7520_read_reg(hclient, 0xC0); reg[0xC1] = adv7520_read_reg(hclient, 0xC1); reg[0xC2] = adv7520_read_reg(hclient, 0xC2); reg[0xc3] = adv7520_read_reg(hclient, 0xC3); DEV_DBG("HDCP: BKSV={%02x,%02x,%02x,%02x,%02x}\n", reg[0xbf], reg[0xc0], reg[0xc1], reg[0xc2], reg[0xc3]); reg[0xBE] = adv7520_read_reg(hclient, 0xBE); if (~(reg[0xBE] & 0x40)) { ; } else { adv7520_write_reg(hclient, 0x0C, (u8)0x84); mutex_lock(&hdcp_state_mutex); hdcp_activating = FALSE; mutex_unlock(&hdcp_state_mutex); DEV_WARN("HDCP: Sink Repeater (%02x), (unmute audio)\n", reg[0xbe]); adv7520_comm_power(0, 1); return; } msleep(200); reg[0xB8] = adv7520_read_reg(hclient, 0xB8); DEV_INFO("HDCP: Status reg[0xB8] is %02x\n", reg[0xb8]); if (reg[0xb8] & 0x40) { adv7520_write_reg(hclient, 0x0C, (u8)0x84); DEV_INFO("HDCP: A/V content Encrypted (unmute audio)\n"); external_common_state->hdcp_active = TRUE; } adv7520_comm_power(0, 1); mutex_lock(&hdcp_state_mutex); hdcp_activating = FALSE; mutex_unlock(&hdcp_state_mutex); }
static void adv7520_hdcp_enable(struct work_struct *work) { DEV_INFO("HDCP: Start reg[0xaf]=%02x (mute audio)\n", reg[0xaf]); adv7520_comm_power(1, 1); /* Mute Audio */ adv7520_write_reg(hclient, 0x0C, (u8)0xC3); msleep(200); /* Wait for BKSV ready interrupt */ /* Read BKSV's keys from HDTV */ reg[0xBF] = adv7520_read_reg(hclient, 0xBF); reg[0xC0] = adv7520_read_reg(hclient, 0xC0); reg[0xC1] = adv7520_read_reg(hclient, 0xC1); reg[0xC2] = adv7520_read_reg(hclient, 0xC2); reg[0xc3] = adv7520_read_reg(hclient, 0xC3); DEV_DBG("HDCP: BKSV={%02x,%02x,%02x,%02x,%02x}\n", reg[0xbf], reg[0xc0], reg[0xc1], reg[0xc2], reg[0xc3]); /* Is SINK repeater */ reg[0xBE] = adv7520_read_reg(hclient, 0xBE); if (~(reg[0xBE] & 0x40)) { ; /* compare with revocation list */ /* Check 20 1's and 20 zero's */ } else { /* Don't implement HDCP if sink as a repeater */ adv7520_write_reg(hclient, 0x0C, (u8)0x84); mutex_lock(&hdcp_state_mutex); hdcp_activating = FALSE; mutex_unlock(&hdcp_state_mutex); DEV_WARN("HDCP: Sink Repeater (%02x), (unmute audio)\n", reg[0xbe]); adv7520_comm_power(0, 1); return; } msleep(200); reg[0xB8] = adv7520_read_reg(hclient, 0xB8); DEV_INFO("HDCP: Status reg[0xB8] is %02x\n", reg[0xb8]); if (reg[0xb8] & 0x40) { /* UnMute Audio */ adv7520_write_reg(hclient, 0x0C, (u8)0x84); DEV_INFO("HDCP: A/V content Encrypted (unmute audio)\n"); external_common_state->hdcp_active = TRUE; } adv7520_comm_power(0, 1); mutex_lock(&hdcp_state_mutex); hdcp_activating = FALSE; mutex_unlock(&hdcp_state_mutex); }
//bool isCarkitConnected=false; void dp_switch_carkit(bool enable) { //isCarkitConnected=enable; g_otg_state=enable; DEV_DBG("%s: dp_switch_carkit is %d++++\n", __func__,enable); if(NULL != notify_carkit_in_out_func_ptr) { printk("[dp] carkit cable notify (%d)\n", enable); (*notify_carkit_in_out_func_ptr) (enable); } }
static ssize_t external_common_rda_connected(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t ret; mutex_lock(&external_common_state_hpd_mutex); ret = snprintf(buf, PAGE_SIZE, "%d\n", external_common_state->hpd_state); DEV_DBG("%s: '%d'\n", __func__, external_common_state->hpd_state); mutex_unlock(&external_common_state_hpd_mutex); return ret; }
static irqreturn_t dp_usb_id_detect_handler(int irq, void *dev_id){ struct anx7808_platform_data *pdata = anx7808_client->dev.platform_data; struct anx7808_data *anx7808 = (struct anx7808_data *)dev_id; if(gpio_get_value(pdata->gpio_cbl_det)==1)goto exit; DEV_DBG("%s: ++++\n", __func__); if(gpio_get_value(pdata->gpio_usb_id)==0) queue_delayed_work(anx7808->workqueue, &anx7808->carKitwork, 50); else dp_switch_carkit(false); exit: return IRQ_HANDLED; }
/* ISR for TV out cable detect */ static irqreturn_t tvout_msm_isr(int irq, void *dev_id) { tvout_msm_state->hpd_int_status = TV_IN(TV_INTR_STATUS); TV_OUT(TV_INTR_CLEAR, tvout_msm_state->hpd_int_status); DEV_DBG("%s: ISR: 0x%02x\n", __func__, tvout_msm_state->hpd_int_status & 0x05); if (tvenc_pdata->poll) if (!tvout_msm_state || !tvout_msm_state->disp_powered_up) { DEV_DBG("%s: ISR ignored, display not yet powered on\n", __func__); return IRQ_HANDLED; } if (tvout_msm_state->hpd_int_status & BIT(0) || tvout_msm_state->hpd_int_status & BIT(2)) { /* Use .75sec to debounce the interrupt */ mod_timer(&tvout_msm_state->hpd_state_timer, jiffies + msecs_to_jiffies(750)); } return IRQ_HANDLED; }
static int nfcsim_target_found(struct nfcsim *dev) { struct nfc_target nfc_tgt; DEV_DBG(dev, "\n"); memset(&nfc_tgt, 0, sizeof(struct nfc_target)); nfc_tgt.supported_protocols = NFC_PROTO_NFC_DEP_MASK; nfc_targets_found(dev->nfc_dev, &nfc_tgt, 1); return 0; }
static int tvout_device_pm_resume(struct device *dev) { mutex_lock(&tvout_msm_state_mutex); if (!tvout_msm_state->pm_suspended) { mutex_unlock(&tvout_msm_state_mutex); return 0; } if (tvenc_pdata->poll) { tvout_msm_state->pm_suspended = FALSE; mod_timer(&tvout_msm_state->hpd_work_timer, jiffies + msecs_to_jiffies(TVOUT_HPD_DUTY_CYCLE)); mutex_unlock(&tvout_msm_state_mutex); DEV_DBG("%s: resuming cable detect timer\n", __func__); } else { tvenc_set_encoder_clock(CLOCK_ON); tvout_msm_state->pm_suspended = FALSE; mutex_unlock(&tvout_msm_state_mutex); enable_irq(tvout_msm_state->irq); DEV_DBG("%s: enable cable detect interrupt\n", __func__); } return 0; }
static ssize_t hdmi_3d_wta_format_3d(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { ssize_t ret = strnlen(buf, PAGE_SIZE); int format_3d = atoi(buf); if (format_3d >= 0 && format_3d <= 2) { if (format_3d != external_common_state->format_3d) { external_common_state->format_3d = format_3d; if (external_common_state->switch_3d) external_common_state->switch_3d(format_3d); DEV_DBG("%s: '%d'\n", __func__, external_common_state->format_3d); } else { DEV_DBG("%s: '%d' (unchanged)\n", __func__, external_common_state->format_3d); } } else { DEV_DBG("%s: '%d' (unknown)\n", __func__, format_3d); } return ret; }
static void nfcsim_stop_poll(struct nfc_dev *nfc_dev) { struct nfcsim *dev = nfc_get_drvdata(nfc_dev); DEV_DBG(dev, "Stop poll\n"); mutex_lock(&dev->lock); dev->polling_mode = NFCSIM_POLL_NONE; mutex_unlock(&dev->lock); cancel_delayed_work_sync(&dev->poll_work); }
static int nfcsim_dev_up(struct nfc_dev *nfc_dev) { struct nfcsim *dev = nfc_get_drvdata(nfc_dev); DEV_DBG(dev, "\n"); mutex_lock(&dev->lock); dev->up = 1; mutex_unlock(&dev->lock); return 0; }
int msm_dss_enable_gpio(struct dss_gpio *in_gpio, int num_gpio, int enable) { int i = 0, rc = 0; if (enable) { for (i = 0; i < num_gpio; i++) { DEV_DBG("%pS->%s: %s enable\n", __builtin_return_address(0), __func__, in_gpio[i].gpio_name); rc = gpio_request(in_gpio[i].gpio, in_gpio[i].gpio_name); if (rc < 0) { DEV_ERR("%pS->%s: %s enable failed\n", __builtin_return_address(0), __func__, in_gpio[i].gpio_name); goto disable_gpio; } gpio_set_value(in_gpio[i].gpio, in_gpio[i].value); } } else { for (i = num_gpio-1; i >= 0; i--) { DEV_DBG("%pS->%s: %s disable\n", __builtin_return_address(0), __func__, in_gpio[i].gpio_name); if (in_gpio[i].gpio) gpio_free(in_gpio[i].gpio); } } return rc; disable_gpio: for (i--; i >= 0; i--) if (in_gpio[i].gpio) gpio_free(in_gpio[i].gpio); return rc; } /* msm_dss_enable_gpio */
void sp_tx_hardware_recovery(struct i2c_client *client) { struct anx7808_platform_data *pdata = client->dev.platform_data; //return; gpio_set_value(pdata->gpio_reset, 0); msleep(20); //gpio_set_value(pdata->gpio_v10_ctrl, 0); //msleep(5); gpio_set_value(pdata->gpio_p_dwn, 1); msleep(20); DEV_DBG("%s: anx7808 power recovery\n", __func__); }
static void tvout_msm_hpd_work(struct work_struct *work) { uint32 reg; #ifdef CONFIG_SUSPEND mutex_lock(&tvout_msm_state_mutex); if (tvout_msm_state->pm_suspended) { mutex_unlock(&tvout_msm_state_mutex); DEV_WARN("%s: ignored, pm_suspended\n", __func__); return; } mutex_unlock(&tvout_msm_state_mutex); #endif /* Enable power lines & clocks */ tvenc_pdata->pm_vid_en(1); tvenc_set_clock(CLOCK_ON); /* Enable encoder to get a stable interrupt */ reg = TV_IN(TV_ENC_CTL); TV_OUT(TV_ENC_CTL, reg | TVENC_CTL_ENC_EN); /* SW- workaround to update status register */ reg = TV_IN(TV_DAC_INTF); TV_OUT(TV_DAC_INTF, reg & ~TVENC_LOAD_DETECT_EN); TV_OUT(TV_INTR_CLEAR, 0xf); reg = TV_IN(TV_DAC_INTF); TV_OUT(TV_DAC_INTF, reg | TVENC_LOAD_DETECT_EN); tvout_msm_state->hpd_int_status = TV_IN(TV_INTR_STATUS); /* Disable TV encoder */ reg = TV_IN(TV_ENC_CTL); TV_OUT(TV_ENC_CTL, reg & ~TVENC_CTL_ENC_EN); /*Disable power lines & clocks */ tvenc_set_clock(CLOCK_OFF); tvenc_pdata->pm_vid_en(0); DEV_DBG("%s: ISR: 0x%02x\n", __func__, tvout_msm_state->hpd_int_status & 0x05); mod_timer(&tvout_msm_state->hpd_work_timer, jiffies + msecs_to_jiffies(TVOUT_HPD_DUTY_CYCLE)); tvout_check_status(); }
static void nfcsim_cleanup_dev(struct nfcsim *dev, u8 shutdown) { DEV_DBG(dev, "shutdown=%d\n", shutdown); mutex_lock(&dev->lock); dev->polling_mode = NFCSIM_POLL_NONE; dev->shutting_down = shutdown; dev->cb = NULL; dev_kfree_skb(dev->clone_skb); dev->clone_skb = NULL; mutex_unlock(&dev->lock); cancel_delayed_work_sync(&dev->poll_work); cancel_delayed_work_sync(&dev->recv_work); }
static int tvout_device_pm_suspend(struct device *dev) { mutex_lock(&tvout_msm_state_mutex); if (tvout_msm_state->pm_suspended) { mutex_unlock(&tvout_msm_state_mutex); return 0; } if (tvenc_pdata->poll) { if (del_timer(&tvout_msm_state->hpd_work_timer)) DEV_DBG("%s: suspending cable detect timer\n", __func__); } else { disable_irq(tvout_msm_state->irq); tvenc_set_encoder_clock(CLOCK_OFF); } tvout_msm_state->pm_suspended = TRUE; mutex_unlock(&tvout_msm_state_mutex); return 0; }
static int nfcsim_dep_link_up(struct nfc_dev *nfc_dev, struct nfc_target *target, u8 comm_mode, u8 *gb, size_t gb_len) { int rc; struct nfcsim *dev = nfc_get_drvdata(nfc_dev); struct nfcsim *peer = dev->peer_dev; u8 *remote_gb; size_t remote_gb_len; DEV_DBG(dev, "target_idx: %d, comm_mode: %d\n", target->idx, comm_mode); mutex_lock(&peer->lock); nfc_tm_activated(peer->nfc_dev, NFC_PROTO_NFC_DEP_MASK, NFC_COMM_ACTIVE, gb, gb_len); remote_gb = nfc_get_local_general_bytes(peer->nfc_dev, &remote_gb_len); if (!remote_gb) { DEV_ERR(peer, "Can't get remote general bytes\n"); mutex_unlock(&peer->lock); return -EINVAL; } mutex_unlock(&peer->lock); mutex_lock(&dev->lock); rc = nfc_set_remote_general_bytes(nfc_dev, remote_gb, remote_gb_len); if (rc) { DEV_ERR(dev, "Can't set remote general bytes\n"); mutex_unlock(&dev->lock); return rc; } rc = nfc_dep_link_is_up(nfc_dev, target->idx, NFC_COMM_ACTIVE, NFC_RF_INITIATOR); mutex_unlock(&dev->lock); return rc; }
/* Change HDMI state */ static void change_hdmi_state(int online) { if (!external_common_state) return; mutex_lock(&external_common_state_hpd_mutex); external_common_state->hpd_state = online; mutex_unlock(&external_common_state_hpd_mutex); if (!external_common_state->uevent_kobj) return; if (online) kobject_uevent(external_common_state->uevent_kobj, KOBJ_ONLINE); else kobject_uevent(external_common_state->uevent_kobj, KOBJ_OFFLINE); DEV_DBG("adv7525_uevent: %d\n", online); }
u32 dss_reg_r(struct dss_io_data *io, u32 offset, u32 debug) { u32 value; if (!io || !io->base) { DEV_ERR("%pS->%s: invalid input\n", __builtin_return_address(0), __func__); return -EINVAL; } if (offset > io->len) { DEV_ERR("%pS->%s: offset out of range\n", __builtin_return_address(0), __func__); return -EINVAL; } value = readl_relaxed(io->base + offset); if (debug) DEV_DBG("[%08x] <= %08x\n", (u32)(io->base + offset), value); return value; } /* dss_reg_r */
/* create HDMI kobject and initialize */ int hdmi_common_state_create(struct platform_device *pdev) { int rc; struct msm_fb_data_type *mfd = platform_get_drvdata(pdev); rc = sysfs_create_group(&mfd->fbi->dev->kobj, &hdmi_common_fs_attr_group); if (rc) { DEV_ERR("%s: sysfs group creation failed, rc=%d\n", __func__, rc); return rc; } hdmi_common_state->uevent_kobj = &mfd->fbi->dev->kobj; DEV_ERR("%s: sysfs group %p\n", __func__, hdmi_common_state->uevent_kobj); kobject_uevent(hdmi_common_state->uevent_kobj, KOBJ_ADD); DEV_DBG("%s: kobject_uevent(KOBJ_ADD)\n", __func__); return 0; }
static int nfcsim_start_poll(struct nfc_dev *nfc_dev, u32 im_protocols, u32 tm_protocols) { struct nfcsim *dev = nfc_get_drvdata(nfc_dev); int rc; mutex_lock(&dev->lock); if (dev->polling_mode != NFCSIM_POLL_NONE) { DEV_ERR(dev, "Already in polling mode\n"); rc = -EBUSY; goto exit; } if (im_protocols & NFC_PROTO_NFC_DEP_MASK) dev->polling_mode |= NFCSIM_POLL_INITIATOR; if (tm_protocols & NFC_PROTO_NFC_DEP_MASK) dev->polling_mode |= NFCSIM_POLL_TARGET; if (dev->polling_mode == NFCSIM_POLL_NONE) { DEV_ERR(dev, "Unsupported polling mode\n"); rc = -EINVAL; goto exit; } dev->initiator = 0; dev->curr_polling_mode = NFCSIM_POLL_NONE; queue_delayed_work(wq, &dev->poll_work, 0); DEV_DBG(dev, "Start polling: im: 0x%X, tm: 0x%X\n", im_protocols, tm_protocols); rc = 0; exit: mutex_unlock(&dev->lock); return rc; }
/* LGE_CHANGE_S [[email protected]] 2011-07-06, Add power_state for NXP HDMI module build */ static ssize_t hdmi_common_wta_power_state(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { ssize_t ret = strnlen(buf, PAGE_SIZE); int power_state; power_state = atoi(buf); if(power_state==1) external_common_state->power_state = 1; else if(power_state==0) external_common_state->power_state = 0; else external_common_state->power_state = -1; DEV_DBG("%s: 'power=%d' successful\n", __func__, external_common_state->power_state); /* LGE_CHANGE_S [[email protected]] 2011-07-06, Add power_state for NXP HDMI module build */ #ifdef CONFIG_LGE_HDMI_MODULE_BUILD #else change_hdmi_power(external_common_state->power_state); #endif /* LGE_CHANGE_S [[email protected]] 2011-07-06, Add power_state for NXP HDMI module build */ return ret; }
static ssize_t external_common_wta_video_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { ssize_t ret = strnlen(buf, PAGE_SIZE); uint32 video_mode; #ifdef CONFIG_FB_MSM_HDMI_COMMON const struct hdmi_disp_mode_timing_type *disp_mode; #endif mutex_lock(&external_common_state_hpd_mutex); if (!external_common_state->hpd_state) { mutex_unlock(&external_common_state_hpd_mutex); DEV_INFO("%s: FAILED: display off or cable disconnected\n", __func__); return ret; } mutex_unlock(&external_common_state_hpd_mutex); video_mode = atoi(buf)-1; kobject_uevent(external_common_state->uevent_kobj, KOBJ_OFFLINE); #ifdef CONFIG_FB_MSM_HDMI_COMMON disp_mode = hdmi_common_get_supported_mode(video_mode); if (!disp_mode) { DEV_INFO("%s: FAILED: mode not supported (%d)\n", __func__, video_mode); return ret; } external_common_state->disp_mode_list.num_of_elements = 1; external_common_state->disp_mode_list.disp_mode_list[0] = video_mode; #elif defined(CONFIG_FB_MSM_TVOUT) external_common_state->tvout_enable(0); external_common_state->video_resolution = video_mode; external_common_state->tvout_enable(1); #endif DEV_DBG("%s: 'mode=%d %s' successful (sending OFF/ONLINE)\n", __func__, video_mode, video_format_2string(video_mode)); kobject_uevent(external_common_state->uevent_kobj, KOBJ_ONLINE); return ret; }
void dss_reg_w(struct dss_io_data *io, u32 offset, u32 value, u32 debug) { u32 in_val; if (!io || !io->base) { DEV_ERR("%pS->%s: invalid input\n", __builtin_return_address(0), __func__); return; } if (offset > io->len) { DEV_ERR("%pS->%s: offset out of range\n", __builtin_return_address(0), __func__); return; } writel_relaxed(value, io->base + offset); if (debug) { in_val = readl_relaxed(io->base + offset); DEV_DBG("[%08x] => %08x [%08x]\n", (u32)(io->base + offset), value, in_val); } } /* dss_reg_w */
static int __devinit tvout_probe(struct platform_device *pdev) { int rc = 0; uint32 reg; struct platform_device *fb_dev; #ifdef CONFIG_FB_MSM_TVOUT_NTSC_M external_common_state->video_resolution = NTSC_M; #elif defined CONFIG_FB_MSM_TVOUT_NTSC_J external_common_state->video_resolution = NTSC_J; #elif defined CONFIG_FB_MSM_TVOUT_PAL_M external_common_state->video_resolution = PAL_M; #elif defined CONFIG_FB_MSM_TVOUT_PAL_N external_common_state->video_resolution = PAL_N; #elif defined CONFIG_FB_MSM_TVOUT_PAL_BDGHIN external_common_state->video_resolution = PAL_BDGHIN; #endif external_common_state->dev = &pdev->dev; if (pdev->id == 0) { struct resource *res; #define GET_RES(name, mode) do { \ res = platform_get_resource_byname(pdev, mode, name); \ if (!res) { \ DEV_DBG("'" name "' resource not found\n"); \ rc = -ENODEV; \ goto error; \ } \ } while (0) #define GET_IRQ(var, name) do { \ GET_RES(name, IORESOURCE_IRQ); \ var = res->start; \ } while (0) GET_IRQ(tvout_msm_state->irq, "tvout_device_irq"); #undef GET_IRQ #undef GET_RES return 0; } DEV_DBG("%s: tvout_msm_state->irq : %d", __func__, tvout_msm_state->irq); rc = request_irq(tvout_msm_state->irq, &tvout_msm_isr, IRQF_TRIGGER_HIGH, "tvout_msm_isr", NULL); if (rc) { DEV_DBG("Init FAILED: IRQ request, rc=%d\n", rc); goto error; } disable_irq(tvout_msm_state->irq); init_timer(&tvout_msm_state->hpd_state_timer); tvout_msm_state->hpd_state_timer.function = tvout_msm_hpd_state_timer; tvout_msm_state->hpd_state_timer.data = (uint32)NULL; tvout_msm_state->hpd_state_timer.expires = jiffies + msecs_to_jiffies(1000); if (tvenc_pdata->poll) { init_timer(&tvout_msm_state->hpd_work_timer); tvout_msm_state->hpd_work_timer.function = tvout_msm_hpd_work_timer; tvout_msm_state->hpd_work_timer.data = (uint32)NULL; tvout_msm_state->hpd_work_timer.expires = jiffies + msecs_to_jiffies(1000); } fb_dev = msm_fb_add_device(pdev); if (fb_dev) { rc = external_common_state_create(fb_dev); if (rc) { DEV_ERR("Init FAILED: tvout_msm_state_create, rc=%d\n", rc); goto error; } if (tvenc_pdata->poll) { /* Start polling timer to detect load */ mod_timer(&tvout_msm_state->hpd_work_timer, jiffies + msecs_to_jiffies(TVOUT_HPD_DUTY_CYCLE)); } else { /* Enable interrupt to detect load */ tvenc_set_encoder_clock(CLOCK_ON); reg = TV_IN(TV_DAC_INTF); reg |= TVENC_LOAD_DETECT_EN; TV_OUT(TV_DAC_INTF, reg); TV_OUT(TV_INTR_ENABLE, 0x5); enable_irq(tvout_msm_state->irq); } } else DEV_ERR("Init FAILED: failed to add fb device\n"); error: return 0; }