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         if (device_get_property(DEVICE_TYPE_EXTCON, PROP_EXTCON_EARKEY_ONLINE, &val) == 0)
 214                 vconf_set_int(VCONFKEY_SYSMAN_EARJACKKEY, val);
 215 }
 216
 217 static void tvout_chgdet_cb(struct ss_main_data *ad)
 218 {
 219         PRT_TRACE("jack - tvout changed\n");
 220         pm_change_state(LCD_NORMAL);
 221 }
 222
 223 static void hdmi_chgdet_cb(struct ss_main_data *ad)
 224 {
 225         int val;
 226         int ret = -1;
 227
 228         pm_change_state(LCD_NORMAL);
 229         if (device_get_property(DEVICE_TYPE_EXTCON, PROP_EXTCON_HDMI_SUPPORT, &val) == 0) {
 230                 if (val!=1) {
 231                         PRT_TRACE_ERR("target is not support HDMI");
 232                         vconf_set_int(VCONFKEY_SYSMAN_HDMI, HDMI_NOT_SUPPORTED);
 233                         return;
 234                 }
 235         }
 236         if (device_get_property(DEVICE_TYPE_EXTCON, PROP_EXTCON_HDMI_ONLINE, &val) == 0) {
 237                 PRT_TRACE("jack - hdmi changed %d",val);
 238                 vconf_set_int(VCONFKEY_SYSMAN_HDMI,val);
 239                 if(val == 1)
 240                         pm_lock_state(LCD_NORMAL, GOTO_STATE_NOW, 0);
 241                 else
 242                         pm_unlock_state(LCD_NORMAL, PM_SLEEP_MARGIN);
 243         } else {
 244                 PRT_TRACE_ERR("failed to get hdmi_online status");
 245         }
 246 }
 247
 248 static void keyboard_chgdet_cb(struct ss_main_data *ad)
 249 {
 250         int val = -1;
 251
 252         if (device_get_property(DEVICE_TYPE_EXTCON, PROP_EXTCON_KEYBOARD_ONLINE, &val) == 0) {
 253                 PRT_TRACE("jack - keyboard changed %d",val);
 254                 if(val != 1)
 255                         val = 0;
 256                 vconf_set_int(VCONFKEY_SYSMAN_SLIDING_KEYBOARD, val);
 257         } else {
 258                 vconf_set_int(VCONFKEY_SYSMAN_SLIDING_KEYBOARD, VCONFKEY_SYSMAN_SLIDING_KEYBOARD_NOT_SUPPORTED);
 259         }
 260 }
 261
 262 static void mmc_chgdet_cb(void *data)
 263 {
 264         static int inserted;
 265         int ret = -1;
 266         int val = -1;
 267
 268         if (data == NULL) {
 269                 /* when removed mmc, emul kernel notify twice
 270                  * So this code ignores second event */
 271                 if (!inserted)
 272                         return;
 273                 PRT_TRACE("mmc removed");
 274                 ss_mmc_removed();
 275                 inserted = 0;
 276         } else {
 277                 /* when inserted mmc, emul kernel notify twice(insert, changed)
 278                  * So this code ignores second event */
 279                 if (inserted)
 280                         return;
 281                 PRT_TRACE("mmc added");
 282                 inserted = 1;
 283                 ret = ss_mmc_inserted();
 284                 if (ret == -1) {
 285                         vconf_get_int(VCONFKEY_SYSMAN_MMC_MOUNT,&val);
 286                         if (val == VCONFKEY_SYSMAN_MMC_MOUNT_FAILED) {
 287                                 bundle *b = NULL;
 288                                 b = bundle_create();
 289                                 if (b == NULL) {
 290                                         PRT_TRACE_ERR("error bundle_create()");
 291                                         return;
 292                                 }
 293                                 bundle_add(b, "_SYSPOPUP_CONTENT_", "mounterr");
 294                                 ret = syspopup_launch("mmc-syspopup", b);
 295                                 if (ret < 0) {
 296                                         PRT_TRACE_ERR("popup launch failed");
 297                                 }
 298                                 bundle_free(b);
 299                         } else if (val == VCONFKEY_SYSMAN_MMC_MOUNT_COMPLETED) {
 300                                 bundle *b = NULL;
 301                                 b = bundle_create();
 302                                 if (b == NULL) {
 303                                         PRT_TRACE_ERR("error bundle_create()");
 304                                         return;
 305                                 }
 306                                 bundle_add(b, "_SYSPOPUP_CONTENT_", "mountrdonly");
 307                                 ret = syspopup_launch("mmc-syspopup", b);
 308                                 if (ret < 0) {
 309                                         PRT_TRACE_ERR("popup launch failed");
 310                                 }
 311                                 bundle_free(b);
 312                         }
 313                 }
 314         }
 315 }
 316
 317 static void ums_unmount_cb(void *data)
 318 {
 319         umount(MOVINAND_MOUNT_POINT);
 320 }
 321
 322 static int __check_abnormal_popup_launch(void)
 323 {
 324         static int noti_count = 0;
 325         if (noti_count >= ABNORMAL_POPUP_COUNTER) {
 326                 noti_count = 0;
 327                 return 0;
 328         } else {
 329                 noti_count++;
 330                 return -EAGAIN;
 331         }
 332 }
 333
 334 static void charge_cb(struct ss_main_data *ad)
 335 {
 336         int val = -1;
 337         int charge_now = -1;
 338         int capacity = -1;
 339         char params[BUFF_MAX];
 340         static int bat_full_noti = 0;
 341
 342         ss_lowbat_monitor(NULL);
 343
 344         if (device_get_property(DEVICE_TYPE_POWER, PROP_POWER_CHARGE_NOW, &charge_now) != 0 ||
 345             device_get_property(DEVICE_TYPE_POWER, PROP_POWER_CAPACITY, &capacity) != 0)
 346                 PRT_TRACE_ERR("fail to get battery node value");
 347         if (charge_now == 0 && capacity == 0) {
 348                 PRT_TRACE_ERR("target will be shut down");
 349                 ss_action_entry_call_internal(PREDEF_LOWBAT, 1, POWER_OFF_BAT_ACT);
 350                 return;
 351         }
 352
 353         if (device_get_property(DEVICE_TYPE_POWER, PROP_POWER_HEALTH, &val) == 0) {
 354                 if (val==BATTERY_OVERHEAT || val==BATTERY_COLD) {
 355                         PRT_TRACE_ERR("Battery health status is not good (%d)", val);
 356
 357                         if (__check_abnormal_popup_launch() != 0)
 358                                 return;
 359
 360                         if (device_get_property(DEVICE_TYPE_POWER, PROP_POWER_CAPACITY, &val) == 0 && val <= 0)
 361                                 ss_action_entry_call_internal(PREDEF_LOWBAT, 1, POWER_OFF_BAT_ACT);
 362                         else
 363                                 ss_action_entry_call_internal(PREDEF_LOWBAT, 1, CHARGE_ERROR_ACT);
 364                         return;
 365                 }
 366         } else {
 367                 PRT_TRACE_ERR("failed to get battery health status");
 368         }
 369         device_get_property(DEVICE_TYPE_POWER, PROP_POWER_CHARGE_FULL, &val);
 370         if (val==0) {
 371                 if (bat_full_noti==1) {
 372                         snprintf(params, sizeof(params), "%d %d", CB_NOTI_BATT_FULL, CB_NOTI_OFF);
 373                         ss_launch_if_noexist("/usr/bin/sys_device_noti", params);
 374                 }
 375                 bat_full_noti = 0;
 376         } else {
 377                 if (val==1 && bat_full_noti==0) {
 378                         bat_full_noti = 1;
 379                         PRT_TRACE("battery full noti");
 380                         snprintf(params, sizeof(params), "%d %d", CB_NOTI_BATT_FULL, CB_NOTI_ON);
 381                         ss_launch_if_noexist("/usr/bin/sys_device_noti", params);
 382                 }
 383         }
 384 }
 385
 386 #ifdef ENABLE_EDBUS_USE
 387 static void cb_xxxxx_signaled(void *data, DBusMessage * msg)
 388 {
 389         char *args;
 390         DBusError err;
 391         struct ss_main_data *ad;
 392
 393         ad = data;
 394
 395         dbus_error_init(&err);
 396         if (dbus_message_get_args
 397             (msg, &err, DBUS_TYPE_STRING, &args, DBUS_TYPE_INVALID)) {
 398                 if (!strcmp(args, "action")) ;  /* action */
 399         }
 400
 401         return;
 402 }
 403 #endif                          /* ENABLE_EDBUS_USE */
 404
 405 static void usb_host_chgdet_cb(keynode_t *in_key, struct ss_main_data *ad)
 406 {
 407         PRT_TRACE("ENTER: usb_host_chgdet_cb()");
 408         int status;
 409         int ret = vconf_get_int(VCONFKEY_SYSMAN_USB_HOST_STATUS, &status);
 410         if (ret != 0) {
 411                 PRT_TRACE_ERR("vconf get failed(VCONFKEY_SYSMAN_USB_HOST_STATUS)\n");
 412                 return ;
 413         }
 414
 415         if(VCONFKEY_SYSMAN_USB_HOST_CONNECTED == status) {
 416                 int pid = ss_launch_if_noexist(USBCON_EXEC_PATH, NULL);
 417                 if (pid < 0) {
 418                         PRT_TRACE("usb-server launching failed\n");
 419                         return;
 420                 }
 421         }
 422         PRT_TRACE("EXIT: usb_host_chgdet_cb()");
 423 }
 424
 425 static void usb_host_add_cb()
 426 {
 427         PRT_TRACE("ENTER: usb_host_add_cb()\n");
 428         int status;
 429         int ret = vconf_get_int(VCONFKEY_SYSMAN_USB_HOST_STATUS, &status);
 430         if (ret != 0) {
 431                 PRT_TRACE("vconf get failed ()\n");
 432                 return;
 433         }
 434
 435         if (-1 == status) { /* '-1' means that USB host mode is not loaded yet */
 436                 PRT_TRACE("This usb device is connected defaultly\n");
 437
 438                 ret = system(STORE_DEFAULT_USB_INFO);
 439                 PRT_TRACE("Return value of usb-devices: %d\n", ret);
 440                 if (0 != access(DEFAULT_USB_INFO_PATH, F_OK)) {
 441                         ret = system(STORE_DEFAULT_USB_INFO);
 442                         PRT_TRACE("Return value of usb-devices: %d\n", ret);
 443                 }
 444         }
 445         PRT_TRACE("EXIT: usb_host_add_cb()\n");
 446 }
 447
 448 static int uevent_control_stop(int ufd)
 449 {
 450         if (ufdh) {
 451                 ecore_main_fd_handler_del(ufdh);
 452                 ufdh = NULL;
 453         }
 454         if (ufd >= 0) {
 455                 close(ufd);
 456                 ufd = -1;
 457         }
 458         if (mon) {
 459                 udev_monitor_unref(mon);
 460                 mon = NULL;
 461         }
 462         if (udev) {
 463                 udev_unref(udev);
 464                 udev = NULL;
 465         }
 466         return 0;
 467 }
 468
 469 static int uevent_control_start(void)
 470 {
 471         int ufd = -1;
 472
 473         udev = udev_new();
 474         if (!udev) {
 475                 PRT_TRACE_ERR("error create udev");
 476                 return -1;
 477         }
 478
 479         mon = udev_monitor_new_from_netlink(udev, "kernel");
 480         if (mon == NULL) {
 481                 PRT_TRACE_ERR("error udev_monitor create");
 482                 uevent_control_stop(-1);
 483                 return -1;
 484         }
 485
 486         udev_monitor_set_receive_buffer_size(mon, 1024);
 487         if (udev_monitor_filter_add_match_subsystem_devtype(mon, "platform", NULL) < 0) {
 488                 PRT_TRACE_ERR("error apply subsystem filter");
 489                 uevent_control_stop(-1);
 490                 return -1;
 491         }
 492
 493         ufd = udev_monitor_get_fd(mon);
 494         if (ufd == -1) {
 495                 PRT_TRACE_ERR("error udev_monitor_get_fd");
 496                 uevent_control_stop(ufd);
 497                 return -1;
 498         }
 499
 500         ufdh = ecore_main_fd_handler_add(ufd, ECORE_FD_READ, uevent_control_cb, NULL, NULL, NULL);
 501         if (!ufdh) {
 502                 PRT_TRACE_ERR("error ecore_main_fd_handler_add");
 503                 uevent_control_stop(ufd);
 504                 return -1;
 505         }
 506
 507         if (udev_monitor_enable_receiving(mon) < 0) {
 508                 PRT_TRACE_ERR("error unable to subscribe to udev events");
 509                 uevent_control_stop(ufd);
 510                 return -1;
 511         }
 512
 513         return 0;
 514 }
 515
 516 static int uevent_control_cb(void *data, Ecore_Fd_Handler *fd_handler)
 517 {
 518         struct udev_device *dev = NULL;
 519         struct udev_list_entry *list_entry = NULL;
 520         char *env_name = NULL;
 521         char *env_value = NULL;
 522         int ufd = -1;
 523         int ret = -1;
 524
 525         if (!ecore_main_fd_handler_active_get(fd_handler,ECORE_FD_READ))
 526                 return -1;
 527         if ((ufd = ecore_main_fd_handler_fd_get(fd_handler)) == -1)
 528                 return -1;
 529         if ((dev = udev_monitor_receive_device(mon)) == NULL)
 530                 return -1;
 531
 532         udev_list_entry_foreach(list_entry,udev_device_get_properties_list_entry(dev)) {
 533                 env_name = udev_list_entry_get_name(list_entry);
 534                 if (strncmp(env_name, ENV_FILTER, strlen(ENV_FILTER)) == 0) {
 535                         env_value = udev_list_entry_get_value(list_entry);
 536                         ret = 0;
 537                         break;
 538                 }
 539         }
 540
 541         if (ret != 0) {
 542                 udev_device_unref(dev);
 543                 return -1;
 544         }
 545
 546         PRT_TRACE("UEVENT DETECTED (%s)",env_value);
 547         ss_action_entry_call_internal(PREDEF_DEVICE_CHANGED,1,env_value);
 548
 549         udev_device_unref(dev);
 550         uevent_control_stop(ufd);
 551         uevent_control_start();
 552
 553         return 0;
 554 }
 555
 556 int changed_device_def_predefine_action(int argc, char **argv)
 557 {
 558         if (argc != 1 || argv[0] == NULL) {
 559                 PRT_TRACE_ERR("param is failed");
 560                 return -1;
 561         }
 562
 563         if (strncmp(argv[0], ENV_VALUE_USB, strlen(ENV_VALUE_USB)) == 0)
 564                 usb_chgdet_cb(NULL);
 565         if (strncmp(argv[0], ENV_VALUE_CHARGER, strlen(ENV_VALUE_CHARGER)) == 0)
 566                 ta_chgdet_cb(NULL);
 567         if (strncmp(argv[0], ENV_VALUE_EARJACK, strlen(ENV_VALUE_EARJACK)) == 0)
 568                 earjack_chgdet_cb(NULL);
 569         if (strncmp(argv[0], ENV_VALUE_EARKEY, strlen(ENV_VALUE_EARKEY)) == 0)
 570                 earkey_chgdet_cb(NULL);
 571         if (strncmp(argv[0], ENV_VALUE_TVOUT, strlen(ENV_VALUE_TVOUT)) == 0)
 572                 tvout_chgdet_cb(NULL);
 573         if (strncmp(argv[0], ENV_VALUE_HDMI, strlen(ENV_VALUE_HDMI)) == 0)
 574                 hdmi_chgdet_cb(NULL);
 575         if (strncmp(argv[0], ENV_VALUE_KEYBOARD, strlen(ENV_VALUE_KEYBOARD)) == 0)
 576                 keyboard_chgdet_cb(NULL);
 577
 578         return 0;
 579 }
 580
 581 static void pci_keyboard_add_cb(struct ss_main_data *ad)
 582 {
 583         char params[BUFF_MAX];
 584         PRT_TRACE("pci- keyboard inserted\n");
 585         pm_change_state(LCD_NORMAL);
 586
 587         snprintf(params, sizeof(params), "%d", CB_NOTI_PCI_INSERTED);
 588         ss_launch_if_noexist("/usr/bin/sys_pci_noti", params);
 589
 590 }
 591 static void pci_keyboard_remove_cb(struct ss_main_data *ad)
 592 {
 593         char params[BUFF_MAX];
 594         PRT_TRACE("pci- keyboard removed\n");
 595         pm_change_state(LCD_NORMAL);
 596
 597         snprintf(params, sizeof(params), "%d", CB_NOTI_PCI_REMOVED);
 598         ss_launch_if_noexist("/usr/bin/sys_pci_noti", params);
 599 }
 600 int ss_device_change_init(struct ss_main_data *ad)
 601 {
 602         ss_action_entry_add_internal(PREDEF_DEVICE_CHANGED, changed_device_def_predefine_action, NULL, NULL);
 603
 604         if (uevent_control_start() == -1) {
 605                 PRT_TRACE_ERR("fail uevent control init");
 606                 return -1;
 607         }
 608         /* for simple noti change cb */
 609         ss_noti_add("device_usb_chgdet", (void *)usb_chgdet_cb, (void *)ad);
 610         ss_noti_add("device_ta_chgdet", (void *)ta_chgdet_cb, (void *)ad);
 611         ss_noti_add("device_earjack_chgdet", (void *)earjack_chgdet_cb, (void *)ad);
 612         ss_noti_add("device_earkey_chgdet", (void *)earkey_chgdet_cb, (void *)ad);
 613         ss_noti_add("device_tvout_chgdet", (void *)tvout_chgdet_cb, (void *)ad);
 614         ss_noti_add("device_hdmi_chgdet", (void *)hdmi_chgdet_cb, (void *)ad);
 615         ss_noti_add("device_keyboard_chgdet", (void *)keyboard_chgdet_cb, (void *)ad);
 616
 617         ss_noti_add("device_usb_host_add", (void *)usb_host_add_cb, (void *)ad);
 618         ss_noti_add("mmcblk_add", (void *)mmc_chgdet_cb, (void *)1);
 619         ss_noti_add("mmcblk_remove", (void *)mmc_chgdet_cb, NULL);
 620
 621         ss_noti_add("unmount_ums", (void *)ums_unmount_cb, NULL);
 622         ss_noti_add("device_charge_chgdet", (void *)charge_cb, (void *)ad);
 623
 624         ss_noti_add("device_pci_keyboard_add", (void *)pci_keyboard_add_cb, (void *)ad);
 625         ss_noti_add("device_pci_keyboard_remove", (void *)pci_keyboard_remove_cb, (void *)ad);
 626
 627         if (vconf_notify_key_changed(VCONFKEY_SYSMAN_USB_HOST_STATUS, usb_host_chgdet_cb, NULL) < 0) {
 628                 PRT_TRACE_ERR("vconf key notify failed(VCONFKEY_SYSMAN_USB_HOST_STATUS)");
 629         }
 630         /* dbus noti change cb */
 631 #ifdef ENABLE_EDBUS_USE
 632         e_dbus_init();
 633         conn = e_dbus_bus_get(DBUS_BUS_SYSTEM);
 634         if (!conn)
 635                 PRT_TRACE_ERR("check system dbus running!\n");
 636
 637         e_dbus_signal_handler_add(conn, NULL, "/system/uevent/xxxxx",
 638                                   "system.uevent.xxxxx",
 639                                   "Change", cb_xxxxx_signaled, ad);
 640 #endif                          /* ENABLE_EDBUS_USE */
 641
 642         /* set initial state for devices */
 643         input_device_number = 0;
 644         keyboard_chgdet_cb(NULL);
 645         hdmi_chgdet_cb(NULL);
 646         system(STORE_DEFAULT_USB_INFO);
 647
 648         return 0;
 649 }