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