/* *  drivers/extcon/extcon.c - External Connector (extcon) framework. * *  External connector (extcon) class driver * * Copyright (C) 2015 Samsung Electronics * Author: Chanwoo Choi <cw00.choi@samsung.com> * * Copyright (C) 2012 Samsung Electronics * Author: Donggeun Kim <dg77.kim@samsung.com> * Author: MyungJoo Ham <myungjoo.ham@samsung.com> * * based on android/drivers/switch/switch_class.c * Copyright (C) 2008 Google, Inc. * Author: Mike Lockwood <lockwood@android.com> * * This software is licensed under the terms of the GNU General Public * License version 2, as published by the Free Software Foundation, and * may be copied, distributed, and modified under those terms. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the * GNU General Public License for more details. */ #include <linux/module.h>#include <linux/types.h>#include <linux/init.h>#include <linux/device.h>#include <linux/fs.h>#include <linux/err.h>#include <linux/extcon.h>#include <linux/of.h>#include <linux/slab.h>#include <linux/sysfs.h> #define SUPPORTED_CABLE_MAX	32#define CABLE_NAME_MAX		30 static const char *extcon_name[] =  {	[EXTCON_NONE]		= "NONE", 	/* USB external connector */	[EXTCON_USB]		= "USB",	[EXTCON_USB_HOST]	= "USB-HOST", 	/* Charger external connector */	[EXTCON_TA]		= "TA",	[EXTCON_FAST_CHARGER]	= "FAST-CHARGER",	[EXTCON_SLOW_CHARGER]	= "SLOW-CHARGER",	[EXTCON_CHARGE_DOWNSTREAM] = "CHARGE-DOWNSTREAM", 	/* Audio/Video external connector */	[EXTCON_LINE_IN]	= "LINE-IN",	[EXTCON_LINE_OUT]	= "LINE-OUT",	[EXTCON_MICROPHONE]	= "MICROPHONE",	[EXTCON_HEADPHONE]	= "HEADPHONE", 	[EXTCON_HDMI]		= "HDMI",	[EXTCON_MHL]		= "MHL",	[EXTCON_DVI]		= "DVI",	[EXTCON_VGA]		= "VGA",	[EXTCON_SPDIF_IN]	= "SPDIF-IN",	[EXTCON_SPDIF_OUT]	= "SPDIF-OUT",	[EXTCON_VIDEO_IN]	= "VIDEO-IN",	[EXTCON_VIDEO_OUT]	= "VIDEO-OUT", 	/* Etc external connector */	[EXTCON_DOCK]		= "DOCK",	[EXTCON_JIG]		= "JIG",	[EXTCON_MECHANICAL]	= "MECHANICAL", 	NULL,}; static struct class *extcon_class;#if defined(CONFIG_ANDROID)static struct class_compat *switch_class;#endif /* CONFIG_ANDROID */ static LIST_HEAD(extcon_dev_list);static DEFINE_MUTEX(extcon_dev_list_lock); /** * check_mutually_exclusive - Check if new_state violates mutually_exclusive *			      condition. * @edev:	the extcon device * @new_state:	new cable attach status for @edev * * Returns 0 if nothing violates. Returns the index + 1 for the first * violated condition. */static int check_mutually_exclusive(struct extcon_dev *edev, u32 new_state){	int i = 0; 	if (!edev->mutually_exclusive)		return 0; 	for (i = 0; edev->mutually_exclusive[i]; i++) {		int weight;		u32 correspondants = new_state & edev->mutually_exclusive[i]; 		/* calculate the total number of bits set */		weight = hweight32(correspondants);		if (weight > 1)			return i + 1;	} 	return 0;} static int find_cable_index_by_id(struct extcon_dev *edev, const unsigned int id){	int i; 	/* Find the the index of extcon cable in edev->supported_cable */	for (i = 0; i < edev->max_supported; i++) {		if (edev->supported_cable[i] == id)			return i;	} 	return -EINVAL;} static int find_cable_id_by_name(struct extcon_dev *edev, const char *name){	unsigned int id = -EINVAL;	int i = 0; 	/* Find the id of extcon cable */	while (extcon_name[i]) {		if (!strncmp(extcon_name[i], name, CABLE_NAME_MAX)) {			id = i;			break;		}		i++;	} 	return id;} static int find_cable_index_by_name(struct extcon_dev *edev, const char *name){	unsigned int id; 	if (edev->max_supported == 0)		return -EINVAL; 	/* Find the the number of extcon cable */	id = find_cable_id_by_name(edev, name);	if (id < 0)		return id; 	return find_cable_index_by_id(edev, id);} static bool is_extcon_changed(u32 prev, u32 new, int idx, bool *attached){	if (((prev >> idx) & 0x1) != ((new >> idx) & 0x1)) {		*attached = new ? true : false;		return true;	} 	return false;} static ssize_t state_show(struct device *dev, struct device_attribute *attr,			  char *buf){	int i, count = 0;	struct extcon_dev *edev = dev_get_drvdata(dev); 	if (edev->print_state) {		int ret = edev->print_state(edev, buf); 		if (ret >= 0)			return ret;		/* Use default if failed */	} 	if (edev->max_supported == 0)		return sprintf(buf, "%u\n", edev->state); 	for (i = 0; i < edev->max_supported; i++) {		count += sprintf(buf + count, "%s=%d\n",				extcon_name[edev->supported_cable[i]],				 !!(edev->state & (1 << i)));	} 	return count;} static ssize_t state_store(struct device *dev, struct device_attribute *attr,			   const char *buf, size_t count){	u32 state;	ssize_t ret = 0;	struct extcon_dev *edev = dev_get_drvdata(dev); 	ret = sscanf(buf, "0x%x", &state);	if (ret == 0)		ret = -EINVAL;	else		ret = extcon_set_state(edev, state); 	if (ret < 0)		return ret; 	return count;}static DEVICE_ATTR_RW(state); static ssize_t name_show(struct device *dev, struct device_attribute *attr,		char *buf){	struct extcon_dev *edev = dev_get_drvdata(dev); 	return sprintf(buf, "%s\n", edev->name);}static DEVICE_ATTR_RO(name); static ssize_t cable_name_show(struct device *dev,			       struct device_attribute *attr, char *buf){	struct extcon_cable *cable = container_of(attr, struct extcon_cable,						  attr_name);	int i = cable->cable_index; 	return sprintf(buf, "%s\n",			extcon_name[cable->edev->supported_cable[i]]);} static ssize_t cable_state_show(struct device *dev,				struct device_attribute *attr, char *buf){	struct extcon_cable *cable = container_of(attr, struct extcon_cable,						  attr_state); 	int i = cable->cable_index; 	return sprintf(buf, "%d\n",		       extcon_get_cable_state_(cable->edev,					       cable->edev->supported_cable[i]));} /** * extcon_update_state() - Update the cable attach states of the extcon device *			   only for the masked bits. * @edev:	the extcon device * @mask:	the bit mask to designate updated bits. * @state:	new cable attach status for @edev * * Changing the state sends uevent with environment variable containing * the name of extcon device (envp[0]) and the state output (envp[1]). * Tizen uses this format for extcon device to get events from ports. * Android uses this format as well. * * Note that the notifier provides which bits are changed in the state * variable with the val parameter (second) to the callback. */int extcon_update_state(struct extcon_dev *edev, u32 mask, u32 state){	char name_buf[120];	char state_buf[120];	char *prop_buf;	char *envp[3];	int env_offset = 0;	int length;	int index;	unsigned long flags;	bool attached; 	spin_lock_irqsave(&edev->lock, flags); 	if (edev->state != ((edev->state & ~mask) | (state & mask))) {		u32 old_state; 		if (check_mutually_exclusive(edev, (edev->state & ~mask) |						   (state & mask))) {			spin_unlock_irqrestore(&edev->lock, flags);			return -EPERM;		} 		old_state = edev->state;		edev->state &= ~mask;		edev->state |= state & mask; 		for (index = 0; index < edev->max_supported; index++) {			if (is_extcon_changed(old_state, edev->state, index,					      &attached))				raw_notifier_call_chain(&edev->nh[index],							attached, edev);		} 		/* This could be in interrupt handler */		prop_buf = (char *)get_zeroed_page(GFP_ATOMIC);		if (prop_buf) {			length = name_show(&edev->dev, NULL, prop_buf);			if (length > 0) {				if (prop_buf[length - 1] == '\n')					prop_buf[length - 1] = 0;				snprintf(name_buf, sizeof(name_buf),					"NAME=%s", prop_buf);				envp[env_offset++] = name_buf;			}			length = state_show(&edev->dev, NULL, prop_buf);			if (length > 0) {				if (prop_buf[length - 1] == '\n')					prop_buf[length - 1] = 0;				snprintf(state_buf, sizeof(state_buf),					"STATE=%s", prop_buf);				envp[env_offset++] = state_buf;			}			envp[env_offset] = NULL;			/* Unlock early before uevent */			spin_unlock_irqrestore(&edev->lock, flags); 			kobject_uevent_env(&edev->dev.kobj, KOBJ_CHANGE, envp);			free_page((unsigned long)prop_buf);		} else {			/* Unlock early before uevent */			spin_unlock_irqrestore(&edev->lock, flags); 			dev_err(&edev->dev, "out of memory in extcon_set_state\n");			kobject_uevent(&edev->dev.kobj, KOBJ_CHANGE);		}	} else {		/* No changes */		spin_unlock_irqrestore(&edev->lock, flags);	} 	return 0;}EXPORT_SYMBOL_GPL(extcon_update_state); /** * extcon_set_state() - Set the cable attach states of the extcon device. * @edev:	the extcon device * @state:	new cable attach status for @edev * * Note that notifier provides which bits are changed in the state * variable with the val parameter (second) to the callback. */int extcon_set_state(struct extcon_dev *edev, u32 state){	return extcon_update_state(edev, 0xffffffff, state);}EXPORT_SYMBOL_GPL(extcon_set_state); /** * extcon_get_cable_state_() - Get the status of a specific cable. * @edev:	the extcon device that has the cable. * @id:		the unique id of each external connector in extcon enumeration. */int extcon_get_cable_state_(struct extcon_dev *edev, const unsigned int id){	int index; 	index = find_cable_index_by_id(edev, id);	if (index < 0)		return index; 	if (edev->max_supported && edev->max_supported <= index)		return -EINVAL; 	return !!(edev->state & (1 << index));}EXPORT_SYMBOL_GPL(extcon_get_cable_state_); /** * extcon_get_cable_state() - Get the status of a specific cable. * @edev:	the extcon device that has the cable. * @cable_name:	cable name. * * Note that this is slower than extcon_get_cable_state_. */int extcon_get_cable_state(struct extcon_dev *edev, const char *cable_name){	unsigned int id; 	id = find_cable_id_by_name(edev, cable_name);	if (id < 0)		return id; 	return extcon_get_cable_state_(edev, id);}EXPORT_SYMBOL_GPL(extcon_get_cable_state); /** * extcon_set_cable_state_() - Set the status of a specific cable. * @edev:		the extcon device that has the cable. * @id:			the unique id of each external connector *			in extcon enumeration. * @state:		the new cable status. The default semantics is *			true: attached / false: detached. */int extcon_set_cable_state_(struct extcon_dev *edev, unsigned int id,				bool cable_state){	u32 state;	int index; 	index = find_cable_index_by_id(edev, id);	if (index < 0)		return index; 	if (edev->max_supported && edev->max_supported <= index)		return -EINVAL; 	state = cable_state ? (1 << index) : 0;	return extcon_update_state(edev, 1 << index, state);}EXPORT_SYMBOL_GPL(extcon_set_cable_state_); /** * extcon_set_cable_state() - Set the status of a specific cable. * @edev:		the extcon device that has the cable. * @cable_name:		cable name. * @cable_state:	the new cable status. The default semantics is *			true: attached / false: detached. * * Note that this is slower than extcon_set_cable_state_. */int extcon_set_cable_state(struct extcon_dev *edev,			const char *cable_name, bool cable_state){	unsigned int id; 	id = find_cable_id_by_name(edev, cable_name);	if (id < 0)		return id; 	return extcon_set_cable_state_(edev, id, cable_state);}EXPORT_SYMBOL_GPL(extcon_set_cable_state); /** * extcon_get_extcon_dev() - Get the extcon device instance from the name * @extcon_name:	The extcon name provided with extcon_dev_register() */struct extcon_dev *extcon_get_extcon_dev(const char *extcon_name){	struct extcon_dev *sd; 	mutex_lock(&extcon_dev_list_lock);	list_for_each_entry(sd, &extcon_dev_list, entry) {		if (!strcmp(sd->name, extcon_name))			goto out;	}	sd = NULL;out:	mutex_unlock(&extcon_dev_list_lock);	return sd;}EXPORT_SYMBOL_GPL(extcon_get_extcon_dev); /** * extcon_register_interest() - Register a notifier for a state change of a *				specific cable, not an entier set of cables of a *				extcon device. * @obj:		an empty extcon_specific_cable_nb object to be returned. * @extcon_name:	the name of extcon device. *			if NULL, extcon_register_interest will register *			every cable with the target cable_name given. * @cable_name:		the target cable name. * @nb:			the notifier block to get notified. * * Provide an empty extcon_specific_cable_nb. extcon_register_interest() sets * the struct for you. * * extcon_register_interest is a helper function for those who want to get * notification for a single specific cable's status change. If a user wants * to get notification for any changes of all cables of a extcon device, * he/she should use the general extcon_register_notifier(). * * Note that the second parameter given to the callback of nb (val) is * "old_state", not the current state. The current state can be retrieved * by looking at the third pameter (edev pointer)'s state value. */int extcon_register_interest(struct extcon_specific_cable_nb *obj,			     const char *extcon_name, const char *cable_name,			     struct notifier_block *nb){	unsigned long flags;	int ret; 	if (!obj || !cable_name || !nb)		return -EINVAL; 	if (extcon_name) {		obj->edev = extcon_get_extcon_dev(extcon_name);		if (!obj->edev)			return -ENODEV; 		obj->cable_index = find_cable_index_by_name(obj->edev,							cable_name);		if (obj->cable_index < 0)			return obj->cable_index;

Lines 1–500 of 1129. Load more