git.oblomov.eu Git - linux-2.6/blob - 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? use a timer or add the implementation
  33  *     to the stack.
  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_toggle_radio()  RF-Kill subsytem 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/input.h>
  69 #include "wimax-internal.h"
  70
  71 #define D_SUBMODULE op_rfkill
  72 #include "debug-levels.h"
  73
  74 #if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
  75
  76
  77 /**
  78  * wimax_report_rfkill_hw - Reports changes in the hardware RF switch
  79  *
  80  * @wimax_dev: WiMAX device descriptor
  81  *
  82  * @state: New state of the RF Kill switch. %WIMAX_RF_ON radio on,
  83  *     %WIMAX_RF_OFF radio off.
  84  *
  85  * When the device detects a change in the state of thehardware RF
  86  * switch, it must call this function to let the WiMAX kernel stack
  87  * know that the state has changed so it can be properly propagated.
  88  *
  89  * The WiMAX stack caches the state (the driver doesn't need to). As
  90  * well, as the change is propagated it will come back as a request to
  91  * change the software state to mirror the hardware state.
  92  *
  93  * If the device doesn't have a hardware kill switch, just report
  94  * it on initialization as always on (%WIMAX_RF_ON, radio on).
  95  */
  96 void wimax_report_rfkill_hw(struct wimax_dev *wimax_dev,
  97                             enum wimax_rf_state state)
  98 {
  99         int result;
 100         struct device *dev = wimax_dev_to_dev(wimax_dev);
 101         enum wimax_st wimax_state;
 102         enum rfkill_state rfkill_state;
 103
 104         d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
 105         BUG_ON(state == WIMAX_RF_QUERY);
 106         BUG_ON(state != WIMAX_RF_ON && state != WIMAX_RF_OFF);
 107
 108         mutex_lock(&wimax_dev->mutex);
 109         result = wimax_dev_is_ready(wimax_dev);
 110         if (result < 0)
 111                 goto error_not_ready;
 112
 113         if (state != wimax_dev->rf_hw) {
 114                 wimax_dev->rf_hw = state;
 115                 rfkill_state = state == WIMAX_RF_ON ?
 116                         RFKILL_STATE_OFF : RFKILL_STATE_ON;
 117                 if (wimax_dev->rf_hw == WIMAX_RF_ON
 118                     && wimax_dev->rf_sw == WIMAX_RF_ON)
 119                         wimax_state = WIMAX_ST_READY;
 120                 else
 121                         wimax_state = WIMAX_ST_RADIO_OFF;
 122                 __wimax_state_change(wimax_dev, wimax_state);
 123                 input_report_key(wimax_dev->rfkill_input, KEY_WIMAX,
 124                                  rfkill_state);
 125         }
 126 error_not_ready:
 127         mutex_unlock(&wimax_dev->mutex);
 128         d_fnend(3, dev, "(wimax_dev %p state %u) = void [%d]\n",
 129                 wimax_dev, state, result);
 130 }
 131 EXPORT_SYMBOL_GPL(wimax_report_rfkill_hw);
 132
 133
 134 /**
 135  * wimax_report_rfkill_sw - Reports changes in the software RF switch
 136  *
 137  * @wimax_dev: WiMAX device descriptor
 138  *
 139  * @state: New state of the RF kill switch. %WIMAX_RF_ON radio on,
 140  *     %WIMAX_RF_OFF radio off.
 141  *
 142  * Reports changes in the software RF switch state to the the WiMAX
 143  * stack.
 144  *
 145  * The main use is during initialization, so the driver can query the
 146  * device for its current software radio kill switch state and feed it
 147  * to the system.
 148  *
 149  * On the side, the device does not change the software state by
 150  * itself. In practice, this can happen, as the device might decide to
 151  * switch (in software) the radio off for different reasons.
 152  */
 153 void wimax_report_rfkill_sw(struct wimax_dev *wimax_dev,
 154                             enum wimax_rf_state state)
 155 {
 156         int result;
 157         struct device *dev = wimax_dev_to_dev(wimax_dev);
 158         enum wimax_st wimax_state;
 159
 160         d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
 161         BUG_ON(state == WIMAX_RF_QUERY);
 162         BUG_ON(state != WIMAX_RF_ON && state != WIMAX_RF_OFF);
 163
 164         mutex_lock(&wimax_dev->mutex);
 165         result = wimax_dev_is_ready(wimax_dev);
 166         if (result < 0)
 167                 goto error_not_ready;
 168
 169         if (state != wimax_dev->rf_sw) {
 170                 wimax_dev->rf_sw = state;
 171                 if (wimax_dev->rf_hw == WIMAX_RF_ON
 172                     && wimax_dev->rf_sw == WIMAX_RF_ON)
 173                         wimax_state = WIMAX_ST_READY;
 174                 else
 175                         wimax_state = WIMAX_ST_RADIO_OFF;
 176                 __wimax_state_change(wimax_dev, wimax_state);
 177         }
 178 error_not_ready:
 179         mutex_unlock(&wimax_dev->mutex);
 180         d_fnend(3, dev, "(wimax_dev %p state %u) = void [%d]\n",
 181                 wimax_dev, state, result);
 182 }
 183 EXPORT_SYMBOL_GPL(wimax_report_rfkill_sw);
 184
 185
 186 /*
 187  * Callback for the RF Kill toggle operation
 188  *
 189  * This function is called by:
 190  *
 191  * - The rfkill subsystem when the RF-Kill key is pressed in the
 192  *   hardware and the driver notifies through
 193  *   wimax_report_rfkill_hw(). The rfkill subsystem ends up calling back
 194  *   here so the software RF Kill switch state is changed to reflect
 195  *   the hardware switch state.
 196  *
 197  * - When the user sets the state through sysfs' rfkill/state file
 198  *
 199  * - When the user calls wimax_rfkill().
 200  *
 201  * This call blocks!
 202  *
 203  * WARNING! When we call rfkill_unregister(), this will be called with
 204  * state 0!
 205  *
 206  * WARNING: wimax_dev must be locked
 207  */
 208 static
 209 int __wimax_rf_toggle_radio(struct wimax_dev *wimax_dev,
 210                             enum wimax_rf_state state)
 211 {
 212         int result = 0;
 213         struct device *dev = wimax_dev_to_dev(wimax_dev);
 214         enum wimax_st wimax_state;
 215
 216         might_sleep();
 217         d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
 218         if (wimax_dev->rf_sw == state)
 219                 goto out_no_change;
 220         if (wimax_dev->op_rfkill_sw_toggle != NULL)
 221                 result = wimax_dev->op_rfkill_sw_toggle(wimax_dev, state);
 222         else if (state == WIMAX_RF_OFF) /* No op? can't turn off */
 223                 result = -ENXIO;
 224         else                            /* No op? can turn on */
 225                 result = 0;             /* should never happen tho */
 226         if (result >= 0) {
 227                 result = 0;
 228                 wimax_dev->rf_sw = state;
 229                 wimax_state = state == WIMAX_RF_ON ?
 230                         WIMAX_ST_READY : WIMAX_ST_RADIO_OFF;
 231                 __wimax_state_change(wimax_dev, wimax_state);
 232         }
 233 out_no_change:
 234         d_fnend(3, dev, "(wimax_dev %p state %u) = %d\n",
 235                 wimax_dev, state, result);
 236         return result;
 237 }
 238
 239
 240 /*
 241  * Translate from rfkill state to wimax state
 242  *
 243  * NOTE: Special state handling rules here
 244  *
 245  *     Just pretend the call didn't happen if we are in a state where
 246  *     we know for sure it cannot be handled (WIMAX_ST_DOWN or
 247  *     __WIMAX_ST_QUIESCING). rfkill() needs it to register and
 248  *     unregister, as it will run this path.
 249  *
 250  * NOTE: This call will block until the operation is completed.
 251  */
 252 static
 253 int wimax_rfkill_toggle_radio(void *data, enum rfkill_state state)
 254 {
 255         int result;
 256         struct wimax_dev *wimax_dev = data;
 257         struct device *dev = wimax_dev_to_dev(wimax_dev);
 258         enum wimax_rf_state rf_state;
 259
 260         d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
 261         switch (state) {
 262         case RFKILL_STATE_ON:
 263                 rf_state = WIMAX_RF_OFF;
 264                 break;
 265         case RFKILL_STATE_OFF:
 266                 rf_state = WIMAX_RF_ON;
 267                 break;
 268         default:
 269                 BUG();
 270         }
 271         mutex_lock(&wimax_dev->mutex);
 272         if (wimax_dev->state <= __WIMAX_ST_QUIESCING)
 273                 result = 0;     /* just pretend it didn't happen */
 274         else
 275                 result = __wimax_rf_toggle_radio(wimax_dev, rf_state);
 276         mutex_unlock(&wimax_dev->mutex);
 277         d_fnend(3, dev, "(wimax_dev %p state %u) = %d\n",
 278                 wimax_dev, state, result);
 279         return result;
 280 }
 281
 282
 283 /**
 284  * wimax_rfkill - Set the software RF switch state for a WiMAX device
 285  *
 286  * @wimax_dev: WiMAX device descriptor
 287  *
 288  * @state: New RF state.
 289  *
 290  * Returns:
 291  *
 292  * >= 0 toggle state if ok, < 0 errno code on error. The toggle state
 293  * is returned as a bitmap, bit 0 being the hardware RF state, bit 1
 294  * the software RF state.
 295  *
 296  * 0 means disabled (%WIMAX_RF_ON, radio on), 1 means enabled radio
 297  * off (%WIMAX_RF_OFF).
 298  *
 299  * Description:
 300  *
 301  * Called by the user when he wants to request the WiMAX radio to be
 302  * switched on (%WIMAX_RF_ON) or off (%WIMAX_RF_OFF). With
 303  * %WIMAX_RF_QUERY, just the current state is returned.
 304  *
 305  * NOTE:
 306  *
 307  * This call will block until the operation is complete.
 308  */
 309 int wimax_rfkill(struct wimax_dev *wimax_dev, enum wimax_rf_state state)
 310 {
 311         int result;
 312         struct device *dev = wimax_dev_to_dev(wimax_dev);
 313
 314         d_fnstart(3, dev, "(wimax_dev %p state %u)\n", wimax_dev, state);
 315         mutex_lock(&wimax_dev->mutex);
 316         result = wimax_dev_is_ready(wimax_dev);
 317         if (result < 0)
 318                 goto error_not_ready;
 319         switch (state) {
 320         case WIMAX_RF_ON:
 321         case WIMAX_RF_OFF:
 322                 result = __wimax_rf_toggle_radio(wimax_dev, state);
 323                 if (result < 0)
 324                         goto error;
 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 input_dev *input_dev;
 353         struct device *dev = wimax_dev_to_dev(wimax_dev);
 354
 355         d_fnstart(3, dev, "(wimax_dev %p)\n", wimax_dev);
 356         /* Initialize RF Kill */
 357         result = -ENOMEM;
 358         rfkill = rfkill_allocate(dev, RFKILL_TYPE_WIMAX);
 359         if (rfkill == NULL)
 360                 goto error_rfkill_allocate;
 361         wimax_dev->rfkill = rfkill;
 362
 363         rfkill->name = wimax_dev->name;
 364         rfkill->state = RFKILL_STATE_OFF;
 365         rfkill->data = wimax_dev;
 366         rfkill->toggle_radio = wimax_rfkill_toggle_radio;
 367         rfkill->user_claim_unsupported = 1;
 368
 369         /* Initialize the input device for the hw key */
 370         input_dev = input_allocate_device();
 371         if (input_dev == NULL)
 372                 goto error_input_allocate;
 373         wimax_dev->rfkill_input = input_dev;
 374         d_printf(1, dev, "rfkill %p input %p\n", rfkill, input_dev);
 375
 376         input_dev->name = wimax_dev->name;
 377         /* FIXME: get a real device bus ID and stuff? do we care? */
 378         input_dev->id.bustype = BUS_HOST;
 379         input_dev->id.vendor = 0xffff;
 380         input_dev->evbit[0] = BIT(EV_KEY);
 381         set_bit(KEY_WIMAX, input_dev->keybit);
 382
 383         /* Register both */
 384         result = input_register_device(wimax_dev->rfkill_input);
 385         if (result < 0)
 386                 goto error_input_register;
 387         result = rfkill_register(wimax_dev->rfkill);
 388         if (result < 0)
 389                 goto error_rfkill_register;
 390
 391         /* If there is no SW toggle op, SW RFKill is always on */
 392         if (wimax_dev->op_rfkill_sw_toggle == NULL)
 393                 wimax_dev->rf_sw = WIMAX_RF_ON;
 394
 395         d_fnend(3, dev, "(wimax_dev %p) = 0\n", wimax_dev);
 396         return 0;
 397
 398         /* if rfkill_register() suceeds, can't use rfkill_free() any
 399          * more, only rfkill_unregister() [it owns the refcount]; with
 400          * the input device we have the same issue--hence the if. */
 401 error_rfkill_register:
 402         input_unregister_device(wimax_dev->rfkill_input);
 403         wimax_dev->rfkill_input = NULL;
 404 error_input_register:
 405         if (wimax_dev->rfkill_input)
 406                 input_free_device(wimax_dev->rfkill_input);
 407 error_input_allocate:
 408         rfkill_free(wimax_dev->rfkill);
 409 error_rfkill_allocate:
 410         d_fnend(3, dev, "(wimax_dev %p) = %d\n", wimax_dev, result);
 411         return result;
 412 }
 413
 414
 415 /*
 416  * Deregister a WiMAX device's RF Kill support
 417  *
 418  * Ick, we can't call rfkill_free() after rfkill_unregister()...oh
 419  * well.
 420  *
 421  * WARNING: wimax_dev->mutex must be unlocked
 422  */
 423 void wimax_rfkill_rm(struct wimax_dev *wimax_dev)
 424 {
 425         struct device *dev = wimax_dev_to_dev(wimax_dev);
 426         d_fnstart(3, dev, "(wimax_dev %p)\n", wimax_dev);
 427         rfkill_unregister(wimax_dev->rfkill);   /* frees */
 428         input_unregister_device(wimax_dev->rfkill_input);
 429         d_fnend(3, dev, "(wimax_dev %p)\n", wimax_dev);
 430 }
 431
 432
 433 #else /* #ifdef CONFIG_RFKILL */
 434
 435 void wimax_report_rfkill_hw(struct wimax_dev *wimax_dev,
 436                             enum wimax_rf_state state)
 437 {
 438 }
 439 EXPORT_SYMBOL_GPL(wimax_report_rfkill_hw);
 440
 441 void wimax_report_rfkill_sw(struct wimax_dev *wimax_dev,
 442                             enum wimax_rf_state state)
 443 {
 444 }
 445 EXPORT_SYMBOL_GPL(wimax_report_rfkill_sw);
 446
 447 int wimax_rfkill(struct wimax_dev *wimax_dev,
 448                  enum wimax_rf_state state)
 449 {
 450         return WIMAX_RF_ON << 1 | WIMAX_RF_ON;
 451 }
 452 EXPORT_SYMBOL_GPL(wimax_rfkill);
 453
 454 int wimax_rfkill_add(struct wimax_dev *wimax_dev)
 455 {
 456         return 0;
 457 }
 458
 459 void wimax_rfkill_rm(struct wimax_dev *wimax_dev)
 460 {
 461 }
 462
 463 #endif /* #ifdef CONFIG_RFKILL */
 464
 465
 466 /*
 467  * Exporting to user space over generic netlink
 468  *
 469  * Parse the rfkill command from user space, return a combination
 470  * value that describe the states of the different toggles.
 471  *
 472  * Only one attribute: the new state requested (on, off or no change,
 473  * just query).
 474  */
 475
 476 static const
 477 struct nla_policy wimax_gnl_rfkill_policy[WIMAX_GNL_ATTR_MAX + 1] = {
 478         [WIMAX_GNL_RFKILL_IFIDX] = {
 479                 .type = NLA_U32,
 480         },
 481         [WIMAX_GNL_RFKILL_STATE] = {
 482                 .type = NLA_U32         /* enum wimax_rf_state */
 483         },
 484 };
 485
 486
 487 static
 488 int wimax_gnl_doit_rfkill(struct sk_buff *skb, struct genl_info *info)
 489 {
 490         int result, ifindex;
 491         struct wimax_dev *wimax_dev;
 492         struct device *dev;
 493         enum wimax_rf_state new_state;
 494
 495         d_fnstart(3, NULL, "(skb %p info %p)\n", skb, info);
 496         result = -ENODEV;
 497         if (info->attrs[WIMAX_GNL_RFKILL_IFIDX] == NULL) {
 498                 printk(KERN_ERR "WIMAX_GNL_OP_RFKILL: can't find IFIDX "
 499                         "attribute\n");
 500                 goto error_no_wimax_dev;
 501         }
 502         ifindex = nla_get_u32(info->attrs[WIMAX_GNL_RFKILL_IFIDX]);
 503         wimax_dev = wimax_dev_get_by_genl_info(info, ifindex);
 504         if (wimax_dev == NULL)
 505                 goto error_no_wimax_dev;
 506         dev = wimax_dev_to_dev(wimax_dev);
 507         result = -EINVAL;
 508         if (info->attrs[WIMAX_GNL_RFKILL_STATE] == NULL) {
 509                 dev_err(dev, "WIMAX_GNL_RFKILL: can't find RFKILL_STATE "
 510                         "attribute\n");
 511                 goto error_no_pid;
 512         }
 513         new_state = nla_get_u32(info->attrs[WIMAX_GNL_RFKILL_STATE]);
 514
 515         /* Execute the operation and send the result back to user space */
 516         result = wimax_rfkill(wimax_dev, new_state);
 517 error_no_pid:
 518         dev_put(wimax_dev->net_dev);
 519 error_no_wimax_dev:
 520         d_fnend(3, NULL, "(skb %p info %p) = %d\n", skb, info, result);
 521         return result;
 522 }
 523
 524
 525 struct genl_ops wimax_gnl_rfkill = {
 526         .cmd = WIMAX_GNL_OP_RFKILL,
 527         .flags = GENL_ADMIN_PERM,
 528         .policy = wimax_gnl_rfkill_policy,
 529         .doit = wimax_gnl_doit_rfkill,
 530         .dumpit = NULL,
 531 };
 532