/* * Copyright (C) 2006 - 2007 Ivo van Doorn * Copyright (C) 2007 Dmitry Torokhov * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the * Free Software Foundation, Inc., * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include <linux/kernel.h>#include <linux/module.h>#include <linux/init.h>#include <linux/workqueue.h>#include <linux/capability.h>#include <linux/list.h>#include <linux/mutex.h>#include <linux/rfkill.h> /* Get declaration of rfkill_switch_all() to shut up sparse. */#include "rfkill-input.h"  MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>");MODULE_VERSION("1.0");MODULE_DESCRIPTION("RF switch support");MODULE_LICENSE("GPL"); static LIST_HEAD(rfkill_list);	/* list of registered rf switches */static DEFINE_MUTEX(rfkill_global_mutex); static unsigned int rfkill_default_state = RFKILL_STATE_UNBLOCKED;module_param_named(default_state, rfkill_default_state, uint, 0444);MODULE_PARM_DESC(default_state,		 "Default initial state for all radio types, 0 = radio off"); struct rfkill_gsw_state {	enum rfkill_state current_state;	enum rfkill_state default_state;}; static struct rfkill_gsw_state rfkill_global_states[RFKILL_TYPE_MAX];static unsigned long rfkill_states_lockdflt[BITS_TO_LONGS(RFKILL_TYPE_MAX)];static bool rfkill_epo_lock_active;  #ifdef CONFIG_RFKILL_LEDSstatic void rfkill_led_trigger(struct rfkill *rfkill,			       enum rfkill_state state){	struct led_trigger *led = &rfkill->led_trigger; 	if (!led->name)		return;	if (state != RFKILL_STATE_UNBLOCKED)		led_trigger_event(led, LED_OFF);	else		led_trigger_event(led, LED_FULL);} static void rfkill_led_trigger_activate(struct led_classdev *led){	struct rfkill *rfkill = container_of(led->trigger,			struct rfkill, led_trigger); 	rfkill_led_trigger(rfkill, rfkill->state);}#endif /* CONFIG_RFKILL_LEDS */ static void rfkill_uevent(struct rfkill *rfkill){	kobject_uevent(&rfkill->dev.kobj, KOBJ_CHANGE);} static void update_rfkill_state(struct rfkill *rfkill){	enum rfkill_state newstate, oldstate; 	if (rfkill->get_state) {		mutex_lock(&rfkill->mutex);		if (!rfkill->get_state(rfkill->data, &newstate)) {			oldstate = rfkill->state;			rfkill->state = newstate;			if (oldstate != newstate)				rfkill_uevent(rfkill);		}		mutex_unlock(&rfkill->mutex);	}} /** * rfkill_toggle_radio - wrapper for toggle_radio hook * @rfkill: the rfkill struct to use * @force: calls toggle_radio even if cache says it is not needed, *	and also makes sure notifications of the state will be *	sent even if it didn't change * @state: the new state to call toggle_radio() with * * Calls rfkill->toggle_radio, enforcing the API for toggle_radio * calls and handling all the red tape such as issuing notifications * if the call is successful. * * Suspended devices are not touched at all, and -EAGAIN is returned. * * Note that the @force parameter cannot override a (possibly cached) * state of RFKILL_STATE_HARD_BLOCKED.  Any device making use of * RFKILL_STATE_HARD_BLOCKED implements either get_state() or * rfkill_force_state(), so the cache either is bypassed or valid. * * Note that we do call toggle_radio for RFKILL_STATE_SOFT_BLOCKED * even if the radio is in RFKILL_STATE_HARD_BLOCKED state, so as to * give the driver a hint that it should double-BLOCK the transmitter. * * Caller must have acquired rfkill->mutex. */static int rfkill_toggle_radio(struct rfkill *rfkill,				enum rfkill_state state,				int force){	int retval = 0;	enum rfkill_state oldstate, newstate; 	if (unlikely(rfkill->dev.power.power_state.event & PM_EVENT_SLEEP))		return -EBUSY; 	oldstate = rfkill->state; 	if (rfkill->get_state && !force &&	    !rfkill->get_state(rfkill->data, &newstate))		rfkill->state = newstate; 	switch (state) {	case RFKILL_STATE_HARD_BLOCKED:		/* typically happens when refreshing hardware state,		 * such as on resume */		state = RFKILL_STATE_SOFT_BLOCKED;		break;	case RFKILL_STATE_UNBLOCKED:		/* force can't override this, only rfkill_force_state() can */		if (rfkill->state == RFKILL_STATE_HARD_BLOCKED)			return -EPERM;		break;	case RFKILL_STATE_SOFT_BLOCKED:		/* nothing to do, we want to give drivers the hint to double		 * BLOCK even a transmitter that is already in state		 * RFKILL_STATE_HARD_BLOCKED */		break;	default:		WARN(1, KERN_WARNING			"rfkill: illegal state %d passed as parameter "			"to rfkill_toggle_radio\n", state);		return -EINVAL;	} 	if (force || state != rfkill->state) {		retval = rfkill->toggle_radio(rfkill->data, state);		/* never allow a HARD->SOFT downgrade! */		if (!retval && rfkill->state != RFKILL_STATE_HARD_BLOCKED)			rfkill->state = state;	} 	if (force || rfkill->state != oldstate)		rfkill_uevent(rfkill); 	return retval;} /** * __rfkill_switch_all - Toggle state of all switches of given type * @type: type of interfaces to be affected * @state: the new state * * This function toggles the state of all switches of given type, * unless a specific switch is claimed by userspace (in which case, * that switch is left alone) or suspended. * * Caller must have acquired rfkill_global_mutex. */static void __rfkill_switch_all(const enum rfkill_type type,				const enum rfkill_state state){	struct rfkill *rfkill; 	if (WARN((state >= RFKILL_STATE_MAX || type >= RFKILL_TYPE_MAX),			KERN_WARNING			"rfkill: illegal state %d or type %d "			"passed as parameter to __rfkill_switch_all\n",			state, type))		return; 	rfkill_global_states[type].current_state = state;	list_for_each_entry(rfkill, &rfkill_list, node) {		if ((!rfkill->user_claim) && (rfkill->type == type)) {			mutex_lock(&rfkill->mutex);			rfkill_toggle_radio(rfkill, state, 0);			mutex_unlock(&rfkill->mutex);		}	}} /** * rfkill_switch_all - Toggle state of all switches of given type * @type: type of interfaces to be affected * @state: the new state * * Acquires rfkill_global_mutex and calls __rfkill_switch_all(@type, @state). * Please refer to __rfkill_switch_all() for details. * * Does nothing if the EPO lock is active. */void rfkill_switch_all(enum rfkill_type type, enum rfkill_state state){	mutex_lock(&rfkill_global_mutex);	if (!rfkill_epo_lock_active)		__rfkill_switch_all(type, state);	mutex_unlock(&rfkill_global_mutex);}EXPORT_SYMBOL(rfkill_switch_all); /** * rfkill_epo - emergency power off all transmitters * * This kicks all non-suspended rfkill devices to RFKILL_STATE_SOFT_BLOCKED, * ignoring everything in its path but rfkill_global_mutex and rfkill->mutex. * * The global state before the EPO is saved and can be restored later * using rfkill_restore_states(). */void rfkill_epo(void){	struct rfkill *rfkill;	int i; 	mutex_lock(&rfkill_global_mutex); 	rfkill_epo_lock_active = true;	list_for_each_entry(rfkill, &rfkill_list, node) {		mutex_lock(&rfkill->mutex);		rfkill_toggle_radio(rfkill, RFKILL_STATE_SOFT_BLOCKED, 1);		mutex_unlock(&rfkill->mutex);	}	for (i = 0; i < RFKILL_TYPE_MAX; i++) {		rfkill_global_states[i].default_state =				rfkill_global_states[i].current_state;		rfkill_global_states[i].current_state =				RFKILL_STATE_SOFT_BLOCKED;	}	mutex_unlock(&rfkill_global_mutex);}EXPORT_SYMBOL_GPL(rfkill_epo); /** * rfkill_restore_states - restore global states * * Restore (and sync switches to) the global state from the * states in rfkill_default_states.  This can undo the effects of * a call to rfkill_epo(). */void rfkill_restore_states(void){	int i; 	mutex_lock(&rfkill_global_mutex); 	rfkill_epo_lock_active = false;	for (i = 0; i < RFKILL_TYPE_MAX; i++)		__rfkill_switch_all(i, rfkill_global_states[i].default_state);	mutex_unlock(&rfkill_global_mutex);}EXPORT_SYMBOL_GPL(rfkill_restore_states); /** * rfkill_remove_epo_lock - unlock state changes * * Used by rfkill-input manually unlock state changes, when * the EPO switch is deactivated. */void rfkill_remove_epo_lock(void){	mutex_lock(&rfkill_global_mutex);	rfkill_epo_lock_active = false;	mutex_unlock(&rfkill_global_mutex);}EXPORT_SYMBOL_GPL(rfkill_remove_epo_lock); /** * rfkill_is_epo_lock_active - returns true EPO is active * * Returns 0 (false) if there is NOT an active EPO contidion, * and 1 (true) if there is an active EPO contition, which * locks all radios in one of the BLOCKED states. * * Can be called in atomic context. */bool rfkill_is_epo_lock_active(void){	return rfkill_epo_lock_active;}EXPORT_SYMBOL_GPL(rfkill_is_epo_lock_active); /** * rfkill_get_global_state - returns global state for a type * @type: the type to get the global state of * * Returns the current global state for a given wireless * device type. */enum rfkill_state rfkill_get_global_state(const enum rfkill_type type){	return rfkill_global_states[type].current_state;}EXPORT_SYMBOL_GPL(rfkill_get_global_state); /** * rfkill_force_state - Force the internal rfkill radio state * @rfkill: pointer to the rfkill class to modify. * @state: the current radio state the class should be forced to. * * This function updates the internal state of the radio cached * by the rfkill class.  It should be used when the driver gets * a notification by the firmware/hardware of the current *real* * state of the radio rfkill switch. * * Devices which are subject to external changes on their rfkill * state (such as those caused by a hardware rfkill line) MUST * have their driver arrange to call rfkill_force_state() as soon * as possible after such a change. * * This function may not be called from an atomic context. */int rfkill_force_state(struct rfkill *rfkill, enum rfkill_state state){	enum rfkill_state oldstate; 	BUG_ON(!rfkill);	if (WARN((state >= RFKILL_STATE_MAX),			KERN_WARNING			"rfkill: illegal state %d passed as parameter "			"to rfkill_force_state\n", state))		return -EINVAL; 	mutex_lock(&rfkill->mutex); 	oldstate = rfkill->state;	rfkill->state = state; 	if (state != oldstate)		rfkill_uevent(rfkill); 	mutex_unlock(&rfkill->mutex); 	return 0;}EXPORT_SYMBOL(rfkill_force_state); static ssize_t rfkill_name_show(struct device *dev,				struct device_attribute *attr,				char *buf){	struct rfkill *rfkill = to_rfkill(dev); 	return sprintf(buf, "%s\n", rfkill->name);} static const char *rfkill_get_type_str(enum rfkill_type type){	switch (type) {	case RFKILL_TYPE_WLAN:		return "wlan";	case RFKILL_TYPE_BLUETOOTH:		return "bluetooth";	case RFKILL_TYPE_UWB:		return "ultrawideband";	case RFKILL_TYPE_WIMAX:		return "wimax";	case RFKILL_TYPE_WWAN:		return "wwan";	default:		BUG();	}} static ssize_t rfkill_type_show(struct device *dev,				struct device_attribute *attr,				char *buf){	struct rfkill *rfkill = to_rfkill(dev); 	return sprintf(buf, "%s\n", rfkill_get_type_str(rfkill->type));} static ssize_t rfkill_state_show(struct device *dev,				 struct device_attribute *attr,				 char *buf){	struct rfkill *rfkill = to_rfkill(dev); 	update_rfkill_state(rfkill);	return sprintf(buf, "%d\n", rfkill->state);} static ssize_t rfkill_state_store(struct device *dev,				  struct device_attribute *attr,				  const char *buf, size_t count){	struct rfkill *rfkill = to_rfkill(dev);	unsigned long state;	int error; 	if (!capable(CAP_NET_ADMIN))		return -EPERM; 	error = strict_strtoul(buf, 0, &state);	if (error)		return error; 	/* RFKILL_STATE_HARD_BLOCKED is illegal here... */	if (state != RFKILL_STATE_UNBLOCKED &&	    state != RFKILL_STATE_SOFT_BLOCKED)		return -EINVAL; 	error = mutex_lock_killable(&rfkill->mutex);	if (error)		return error; 	if (!rfkill_epo_lock_active)		error = rfkill_toggle_radio(rfkill, state, 0);	else		error = -EPERM; 	mutex_unlock(&rfkill->mutex); 	return error ? error : count;} static ssize_t rfkill_claim_show(struct device *dev,				 struct device_attribute *attr,				 char *buf){	struct rfkill *rfkill = to_rfkill(dev); 	return sprintf(buf, "%d\n", rfkill->user_claim);} static ssize_t rfkill_claim_store(struct device *dev,				  struct device_attribute *attr,				  const char *buf, size_t count){	struct rfkill *rfkill = to_rfkill(dev);	unsigned long claim_tmp;	bool claim;	int error; 	if (!capable(CAP_NET_ADMIN))		return -EPERM; 	if (rfkill->user_claim_unsupported)		return -EOPNOTSUPP; 	error = strict_strtoul(buf, 0, &claim_tmp);	if (error)		return error;	claim = !!claim_tmp; 	/*	 * Take the global lock to make sure the kernel is not in	 * the middle of rfkill_switch_all	 */	error = mutex_lock_killable(&rfkill_global_mutex);	if (error)		return error; 	if (rfkill->user_claim != claim) {		if (!claim && !rfkill_epo_lock_active) {			mutex_lock(&rfkill->mutex);			rfkill_toggle_radio(rfkill,					rfkill_global_states[rfkill->type].current_state,					0);			mutex_unlock(&rfkill->mutex);		}		rfkill->user_claim = claim;	} 	mutex_unlock(&rfkill_global_mutex); 	return error ? error : count;} static struct device_attribute rfkill_dev_attrs[] = {	__ATTR(name, S_IRUGO, rfkill_name_show, NULL),

Lines 1–500 of 882. Load more