drivers/extcon/extcon.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * drivers/extcon/extcon.c - External Connector (extcon) framework.
   4  *
   5  * Copyright (C) 2015 Samsung Electronics
   6  * Author: Chanwoo Choi <cw00.choi@samsung.com>
   7  *
   8  * Copyright (C) 2012 Samsung Electronics
   9  * Author: Donggeun Kim <dg77.kim@samsung.com>
  10  * Author: MyungJoo Ham <myungjoo.ham@samsung.com>
  11  *
  12  * based on android/drivers/switch/switch_class.c
  13  * Copyright (C) 2008 Google, Inc.
  14  * Author: Mike Lockwood <lockwood@android.com>
  15  */
  16
  17 #include <linux/module.h>
  18 #include <linux/types.h>
  19 #include <linux/init.h>
  20 #include <linux/device.h>
  21 #include <linux/fs.h>
  22 #include <linux/err.h>
  23 #include <linux/of.h>
  24 #include <linux/slab.h>
  25 #include <linux/sysfs.h>
  26
  27 #include "extcon.h"
  28
  29 #define SUPPORTED_CABLE_MAX     32
  30
  31 static const struct __extcon_info {
  32         unsigned int type;
  33         unsigned int id;
  34         const char *name;
  35
  36 } extcon_info[] = {
  37         [EXTCON_NONE] = {
  38                 .type = EXTCON_TYPE_MISC,
  39                 .id = EXTCON_NONE,
  40                 .name = "NONE",
  41         },
  42
  43         /* USB external connector */
  44         [EXTCON_USB] = {
  45                 .type = EXTCON_TYPE_USB,
  46                 .id = EXTCON_USB,
  47                 .name = "USB",
  48         },
  49         [EXTCON_USB_HOST] = {
  50                 .type = EXTCON_TYPE_USB,
  51                 .id = EXTCON_USB_HOST,
  52                 .name = "USB-HOST",
  53         },
  54
  55         /* Charging external connector */
  56         [EXTCON_CHG_USB_SDP] = {
  57                 .type = EXTCON_TYPE_CHG | EXTCON_TYPE_USB,
  58                 .id = EXTCON_CHG_USB_SDP,
  59                 .name = "SDP",
  60         },
  61         [EXTCON_CHG_USB_DCP] = {
  62                 .type = EXTCON_TYPE_CHG | EXTCON_TYPE_USB,
  63                 .id = EXTCON_CHG_USB_DCP,
  64                 .name = "DCP",
  65         },
  66         [EXTCON_CHG_USB_CDP] = {
  67                 .type = EXTCON_TYPE_CHG | EXTCON_TYPE_USB,
  68                 .id = EXTCON_CHG_USB_CDP,
  69                 .name = "CDP",
  70         },
  71         [EXTCON_CHG_USB_ACA] = {
  72                 .type = EXTCON_TYPE_CHG | EXTCON_TYPE_USB,
  73                 .id = EXTCON_CHG_USB_ACA,
  74                 .name = "ACA",
  75         },
  76         [EXTCON_CHG_USB_FAST] = {
  77                 .type = EXTCON_TYPE_CHG | EXTCON_TYPE_USB,
  78                 .id = EXTCON_CHG_USB_FAST,
  79                 .name = "FAST-CHARGER",
  80         },
  81         [EXTCON_CHG_USB_SLOW] = {
  82                 .type = EXTCON_TYPE_CHG | EXTCON_TYPE_USB,
  83                 .id = EXTCON_CHG_USB_SLOW,
  84                 .name = "SLOW-CHARGER",
  85         },
  86         [EXTCON_CHG_WPT] = {
  87                 .type = EXTCON_TYPE_CHG,
  88                 .id = EXTCON_CHG_WPT,
  89                 .name = "WPT",
  90         },
  91         [EXTCON_CHG_USB_PD] = {
  92                 .type = EXTCON_TYPE_CHG | EXTCON_TYPE_USB,
  93                 .id = EXTCON_CHG_USB_PD,
  94                 .name = "PD",
  95         },
  96
  97         /* Jack external connector */
  98         [EXTCON_JACK_MICROPHONE] = {
  99                 .type = EXTCON_TYPE_JACK,
 100                 .id = EXTCON_JACK_MICROPHONE,
 101                 .name = "MICROPHONE",
 102         },
 103         [EXTCON_JACK_HEADPHONE] = {
 104                 .type = EXTCON_TYPE_JACK,
 105                 .id = EXTCON_JACK_HEADPHONE,
 106                 .name = "HEADPHONE",
 107         },
 108         [EXTCON_JACK_LINE_IN] = {
 109                 .type = EXTCON_TYPE_JACK,
 110                 .id = EXTCON_JACK_LINE_IN,
 111                 .name = "LINE-IN",
 112         },
 113         [EXTCON_JACK_LINE_OUT] = {
 114                 .type = EXTCON_TYPE_JACK,
 115                 .id = EXTCON_JACK_LINE_OUT,
 116                 .name = "LINE-OUT",
 117         },
 118         [EXTCON_JACK_VIDEO_IN] = {
 119                 .type = EXTCON_TYPE_JACK,
 120                 .id = EXTCON_JACK_VIDEO_IN,
 121                 .name = "VIDEO-IN",
 122         },
 123         [EXTCON_JACK_VIDEO_OUT] = {
 124                 .type = EXTCON_TYPE_JACK,
 125                 .id = EXTCON_JACK_VIDEO_OUT,
 126                 .name = "VIDEO-OUT",
 127         },
 128         [EXTCON_JACK_SPDIF_IN] = {
 129                 .type = EXTCON_TYPE_JACK,
 130                 .id = EXTCON_JACK_SPDIF_IN,
 131                 .name = "SPDIF-IN",
 132         },
 133         [EXTCON_JACK_SPDIF_OUT] = {
 134                 .type = EXTCON_TYPE_JACK,
 135                 .id = EXTCON_JACK_SPDIF_OUT,
 136                 .name = "SPDIF-OUT",
 137         },
 138
 139         /* Display external connector */
 140         [EXTCON_DISP_HDMI] = {
 141                 .type = EXTCON_TYPE_DISP,
 142                 .id = EXTCON_DISP_HDMI,
 143                 .name = "HDMI",
 144         },
 145         [EXTCON_DISP_MHL] = {
 146                 .type = EXTCON_TYPE_DISP,
 147                 .id = EXTCON_DISP_MHL,
 148                 .name = "MHL",
 149         },
 150         [EXTCON_DISP_DVI] = {
 151                 .type = EXTCON_TYPE_DISP,
 152                 .id = EXTCON_DISP_DVI,
 153                 .name = "DVI",
 154         },
 155         [EXTCON_DISP_VGA] = {
 156                 .type = EXTCON_TYPE_DISP,
 157                 .id = EXTCON_DISP_VGA,
 158                 .name = "VGA",
 159         },
 160         [EXTCON_DISP_DP] = {
 161                 .type = EXTCON_TYPE_DISP | EXTCON_TYPE_USB,
 162                 .id = EXTCON_DISP_DP,
 163                 .name = "DP",
 164         },
 165         [EXTCON_DISP_HMD] = {
 166                 .type = EXTCON_TYPE_DISP | EXTCON_TYPE_USB,
 167                 .id = EXTCON_DISP_HMD,
 168                 .name = "HMD",
 169         },
 170
 171         /* Miscellaneous external connector */
 172         [EXTCON_DOCK] = {
 173                 .type = EXTCON_TYPE_MISC,
 174                 .id = EXTCON_DOCK,
 175                 .name = "DOCK",
 176         },
 177         [EXTCON_JIG] = {
 178                 .type = EXTCON_TYPE_MISC,
 179                 .id = EXTCON_JIG,
 180                 .name = "JIG",
 181         },
 182         [EXTCON_MECHANICAL] = {
 183                 .type = EXTCON_TYPE_MISC,
 184                 .id = EXTCON_MECHANICAL,
 185                 .name = "MECHANICAL",
 186         },
 187
 188         { /* sentinel */ }
 189 };
 190
 191 /**
 192  * struct extcon_cable - An internal data for an external connector.
 193  * @edev:               the extcon device
 194  * @cable_index:        the index of this cable in the edev
 195  * @attr_g:             the attribute group for the cable
 196  * @attr_name:          "name" sysfs entry
 197  * @attr_state:         "state" sysfs entry
 198  * @attrs:              the array pointing to attr_name and attr_state for attr_g
 199  */
 200 struct extcon_cable {
 201         struct extcon_dev *edev;
 202         int cable_index;
 203
 204         struct attribute_group attr_g;
 205         struct device_attribute attr_name;
 206         struct device_attribute attr_state;
 207
 208         struct attribute *attrs[3]; /* to be fed to attr_g.attrs */
 209
 210         union extcon_property_value usb_propval[EXTCON_PROP_USB_CNT];
 211         union extcon_property_value chg_propval[EXTCON_PROP_CHG_CNT];
 212         union extcon_property_value jack_propval[EXTCON_PROP_JACK_CNT];
 213         union extcon_property_value disp_propval[EXTCON_PROP_DISP_CNT];
 214
 215         unsigned long usb_bits[BITS_TO_LONGS(EXTCON_PROP_USB_CNT)];
 216         unsigned long chg_bits[BITS_TO_LONGS(EXTCON_PROP_CHG_CNT)];
 217         unsigned long jack_bits[BITS_TO_LONGS(EXTCON_PROP_JACK_CNT)];
 218         unsigned long disp_bits[BITS_TO_LONGS(EXTCON_PROP_DISP_CNT)];
 219 };
 220
 221 static struct class *extcon_class;
 222
 223 static LIST_HEAD(extcon_dev_list);
 224 static DEFINE_MUTEX(extcon_dev_list_lock);
 225
 226 static int check_mutually_exclusive(struct extcon_dev *edev, u32 new_state)
 227 {
 228         int i = 0;
 229
 230         if (!edev->mutually_exclusive)
 231                 return 0;
 232
 233         for (i = 0; edev->mutually_exclusive[i]; i++) {
 234                 int weight;
 235                 u32 correspondants = new_state & edev->mutually_exclusive[i];
 236
 237                 /* calculate the total number of bits set */
 238                 weight = hweight32(correspondants);
 239                 if (weight > 1)
 240                         return i + 1;
 241         }
 242
 243         return 0;
 244 }
 245
 246 static int find_cable_index_by_id(struct extcon_dev *edev, const unsigned int id)
 247 {
 248         int i;
 249
 250         /* Find the the index of extcon cable in edev->supported_cable */
 251         for (i = 0; i < edev->max_supported; i++) {
 252                 if (edev->supported_cable[i] == id)
 253                         return i;
 254         }
 255
 256         return -EINVAL;
 257 }
 258
 259 static int get_extcon_type(unsigned int prop)
 260 {
 261         switch (prop) {
 262         case EXTCON_PROP_USB_MIN ... EXTCON_PROP_USB_MAX:
 263                 return EXTCON_TYPE_USB;
 264         case EXTCON_PROP_CHG_MIN ... EXTCON_PROP_CHG_MAX:
 265                 return EXTCON_TYPE_CHG;
 266         case EXTCON_PROP_JACK_MIN ... EXTCON_PROP_JACK_MAX:
 267                 return EXTCON_TYPE_JACK;
 268         case EXTCON_PROP_DISP_MIN ... EXTCON_PROP_DISP_MAX:
 269                 return EXTCON_TYPE_DISP;
 270         default:
 271                 return -EINVAL;
 272         }
 273 }
 274
 275 static bool is_extcon_attached(struct extcon_dev *edev, unsigned int index)
 276 {
 277         return !!(edev->state & BIT(index));
 278 }
 279
 280 static bool is_extcon_changed(struct extcon_dev *edev, int index,
 281                                 bool new_state)
 282 {
 283         int state = !!(edev->state & BIT(index));
 284         return (state != new_state);
 285 }
 286
 287 static bool is_extcon_property_supported(unsigned int id, unsigned int prop)
 288 {
 289         int type;
 290
 291         /* Check whether the property is supported or not. */
 292         type = get_extcon_type(prop);
 293         if (type < 0)
 294                 return false;
 295
 296         /* Check whether a specific extcon id supports the property or not. */
 297         return !!(extcon_info[id].type & type);
 298 }
 299
 300 static int is_extcon_property_capability(struct extcon_dev *edev,
 301                                 unsigned int id, int index,unsigned int prop)
 302 {
 303         struct extcon_cable *cable;
 304         int type, ret;
 305
 306         /* Check whether the property is supported or not. */
 307         type = get_extcon_type(prop);
 308         if (type < 0)
 309                 return type;
 310
 311         cable = &edev->cables[index];
 312
 313         switch (type) {
 314         case EXTCON_TYPE_USB:
 315                 ret = test_bit(prop - EXTCON_PROP_USB_MIN, cable->usb_bits);
 316                 break;
 317         case EXTCON_TYPE_CHG:
 318                 ret = test_bit(prop - EXTCON_PROP_CHG_MIN, cable->chg_bits);
 319                 break;
 320         case EXTCON_TYPE_JACK:
 321                 ret = test_bit(prop - EXTCON_PROP_JACK_MIN, cable->jack_bits);
 322                 break;
 323         case EXTCON_TYPE_DISP:
 324                 ret = test_bit(prop - EXTCON_PROP_DISP_MIN, cable->disp_bits);
 325                 break;
 326         default:
 327                 ret = -EINVAL;
 328         }
 329
 330         return ret;
 331 }
 332
 333 static void init_property(struct extcon_dev *edev, unsigned int id, int index)
 334 {
 335         unsigned int type = extcon_info[id].type;
 336         struct extcon_cable *cable = &edev->cables[index];
 337
 338         if (EXTCON_TYPE_USB & type)
 339                 memset(cable->usb_propval, 0, sizeof(cable->usb_propval));
 340         if (EXTCON_TYPE_CHG & type)
 341                 memset(cable->chg_propval, 0, sizeof(cable->chg_propval));
 342         if (EXTCON_TYPE_JACK & type)
 343                 memset(cable->jack_propval, 0, sizeof(cable->jack_propval));
 344         if (EXTCON_TYPE_DISP & type)
 345                 memset(cable->disp_propval, 0, sizeof(cable->disp_propval));
 346 }
 347
 348 static ssize_t state_show(struct device *dev, struct device_attribute *attr,
 349                           char *buf)
 350 {
 351         int i, count = 0;
 352         struct extcon_dev *edev = dev_get_drvdata(dev);
 353
 354         if (edev->max_supported == 0)
 355                 return sprintf(buf, "%u\n", edev->state);
 356
 357         for (i = 0; i < edev->max_supported; i++) {
 358                 count += sprintf(buf + count, "%s=%d\n",
 359                                 extcon_info[edev->supported_cable[i]].name,
 360                                  !!(edev->state & BIT(i)));
 361         }
 362
 363         return count;
 364 }
 365 static DEVICE_ATTR_RO(state);
 366
 367 static ssize_t name_show(struct device *dev, struct device_attribute *attr,
 368                 char *buf)
 369 {
 370         struct extcon_dev *edev = dev_get_drvdata(dev);
 371
 372         return sprintf(buf, "%s\n", edev->name);
 373 }
 374 static DEVICE_ATTR_RO(name);
 375
 376 static ssize_t cable_name_show(struct device *dev,
 377                                struct device_attribute *attr, char *buf)
 378 {
 379         struct extcon_cable *cable = container_of(attr, struct extcon_cable,
 380                                                   attr_name);
 381         int i = cable->cable_index;
 382
 383         return sprintf(buf, "%s\n",
 384                         extcon_info[cable->edev->supported_cable[i]].name);
 385 }
 386
 387 static ssize_t cable_state_show(struct device *dev,
 388                                 struct device_attribute *attr, char *buf)
 389 {
 390         struct extcon_cable *cable = container_of(attr, struct extcon_cable,
 391                                                   attr_state);
 392
 393         int i = cable->cable_index;
 394
 395         return sprintf(buf, "%d\n",
 396                 extcon_get_state(cable->edev, cable->edev->supported_cable[i]));
 397 }
 398
 399 /**
 400  * extcon_sync() - Synchronize the state for an external connector.
 401  * @edev:       the extcon device
 402  *
 403  * Note that this function send a notification in order to synchronize
 404  * the state and property of an external connector.
 405  *
 406  * Returns 0 if success or error number if fail.
 407  */
 408 int extcon_sync(struct extcon_dev *edev, unsigned int id)
 409 {
 410         char name_buf[120];
 411         char state_buf[120];
 412         char *prop_buf;
 413         char *envp[3];
 414         int env_offset = 0;
 415         int length;
 416         int index;
 417         int state;
 418         unsigned long flags;
 419
 420         if (!edev)
 421                 return -EINVAL;
 422
 423         index = find_cable_index_by_id(edev, id);
 424         if (index < 0)
 425                 return index;
 426
 427         spin_lock_irqsave(&edev->lock, flags);
 428         state = !!(edev->state & BIT(index));
 429         spin_unlock_irqrestore(&edev->lock, flags);
 430
 431         /*
 432          * Call functions in a raw notifier chain for the specific one
 433          * external connector.
 434          */
 435         raw_notifier_call_chain(&edev->nh[index], state, edev);
 436
 437         /*
 438          * Call functions in a raw notifier chain for the all supported
 439          * external connectors.
 440          */
 441         raw_notifier_call_chain(&edev->nh_all, state, edev);
 442
 443         spin_lock_irqsave(&edev->lock, flags);
 444         /* This could be in interrupt handler */
 445         prop_buf = (char *)get_zeroed_page(GFP_ATOMIC);
 446         if (!prop_buf) {
 447                 /* Unlock early before uevent */
 448                 spin_unlock_irqrestore(&edev->lock, flags);
 449
 450                 dev_err(&edev->dev, "out of memory in extcon_set_state\n");
 451                 kobject_uevent(&edev->dev.kobj, KOBJ_CHANGE);
 452
 453                 return -ENOMEM;
 454         }
 455
 456         length = name_show(&edev->dev, NULL, prop_buf);
 457         if (length > 0) {
 458                 if (prop_buf[length - 1] == '\n')
 459                         prop_buf[length - 1] = 0;
 460                 snprintf(name_buf, sizeof(name_buf), "NAME=%s", prop_buf);
 461                 envp[env_offset++] = name_buf;
 462         }
 463
 464         length = state_show(&edev->dev, NULL, prop_buf);
 465         if (length > 0) {
 466                 if (prop_buf[length - 1] == '\n')
 467                         prop_buf[length - 1] = 0;
 468                 snprintf(state_buf, sizeof(state_buf), "STATE=%s", prop_buf);
 469                 envp[env_offset++] = state_buf;
 470         }
 471         envp[env_offset] = NULL;
 472
 473         /* Unlock early before uevent */
 474         spin_unlock_irqrestore(&edev->lock, flags);
 475         kobject_uevent_env(&edev->dev.kobj, KOBJ_CHANGE, envp);
 476         free_page((unsigned long)prop_buf);
 477
 478         return 0;
 479 }
 480 EXPORT_SYMBOL_GPL(extcon_sync);
 481
 482 /**
 483  * extcon_get_state() - Get the state of an external connector.
 484  * @edev:       the extcon device
 485  * @id:         the unique id indicating an external connector
 486  *
 487  * Returns 0 if success or error number if fail.
 488  */
 489 int extcon_get_state(struct extcon_dev *edev, const unsigned int id)
 490 {
 491         int index, state;
 492         unsigned long flags;
 493
 494         if (!edev)
 495                 return -EINVAL;
 496
 497         index = find_cable_index_by_id(edev, id);
 498         if (index < 0)
 499                 return index;
 500
 501         spin_lock_irqsave(&edev->lock, flags);
 502         state = is_extcon_attached(edev, index);
 503         spin_unlock_irqrestore(&edev->lock, flags);
 504
 505         return state;
 506 }
 507 EXPORT_SYMBOL_GPL(extcon_get_state);
 508
 509 /**
 510  * extcon_set_state() - Set the state of an external connector.
 511  * @edev:       the extcon device
 512  * @id:         the unique id indicating an external connector
 513  * @state:      the new state of an external connector.
 514  *              the default semantics is true: attached / false: detached.
 515  *
 516  * Note that this function set the state of an external connector without
 517  * a notification. To synchronize the state of an external connector,
 518  * have to use extcon_set_state_sync() and extcon_sync().
 519  *
 520  * Returns 0 if success or error number if fail.
 521  */
 522 int extcon_set_state(struct extcon_dev *edev, unsigned int id, bool state)
 523 {
 524         unsigned long flags;
 525         int index, ret = 0;
 526
 527         if (!edev)
 528                 return -EINVAL;
 529
 530         index = find_cable_index_by_id(edev, id);
 531         if (index < 0)
 532                 return index;
 533
 534         spin_lock_irqsave(&edev->lock, flags);
 535
 536         /* Check whether the external connector's state is changed. */
 537         if (!is_extcon_changed(edev, index, state))
 538                 goto out;
 539
 540         if (check_mutually_exclusive(edev,
 541                 (edev->state & ~BIT(index)) | (state & BIT(index)))) {
 542                 ret = -EPERM;
 543                 goto out;
 544         }
 545
 546         /*
 547          * Initialize the value of extcon property before setting
 548          * the detached state for an external connector.
 549          */
 550         if (!state)
 551                 init_property(edev, id, index);
 552
 553         /* Update the state for an external connector. */
 554         if (state)
 555                 edev->state |= BIT(index);
 556         else
 557                 edev->state &= ~(BIT(index));
 558 out:
 559         spin_unlock_irqrestore(&edev->lock, flags);
 560
 561         return ret;
 562 }
 563 EXPORT_SYMBOL_GPL(extcon_set_state);
 564
 565 /**
 566  * extcon_set_state_sync() - Set the state of an external connector with sync.
 567  * @edev:       the extcon device
 568  * @id:         the unique id indicating an external connector
 569  * @state:      the new state of external connector.
 570  *              the default semantics is true: attached / false: detached.
 571  *
 572  * Note that this function set the state of external connector
 573  * and synchronize the state by sending a notification.
 574  *
 575  * Returns 0 if success or error number if fail.
 576  */
 577 int extcon_set_state_sync(struct extcon_dev *edev, unsigned int id, bool state)
 578 {
 579         int ret, index;
 580         unsigned long flags;
 581
 582         index = find_cable_index_by_id(edev, id);
 583         if (index < 0)
 584                 return index;
 585
 586         /* Check whether the external connector's state is changed. */
 587         spin_lock_irqsave(&edev->lock, flags);
 588         ret = is_extcon_changed(edev, index, state);
 589         spin_unlock_irqrestore(&edev->lock, flags);
 590         if (!ret)
 591                 return 0;
 592
 593         ret = extcon_set_state(edev, id, state);
 594         if (ret < 0)
 595                 return ret;
 596
 597         return extcon_sync(edev, id);
 598 }
 599 EXPORT_SYMBOL_GPL(extcon_set_state_sync);
 600
 601 /**
 602  * extcon_get_property() - Get the property value of an external connector.
 603  * @edev:       the extcon device
 604  * @id:         the unique id indicating an external connector
 605  * @prop:       the property id indicating an extcon property
 606  * @prop_val:   the pointer which store the value of extcon property
 607  *
 608  * Note that when getting the property value of external connector,
 609  * the external connector should be attached. If detached state, function
 610  * return 0 without property value. Also, the each property should be
 611  * included in the list of supported properties according to extcon type.
 612  *
 613  * Returns 0 if success or error number if fail.
 614  */
 615 int extcon_get_property(struct extcon_dev *edev, unsigned int id,
 616                                 unsigned int prop,
 617                                 union extcon_property_value *prop_val)
 618 {
 619         struct extcon_cable *cable;
 620         unsigned long flags;
 621         int index, ret = 0;
 622
 623         *prop_val = (union extcon_property_value){0};
 624
 625         if (!edev)
 626                 return -EINVAL;
 627
 628         /* Check whether the property is supported or not */
 629         if (!is_extcon_property_supported(id, prop))
 630                 return -EINVAL;
 631
 632         /* Find the cable index of external connector by using id */
 633         index = find_cable_index_by_id(edev, id);
 634         if (index < 0)
 635                 return index;
 636
 637         spin_lock_irqsave(&edev->lock, flags);
 638
 639         /* Check whether the property is available or not. */
 640         if (!is_extcon_property_capability(edev, id, index, prop)) {
 641                 spin_unlock_irqrestore(&edev->lock, flags);
 642                 return -EPERM;
 643         }
 644
 645         /*
 646          * Check whether the external connector is attached.
 647          * If external connector is detached, the user can not
 648          * get the property value.
 649          */
 650         if (!is_extcon_attached(edev, index)) {
 651                 spin_unlock_irqrestore(&edev->lock, flags);
 652                 return 0;
 653         }
 654
 655         cable = &edev->cables[index];
 656
 657         /* Get the property value according to extcon type */
 658         switch (prop) {
 659         case EXTCON_PROP_USB_MIN ... EXTCON_PROP_USB_MAX:
 660                 *prop_val = cable->usb_propval[prop - EXTCON_PROP_USB_MIN];
 661                 break;
 662         case EXTCON_PROP_CHG_MIN ... EXTCON_PROP_CHG_MAX:
 663                 *prop_val = cable->chg_propval[prop - EXTCON_PROP_CHG_MIN];
 664                 break;
 665         case EXTCON_PROP_JACK_MIN ... EXTCON_PROP_JACK_MAX:
 666                 *prop_val = cable->jack_propval[prop - EXTCON_PROP_JACK_MIN];
 667                 break;
 668         case EXTCON_PROP_DISP_MIN ... EXTCON_PROP_DISP_MAX:
 669                 *prop_val = cable->disp_propval[prop - EXTCON_PROP_DISP_MIN];
 670                 break;
 671         default:
 672                 ret = -EINVAL;
 673                 break;
 674         }
 675
 676         spin_unlock_irqrestore(&edev->lock, flags);
 677
 678         return ret;
 679 }
 680 EXPORT_SYMBOL_GPL(extcon_get_property);
 681
 682 /**
 683  * extcon_set_property() - Set the property value of an external connector.
 684  * @edev:       the extcon device
 685  * @id:         the unique id indicating an external connector
 686  * @prop:       the property id indicating an extcon property
 687  * @prop_val:   the pointer including the new value of extcon property
 688  *
 689  * Note that each property should be included in the list of supported
 690  * properties according to the extcon type.
 691  *
 692  * Returns 0 if success or error number if fail.
 693  */
 694 int extcon_set_property(struct extcon_dev *edev, unsigned int id,
 695                                 unsigned int prop,
 696                                 union extcon_property_value prop_val)
 697 {
 698         struct extcon_cable *cable;
 699         unsigned long flags;
 700         int index, ret = 0;
 701
 702         if (!edev)
 703                 return -EINVAL;
 704
 705         /* Check whether the property is supported or not */
 706         if (!is_extcon_property_supported(id, prop))
 707                 return -EINVAL;
 708
 709         /* Find the cable index of external connector by using id */
 710         index = find_cable_index_by_id(edev, id);
 711         if (index < 0)
 712                 return index;
 713
 714         spin_lock_irqsave(&edev->lock, flags);
 715
 716         /* Check whether the property is available or not. */
 717         if (!is_extcon_property_capability(edev, id, index, prop)) {
 718                 spin_unlock_irqrestore(&edev->lock, flags);
 719                 return -EPERM;
 720         }
 721
 722         cable = &edev->cables[index];
 723
 724         /* Set the property value according to extcon type */
 725         switch (prop) {
 726         case EXTCON_PROP_USB_MIN ... EXTCON_PROP_USB_MAX:
 727                 cable->usb_propval[prop - EXTCON_PROP_USB_MIN] = prop_val;
 728                 break;
 729         case EXTCON_PROP_CHG_MIN ... EXTCON_PROP_CHG_MAX:
 730                 cable->chg_propval[prop - EXTCON_PROP_CHG_MIN] = prop_val;
 731                 break;
 732         case EXTCON_PROP_JACK_MIN ... EXTCON_PROP_JACK_MAX:
 733                 cable->jack_propval[prop - EXTCON_PROP_JACK_MIN] = prop_val;
 734                 break;
 735         case EXTCON_PROP_DISP_MIN ... EXTCON_PROP_DISP_MAX:
 736                 cable->disp_propval[prop - EXTCON_PROP_DISP_MIN] = prop_val;
 737                 break;
 738         default:
 739                 ret = -EINVAL;
 740                 break;
 741         }
 742
 743         spin_unlock_irqrestore(&edev->lock, flags);
 744
 745         return ret;
 746 }
 747 EXPORT_SYMBOL_GPL(extcon_set_property);
 748
 749 /**
 750  * extcon_set_property_sync() - Set property of an external connector with sync.
 751  * @prop_val:   the pointer including the new value of extcon property
 752  *
 753  * Note that when setting the property value of external connector,
 754  * the external connector should be attached. The each property should
 755  * be included in the list of supported properties according to extcon type.
 756  *
 757  * Returns 0 if success or error number if fail.
 758  */
 759 int extcon_set_property_sync(struct extcon_dev *edev, unsigned int id,
 760                                 unsigned int prop,
 761                                 union extcon_property_value prop_val)
 762 {
 763         int ret;
 764
 765         ret = extcon_set_property(edev, id, prop, prop_val);
 766         if (ret < 0)
 767                 return ret;
 768
 769         return extcon_sync(edev, id);
 770 }
 771 EXPORT_SYMBOL_GPL(extcon_set_property_sync);
 772
 773 /**
 774  * extcon_get_property_capability() - Get the capability of the property
 775  *                                      for an external connector.
 776  * @edev:       the extcon device
 777  * @id:         the unique id indicating an external connector
 778  * @prop:       the property id indicating an extcon property
 779  *
 780  * Returns 1 if the property is available or 0 if not available.
 781  */
 782 int extcon_get_property_capability(struct extcon_dev *edev, unsigned int id,
 783                                         unsigned int prop)
 784 {
 785         int index;
 786
 787         if (!edev)
 788                 return -EINVAL;
 789
 790         /* Check whether the property is supported or not */
 791         if (!is_extcon_property_supported(id, prop))
 792                 return -EINVAL;
 793
 794         /* Find the cable index of external connector by using id */
 795         index = find_cable_index_by_id(edev, id);
 796         if (index < 0)
 797                 return index;
 798
 799         return is_extcon_property_capability(edev, id, index, prop);
 800 }
 801 EXPORT_SYMBOL_GPL(extcon_get_property_capability);
 802
 803 /**
 804  * extcon_set_property_capability() - Set the capability of the property
 805  *                                      for an external connector.
 806  * @edev:       the extcon device
 807  * @id:         the unique id indicating an external connector
 808  * @prop:       the property id indicating an extcon property
 809  *
 810  * Note that this function set the capability of the property
 811  * for an external connector in order to mark the bit in capability
 812  * bitmap which mean the available state of the property.
 813  *
 814  * Returns 0 if success or error number if fail.
 815  */
 816 int extcon_set_property_capability(struct extcon_dev *edev, unsigned int id,
 817                                         unsigned int prop)
 818 {
 819         struct extcon_cable *cable;
 820         int index, type, ret = 0;
 821
 822         if (!edev)
 823                 return -EINVAL;
 824
 825         /* Check whether the property is supported or not. */
 826         if (!is_extcon_property_supported(id, prop))
 827                 return -EINVAL;
 828
 829         /* Find the cable index of external connector by using id. */
 830         index = find_cable_index_by_id(edev, id);
 831         if (index < 0)
 832                 return index;
 833
 834         type = get_extcon_type(prop);
 835         if (type < 0)
 836                 return type;
 837
 838         cable = &edev->cables[index];
 839
 840         switch (type) {
 841         case EXTCON_TYPE_USB:
 842                 __set_bit(prop - EXTCON_PROP_USB_MIN, cable->usb_bits);
 843                 break;
 844         case EXTCON_TYPE_CHG:
 845                 __set_bit(prop - EXTCON_PROP_CHG_MIN, cable->chg_bits);
 846                 break;
 847         case EXTCON_TYPE_JACK:
 848                 __set_bit(prop - EXTCON_PROP_JACK_MIN, cable->jack_bits);
 849                 break;
 850         case EXTCON_TYPE_DISP:
 851                 __set_bit(prop - EXTCON_PROP_DISP_MIN, cable->disp_bits);
 852                 break;
 853         default:
 854                 ret = -EINVAL;
 855         }
 856
 857         return ret;
 858 }
 859 EXPORT_SYMBOL_GPL(extcon_set_property_capability);
 860
 861 /**
 862  * extcon_get_extcon_dev() - Get the extcon device instance from the name.
 863  * @extcon_name:        the extcon name provided with extcon_dev_register()
 864  *
 865  * Return the pointer of extcon device if success or ERR_PTR(err) if fail.
 866  * NOTE: This function returns -EPROBE_DEFER so it may only be called from
 867  * probe() functions.
 868  */
 869 struct extcon_dev *extcon_get_extcon_dev(const char *extcon_name)
 870 {
 871         struct extcon_dev *sd;
 872
 873         if (!extcon_name)
 874                 return ERR_PTR(-EINVAL);
 875
 876         mutex_lock(&extcon_dev_list_lock);
 877         list_for_each_entry(sd, &extcon_dev_list, entry) {
 878                 if (!strcmp(sd->name, extcon_name))
 879                         goto out;
 880         }
 881         sd = ERR_PTR(-EPROBE_DEFER);
 882 out:
 883         mutex_unlock(&extcon_dev_list_lock);
 884         return sd;
 885 }
 886 EXPORT_SYMBOL_GPL(extcon_get_extcon_dev);
 887
 888 /**
 889  * extcon_register_notifier() - Register a notifier block to get notified by
 890  *                              any state changes from the extcon.
 891  * @edev:       the extcon device
 892  * @id:         the unique id indicating an external connector
 893  * @nb:         a notifier block to be registered
 894  *
 895  * Note that the second parameter given to the callback of nb (val) is
 896  * the current state of an external connector and the third pameter
 897  * is the pointer of extcon device.
 898  *
 899  * Returns 0 if success or error number if fail.
 900  */
 901 int extcon_register_notifier(struct extcon_dev *edev, unsigned int id,
 902                              struct notifier_block *nb)
 903 {
 904         unsigned long flags;
 905         int ret, idx;
 906
 907         if (!edev || !nb)
 908                 return -EINVAL;
 909
 910         idx = find_cable_index_by_id(edev, id);
 911         if (idx < 0)
 912                 return idx;
 913
 914         spin_lock_irqsave(&edev->lock, flags);
 915         ret = raw_notifier_chain_register(&edev->nh[idx], nb);
 916         spin_unlock_irqrestore(&edev->lock, flags);
 917
 918         return ret;
 919 }
 920 EXPORT_SYMBOL_GPL(extcon_register_notifier);
 921
 922 /**
 923  * extcon_unregister_notifier() - Unregister a notifier block from the extcon.
 924  * @edev:       the extcon device
 925  * @id:         the unique id indicating an external connector
 926  * @nb:         a notifier block to be registered
 927  *
 928  * Returns 0 if success or error number if fail.
 929  */
 930 int extcon_unregister_notifier(struct extcon_dev *edev, unsigned int id,
 931                                 struct notifier_block *nb)
 932 {
 933         unsigned long flags;
 934         int ret, idx;
 935
 936         if (!edev || !nb)
 937                 return -EINVAL;
 938
 939         idx = find_cable_index_by_id(edev, id);
 940         if (idx < 0)
 941                 return idx;
 942
 943         spin_lock_irqsave(&edev->lock, flags);
 944         ret = raw_notifier_chain_unregister(&edev->nh[idx], nb);
 945         spin_unlock_irqrestore(&edev->lock, flags);
 946
 947         return ret;
 948 }
 949 EXPORT_SYMBOL_GPL(extcon_unregister_notifier);
 950
 951 /**
 952  * extcon_register_notifier_all() - Register a notifier block for all connectors.
 953  * @edev:       the extcon device
 954  * @nb:         a notifier block to be registered
 955  *
 956  * Note that this function registers a notifier block in order to receive
 957  * the state change of all supported external connectors from extcon device.
 958  * And the second parameter given to the callback of nb (val) is
 959  * the current state and the third pameter is the pointer of extcon device.
 960  *
 961  * Returns 0 if success or error number if fail.
 962  */
 963 int extcon_register_notifier_all(struct extcon_dev *edev,
 964                                 struct notifier_block *nb)
 965 {
 966         unsigned long flags;
 967         int ret;
 968
 969         if (!edev || !nb)
 970                 return -EINVAL;
 971
 972         spin_lock_irqsave(&edev->lock, flags);
 973         ret = raw_notifier_chain_register(&edev->nh_all, nb);
 974         spin_unlock_irqrestore(&edev->lock, flags);
 975
 976         return ret;
 977 }
 978 EXPORT_SYMBOL_GPL(extcon_register_notifier_all);
 979
 980 /**
 981  * extcon_unregister_notifier_all() - Unregister a notifier block from extcon.
 982  * @edev:       the extcon device
 983  * @nb:         a notifier block to be registered
 984  *
 985  * Returns 0 if success or error number if fail.
 986  */
 987 int extcon_unregister_notifier_all(struct extcon_dev *edev,
 988                                 struct notifier_block *nb)
 989 {
 990         unsigned long flags;
 991         int ret;
 992
 993         if (!edev || !nb)
 994                 return -EINVAL;
 995
 996         spin_lock_irqsave(&edev->lock, flags);
 997         ret = raw_notifier_chain_unregister(&edev->nh_all, nb);
 998         spin_unlock_irqrestore(&edev->lock, flags);
 999
1000         return ret;
1001 }
1002 EXPORT_SYMBOL_GPL(extcon_unregister_notifier_all);
1003
1004 static struct attribute *extcon_attrs[] = {
1005         &dev_attr_state.attr,
1006         &dev_attr_name.attr,
1007         NULL,
1008 };
1009 ATTRIBUTE_GROUPS(extcon);
1010
1011 static int create_extcon_class(void)
1012 {
1013         if (!extcon_class) {
1014                 extcon_class = class_create(THIS_MODULE, "extcon");
1015                 if (IS_ERR(extcon_class))
1016                         return PTR_ERR(extcon_class);
1017                 extcon_class->dev_groups = extcon_groups;
1018         }
1019
1020         return 0;
1021 }
1022
1023 static void extcon_dev_release(struct device *dev)
1024 {
1025 }
1026
1027 static const char *muex_name = "mutually_exclusive";
1028 static void dummy_sysfs_dev_release(struct device *dev)
1029 {
1030 }
1031
1032 /*
1033  * extcon_dev_allocate() - Allocate the memory of extcon device.
1034  * @supported_cable:    the array of the supported external connectors
1035  *                      ending with EXTCON_NONE.
1036  *
1037  * Note that this function allocates the memory for extcon device
1038  * and initialize default setting for the extcon device.
1039  *
1040  * Returns the pointer memory of allocated extcon_dev if success
1041  * or ERR_PTR(err) if fail.
1042  */
1043 struct extcon_dev *extcon_dev_allocate(const unsigned int *supported_cable)
1044 {
1045         struct extcon_dev *edev;
1046
1047         if (!supported_cable)
1048                 return ERR_PTR(-EINVAL);
1049
1050         edev = kzalloc(sizeof(*edev), GFP_KERNEL);
1051         if (!edev)
1052                 return ERR_PTR(-ENOMEM);
1053
1054         edev->max_supported = 0;
1055         edev->supported_cable = supported_cable;
1056
1057         return edev;
1058 }
1059
1060 /*
1061  * extcon_dev_free() - Free the memory of extcon device.
1062  * @edev:       the extcon device
1063  */
1064 void extcon_dev_free(struct extcon_dev *edev)
1065 {
1066         kfree(edev);
1067 }
1068 EXPORT_SYMBOL_GPL(extcon_dev_free);
1069
1070 /**
1071  * extcon_dev_register() - Register an new extcon device
1072  * @edev:       the extcon device to be registered
1073  *
1074  * Among the members of edev struct, please set the "user initializing data"
1075  * do not set the values of "internal data", which are initialized by
1076  * this function.
1077  *
1078  * Note that before calling this funciton, have to allocate the memory
1079  * of an extcon device by using the extcon_dev_allocate(). And the extcon
1080  * dev should include the supported_cable information.
1081  *
1082  * Returns 0 if success or error number if fail.
1083  */
1084 int extcon_dev_register(struct extcon_dev *edev)
1085 {
1086         int ret, index = 0;
1087         static atomic_t edev_no = ATOMIC_INIT(-1);
1088
1089         if (!extcon_class) {
1090                 ret = create_extcon_class();
1091                 if (ret < 0)
1092                         return ret;
1093         }
1094
1095         if (!edev || !edev->supported_cable)
1096                 return -EINVAL;
1097
1098         for (; edev->supported_cable[index] != EXTCON_NONE; index++);
1099
1100         edev->max_supported = index;
1101         if (index > SUPPORTED_CABLE_MAX) {
1102                 dev_err(&edev->dev,
1103                         "exceed the maximum number of supported cables\n");
1104                 return -EINVAL;
1105         }
1106
1107         edev->dev.class = extcon_class;
1108         edev->dev.release = extcon_dev_release;
1109
1110         edev->name = dev_name(edev->dev.parent);
1111         if (IS_ERR_OR_NULL(edev->name)) {
1112                 dev_err(&edev->dev,
1113                         "extcon device name is null\n");
1114                 return -EINVAL;
1115         }
1116         dev_set_name(&edev->dev, "extcon%lu",
1117                         (unsigned long)atomic_inc_return(&edev_no));
1118
1119         if (edev->max_supported) {
1120                 char *str;
1121                 struct extcon_cable *cable;
1122
1123                 edev->cables = kcalloc(edev->max_supported,
1124                                        sizeof(struct extcon_cable),
1125                                        GFP_KERNEL);
1126                 if (!edev->cables) {
1127                         ret = -ENOMEM;
1128                         goto err_sysfs_alloc;
1129                 }
1130                 for (index = 0; index < edev->max_supported; index++) {
1131                         cable = &edev->cables[index];
1132
1133                         str = kasprintf(GFP_KERNEL, "cable.%d", index);
1134                         if (!str) {
1135                                 for (index--; index >= 0; index--) {
1136                                         cable = &edev->cables[index];
1137                                         kfree(cable->attr_g.name);
1138                                 }
1139                                 ret = -ENOMEM;
1140
1141                                 goto err_alloc_cables;
1142                         }
1143
1144                         cable->edev = edev;
1145                         cable->cable_index = index;
1146                         cable->attrs[0] = &cable->attr_name.attr;
1147                         cable->attrs[1] = &cable->attr_state.attr;
1148                         cable->attrs[2] = NULL;
1149                         cable->attr_g.name = str;
1150                         cable->attr_g.attrs = cable->attrs;
1151
1152                         sysfs_attr_init(&cable->attr_name.attr);
1153                         cable->attr_name.attr.name = "name";
1154                         cable->attr_name.attr.mode = 0444;
1155                         cable->attr_name.show = cable_name_show;
1156
1157                         sysfs_attr_init(&cable->attr_state.attr);
1158                         cable->attr_state.attr.name = "state";
1159                         cable->attr_state.attr.mode = 0444;
1160                         cable->attr_state.show = cable_state_show;
1161                 }
1162         }
1163
1164         if (edev->max_supported && edev->mutually_exclusive) {
1165                 char *name;
1166
1167                 /* Count the size of mutually_exclusive array */
1168                 for (index = 0; edev->mutually_exclusive[index]; index++)
1169                         ;
1170
1171                 edev->attrs_muex = kcalloc(index + 1,
1172                                            sizeof(struct attribute *),
1173                                            GFP_KERNEL);
1174                 if (!edev->attrs_muex) {
1175                         ret = -ENOMEM;
1176                         goto err_muex;
1177                 }
1178
1179                 edev->d_attrs_muex = kcalloc(index,
1180                                              sizeof(struct device_attribute),
1181                                              GFP_KERNEL);
1182                 if (!edev->d_attrs_muex) {
1183                         ret = -ENOMEM;
1184                         kfree(edev->attrs_muex);
1185                         goto err_muex;
1186                 }
1187
1188                 for (index = 0; edev->mutually_exclusive[index]; index++) {
1189                         name = kasprintf(GFP_KERNEL, "0x%x",
1190                                          edev->mutually_exclusive[index]);
1191                         if (!name) {
1192                                 for (index--; index >= 0; index--) {
1193                                         kfree(edev->d_attrs_muex[index].attr.
1194                                               name);
1195                                 }
1196                                 kfree(edev->d_attrs_muex);
1197                                 kfree(edev->attrs_muex);
1198                                 ret = -ENOMEM;
1199                                 goto err_muex;
1200                         }
1201                         sysfs_attr_init(&edev->d_attrs_muex[index].attr);
1202                         edev->d_attrs_muex[index].attr.name = name;
1203                         edev->d_attrs_muex[index].attr.mode = 0000;
1204                         edev->attrs_muex[index] = &edev->d_attrs_muex[index]
1205                                                         .attr;
1206                 }
1207                 edev->attr_g_muex.name = muex_name;
1208                 edev->attr_g_muex.attrs = edev->attrs_muex;
1209
1210         }
1211
1212         if (edev->max_supported) {
1213                 edev->extcon_dev_type.groups =
1214                         kcalloc(edev->max_supported + 2,
1215                                 sizeof(struct attribute_group *),
1216                                 GFP_KERNEL);
1217                 if (!edev->extcon_dev_type.groups) {
1218                         ret = -ENOMEM;
1219                         goto err_alloc_groups;
1220                 }
1221
1222                 edev->extcon_dev_type.name = dev_name(&edev->dev);
1223                 edev->extcon_dev_type.release = dummy_sysfs_dev_release;
1224
1225                 for (index = 0; index < edev->max_supported; index++)
1226                         edev->extcon_dev_type.groups[index] =
1227                                 &edev->cables[index].attr_g;
1228                 if (edev->mutually_exclusive)
1229                         edev->extcon_dev_type.groups[index] =
1230                                 &edev->attr_g_muex;
1231
1232                 edev->dev.type = &edev->extcon_dev_type;
1233         }
1234
1235         spin_lock_init(&edev->lock);
1236         if (edev->max_supported) {
1237                 edev->nh = kcalloc(edev->max_supported, sizeof(*edev->nh),
1238                                 GFP_KERNEL);
1239                 if (!edev->nh) {
1240                         ret = -ENOMEM;
1241                         goto err_alloc_nh;
1242                 }
1243         }
1244
1245         for (index = 0; index < edev->max_supported; index++)
1246                 RAW_INIT_NOTIFIER_HEAD(&edev->nh[index]);
1247
1248         RAW_INIT_NOTIFIER_HEAD(&edev->nh_all);
1249
1250         dev_set_drvdata(&edev->dev, edev);
1251         edev->state = 0;
1252
1253         ret = device_register(&edev->dev);
1254         if (ret) {
1255                 put_device(&edev->dev);
1256                 goto err_dev;
1257         }
1258
1259         mutex_lock(&extcon_dev_list_lock);
1260         list_add(&edev->entry, &extcon_dev_list);
1261         mutex_unlock(&extcon_dev_list_lock);
1262
1263         return 0;
1264
1265 err_dev:
1266         if (edev->max_supported)
1267                 kfree(edev->nh);
1268 err_alloc_nh:
1269         if (edev->max_supported)
1270                 kfree(edev->extcon_dev_type.groups);
1271 err_alloc_groups:
1272         if (edev->max_supported && edev->mutually_exclusive) {
1273                 for (index = 0; edev->mutually_exclusive[index]; index++)
1274                         kfree(edev->d_attrs_muex[index].attr.name);
1275                 kfree(edev->d_attrs_muex);
1276                 kfree(edev->attrs_muex);
1277         }
1278 err_muex:
1279         for (index = 0; index < edev->max_supported; index++)
1280                 kfree(edev->cables[index].attr_g.name);
1281 err_alloc_cables:
1282         if (edev->max_supported)
1283                 kfree(edev->cables);
1284 err_sysfs_alloc:
1285         return ret;
1286 }
1287 EXPORT_SYMBOL_GPL(extcon_dev_register);
1288
1289 /**
1290  * extcon_dev_unregister() - Unregister the extcon device.
1291  * @edev:       the extcon device to be unregistered.
1292  *
1293  * Note that this does not call kfree(edev) because edev was not allocated
1294  * by this class.
1295  */
1296 void extcon_dev_unregister(struct extcon_dev *edev)
1297 {
1298         int index;
1299
1300         if (!edev)
1301                 return;
1302
1303         mutex_lock(&extcon_dev_list_lock);
1304         list_del(&edev->entry);
1305         mutex_unlock(&extcon_dev_list_lock);
1306
1307         if (IS_ERR_OR_NULL(get_device(&edev->dev))) {
1308                 dev_err(&edev->dev, "Failed to unregister extcon_dev (%s)\n",
1309                                 dev_name(&edev->dev));
1310                 return;
1311         }
1312
1313         device_unregister(&edev->dev);
1314
1315         if (edev->mutually_exclusive && edev->max_supported) {
1316                 for (index = 0; edev->mutually_exclusive[index];
1317                                 index++)
1318                         kfree(edev->d_attrs_muex[index].attr.name);
1319                 kfree(edev->d_attrs_muex);
1320                 kfree(edev->attrs_muex);
1321         }
1322
1323         for (index = 0; index < edev->max_supported; index++)
1324                 kfree(edev->cables[index].attr_g.name);
1325
1326         if (edev->max_supported) {
1327                 kfree(edev->extcon_dev_type.groups);
1328                 kfree(edev->cables);
1329                 kfree(edev->nh);
1330         }
1331
1332         put_device(&edev->dev);
1333 }
1334 EXPORT_SYMBOL_GPL(extcon_dev_unregister);
1335
1336 #ifdef CONFIG_OF
1337
1338 /*
1339  * extcon_find_edev_by_node - Find the extcon device from devicetree.
1340  * @node        : OF node identifying edev
1341  *
1342  * Return the pointer of extcon device if success or ERR_PTR(err) if fail.
1343  */
1344 struct extcon_dev *extcon_find_edev_by_node(struct device_node *node)
1345 {
1346         struct extcon_dev *edev;
1347
1348         mutex_lock(&extcon_dev_list_lock);
1349         list_for_each_entry(edev, &extcon_dev_list, entry)
1350                 if (edev->dev.parent && edev->dev.parent->of_node == node)
1351                         goto out;
1352         edev = ERR_PTR(-EPROBE_DEFER);
1353 out:
1354         mutex_unlock(&extcon_dev_list_lock);
1355
1356         return edev;
1357 }
1358
1359 /*
1360  * extcon_get_edev_by_phandle - Get the extcon device from devicetree.
1361  * @dev         : the instance to the given device
1362  * @index       : the index into list of extcon_dev
1363  *
1364  * Return the pointer of extcon device if success or ERR_PTR(err) if fail.
1365  */
1366 struct extcon_dev *extcon_get_edev_by_phandle(struct device *dev, int index)
1367 {
1368         struct device_node *node;
1369         struct extcon_dev *edev;
1370
1371         if (!dev)
1372                 return ERR_PTR(-EINVAL);
1373
1374         if (!dev->of_node) {
1375                 dev_dbg(dev, "device does not have a device node entry\n");
1376                 return ERR_PTR(-EINVAL);
1377         }
1378
1379         node = of_parse_phandle(dev->of_node, "extcon", index);
1380         if (!node) {
1381                 dev_dbg(dev, "failed to get phandle in %pOF node\n",
1382                         dev->of_node);
1383                 return ERR_PTR(-ENODEV);
1384         }
1385
1386         edev = extcon_find_edev_by_node(node);
1387         of_node_put(node);
1388
1389         return edev;
1390 }
1391
1392 #else
1393
1394 struct extcon_dev *extcon_find_edev_by_node(struct device_node *node)
1395 {
1396         return ERR_PTR(-ENOSYS);
1397 }
1398
1399 struct extcon_dev *extcon_get_edev_by_phandle(struct device *dev, int index)
1400 {
1401         return ERR_PTR(-ENOSYS);
1402 }
1403
1404 #endif /* CONFIG_OF */
1405
1406 EXPORT_SYMBOL_GPL(extcon_find_edev_by_node);
1407 EXPORT_SYMBOL_GPL(extcon_get_edev_by_phandle);
1408
1409 /**
1410  * extcon_get_edev_name() - Get the name of the extcon device.
1411  * @edev:       the extcon device
1412  */
1413 const char *extcon_get_edev_name(struct extcon_dev *edev)
1414 {
1415         return !edev ? NULL : edev->name;
1416 }
1417 EXPORT_SYMBOL_GPL(extcon_get_edev_name);
1418
1419 static int __init extcon_class_init(void)
1420 {
1421         return create_extcon_class();
1422 }
1423 module_init(extcon_class_init);
1424
1425 static void __exit extcon_class_exit(void)
1426 {
1427         class_destroy(extcon_class);
1428 }
1429 module_exit(extcon_class_exit);
1430
1431 MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>");
1432 MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
1433 MODULE_DESCRIPTION("External Connector (extcon) framework");
1434 MODULE_LICENSE("GPL v2");