linux/net/wimax/op-rfkill.c
<<
>>
Prefs
   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 */
  93void 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        }
 122error_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}
 127EXPORT_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 */
 149void 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        }
 175error_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}
 180EXPORT_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 */
 205static
 206int __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        }
 230out_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 */
 249static 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
 271static 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 */
 301int 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;
 333error:
 334error_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}
 340EXPORT_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 */
 348int 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
 378error_rfkill_register:
 379        rfkill_destroy(wimax_dev->rfkill);
 380error_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 */
 394void 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
 414static 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
 424static
 425int 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);
 454error_no_pid:
 455        dev_put(wimax_dev->net_dev);
 456error_no_wimax_dev:
 457        d_fnend(3, NULL, "(skb %p info %p) = %d\n", skb, info, result);
 458        return result;
 459}
 460
 461
 462struct 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
 470
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.