2007-05-07 09:34:20 +02:00
|
|
|
/*
|
2007-09-27 23:57:05 +02:00
|
|
|
* Copyright (C) 2006 - 2007 Ivo van Doorn
|
2007-05-07 09:34:20 +02:00
|
|
|
* 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>
|
|
|
|
|
2007-11-02 20:18:11 +01:00
|
|
|
/* Get declaration of rfkill_switch_all() to shut up sparse. */
|
|
|
|
#include "rfkill-input.h"
|
|
|
|
|
|
|
|
|
2007-05-07 09:34:20 +02:00
|
|
|
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 */
|
2008-08-26 16:58:00 +02:00
|
|
|
static DEFINE_MUTEX(rfkill_global_mutex);
|
2007-05-07 09:34:20 +02:00
|
|
|
|
2008-06-23 22:46:42 +02:00
|
|
|
static unsigned int rfkill_default_state = RFKILL_STATE_UNBLOCKED;
|
2008-06-23 22:22:59 +02:00
|
|
|
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");
|
|
|
|
|
2008-08-02 20:10:58 +02:00
|
|
|
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)];
|
rfkill: add master_switch_mode and EPO lock to rfkill and rfkill-input
Add of software-based sanity to rfkill and rfkill-input so that it can
reproduce what hardware-based EPO switches do, blocking all transmitters
and locking down any further attempts to unblock them until the switch is
deactivated.
rfkill-input is responsible for issuing the EPO control requests, like
before.
While an rfkill EPO is active, all transmitters are locked to one of the
BLOCKED states and all attempts to change that through the rfkill API
(userspace and kernel) will be either ignored or return -EPERM errors.
The lock will be released upon receipt of EV_SW SW_RFKILL_ALL ON by
rfkill-input, or should modular rfkill-input be unloaded.
This makes rfkill and rfkill-input extend the operation of an existing
wireless master kill switch to all wireless devices in the system, even
those that are not under hardware or firmware control.
Since the above is the expected operational behavior for the master rfkill
switch, the EPO lock functionality is not optional.
Also, extend rfkill-input to allow for three different behaviors when it
receives an EV_SW SW_RFKILL_ALL ON input event. The user can set which
behavior he wants through the master_switch_mode parameter:
master_switch_mode = 0: EV_SW SW_RFKILL_ALL ON just unlocks rfkill
controller state changes (so that the rfkill userspace and kernel APIs can
now be used to change rfkill controller states again), but doesn't change
any of their states (so they will all remain blocked). This is the safest
mode of operation, as it requires explicit operator action to re-enable a
transmitter.
master_switch_mode = 1: EV_SW SW_RFKILL_ALL ON causes rfkill-input to
attempt to restore the system to the state before the last EV_SW
SW_RFKILL_ALL OFF event, or to the default global states if no EV_SW
SW_RFKILL_ALL OFF ever happened. This is the recommended mode of
operation for laptops.
master_switch_mode = 2: tries to unblock all rfkill controllers (i.e.
enable all transmitters) when an EV_SW SW_RFKILL_ALL ON event is received.
This is the default mode of operation, as it mimics the previous behavior
of rfkill-input.
In order to implement these features in a clean way, the entire event
handling of rfkill-input was refactored into a single worker function.
Protection against input event DoS (repeatedly firing rfkill events for
rfkill-input to process) was removed during the code refactoring. It will
be added back in a future patch.
Note that with these changes, rfkill-input doesn't need to explicitly
handle any radio types for which KEY_<radio type> or SW_<radio type> events
do not exist yet.
Code to handle EV_SW SW_{WLAN,WWAN,BLUETOOTH,WIMAX,...} was added as it
might be needed in the future (and its implementation is not that obvious),
but is currently #ifdef'd out to avoid wasting resources.
Signed-off-by: Henrique de Moraes Holschuh <hmh@hmh.eng.br>
Cc: Ivo van Doorn <IvDoorn@gmail.com>
Cc: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-10-10 02:49:33 +02:00
|
|
|
static bool rfkill_epo_lock_active;
|
2007-05-07 09:34:20 +02:00
|
|
|
|
2008-06-23 22:23:03 +02:00
|
|
|
static BLOCKING_NOTIFIER_HEAD(rfkill_notifier_list);
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* register_rfkill_notifier - Add notifier to rfkill notifier chain
|
|
|
|
* @nb: pointer to the new entry to add to the chain
|
|
|
|
*
|
|
|
|
* See blocking_notifier_chain_register() for return value and further
|
|
|
|
* observations.
|
|
|
|
*
|
|
|
|
* Adds a notifier to the rfkill notifier chain. The chain will be
|
|
|
|
* called with a pointer to the relevant rfkill structure as a parameter,
|
|
|
|
* refer to include/linux/rfkill.h for the possible events.
|
|
|
|
*
|
|
|
|
* Notifiers added to this chain are to always return NOTIFY_DONE. This
|
|
|
|
* chain is a blocking notifier chain: notifiers can sleep.
|
|
|
|
*
|
|
|
|
* Calls to this chain may have been done through a workqueue. One must
|
|
|
|
* assume unordered asynchronous behaviour, there is no way to know if
|
|
|
|
* actions related to the event that generated the notification have been
|
|
|
|
* carried out already.
|
|
|
|
*/
|
|
|
|
int register_rfkill_notifier(struct notifier_block *nb)
|
|
|
|
{
|
2008-08-26 16:57:59 +02:00
|
|
|
BUG_ON(!nb);
|
2008-06-23 22:23:03 +02:00
|
|
|
return blocking_notifier_chain_register(&rfkill_notifier_list, nb);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(register_rfkill_notifier);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* unregister_rfkill_notifier - remove notifier from rfkill notifier chain
|
|
|
|
* @nb: pointer to the entry to remove from the chain
|
|
|
|
*
|
|
|
|
* See blocking_notifier_chain_unregister() for return value and further
|
|
|
|
* observations.
|
|
|
|
*
|
|
|
|
* Removes a notifier from the rfkill notifier chain.
|
|
|
|
*/
|
|
|
|
int unregister_rfkill_notifier(struct notifier_block *nb)
|
|
|
|
{
|
2008-08-26 16:57:59 +02:00
|
|
|
BUG_ON(!nb);
|
2008-06-23 22:23:03 +02:00
|
|
|
return blocking_notifier_chain_unregister(&rfkill_notifier_list, nb);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(unregister_rfkill_notifier);
|
|
|
|
|
2007-09-27 21:33:12 +02:00
|
|
|
|
|
|
|
static void rfkill_led_trigger(struct rfkill *rfkill,
|
|
|
|
enum rfkill_state state)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_RFKILL_LEDS
|
|
|
|
struct led_trigger *led = &rfkill->led_trigger;
|
|
|
|
|
|
|
|
if (!led->name)
|
|
|
|
return;
|
2008-06-23 22:46:42 +02:00
|
|
|
if (state != RFKILL_STATE_UNBLOCKED)
|
2007-09-27 21:33:12 +02:00
|
|
|
led_trigger_event(led, LED_OFF);
|
|
|
|
else
|
|
|
|
led_trigger_event(led, LED_FULL);
|
|
|
|
#endif /* CONFIG_RFKILL_LEDS */
|
|
|
|
}
|
|
|
|
|
2008-07-22 12:21:59 +02:00
|
|
|
#ifdef CONFIG_RFKILL_LEDS
|
|
|
|
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 */
|
|
|
|
|
2008-06-23 22:23:03 +02:00
|
|
|
static void notify_rfkill_state_change(struct rfkill *rfkill)
|
|
|
|
{
|
2008-10-03 21:58:05 +02:00
|
|
|
rfkill_led_trigger(rfkill, rfkill->state);
|
2008-06-23 22:23:03 +02:00
|
|
|
blocking_notifier_call_chain(&rfkill_notifier_list,
|
|
|
|
RFKILL_STATE_CHANGED,
|
|
|
|
rfkill);
|
|
|
|
}
|
|
|
|
|
2008-06-23 22:23:00 +02:00
|
|
|
static void update_rfkill_state(struct rfkill *rfkill)
|
|
|
|
{
|
2008-06-23 22:23:03 +02:00
|
|
|
enum rfkill_state newstate, oldstate;
|
2008-06-23 22:23:00 +02:00
|
|
|
|
|
|
|
if (rfkill->get_state) {
|
|
|
|
mutex_lock(&rfkill->mutex);
|
2008-06-23 22:23:03 +02:00
|
|
|
if (!rfkill->get_state(rfkill->data, &newstate)) {
|
|
|
|
oldstate = rfkill->state;
|
2008-06-23 22:23:00 +02:00
|
|
|
rfkill->state = newstate;
|
2008-06-23 22:23:03 +02:00
|
|
|
if (oldstate != newstate)
|
|
|
|
notify_rfkill_state_change(rfkill);
|
|
|
|
}
|
2008-06-23 22:23:00 +02:00
|
|
|
mutex_unlock(&rfkill->mutex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-06-23 22:46:42 +02:00
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*
|
2008-07-03 18:14:56 +02:00
|
|
|
* 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.
|
|
|
|
*
|
2008-08-02 19:56:25 +02:00
|
|
|
* Suspended devices are not touched at all, and -EAGAIN is returned.
|
|
|
|
*
|
2008-07-22 02:18:22 +02:00
|
|
|
* Note that the @force parameter cannot override a (possibly cached)
|
|
|
|
* state of RFKILL_STATE_HARD_BLOCKED. Any device making use of
|
2008-06-23 22:46:42 +02:00
|
|
|
* 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.
|
|
|
|
*
|
2008-07-22 02:18:20 +02:00
|
|
|
* Caller must have acquired rfkill->mutex.
|
2008-06-23 22:46:42 +02:00
|
|
|
*/
|
2007-05-07 09:34:20 +02:00
|
|
|
static int rfkill_toggle_radio(struct rfkill *rfkill,
|
2008-06-23 22:23:02 +02:00
|
|
|
enum rfkill_state state,
|
|
|
|
int force)
|
2007-05-07 09:34:20 +02:00
|
|
|
{
|
2007-11-28 17:49:34 +01:00
|
|
|
int retval = 0;
|
2008-06-23 22:23:00 +02:00
|
|
|
enum rfkill_state oldstate, newstate;
|
|
|
|
|
2008-08-02 19:56:25 +02:00
|
|
|
if (unlikely(rfkill->dev.power.power_state.event & PM_EVENT_SLEEP))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2008-06-23 22:23:00 +02:00
|
|
|
oldstate = rfkill->state;
|
|
|
|
|
2008-06-23 22:23:02 +02:00
|
|
|
if (rfkill->get_state && !force &&
|
2008-06-23 22:23:00 +02:00
|
|
|
!rfkill->get_state(rfkill->data, &newstate))
|
|
|
|
rfkill->state = newstate;
|
2007-05-07 09:34:20 +02:00
|
|
|
|
2008-06-23 22:46:42 +02:00
|
|
|
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;
|
2008-08-02 20:11:00 +02:00
|
|
|
default:
|
2008-08-26 16:57:59 +02:00
|
|
|
WARN(1, KERN_WARNING
|
|
|
|
"rfkill: illegal state %d passed as parameter "
|
|
|
|
"to rfkill_toggle_radio\n", state);
|
2008-08-02 20:11:00 +02:00
|
|
|
return -EINVAL;
|
2008-06-23 22:46:42 +02:00
|
|
|
}
|
|
|
|
|
2008-06-23 22:23:02 +02:00
|
|
|
if (force || state != rfkill->state) {
|
2007-05-07 09:34:20 +02:00
|
|
|
retval = rfkill->toggle_radio(rfkill->data, state);
|
2008-06-23 22:46:42 +02:00
|
|
|
/* never allow a HARD->SOFT downgrade! */
|
|
|
|
if (!retval && rfkill->state != RFKILL_STATE_HARD_BLOCKED)
|
2007-05-07 09:34:20 +02:00
|
|
|
rfkill->state = state;
|
|
|
|
}
|
|
|
|
|
2008-10-03 21:58:05 +02:00
|
|
|
if (force || rfkill->state != oldstate)
|
2008-06-23 22:23:03 +02:00
|
|
|
notify_rfkill_state_change(rfkill);
|
2008-06-23 22:23:00 +02:00
|
|
|
|
2007-05-07 09:34:20 +02:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-08-02 20:10:58 +02:00
|
|
|
* __rfkill_switch_all - Toggle state of all switches of given type
|
2008-07-22 02:18:22 +02:00
|
|
|
* @type: type of interfaces to be affected
|
2007-05-07 09:34:20 +02:00
|
|
|
* @state: the new state
|
|
|
|
*
|
2008-07-22 02:18:22 +02:00
|
|
|
* This function toggles the state of all switches of given type,
|
|
|
|
* unless a specific switch is claimed by userspace (in which case,
|
2008-08-02 19:56:25 +02:00
|
|
|
* that switch is left alone) or suspended.
|
2008-08-02 20:10:58 +02:00
|
|
|
*
|
2008-08-26 16:58:00 +02:00
|
|
|
* Caller must have acquired rfkill_global_mutex.
|
2007-05-07 09:34:20 +02:00
|
|
|
*/
|
2008-08-02 20:10:58 +02:00
|
|
|
static void __rfkill_switch_all(const enum rfkill_type type,
|
|
|
|
const enum rfkill_state state)
|
2007-05-07 09:34:20 +02:00
|
|
|
{
|
|
|
|
struct rfkill *rfkill;
|
|
|
|
|
2008-08-26 16:57:59 +02:00
|
|
|
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))
|
2008-08-02 20:11:00 +02:00
|
|
|
return;
|
|
|
|
|
2008-08-02 20:10:58 +02:00
|
|
|
rfkill_global_states[type].current_state = state;
|
2007-05-07 09:34:20 +02:00
|
|
|
list_for_each_entry(rfkill, &rfkill_list, node) {
|
2008-07-22 02:18:20 +02:00
|
|
|
if ((!rfkill->user_claim) && (rfkill->type == type)) {
|
|
|
|
mutex_lock(&rfkill->mutex);
|
2008-06-23 22:23:02 +02:00
|
|
|
rfkill_toggle_radio(rfkill, state, 0);
|
2008-07-22 02:18:20 +02:00
|
|
|
mutex_unlock(&rfkill->mutex);
|
|
|
|
}
|
2007-05-07 09:34:20 +02:00
|
|
|
}
|
2008-08-02 20:10:58 +02:00
|
|
|
}
|
2007-05-07 09:34:20 +02:00
|
|
|
|
2008-08-02 20:10:58 +02:00
|
|
|
/**
|
|
|
|
* rfkill_switch_all - Toggle state of all switches of given type
|
|
|
|
* @type: type of interfaces to be affected
|
|
|
|
* @state: the new state
|
|
|
|
*
|
2008-08-26 16:58:00 +02:00
|
|
|
* Acquires rfkill_global_mutex and calls __rfkill_switch_all(@type, @state).
|
2008-08-02 20:10:58 +02:00
|
|
|
* Please refer to __rfkill_switch_all() for details.
|
rfkill: add master_switch_mode and EPO lock to rfkill and rfkill-input
Add of software-based sanity to rfkill and rfkill-input so that it can
reproduce what hardware-based EPO switches do, blocking all transmitters
and locking down any further attempts to unblock them until the switch is
deactivated.
rfkill-input is responsible for issuing the EPO control requests, like
before.
While an rfkill EPO is active, all transmitters are locked to one of the
BLOCKED states and all attempts to change that through the rfkill API
(userspace and kernel) will be either ignored or return -EPERM errors.
The lock will be released upon receipt of EV_SW SW_RFKILL_ALL ON by
rfkill-input, or should modular rfkill-input be unloaded.
This makes rfkill and rfkill-input extend the operation of an existing
wireless master kill switch to all wireless devices in the system, even
those that are not under hardware or firmware control.
Since the above is the expected operational behavior for the master rfkill
switch, the EPO lock functionality is not optional.
Also, extend rfkill-input to allow for three different behaviors when it
receives an EV_SW SW_RFKILL_ALL ON input event. The user can set which
behavior he wants through the master_switch_mode parameter:
master_switch_mode = 0: EV_SW SW_RFKILL_ALL ON just unlocks rfkill
controller state changes (so that the rfkill userspace and kernel APIs can
now be used to change rfkill controller states again), but doesn't change
any of their states (so they will all remain blocked). This is the safest
mode of operation, as it requires explicit operator action to re-enable a
transmitter.
master_switch_mode = 1: EV_SW SW_RFKILL_ALL ON causes rfkill-input to
attempt to restore the system to the state before the last EV_SW
SW_RFKILL_ALL OFF event, or to the default global states if no EV_SW
SW_RFKILL_ALL OFF ever happened. This is the recommended mode of
operation for laptops.
master_switch_mode = 2: tries to unblock all rfkill controllers (i.e.
enable all transmitters) when an EV_SW SW_RFKILL_ALL ON event is received.
This is the default mode of operation, as it mimics the previous behavior
of rfkill-input.
In order to implement these features in a clean way, the entire event
handling of rfkill-input was refactored into a single worker function.
Protection against input event DoS (repeatedly firing rfkill events for
rfkill-input to process) was removed during the code refactoring. It will
be added back in a future patch.
Note that with these changes, rfkill-input doesn't need to explicitly
handle any radio types for which KEY_<radio type> or SW_<radio type> events
do not exist yet.
Code to handle EV_SW SW_{WLAN,WWAN,BLUETOOTH,WIMAX,...} was added as it
might be needed in the future (and its implementation is not that obvious),
but is currently #ifdef'd out to avoid wasting resources.
Signed-off-by: Henrique de Moraes Holschuh <hmh@hmh.eng.br>
Cc: Ivo van Doorn <IvDoorn@gmail.com>
Cc: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-10-10 02:49:33 +02:00
|
|
|
*
|
|
|
|
* Does nothing if the EPO lock is active.
|
2008-08-02 20:10:58 +02:00
|
|
|
*/
|
|
|
|
void rfkill_switch_all(enum rfkill_type type, enum rfkill_state state)
|
|
|
|
{
|
2008-08-26 16:58:00 +02:00
|
|
|
mutex_lock(&rfkill_global_mutex);
|
rfkill: add master_switch_mode and EPO lock to rfkill and rfkill-input
Add of software-based sanity to rfkill and rfkill-input so that it can
reproduce what hardware-based EPO switches do, blocking all transmitters
and locking down any further attempts to unblock them until the switch is
deactivated.
rfkill-input is responsible for issuing the EPO control requests, like
before.
While an rfkill EPO is active, all transmitters are locked to one of the
BLOCKED states and all attempts to change that through the rfkill API
(userspace and kernel) will be either ignored or return -EPERM errors.
The lock will be released upon receipt of EV_SW SW_RFKILL_ALL ON by
rfkill-input, or should modular rfkill-input be unloaded.
This makes rfkill and rfkill-input extend the operation of an existing
wireless master kill switch to all wireless devices in the system, even
those that are not under hardware or firmware control.
Since the above is the expected operational behavior for the master rfkill
switch, the EPO lock functionality is not optional.
Also, extend rfkill-input to allow for three different behaviors when it
receives an EV_SW SW_RFKILL_ALL ON input event. The user can set which
behavior he wants through the master_switch_mode parameter:
master_switch_mode = 0: EV_SW SW_RFKILL_ALL ON just unlocks rfkill
controller state changes (so that the rfkill userspace and kernel APIs can
now be used to change rfkill controller states again), but doesn't change
any of their states (so they will all remain blocked). This is the safest
mode of operation, as it requires explicit operator action to re-enable a
transmitter.
master_switch_mode = 1: EV_SW SW_RFKILL_ALL ON causes rfkill-input to
attempt to restore the system to the state before the last EV_SW
SW_RFKILL_ALL OFF event, or to the default global states if no EV_SW
SW_RFKILL_ALL OFF ever happened. This is the recommended mode of
operation for laptops.
master_switch_mode = 2: tries to unblock all rfkill controllers (i.e.
enable all transmitters) when an EV_SW SW_RFKILL_ALL ON event is received.
This is the default mode of operation, as it mimics the previous behavior
of rfkill-input.
In order to implement these features in a clean way, the entire event
handling of rfkill-input was refactored into a single worker function.
Protection against input event DoS (repeatedly firing rfkill events for
rfkill-input to process) was removed during the code refactoring. It will
be added back in a future patch.
Note that with these changes, rfkill-input doesn't need to explicitly
handle any radio types for which KEY_<radio type> or SW_<radio type> events
do not exist yet.
Code to handle EV_SW SW_{WLAN,WWAN,BLUETOOTH,WIMAX,...} was added as it
might be needed in the future (and its implementation is not that obvious),
but is currently #ifdef'd out to avoid wasting resources.
Signed-off-by: Henrique de Moraes Holschuh <hmh@hmh.eng.br>
Cc: Ivo van Doorn <IvDoorn@gmail.com>
Cc: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-10-10 02:49:33 +02:00
|
|
|
if (!rfkill_epo_lock_active)
|
|
|
|
__rfkill_switch_all(type, state);
|
2008-08-26 16:58:00 +02:00
|
|
|
mutex_unlock(&rfkill_global_mutex);
|
2007-05-07 09:34:20 +02:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(rfkill_switch_all);
|
|
|
|
|
2008-06-23 22:23:07 +02:00
|
|
|
/**
|
|
|
|
* rfkill_epo - emergency power off all transmitters
|
|
|
|
*
|
2008-08-02 19:56:25 +02:00
|
|
|
* This kicks all non-suspended rfkill devices to RFKILL_STATE_SOFT_BLOCKED,
|
2008-08-26 16:58:00 +02:00
|
|
|
* ignoring everything in its path but rfkill_global_mutex and rfkill->mutex.
|
2008-08-02 20:10:58 +02:00
|
|
|
*
|
|
|
|
* The global state before the EPO is saved and can be restored later
|
|
|
|
* using rfkill_restore_states().
|
2008-06-23 22:23:07 +02:00
|
|
|
*/
|
|
|
|
void rfkill_epo(void)
|
|
|
|
{
|
|
|
|
struct rfkill *rfkill;
|
2008-08-02 20:10:58 +02:00
|
|
|
int i;
|
2008-06-23 22:23:07 +02:00
|
|
|
|
2008-08-26 16:58:00 +02:00
|
|
|
mutex_lock(&rfkill_global_mutex);
|
|
|
|
|
rfkill: add master_switch_mode and EPO lock to rfkill and rfkill-input
Add of software-based sanity to rfkill and rfkill-input so that it can
reproduce what hardware-based EPO switches do, blocking all transmitters
and locking down any further attempts to unblock them until the switch is
deactivated.
rfkill-input is responsible for issuing the EPO control requests, like
before.
While an rfkill EPO is active, all transmitters are locked to one of the
BLOCKED states and all attempts to change that through the rfkill API
(userspace and kernel) will be either ignored or return -EPERM errors.
The lock will be released upon receipt of EV_SW SW_RFKILL_ALL ON by
rfkill-input, or should modular rfkill-input be unloaded.
This makes rfkill and rfkill-input extend the operation of an existing
wireless master kill switch to all wireless devices in the system, even
those that are not under hardware or firmware control.
Since the above is the expected operational behavior for the master rfkill
switch, the EPO lock functionality is not optional.
Also, extend rfkill-input to allow for three different behaviors when it
receives an EV_SW SW_RFKILL_ALL ON input event. The user can set which
behavior he wants through the master_switch_mode parameter:
master_switch_mode = 0: EV_SW SW_RFKILL_ALL ON just unlocks rfkill
controller state changes (so that the rfkill userspace and kernel APIs can
now be used to change rfkill controller states again), but doesn't change
any of their states (so they will all remain blocked). This is the safest
mode of operation, as it requires explicit operator action to re-enable a
transmitter.
master_switch_mode = 1: EV_SW SW_RFKILL_ALL ON causes rfkill-input to
attempt to restore the system to the state before the last EV_SW
SW_RFKILL_ALL OFF event, or to the default global states if no EV_SW
SW_RFKILL_ALL OFF ever happened. This is the recommended mode of
operation for laptops.
master_switch_mode = 2: tries to unblock all rfkill controllers (i.e.
enable all transmitters) when an EV_SW SW_RFKILL_ALL ON event is received.
This is the default mode of operation, as it mimics the previous behavior
of rfkill-input.
In order to implement these features in a clean way, the entire event
handling of rfkill-input was refactored into a single worker function.
Protection against input event DoS (repeatedly firing rfkill events for
rfkill-input to process) was removed during the code refactoring. It will
be added back in a future patch.
Note that with these changes, rfkill-input doesn't need to explicitly
handle any radio types for which KEY_<radio type> or SW_<radio type> events
do not exist yet.
Code to handle EV_SW SW_{WLAN,WWAN,BLUETOOTH,WIMAX,...} was added as it
might be needed in the future (and its implementation is not that obvious),
but is currently #ifdef'd out to avoid wasting resources.
Signed-off-by: Henrique de Moraes Holschuh <hmh@hmh.eng.br>
Cc: Ivo van Doorn <IvDoorn@gmail.com>
Cc: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-10-10 02:49:33 +02:00
|
|
|
rfkill_epo_lock_active = true;
|
2008-06-23 22:23:07 +02:00
|
|
|
list_for_each_entry(rfkill, &rfkill_list, node) {
|
2008-07-22 02:18:20 +02:00
|
|
|
mutex_lock(&rfkill->mutex);
|
2008-06-23 22:46:42 +02:00
|
|
|
rfkill_toggle_radio(rfkill, RFKILL_STATE_SOFT_BLOCKED, 1);
|
2008-07-22 02:18:20 +02:00
|
|
|
mutex_unlock(&rfkill->mutex);
|
2008-06-23 22:23:07 +02:00
|
|
|
}
|
2008-08-02 20:10:58 +02:00
|
|
|
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;
|
|
|
|
}
|
2008-08-26 16:58:00 +02:00
|
|
|
mutex_unlock(&rfkill_global_mutex);
|
2008-06-23 22:23:07 +02:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rfkill_epo);
|
|
|
|
|
2008-08-02 20:10:58 +02:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
|
2008-08-26 16:58:00 +02:00
|
|
|
mutex_lock(&rfkill_global_mutex);
|
|
|
|
|
rfkill: add master_switch_mode and EPO lock to rfkill and rfkill-input
Add of software-based sanity to rfkill and rfkill-input so that it can
reproduce what hardware-based EPO switches do, blocking all transmitters
and locking down any further attempts to unblock them until the switch is
deactivated.
rfkill-input is responsible for issuing the EPO control requests, like
before.
While an rfkill EPO is active, all transmitters are locked to one of the
BLOCKED states and all attempts to change that through the rfkill API
(userspace and kernel) will be either ignored or return -EPERM errors.
The lock will be released upon receipt of EV_SW SW_RFKILL_ALL ON by
rfkill-input, or should modular rfkill-input be unloaded.
This makes rfkill and rfkill-input extend the operation of an existing
wireless master kill switch to all wireless devices in the system, even
those that are not under hardware or firmware control.
Since the above is the expected operational behavior for the master rfkill
switch, the EPO lock functionality is not optional.
Also, extend rfkill-input to allow for three different behaviors when it
receives an EV_SW SW_RFKILL_ALL ON input event. The user can set which
behavior he wants through the master_switch_mode parameter:
master_switch_mode = 0: EV_SW SW_RFKILL_ALL ON just unlocks rfkill
controller state changes (so that the rfkill userspace and kernel APIs can
now be used to change rfkill controller states again), but doesn't change
any of their states (so they will all remain blocked). This is the safest
mode of operation, as it requires explicit operator action to re-enable a
transmitter.
master_switch_mode = 1: EV_SW SW_RFKILL_ALL ON causes rfkill-input to
attempt to restore the system to the state before the last EV_SW
SW_RFKILL_ALL OFF event, or to the default global states if no EV_SW
SW_RFKILL_ALL OFF ever happened. This is the recommended mode of
operation for laptops.
master_switch_mode = 2: tries to unblock all rfkill controllers (i.e.
enable all transmitters) when an EV_SW SW_RFKILL_ALL ON event is received.
This is the default mode of operation, as it mimics the previous behavior
of rfkill-input.
In order to implement these features in a clean way, the entire event
handling of rfkill-input was refactored into a single worker function.
Protection against input event DoS (repeatedly firing rfkill events for
rfkill-input to process) was removed during the code refactoring. It will
be added back in a future patch.
Note that with these changes, rfkill-input doesn't need to explicitly
handle any radio types for which KEY_<radio type> or SW_<radio type> events
do not exist yet.
Code to handle EV_SW SW_{WLAN,WWAN,BLUETOOTH,WIMAX,...} was added as it
might be needed in the future (and its implementation is not that obvious),
but is currently #ifdef'd out to avoid wasting resources.
Signed-off-by: Henrique de Moraes Holschuh <hmh@hmh.eng.br>
Cc: Ivo van Doorn <IvDoorn@gmail.com>
Cc: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-10-10 02:49:33 +02:00
|
|
|
rfkill_epo_lock_active = false;
|
2008-08-02 20:10:58 +02:00
|
|
|
for (i = 0; i < RFKILL_TYPE_MAX; i++)
|
|
|
|
__rfkill_switch_all(i, rfkill_global_states[i].default_state);
|
2008-08-26 16:58:00 +02:00
|
|
|
mutex_unlock(&rfkill_global_mutex);
|
2008-08-02 20:10:58 +02:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rfkill_restore_states);
|
|
|
|
|
rfkill: add master_switch_mode and EPO lock to rfkill and rfkill-input
Add of software-based sanity to rfkill and rfkill-input so that it can
reproduce what hardware-based EPO switches do, blocking all transmitters
and locking down any further attempts to unblock them until the switch is
deactivated.
rfkill-input is responsible for issuing the EPO control requests, like
before.
While an rfkill EPO is active, all transmitters are locked to one of the
BLOCKED states and all attempts to change that through the rfkill API
(userspace and kernel) will be either ignored or return -EPERM errors.
The lock will be released upon receipt of EV_SW SW_RFKILL_ALL ON by
rfkill-input, or should modular rfkill-input be unloaded.
This makes rfkill and rfkill-input extend the operation of an existing
wireless master kill switch to all wireless devices in the system, even
those that are not under hardware or firmware control.
Since the above is the expected operational behavior for the master rfkill
switch, the EPO lock functionality is not optional.
Also, extend rfkill-input to allow for three different behaviors when it
receives an EV_SW SW_RFKILL_ALL ON input event. The user can set which
behavior he wants through the master_switch_mode parameter:
master_switch_mode = 0: EV_SW SW_RFKILL_ALL ON just unlocks rfkill
controller state changes (so that the rfkill userspace and kernel APIs can
now be used to change rfkill controller states again), but doesn't change
any of their states (so they will all remain blocked). This is the safest
mode of operation, as it requires explicit operator action to re-enable a
transmitter.
master_switch_mode = 1: EV_SW SW_RFKILL_ALL ON causes rfkill-input to
attempt to restore the system to the state before the last EV_SW
SW_RFKILL_ALL OFF event, or to the default global states if no EV_SW
SW_RFKILL_ALL OFF ever happened. This is the recommended mode of
operation for laptops.
master_switch_mode = 2: tries to unblock all rfkill controllers (i.e.
enable all transmitters) when an EV_SW SW_RFKILL_ALL ON event is received.
This is the default mode of operation, as it mimics the previous behavior
of rfkill-input.
In order to implement these features in a clean way, the entire event
handling of rfkill-input was refactored into a single worker function.
Protection against input event DoS (repeatedly firing rfkill events for
rfkill-input to process) was removed during the code refactoring. It will
be added back in a future patch.
Note that with these changes, rfkill-input doesn't need to explicitly
handle any radio types for which KEY_<radio type> or SW_<radio type> events
do not exist yet.
Code to handle EV_SW SW_{WLAN,WWAN,BLUETOOTH,WIMAX,...} was added as it
might be needed in the future (and its implementation is not that obvious),
but is currently #ifdef'd out to avoid wasting resources.
Signed-off-by: Henrique de Moraes Holschuh <hmh@hmh.eng.br>
Cc: Ivo van Doorn <IvDoorn@gmail.com>
Cc: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-10-10 02:49:33 +02:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2008-10-09 23:15:30 +02:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2008-06-23 22:23:00 +02:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*
|
2008-07-22 02:18:17 +02:00
|
|
|
* 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.
|
2008-06-23 22:23:00 +02:00
|
|
|
*/
|
|
|
|
int rfkill_force_state(struct rfkill *rfkill, enum rfkill_state state)
|
|
|
|
{
|
2008-06-23 22:23:03 +02:00
|
|
|
enum rfkill_state oldstate;
|
|
|
|
|
2008-08-26 16:57:59 +02:00
|
|
|
BUG_ON(!rfkill);
|
|
|
|
if (WARN((state >= RFKILL_STATE_MAX),
|
|
|
|
KERN_WARNING
|
|
|
|
"rfkill: illegal state %d passed as parameter "
|
|
|
|
"to rfkill_force_state\n", state))
|
2008-06-23 22:23:00 +02:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
mutex_lock(&rfkill->mutex);
|
2008-06-23 22:23:03 +02:00
|
|
|
|
|
|
|
oldstate = rfkill->state;
|
2008-06-23 22:23:00 +02:00
|
|
|
rfkill->state = state;
|
2008-06-23 22:23:03 +02:00
|
|
|
|
|
|
|
if (state != oldstate)
|
|
|
|
notify_rfkill_state_change(rfkill);
|
|
|
|
|
2008-06-23 22:23:00 +02:00
|
|
|
mutex_unlock(&rfkill->mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(rfkill_force_state);
|
|
|
|
|
2007-05-07 09:34:20 +02:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2008-06-23 22:23:04 +02:00
|
|
|
static const char *rfkill_get_type_str(enum rfkill_type type)
|
2007-05-07 09:34:20 +02:00
|
|
|
{
|
2008-06-23 22:23:04 +02:00
|
|
|
switch (type) {
|
2007-05-07 09:34:20 +02:00
|
|
|
case RFKILL_TYPE_WLAN:
|
2008-06-23 22:23:04 +02:00
|
|
|
return "wlan";
|
2007-05-07 09:34:20 +02:00
|
|
|
case RFKILL_TYPE_BLUETOOTH:
|
2008-06-23 22:23:04 +02:00
|
|
|
return "bluetooth";
|
2007-09-13 09:21:31 +02:00
|
|
|
case RFKILL_TYPE_UWB:
|
2008-06-23 22:23:04 +02:00
|
|
|
return "ultrawideband";
|
2008-01-23 22:40:27 +01:00
|
|
|
case RFKILL_TYPE_WIMAX:
|
2008-06-23 22:23:04 +02:00
|
|
|
return "wimax";
|
2008-06-23 22:23:01 +02:00
|
|
|
case RFKILL_TYPE_WWAN:
|
2008-06-23 22:23:04 +02:00
|
|
|
return "wwan";
|
2007-05-07 09:34:20 +02:00
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
2008-06-23 22:23:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t rfkill_type_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct rfkill *rfkill = to_rfkill(dev);
|
2007-05-07 09:34:20 +02:00
|
|
|
|
2008-06-23 22:23:04 +02:00
|
|
|
return sprintf(buf, "%s\n", rfkill_get_type_str(rfkill->type));
|
2007-05-07 09:34:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t rfkill_state_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct rfkill *rfkill = to_rfkill(dev);
|
|
|
|
|
2008-06-23 22:23:00 +02:00
|
|
|
update_rfkill_state(rfkill);
|
2007-05-07 09:34:20 +02:00
|
|
|
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);
|
2008-08-26 16:57:57 +02:00
|
|
|
unsigned long state;
|
2007-05-07 09:34:20 +02:00
|
|
|
int error;
|
|
|
|
|
|
|
|
if (!capable(CAP_NET_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
|
2008-08-26 16:57:57 +02:00
|
|
|
error = strict_strtoul(buf, 0, &state);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2008-06-23 22:46:42 +02:00
|
|
|
/* RFKILL_STATE_HARD_BLOCKED is illegal here... */
|
|
|
|
if (state != RFKILL_STATE_UNBLOCKED &&
|
|
|
|
state != RFKILL_STATE_SOFT_BLOCKED)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-10-09 23:15:29 +02:00
|
|
|
error = mutex_lock_killable(&rfkill->mutex);
|
|
|
|
if (error)
|
|
|
|
return error;
|
rfkill: add master_switch_mode and EPO lock to rfkill and rfkill-input
Add of software-based sanity to rfkill and rfkill-input so that it can
reproduce what hardware-based EPO switches do, blocking all transmitters
and locking down any further attempts to unblock them until the switch is
deactivated.
rfkill-input is responsible for issuing the EPO control requests, like
before.
While an rfkill EPO is active, all transmitters are locked to one of the
BLOCKED states and all attempts to change that through the rfkill API
(userspace and kernel) will be either ignored or return -EPERM errors.
The lock will be released upon receipt of EV_SW SW_RFKILL_ALL ON by
rfkill-input, or should modular rfkill-input be unloaded.
This makes rfkill and rfkill-input extend the operation of an existing
wireless master kill switch to all wireless devices in the system, even
those that are not under hardware or firmware control.
Since the above is the expected operational behavior for the master rfkill
switch, the EPO lock functionality is not optional.
Also, extend rfkill-input to allow for three different behaviors when it
receives an EV_SW SW_RFKILL_ALL ON input event. The user can set which
behavior he wants through the master_switch_mode parameter:
master_switch_mode = 0: EV_SW SW_RFKILL_ALL ON just unlocks rfkill
controller state changes (so that the rfkill userspace and kernel APIs can
now be used to change rfkill controller states again), but doesn't change
any of their states (so they will all remain blocked). This is the safest
mode of operation, as it requires explicit operator action to re-enable a
transmitter.
master_switch_mode = 1: EV_SW SW_RFKILL_ALL ON causes rfkill-input to
attempt to restore the system to the state before the last EV_SW
SW_RFKILL_ALL OFF event, or to the default global states if no EV_SW
SW_RFKILL_ALL OFF ever happened. This is the recommended mode of
operation for laptops.
master_switch_mode = 2: tries to unblock all rfkill controllers (i.e.
enable all transmitters) when an EV_SW SW_RFKILL_ALL ON event is received.
This is the default mode of operation, as it mimics the previous behavior
of rfkill-input.
In order to implement these features in a clean way, the entire event
handling of rfkill-input was refactored into a single worker function.
Protection against input event DoS (repeatedly firing rfkill events for
rfkill-input to process) was removed during the code refactoring. It will
be added back in a future patch.
Note that with these changes, rfkill-input doesn't need to explicitly
handle any radio types for which KEY_<radio type> or SW_<radio type> events
do not exist yet.
Code to handle EV_SW SW_{WLAN,WWAN,BLUETOOTH,WIMAX,...} was added as it
might be needed in the future (and its implementation is not that obvious),
but is currently #ifdef'd out to avoid wasting resources.
Signed-off-by: Henrique de Moraes Holschuh <hmh@hmh.eng.br>
Cc: Ivo van Doorn <IvDoorn@gmail.com>
Cc: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-10-10 02:49:33 +02:00
|
|
|
|
|
|
|
if (!rfkill_epo_lock_active)
|
|
|
|
error = rfkill_toggle_radio(rfkill, state, 0);
|
|
|
|
else
|
|
|
|
error = -EPERM;
|
|
|
|
|
2007-11-28 17:49:34 +01:00
|
|
|
mutex_unlock(&rfkill->mutex);
|
2007-05-07 09:34:20 +02:00
|
|
|
|
2007-11-28 17:49:34 +01:00
|
|
|
return error ? error : count;
|
2007-05-07 09:34:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t rfkill_claim_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct rfkill *rfkill = to_rfkill(dev);
|
|
|
|
|
2008-08-26 16:57:58 +02:00
|
|
|
return sprintf(buf, "%d\n", rfkill->user_claim);
|
2007-05-07 09:34:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2008-08-26 16:57:57 +02:00
|
|
|
unsigned long claim_tmp;
|
|
|
|
bool claim;
|
2007-05-07 09:34:20 +02:00
|
|
|
int error;
|
|
|
|
|
|
|
|
if (!capable(CAP_NET_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
|
2008-07-22 02:18:20 +02:00
|
|
|
if (rfkill->user_claim_unsupported)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2008-08-26 16:57:57 +02:00
|
|
|
error = strict_strtoul(buf, 0, &claim_tmp);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
claim = !!claim_tmp;
|
|
|
|
|
2007-05-07 09:34:20 +02:00
|
|
|
/*
|
|
|
|
* Take the global lock to make sure the kernel is not in
|
|
|
|
* the middle of rfkill_switch_all
|
|
|
|
*/
|
2008-10-09 23:15:29 +02:00
|
|
|
error = mutex_lock_killable(&rfkill_global_mutex);
|
2007-05-07 09:34:20 +02:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
if (rfkill->user_claim != claim) {
|
rfkill: add master_switch_mode and EPO lock to rfkill and rfkill-input
Add of software-based sanity to rfkill and rfkill-input so that it can
reproduce what hardware-based EPO switches do, blocking all transmitters
and locking down any further attempts to unblock them until the switch is
deactivated.
rfkill-input is responsible for issuing the EPO control requests, like
before.
While an rfkill EPO is active, all transmitters are locked to one of the
BLOCKED states and all attempts to change that through the rfkill API
(userspace and kernel) will be either ignored or return -EPERM errors.
The lock will be released upon receipt of EV_SW SW_RFKILL_ALL ON by
rfkill-input, or should modular rfkill-input be unloaded.
This makes rfkill and rfkill-input extend the operation of an existing
wireless master kill switch to all wireless devices in the system, even
those that are not under hardware or firmware control.
Since the above is the expected operational behavior for the master rfkill
switch, the EPO lock functionality is not optional.
Also, extend rfkill-input to allow for three different behaviors when it
receives an EV_SW SW_RFKILL_ALL ON input event. The user can set which
behavior he wants through the master_switch_mode parameter:
master_switch_mode = 0: EV_SW SW_RFKILL_ALL ON just unlocks rfkill
controller state changes (so that the rfkill userspace and kernel APIs can
now be used to change rfkill controller states again), but doesn't change
any of their states (so they will all remain blocked). This is the safest
mode of operation, as it requires explicit operator action to re-enable a
transmitter.
master_switch_mode = 1: EV_SW SW_RFKILL_ALL ON causes rfkill-input to
attempt to restore the system to the state before the last EV_SW
SW_RFKILL_ALL OFF event, or to the default global states if no EV_SW
SW_RFKILL_ALL OFF ever happened. This is the recommended mode of
operation for laptops.
master_switch_mode = 2: tries to unblock all rfkill controllers (i.e.
enable all transmitters) when an EV_SW SW_RFKILL_ALL ON event is received.
This is the default mode of operation, as it mimics the previous behavior
of rfkill-input.
In order to implement these features in a clean way, the entire event
handling of rfkill-input was refactored into a single worker function.
Protection against input event DoS (repeatedly firing rfkill events for
rfkill-input to process) was removed during the code refactoring. It will
be added back in a future patch.
Note that with these changes, rfkill-input doesn't need to explicitly
handle any radio types for which KEY_<radio type> or SW_<radio type> events
do not exist yet.
Code to handle EV_SW SW_{WLAN,WWAN,BLUETOOTH,WIMAX,...} was added as it
might be needed in the future (and its implementation is not that obvious),
but is currently #ifdef'd out to avoid wasting resources.
Signed-off-by: Henrique de Moraes Holschuh <hmh@hmh.eng.br>
Cc: Ivo van Doorn <IvDoorn@gmail.com>
Cc: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-10-10 02:49:33 +02:00
|
|
|
if (!claim && !rfkill_epo_lock_active) {
|
2008-07-22 02:18:20 +02:00
|
|
|
mutex_lock(&rfkill->mutex);
|
2007-05-07 09:34:20 +02:00
|
|
|
rfkill_toggle_radio(rfkill,
|
2008-08-02 20:10:58 +02:00
|
|
|
rfkill_global_states[rfkill->type].current_state,
|
|
|
|
0);
|
2008-07-22 02:18:20 +02:00
|
|
|
mutex_unlock(&rfkill->mutex);
|
|
|
|
}
|
2007-05-07 09:34:20 +02:00
|
|
|
rfkill->user_claim = claim;
|
|
|
|
}
|
|
|
|
|
2008-08-26 16:58:00 +02:00
|
|
|
mutex_unlock(&rfkill_global_mutex);
|
2007-05-07 09:34:20 +02:00
|
|
|
|
2007-09-27 21:34:23 +02:00
|
|
|
return error ? error : count;
|
2007-05-07 09:34:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct device_attribute rfkill_dev_attrs[] = {
|
|
|
|
__ATTR(name, S_IRUGO, rfkill_name_show, NULL),
|
|
|
|
__ATTR(type, S_IRUGO, rfkill_type_show, NULL),
|
2007-07-19 00:38:03 +02:00
|
|
|
__ATTR(state, S_IRUGO|S_IWUSR, rfkill_state_show, rfkill_state_store),
|
2007-05-07 09:34:20 +02:00
|
|
|
__ATTR(claim, S_IRUGO|S_IWUSR, rfkill_claim_show, rfkill_claim_store),
|
|
|
|
__ATTR_NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static void rfkill_release(struct device *dev)
|
|
|
|
{
|
|
|
|
struct rfkill *rfkill = to_rfkill(dev);
|
|
|
|
|
|
|
|
kfree(rfkill);
|
|
|
|
module_put(THIS_MODULE);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
static int rfkill_suspend(struct device *dev, pm_message_t state)
|
|
|
|
{
|
2008-11-21 23:40:09 +01:00
|
|
|
struct rfkill *rfkill = to_rfkill(dev);
|
|
|
|
|
2008-08-26 16:58:01 +02:00
|
|
|
/* mark class device as suspended */
|
|
|
|
if (dev->power.power_state.event != state.event)
|
2007-05-07 09:34:20 +02:00
|
|
|
dev->power.power_state = state;
|
|
|
|
|
2008-11-21 23:40:09 +01:00
|
|
|
/* store state for the resume handler */
|
|
|
|
rfkill->state_for_resume = rfkill->state;
|
|
|
|
|
2007-05-07 09:34:20 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rfkill_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct rfkill *rfkill = to_rfkill(dev);
|
|
|
|
|
|
|
|
if (dev->power.power_state.event != PM_EVENT_ON) {
|
|
|
|
mutex_lock(&rfkill->mutex);
|
|
|
|
|
2008-08-02 19:56:25 +02:00
|
|
|
dev->power.power_state.event = PM_EVENT_ON;
|
|
|
|
|
2008-10-09 23:15:32 +02:00
|
|
|
/*
|
|
|
|
* If we are under EPO, kick transmitter offline,
|
|
|
|
* otherwise restore to pre-suspend state.
|
|
|
|
*
|
|
|
|
* Issue a notification in any case
|
|
|
|
*/
|
|
|
|
rfkill_toggle_radio(rfkill,
|
|
|
|
rfkill_epo_lock_active ?
|
|
|
|
RFKILL_STATE_SOFT_BLOCKED :
|
2008-11-21 23:40:09 +01:00
|
|
|
rfkill->state_for_resume,
|
2008-10-09 23:15:32 +02:00
|
|
|
1);
|
2007-05-07 09:34:20 +02:00
|
|
|
|
|
|
|
mutex_unlock(&rfkill->mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define rfkill_suspend NULL
|
|
|
|
#define rfkill_resume NULL
|
|
|
|
#endif
|
|
|
|
|
2008-06-23 22:23:05 +02:00
|
|
|
static int rfkill_blocking_uevent_notifier(struct notifier_block *nb,
|
|
|
|
unsigned long eventid,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct rfkill *rfkill = (struct rfkill *)data;
|
|
|
|
|
|
|
|
switch (eventid) {
|
|
|
|
case RFKILL_STATE_CHANGED:
|
|
|
|
kobject_uevent(&rfkill->dev.kobj, KOBJ_CHANGE);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block rfkill_blocking_uevent_nb = {
|
|
|
|
.notifier_call = rfkill_blocking_uevent_notifier,
|
|
|
|
.priority = 0,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int rfkill_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
|
|
|
|
{
|
|
|
|
struct rfkill *rfkill = to_rfkill(dev);
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = add_uevent_var(env, "RFKILL_NAME=%s", rfkill->name);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
error = add_uevent_var(env, "RFKILL_TYPE=%s",
|
|
|
|
rfkill_get_type_str(rfkill->type));
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
error = add_uevent_var(env, "RFKILL_STATE=%d", rfkill->state);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-05-07 09:34:20 +02:00
|
|
|
static struct class rfkill_class = {
|
|
|
|
.name = "rfkill",
|
|
|
|
.dev_release = rfkill_release,
|
|
|
|
.dev_attrs = rfkill_dev_attrs,
|
|
|
|
.suspend = rfkill_suspend,
|
|
|
|
.resume = rfkill_resume,
|
2008-06-23 22:23:05 +02:00
|
|
|
.dev_uevent = rfkill_dev_uevent,
|
2007-05-07 09:34:20 +02:00
|
|
|
};
|
|
|
|
|
2008-08-02 20:10:57 +02:00
|
|
|
static int rfkill_check_duplicity(const struct rfkill *rfkill)
|
|
|
|
{
|
|
|
|
struct rfkill *p;
|
|
|
|
unsigned long seen[BITS_TO_LONGS(RFKILL_TYPE_MAX)];
|
|
|
|
|
|
|
|
memset(seen, 0, sizeof(seen));
|
|
|
|
|
|
|
|
list_for_each_entry(p, &rfkill_list, node) {
|
2008-08-26 16:57:59 +02:00
|
|
|
if (WARN((p == rfkill), KERN_WARNING
|
|
|
|
"rfkill: illegal attempt to register "
|
|
|
|
"an already registered rfkill struct\n"))
|
2008-08-02 20:10:57 +02:00
|
|
|
return -EEXIST;
|
|
|
|
set_bit(p->type, seen);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 0: first switch of its kind */
|
2008-10-30 23:46:48 +01:00
|
|
|
return (test_bit(rfkill->type, seen)) ? 1 : 0;
|
2008-08-02 20:10:57 +02:00
|
|
|
}
|
|
|
|
|
2007-05-07 09:34:20 +02:00
|
|
|
static int rfkill_add_switch(struct rfkill *rfkill)
|
|
|
|
{
|
2008-08-02 20:10:57 +02:00
|
|
|
int error;
|
|
|
|
|
2008-08-26 16:58:00 +02:00
|
|
|
mutex_lock(&rfkill_global_mutex);
|
2007-05-07 09:34:20 +02:00
|
|
|
|
2008-08-02 20:10:57 +02:00
|
|
|
error = rfkill_check_duplicity(rfkill);
|
|
|
|
if (error < 0)
|
|
|
|
goto unlock_out;
|
|
|
|
|
2008-08-02 20:10:58 +02:00
|
|
|
if (!error) {
|
|
|
|
/* lock default after first use */
|
|
|
|
set_bit(rfkill->type, rfkill_states_lockdflt);
|
|
|
|
rfkill_global_states[rfkill->type].current_state =
|
|
|
|
rfkill_global_states[rfkill->type].default_state;
|
|
|
|
}
|
|
|
|
|
|
|
|
rfkill_toggle_radio(rfkill,
|
|
|
|
rfkill_global_states[rfkill->type].current_state,
|
|
|
|
0);
|
2008-07-03 18:14:57 +02:00
|
|
|
|
|
|
|
list_add_tail(&rfkill->node, &rfkill_list);
|
2007-05-07 09:34:20 +02:00
|
|
|
|
2008-08-02 20:10:57 +02:00
|
|
|
error = 0;
|
|
|
|
unlock_out:
|
2008-08-26 16:58:00 +02:00
|
|
|
mutex_unlock(&rfkill_global_mutex);
|
2007-10-28 15:16:50 +01:00
|
|
|
|
2008-08-02 20:10:57 +02:00
|
|
|
return error;
|
2007-05-07 09:34:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void rfkill_remove_switch(struct rfkill *rfkill)
|
|
|
|
{
|
2008-08-26 16:58:00 +02:00
|
|
|
mutex_lock(&rfkill_global_mutex);
|
2007-05-07 09:34:20 +02:00
|
|
|
list_del_init(&rfkill->node);
|
2008-08-26 16:58:00 +02:00
|
|
|
mutex_unlock(&rfkill_global_mutex);
|
2008-07-22 02:18:20 +02:00
|
|
|
|
|
|
|
mutex_lock(&rfkill->mutex);
|
|
|
|
rfkill_toggle_radio(rfkill, RFKILL_STATE_SOFT_BLOCKED, 1);
|
|
|
|
mutex_unlock(&rfkill->mutex);
|
2007-05-07 09:34:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rfkill_allocate - allocate memory for rfkill structure.
|
|
|
|
* @parent: device that has rf switch on it
|
2007-09-13 09:20:42 +02:00
|
|
|
* @type: type of the switch (RFKILL_TYPE_*)
|
2007-05-07 09:34:20 +02:00
|
|
|
*
|
|
|
|
* This function should be called by the network driver when it needs
|
2008-07-22 02:18:22 +02:00
|
|
|
* rfkill structure. Once the structure is allocated the driver should
|
|
|
|
* finish its initialization by setting the name, private data, enable_radio
|
2007-05-07 09:34:20 +02:00
|
|
|
* and disable_radio methods and then register it with rfkill_register().
|
2008-07-22 02:18:22 +02:00
|
|
|
*
|
2007-05-07 09:34:20 +02:00
|
|
|
* NOTE: If registration fails the structure shoudl be freed by calling
|
|
|
|
* rfkill_free() otherwise rfkill_unregister() should be used.
|
|
|
|
*/
|
2008-08-02 20:10:59 +02:00
|
|
|
struct rfkill * __must_check rfkill_allocate(struct device *parent,
|
|
|
|
enum rfkill_type type)
|
2007-05-07 09:34:20 +02:00
|
|
|
{
|
|
|
|
struct rfkill *rfkill;
|
|
|
|
struct device *dev;
|
|
|
|
|
2008-08-26 16:57:59 +02:00
|
|
|
if (WARN((type >= RFKILL_TYPE_MAX),
|
|
|
|
KERN_WARNING
|
|
|
|
"rfkill: illegal type %d passed as parameter "
|
|
|
|
"to rfkill_allocate\n", type))
|
|
|
|
return NULL;
|
|
|
|
|
2007-05-07 09:34:20 +02:00
|
|
|
rfkill = kzalloc(sizeof(struct rfkill), GFP_KERNEL);
|
2007-05-19 21:24:39 +02:00
|
|
|
if (!rfkill)
|
2007-05-07 09:34:20 +02:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
mutex_init(&rfkill->mutex);
|
|
|
|
INIT_LIST_HEAD(&rfkill->node);
|
|
|
|
rfkill->type = type;
|
|
|
|
|
|
|
|
dev = &rfkill->dev;
|
|
|
|
dev->class = &rfkill_class;
|
|
|
|
dev->parent = parent;
|
|
|
|
device_initialize(dev);
|
|
|
|
|
|
|
|
__module_get(THIS_MODULE);
|
|
|
|
|
|
|
|
return rfkill;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(rfkill_allocate);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rfkill_free - Mark rfkill structure for deletion
|
|
|
|
* @rfkill: rfkill structure to be destroyed
|
|
|
|
*
|
2008-07-22 02:18:22 +02:00
|
|
|
* Decrements reference count of the rfkill structure so it is destroyed.
|
2007-05-07 09:34:20 +02:00
|
|
|
* Note that rfkill_free() should _not_ be called after rfkill_unregister().
|
|
|
|
*/
|
|
|
|
void rfkill_free(struct rfkill *rfkill)
|
|
|
|
{
|
|
|
|
if (rfkill)
|
|
|
|
put_device(&rfkill->dev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(rfkill_free);
|
|
|
|
|
2007-09-27 21:33:12 +02:00
|
|
|
static void rfkill_led_trigger_register(struct rfkill *rfkill)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_RFKILL_LEDS
|
|
|
|
int error;
|
|
|
|
|
2008-07-22 12:17:37 +02:00
|
|
|
if (!rfkill->led_trigger.name)
|
2008-11-10 22:55:14 +01:00
|
|
|
rfkill->led_trigger.name = dev_name(&rfkill->dev);
|
2008-07-22 12:21:59 +02:00
|
|
|
if (!rfkill->led_trigger.activate)
|
|
|
|
rfkill->led_trigger.activate = rfkill_led_trigger_activate;
|
2007-09-27 21:33:12 +02:00
|
|
|
error = led_trigger_register(&rfkill->led_trigger);
|
|
|
|
if (error)
|
|
|
|
rfkill->led_trigger.name = NULL;
|
|
|
|
#endif /* CONFIG_RFKILL_LEDS */
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rfkill_led_trigger_unregister(struct rfkill *rfkill)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_RFKILL_LEDS
|
2008-07-22 02:18:18 +02:00
|
|
|
if (rfkill->led_trigger.name) {
|
2007-09-27 21:33:12 +02:00
|
|
|
led_trigger_unregister(&rfkill->led_trigger);
|
2008-07-22 02:18:18 +02:00
|
|
|
rfkill->led_trigger.name = NULL;
|
|
|
|
}
|
2007-09-27 21:33:12 +02:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2007-05-07 09:34:20 +02:00
|
|
|
/**
|
|
|
|
* rfkill_register - Register a rfkill structure.
|
|
|
|
* @rfkill: rfkill structure to be registered
|
|
|
|
*
|
|
|
|
* This function should be called by the network driver when the rfkill
|
|
|
|
* structure needs to be registered. Immediately from registration the
|
|
|
|
* switch driver should be able to service calls to toggle_radio.
|
|
|
|
*/
|
2008-08-02 20:10:59 +02:00
|
|
|
int __must_check rfkill_register(struct rfkill *rfkill)
|
2007-05-07 09:34:20 +02:00
|
|
|
{
|
|
|
|
static atomic_t rfkill_no = ATOMIC_INIT(0);
|
|
|
|
struct device *dev = &rfkill->dev;
|
|
|
|
int error;
|
|
|
|
|
2008-08-26 16:57:59 +02:00
|
|
|
if (WARN((!rfkill || !rfkill->toggle_radio ||
|
|
|
|
rfkill->type >= RFKILL_TYPE_MAX ||
|
|
|
|
rfkill->state >= RFKILL_STATE_MAX),
|
|
|
|
KERN_WARNING
|
|
|
|
"rfkill: attempt to register a "
|
|
|
|
"badly initialized rfkill struct\n"))
|
2008-08-02 20:11:00 +02:00
|
|
|
return -EINVAL;
|
2007-05-07 09:34:20 +02:00
|
|
|
|
2008-11-10 22:55:14 +01:00
|
|
|
dev_set_name(dev, "rfkill%ld", (long)atomic_inc_return(&rfkill_no) - 1);
|
2007-10-28 13:07:54 +01:00
|
|
|
|
|
|
|
rfkill_led_trigger_register(rfkill);
|
|
|
|
|
2007-05-07 09:34:20 +02:00
|
|
|
error = rfkill_add_switch(rfkill);
|
2008-01-13 22:20:56 +01:00
|
|
|
if (error) {
|
|
|
|
rfkill_led_trigger_unregister(rfkill);
|
2007-05-07 09:34:20 +02:00
|
|
|
return error;
|
2008-01-13 22:20:56 +01:00
|
|
|
}
|
2007-05-07 09:34:20 +02:00
|
|
|
|
|
|
|
error = device_add(dev);
|
|
|
|
if (error) {
|
|
|
|
rfkill_remove_switch(rfkill);
|
2008-07-22 02:18:18 +02:00
|
|
|
rfkill_led_trigger_unregister(rfkill);
|
2007-05-07 09:34:20 +02:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(rfkill_register);
|
|
|
|
|
|
|
|
/**
|
2008-06-23 22:22:57 +02:00
|
|
|
* rfkill_unregister - Unregister a rfkill structure.
|
2007-05-07 09:34:20 +02:00
|
|
|
* @rfkill: rfkill structure to be unregistered
|
|
|
|
*
|
|
|
|
* This function should be called by the network driver during device
|
|
|
|
* teardown to destroy rfkill structure. Note that rfkill_free() should
|
|
|
|
* _not_ be called after rfkill_unregister().
|
|
|
|
*/
|
|
|
|
void rfkill_unregister(struct rfkill *rfkill)
|
|
|
|
{
|
2008-08-26 16:57:59 +02:00
|
|
|
BUG_ON(!rfkill);
|
2007-05-07 09:34:20 +02:00
|
|
|
device_del(&rfkill->dev);
|
|
|
|
rfkill_remove_switch(rfkill);
|
2007-10-28 13:07:54 +01:00
|
|
|
rfkill_led_trigger_unregister(rfkill);
|
2007-05-07 09:34:20 +02:00
|
|
|
put_device(&rfkill->dev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(rfkill_unregister);
|
|
|
|
|
2008-08-02 20:10:58 +02:00
|
|
|
/**
|
|
|
|
* rfkill_set_default - set initial value for a switch type
|
|
|
|
* @type - the type of switch to set the default state of
|
|
|
|
* @state - the new default state for that group of switches
|
|
|
|
*
|
|
|
|
* Sets the initial state rfkill should use for a given type.
|
|
|
|
* The following initial states are allowed: RFKILL_STATE_SOFT_BLOCKED
|
|
|
|
* and RFKILL_STATE_UNBLOCKED.
|
|
|
|
*
|
|
|
|
* This function is meant to be used by platform drivers for platforms
|
|
|
|
* that can save switch state across power down/reboot.
|
|
|
|
*
|
|
|
|
* The default state for each switch type can be changed exactly once.
|
|
|
|
* After a switch of that type is registered, the default state cannot
|
|
|
|
* be changed anymore. This guards against multiple drivers it the
|
|
|
|
* same platform trying to set the initial switch default state, which
|
|
|
|
* is not allowed.
|
|
|
|
*
|
|
|
|
* Returns -EPERM if the state has already been set once or is in use,
|
|
|
|
* so drivers likely want to either ignore or at most printk(KERN_NOTICE)
|
|
|
|
* if this function returns -EPERM.
|
|
|
|
*
|
|
|
|
* Returns 0 if the new default state was set, or an error if it
|
|
|
|
* could not be set.
|
|
|
|
*/
|
|
|
|
int rfkill_set_default(enum rfkill_type type, enum rfkill_state state)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2008-08-26 16:57:59 +02:00
|
|
|
if (WARN((type >= RFKILL_TYPE_MAX ||
|
|
|
|
(state != RFKILL_STATE_SOFT_BLOCKED &&
|
|
|
|
state != RFKILL_STATE_UNBLOCKED)),
|
|
|
|
KERN_WARNING
|
|
|
|
"rfkill: illegal state %d or type %d passed as "
|
|
|
|
"parameter to rfkill_set_default\n", state, type))
|
2008-08-02 20:10:58 +02:00
|
|
|
return -EINVAL;
|
|
|
|
|
2008-08-26 16:58:00 +02:00
|
|
|
mutex_lock(&rfkill_global_mutex);
|
2008-08-02 20:10:58 +02:00
|
|
|
|
|
|
|
if (!test_and_set_bit(type, rfkill_states_lockdflt)) {
|
|
|
|
rfkill_global_states[type].default_state = state;
|
2008-10-09 23:15:30 +02:00
|
|
|
rfkill_global_states[type].current_state = state;
|
2008-08-02 20:10:58 +02:00
|
|
|
error = 0;
|
|
|
|
} else
|
|
|
|
error = -EPERM;
|
|
|
|
|
2008-08-26 16:58:00 +02:00
|
|
|
mutex_unlock(&rfkill_global_mutex);
|
2008-08-02 20:10:58 +02:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rfkill_set_default);
|
|
|
|
|
2007-05-07 09:34:20 +02:00
|
|
|
/*
|
|
|
|
* Rfkill module initialization/deinitialization.
|
|
|
|
*/
|
|
|
|
static int __init rfkill_init(void)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
int i;
|
|
|
|
|
2008-06-23 22:46:42 +02:00
|
|
|
/* RFKILL_STATE_HARD_BLOCKED is illegal here... */
|
|
|
|
if (rfkill_default_state != RFKILL_STATE_SOFT_BLOCKED &&
|
|
|
|
rfkill_default_state != RFKILL_STATE_UNBLOCKED)
|
2008-06-23 22:22:59 +02:00
|
|
|
return -EINVAL;
|
|
|
|
|
2008-08-02 20:10:58 +02:00
|
|
|
for (i = 0; i < RFKILL_TYPE_MAX; i++)
|
|
|
|
rfkill_global_states[i].default_state = rfkill_default_state;
|
2007-05-07 09:34:20 +02:00
|
|
|
|
|
|
|
error = class_register(&rfkill_class);
|
|
|
|
if (error) {
|
|
|
|
printk(KERN_ERR "rfkill: unable to register rfkill class\n");
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2008-06-23 22:23:05 +02:00
|
|
|
register_rfkill_notifier(&rfkill_blocking_uevent_nb);
|
|
|
|
|
2007-05-07 09:34:20 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit rfkill_exit(void)
|
|
|
|
{
|
2008-06-23 22:23:05 +02:00
|
|
|
unregister_rfkill_notifier(&rfkill_blocking_uevent_nb);
|
2007-05-07 09:34:20 +02:00
|
|
|
class_unregister(&rfkill_class);
|
|
|
|
}
|
|
|
|
|
2007-10-28 14:39:02 +01:00
|
|
|
subsys_initcall(rfkill_init);
|
2007-05-07 09:34:20 +02:00
|
|
|
module_exit(rfkill_exit);
|