Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux...
[platform/adaptation/renesas_rcar/renesas_kernel.git] / net / wimax / op-rfkill.c
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 <linux/export.h>
69 #include "wimax-internal.h"
70
71 #define D_SUBMODULE op_rfkill
72 #include "debug-levels.h"
73
74 /**
75  * wimax_report_rfkill_hw - Reports changes in the hardware RF switch
76  *
77  * @wimax_dev: WiMAX device descriptor
78  *
79  * @state: New state of the RF Kill switch. %WIMAX_RF_ON radio on,
80  *     %WIMAX_RF_OFF radio off.
81  *
82  * When the device detects a change in the state of thehardware RF
83  * switch, it must call this function to let the WiMAX kernel stack
84  * know that the state has changed so it can be properly propagated.
85  *
86  * The WiMAX stack caches the state (the driver doesn't need to). As
87  * well, as the change is propagated it will come back as a request to
88  * change the software state to mirror the hardware state.
89  *
90  * If the device doesn't have a hardware kill switch, just report
91  * it on initialization as always on (%WIMAX_RF_ON, radio on).
92  */
93 void wimax_report_rfkill_hw(struct wimax_dev *wimax_dev,
94                             enum wimax_rf_state state)
95 {
96         int result;
97         struct device *dev = wimax_dev_to_dev(wimax_dev);
98         enum wimax_st wimax_state;
99
100         d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
101         BUG_ON(state == WIMAX_RF_QUERY);
102         BUG_ON(state != WIMAX_RF_ON && state != WIMAX_RF_OFF);
103
104         mutex_lock(&wimax_dev->mutex);
105         result = wimax_dev_is_ready(wimax_dev);
106         if (result < 0)
107                 goto error_not_ready;
108
109         if (state != wimax_dev->rf_hw) {
110                 wimax_dev->rf_hw = state;
111                 if (wimax_dev->rf_hw == WIMAX_RF_ON &&
112                     wimax_dev->rf_sw == WIMAX_RF_ON)
113                         wimax_state = WIMAX_ST_READY;
114                 else
115                         wimax_state = WIMAX_ST_RADIO_OFF;
116
117                 result = rfkill_set_hw_state(wimax_dev->rfkill,
118                                              state == WIMAX_RF_OFF);
119
120                 __wimax_state_change(wimax_dev, wimax_state);
121         }
122 error_not_ready:
123         mutex_unlock(&wimax_dev->mutex);
124         d_fnend(3, dev, "(wimax_dev %p state %u) = void [%d]\n",
125                 wimax_dev, state, result);
126 }
127 EXPORT_SYMBOL_GPL(wimax_report_rfkill_hw);
128
129
130 /**
131  * wimax_report_rfkill_sw - Reports changes in the software RF switch
132  *
133  * @wimax_dev: WiMAX device descriptor
134  *
135  * @state: New state of the RF kill switch. %WIMAX_RF_ON radio on,
136  *     %WIMAX_RF_OFF radio off.
137  *
138  * Reports changes in the software RF switch state to the the WiMAX
139  * stack.
140  *
141  * The main use is during initialization, so the driver can query the
142  * device for its current software radio kill switch state and feed it
143  * to the system.
144  *
145  * On the side, the device does not change the software state by
146  * itself. In practice, this can happen, as the device might decide to
147  * switch (in software) the radio off for different reasons.
148  */
149 void wimax_report_rfkill_sw(struct wimax_dev *wimax_dev,
150                             enum wimax_rf_state state)
151 {
152         int result;
153         struct device *dev = wimax_dev_to_dev(wimax_dev);
154         enum wimax_st wimax_state;
155
156         d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
157         BUG_ON(state == WIMAX_RF_QUERY);
158         BUG_ON(state != WIMAX_RF_ON && state != WIMAX_RF_OFF);
159
160         mutex_lock(&wimax_dev->mutex);
161         result = wimax_dev_is_ready(wimax_dev);
162         if (result < 0)
163                 goto error_not_ready;
164
165         if (state != wimax_dev->rf_sw) {
166                 wimax_dev->rf_sw = state;
167                 if (wimax_dev->rf_hw == WIMAX_RF_ON &&
168                     wimax_dev->rf_sw == WIMAX_RF_ON)
169                         wimax_state = WIMAX_ST_READY;
170                 else
171                         wimax_state = WIMAX_ST_RADIO_OFF;
172                 __wimax_state_change(wimax_dev, wimax_state);
173                 rfkill_set_sw_state(wimax_dev->rfkill, state == WIMAX_RF_OFF);
174         }
175 error_not_ready:
176         mutex_unlock(&wimax_dev->mutex);
177         d_fnend(3, dev, "(wimax_dev %p state %u) = void [%d]\n",
178                 wimax_dev, state, result);
179 }
180 EXPORT_SYMBOL_GPL(wimax_report_rfkill_sw);
181
182
183 /*
184  * Callback for the RF Kill toggle operation
185  *
186  * This function is called by:
187  *
188  * - The rfkill subsystem when the RF-Kill key is pressed in the
189  *   hardware and the driver notifies through
190  *   wimax_report_rfkill_hw(). The rfkill subsystem ends up calling back
191  *   here so the software RF Kill switch state is changed to reflect
192  *   the hardware switch state.
193  *
194  * - When the user sets the state through sysfs' rfkill/state file
195  *
196  * - When the user calls wimax_rfkill().
197  *
198  * This call blocks!
199  *
200  * WARNING! When we call rfkill_unregister(), this will be called with
201  * state 0!
202  *
203  * WARNING: wimax_dev must be locked
204  */
205 static
206 int __wimax_rf_toggle_radio(struct wimax_dev *wimax_dev,
207                             enum wimax_rf_state state)
208 {
209         int result = 0;
210         struct device *dev = wimax_dev_to_dev(wimax_dev);
211         enum wimax_st wimax_state;
212
213         might_sleep();
214         d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
215         if (wimax_dev->rf_sw == state)
216                 goto out_no_change;
217         if (wimax_dev->op_rfkill_sw_toggle != NULL)
218                 result = wimax_dev->op_rfkill_sw_toggle(wimax_dev, state);
219         else if (state == WIMAX_RF_OFF) /* No op? can't turn off */
220                 result = -ENXIO;
221         else                            /* No op? can turn on */
222                 result = 0;             /* should never happen tho */
223         if (result >= 0) {
224                 result = 0;
225                 wimax_dev->rf_sw = state;
226                 wimax_state = state == WIMAX_RF_ON ?
227                         WIMAX_ST_READY : WIMAX_ST_RADIO_OFF;
228                 __wimax_state_change(wimax_dev, wimax_state);
229         }
230 out_no_change:
231         d_fnend(3, dev, "(wimax_dev %p state %u) = %d\n",
232                 wimax_dev, state, result);
233         return result;
234 }
235
236
237 /*
238  * Translate from rfkill state to wimax state
239  *
240  * NOTE: Special state handling rules here
241  *
242  *     Just pretend the call didn't happen if we are in a state where
243  *     we know for sure it cannot be handled (WIMAX_ST_DOWN or
244  *     __WIMAX_ST_QUIESCING). rfkill() needs it to register and
245  *     unregister, as it will run this path.
246  *
247  * NOTE: This call will block until the operation is completed.
248  */
249 static int wimax_rfkill_set_radio_block(void *data, bool blocked)
250 {
251         int result;
252         struct wimax_dev *wimax_dev = data;
253         struct device *dev = wimax_dev_to_dev(wimax_dev);
254         enum wimax_rf_state rf_state;
255
256         d_fnstart(3, dev, "(wimax_dev %p blocked %u)\n", wimax_dev, blocked);
257         rf_state = WIMAX_RF_ON;
258         if (blocked)
259                 rf_state = WIMAX_RF_OFF;
260         mutex_lock(&wimax_dev->mutex);
261         if (wimax_dev->state <= __WIMAX_ST_QUIESCING)
262                 result = 0;
263         else
264                 result = __wimax_rf_toggle_radio(wimax_dev, rf_state);
265         mutex_unlock(&wimax_dev->mutex);
266         d_fnend(3, dev, "(wimax_dev %p blocked %u) = %d\n",
267                 wimax_dev, blocked, result);
268         return result;
269 }
270
271 static const struct rfkill_ops wimax_rfkill_ops = {
272         .set_block = wimax_rfkill_set_radio_block,
273 };
274
275 /**
276  * wimax_rfkill - Set the software RF switch state for a WiMAX device
277  *
278  * @wimax_dev: WiMAX device descriptor
279  *
280  * @state: New RF state.
281  *
282  * Returns:
283  *
284  * >= 0 toggle state if ok, < 0 errno code on error. The toggle state
285  * is returned as a bitmap, bit 0 being the hardware RF state, bit 1
286  * the software RF state.
287  *
288  * 0 means disabled (%WIMAX_RF_ON, radio on), 1 means enabled radio
289  * off (%WIMAX_RF_OFF).
290  *
291  * Description:
292  *
293  * Called by the user when he wants to request the WiMAX radio to be
294  * switched on (%WIMAX_RF_ON) or off (%WIMAX_RF_OFF). With
295  * %WIMAX_RF_QUERY, just the current state is returned.
296  *
297  * NOTE:
298  *
299  * This call will block until the operation is complete.
300  */
301 int wimax_rfkill(struct wimax_dev *wimax_dev, enum wimax_rf_state state)
302 {
303         int result;
304         struct device *dev = wimax_dev_to_dev(wimax_dev);
305
306         d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
307         mutex_lock(&wimax_dev->mutex);
308         result = wimax_dev_is_ready(wimax_dev);
309         if (result < 0) {
310                 /* While initializing, < 1.4.3 wimax-tools versions use
311                  * this call to check if the device is a valid WiMAX
312                  * device; so we allow it to proceed always,
313                  * considering the radios are all off. */
314                 if (result == -ENOMEDIUM && state == WIMAX_RF_QUERY)
315                         result = WIMAX_RF_OFF << 1 | WIMAX_RF_OFF;
316                 goto error_not_ready;
317         }
318         switch (state) {
319         case WIMAX_RF_ON:
320         case WIMAX_RF_OFF:
321                 result = __wimax_rf_toggle_radio(wimax_dev, state);
322                 if (result < 0)
323                         goto error;
324                 rfkill_set_sw_state(wimax_dev->rfkill, state == WIMAX_RF_OFF);
325                 break;
326         case WIMAX_RF_QUERY:
327                 break;
328         default:
329                 result = -EINVAL;
330                 goto error;
331         }
332         result = wimax_dev->rf_sw << 1 | wimax_dev->rf_hw;
333 error:
334 error_not_ready:
335         mutex_unlock(&wimax_dev->mutex);
336         d_fnend(3, dev, "(wimax_dev %p state %u) = %d\n",
337                 wimax_dev, state, result);
338         return result;
339 }
340 EXPORT_SYMBOL(wimax_rfkill);
341
342
343 /*
344  * Register a new WiMAX device's RF Kill support
345  *
346  * WARNING: wimax_dev->mutex must be unlocked
347  */
348 int wimax_rfkill_add(struct wimax_dev *wimax_dev)
349 {
350         int result;
351         struct rfkill *rfkill;
352         struct device *dev = wimax_dev_to_dev(wimax_dev);
353
354         d_fnstart(3, dev, "(wimax_dev %p)\n", wimax_dev);
355         /* Initialize RF Kill */
356         result = -ENOMEM;
357         rfkill = rfkill_alloc(wimax_dev->name, dev, RFKILL_TYPE_WIMAX,
358                               &wimax_rfkill_ops, wimax_dev);
359         if (rfkill == NULL)
360                 goto error_rfkill_allocate;
361
362         d_printf(1, dev, "rfkill %p\n", rfkill);
363
364         wimax_dev->rfkill = rfkill;
365
366         rfkill_init_sw_state(rfkill, 1);
367         result = rfkill_register(wimax_dev->rfkill);
368         if (result < 0)
369                 goto error_rfkill_register;
370
371         /* If there is no SW toggle op, SW RFKill is always on */
372         if (wimax_dev->op_rfkill_sw_toggle == NULL)
373                 wimax_dev->rf_sw = WIMAX_RF_ON;
374
375         d_fnend(3, dev, "(wimax_dev %p) = 0\n", wimax_dev);
376         return 0;
377
378 error_rfkill_register:
379         rfkill_destroy(wimax_dev->rfkill);
380 error_rfkill_allocate:
381         d_fnend(3, dev, "(wimax_dev %p) = %d\n", wimax_dev, result);
382         return result;
383 }
384
385
386 /*
387  * Deregister a WiMAX device's RF Kill support
388  *
389  * Ick, we can't call rfkill_free() after rfkill_unregister()...oh
390  * well.
391  *
392  * WARNING: wimax_dev->mutex must be unlocked
393  */
394 void wimax_rfkill_rm(struct wimax_dev *wimax_dev)
395 {
396         struct device *dev = wimax_dev_to_dev(wimax_dev);
397         d_fnstart(3, dev, "(wimax_dev %p)\n", wimax_dev);
398         rfkill_unregister(wimax_dev->rfkill);
399         rfkill_destroy(wimax_dev->rfkill);
400         d_fnend(3, dev, "(wimax_dev %p)\n", wimax_dev);
401 }
402
403
404 /*
405  * Exporting to user space over generic netlink
406  *
407  * Parse the rfkill command from user space, return a combination
408  * value that describe the states of the different toggles.
409  *
410  * Only one attribute: the new state requested (on, off or no change,
411  * just query).
412  */
413
414 static const struct nla_policy wimax_gnl_rfkill_policy[WIMAX_GNL_ATTR_MAX + 1] = {
415         [WIMAX_GNL_RFKILL_IFIDX] = {
416                 .type = NLA_U32,
417         },
418         [WIMAX_GNL_RFKILL_STATE] = {
419                 .type = NLA_U32         /* enum wimax_rf_state */
420         },
421 };
422
423
424 static
425 int wimax_gnl_doit_rfkill(struct sk_buff *skb, struct genl_info *info)
426 {
427         int result, ifindex;
428         struct wimax_dev *wimax_dev;
429         struct device *dev;
430         enum wimax_rf_state new_state;
431
432         d_fnstart(3, NULL, "(skb %p info %p)\n", skb, info);
433         result = -ENODEV;
434         if (info->attrs[WIMAX_GNL_RFKILL_IFIDX] == NULL) {
435                 printk(KERN_ERR "WIMAX_GNL_OP_RFKILL: can't find IFIDX "
436                         "attribute\n");
437                 goto error_no_wimax_dev;
438         }
439         ifindex = nla_get_u32(info->attrs[WIMAX_GNL_RFKILL_IFIDX]);
440         wimax_dev = wimax_dev_get_by_genl_info(info, ifindex);
441         if (wimax_dev == NULL)
442                 goto error_no_wimax_dev;
443         dev = wimax_dev_to_dev(wimax_dev);
444         result = -EINVAL;
445         if (info->attrs[WIMAX_GNL_RFKILL_STATE] == NULL) {
446                 dev_err(dev, "WIMAX_GNL_RFKILL: can't find RFKILL_STATE "
447                         "attribute\n");
448                 goto error_no_pid;
449         }
450         new_state = nla_get_u32(info->attrs[WIMAX_GNL_RFKILL_STATE]);
451
452         /* Execute the operation and send the result back to user space */
453         result = wimax_rfkill(wimax_dev, new_state);
454 error_no_pid:
455         dev_put(wimax_dev->net_dev);
456 error_no_wimax_dev:
457         d_fnend(3, NULL, "(skb %p info %p) = %d\n", skb, info, result);
458         return result;
459 }
460
461
462 struct genl_ops wimax_gnl_rfkill = {
463         .cmd = WIMAX_GNL_OP_RFKILL,
464         .flags = GENL_ADMIN_PERM,
465         .policy = wimax_gnl_rfkill_policy,
466         .doit = wimax_gnl_doit_rfkill,
467         .dumpit = NULL,
468 };
469