2 * drivers/extcon/extcon.c - External Connector (extcon) framework.
4 * Copyright (C) 2015 Samsung Electronics
5 * Author: Chanwoo Choi <cw00.choi@samsung.com>
7 * Copyright (C) 2012 Samsung Electronics
8 * Author: Donggeun Kim <dg77.kim@samsung.com>
9 * Author: MyungJoo Ham <myungjoo.ham@samsung.com>
11 * based on android/drivers/switch/switch_class.c
12 * Copyright (C) 2008 Google, Inc.
13 * Author: Mike Lockwood <lockwood@android.com>
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.
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.
25 #include <linux/module.h>
26 #include <linux/types.h>
27 #include <linux/init.h>
28 #include <linux/device.h>
30 #include <linux/err.h>
32 #include <linux/slab.h>
33 #include <linux/sysfs.h>
37 #define SUPPORTED_CABLE_MAX 32
39 static const struct __extcon_info
{
46 .type
= EXTCON_TYPE_MISC
,
51 /* USB external connector */
53 .type
= EXTCON_TYPE_USB
,
58 .type
= EXTCON_TYPE_USB
,
59 .id
= EXTCON_USB_HOST
,
63 /* Charging external connector */
64 [EXTCON_CHG_USB_SDP
] = {
65 .type
= EXTCON_TYPE_CHG
| EXTCON_TYPE_USB
,
66 .id
= EXTCON_CHG_USB_SDP
,
69 [EXTCON_CHG_USB_DCP
] = {
70 .type
= EXTCON_TYPE_CHG
| EXTCON_TYPE_USB
,
71 .id
= EXTCON_CHG_USB_DCP
,
74 [EXTCON_CHG_USB_CDP
] = {
75 .type
= EXTCON_TYPE_CHG
| EXTCON_TYPE_USB
,
76 .id
= EXTCON_CHG_USB_CDP
,
79 [EXTCON_CHG_USB_ACA
] = {
80 .type
= EXTCON_TYPE_CHG
| EXTCON_TYPE_USB
,
81 .id
= EXTCON_CHG_USB_ACA
,
84 [EXTCON_CHG_USB_FAST
] = {
85 .type
= EXTCON_TYPE_CHG
| EXTCON_TYPE_USB
,
86 .id
= EXTCON_CHG_USB_FAST
,
87 .name
= "FAST-CHARGER",
89 [EXTCON_CHG_USB_SLOW
] = {
90 .type
= EXTCON_TYPE_CHG
| EXTCON_TYPE_USB
,
91 .id
= EXTCON_CHG_USB_SLOW
,
92 .name
= "SLOW-CHARGER",
95 .type
= EXTCON_TYPE_CHG
,
99 [EXTCON_CHG_USB_PD
] = {
100 .type
= EXTCON_TYPE_CHG
| EXTCON_TYPE_USB
,
101 .id
= EXTCON_CHG_USB_PD
,
105 /* Jack external connector */
106 [EXTCON_JACK_MICROPHONE
] = {
107 .type
= EXTCON_TYPE_JACK
,
108 .id
= EXTCON_JACK_MICROPHONE
,
109 .name
= "MICROPHONE",
111 [EXTCON_JACK_HEADPHONE
] = {
112 .type
= EXTCON_TYPE_JACK
,
113 .id
= EXTCON_JACK_HEADPHONE
,
116 [EXTCON_JACK_LINE_IN
] = {
117 .type
= EXTCON_TYPE_JACK
,
118 .id
= EXTCON_JACK_LINE_IN
,
121 [EXTCON_JACK_LINE_OUT
] = {
122 .type
= EXTCON_TYPE_JACK
,
123 .id
= EXTCON_JACK_LINE_OUT
,
126 [EXTCON_JACK_VIDEO_IN
] = {
127 .type
= EXTCON_TYPE_JACK
,
128 .id
= EXTCON_JACK_VIDEO_IN
,
131 [EXTCON_JACK_VIDEO_OUT
] = {
132 .type
= EXTCON_TYPE_JACK
,
133 .id
= EXTCON_JACK_VIDEO_OUT
,
136 [EXTCON_JACK_SPDIF_IN
] = {
137 .type
= EXTCON_TYPE_JACK
,
138 .id
= EXTCON_JACK_SPDIF_IN
,
141 [EXTCON_JACK_SPDIF_OUT
] = {
142 .type
= EXTCON_TYPE_JACK
,
143 .id
= EXTCON_JACK_SPDIF_OUT
,
147 /* Display external connector */
148 [EXTCON_DISP_HDMI
] = {
149 .type
= EXTCON_TYPE_DISP
,
150 .id
= EXTCON_DISP_HDMI
,
153 [EXTCON_DISP_MHL
] = {
154 .type
= EXTCON_TYPE_DISP
,
155 .id
= EXTCON_DISP_MHL
,
158 [EXTCON_DISP_DVI
] = {
159 .type
= EXTCON_TYPE_DISP
,
160 .id
= EXTCON_DISP_DVI
,
163 [EXTCON_DISP_VGA
] = {
164 .type
= EXTCON_TYPE_DISP
,
165 .id
= EXTCON_DISP_VGA
,
169 .type
= EXTCON_TYPE_DISP
| EXTCON_TYPE_USB
,
170 .id
= EXTCON_DISP_DP
,
173 [EXTCON_DISP_HMD
] = {
174 .type
= EXTCON_TYPE_DISP
| EXTCON_TYPE_USB
,
175 .id
= EXTCON_DISP_HMD
,
179 /* Miscellaneous external connector */
181 .type
= EXTCON_TYPE_MISC
,
186 .type
= EXTCON_TYPE_MISC
,
190 [EXTCON_MECHANICAL
] = {
191 .type
= EXTCON_TYPE_MISC
,
192 .id
= EXTCON_MECHANICAL
,
193 .name
= "MECHANICAL",
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
208 struct extcon_cable
{
209 struct extcon_dev
*edev
;
212 struct attribute_group attr_g
;
213 struct device_attribute attr_name
;
214 struct device_attribute attr_state
;
216 struct attribute
*attrs
[3]; /* to be fed to attr_g.attrs */
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
];
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
)];
229 static struct class *extcon_class
;
231 static LIST_HEAD(extcon_dev_list
);
232 static DEFINE_MUTEX(extcon_dev_list_lock
);
234 static int check_mutually_exclusive(struct extcon_dev
*edev
, u32 new_state
)
238 if (!edev
->mutually_exclusive
)
241 for (i
= 0; edev
->mutually_exclusive
[i
]; i
++) {
243 u32 correspondants
= new_state
& edev
->mutually_exclusive
[i
];
245 /* calculate the total number of bits set */
246 weight
= hweight32(correspondants
);
254 static int find_cable_index_by_id(struct extcon_dev
*edev
, const unsigned int id
)
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
)
267 static int get_extcon_type(unsigned int 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
;
283 static bool is_extcon_attached(struct extcon_dev
*edev
, unsigned int index
)
285 return !!(edev
->state
& BIT(index
));
288 static bool is_extcon_changed(struct extcon_dev
*edev
, int index
,
291 int state
= !!(edev
->state
& BIT(index
));
292 return (state
!= new_state
);
295 static bool is_extcon_property_supported(unsigned int id
, unsigned int prop
)
299 /* Check whether the property is supported or not. */
300 type
= get_extcon_type(prop
);
304 /* Check whether a specific extcon id supports the property or not. */
305 return !!(extcon_info
[id
].type
& type
);
308 static int is_extcon_property_capability(struct extcon_dev
*edev
,
309 unsigned int id
, int index
,unsigned int prop
)
311 struct extcon_cable
*cable
;
314 /* Check whether the property is supported or not. */
315 type
= get_extcon_type(prop
);
319 cable
= &edev
->cables
[index
];
322 case EXTCON_TYPE_USB
:
323 ret
= test_bit(prop
- EXTCON_PROP_USB_MIN
, cable
->usb_bits
);
325 case EXTCON_TYPE_CHG
:
326 ret
= test_bit(prop
- EXTCON_PROP_CHG_MIN
, cable
->chg_bits
);
328 case EXTCON_TYPE_JACK
:
329 ret
= test_bit(prop
- EXTCON_PROP_JACK_MIN
, cable
->jack_bits
);
331 case EXTCON_TYPE_DISP
:
332 ret
= test_bit(prop
- EXTCON_PROP_DISP_MIN
, cable
->disp_bits
);
341 static void init_property(struct extcon_dev
*edev
, unsigned int id
, int index
)
343 unsigned int type
= extcon_info
[id
].type
;
344 struct extcon_cable
*cable
= &edev
->cables
[index
];
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
));
356 static ssize_t
state_show(struct device
*dev
, struct device_attribute
*attr
,
360 struct extcon_dev
*edev
= dev_get_drvdata(dev
);
362 if (edev
->max_supported
== 0)
363 return sprintf(buf
, "%u\n", edev
->state
);
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
)));
373 static DEVICE_ATTR_RO(state
);
375 static ssize_t
name_show(struct device
*dev
, struct device_attribute
*attr
,
378 struct extcon_dev
*edev
= dev_get_drvdata(dev
);
380 return sprintf(buf
, "%s\n", edev
->name
);
382 static DEVICE_ATTR_RO(name
);
384 static ssize_t
cable_name_show(struct device
*dev
,
385 struct device_attribute
*attr
, char *buf
)
387 struct extcon_cable
*cable
= container_of(attr
, struct extcon_cable
,
389 int i
= cable
->cable_index
;
391 return sprintf(buf
, "%s\n",
392 extcon_info
[cable
->edev
->supported_cable
[i
]].name
);
395 static ssize_t
cable_state_show(struct device
*dev
,
396 struct device_attribute
*attr
, char *buf
)
398 struct extcon_cable
*cable
= container_of(attr
, struct extcon_cable
,
401 int i
= cable
->cable_index
;
403 return sprintf(buf
, "%d\n",
404 extcon_get_state(cable
->edev
, cable
->edev
->supported_cable
[i
]));
408 * extcon_sync() - Synchronize the state for an external connector.
409 * @edev: the extcon device
411 * Note that this function send a notification in order to synchronize
412 * the state and property of an external connector.
414 * Returns 0 if success or error number if fail.
416 int extcon_sync(struct extcon_dev
*edev
, unsigned int id
)
431 index
= find_cable_index_by_id(edev
, id
);
435 spin_lock_irqsave(&edev
->lock
, flags
);
437 state
= !!(edev
->state
& BIT(index
));
440 * Call functions in a raw notifier chain for the specific one
441 * external connector.
443 raw_notifier_call_chain(&edev
->nh
[index
], state
, edev
);
446 * Call functions in a raw notifier chain for the all supported
447 * external connectors.
449 raw_notifier_call_chain(&edev
->nh_all
, state
, edev
);
451 /* This could be in interrupt handler */
452 prop_buf
= (char *)get_zeroed_page(GFP_ATOMIC
);
454 /* Unlock early before uevent */
455 spin_unlock_irqrestore(&edev
->lock
, flags
);
457 dev_err(&edev
->dev
, "out of memory in extcon_set_state\n");
458 kobject_uevent(&edev
->dev
.kobj
, KOBJ_CHANGE
);
463 length
= name_show(&edev
->dev
, NULL
, prop_buf
);
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
;
471 length
= state_show(&edev
->dev
, NULL
, prop_buf
);
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
;
478 envp
[env_offset
] = NULL
;
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
);
487 EXPORT_SYMBOL_GPL(extcon_sync
);
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
494 * Returns 0 if success or error number if fail.
496 int extcon_get_state(struct extcon_dev
*edev
, const unsigned int id
)
504 index
= find_cable_index_by_id(edev
, id
);
508 spin_lock_irqsave(&edev
->lock
, flags
);
509 state
= is_extcon_attached(edev
, index
);
510 spin_unlock_irqrestore(&edev
->lock
, flags
);
514 EXPORT_SYMBOL_GPL(extcon_get_state
);
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.
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().
527 * Returns 0 if success or error number if fail.
529 int extcon_set_state(struct extcon_dev
*edev
, unsigned int id
, bool state
)
537 index
= find_cable_index_by_id(edev
, id
);
541 spin_lock_irqsave(&edev
->lock
, flags
);
543 /* Check whether the external connector's state is changed. */
544 if (!is_extcon_changed(edev
, index
, state
))
547 if (check_mutually_exclusive(edev
,
548 (edev
->state
& ~BIT(index
)) | (state
& BIT(index
)))) {
554 * Initialize the value of extcon property before setting
555 * the detached state for an external connector.
558 init_property(edev
, id
, index
);
560 /* Update the state for an external connector. */
562 edev
->state
|= BIT(index
);
564 edev
->state
&= ~(BIT(index
));
566 spin_unlock_irqrestore(&edev
->lock
, flags
);
570 EXPORT_SYMBOL_GPL(extcon_set_state
);
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.
579 * Note that this function set the state of external connector
580 * and synchronize the state by sending a notification.
582 * Returns 0 if success or error number if fail.
584 int extcon_set_state_sync(struct extcon_dev
*edev
, unsigned int id
, bool state
)
589 index
= find_cable_index_by_id(edev
, id
);
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
);
600 ret
= extcon_set_state(edev
, id
, state
);
604 return extcon_sync(edev
, id
);
606 EXPORT_SYMBOL_GPL(extcon_set_state_sync
);
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
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.
620 * Returns 0 if success or error number if fail.
622 int extcon_get_property(struct extcon_dev
*edev
, unsigned int id
,
624 union extcon_property_value
*prop_val
)
626 struct extcon_cable
*cable
;
630 *prop_val
= (union extcon_property_value
)(0);
635 /* Check whether the property is supported or not */
636 if (!is_extcon_property_supported(id
, prop
))
639 /* Find the cable index of external connector by using id */
640 index
= find_cable_index_by_id(edev
, id
);
644 spin_lock_irqsave(&edev
->lock
, flags
);
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
);
653 * Check whether the external connector is attached.
654 * If external connector is detached, the user can not
655 * get the property value.
657 if (!is_extcon_attached(edev
, index
)) {
658 spin_unlock_irqrestore(&edev
->lock
, flags
);
662 cable
= &edev
->cables
[index
];
664 /* Get the property value according to extcon type */
666 case EXTCON_PROP_USB_MIN
... EXTCON_PROP_USB_MAX
:
667 *prop_val
= cable
->usb_propval
[prop
- EXTCON_PROP_USB_MIN
];
669 case EXTCON_PROP_CHG_MIN
... EXTCON_PROP_CHG_MAX
:
670 *prop_val
= cable
->chg_propval
[prop
- EXTCON_PROP_CHG_MIN
];
672 case EXTCON_PROP_JACK_MIN
... EXTCON_PROP_JACK_MAX
:
673 *prop_val
= cable
->jack_propval
[prop
- EXTCON_PROP_JACK_MIN
];
675 case EXTCON_PROP_DISP_MIN
... EXTCON_PROP_DISP_MAX
:
676 *prop_val
= cable
->disp_propval
[prop
- EXTCON_PROP_DISP_MIN
];
683 spin_unlock_irqrestore(&edev
->lock
, flags
);
687 EXPORT_SYMBOL_GPL(extcon_get_property
);
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
696 * Note that each property should be included in the list of supported
697 * properties according to the extcon type.
699 * Returns 0 if success or error number if fail.
701 int extcon_set_property(struct extcon_dev
*edev
, unsigned int id
,
703 union extcon_property_value prop_val
)
705 struct extcon_cable
*cable
;
712 /* Check whether the property is supported or not */
713 if (!is_extcon_property_supported(id
, prop
))
716 /* Find the cable index of external connector by using id */
717 index
= find_cable_index_by_id(edev
, id
);
721 spin_lock_irqsave(&edev
->lock
, flags
);
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
);
729 cable
= &edev
->cables
[index
];
731 /* Set the property value according to extcon type */
733 case EXTCON_PROP_USB_MIN
... EXTCON_PROP_USB_MAX
:
734 cable
->usb_propval
[prop
- EXTCON_PROP_USB_MIN
] = prop_val
;
736 case EXTCON_PROP_CHG_MIN
... EXTCON_PROP_CHG_MAX
:
737 cable
->chg_propval
[prop
- EXTCON_PROP_CHG_MIN
] = prop_val
;
739 case EXTCON_PROP_JACK_MIN
... EXTCON_PROP_JACK_MAX
:
740 cable
->jack_propval
[prop
- EXTCON_PROP_JACK_MIN
] = prop_val
;
742 case EXTCON_PROP_DISP_MIN
... EXTCON_PROP_DISP_MAX
:
743 cable
->disp_propval
[prop
- EXTCON_PROP_DISP_MIN
] = prop_val
;
750 spin_unlock_irqrestore(&edev
->lock
, flags
);
754 EXPORT_SYMBOL_GPL(extcon_set_property
);
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
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.
764 * Returns 0 if success or error number if fail.
766 int extcon_set_property_sync(struct extcon_dev
*edev
, unsigned int id
,
768 union extcon_property_value prop_val
)
772 ret
= extcon_set_property(edev
, id
, prop
, prop_val
);
776 return extcon_sync(edev
, id
);
778 EXPORT_SYMBOL_GPL(extcon_set_property_sync
);
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
787 * Returns 1 if the property is available or 0 if not available.
789 int extcon_get_property_capability(struct extcon_dev
*edev
, unsigned int id
,
797 /* Check whether the property is supported or not */
798 if (!is_extcon_property_supported(id
, prop
))
801 /* Find the cable index of external connector by using id */
802 index
= find_cable_index_by_id(edev
, id
);
806 return is_extcon_property_capability(edev
, id
, index
, prop
);
808 EXPORT_SYMBOL_GPL(extcon_get_property_capability
);
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
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.
821 * Returns 0 if success or error number if fail.
823 int extcon_set_property_capability(struct extcon_dev
*edev
, unsigned int id
,
826 struct extcon_cable
*cable
;
827 int index
, type
, ret
= 0;
832 /* Check whether the property is supported or not. */
833 if (!is_extcon_property_supported(id
, prop
))
836 /* Find the cable index of external connector by using id. */
837 index
= find_cable_index_by_id(edev
, id
);
841 type
= get_extcon_type(prop
);
845 cable
= &edev
->cables
[index
];
848 case EXTCON_TYPE_USB
:
849 __set_bit(prop
- EXTCON_PROP_USB_MIN
, cable
->usb_bits
);
851 case EXTCON_TYPE_CHG
:
852 __set_bit(prop
- EXTCON_PROP_CHG_MIN
, cable
->chg_bits
);
854 case EXTCON_TYPE_JACK
:
855 __set_bit(prop
- EXTCON_PROP_JACK_MIN
, cable
->jack_bits
);
857 case EXTCON_TYPE_DISP
:
858 __set_bit(prop
- EXTCON_PROP_DISP_MIN
, cable
->disp_bits
);
866 EXPORT_SYMBOL_GPL(extcon_set_property_capability
);
869 * extcon_get_extcon_dev() - Get the extcon device instance from the name.
870 * @extcon_name: the extcon name provided with extcon_dev_register()
872 * Return the pointer of extcon device if success or ERR_PTR(err) if fail.
874 struct extcon_dev
*extcon_get_extcon_dev(const char *extcon_name
)
876 struct extcon_dev
*sd
;
879 return ERR_PTR(-EINVAL
);
881 mutex_lock(&extcon_dev_list_lock
);
882 list_for_each_entry(sd
, &extcon_dev_list
, entry
) {
883 if (!strcmp(sd
->name
, extcon_name
))
888 mutex_unlock(&extcon_dev_list_lock
);
891 EXPORT_SYMBOL_GPL(extcon_get_extcon_dev
);
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
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.
904 * Returns 0 if success or error number if fail.
906 int extcon_register_notifier(struct extcon_dev
*edev
, unsigned int id
,
907 struct notifier_block
*nb
)
910 int ret
, idx
= -EINVAL
;
915 idx
= find_cable_index_by_id(edev
, id
);
919 spin_lock_irqsave(&edev
->lock
, flags
);
920 ret
= raw_notifier_chain_register(&edev
->nh
[idx
], nb
);
921 spin_unlock_irqrestore(&edev
->lock
, flags
);
925 EXPORT_SYMBOL_GPL(extcon_register_notifier
);
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
933 * Returns 0 if success or error number if fail.
935 int extcon_unregister_notifier(struct extcon_dev
*edev
, unsigned int id
,
936 struct notifier_block
*nb
)
944 idx
= find_cable_index_by_id(edev
, id
);
948 spin_lock_irqsave(&edev
->lock
, flags
);
949 ret
= raw_notifier_chain_unregister(&edev
->nh
[idx
], nb
);
950 spin_unlock_irqrestore(&edev
->lock
, flags
);
954 EXPORT_SYMBOL_GPL(extcon_unregister_notifier
);
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
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.
966 * Returns 0 if success or error number if fail.
968 int extcon_register_notifier_all(struct extcon_dev
*edev
,
969 struct notifier_block
*nb
)
977 spin_lock_irqsave(&edev
->lock
, flags
);
978 ret
= raw_notifier_chain_register(&edev
->nh_all
, nb
);
979 spin_unlock_irqrestore(&edev
->lock
, flags
);
983 EXPORT_SYMBOL_GPL(extcon_register_notifier_all
);
986 * extcon_unregister_notifier_all() - Unregister a notifier block from extcon.
987 * @edev: the extcon device
988 * @nb: a notifier block to be registered
990 * Returns 0 if success or error number if fail.
992 int extcon_unregister_notifier_all(struct extcon_dev
*edev
,
993 struct notifier_block
*nb
)
1001 spin_lock_irqsave(&edev
->lock
, flags
);
1002 ret
= raw_notifier_chain_unregister(&edev
->nh_all
, nb
);
1003 spin_unlock_irqrestore(&edev
->lock
, flags
);
1007 EXPORT_SYMBOL_GPL(extcon_unregister_notifier_all
);
1009 static struct attribute
*extcon_attrs
[] = {
1010 &dev_attr_state
.attr
,
1011 &dev_attr_name
.attr
,
1014 ATTRIBUTE_GROUPS(extcon
);
1016 static int create_extcon_class(void)
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
;
1028 static void extcon_dev_release(struct device
*dev
)
1032 static const char *muex_name
= "mutually_exclusive";
1033 static void dummy_sysfs_dev_release(struct device
*dev
)
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.
1042 * Note that this function allocates the memory for extcon device
1043 * and initialize default setting for the extcon device.
1045 * Returns the pointer memory of allocated extcon_dev if success
1046 * or ERR_PTR(err) if fail.
1048 struct extcon_dev
*extcon_dev_allocate(const unsigned int *supported_cable
)
1050 struct extcon_dev
*edev
;
1052 if (!supported_cable
)
1053 return ERR_PTR(-EINVAL
);
1055 edev
= kzalloc(sizeof(*edev
), GFP_KERNEL
);
1057 return ERR_PTR(-ENOMEM
);
1059 edev
->max_supported
= 0;
1060 edev
->supported_cable
= supported_cable
;
1066 * extcon_dev_free() - Free the memory of extcon device.
1067 * @edev: the extcon device
1069 void extcon_dev_free(struct extcon_dev
*edev
)
1073 EXPORT_SYMBOL_GPL(extcon_dev_free
);
1076 * extcon_dev_register() - Register an new extcon device
1077 * @edev: the extcon device to be registered
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
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.
1087 * Returns 0 if success or error number if fail.
1089 int extcon_dev_register(struct extcon_dev
*edev
)
1092 static atomic_t edev_no
= ATOMIC_INIT(-1);
1094 if (!extcon_class
) {
1095 ret
= create_extcon_class();
1100 if (!edev
|| !edev
->supported_cable
)
1103 for (; edev
->supported_cable
[index
] != EXTCON_NONE
; index
++);
1105 edev
->max_supported
= index
;
1106 if (index
> SUPPORTED_CABLE_MAX
) {
1108 "exceed the maximum number of supported cables\n");
1112 edev
->dev
.class = extcon_class
;
1113 edev
->dev
.release
= extcon_dev_release
;
1115 edev
->name
= dev_name(edev
->dev
.parent
);
1116 if (IS_ERR_OR_NULL(edev
->name
)) {
1118 "extcon device name is null\n");
1121 dev_set_name(&edev
->dev
, "extcon%lu",
1122 (unsigned long)atomic_inc_return(&edev_no
));
1124 if (edev
->max_supported
) {
1127 struct extcon_cable
*cable
;
1129 edev
->cables
= kzalloc(sizeof(struct extcon_cable
) *
1130 edev
->max_supported
, GFP_KERNEL
);
1131 if (!edev
->cables
) {
1133 goto err_sysfs_alloc
;
1135 for (index
= 0; index
< edev
->max_supported
; index
++) {
1136 cable
= &edev
->cables
[index
];
1138 snprintf(buf
, 10, "cable.%d", index
);
1139 str
= kzalloc(sizeof(char) * (strlen(buf
) + 1),
1142 for (index
--; index
>= 0; index
--) {
1143 cable
= &edev
->cables
[index
];
1144 kfree(cable
->attr_g
.name
);
1148 goto err_alloc_cables
;
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
;
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
;
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
;
1172 if (edev
->max_supported
&& edev
->mutually_exclusive
) {
1176 /* Count the size of mutually_exclusive array */
1177 for (index
= 0; edev
->mutually_exclusive
[index
]; index
++)
1180 edev
->attrs_muex
= kzalloc(sizeof(struct attribute
*) *
1181 (index
+ 1), GFP_KERNEL
);
1182 if (!edev
->attrs_muex
) {
1187 edev
->d_attrs_muex
= kzalloc(sizeof(struct device_attribute
) *
1189 if (!edev
->d_attrs_muex
) {
1191 kfree(edev
->attrs_muex
);
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),
1200 for (index
--; index
>= 0; index
--) {
1201 kfree(edev
->d_attrs_muex
[index
].attr
.
1204 kfree(edev
->d_attrs_muex
);
1205 kfree(edev
->attrs_muex
);
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
]
1216 edev
->attr_g_muex
.name
= muex_name
;
1217 edev
->attr_g_muex
.attrs
= edev
->attrs_muex
;
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
) {
1227 goto err_alloc_groups
;
1230 edev
->extcon_dev_type
.name
= dev_name(&edev
->dev
);
1231 edev
->extcon_dev_type
.release
= dummy_sysfs_dev_release
;
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
] =
1240 edev
->dev
.type
= &edev
->extcon_dev_type
;
1243 ret
= device_register(&edev
->dev
);
1245 put_device(&edev
->dev
);
1249 spin_lock_init(&edev
->lock
);
1250 edev
->nh
= devm_kcalloc(&edev
->dev
, edev
->max_supported
,
1251 sizeof(*edev
->nh
), GFP_KERNEL
);
1257 for (index
= 0; index
< edev
->max_supported
; index
++)
1258 RAW_INIT_NOTIFIER_HEAD(&edev
->nh
[index
]);
1260 RAW_INIT_NOTIFIER_HEAD(&edev
->nh_all
);
1262 dev_set_drvdata(&edev
->dev
, edev
);
1265 mutex_lock(&extcon_dev_list_lock
);
1266 list_add(&edev
->entry
, &extcon_dev_list
);
1267 mutex_unlock(&extcon_dev_list_lock
);
1272 if (edev
->max_supported
)
1273 kfree(edev
->extcon_dev_type
.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
);
1282 for (index
= 0; index
< edev
->max_supported
; index
++)
1283 kfree(edev
->cables
[index
].attr_g
.name
);
1285 if (edev
->max_supported
)
1286 kfree(edev
->cables
);
1290 EXPORT_SYMBOL_GPL(extcon_dev_register
);
1293 * extcon_dev_unregister() - Unregister the extcon device.
1294 * @edev: the extcon device to be unregistered.
1296 * Note that this does not call kfree(edev) because edev was not allocated
1299 void extcon_dev_unregister(struct extcon_dev
*edev
)
1306 mutex_lock(&extcon_dev_list_lock
);
1307 list_del(&edev
->entry
);
1308 mutex_unlock(&extcon_dev_list_lock
);
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
));
1316 device_unregister(&edev
->dev
);
1318 if (edev
->mutually_exclusive
&& edev
->max_supported
) {
1319 for (index
= 0; edev
->mutually_exclusive
[index
];
1321 kfree(edev
->d_attrs_muex
[index
].attr
.name
);
1322 kfree(edev
->d_attrs_muex
);
1323 kfree(edev
->attrs_muex
);
1326 for (index
= 0; index
< edev
->max_supported
; index
++)
1327 kfree(edev
->cables
[index
].attr_g
.name
);
1329 if (edev
->max_supported
) {
1330 kfree(edev
->extcon_dev_type
.groups
);
1331 kfree(edev
->cables
);
1334 put_device(&edev
->dev
);
1336 EXPORT_SYMBOL_GPL(extcon_dev_unregister
);
1340 * extcon_get_edev_by_phandle - Get the extcon device from devicetree.
1341 * @dev : the instance to the given device
1342 * @index : the index into list of extcon_dev
1344 * Return the pointer of extcon device if success or ERR_PTR(err) if fail.
1346 struct extcon_dev
*extcon_get_edev_by_phandle(struct device
*dev
, int index
)
1348 struct device_node
*node
;
1349 struct extcon_dev
*edev
;
1352 return ERR_PTR(-EINVAL
);
1354 if (!dev
->of_node
) {
1355 dev_dbg(dev
, "device does not have a device node entry\n");
1356 return ERR_PTR(-EINVAL
);
1359 node
= of_parse_phandle(dev
->of_node
, "extcon", index
);
1361 dev_dbg(dev
, "failed to get phandle in %pOF node\n",
1363 return ERR_PTR(-ENODEV
);
1366 mutex_lock(&extcon_dev_list_lock
);
1367 list_for_each_entry(edev
, &extcon_dev_list
, entry
) {
1368 if (edev
->dev
.parent
&& edev
->dev
.parent
->of_node
== node
) {
1369 mutex_unlock(&extcon_dev_list_lock
);
1374 mutex_unlock(&extcon_dev_list_lock
);
1377 return ERR_PTR(-EPROBE_DEFER
);
1380 struct extcon_dev
*extcon_get_edev_by_phandle(struct device
*dev
, int index
)
1382 return ERR_PTR(-ENOSYS
);
1384 #endif /* CONFIG_OF */
1385 EXPORT_SYMBOL_GPL(extcon_get_edev_by_phandle
);
1388 * extcon_get_edev_name() - Get the name of the extcon device.
1389 * @edev: the extcon device
1391 const char *extcon_get_edev_name(struct extcon_dev
*edev
)
1393 return !edev
? NULL
: edev
->name
;
1396 static int __init
extcon_class_init(void)
1398 return create_extcon_class();
1400 module_init(extcon_class_init
);
1402 static void __exit
extcon_class_exit(void)
1404 class_destroy(extcon_class
);
1406 module_exit(extcon_class_exit
);
1408 MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>");
1409 MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
1410 MODULE_DESCRIPTION("External Connector (extcon) framework");
1411 MODULE_LICENSE("GPL v2");