static int __init pm_init(void)
{
int error = pm_start_workqueue();
#ifdef CONFIG_PERFLOCK
#ifdef CONFIG_SHSYS_CUST_PERFLOCK
#ifdef CONFIG_SHSYS_CUST_USER_PERFLOCK
int i;
static char perflock_name[PERF_LOCK_INVALID][25];
static char limitlock_name[PERF_LOCK_INVALID][26];
#endif
#else
int i;
char buf[38];
#endif
#endif
if (error)
return error;
hibernate_image_size_init();
hibernate_reserved_size_init();
touch_evt_timer_val = ktime_set(2, 0);
hrtimer_init(&tc_ev_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
tc_ev_timer.function = &tc_ev_stop;
tc_ev_processed = 1;
#ifdef CONFIG_PERFLOCK
#ifdef CONFIG_SHSYS_CUST_PERFLOCK
#ifdef CONFIG_SHSYS_CUST_USER_PERFLOCK
pm_qos_add_request(&user_perf_lock_qos, PM_QOS_CPU_DMA_LATENCY, PM_QOS_DEFAULT_VALUE);
for (i = 0; i < PERF_LOCK_INVALID; i++) {
snprintf(perflock_name[i], 24, "User Perflock level(%d)", i);
perflock_name[i][24] = '\0';
perf_lock_init(&user_perf_lock[i], i, perflock_name[i]);
snprintf(limitlock_name[i], 25, "User Limitlock level(%d)", i);
limitlock_name[i][25] = '\0';
limit_lock_init(&user_limit_lock[i], i, limitlock_name[i]);
}
#endif
#else
perf_lock_init(&user_perf_lock, PERF_LOCK_HIGHEST, "User Perflock");
for (i = 0; i < CEILING_LEVEL_INVALID; i++) {
snprintf(buf, 37, "User cpufreq_ceiling lock level(%d)", i);
buf[37] = '\0';
perf_lock_init_v2(&user_cpufreq_ceiling[i], i, buf);
}
#endif
#endif
power_kobj = kobject_create_and_add("power", NULL);
if (!power_kobj)
return -ENOMEM;
error = sysfs_create_group(power_kobj, &attr_group);
if (error)
return error;
return pm_autosleep_init();
}
static int mipi_himax_lcd_probe(struct platform_device *pdev)
{
#if defined CONFIG_FB_MSM_SELF_REFRESH
int ret;
#endif
if (pdev->id == 0) {
mipi_himax_pdata = pdev->dev.platform_data;
mutex_init(&cmdlock);
#if defined CONFIG_FB_MSM_SELF_REFRESH
ret = setup_vsync(pdev, 1);
if (ret) {
dev_err(&pdev->dev, "mipi_himax_setup_vsync failed\n");
return ret;
}
wake_lock_init(&himax_idle_wake_lock, WAKE_LOCK_IDLE, "himax_idle_lock");
#ifdef CONFIG_PERFLOCK
perf_lock_init(&himax_perf_lock, PERF_LOCK_HIGHEST, "himax");
#endif
#endif
return 0;
}
msm_fb_add_device(pdev);
return 0;
}
static int __init imx081_init_module(void)
{
int32_t rc = 0;
sharp_smem_common_type *p_sh_smem_common_type = NULL;
int32_t camOtpData_size = 0;
CDBG("%s:%d\n", __func__, __LINE__);
p_sh_smem_common_type = sh_smem_get_common_address();
if(p_sh_smem_common_type != NULL){
camOtpData_size = sizeof(p_sh_smem_common_type->sh_camOtpData);
CDBG("%s camOtpData_size = %d\n", __func__, camOtpData_size);
imx081_diag_data = kmalloc(camOtpData_size, GFP_KERNEL);
if(imx081_diag_data != NULL){
memcpy(imx081_diag_data, &p_sh_smem_common_type->sh_camOtpData[0], camOtpData_size);
}
}
perf_lock_init(&imx081_perf_lock, PERF_LOCK_960000KHz, "camera_imx081");
rc = platform_driver_probe(&imx081_platform_driver,
imx081_platform_probe);
if (!rc)
return rc;
CDBG("%s:%d rc %d\n", __func__, __LINE__, rc);
return i2c_add_driver(&imx081_i2c_driver);
}
static int __devinit
wcnss_wlan_probe(struct platform_device *pdev)
{
if (penv) {
dev_err(&pdev->dev, "cannot handle multiple devices.\n");
return -ENODEV;
}
#ifdef CONFIG_PERFLOCK
perf_lock_init(&qcom_wlan_perf_lock, TYPE_PERF_LOCK, PERF_LOCK_HIGHEST, "qcom-wifi-perf");
#endif
penv = kzalloc(sizeof(*penv), GFP_KERNEL);
if (!penv) {
dev_err(&pdev->dev, "cannot allocate device memory.\n");
return -ENOMEM;
}
penv->pdev = pdev;
#ifdef MODULE
pr_info(DEVICE " probed in MODULE mode\n");
return wcnss_trigger_config(pdev);
#else
pr_info(DEVICE " probed in built-in mode\n");
return misc_register(&wcnss_misc);
#endif
}
static int __init pm_init(void)
{
int error = pm_start_workqueue();
#ifdef CONFIG_PERFLOCK
int i;
static char ceil_buf[PERF_LOCK_INVALID][38];
static char perf_buf[PERF_LOCK_INVALID][24];
#endif
if (error)
return error;
hibernate_image_size_init();
hibernate_reserved_size_init();
touch_evt_timer_val = ktime_set(2, 0);
hrtimer_init(&tc_ev_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
tc_ev_timer.function = &tc_ev_stop;
tc_ev_processed = 1;
power_kobj = kobject_create_and_add("power", NULL);
#ifdef CONFIG_PERFLOCK
perf_lock_init(&user_cpu_perf_lock, TYPE_PERF_LOCK, PERF_LOCK_HIGHEST, "User CPU Highest Perflock");
perf_lock_init(&user_cpu_ceiling_lock, TYPE_CPUFREQ_CEILING, PERF_LOCK_HIGH, "User CPU High cpufreq_ceiling lock");
for (i = PERF_LOCK_LOWEST; i < PERF_LOCK_INVALID; i++) {
snprintf(perf_buf[i], 23, "User Perflock level(%d)", i);
perf_buf[i][23] = '\0';
perf_lock_init(&user_perf_lock[i], TYPE_PERF_LOCK, i, perf_buf[i]);
snprintf(ceil_buf[i], 37, "User cpufreq_ceiling lock level(%d)", i);
ceil_buf[i][37] = '\0';
perf_lock_init(&user_ceiling_lock[i], TYPE_CPUFREQ_CEILING, i, ceil_buf[i]);
}
#endif
if (!power_kobj)
return -ENOMEM;
error = sysfs_create_group(power_kobj, &attr_group);
if (error)
return error;
return pm_autosleep_init();
}
static int __init pm_init(void)
{
int error = pm_start_workqueue();
if (error)
return error;
power_kobj = kobject_create_and_add("power", NULL);
#ifdef CONFIG_PERFLOCK
perf_lock_init(&user_perf_lock, PERF_LOCK_HIGHEST, "User Perflock");
#endif
if (!power_kobj)
return -ENOMEM;
return sysfs_create_group(power_kobj, &attr_group);
}
static int __devinit
wcnss_wlan_probe(struct platform_device *pdev)
{
/* verify we haven't been called more than once */
if (penv) {
dev_err(&pdev->dev, "cannot handle multiple devices.\n");
return -ENODEV;
}
#ifdef CONFIG_PERFLOCK
perf_lock_init(&qcom_wlan_perf_lock, PERF_LOCK_HIGHEST, "qcom-wifi-perf");
#endif /* CONFIG_PERFLOCK */
/* create an environment to track the device */
penv = kzalloc(sizeof(*penv), GFP_KERNEL);
if (!penv) {
dev_err(&pdev->dev, "cannot allocate device memory.\n");
return -ENOMEM;
}
penv->pdev = pdev;
#ifdef MODULE
/*
* Since we were built as a module, we are running because
* the module was loaded, therefore we assume userspace
* applications are available to service PIL, so we can
* trigger the WCNSS configuration now
*/
pr_info(DEVICE " probed in MODULE mode\n");
return wcnss_trigger_config(pdev);
#else
/*
* Since we were built into the kernel we'll be called as part
* of kernel initialization. We don't know if userspace
* applications are available to service PIL at this time
* (they probably are not), so we simply create a device node
* here. When userspace is available it should touch the
* device so that we know that WCNSS configuration can take
* place
*/
pr_info(DEVICE " probed in built-in mode\n");
return misc_register(&wcnss_misc);
#endif
}
static int __devinit hs_probe(struct platform_device *pdev)
{
int rc = 0;
struct input_dev *ipdev;
#if 1
struct api_remote_req_t1 {
struct rpc_request_hdr hdr;
} send_p;
#endif
hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
if (!hs)
return -ENOMEM;
hs->sdev.name = "h2w";
hs->sdev.print_name = msm_headset_print_name;
rc = switch_dev_register(&hs->sdev);
if (rc)
goto err_switch_dev_register;
#ifdef FLIP_USE /* FLIP */
hs->sdev_flip.name = "flip";
hs->sdev_flip.print_name = msm_flip_print_name;
rc = switch_dev_register(&hs->sdev_flip);
if (rc)
goto err_switch_dev_register;
hs->sdev_flip_chatt.name = "flip_chatt";
hs->sdev_flip_chatt.print_name = msm_flip_chatt_print_name;
rc = switch_dev_register(&hs->sdev_flip_chatt);
if (rc)
goto err_switch_dev_register;
#endif
#if 0
hs->sdev_hssw.name = "headphone_switch";
hs->sdev_hssw.print_name = msm_hssw_print_name;
rc = switch_dev_register(&hs->sdev_hssw);
if (rc)
goto err_switch_dev_register;
#endif
ipdev = input_allocate_device();
if (!ipdev) {
rc = -ENOMEM;
goto err_alloc_input_dev;
}
input_set_drvdata(ipdev, hs);
hs->ipdev = ipdev;
if (pdev->dev.platform_data)
hs->hs_pdata = pdev->dev.platform_data;
if (hs->hs_pdata->hs_name)
ipdev->name = hs->hs_pdata->hs_name;
else
ipdev->name = DRIVER_NAME;
ipdev->id.vendor = 0x0001;
ipdev->id.product = 1;
ipdev->id.version = 1;
#if 0
input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
input_set_capability(ipdev, EV_SW, SW_MICROPHONE_INSERT);
input_set_capability(ipdev, EV_KEY, KEY_POWER);
input_set_capability(ipdev, EV_KEY, KEY_END);
#else
input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
#endif
#ifdef FLIP_USE /* FLIP */
input_set_capability(ipdev, EV_SW, SW_LID);
#ifdef CONFIG_PERF_LOCK_ENABLE
perf_lock_init(&flip_perf_lock, PERF_LOCK_HIGHEST, "Flip");
#endif
#endif
rc = input_register_device(ipdev);
if (rc) {
dev_err(&ipdev->dev,
"hs_probe: input_register_device rc=%d\n", rc);
goto err_reg_input_dev;
}
platform_set_drvdata(pdev, hs);
rc = hs_rpc_init();
if (rc) {
dev_err(&ipdev->dev, "rpc init failure\n");
goto err_hs_rpc_init;
}
#if 1
rc = msm_rpc_call_reply(rpc_svc_p,
HS_SHEXTDET_API_INITIALIZE_REMOTE_PROC,
&send_p,sizeof(send_p),
NULL,0,
5 * HZ);
if(rc)
goto err_hs_rpc_init;
#endif
return 0;
err_hs_rpc_init:
input_unregister_device(ipdev);
ipdev = NULL;
err_reg_input_dev:
input_free_device(ipdev);
err_alloc_input_dev:
switch_dev_unregister(&hs->sdev);
#ifdef FLIP_USE /* FLIP */
switch_dev_unregister(&hs->sdev_flip);
switch_dev_unregister(&hs->sdev_flip_chatt);
#endif
#if 0
switch_dev_unregister(&hs->sdev_hssw);
#endif
err_switch_dev_register:
kfree(hs);
return rc;
}
static int __init set_perflock_init(void) {
mutex_init(&lock);
perf_lock_init(&media_perf_lock, PERF_LOCK_HIGHEST, "media");
return misc_register(&perflock_misc);
}