drivers/extcon/extcon.c

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