3 * RF-kill framework integration
6 * Copyright (C) 2008 Intel Corporation <linux-wimax@intel.com>
7 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
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.
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.
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
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.
29 * A non-polled generic rfkill device is embedded into the WiMAX
30 * subsystem's representation of a device.
32 * FIXME: Need polled support? Let drivers provide a poll routine
33 * and hand it to rfkill ops then?
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.
42 * wimax_gnl_doit_rfkill() User space calling wimax_rfkill()
43 * wimax_rfkill() Kernel calling wimax_rfkill()
44 * __wimax_rf_toggle_radio()
46 * wimax_rfkill_set_radio_block() RF-Kill subsytem calling
47 * __wimax_rf_toggle_radio()
49 * __wimax_rf_toggle_radio()
50 * wimax_dev->op_rfkill_sw_toggle() Driver backend
51 * __wimax_state_change()
53 * wimax_report_rfkill_sw() Driver reports state change
54 * __wimax_state_change()
56 * wimax_report_rfkill_hw() Driver reports state change
57 * __wimax_state_change()
59 * wimax_rfkill_add() Initialize/shutdown rfkill support
60 * wimax_rfkill_rm() [called by wimax_dev_add/rm()]
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"
70 #define D_SUBMODULE op_rfkill
71 #include "debug-levels.h"
74 * wimax_report_rfkill_hw - Reports changes in the hardware RF switch
76 * @wimax_dev: WiMAX device descriptor
78 * @state: New state of the RF Kill switch. %WIMAX_RF_ON radio on,
79 * %WIMAX_RF_OFF radio off.
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.
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.
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).
92 void wimax_report_rfkill_hw(struct wimax_dev
*wimax_dev
,
93 enum wimax_rf_state state
)
96 struct device
*dev
= wimax_dev_to_dev(wimax_dev
);
97 enum wimax_st wimax_state
;
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
);
103 mutex_lock(&wimax_dev
->mutex
);
104 result
= wimax_dev_is_ready(wimax_dev
);
106 goto error_not_ready
;
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
;
114 wimax_state
= WIMAX_ST_RADIO_OFF
;
116 rfkill_set_hw_state(wimax_dev
->rfkill
, state
== WIMAX_RF_OFF
);
118 __wimax_state_change(wimax_dev
, wimax_state
);
121 mutex_unlock(&wimax_dev
->mutex
);
122 d_fnend(3, dev
, "(wimax_dev %p state %u) = void [%d]\n",
123 wimax_dev
, state
, result
);
125 EXPORT_SYMBOL_GPL(wimax_report_rfkill_hw
);
129 * wimax_report_rfkill_sw - Reports changes in the software RF switch
131 * @wimax_dev: WiMAX device descriptor
133 * @state: New state of the RF kill switch. %WIMAX_RF_ON radio on,
134 * %WIMAX_RF_OFF radio off.
136 * Reports changes in the software RF switch state to the the WiMAX
139 * The main use is during initialization, so the driver can query the
140 * device for its current software radio kill switch state and feed it
143 * On the side, the device does not change the software state by
144 * itself. In practice, this can happen, as the device might decide to
145 * switch (in software) the radio off for different reasons.
147 void wimax_report_rfkill_sw(struct wimax_dev
*wimax_dev
,
148 enum wimax_rf_state state
)
151 struct device
*dev
= wimax_dev_to_dev(wimax_dev
);
152 enum wimax_st wimax_state
;
154 d_fnstart(3, dev
, "(wimax_dev %p state %u)\n", wimax_dev
, state
);
155 BUG_ON(state
== WIMAX_RF_QUERY
);
156 BUG_ON(state
!= WIMAX_RF_ON
&& state
!= WIMAX_RF_OFF
);
158 mutex_lock(&wimax_dev
->mutex
);
159 result
= wimax_dev_is_ready(wimax_dev
);
161 goto error_not_ready
;
163 if (state
!= wimax_dev
->rf_sw
) {
164 wimax_dev
->rf_sw
= state
;
165 if (wimax_dev
->rf_hw
== WIMAX_RF_ON
166 && wimax_dev
->rf_sw
== WIMAX_RF_ON
)
167 wimax_state
= WIMAX_ST_READY
;
169 wimax_state
= WIMAX_ST_RADIO_OFF
;
170 __wimax_state_change(wimax_dev
, wimax_state
);
171 rfkill_set_sw_state(wimax_dev
->rfkill
, state
== WIMAX_RF_OFF
);
174 mutex_unlock(&wimax_dev
->mutex
);
175 d_fnend(3, dev
, "(wimax_dev %p state %u) = void [%d]\n",
176 wimax_dev
, state
, result
);
178 EXPORT_SYMBOL_GPL(wimax_report_rfkill_sw
);
182 * Callback for the RF Kill toggle operation
184 * This function is called by:
186 * - The rfkill subsystem when the RF-Kill key is pressed in the
187 * hardware and the driver notifies through
188 * wimax_report_rfkill_hw(). The rfkill subsystem ends up calling back
189 * here so the software RF Kill switch state is changed to reflect
190 * the hardware switch state.
192 * - When the user sets the state through sysfs' rfkill/state file
194 * - When the user calls wimax_rfkill().
198 * WARNING! When we call rfkill_unregister(), this will be called with
201 * WARNING: wimax_dev must be locked
204 int __wimax_rf_toggle_radio(struct wimax_dev
*wimax_dev
,
205 enum wimax_rf_state state
)
208 struct device
*dev
= wimax_dev_to_dev(wimax_dev
);
209 enum wimax_st wimax_state
;
212 d_fnstart(3, dev
, "(wimax_dev %p state %u)\n", wimax_dev
, state
);
213 if (wimax_dev
->rf_sw
== state
)
215 if (wimax_dev
->op_rfkill_sw_toggle
!= NULL
)
216 result
= wimax_dev
->op_rfkill_sw_toggle(wimax_dev
, state
);
217 else if (state
== WIMAX_RF_OFF
) /* No op? can't turn off */
219 else /* No op? can turn on */
220 result
= 0; /* should never happen tho */
223 wimax_dev
->rf_sw
= state
;
224 wimax_state
= state
== WIMAX_RF_ON
?
225 WIMAX_ST_READY
: WIMAX_ST_RADIO_OFF
;
226 __wimax_state_change(wimax_dev
, wimax_state
);
229 d_fnend(3, dev
, "(wimax_dev %p state %u) = %d\n",
230 wimax_dev
, state
, result
);
236 * Translate from rfkill state to wimax state
238 * NOTE: Special state handling rules here
240 * Just pretend the call didn't happen if we are in a state where
241 * we know for sure it cannot be handled (WIMAX_ST_DOWN or
242 * __WIMAX_ST_QUIESCING). rfkill() needs it to register and
243 * unregister, as it will run this path.
245 * NOTE: This call will block until the operation is completed.
247 static int wimax_rfkill_set_radio_block(void *data
, bool blocked
)
250 struct wimax_dev
*wimax_dev
= data
;
251 struct device
*dev
= wimax_dev_to_dev(wimax_dev
);
252 enum wimax_rf_state rf_state
;
254 d_fnstart(3, dev
, "(wimax_dev %p blocked %u)\n", wimax_dev
, blocked
);
255 rf_state
= WIMAX_RF_ON
;
257 rf_state
= WIMAX_RF_OFF
;
258 mutex_lock(&wimax_dev
->mutex
);
259 if (wimax_dev
->state
<= __WIMAX_ST_QUIESCING
)
262 result
= __wimax_rf_toggle_radio(wimax_dev
, rf_state
);
263 mutex_unlock(&wimax_dev
->mutex
);
264 d_fnend(3, dev
, "(wimax_dev %p blocked %u) = %d\n",
265 wimax_dev
, blocked
, result
);
269 static const struct rfkill_ops wimax_rfkill_ops
= {
270 .set_block
= wimax_rfkill_set_radio_block
,
274 * wimax_rfkill - Set the software RF switch state for a WiMAX device
276 * @wimax_dev: WiMAX device descriptor
278 * @state: New RF state.
282 * >= 0 toggle state if ok, < 0 errno code on error. The toggle state
283 * is returned as a bitmap, bit 0 being the hardware RF state, bit 1
284 * the software RF state.
286 * 0 means disabled (%WIMAX_RF_ON, radio on), 1 means enabled radio
287 * off (%WIMAX_RF_OFF).
291 * Called by the user when he wants to request the WiMAX radio to be
292 * switched on (%WIMAX_RF_ON) or off (%WIMAX_RF_OFF). With
293 * %WIMAX_RF_QUERY, just the current state is returned.
297 * This call will block until the operation is complete.
299 int wimax_rfkill(struct wimax_dev
*wimax_dev
, enum wimax_rf_state state
)
302 struct device
*dev
= wimax_dev_to_dev(wimax_dev
);
304 d_fnstart(3, dev
, "(wimax_dev %p state %u)\n", wimax_dev
, state
);
305 mutex_lock(&wimax_dev
->mutex
);
306 result
= wimax_dev_is_ready(wimax_dev
);
308 goto error_not_ready
;
312 result
= __wimax_rf_toggle_radio(wimax_dev
, state
);
315 rfkill_set_sw_state(wimax_dev
->rfkill
, state
== WIMAX_RF_OFF
);
323 result
= wimax_dev
->rf_sw
<< 1 | wimax_dev
->rf_hw
;
326 mutex_unlock(&wimax_dev
->mutex
);
327 d_fnend(3, dev
, "(wimax_dev %p state %u) = %d\n",
328 wimax_dev
, state
, result
);
331 EXPORT_SYMBOL(wimax_rfkill
);
335 * Register a new WiMAX device's RF Kill support
337 * WARNING: wimax_dev->mutex must be unlocked
339 int wimax_rfkill_add(struct wimax_dev
*wimax_dev
)
342 struct rfkill
*rfkill
;
343 struct device
*dev
= wimax_dev_to_dev(wimax_dev
);
345 d_fnstart(3, dev
, "(wimax_dev %p)\n", wimax_dev
);
346 /* Initialize RF Kill */
348 rfkill
= rfkill_alloc(wimax_dev
->name
, dev
, RFKILL_TYPE_WIMAX
,
349 &wimax_rfkill_ops
, wimax_dev
);
351 goto error_rfkill_allocate
;
353 d_printf(1, dev
, "rfkill %p\n", rfkill
);
355 wimax_dev
->rfkill
= rfkill
;
357 result
= rfkill_register(wimax_dev
->rfkill
);
359 goto error_rfkill_register
;
361 /* If there is no SW toggle op, SW RFKill is always on */
362 if (wimax_dev
->op_rfkill_sw_toggle
== NULL
)
363 wimax_dev
->rf_sw
= WIMAX_RF_ON
;
365 d_fnend(3, dev
, "(wimax_dev %p) = 0\n", wimax_dev
);
368 error_rfkill_register
:
369 rfkill_destroy(wimax_dev
->rfkill
);
370 error_rfkill_allocate
:
371 d_fnend(3, dev
, "(wimax_dev %p) = %d\n", wimax_dev
, result
);
377 * Deregister a WiMAX device's RF Kill support
379 * Ick, we can't call rfkill_free() after rfkill_unregister()...oh
382 * WARNING: wimax_dev->mutex must be unlocked
384 void wimax_rfkill_rm(struct wimax_dev
*wimax_dev
)
386 struct device
*dev
= wimax_dev_to_dev(wimax_dev
);
387 d_fnstart(3, dev
, "(wimax_dev %p)\n", wimax_dev
);
388 rfkill_unregister(wimax_dev
->rfkill
);
389 rfkill_destroy(wimax_dev
->rfkill
);
390 d_fnend(3, dev
, "(wimax_dev %p)\n", wimax_dev
);
395 * Exporting to user space over generic netlink
397 * Parse the rfkill command from user space, return a combination
398 * value that describe the states of the different toggles.
400 * Only one attribute: the new state requested (on, off or no change,
405 struct nla_policy wimax_gnl_rfkill_policy
[WIMAX_GNL_ATTR_MAX
+ 1] = {
406 [WIMAX_GNL_RFKILL_IFIDX
] = {
409 [WIMAX_GNL_RFKILL_STATE
] = {
410 .type
= NLA_U32
/* enum wimax_rf_state */
416 int wimax_gnl_doit_rfkill(struct sk_buff
*skb
, struct genl_info
*info
)
419 struct wimax_dev
*wimax_dev
;
421 enum wimax_rf_state new_state
;
423 d_fnstart(3, NULL
, "(skb %p info %p)\n", skb
, info
);
425 if (info
->attrs
[WIMAX_GNL_RFKILL_IFIDX
] == NULL
) {
426 printk(KERN_ERR
"WIMAX_GNL_OP_RFKILL: can't find IFIDX "
428 goto error_no_wimax_dev
;
430 ifindex
= nla_get_u32(info
->attrs
[WIMAX_GNL_RFKILL_IFIDX
]);
431 wimax_dev
= wimax_dev_get_by_genl_info(info
, ifindex
);
432 if (wimax_dev
== NULL
)
433 goto error_no_wimax_dev
;
434 dev
= wimax_dev_to_dev(wimax_dev
);
436 if (info
->attrs
[WIMAX_GNL_RFKILL_STATE
] == NULL
) {
437 dev_err(dev
, "WIMAX_GNL_RFKILL: can't find RFKILL_STATE "
441 new_state
= nla_get_u32(info
->attrs
[WIMAX_GNL_RFKILL_STATE
]);
443 /* Execute the operation and send the result back to user space */
444 result
= wimax_rfkill(wimax_dev
, new_state
);
446 dev_put(wimax_dev
->net_dev
);
448 d_fnend(3, NULL
, "(skb %p info %p) = %d\n", skb
, info
, result
);
453 struct genl_ops wimax_gnl_rfkill
= {
454 .cmd
= WIMAX_GNL_OP_RFKILL
,
455 .flags
= GENL_ADMIN_PERM
,
456 .policy
= wimax_gnl_rfkill_policy
,
457 .doit
= wimax_gnl_doit_rfkill
,