Root/
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 | */ |
92 | void 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 | } |
121 | error_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 | } |
126 | EXPORT_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 | */ |
148 | void 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 | } |
174 | error_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 | } |
179 | EXPORT_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 | */ |
204 | static |
205 | int __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 | } |
229 | out_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 | */ |
248 | static 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 | |
270 | static 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 | */ |
300 | int 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; |
332 | error: |
333 | error_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 | } |
339 | EXPORT_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 | */ |
347 | int 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 | |
377 | error_rfkill_register: |
378 | rfkill_destroy(wimax_dev->rfkill); |
379 | error_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 | */ |
393 | void 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 | |
413 | static 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 | |
423 | static |
424 | int 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); |
453 | error_no_pid: |
454 | dev_put(wimax_dev->net_dev); |
455 | error_no_wimax_dev: |
456 | d_fnend(3, NULL, "(skb %p info %p) = %d\n", skb, info, result); |
457 | return result; |
458 | } |
459 | |
460 | |
461 | struct 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 | |
469 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9