Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 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 | * |
Johannes Berg | 19d337d | 2009-06-02 13:01:37 +0200 | [diff] [blame] | 32 | * FIXME: Need polled support? Let drivers provide a poll routine |
| 33 | * and hand it to rfkill ops then? |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 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 | * |
Johannes Berg | 19d337d | 2009-06-02 13:01:37 +0200 | [diff] [blame] | 46 | * wimax_rfkill_set_radio_block() RF-Kill subsytem calling |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 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> |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 68 | #include "wimax-internal.h" |
| 69 | |
| 70 | #define D_SUBMODULE op_rfkill |
| 71 | #include "debug-levels.h" |
| 72 | |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 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; |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 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; |
Joe Perches | f64f9e7 | 2009-11-29 16:55:45 -0800 | [diff] [blame^] | 110 | if (wimax_dev->rf_hw == WIMAX_RF_ON && |
| 111 | wimax_dev->rf_sw == WIMAX_RF_ON) |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 112 | wimax_state = WIMAX_ST_READY; |
| 113 | else |
| 114 | wimax_state = WIMAX_ST_RADIO_OFF; |
Johannes Berg | 19d337d | 2009-06-02 13:01:37 +0200 | [diff] [blame] | 115 | |
Inaky Perez-Gonzalez | d2f4c10 | 2009-06-11 11:12:48 -0700 | [diff] [blame] | 116 | result = rfkill_set_hw_state(wimax_dev->rfkill, |
| 117 | state == WIMAX_RF_OFF); |
Johannes Berg | 19d337d | 2009-06-02 13:01:37 +0200 | [diff] [blame] | 118 | |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 119 | __wimax_state_change(wimax_dev, wimax_state); |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 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; |
Joe Perches | f64f9e7 | 2009-11-29 16:55:45 -0800 | [diff] [blame^] | 166 | if (wimax_dev->rf_hw == WIMAX_RF_ON && |
| 167 | wimax_dev->rf_sw == WIMAX_RF_ON) |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 168 | wimax_state = WIMAX_ST_READY; |
| 169 | else |
| 170 | wimax_state = WIMAX_ST_RADIO_OFF; |
| 171 | __wimax_state_change(wimax_dev, wimax_state); |
Johannes Berg | 19d337d | 2009-06-02 13:01:37 +0200 | [diff] [blame] | 172 | rfkill_set_sw_state(wimax_dev->rfkill, state == WIMAX_RF_OFF); |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 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 | */ |
Johannes Berg | 19d337d | 2009-06-02 13:01:37 +0200 | [diff] [blame] | 248 | static int wimax_rfkill_set_radio_block(void *data, bool blocked) |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 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 | |
Johannes Berg | 19d337d | 2009-06-02 13:01:37 +0200 | [diff] [blame] | 255 | d_fnstart(3, dev, "(wimax_dev %p blocked %u)\n", wimax_dev, blocked); |
| 256 | rf_state = WIMAX_RF_ON; |
| 257 | if (blocked) |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 258 | rf_state = WIMAX_RF_OFF; |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 259 | mutex_lock(&wimax_dev->mutex); |
| 260 | if (wimax_dev->state <= __WIMAX_ST_QUIESCING) |
Johannes Berg | 19d337d | 2009-06-02 13:01:37 +0200 | [diff] [blame] | 261 | result = 0; |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 262 | else |
| 263 | result = __wimax_rf_toggle_radio(wimax_dev, rf_state); |
| 264 | mutex_unlock(&wimax_dev->mutex); |
Johannes Berg | 19d337d | 2009-06-02 13:01:37 +0200 | [diff] [blame] | 265 | d_fnend(3, dev, "(wimax_dev %p blocked %u) = %d\n", |
| 266 | wimax_dev, blocked, result); |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 267 | return result; |
| 268 | } |
| 269 | |
Johannes Berg | 19d337d | 2009-06-02 13:01:37 +0200 | [diff] [blame] | 270 | static const struct rfkill_ops wimax_rfkill_ops = { |
| 271 | .set_block = wimax_rfkill_set_radio_block, |
| 272 | }; |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 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); |
Inaky Perez-Gonzalez | 81d3f90 | 2009-10-03 16:51:02 +0900 | [diff] [blame] | 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; |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 315 | goto error_not_ready; |
Inaky Perez-Gonzalez | 81d3f90 | 2009-10-03 16:51:02 +0900 | [diff] [blame] | 316 | } |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 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; |
Johannes Berg | 19d337d | 2009-06-02 13:01:37 +0200 | [diff] [blame] | 323 | rfkill_set_sw_state(wimax_dev->rfkill, state == WIMAX_RF_OFF); |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 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; |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 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; |
Johannes Berg | 19d337d | 2009-06-02 13:01:37 +0200 | [diff] [blame] | 356 | rfkill = rfkill_alloc(wimax_dev->name, dev, RFKILL_TYPE_WIMAX, |
| 357 | &wimax_rfkill_ops, wimax_dev); |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 358 | if (rfkill == NULL) |
| 359 | goto error_rfkill_allocate; |
Johannes Berg | 19d337d | 2009-06-02 13:01:37 +0200 | [diff] [blame] | 360 | |
| 361 | d_printf(1, dev, "rfkill %p\n", rfkill); |
| 362 | |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 363 | wimax_dev->rfkill = rfkill; |
| 364 | |
Inaky Perez-Gonzalez | c29eaf3 | 2009-08-27 17:54:53 -0700 | [diff] [blame] | 365 | rfkill_init_sw_state(rfkill, 1); |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 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 | |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 377 | error_rfkill_register: |
Johannes Berg | 19d337d | 2009-06-02 13:01:37 +0200 | [diff] [blame] | 378 | rfkill_destroy(wimax_dev->rfkill); |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 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); |
Johannes Berg | 19d337d | 2009-06-02 13:01:37 +0200 | [diff] [blame] | 397 | rfkill_unregister(wimax_dev->rfkill); |
| 398 | rfkill_destroy(wimax_dev->rfkill); |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 399 | d_fnend(3, dev, "(wimax_dev %p)\n", wimax_dev); |
| 400 | } |
| 401 | |
| 402 | |
Inaky Perez-Gonzalez | 3e65646 | 2008-12-20 16:57:38 -0800 | [diff] [blame] | 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 |
| 414 | 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 | |