/* *  drivers/extcon/extcon_class.c * *  External connector (extcon) class driver * * 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/slab.h>#include <linux/sysfs.h> /* * extcon_cable_name suggests the standard cable names for commonly used * cable types. * * However, please do not use extcon_cable_name directly for extcon_dev * struct's supported_cable pointer unless your device really supports * every single port-type of the following cable names. Please choose cable * names that are actually used in your extcon device. */const char extcon_cable_name[][CABLE_NAME_MAX + 1] = {	[EXTCON_USB]		= "USB",	[EXTCON_USB_HOST]	= "USB-Host",	[EXTCON_TA]		= "TA",	[EXTCON_FAST_CHARGER]	= "Fast-charger",	[EXTCON_SLOW_CHARGER]	= "Slow-charger",	[EXTCON_CHARGE_DOWNSTREAM]	= "Charge-downstream",	[EXTCON_HDMI]		= "HDMI",	[EXTCON_MHL]		= "MHL",	[EXTCON_DVI]		= "DVI",	[EXTCON_VGA]		= "VGA",	[EXTCON_DOCK]		= "Dock",	[EXTCON_LINE_IN]	= "Line-in",	[EXTCON_LINE_OUT]	= "Line-out",	[EXTCON_MIC_IN]		= "Microphone",	[EXTCON_HEADPHONE_OUT]	= "Headphone",	[EXTCON_SPDIF_IN]	= "SPDIF-in",	[EXTCON_SPDIF_OUT]	= "SPDIF-out",	[EXTCON_VIDEO_IN]	= "Video-in",	[EXTCON_VIDEO_OUT]	= "Video-out",	[EXTCON_MECHANICAL]	= "Mechanical",}; 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 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 < SUPPORTED_CABLE_MAX; i++) {		if (!edev->supported_cable[i])			break;		count += sprintf(buf + count, "%s=%d\n",				 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); 	/* Optional callback given by the user */	if (edev->print_name) {		int ret = edev->print_name(edev, buf);		if (ret >= 0)			return ret;	} 	return sprintf(buf, "%s\n", dev_name(&edev->dev));}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); 	return sprintf(buf, "%s\n",		       cable->edev->supported_cable[cable->cable_index]);} 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); 	return sprintf(buf, "%d\n",		       extcon_get_cable_state_(cable->edev,					       cable->cable_index));} /** * 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;	unsigned long flags; 	spin_lock_irqsave(&edev->lock, flags); 	if (edev->state != ((edev->state & ~mask) | (state & mask))) {		u32 old_state = edev->state; 		if (check_mutually_exclusive(edev, (edev->state & ~mask) |						   (state & mask))) {			spin_unlock_irqrestore(&edev->lock, flags);			return -EPERM;		} 		edev->state &= ~mask;		edev->state |= state & mask; 		raw_notifier_call_chain(&edev->nh, old_state, 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_find_cable_index() - Get the cable index based on the cable name. * @edev:	the extcon device that has the cable. * @cable_name:	cable name to be searched. * * Note that accessing a cable state based on cable_index is faster than * cable_name because using cable_name induces a loop with strncmp(). * Thus, when get/set_cable_state is repeatedly used, using cable_index * is recommended. */int extcon_find_cable_index(struct extcon_dev *edev, const char *cable_name){	int i; 	if (edev->supported_cable) {		for (i = 0; edev->supported_cable[i]; i++) {			if (!strncmp(edev->supported_cable[i],				cable_name, CABLE_NAME_MAX))				return i;		}	} 	return -EINVAL;}EXPORT_SYMBOL_GPL(extcon_find_cable_index); /** * extcon_get_cable_state_() - Get the status of a specific cable. * @edev:	the extcon device that has the cable. * @index:	cable index that can be retrieved by extcon_find_cable_index(). */int extcon_get_cable_state_(struct extcon_dev *edev, int index){	if (index < 0 || (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){	return extcon_get_cable_state_(edev, extcon_find_cable_index						(edev, cable_name));}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. * @index:		cable index that can be retrieved by *			extcon_find_cable_index(). * @cable_state:	the new cable status. The default semantics is *			true: attached / false: detached. */int extcon_set_cable_state_(struct extcon_dev *edev,			int index, bool cable_state){	u32 state; 	if (index < 0 || (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){	return extcon_set_cable_state_(edev, extcon_find_cable_index					(edev, cable_name), 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); static int _call_per_cable(struct notifier_block *nb, unsigned long val,			   void *ptr){	struct extcon_specific_cable_nb *obj = container_of(nb,			struct extcon_specific_cable_nb, internal_nb);	struct extcon_dev *edev = ptr; 	if ((val & (1 << obj->cable_index)) !=	    (edev->state & (1 << obj->cable_index))) {		bool cable_state = true; 		obj->previous_value = val; 		if (val & (1 << obj->cable_index))			cable_state = false; 		return obj->user_nb->notifier_call(obj->user_nb,				cable_state, ptr);	} 	return NOTIFY_OK;} /** * 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){	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 = extcon_find_cable_index(obj->edev,							  cable_name);		if (obj->cable_index < 0)			return obj->cable_index; 		obj->user_nb = nb; 		obj->internal_nb.notifier_call = _call_per_cable; 		return raw_notifier_chain_register(&obj->edev->nh,						  &obj->internal_nb);	} else {		struct class_dev_iter iter;		struct extcon_dev *extd;		struct device *dev; 		if (!extcon_class)			return -ENODEV;		class_dev_iter_init(&iter, extcon_class, NULL, NULL);		while ((dev = class_dev_iter_next(&iter))) {			extd = dev_get_drvdata(dev); 			if (extcon_find_cable_index(extd, cable_name) < 0)				continue; 			class_dev_iter_exit(&iter);			return extcon_register_interest(obj, extd->name,						cable_name, nb);		} 		return -ENODEV;	}}EXPORT_SYMBOL_GPL(extcon_register_interest); /** * extcon_unregister_interest() - Unregister the notifier registered by *				  extcon_register_interest(). * @obj:	the extcon_specific_cable_nb object returned by *		extcon_register_interest(). */int extcon_unregister_interest(struct extcon_specific_cable_nb *obj){	if (!obj)		return -EINVAL; 	return raw_notifier_chain_unregister(&obj->edev->nh, &obj->internal_nb);

Lines 1–500 of 840. Load more