drivers/cpufreq/cpufreq_pmqos_input.c

   1 /* cpufreq_pmqos_input */
   2
   3 #include <linux/input.h>
   4
   5 struct input_dev touch_booster;
   6 static int touch_booster_state;
   7 const char touch_booster_name[] = "TOUCH_BOOSTER";
   8
   9 struct input_dev rotary_booster;
  10 const char rotary_booster_name[] = "ROTARY_BOOSTER";
  11 static int touch_boost_initialized;
  12
  13
  14 struct mutex tb_muxtex_lock;
  15 struct delayed_work tb_work_off;
  16 struct delayed_work tb_work_chg;
  17
  18 /* TOUCH */
  19 #if defined(TRM_TOUCH_BOOSTER_EN)
  20 static struct pm_qos_request touch_press_qos_array[NUMBER_OF_LOCK];
  21 static struct pm_qos_request touch_move_qos_array[NUMBER_OF_LOCK];
  22 static struct pm_qos_request touch_release_qos_array[NUMBER_OF_LOCK];
  23 #endif
  24
  25 #if defined(TOUCH_WAKEUP_BOOSTER)
  26 /* Touch Wakeup Booster */
  27 static int touch_wakeup_initialized;
  28 struct mutex touch_wakeup_booter_lock;
  29 struct delayed_work touch_wakeup_booster_off_work;
  30 static struct pm_qos_request pm_qos_cpufreq_touch_wakeup;
  31 static struct pm_qos_request pm_qos_cpuonline_touch_wakeup;
  32
  33 extern int suspend_state;
  34 void touch_wakeup_booster_turn_on(void)
  35 {
  36         if(!suspend_state)
  37                 return;
  38
  39         if (!touch_wakeup_initialized)
  40                 return;
  41
  42         mutex_lock(&touch_wakeup_booter_lock);
  43
  44         pr_info("%s\n", __FUNCTION__);
  45
  46         if (!pm_qos_request_active(&pm_qos_cpufreq_touch_wakeup)) {
  47                 pm_qos_add_request(&pm_qos_cpufreq_touch_wakeup
  48                         , PM_QOS_CPU_FREQ_MIN, touch_wakeup_min_cpu_freq);
  49                 if (!pm_qos_request_active(&pm_qos_cpuonline_touch_wakeup)) {
  50                                 pm_qos_add_request(&pm_qos_cpuonline_touch_wakeup
  51                                         , PM_QOS_CPU_ONLINE_MIN, 2);
  52                 }
  53
  54                 schedule_delayed_work(&touch_wakeup_booster_off_work
  55                         ,msecs_to_jiffies(TOUCH_WAKEUP_BOOSTER_DELAY));
  56         }
  57
  58         mutex_unlock(&touch_wakeup_booter_lock);
  59 }
  60
  61 static void touch_wakeup_off_work_func(struct work_struct *work)
  62 {
  63         mutex_lock(&touch_wakeup_booter_lock);
  64
  65         if (pm_qos_request_active(&pm_qos_cpufreq_touch_wakeup))
  66                 pm_qos_remove_request(&pm_qos_cpufreq_touch_wakeup);
  67
  68         if (pm_qos_request_active(&pm_qos_cpuonline_touch_wakeup))
  69                 pm_qos_remove_request(&pm_qos_cpuonline_touch_wakeup);
  70
  71         mutex_unlock(&touch_wakeup_booter_lock);
  72
  73         pr_info("%s\n", __FUNCTION__);
  74 }
  75 #endif
  76
  77
  78 #if defined(HARD_KEY_BOOSTER)
  79 /* Hard Key Booster */
  80 static int hard_key_initialized;
  81 struct mutex hard_key_booster_lock;
  82 struct delayed_work hardkey_booster_off_work;
  83 static struct pm_qos_request pm_qos_cpufreq_hard_key;
  84 static struct pm_qos_request pm_qos_cpuonline_hard_key;
  85
  86 extern int suspend_state;
  87 void hard_key_booster_turn_on(void)
  88 {
  89         if(!suspend_state)
  90                 return;
  91
  92         if (!hard_key_initialized)
  93                 return;
  94
  95         mutex_lock(&hard_key_booster_lock);
  96
  97         pr_info("%s\n", __FUNCTION__);
  98
  99         if (!pm_qos_request_active(&pm_qos_cpufreq_hard_key)) {
 100                 pm_qos_add_request(&pm_qos_cpufreq_hard_key
 101                         , PM_QOS_CPU_FREQ_MIN, hard_key_min_cpu_freq);
 102                 if (!pm_qos_request_active(&pm_qos_cpuonline_hard_key)) {
 103                                 pm_qos_add_request(&pm_qos_cpuonline_hard_key
 104                                         , PM_QOS_CPU_ONLINE_MIN, 2);
 105                 }
 106
 107                 schedule_delayed_work(&hardkey_booster_off_work
 108                         ,msecs_to_jiffies(KEY_BOOSTER_DELAY));
 109         }
 110
 111         mutex_unlock(&hard_key_booster_lock);
 112 }
 113
 114 static void hard_key_off_work_func(struct work_struct *work)
 115 {
 116         mutex_lock(&hard_key_booster_lock);
 117
 118         if (pm_qos_request_active(&pm_qos_cpufreq_hard_key))
 119                 pm_qos_remove_request(&pm_qos_cpufreq_hard_key);
 120
 121         if (pm_qos_request_active(&pm_qos_cpuonline_hard_key))
 122                 pm_qos_remove_request(&pm_qos_cpuonline_hard_key);
 123
 124         mutex_unlock(&hard_key_booster_lock);
 125
 126         pr_info("%s\n", __FUNCTION__);
 127 }
 128 #endif
 129
 130
 131 #if defined(ROTARY_BOOSTER)
 132 #include <linux/pm_qos.h>
 133
 134 struct delayed_work rotary_booster_off_work;
 135 static struct pm_qos_request pm_qos_rotary_cpufreq;
 136 static struct pm_qos_request pm_qos_rotary_miffreq;
 137
 138 struct mutex rotary_dvfs_lock;
 139 struct mutex rotary_off_dvfs_lock;
 140 static int rotary_initialized;
 141
 142 static void rotary_off_work_func(struct work_struct *work)
 143 {
 144 #if defined(CONFIG_SLP_MINI_TRACER)
 145         kernel_mini_tracer_smp("rotary_off_1\n");
 146 #endif
 147         mutex_lock(&rotary_off_dvfs_lock);
 148 #if defined(CONFIG_SLP_MINI_TRACER)
 149         kernel_mini_tracer_smp("rotary_off_2\n");
 150 #endif
 151         if (pm_qos_request_active(&pm_qos_rotary_cpufreq))
 152                 pm_qos_remove_request(&pm_qos_rotary_cpufreq);
 153
 154         if (pm_qos_request_active(&pm_qos_rotary_miffreq))
 155                 pm_qos_remove_request(&pm_qos_rotary_miffreq);
 156 #if defined(CONFIG_SLP_MINI_TRACER)
 157         kernel_mini_tracer_smp("rotary_off_3\n");
 158 #endif
 159         mutex_unlock(&rotary_off_dvfs_lock);
 160 #if defined(CONFIG_SLP_MINI_TRACER)
 161         kernel_mini_tracer_smp("rotary_off_4\n");
 162 #endif
 163
 164 }
 165
 166 void rotary_booster_turn_on(void)
 167 {
 168         if (!rotary_initialized)
 169                 return;
 170
 171 #if defined(CONFIG_SLP_INPUT_REC)
 172         __slp_store_input_history(&rotary_booster, ROTORY_BOOSTER_TURN, 0, 0);
 173 #endif
 174
 175 #if defined(ROTARY_BOOSTER)
 176 #if defined(CONFIG_SLP_MINI_TRACER)
 177         kernel_mini_tracer_smp("rotary_0\n");
 178 #endif
 179         mutex_lock(&rotary_dvfs_lock);
 180 #if defined(CONFIG_SLP_MINI_TRACER)
 181         kernel_mini_tracer_smp("rotary_1\n");
 182 #endif
 183
 184         if (!pm_qos_request_active(&pm_qos_rotary_cpufreq)) {
 185 #if defined(CONFIG_SLP_MINI_TRACER)
 186         kernel_mini_tracer_smp("rotary_2\n");
 187 #endif
 188                 pm_qos_add_request(&pm_qos_rotary_cpufreq
 189                         , PM_QOS_CPU_FREQ_MIN, rotary_min_cpu_freq);
 190
 191                 if (!pm_qos_request_active(&pm_qos_rotary_miffreq)) {
 192                                 pm_qos_add_request(&pm_qos_rotary_miffreq
 193                                         , PM_QOS_BUS_THROUGHPUT, rotary_min_mif_freq);
 194                 }
 195
 196                 schedule_delayed_work(&rotary_booster_off_work
 197                         ,msecs_to_jiffies(ROTARY_BOOSTER_DELAY));
 198         } else {
 199 #if defined(CONFIG_SLP_MINI_TRACER)
 200         kernel_mini_tracer_smp("rotary_3\n");
 201 #endif
 202                 cancel_delayed_work_sync(&rotary_booster_off_work);
 203                 schedule_delayed_work(&rotary_booster_off_work
 204                         ,msecs_to_jiffies(ROTARY_BOOSTER_DELAY));
 205         }
 206 #if defined(CONFIG_SLP_MINI_TRACER)
 207         kernel_mini_tracer_smp("rotary_4\n");
 208 #endif
 209         mutex_unlock(&rotary_dvfs_lock);
 210 #if defined(CONFIG_SLP_MINI_TRACER)
 211         kernel_mini_tracer_smp("rotary_5\n");
 212 #endif
 213
 214 #endif
 215
 216 }
 217 #endif
 218
 219
 220 void touch_booster_move(struct work_struct *work)
 221 {
 222 #if defined(CONFIG_SLP_INPUT_REC)
 223         __slp_store_input_history(&touch_booster, TOUCH_BOOSTER_MOVE, 0, 0);
 224 #endif
 225
 226         if (touch_booster_state == TOUCH_BOOSTER_PRESS) {
 227                 mutex_lock(&tb_muxtex_lock);
 228
 229                 touch_booster_move_sub();
 230
 231                 mutex_unlock(&tb_muxtex_lock);
 232         }
 233
 234 }
 235
 236 void touch_booster_press(void)
 237 {
 238         if (!touch_boost_initialized)
 239                 return;
 240
 241 #if defined(CONFIG_SLP_INPUT_REC)
 242         __slp_store_input_history(&touch_booster, TOUCH_BOOSTER_PRESS, 0, 0);
 243 #endif
 244
 245         mutex_lock(&tb_muxtex_lock);
 246         cancel_delayed_work(&tb_work_off);
 247
 248         if ((touch_booster_state == TOUCH_BOOSTER_RELEASE)
 249                         && (cpufreq_get_touch_boost_en() == 1)) {
 250                 touch_booster_press_sub();
 251                 schedule_delayed_work(&tb_work_chg
 252                         , msecs_to_jiffies(TOUCH_BOOSTER_CHG_TIME));
 253
 254
 255                 touch_booster_state = TOUCH_BOOSTER_PRESS;
 256         }
 257
 258         mutex_unlock(&tb_muxtex_lock);
 259
 260 }
 261
 262 void touch_booster_release(void)
 263 {
 264 #if defined(CONFIG_SLP_INPUT_REC)
 265         __slp_store_input_history(&touch_booster, TOUCH_BOOSTER_RELEASE, 0, 0);
 266 #endif
 267
 268         if (touch_booster_state == TOUCH_BOOSTER_PRESS) {
 269                 touch_booster_release_sub();
 270
 271                 cancel_delayed_work(&tb_work_chg);
 272                 schedule_delayed_work(&tb_work_off,
 273                         msecs_to_jiffies(TOUCH_BOOSTER_OFF_TIME));
 274         }
 275 }
 276
 277
 278 void touch_booster_off(struct work_struct *work)
 279 {
 280         mutex_lock(&tb_muxtex_lock);
 281
 282         touch_booster_off_sub();
 283         touch_booster_state = TOUCH_BOOSTER_RELEASE;
 284
 285         mutex_unlock(&tb_muxtex_lock);
 286 }
 287
 288
 289 void touch_booster_release_all(void)
 290 {
 291 #if defined(CONFIG_SLP_INPUT_REC)
 292         __slp_store_input_history(&touch_booster, TOUCH_BOOSTER_RELEASE_ALL, 0, 0);
 293 #endif
 294
 295         mutex_lock(&tb_muxtex_lock);
 296
 297         cancel_delayed_work(&tb_work_off);
 298         cancel_delayed_work(&tb_work_chg);
 299         schedule_work(&tb_work_off.work);
 300
 301         mutex_unlock(&tb_muxtex_lock);
 302 }
 303
 304
 305
 306 #if defined(TRM_TOUCH_BOOSTER_EN)
 307 static bool  touch_boost_en_value = 1;
 308 static ssize_t show_touch_boost_en(struct kobject *kobj,
 309                                 struct attribute *attr, char *buf)
 310 {
 311         unsigned int ret = 0;
 312         ret =  sprintf(buf, "%d\n", touch_boost_en_value);
 313         return ret;
 314 }
 315
 316 static ssize_t store_touch_boost_en(struct kobject *a, struct attribute *b,
 317                                   const char *buf, size_t count)
 318 {
 319
 320         int input;
 321         input = atoi(buf);
 322
 323         if ((input == 0 ) || (input == 1 ))
 324                 touch_boost_en_value = input;
 325
 326         return count;
 327 }
 328
 329
 330 bool cpufreq_get_touch_boost_en(void)
 331 {
 332         return touch_boost_en_value;
 333 }
 334
 335 static unsigned int touch_boost_press_value = PM_QOS_TOUCH_PRESS_DEFAULT_VALUE;
 336 static ssize_t show_touch_boost_press(struct kobject *kobj,
 337                                 struct attribute *attr, char *buf)
 338 {
 339         unsigned int ret = 0;
 340         ret =  sprintf(buf, "%d\n", cpufreq_get_touch_boost_press());
 341         return ret;
 342 }
 343
 344 static ssize_t store_touch_boost_press(struct kobject *a, struct attribute *b,
 345                                   const char *buf, size_t count)
 346 {
 347         set_pmqos_data(touch_press_qos_array, PM_QOS_TOUCH_PRESS, buf);
 348
 349         return count;
 350 }
 351
 352
 353 unsigned int cpufreq_get_touch_boost_press(void)
 354 {
 355
 356         touch_boost_press_value = pm_qos_request(PM_QOS_TOUCH_PRESS);
 357
 358         return touch_boost_press_value;
 359 }
 360
 361
 362
 363
 364 static unsigned int touch_boost_move_value = PM_QOS_TOUCH_MOVE_DEFAULT_VALUE;
 365 static ssize_t show_touch_boost_move(struct kobject *kobj,
 366                                 struct attribute *attr, char *buf)
 367 {
 368         unsigned int ret = 0;
 369         ret =  sprintf(buf, "%d\n", cpufreq_get_touch_boost_move());
 370         return ret;
 371 }
 372
 373 static ssize_t store_touch_boost_move(struct kobject *a, struct attribute *b,
 374                                   const char *buf, size_t count)
 375 {
 376
 377         set_pmqos_data(touch_move_qos_array, PM_QOS_TOUCH_MOVE, buf);
 378
 379         return count;
 380 }
 381
 382 unsigned int cpufreq_get_touch_boost_move(void)
 383 {
 384         touch_boost_move_value = pm_qos_request(PM_QOS_TOUCH_MOVE);
 385
 386         return touch_boost_move_value;
 387 }
 388
 389
 390
 391
 392 static unsigned int touch_boost_release_value = PM_QOS_TOUCH_RELEASE_DEFAULT_VALUE;
 393 static ssize_t show_touch_boost_release(struct kobject *kobj,
 394                                 struct attribute *attr, char *buf)
 395 {
 396         unsigned int ret = 0;
 397         ret =  sprintf(buf, "%d\n", cpufreq_get_touch_boost_release());
 398         return ret;
 399 }
 400
 401 static ssize_t store_touch_boost_release(struct kobject *a, struct attribute *b,
 402                                   const char *buf, size_t count)
 403 {
 404
 405         set_pmqos_data(touch_release_qos_array, PM_QOS_TOUCH_RELEASE, buf);
 406
 407         return count;
 408 }
 409
 410
 411 unsigned int cpufreq_get_touch_boost_release(void)
 412 {
 413         touch_boost_release_value = pm_qos_request(PM_QOS_TOUCH_RELEASE);
 414
 415         return touch_boost_release_value;
 416 }
 417
 418
 419 static int touch_cpu_online_min_value;
 420 unsigned int touch_cpu_get_online_min(void)
 421 {
 422         return touch_cpu_online_min_value;
 423 }
 424
 425 static ssize_t show_touch_cpu_online_min(struct kobject *kobj,
 426                                 struct attribute *attr, char *buf)
 427 {
 428         unsigned int ret = 0;
 429         ret =  sprintf(buf, "%d\n", touch_cpu_get_online_min());
 430
 431         return ret;
 432 }
 433
 434 static ssize_t __ref store_touch_cpu_online_min(struct kobject *a, struct attribute *b,
 435                                         const char *buf, size_t count)
 436 {
 437         int lock_value = 0;
 438
 439         if (strstr(buf, "-1")!=NULL)
 440                 lock_value = -1;
 441         else
 442                 lock_value = atoi(buf);
 443
 444         if ((lock_value > 0) && (lock_value <= NR_CPUS))
 445                 touch_cpu_online_min_value = lock_value;
 446         else if (lock_value == -1)
 447                 touch_cpu_online_min_value = lock_value;
 448
 449         return count;
 450 }
 451 #endif
 452
 453
 454
 455 #if defined(TRM_TOUCH_BOOSTER_EN)
 456 define_one_root_rw(touch_boost_en);
 457 define_one_root_rw(touch_boost_press);
 458 define_one_root_rw(touch_boost_move);
 459 define_one_root_rw(touch_boost_release);
 460 define_one_root_rw(touch_cpu_online_min);
 461 #endif
 462
 463
 464 void input_booster_init(void)
 465 {
 466         /* STEP 1 : TOUCH BOOSTER INIT */
 467         touch_booster.name = touch_booster_name;
 468         mutex_init(&tb_muxtex_lock);
 469
 470         INIT_DELAYED_WORK(&tb_work_off, touch_booster_off);
 471         INIT_DELAYED_WORK(&tb_work_chg, touch_booster_move);
 472         touch_booster_state = TOUCH_BOOSTER_RELEASE;
 473         touch_boost_initialized = 1;
 474
 475         /* STEP 2 : ROTARY BOOSTER INIT */
 476 #if defined(ROTARY_BOOSTER)
 477         rotary_booster.name = rotary_booster_name;
 478         mutex_init(&rotary_dvfs_lock);
 479         mutex_init(&rotary_off_dvfs_lock);
 480         INIT_DELAYED_WORK(&rotary_booster_off_work, rotary_off_work_func);
 481         rotary_initialized = 1;
 482 #endif
 483
 484 #if defined(HARD_KEY_BOOSTER)
 485         mutex_init(&hard_key_booster_lock);
 486         INIT_DELAYED_WORK(&hardkey_booster_off_work, hard_key_off_work_func);
 487         hard_key_initialized = 1;
 488 #endif
 489
 490 #if defined(TOUCH_WAKEUP_BOOSTER)
 491         mutex_init(&touch_wakeup_booter_lock);
 492         INIT_DELAYED_WORK(&touch_wakeup_booster_off_work, touch_wakeup_off_work_func);
 493         touch_wakeup_initialized = 1;
 494 #endif
 495
 496 }
 497
 498