ss_device_change_handler.c

   1 /*
   2  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include <stdlib.h>
  19 #include <fcntl.h>
  20 #include <dirent.h>
  21 #include <errno.h>
  22 #include <vconf.h>
  23 #include <sysman.h>
  24 #include <pmapi.h>
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <sys/mount.h>
  28 #include <syspopup_caller.h>
  29 #include <aul.h>
  30 #include <bundle.h>
  31 #include <dirent.h>
  32 #include <libudev.h>
  33 #include "ss_queue.h"
  34 #include "ss_log.h"
  35 #include "ss_device_handler.h"
  36 #include "device-node.h"
  37 #include "ss_noti.h"
  38 #include "include/ss_data.h"
  39 #include "sys_device_noti/sys_device_noti.h"
  40 #include "sys_pci_noti/sys_pci_noti.h"
  41 #include "ss_predefine.h"
  42 #define BUFF_MAX                255
  43 #define SYS_CLASS_INPUT         "/sys/class/input"
  44 #define USBCON_EXEC_PATH        PREFIX"/bin/usb-server"
  45 #define DEFAULT_USB_INFO_PATH   "/tmp/usb_default"
  46 #define STORE_DEFAULT_USB_INFO  "usb-devices > "DEFAULT_USB_INFO_PATH
  47 #define HDMI_NOT_SUPPORTED      (-1)
  48 #ifdef ENABLE_EDBUS_USE
  49 #include <E_DBus.h>
  50 static E_DBus_Connection *conn;
  51 #endif                          /* ENABLE_EDBUS_USE */
  52
  53 struct input_event {
  54         long dummy[2];
  55         unsigned short type;
  56         unsigned short code;
  57         int value;
  58 };
  59
  60 enum snd_jack_types {
  61         SND_JACK_HEADPHONE = 0x0001,
  62         SND_JACK_MICROPHONE = 0x0002,
  63         SND_JACK_HEADSET = SND_JACK_HEADPHONE | SND_JACK_MICROPHONE,
  64         SND_JACK_LINEOUT = 0x0004,
  65         SND_JACK_MECHANICAL = 0x0008,   /* If detected separately */
  66         SND_JACK_VIDEOOUT = 0x0010,
  67         SND_JACK_AVOUT = SND_JACK_LINEOUT | SND_JACK_VIDEOOUT,
  68 };
  69
  70 #define CHANGE_ACTION           "change"
  71 #define ENV_FILTER              "CHGDET"
  72 #define ENV_VALUE_USB           "usb"
  73 #define ENV_VALUE_CHARGER       "charger"
  74 #define ENV_VALUE_EARJACK       "earjack"
  75 #define ENV_VALUE_EARKEY        "earkey"
  76 #define ENV_VALUE_TVOUT         "tvout"
  77 #define ENV_VALUE_HDMI          "hdmi"
  78 #define ENV_VALUE_KEYBOARD      "keyboard"
  79
  80
  81 #define ABNORMAL_POPUP_COUNTER  5
  82
  83 static int input_device_number;
  84
  85 static struct udev_monitor *mon = NULL;
  86 static struct udev *udev = NULL;
  87 static Ecore_Fd_Handler *ufdh = NULL;
  88
  89 static int uevent_control_cb(void *data, Ecore_Fd_Handler *fd_handler);
  90
  91 static int check_lowbat_charge_device(int bInserted)
  92 {
  93         static int bChargeDeviceInserted = 0;
  94         int val = -1;
  95         int bat_state = -1;
  96         int ret = -1;
  97         if (bInserted == 1) {
  98                 if (device_get_property(DEVICE_TYPE_POWER, PROP_POWER_CHARGE_NOW, &val) == 0) {
  99                         if (val == 1)
 100                                 bChargeDeviceInserted = 1;
 101                         return 0;
 102                 }
 103         } else if (bInserted == 0) {
 104                 if (device_get_property(DEVICE_TYPE_POWER, PROP_POWER_CHARGE_NOW, &val) == 0) {
 105                         if (val == 0 && bChargeDeviceInserted == 1) {
 106                                 bChargeDeviceInserted = 0;
 107                                 //low bat popup during charging device removing
 108                                 if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state) == 0) {
 109                                         if(bat_state < VCONFKEY_SYSMAN_BAT_NORMAL
 110                                         || bat_state == VCONFKEY_SYSMAN_BAT_REAL_POWER_OFF) {
 111                                                 bundle *b = NULL;
 112                                                 b = bundle_create();
 113                                                 if(bat_state == VCONFKEY_SYSMAN_BAT_REAL_POWER_OFF)
 114                                                         bundle_add(b,"_SYSPOPUP_CONTENT_", "poweroff");
 115                                                 else
 116                                                         bundle_add(b, "_SYSPOPUP_CONTENT_", "warning");
 117                                                 ret = syspopup_launch("lowbat-syspopup", b);
 118                                                 if (ret < 0) {
 119                                                         PRT_TRACE_EM("popup lauch failed\n");
 120                                                 }
 121                                                 bundle_free(b);
 122                                         }
 123                                 } else {
 124                                         PRT_TRACE_ERR("failed to get vconf key");
 125                                         return -1;
 126                                 }
 127                         }
 128                         return 0;
 129                 }
 130         }
 131         return -1;
 132 }
 133
 134 static void usb_chgdet_cb(struct ss_main_data *ad)
 135 {
 136         int val = -1;
 137         char params[BUFF_MAX];
 138
 139         predefine_pm_change_state(LCD_NORMAL);
 140
 141         /* check charging now */
 142         ss_lowbat_is_charge_in_now();
 143         /* check current battery level */
 144         ss_lowbat_monitor(NULL);
 145         ss_action_entry_call_internal(PREDEF_USBCON, 0);
 146         if (device_get_property(DEVICE_TYPE_EXTCON, PROP_EXTCON_USB_ONLINE, &val) == 0) {
 147                 PRT_TRACE("jack - usb changed %d",val);
 148                 check_lowbat_charge_device(val);
 149                 if (val==1) {
 150                         snprintf(params, sizeof(params), "%d", CB_NOTI_BATT_CHARGE);
 151                         ss_launch_if_noexist("/usr/bin/sys_device_noti", params);
 152                         PRT_TRACE("usb device notification");
 153                 }
 154         } else {
 155                 PRT_TRACE_ERR("fail to get usb_online status");
 156         }
 157 }
 158
 159 static void __sync_usb_status(void)
 160 {
 161         int val = -1;
 162         int status = -1;
 163         if (device_get_property(DEVICE_TYPE_EXTCON, PROP_EXTCON_USB_ONLINE, &val) != 0 ||
 164             vconf_get_int(VCONFKEY_SYSMAN_USB_STATUS,&status) != 0)
 165                 return;
 166         if ((val == 1 && status == VCONFKEY_SYSMAN_USB_DISCONNECTED) ||
 167             (val == 0 && status == VCONFKEY_SYSMAN_USB_AVAILABLE))
 168                 ss_action_entry_call_internal(PREDEF_USBCON, 0);
 169 }
 170
 171 static void ta_chgdet_cb(struct ss_main_data *ad)
 172 {
 173         int val = -1;
 174         int ret = -1;
 175         int bat_state = VCONFKEY_SYSMAN_BAT_NORMAL;
 176         char params[BUFF_MAX];
 177
 178         predefine_pm_change_state(LCD_NORMAL);
 179
 180         /* check charging now */
 181         ss_lowbat_is_charge_in_now();
 182         /* check current battery level */
 183         ss_lowbat_monitor(NULL);
 184
 185         if (device_get_property(DEVICE_TYPE_EXTCON, PROP_EXTCON_TA_ONLINE, &val) == 0) {
 186                 PRT_TRACE("jack - ta changed %d",val);
 187                 check_lowbat_charge_device(val);
 188                 vconf_set_int(VCONFKEY_SYSMAN_CHARGER_STATUS, val);
 189                 if (val == 0) {
 190                         pm_unlock_state(LCD_OFF, STAY_CUR_STATE);
 191                 } else {
 192                         pm_lock_state(LCD_OFF, STAY_CUR_STATE, 0);
 193                         snprintf(params, sizeof(params), "%d", CB_NOTI_BATT_CHARGE);
 194                         ss_launch_if_noexist("/usr/bin/sys_device_noti", params);
 195                         PRT_TRACE("ta device notification");
 196                 }
 197                 __sync_usb_status();
 198         }
 199         else
 200                 PRT_TRACE_ERR("failed to get ta status\n");
 201 }
 202
 203 static void earjack_chgdet_cb(struct ss_main_data *ad)
 204 {
 205         PRT_TRACE("jack - earjack changed\n");
 206         ss_action_entry_call_internal(PREDEF_EARJACKCON, 0);
 207 }
 208
 209 static void earkey_chgdet_cb(struct ss_main_data *ad)
 210 {
 211         int val;
 212         PRT_TRACE("jack - earkey changed\n");
 213
 214         if (device_get_property(DEVICE_TYPE_EXTCON, PROP_EXTCON_EARKEY_ONLINE, &val) == 0)
 215                 vconf_set_int(VCONFKEY_SYSMAN_EARJACKKEY, val);
 216 }
 217
 218 static void tvout_chgdet_cb(struct ss_main_data *ad)
 219 {
 220         PRT_TRACE("jack - tvout changed\n");
 221         pm_change_state(LCD_NORMAL);
 222 }
 223
 224 static void hdmi_chgdet_cb(struct ss_main_data *ad)
 225 {
 226         int val;
 227         int ret = -1;
 228
 229         pm_change_state(LCD_NORMAL);
 230         if (device_get_property(DEVICE_TYPE_EXTCON, PROP_EXTCON_HDMI_SUPPORT, &val) == 0) {
 231                 if (val!=1) {
 232                         PRT_TRACE_ERR("target is not support HDMI");
 233                         vconf_set_int(VCONFKEY_SYSMAN_HDMI, HDMI_NOT_SUPPORTED);
 234                         return;
 235                 }
 236         }
 237         if (device_get_property(DEVICE_TYPE_EXTCON, PROP_EXTCON_HDMI_ONLINE, &val) == 0) {
 238                 PRT_TRACE("jack - hdmi changed %d",val);
 239                 vconf_set_int(VCONFKEY_SYSMAN_HDMI,val);
 240                 if(val == 1)
 241                         pm_lock_state(LCD_NORMAL, GOTO_STATE_NOW, 0);
 242                 else
 243                         pm_unlock_state(LCD_NORMAL, PM_SLEEP_MARGIN);
 244         } else {
 245                 PRT_TRACE_ERR("failed to get hdmi_online status");
 246         }
 247 }
 248
 249 static void keyboard_chgdet_cb(struct ss_main_data *ad)
 250 {
 251         int val = -1;
 252
 253         if (device_get_property(DEVICE_TYPE_EXTCON, PROP_EXTCON_KEYBOARD_ONLINE, &val) == 0) {
 254                 PRT_TRACE("jack - keyboard changed %d",val);
 255                 if(val != 1)
 256                         val = 0;
 257                 vconf_set_int(VCONFKEY_SYSMAN_SLIDING_KEYBOARD, val);
 258         } else {
 259                 vconf_set_int(VCONFKEY_SYSMAN_SLIDING_KEYBOARD, VCONFKEY_SYSMAN_SLIDING_KEYBOARD_NOT_SUPPORTED);
 260         }
 261 }
 262
 263 static void mmc_chgdet_cb(void *data)
 264 {
 265         static int inserted;
 266         int ret = -1;
 267         int val = -1;
 268
 269         if (data == NULL) {
 270                 PRT_TRACE("mmc removed");
 271                 ss_mmc_removed();
 272                 inserted = 0;
 273         } else {
 274                 PRT_TRACE("mmc added");
 275                 if (inserted)
 276                         return;
 277                 inserted = 1;
 278                 ret = ss_mmc_inserted();
 279                 if (ret == -1) {
 280                         vconf_get_int(VCONFKEY_SYSMAN_MMC_MOUNT,&val);
 281                         if (val == VCONFKEY_SYSMAN_MMC_MOUNT_FAILED) {
 282                                 bundle *b = NULL;
 283                                 b = bundle_create();
 284                                 if (b == NULL) {
 285                                         PRT_TRACE_ERR("error bundle_create()");
 286                                         return;
 287                                 }
 288                                 bundle_add(b, "_SYSPOPUP_CONTENT_", "mounterr");
 289                                 ret = syspopup_launch("mmc-syspopup", b);
 290                                 if (ret < 0) {
 291                                         PRT_TRACE_ERR("popup launch failed");
 292                                 }
 293                                 bundle_free(b);
 294                         } else if (val == VCONFKEY_SYSMAN_MMC_MOUNT_COMPLETED) {
 295                                 bundle *b = NULL;
 296                                 b = bundle_create();
 297                                 if (b == NULL) {
 298                                         PRT_TRACE_ERR("error bundle_create()");
 299                                         return;
 300                                 }
 301                                 bundle_add(b, "_SYSPOPUP_CONTENT_", "mountrdonly");
 302                                 ret = syspopup_launch("mmc-syspopup", b);
 303                                 if (ret < 0) {
 304                                         PRT_TRACE_ERR("popup launch failed");
 305                                 }
 306                                 bundle_free(b);
 307                         }
 308                 }
 309         }
 310 }
 311
 312 static void ums_unmount_cb(void *data)
 313 {
 314         umount(MOVINAND_MOUNT_POINT);
 315 }
 316
 317 static int __check_abnormal_popup_launch(void)
 318 {
 319         static int noti_count = 0;
 320         if (noti_count >= ABNORMAL_POPUP_COUNTER) {
 321                 noti_count = 0;
 322                 return 0;
 323         } else {
 324                 noti_count++;
 325                 return -EAGAIN;
 326         }
 327 }
 328
 329 static void charge_cb(struct ss_main_data *ad)
 330 {
 331         int val = -1;
 332         int charge_now = -1;
 333         int capacity = -1;
 334         char params[BUFF_MAX];
 335         static int bat_full_noti = 0;
 336
 337         ss_lowbat_monitor(NULL);
 338
 339         if (device_get_property(DEVICE_TYPE_POWER, PROP_POWER_CHARGE_NOW, &charge_now) != 0 ||
 340             device_get_property(DEVICE_TYPE_POWER, PROP_POWER_CAPACITY, &capacity) != 0)
 341                 PRT_TRACE_ERR("fail to get battery node value");
 342         if (charge_now == 0 && capacity == 0) {
 343                 PRT_TRACE_ERR("target will be shut down");
 344                 ss_action_entry_call_internal(PREDEF_LOWBAT, 1, POWER_OFF_BAT_ACT);
 345                 return;
 346         }
 347
 348         if (device_get_property(DEVICE_TYPE_POWER, PROP_POWER_HEALTH, &val) == 0) {
 349                 if (val==BATTERY_OVERHEAT || val==BATTERY_COLD) {
 350                         PRT_TRACE_ERR("Battery health status is not good (%d)", val);
 351
 352                         if (__check_abnormal_popup_launch() != 0)
 353                                 return;
 354
 355                         if (device_get_property(DEVICE_TYPE_POWER, PROP_POWER_CAPACITY, &val) == 0 && val <= 0)
 356                                 ss_action_entry_call_internal(PREDEF_LOWBAT, 1, POWER_OFF_BAT_ACT);
 357                         else
 358                                 ss_action_entry_call_internal(PREDEF_LOWBAT, 1, CHARGE_ERROR_ACT);
 359                         return;
 360                 }
 361         } else {
 362                 PRT_TRACE_ERR("failed to get battery health status");
 363         }
 364         device_get_property(DEVICE_TYPE_POWER, PROP_POWER_CHARGE_FULL, &val);
 365         if (val==0) {
 366                 if (bat_full_noti==1) {
 367                         snprintf(params, sizeof(params), "%d %d", CB_NOTI_BATT_FULL, CB_NOTI_OFF);
 368                         ss_launch_if_noexist("/usr/bin/sys_device_noti", params);
 369                 }
 370                 bat_full_noti = 0;
 371         } else {
 372                 if (val==1 && bat_full_noti==0) {
 373                         bat_full_noti = 1;
 374                         PRT_TRACE("battery full noti");
 375                         snprintf(params, sizeof(params), "%d %d", CB_NOTI_BATT_FULL, CB_NOTI_ON);
 376                         ss_launch_if_noexist("/usr/bin/sys_device_noti", params);
 377                 }
 378         }
 379 }
 380
 381 #ifdef ENABLE_EDBUS_USE
 382 static void cb_xxxxx_signaled(void *data, DBusMessage * msg)
 383 {
 384         char *args;
 385         DBusError err;
 386         struct ss_main_data *ad;
 387
 388         ad = data;
 389
 390         dbus_error_init(&err);
 391         if (dbus_message_get_args
 392             (msg, &err, DBUS_TYPE_STRING, &args, DBUS_TYPE_INVALID)) {
 393                 if (!strcmp(args, "action")) ;  /* action */
 394         }
 395
 396         return;
 397 }
 398 #endif                          /* ENABLE_EDBUS_USE */
 399
 400 static void usb_host_chgdet_cb(keynode_t *in_key, struct ss_main_data *ad)
 401 {
 402         PRT_TRACE("ENTER: usb_host_chgdet_cb()");
 403         int status;
 404         int ret = vconf_get_int(VCONFKEY_SYSMAN_USB_HOST_STATUS, &status);
 405         if (ret != 0) {
 406                 PRT_TRACE_ERR("vconf get failed(VCONFKEY_SYSMAN_USB_HOST_STATUS)\n");
 407                 return ;
 408         }
 409
 410         if(VCONFKEY_SYSMAN_USB_HOST_CONNECTED == status) {
 411                 int pid = ss_launch_if_noexist(USBCON_EXEC_PATH, NULL);
 412                 if (pid < 0) {
 413                         PRT_TRACE("usb-server launching failed\n");
 414                         return;
 415                 }
 416         }
 417         PRT_TRACE("EXIT: usb_host_chgdet_cb()");
 418 }
 419
 420 static void usb_host_add_cb()
 421 {
 422         PRT_TRACE("ENTER: usb_host_add_cb()\n");
 423         int status;
 424         int ret = vconf_get_int(VCONFKEY_SYSMAN_USB_HOST_STATUS, &status);
 425         if (ret != 0) {
 426                 PRT_TRACE("vconf get failed ()\n");
 427                 return;
 428         }
 429
 430         if (-1 == status) { /* '-1' means that USB host mode is not loaded yet */
 431                 PRT_TRACE("This usb device is connected defaultly\n");
 432
 433                 ret = system(STORE_DEFAULT_USB_INFO);
 434                 PRT_TRACE("Return value of usb-devices: %d\n", ret);
 435                 if (0 != access(DEFAULT_USB_INFO_PATH, F_OK)) {
 436                         ret = system(STORE_DEFAULT_USB_INFO);
 437                         PRT_TRACE("Return value of usb-devices: %d\n", ret);
 438                 }
 439         }
 440         PRT_TRACE("EXIT: usb_host_add_cb()\n");
 441 }
 442
 443 static int uevent_control_stop(int ufd)
 444 {
 445         if (ufdh) {
 446                 ecore_main_fd_handler_del(ufdh);
 447                 ufdh = NULL;
 448         }
 449         if (ufd >= 0) {
 450                 close(ufd);
 451                 ufd = -1;
 452         }
 453         if (mon) {
 454                 udev_monitor_unref(mon);
 455                 mon = NULL;
 456         }
 457         if (udev) {
 458                 udev_unref(udev);
 459                 udev = NULL;
 460         }
 461         return 0;
 462 }
 463
 464 static int uevent_control_start(void)
 465 {
 466         int ufd = -1;
 467
 468         udev = udev_new();
 469         if (!udev) {
 470                 PRT_TRACE_ERR("error create udev");
 471                 return -1;
 472         }
 473
 474         mon = udev_monitor_new_from_netlink(udev, "kernel");
 475         if (mon == NULL) {
 476                 PRT_TRACE_ERR("error udev_monitor create");
 477                 uevent_control_stop(-1);
 478                 return -1;
 479         }
 480
 481         udev_monitor_set_receive_buffer_size(mon, 1024);
 482         if (udev_monitor_filter_add_match_subsystem_devtype(mon, "platform", NULL) < 0) {
 483                 PRT_TRACE_ERR("error apply subsystem filter");
 484                 uevent_control_stop(-1);
 485                 return -1;
 486         }
 487
 488         ufd = udev_monitor_get_fd(mon);
 489         if (ufd == -1) {
 490                 PRT_TRACE_ERR("error udev_monitor_get_fd");
 491                 uevent_control_stop(ufd);
 492                 return -1;
 493         }
 494
 495         ufdh = ecore_main_fd_handler_add(ufd, ECORE_FD_READ, uevent_control_cb, NULL, NULL, NULL);
 496         if (!ufdh) {
 497                 PRT_TRACE_ERR("error ecore_main_fd_handler_add");
 498                 uevent_control_stop(ufd);
 499                 return -1;
 500         }
 501
 502         if (udev_monitor_enable_receiving(mon) < 0) {
 503                 PRT_TRACE_ERR("error unable to subscribe to udev events");
 504                 uevent_control_stop(ufd);
 505                 return -1;
 506         }
 507
 508         return 0;
 509 }
 510
 511 static int uevent_control_cb(void *data, Ecore_Fd_Handler *fd_handler)
 512 {
 513         struct udev_device *dev = NULL;
 514         struct udev_list_entry *list_entry = NULL;
 515         char *env_name = NULL;
 516         char *env_value = NULL;
 517         int ufd = -1;
 518         int ret = -1;
 519
 520         if (!ecore_main_fd_handler_active_get(fd_handler,ECORE_FD_READ))
 521                 return -1;
 522         if ((ufd = ecore_main_fd_handler_fd_get(fd_handler)) == -1)
 523                 return -1;
 524         if ((dev = udev_monitor_receive_device(mon)) == NULL)
 525                 return -1;
 526
 527         udev_list_entry_foreach(list_entry,udev_device_get_properties_list_entry(dev)) {
 528                 env_name = udev_list_entry_get_name(list_entry);
 529                 if (strncmp(env_name, ENV_FILTER, strlen(ENV_FILTER)) == 0) {
 530                         env_value = udev_list_entry_get_value(list_entry);
 531                         ret = 0;
 532                         break;
 533                 }
 534         }
 535
 536         if (ret != 0) {
 537                 udev_device_unref(dev);
 538                 return -1;
 539         }
 540
 541         PRT_TRACE("UEVENT DETECTED (%s)",env_value);
 542         ss_action_entry_call_internal(PREDEF_DEVICE_CHANGED,1,env_value);
 543
 544         udev_device_unref(dev);
 545         uevent_control_stop(ufd);
 546         uevent_control_start();
 547
 548         return 0;
 549 }
 550
 551 int changed_device_def_predefine_action(int argc, char **argv)
 552 {
 553         if (argc != 1 || argv[0] == NULL) {
 554                 PRT_TRACE_ERR("param is failed");
 555                 return -1;
 556         }
 557
 558         if (strncmp(argv[0], ENV_VALUE_USB, strlen(ENV_VALUE_USB)) == 0)
 559                 usb_chgdet_cb(NULL);
 560         if (strncmp(argv[0], ENV_VALUE_CHARGER, strlen(ENV_VALUE_CHARGER)) == 0)
 561                 ta_chgdet_cb(NULL);
 562         if (strncmp(argv[0], ENV_VALUE_EARJACK, strlen(ENV_VALUE_EARJACK)) == 0)
 563                 earjack_chgdet_cb(NULL);
 564         if (strncmp(argv[0], ENV_VALUE_EARKEY, strlen(ENV_VALUE_EARKEY)) == 0)
 565                 earkey_chgdet_cb(NULL);
 566         if (strncmp(argv[0], ENV_VALUE_TVOUT, strlen(ENV_VALUE_TVOUT)) == 0)
 567                 tvout_chgdet_cb(NULL);
 568         if (strncmp(argv[0], ENV_VALUE_HDMI, strlen(ENV_VALUE_HDMI)) == 0)
 569                 hdmi_chgdet_cb(NULL);
 570         if (strncmp(argv[0], ENV_VALUE_KEYBOARD, strlen(ENV_VALUE_KEYBOARD)) == 0)
 571                 keyboard_chgdet_cb(NULL);
 572
 573         return 0;
 574 }
 575
 576 static void pci_keyboard_add_cb(struct ss_main_data *ad)
 577 {
 578         char params[BUFF_MAX];
 579         PRT_TRACE("pci- keyboard inserted\n");
 580         pm_change_state(LCD_NORMAL);
 581
 582         snprintf(params, sizeof(params), "%d", CB_NOTI_PCI_INSERTED);
 583         ss_launch_if_noexist("/usr/bin/sys_pci_noti", params);
 584
 585 }
 586 static void pci_keyboard_remove_cb(struct ss_main_data *ad)
 587 {
 588         char params[BUFF_MAX];
 589         PRT_TRACE("pci- keyboard removed\n");
 590         pm_change_state(LCD_NORMAL);
 591
 592         snprintf(params, sizeof(params), "%d", CB_NOTI_PCI_REMOVED);
 593         ss_launch_if_noexist("/usr/bin/sys_pci_noti", params);
 594 }
 595 int ss_device_change_init(struct ss_main_data *ad)
 596 {
 597         ss_action_entry_add_internal(PREDEF_DEVICE_CHANGED, changed_device_def_predefine_action, NULL, NULL);
 598
 599         if (uevent_control_start() == -1) {
 600                 PRT_TRACE_ERR("fail uevent control init");
 601                 return -1;
 602         }
 603         /* for simple noti change cb */
 604         ss_noti_add("device_usb_chgdet", (void *)usb_chgdet_cb, (void *)ad);
 605         ss_noti_add("device_ta_chgdet", (void *)ta_chgdet_cb, (void *)ad);
 606         ss_noti_add("device_earjack_chgdet", (void *)earjack_chgdet_cb, (void *)ad);
 607         ss_noti_add("device_earkey_chgdet", (void *)earkey_chgdet_cb, (void *)ad);
 608         ss_noti_add("device_tvout_chgdet", (void *)tvout_chgdet_cb, (void *)ad);
 609         ss_noti_add("device_hdmi_chgdet", (void *)hdmi_chgdet_cb, (void *)ad);
 610         ss_noti_add("device_keyboard_chgdet", (void *)keyboard_chgdet_cb, (void *)ad);
 611
 612         ss_noti_add("device_usb_host_add", (void *)usb_host_add_cb, (void *)ad);
 613         ss_noti_add("mmcblk_add", (void *)mmc_chgdet_cb, (void *)1);
 614         ss_noti_add("mmcblk_remove", (void *)mmc_chgdet_cb, NULL);
 615
 616         ss_noti_add("unmount_ums", (void *)ums_unmount_cb, NULL);
 617         ss_noti_add("device_charge_chgdet", (void *)charge_cb, (void *)ad);
 618
 619         ss_noti_add("device_pci_keyboard_add", (void *)pci_keyboard_add_cb, (void *)ad);
 620         ss_noti_add("device_pci_keyboard_remove", (void *)pci_keyboard_remove_cb, (void *)ad);
 621
 622         if (vconf_notify_key_changed(VCONFKEY_SYSMAN_USB_HOST_STATUS, usb_host_chgdet_cb, NULL) < 0) {
 623                 PRT_TRACE_ERR("vconf key notify failed(VCONFKEY_SYSMAN_USB_HOST_STATUS)");
 624         }
 625         /* dbus noti change cb */
 626 #ifdef ENABLE_EDBUS_USE
 627         e_dbus_init();
 628         conn = e_dbus_bus_get(DBUS_BUS_SYSTEM);
 629         if (!conn)
 630                 PRT_TRACE_ERR("check system dbus running!\n");
 631
 632         e_dbus_signal_handler_add(conn, NULL, "/system/uevent/xxxxx",
 633                                   "system.uevent.xxxxx",
 634                                   "Change", cb_xxxxx_signaled, ad);
 635 #endif                          /* ENABLE_EDBUS_USE */
 636
 637         /* set initial state for devices */
 638         input_device_number = 0;
 639         keyboard_chgdet_cb(NULL);
 640         hdmi_chgdet_cb(NULL);
 641         system(STORE_DEFAULT_USB_INFO);
 642
 643         return 0;
 644 }