[linux-2.6-block.git] / net / wimax / op-rfkill.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Linux WiMAX
 * RF-kill framework integration
 *
 * Copyright (C) 2008 Intel Corporation <linux-wimax@intel.com>
 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
 *
 * This integrates into the Linux Kernel rfkill susbystem so that the
 * drivers just have to do the bare minimal work, which is providing a
 * method to set the software RF-Kill switch and to report changes in
 * the software and hardware switch status.
 *
 * A non-polled generic rfkill device is embedded into the WiMAX
 * subsystem's representation of a device.
 *
 * FIXME: Need polled support? Let drivers provide a poll routine
 *	  and hand it to rfkill ops then?
 *
 * All device drivers have to do is after wimax_dev_init(), call
 * wimax_report_rfkill_hw() and wimax_report_rfkill_sw() to update
 * initial state and then every time it changes. See wimax.h:struct
 * wimax_dev for more information.
 *
 * ROADMAP
 *
 * wimax_gnl_doit_rfkill()      User space calling wimax_rfkill()
 *   wimax_rfkill()             Kernel calling wimax_rfkill()
 *     __wimax_rf_toggle_radio()
 *
 * wimax_rfkill_set_radio_block()  RF-Kill subsystem calling
 *   __wimax_rf_toggle_radio()
 *
 * __wimax_rf_toggle_radio()
 *   wimax_dev->op_rfkill_sw_toggle() Driver backend
 *   __wimax_state_change()
 *
 * wimax_report_rfkill_sw()     Driver reports state change
 *   __wimax_state_change()
 *
 * wimax_report_rfkill_hw()     Driver reports state change
 *   __wimax_state_change()
 *
 * wimax_rfkill_add()           Initialize/shutdown rfkill support
 * wimax_rfkill_rm()            [called by wimax_dev_add/rm()]
 */

#include <net/wimax.h>
#include <net/genetlink.h>
#include <linux/wimax.h>
#include <linux/security.h>
#include <linux/rfkill.h>
#include <linux/export.h>
#include "wimax-internal.h"

#define D_SUBMODULE op_rfkill
#include "debug-levels.h"

/**
 * wimax_report_rfkill_hw - Reports changes in the hardware RF switch
 *
 * @wimax_dev: WiMAX device descriptor
 *
 * @state: New state of the RF Kill switch. %WIMAX_RF_ON radio on,
 *     %WIMAX_RF_OFF radio off.
 *
 * When the device detects a change in the state of thehardware RF
 * switch, it must call this function to let the WiMAX kernel stack
 * know that the state has changed so it can be properly propagated.
 *
 * The WiMAX stack caches the state (the driver doesn't need to). As
 * well, as the change is propagated it will come back as a request to
 * change the software state to mirror the hardware state.
 *
 * If the device doesn't have a hardware kill switch, just report
 * it on initialization as always on (%WIMAX_RF_ON, radio on).
 */
void wimax_report_rfkill_hw(struct wimax_dev *wimax_dev,
			    enum wimax_rf_state state)
{
	int result;
	struct device *dev = wimax_dev_to_dev(wimax_dev);
	enum wimax_st wimax_state;

	d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
	BUG_ON(state == WIMAX_RF_QUERY);
	BUG_ON(state != WIMAX_RF_ON && state != WIMAX_RF_OFF);

	mutex_lock(&wimax_dev->mutex);
	result = wimax_dev_is_ready(wimax_dev);
	if (result < 0)
		goto error_not_ready;

	if (state != wimax_dev->rf_hw) {
		wimax_dev->rf_hw = state;
		if (wimax_dev->rf_hw == WIMAX_RF_ON &&
		    wimax_dev->rf_sw == WIMAX_RF_ON)
			wimax_state = WIMAX_ST_READY;
		else
			wimax_state = WIMAX_ST_RADIO_OFF;

		result = rfkill_set_hw_state(wimax_dev->rfkill,
					     state == WIMAX_RF_OFF);

		__wimax_state_change(wimax_dev, wimax_state);
	}
error_not_ready:
	mutex_unlock(&wimax_dev->mutex);
	d_fnend(3, dev, "(wimax_dev %p state %u) = void [%d]\n",
		wimax_dev, state, result);
}
EXPORT_SYMBOL_GPL(wimax_report_rfkill_hw);


/**
 * wimax_report_rfkill_sw - Reports changes in the software RF switch
 *
 * @wimax_dev: WiMAX device descriptor
 *
 * @state: New state of the RF kill switch. %WIMAX_RF_ON radio on,
 *     %WIMAX_RF_OFF radio off.
 *
 * Reports changes in the software RF switch state to the WiMAX stack.
 *
 * The main use is during initialization, so the driver can query the
 * device for its current software radio kill switch state and feed it
 * to the system.
 *
 * On the side, the device does not change the software state by
 * itself. In practice, this can happen, as the device might decide to
 * switch (in software) the radio off for different reasons.
 */
void wimax_report_rfkill_sw(struct wimax_dev *wimax_dev,
			    enum wimax_rf_state state)
{
	int result;
	struct device *dev = wimax_dev_to_dev(wimax_dev);
	enum wimax_st wimax_state;

	d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
	BUG_ON(state == WIMAX_RF_QUERY);
	BUG_ON(state != WIMAX_RF_ON && state != WIMAX_RF_OFF);

	mutex_lock(&wimax_dev->mutex);
	result = wimax_dev_is_ready(wimax_dev);
	if (result < 0)
		goto error_not_ready;

	if (state != wimax_dev->rf_sw) {
		wimax_dev->rf_sw = state;
		if (wimax_dev->rf_hw == WIMAX_RF_ON &&
		    wimax_dev->rf_sw == WIMAX_RF_ON)
			wimax_state = WIMAX_ST_READY;
		else
			wimax_state = WIMAX_ST_RADIO_OFF;
		__wimax_state_change(wimax_dev, wimax_state);
		rfkill_set_sw_state(wimax_dev->rfkill, state == WIMAX_RF_OFF);
	}
error_not_ready:
	mutex_unlock(&wimax_dev->mutex);
	d_fnend(3, dev, "(wimax_dev %p state %u) = void [%d]\n",
		wimax_dev, state, result);
}
EXPORT_SYMBOL_GPL(wimax_report_rfkill_sw);


/*
 * Callback for the RF Kill toggle operation
 *
 * This function is called by:
 *
 * - The rfkill subsystem when the RF-Kill key is pressed in the
 *   hardware and the driver notifies through
 *   wimax_report_rfkill_hw(). The rfkill subsystem ends up calling back
 *   here so the software RF Kill switch state is changed to reflect
 *   the hardware switch state.
 *
 * - When the user sets the state through sysfs' rfkill/state file
 *
 * - When the user calls wimax_rfkill().
 *
 * This call blocks!
 *
 * WARNING! When we call rfkill_unregister(), this will be called with
 * state 0!
 *
 * WARNING: wimax_dev must be locked
 */
static
int __wimax_rf_toggle_radio(struct wimax_dev *wimax_dev,
			    enum wimax_rf_state state)
{
	int result = 0;
	struct device *dev = wimax_dev_to_dev(wimax_dev);
	enum wimax_st wimax_state;

	might_sleep();
	d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
	if (wimax_dev->rf_sw == state)
		goto out_no_change;
	if (wimax_dev->op_rfkill_sw_toggle != NULL)
		result = wimax_dev->op_rfkill_sw_toggle(wimax_dev, state);
	else if (state == WIMAX_RF_OFF)	/* No op? can't turn off */
		result = -ENXIO;
	else				/* No op? can turn on */
		result = 0;		/* should never happen tho */
	if (result >= 0) {
		result = 0;
		wimax_dev->rf_sw = state;
		wimax_state = state == WIMAX_RF_ON ?
			WIMAX_ST_READY : WIMAX_ST_RADIO_OFF;
		__wimax_state_change(wimax_dev, wimax_state);
	}
out_no_change:
	d_fnend(3, dev, "(wimax_dev %p state %u) = %d\n",
		wimax_dev, state, result);
	return result;
}


/*
 * Translate from rfkill state to wimax state
 *
 * NOTE: Special state handling rules here
 *
 *     Just pretend the call didn't happen if we are in a state where
 *     we know for sure it cannot be handled (WIMAX_ST_DOWN or
 *     __WIMAX_ST_QUIESCING). rfkill() needs it to register and
 *     unregister, as it will run this path.
 *
 * NOTE: This call will block until the operation is completed.
 */
static int wimax_rfkill_set_radio_block(void *data, bool blocked)
{
	int result;
	struct wimax_dev *wimax_dev = data;
	struct device *dev = wimax_dev_to_dev(wimax_dev);
	enum wimax_rf_state rf_state;

	d_fnstart(3, dev, "(wimax_dev %p blocked %u)\n", wimax_dev, blocked);
	rf_state = WIMAX_RF_ON;
	if (blocked)
		rf_state = WIMAX_RF_OFF;
	mutex_lock(&wimax_dev->mutex);
	if (wimax_dev->state <= __WIMAX_ST_QUIESCING)
		result = 0;
	else
		result = __wimax_rf_toggle_radio(wimax_dev, rf_state);
	mutex_unlock(&wimax_dev->mutex);
	d_fnend(3, dev, "(wimax_dev %p blocked %u) = %d\n",
		wimax_dev, blocked, result);
	return result;
}

static const struct rfkill_ops wimax_rfkill_ops = {
	.set_block = wimax_rfkill_set_radio_block,
};

/**
 * wimax_rfkill - Set the software RF switch state for a WiMAX device
 *
 * @wimax_dev: WiMAX device descriptor
 *
 * @state: New RF state.
 *
 * Returns:
 *
 * >= 0 toggle state if ok, < 0 errno code on error. The toggle state
 * is returned as a bitmap, bit 0 being the hardware RF state, bit 1
 * the software RF state.
 *
 * 0 means disabled (%WIMAX_RF_ON, radio on), 1 means enabled radio
 * off (%WIMAX_RF_OFF).
 *
 * Description:
 *
 * Called by the user when he wants to request the WiMAX radio to be
 * switched on (%WIMAX_RF_ON) or off (%WIMAX_RF_OFF). With
 * %WIMAX_RF_QUERY, just the current state is returned.
 *
 * NOTE:
 *
 * This call will block until the operation is complete.
 */
int wimax_rfkill(struct wimax_dev *wimax_dev, enum wimax_rf_state state)
{
	int result;
	struct device *dev = wimax_dev_to_dev(wimax_dev);

	d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
	mutex_lock(&wimax_dev->mutex);
	result = wimax_dev_is_ready(wimax_dev);
	if (result < 0) {
		/* While initializing, < 1.4.3 wimax-tools versions use
		 * this call to check if the device is a valid WiMAX
		 * device; so we allow it to proceed always,
		 * considering the radios are all off. */
		if (result == -ENOMEDIUM && state == WIMAX_RF_QUERY)
			result = WIMAX_RF_OFF << 1 | WIMAX_RF_OFF;
		goto error_not_ready;
	}
	switch (state) {
	case WIMAX_RF_ON:
	case WIMAX_RF_OFF:
		result = __wimax_rf_toggle_radio(wimax_dev, state);
		if (result < 0)
			goto error;
		rfkill_set_sw_state(wimax_dev->rfkill, state == WIMAX_RF_OFF);
		break;
	case WIMAX_RF_QUERY:
		break;
	default:
		result = -EINVAL;
		goto error;
	}
	result = wimax_dev->rf_sw << 1 | wimax_dev->rf_hw;
error:
error_not_ready:
	mutex_unlock(&wimax_dev->mutex);
	d_fnend(3, dev, "(wimax_dev %p state %u) = %d\n",
		wimax_dev, state, result);
	return result;
}
EXPORT_SYMBOL(wimax_rfkill);


/*
 * Register a new WiMAX device's RF Kill support
 *
 * WARNING: wimax_dev->mutex must be unlocked
 */
int wimax_rfkill_add(struct wimax_dev *wimax_dev)
{
	int result;
	struct rfkill *rfkill;
	struct device *dev = wimax_dev_to_dev(wimax_dev);

	d_fnstart(3, dev, "(wimax_dev %p)\n", wimax_dev);
	/* Initialize RF Kill */
	result = -ENOMEM;
	rfkill = rfkill_alloc(wimax_dev->name, dev, RFKILL_TYPE_WIMAX,
			      &wimax_rfkill_ops, wimax_dev);
	if (rfkill == NULL)
		goto error_rfkill_allocate;

	d_printf(1, dev, "rfkill %p\n", rfkill);

	wimax_dev->rfkill = rfkill;

	rfkill_init_sw_state(rfkill, 1);
	result = rfkill_register(wimax_dev->rfkill);
	if (result < 0)
		goto error_rfkill_register;

	/* If there is no SW toggle op, SW RFKill is always on */
	if (wimax_dev->op_rfkill_sw_toggle == NULL)
		wimax_dev->rf_sw = WIMAX_RF_ON;

	d_fnend(3, dev, "(wimax_dev %p) = 0\n", wimax_dev);
	return 0;

error_rfkill_register:
	rfkill_destroy(wimax_dev->rfkill);
error_rfkill_allocate:
	d_fnend(3, dev, "(wimax_dev %p) = %d\n", wimax_dev, result);
	return result;
}


/*
 * Deregister a WiMAX device's RF Kill support
 *
 * Ick, we can't call rfkill_free() after rfkill_unregister()...oh
 * well.
 *
 * WARNING: wimax_dev->mutex must be unlocked
 */
void wimax_rfkill_rm(struct wimax_dev *wimax_dev)
{
	struct device *dev = wimax_dev_to_dev(wimax_dev);
	d_fnstart(3, dev, "(wimax_dev %p)\n", wimax_dev);
	rfkill_unregister(wimax_dev->rfkill);
	rfkill_destroy(wimax_dev->rfkill);
	d_fnend(3, dev, "(wimax_dev %p)\n", wimax_dev);
}


/*
 * Exporting to user space over generic netlink
 *
 * Parse the rfkill command from user space, return a combination
 * value that describe the states of the different toggles.
 *
 * Only one attribute: the new state requested (on, off or no change,
 * just query).
 */

int wimax_gnl_doit_rfkill(struct sk_buff *skb, struct genl_info *info)
{
	int result, ifindex;
	struct wimax_dev *wimax_dev;
	struct device *dev;
	enum wimax_rf_state new_state;

	d_fnstart(3, NULL, "(skb %p info %p)\n", skb, info);
	result = -ENODEV;
	if (info->attrs[WIMAX_GNL_RFKILL_IFIDX] == NULL) {
		pr_err("WIMAX_GNL_OP_RFKILL: can't find IFIDX attribute\n");
		goto error_no_wimax_dev;
	}
	ifindex = nla_get_u32(info->attrs[WIMAX_GNL_RFKILL_IFIDX]);
	wimax_dev = wimax_dev_get_by_genl_info(info, ifindex);
	if (wimax_dev == NULL)
		goto error_no_wimax_dev;
	dev = wimax_dev_to_dev(wimax_dev);
	result = -EINVAL;
	if (info->attrs[WIMAX_GNL_RFKILL_STATE] == NULL) {
		dev_err(dev, "WIMAX_GNL_RFKILL: can't find RFKILL_STATE "
			"attribute\n");
		goto error_no_pid;
	}
	new_state = nla_get_u32(info->attrs[WIMAX_GNL_RFKILL_STATE]);

	/* Execute the operation and send the result back to user space */
	result = wimax_rfkill(wimax_dev, new_state);
error_no_pid:
	dev_put(wimax_dev->net_dev);
error_no_wimax_dev:
	d_fnend(3, NULL, "(skb %p info %p) = %d\n", skb, info, result);
	return result;
}
Commit	Line	Data
04672fe6	1	// SPDX-License-Identifier: GPL-2.0-only
3e65646b IPG	2	/*
	3	* Linux WiMAX
	4	* RF-kill framework integration
	5	*
3e65646b IPG	6	* Copyright (C) 2008 Intel Corporation <linux-wimax@intel.com>
	7	* Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
	8	*
3e65646b IPG	9	* This integrates into the Linux Kernel rfkill susbystem so that the
	10	* drivers just have to do the bare minimal work, which is providing a
	11	* method to set the software RF-Kill switch and to report changes in
	12	* the software and hardware switch status.
	13	*
	14	* A non-polled generic rfkill device is embedded into the WiMAX
	15	* subsystem's representation of a device.
	16	*
19d337df JB	17	* FIXME: Need polled support? Let drivers provide a poll routine
19d337df JB	18	* and hand it to rfkill ops then?
3e65646b IPG	19	*
	20	* All device drivers have to do is after wimax_dev_init(), call
	21	* wimax_report_rfkill_hw() and wimax_report_rfkill_sw() to update
	22	* initial state and then every time it changes. See wimax.h:struct
	23	* wimax_dev for more information.
	24	*
	25	* ROADMAP
	26	*
	27	* wimax_gnl_doit_rfkill() User space calling wimax_rfkill()
	28	* wimax_rfkill() Kernel calling wimax_rfkill()
	29	* __wimax_rf_toggle_radio()
	30	*
88393161	31	* wimax_rfkill_set_radio_block() RF-Kill subsystem calling
3e65646b IPG	32	* __wimax_rf_toggle_radio()
	33	*
	34	* __wimax_rf_toggle_radio()
	35	* wimax_dev->op_rfkill_sw_toggle() Driver backend
	36	* __wimax_state_change()
	37	*
	38	* wimax_report_rfkill_sw() Driver reports state change
	39	* __wimax_state_change()
	40	*
	41	* wimax_report_rfkill_hw() Driver reports state change
	42	* __wimax_state_change()
	43	*
	44	* wimax_rfkill_add() Initialize/shutdown rfkill support
	45	* wimax_rfkill_rm() [called by wimax_dev_add/rm()]
	46	*/
	47
	48	#include <net/wimax.h>
	49	#include <net/genetlink.h>
	50	#include <linux/wimax.h>
	51	#include <linux/security.h>
	52	#include <linux/rfkill.h>
bc3b2d7f	53	#include <linux/export.h>
3e65646b IPG	54	#include "wimax-internal.h"
	55
	56	#define D_SUBMODULE op_rfkill
	57	#include "debug-levels.h"
	58
3e65646b IPG	59	/**
	60	* wimax_report_rfkill_hw - Reports changes in the hardware RF switch
	61	*
	62	* @wimax_dev: WiMAX device descriptor
	63	*
	64	* @state: New state of the RF Kill switch. %WIMAX_RF_ON radio on,
	65	* %WIMAX_RF_OFF radio off.
	66	*
	67	* When the device detects a change in the state of thehardware RF
	68	* switch, it must call this function to let the WiMAX kernel stack
	69	* know that the state has changed so it can be properly propagated.
	70	*
	71	* The WiMAX stack caches the state (the driver doesn't need to). As
	72	* well, as the change is propagated it will come back as a request to
	73	* change the software state to mirror the hardware state.
	74	*
	75	* If the device doesn't have a hardware kill switch, just report
	76	* it on initialization as always on (%WIMAX_RF_ON, radio on).
	77	*/
	78	void wimax_report_rfkill_hw(struct wimax_dev *wimax_dev,
	79	enum wimax_rf_state state)
	80	{
	81	int result;
	82	struct device *dev = wimax_dev_to_dev(wimax_dev);
	83	enum wimax_st wimax_state;
3e65646b IPG	84
	85	d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
	86	BUG_ON(state == WIMAX_RF_QUERY);
	87	BUG_ON(state != WIMAX_RF_ON && state != WIMAX_RF_OFF);
	88
	89	mutex_lock(&wimax_dev->mutex);
	90	result = wimax_dev_is_ready(wimax_dev);
	91	if (result < 0)
	92	goto error_not_ready;
	93
	94	if (state != wimax_dev->rf_hw) {
	95	wimax_dev->rf_hw = state;
f64f9e71 JP	96	if (wimax_dev->rf_hw == WIMAX_RF_ON &&
f64f9e71 JP	97	wimax_dev->rf_sw == WIMAX_RF_ON)
3e65646b IPG	98	wimax_state = WIMAX_ST_READY;
	99	else
	100	wimax_state = WIMAX_ST_RADIO_OFF;
19d337df	101
d2f4c105 IPG	102	result = rfkill_set_hw_state(wimax_dev->rfkill,
d2f4c105 IPG	103	state == WIMAX_RF_OFF);
19d337df	104
3e65646b	105	__wimax_state_change(wimax_dev, wimax_state);
3e65646b IPG	106	}
	107	error_not_ready:
	108	mutex_unlock(&wimax_dev->mutex);
	109	d_fnend(3, dev, "(wimax_dev %p state %u) = void [%d]\n",
	110	wimax_dev, state, result);
	111	}
	112	EXPORT_SYMBOL_GPL(wimax_report_rfkill_hw);
	113
	114
	115	/**
	116	* wimax_report_rfkill_sw - Reports changes in the software RF switch
	117	*
	118	* @wimax_dev: WiMAX device descriptor
	119	*
	120	* @state: New state of the RF kill switch. %WIMAX_RF_ON radio on,
	121	* %WIMAX_RF_OFF radio off.
	122	*
4933d85c	123	* Reports changes in the software RF switch state to the WiMAX stack.
3e65646b IPG	124	*
	125	* The main use is during initialization, so the driver can query the
	126	* device for its current software radio kill switch state and feed it
	127	* to the system.
	128	*
	129	* On the side, the device does not change the software state by
	130	* itself. In practice, this can happen, as the device might decide to
	131	* switch (in software) the radio off for different reasons.
	132	*/
	133	void wimax_report_rfkill_sw(struct wimax_dev *wimax_dev,
	134	enum wimax_rf_state state)
	135	{
	136	int result;
	137	struct device *dev = wimax_dev_to_dev(wimax_dev);
	138	enum wimax_st wimax_state;
	139
	140	d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
	141	BUG_ON(state == WIMAX_RF_QUERY);
	142	BUG_ON(state != WIMAX_RF_ON && state != WIMAX_RF_OFF);
	143
	144	mutex_lock(&wimax_dev->mutex);
	145	result = wimax_dev_is_ready(wimax_dev);
	146	if (result < 0)
	147	goto error_not_ready;
	148
	149	if (state != wimax_dev->rf_sw) {
	150	wimax_dev->rf_sw = state;
f64f9e71 JP	151	if (wimax_dev->rf_hw == WIMAX_RF_ON &&
f64f9e71 JP	152	wimax_dev->rf_sw == WIMAX_RF_ON)
3e65646b IPG	153	wimax_state = WIMAX_ST_READY;
	154	else
	155	wimax_state = WIMAX_ST_RADIO_OFF;
	156	__wimax_state_change(wimax_dev, wimax_state);
19d337df	157	rfkill_set_sw_state(wimax_dev->rfkill, state == WIMAX_RF_OFF);
3e65646b IPG	158	}
	159	error_not_ready:
	160	mutex_unlock(&wimax_dev->mutex);
	161	d_fnend(3, dev, "(wimax_dev %p state %u) = void [%d]\n",
	162	wimax_dev, state, result);
	163	}
	164	EXPORT_SYMBOL_GPL(wimax_report_rfkill_sw);
	165
	166
	167	/*
	168	* Callback for the RF Kill toggle operation
	169	*
	170	* This function is called by:
	171	*
	172	* - The rfkill subsystem when the RF-Kill key is pressed in the
	173	* hardware and the driver notifies through
	174	* wimax_report_rfkill_hw(). The rfkill subsystem ends up calling back
	175	* here so the software RF Kill switch state is changed to reflect
	176	* the hardware switch state.
	177	*
	178	* - When the user sets the state through sysfs' rfkill/state file
	179	*
	180	* - When the user calls wimax_rfkill().
	181	*
	182	* This call blocks!
	183	*
	184	* WARNING! When we call rfkill_unregister(), this will be called with
	185	* state 0!
	186	*
	187	* WARNING: wimax_dev must be locked
	188	*/
	189	static
	190	int __wimax_rf_toggle_radio(struct wimax_dev *wimax_dev,
	191	enum wimax_rf_state state)
	192	{
	193	int result = 0;
	194	struct device *dev = wimax_dev_to_dev(wimax_dev);
	195	enum wimax_st wimax_state;
	196
	197	might_sleep();
	198	d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
	199	if (wimax_dev->rf_sw == state)
	200	goto out_no_change;
	201	if (wimax_dev->op_rfkill_sw_toggle != NULL)
	202	result = wimax_dev->op_rfkill_sw_toggle(wimax_dev, state);
	203	else if (state == WIMAX_RF_OFF) /* No op? can't turn off */
	204	result = -ENXIO;
	205	else /* No op? can turn on */
	206	result = 0; /* should never happen tho */
	207	if (result >= 0) {
	208	result = 0;
	209	wimax_dev->rf_sw = state;
	210	wimax_state = state == WIMAX_RF_ON ?
	211	WIMAX_ST_READY : WIMAX_ST_RADIO_OFF;
	212	__wimax_state_change(wimax_dev, wimax_state);
	213	}
	214	out_no_change:
	215	d_fnend(3, dev, "(wimax_dev %p state %u) = %d\n",
	216	wimax_dev, state, result);
	217	return result;
	218	}
	219
	220
	221	/*
222	* Translate from rfkill state to wimax state
223	*
224	* NOTE: Special state handling rules here
225	*
226	* Just pretend the call didn't happen if we are in a state where
227	* we know for sure it cannot be handled (WIMAX_ST_DOWN or
228	* __WIMAX_ST_QUIESCING). rfkill() needs it to register and
229	* unregister, as it will run this path.
230	*
231	* NOTE: This call will block until the operation is completed.
232	*/
19d337df	233	static int wimax_rfkill_set_radio_block(void *data, bool blocked)
3e65646b IPG	234	{
	235	int result;
	236	struct wimax_dev *wimax_dev = data;
	237	struct device *dev = wimax_dev_to_dev(wimax_dev);
	238	enum wimax_rf_state rf_state;
	239
19d337df JB	240	d_fnstart(3, dev, "(wimax_dev %p blocked %u)\n", wimax_dev, blocked);
	241	rf_state = WIMAX_RF_ON;
	242	if (blocked)
3e65646b	243	rf_state = WIMAX_RF_OFF;
3e65646b IPG	244	mutex_lock(&wimax_dev->mutex);
3e65646b IPG	245	if (wimax_dev->state <= __WIMAX_ST_QUIESCING)
19d337df	246	result = 0;
3e65646b IPG	247	else
	248	result = __wimax_rf_toggle_radio(wimax_dev, rf_state);
	249	mutex_unlock(&wimax_dev->mutex);
19d337df JB	250	d_fnend(3, dev, "(wimax_dev %p blocked %u) = %d\n",
19d337df JB	251	wimax_dev, blocked, result);
3e65646b IPG	252	return result;
	253	}
	254
19d337df JB	255	static const struct rfkill_ops wimax_rfkill_ops = {
	256	.set_block = wimax_rfkill_set_radio_block,
	257	};
3e65646b IPG	258
	259	/**
	260	* wimax_rfkill - Set the software RF switch state for a WiMAX device
	261	*
	262	* @wimax_dev: WiMAX device descriptor
	263	*
	264	* @state: New RF state.
	265	*
	266	* Returns:
	267	*
	268	* >= 0 toggle state if ok, < 0 errno code on error. The toggle state
	269	* is returned as a bitmap, bit 0 being the hardware RF state, bit 1
	270	* the software RF state.
	271	*
	272	* 0 means disabled (%WIMAX_RF_ON, radio on), 1 means enabled radio
	273	* off (%WIMAX_RF_OFF).
	274	*
	275	* Description:
	276	*
	277	* Called by the user when he wants to request the WiMAX radio to be
	278	* switched on (%WIMAX_RF_ON) or off (%WIMAX_RF_OFF). With
	279	* %WIMAX_RF_QUERY, just the current state is returned.
	280	*
	281	* NOTE:
	282	*
	283	* This call will block until the operation is complete.
	284	*/
	285	int wimax_rfkill(struct wimax_dev *wimax_dev, enum wimax_rf_state state)
	286	{
	287	int result;
	288	struct device *dev = wimax_dev_to_dev(wimax_dev);
	289
	290	d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
	291	mutex_lock(&wimax_dev->mutex);
	292	result = wimax_dev_is_ready(wimax_dev);
81d3f905 IPG	293	if (result < 0) {
	294	/* While initializing, < 1.4.3 wimax-tools versions use
	295	* this call to check if the device is a valid WiMAX
	296	* device; so we allow it to proceed always,
	297	* considering the radios are all off. */
	298	if (result == -ENOMEDIUM && state == WIMAX_RF_QUERY)
	299	result = WIMAX_RF_OFF << 1 \| WIMAX_RF_OFF;
3e65646b	300	goto error_not_ready;
81d3f905	301	}
3e65646b IPG	302	switch (state) {
	303	case WIMAX_RF_ON:
	304	case WIMAX_RF_OFF:
	305	result = __wimax_rf_toggle_radio(wimax_dev, state);
	306	if (result < 0)
	307	goto error;
19d337df	308	rfkill_set_sw_state(wimax_dev->rfkill, state == WIMAX_RF_OFF);
3e65646b IPG	309	break;
	310	case WIMAX_RF_QUERY:
	311	break;
	312	default:
	313	result = -EINVAL;
	314	goto error;
	315	}
	316	result = wimax_dev->rf_sw << 1 \| wimax_dev->rf_hw;
	317	error:
	318	error_not_ready:
	319	mutex_unlock(&wimax_dev->mutex);
	320	d_fnend(3, dev, "(wimax_dev %p state %u) = %d\n",
	321	wimax_dev, state, result);
	322	return result;
	323	}
	324	EXPORT_SYMBOL(wimax_rfkill);
	325
	326
	327	/*
	328	* Register a new WiMAX device's RF Kill support
	329	*
	330	* WARNING: wimax_dev->mutex must be unlocked
	331	*/
	332	int wimax_rfkill_add(struct wimax_dev *wimax_dev)
	333	{
	334	int result;
	335	struct rfkill *rfkill;
3e65646b IPG	336	struct device *dev = wimax_dev_to_dev(wimax_dev);
	337
	338	d_fnstart(3, dev, "(wimax_dev %p)\n", wimax_dev);
	339	/* Initialize RF Kill */
	340	result = -ENOMEM;
19d337df JB	341	rfkill = rfkill_alloc(wimax_dev->name, dev, RFKILL_TYPE_WIMAX,
19d337df JB	342	&wimax_rfkill_ops, wimax_dev);
3e65646b IPG	343	if (rfkill == NULL)
3e65646b IPG	344	goto error_rfkill_allocate;
19d337df JB	345
	346	d_printf(1, dev, "rfkill %p\n", rfkill);
	347
3e65646b IPG	348	wimax_dev->rfkill = rfkill;
3e65646b IPG	349
c29eaf3f	350	rfkill_init_sw_state(rfkill, 1);
3e65646b IPG	351	result = rfkill_register(wimax_dev->rfkill);
	352	if (result < 0)
	353	goto error_rfkill_register;
	354
	355	/* If there is no SW toggle op, SW RFKill is always on */
	356	if (wimax_dev->op_rfkill_sw_toggle == NULL)
	357	wimax_dev->rf_sw = WIMAX_RF_ON;
	358
	359	d_fnend(3, dev, "(wimax_dev %p) = 0\n", wimax_dev);
	360	return 0;
	361
3e65646b	362	error_rfkill_register:
19d337df	363	rfkill_destroy(wimax_dev->rfkill);
3e65646b IPG	364	error_rfkill_allocate:
	365	d_fnend(3, dev, "(wimax_dev %p) = %d\n", wimax_dev, result);
	366	return result;
	367	}
	368
	369
	370	/*
	371	* Deregister a WiMAX device's RF Kill support
	372	*
	373	* Ick, we can't call rfkill_free() after rfkill_unregister()...oh
	374	* well.
	375	*
	376	* WARNING: wimax_dev->mutex must be unlocked
	377	*/
	378	void wimax_rfkill_rm(struct wimax_dev *wimax_dev)
	379	{
	380	struct device *dev = wimax_dev_to_dev(wimax_dev);
	381	d_fnstart(3, dev, "(wimax_dev %p)\n", wimax_dev);
19d337df JB	382	rfkill_unregister(wimax_dev->rfkill);
19d337df JB	383	rfkill_destroy(wimax_dev->rfkill);
3e65646b IPG	384	d_fnend(3, dev, "(wimax_dev %p)\n", wimax_dev);
	385	}
	386
	387
3e65646b IPG	388	/*
	389	* Exporting to user space over generic netlink
	390	*
	391	* Parse the rfkill command from user space, return a combination
	392	* value that describe the states of the different toggles.
	393	*
	394	* Only one attribute: the new state requested (on, off or no change,
	395	* just query).
	396	*/
	397
3e65646b IPG	398	int wimax_gnl_doit_rfkill(struct sk_buff skb, struct genl_info info)
	399	{
	400	int result, ifindex;
	401	struct wimax_dev *wimax_dev;
	402	struct device *dev;
	403	enum wimax_rf_state new_state;
	404
	405	d_fnstart(3, NULL, "(skb %p info %p)\n", skb, info);
	406	result = -ENODEV;
	407	if (info->attrs[WIMAX_GNL_RFKILL_IFIDX] == NULL) {
28b7deae	408	pr_err("WIMAX_GNL_OP_RFKILL: can't find IFIDX attribute\n");
3e65646b IPG	409	goto error_no_wimax_dev;
	410	}
	411	ifindex = nla_get_u32(info->attrs[WIMAX_GNL_RFKILL_IFIDX]);
	412	wimax_dev = wimax_dev_get_by_genl_info(info, ifindex);
	413	if (wimax_dev == NULL)
	414	goto error_no_wimax_dev;
	415	dev = wimax_dev_to_dev(wimax_dev);
	416	result = -EINVAL;
	417	if (info->attrs[WIMAX_GNL_RFKILL_STATE] == NULL) {
	418	dev_err(dev, "WIMAX_GNL_RFKILL: can't find RFKILL_STATE "
	419	"attribute\n");
	420	goto error_no_pid;
	421	}
	422	new_state = nla_get_u32(info->attrs[WIMAX_GNL_RFKILL_STATE]);
	423
	424	/* Execute the operation and send the result back to user space */
	425	result = wimax_rfkill(wimax_dev, new_state);
	426	error_no_pid:
	427	dev_put(wimax_dev->net_dev);
	428	error_no_wimax_dev:
	429	d_fnend(3, NULL, "(skb %p info %p) = %d\n", skb, info, result);
	430	return result;
	431	}