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