static void wacom_i2c_early_suspend(struct early_suspend *h)
{
struct wacom_i2c *wac_i2c = container_of(h, struct wacom_i2c, early_suspend);
if(IsWacomEnabled == false){
printk(KERN_ERR "[E-PEN]: E-PEN have been disabled by menu \n");
return;
}
disable_irq(wac_i2c->client->irq);
#ifdef EPEN_CPU_LOCK
if (epen_cpu_lock_status) {
s5pv310_cpufreq_lock_free(DVFS_LOCK_ID_PEN);
epen_cpu_lock_status = 0;
}
#endif
/* release pen, if it is pressed*/
if(wac_i2c->pen_pressed || wac_i2c->side_pressed)
{
input_report_abs(wac_i2c->input_dev, ABS_PRESSURE, 0);
input_report_key(wac_i2c->input_dev, EPEN_STYLUS, 0);
input_report_key(wac_i2c->input_dev, BTN_TOUCH, 0);
input_report_key(wac_i2c->input_dev, wac_i2c->tool, 0);
input_sync(wac_i2c->input_dev);
pr_info("[E-PEN] is released\n");
}
wac_i2c->wac_pdata->early_suspend_platform_hw();
printk(KERN_DEBUG "[E-PEN]:%s.\n", __func__);
}
static ssize_t dvfslock_ctrl(const char *buf, size_t count)
{
unsigned int ret = -EINVAL;
int dlevel;
int dtime_msec;
ret = sscanf(buf, "%u", &gdDvfsctrl);
if (ret != 1)
return -EINVAL;
if (gdDvfsctrl ==0) {
if (dvfsctrl_locked) {
s5pv310_cpufreq_lock_free(DVFS_LOCK_ID_APP);
dvfsctrl_locked = 0;
}
return -EINVAL;
}
if (dvfsctrl_locked) {
printk(KERN_ERR "%s - already locked\n", __func__);
return 0;
}
dlevel = gdDvfsctrl / 10000;
dtime_msec = gdDvfsctrl % 10000;
if (dtime_msec < 16)
dtime_msec = 16;
if (dtime_msec == 0)
return -EINVAL;
if (dlevel)
dlevel = CPU_L1;
else
dlevel = CPU_L0;
printk(KERN_DEBUG "%s: level = %d, time =%d\n", __func__, dlevel, dtime_msec);
s5pv310_cpufreq_lock(DVFS_LOCK_ID_APP, dlevel);
dvfsctrl_locked = 1;
schedule_delayed_work(&dvfslock_ctrl_unlock_work, msecs_to_jiffies(dtime_msec));
return -EINVAL;
}
static void wacom_i2c_early_suspend(struct early_suspend *h)
{
struct wacom_i2c *wac_i2c = container_of(h, struct wacom_i2c, early_suspend);
if(IsWacomEnabled == false){
printk(KERN_ERR "[E-PEN]: E-PEN have been disabled by menu \n");
return;
}
disable_irq(wac_i2c->client->irq);
#ifdef EPEN_CPU_LOCK
if (epen_cpu_lock_status) {
s5pv310_cpufreq_lock_free(DVFS_LOCK_ID_PEN);
epen_cpu_lock_status = 0;
}
#endif
#ifdef WACOM_PDCT_WORK_AROUND
disable_irq(wac_i2c->irq_pdct);
#endif
printk(KERN_INFO "[E-PEN] %s - wac_i2c->pen_pdct = %d, wac_i2c->pen_pressed = %d\n", __func__, wac_i2c->pen_pdct, wac_i2c->pen_pressed);
printk(KERN_INFO "[E-PEN] %s - wac_i2c->side_pressed = %d, wac_i2c->pen_prox = %d\n", __func__, wac_i2c->side_pressed, wac_i2c->pen_prox);
/* release pen, if it is pressed*/
#if 0 //def WACOM_PDCT_WORK_AROUND
if (wac_i2c->pen_pdct == PDCT_DETECT_PEN)
#else
if (wac_i2c->pen_pressed || wac_i2c->side_pressed
|| wac_i2c->pen_prox)
#endif
forced_release(wac_i2c);
wac_i2c->wac_pdata->early_suspend_platform_hw();
printk(KERN_DEBUG "[E-PEN]:%s.\n", __func__);
}
static int mfc_release(struct inode *inode, struct file *file)
{
struct mfc_inst_ctx *mfc_ctx;
struct mfc_dev *dev;
int ret;
mfc_ctx = (struct mfc_inst_ctx *)file->private_data;
if (!mfc_ctx)
return -EINVAL;
dev = mfc_ctx->dev;
mutex_lock(&dev->lock);
#ifdef CONFIG_CPU_FREQ
/* Release MFC & Bus Frequency lock for High resolution */
if (mfc_ctx->busfreq_flag == true) {
atomic_dec(&dev->busfreq_lock_cnt);
mfc_ctx->busfreq_flag = false;
if (atomic_read(&dev->busfreq_lock_cnt) == 0) {
/* release Freq lock back to normal */
s5pv310_busfreq_lock_free(DVFS_LOCK_ID_MFC);
mfc_dbg("[%s] Bus Freq lock Released Normal !!\n", __func__);
}
}
/* Release MFC & CPU Frequency lock for High resolution */
if (mfc_ctx->cpufreq_flag == true) {
atomic_dec(&dev->cpufreq_lock_cnt);
mfc_ctx->cpufreq_flag = false;
if (atomic_read(&dev->cpufreq_lock_cnt) == 0) {
/* release Freq lock back to normal */
s5pv310_cpufreq_lock_free(DVFS_LOCK_ID_MFC);
mfc_dbg("[%s] CPU Freq lock Released Normal !!\n", __func__);
}
}
#endif
file->private_data = NULL;
printk(KERN_INFO "MFC instance [%d] released\n", mfc_ctx->id);
dev->inst_ctx[mfc_ctx->id] = NULL;
atomic_dec(&dev->inst_cnt);
mfc_destroy_inst(mfc_ctx);
if (atomic_read(&dev->inst_cnt) == 0) {
ret = mfc_power_off();
if (ret < 0) {
mfc_err("power disable failed\n");
goto err_pwr_disable;
}
/*
* All MFC instances are shut down - MFC is no longer running
*/
mfc_is_running = 0;
} else {
#if defined(SYSMMU_MFC_ON) && !defined(CONFIG_VIDEO_MFC_VCM_UMP)
mfc_clock_on();
sysmmu_tlb_invalidate(SYSMMU_MFC_L);
sysmmu_tlb_invalidate(SYSMMU_MFC_R);
mfc_clock_off();
#endif
}
ret = 0;
err_pwr_disable:
mutex_unlock(&dev->lock);
return ret;
}
static void do_dvfsunlock_timer(struct work_struct *work)
{
dvfsctrl_locked = 0;
s5pv310_cpufreq_lock_free(DVFS_LOCK_ID_APP);
}
static int s5k6aafx_init(struct v4l2_subdev *sd, u32 val)
{
//struct i2c_client *client = v4l2_get_subdevdata(sd);
struct s5k6aafx_state *state = to_state(sd);
int err = -EINVAL;
static int lock_level = -1;
FUNC_ENTR();
#ifdef CONFIG_LOAD_FILE
err = loadFile();
if (unlikely(err)) {
printk("%s: failed to init\n", __func__);
return err;
}
#endif
#if defined(CONFIG_CPU_FREQ)
if (lock_level < 0)
lock_level = s5pv310_cpufreq_round_idx(CPUFREQ_1200MHZ);
if (s5pv310_cpufreq_lock(DVFS_LOCK_ID_CAM, lock_level))
printk(KERN_ERR "%s: error : failed lock DVFS\n", __func__);
#endif
/* set initial regster value */
if (state->vt_mode == 0)
{
printk("%s: load camera common setting \n", __func__);
#ifdef CONFIG_LOAD_FILE
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_common");
#else
err = s5k6aafx_write_regs(sd, s5k6aafx_common, sizeof(s5k6aafx_common) / sizeof(s5k6aafx_common[0]));
#endif
}
else
{
printk("%s: load camera VT call setting \n", __func__);
#ifdef CONFIG_LOAD_FILE
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_vt_common");
#else
err = s5k6aafx_write_regs(sd, s5k6aafx_vt_common, sizeof(s5k6aafx_vt_common) / sizeof(s5k6aafx_vt_common[0]));
#endif
}
#if defined(CONFIG_CPU_FREQ)
s5pv310_cpufreq_lock_free(DVFS_LOCK_ID_CAM);
#endif
if (unlikely(err))
{
printk("%s: failed to init\n", __func__);
return err;
}
#if defined(CONFIG_TARGET_LOCALE_LTN)
//latin_cam VT Cam Antibanding
if (state->anti_banding == ANTI_BANDING_60HZ)
{
err = s5k6aafx_set_60hz_antibanding(sd);
if (unlikely(err))
{
printk("%s: failed to s5k6aafx_set_60hz_antibanding \n", __func__);
return err;
}
}
//hmin84.park -10.07.06
#endif
state->set_fmt.width = DEFAULT_WIDTH;
state->set_fmt.height = DEFAULT_HEIGHT;
return 0;
}
static int s5k5bbgx_init(struct v4l2_subdev *sd, u32 val)
{
/* struct i2c_client *client = v4l2_get_subdevdata(sd); */
struct s5k5bbgx_state *state = to_state(sd);
int err = -EINVAL;
cam_dbg("E\n");
#ifdef CONFIG_CPU_FREQ
if (s5pv310_cpufreq_lock(DVFS_LOCK_ID_CAM, CPU_L0))
cam_err("failed lock DVFS\n");
#endif
/* set initial regster value */
#ifdef CONFIG_LOAD_FILE
if (!state->vt_mode) {
cam_dbg("load camera common setting\n");
err = s5k5bbgx_write_regs_from_sd(sd,
"s5k5bbgx_common");
} else {
if (state->vt_mode == 1) {
cam_info("load camera VT call setting\n");
err = s5k5bbgx_write_regs_from_sd(sd,
"s5k5bbgx_vt_common");
} else {
cam_info("load camera WIFI VT call setting\n");
err = s5k5bbgx_write_regs_from_sd(sd,
"s5k5bbgx_vt_wifi_common");
}
}
#else
if (!state->vt_mode) {
cam_info("load camera common setting\n");
err = s5k5bbgx_write_regs(sd, s5k5bbgx_common,
sizeof(s5k5bbgx_common) / \
sizeof(s5k5bbgx_common[0]));
} else {
if (state->vt_mode == 1) {
cam_info("load camera VT call setting\n");
err = s5k5bbgx_write_regs(sd, s5k5bbgx_vt_common,
sizeof(s5k5bbgx_vt_common) / \
sizeof(s5k5bbgx_vt_common[0]));
} else {
cam_info("load camera WIFI VT call setting\n");
err = s5k5bbgx_write_regs(sd, s5k5bbgx_vt_wifi_common,
sizeof(s5k5bbgx_vt_wifi_common) / \
sizeof(s5k5bbgx_vt_wifi_common[0]));
}
}
#endif
#ifdef CONFIG_CPU_FREQ
s5pv310_cpufreq_lock_free(DVFS_LOCK_ID_CAM);
#endif
if (unlikely(err)) {
cam_err("failed to init\n");
return err;
}
/* We stop stream-output from sensor when starting camera. */
err = s5k5bbgx_control_stream(sd, STREAM_STOP);
if (unlikely(err < 0))
return err;
msleep(150);
if (state->vt_mode && (state->req_fps != state->set_fps)) {
err = s5k5bbgx_set_frame_rate(sd, state->req_fps);
if (unlikely(err < 0))
return err;
else
state->set_fps = state->req_fps;
}
state->initialized = 1;
return 0;
}
