1rfkill - RF switch subsystem support 2==================================== 3 41 Introduction 52 Implementation details 63 Kernel driver guidelines 73.1 wireless device drivers 83.2 platform/switch drivers 93.3 input device drivers 104 Kernel API 115 Userspace support 12 13 141. Introduction: 15 16The rfkill switch subsystem exists to add a generic interface to circuitry that 17can enable or disable the signal output of a wireless *transmitter* of any 18type. By far, the most common use is to disable radio-frequency transmitters. 19 20Note that disabling the signal output means that the the transmitter is to be 21made to not emit any energy when "blocked". rfkill is not about blocking data 22transmissions, it is about blocking energy emission. 23 24The rfkill subsystem offers support for keys and switches often found on 25laptops to enable wireless devices like WiFi and Bluetooth, so that these keys 26and switches actually perform an action in all wireless devices of a given type 27attached to the system. 28 29The buttons to enable and disable the wireless transmitters are important in 30situations where the user is for example using his laptop on a location where 31radio-frequency transmitters _must_ be disabled (e.g. airplanes). 32 33Because of this requirement, userspace support for the keys should not be made 34mandatory. Because userspace might want to perform some additional smarter 35tasks when the key is pressed, rfkill provides userspace the possibility to 36take over the task to handle the key events. 37 38=============================================================================== 392: Implementation details 40 41The rfkill subsystem is composed of various components: the rfkill class, the 42rfkill-input module (an input layer handler), and some specific input layer 43events. 44 45The rfkill class provides kernel drivers with an interface that allows them to 46know when they should enable or disable a wireless network device transmitter. 47This is enabled by the CONFIG_RFKILL Kconfig option. 48 49The rfkill class support makes sure userspace will be notified of all state 50changes on rfkill devices through uevents. It provides a notification chain 51for interested parties in the kernel to also get notified of rfkill state 52changes in other drivers. It creates several sysfs entries which can be used 53by userspace. See section "Userspace support". 54 55The rfkill-input module provides the kernel with the ability to implement a 56basic response when the user presses a key or button (or toggles a switch) 57related to rfkill functionality. It is an in-kernel implementation of default 58policy of reacting to rfkill-related input events and neither mandatory nor 59required for wireless drivers to operate. It is enabled by the 60CONFIG_RFKILL_INPUT Kconfig option. 61 62rfkill-input is a rfkill-related events input layer handler. This handler will 63listen to all rfkill key events and will change the rfkill state of the 64wireless devices accordingly. With this option enabled userspace could either 65do nothing or simply perform monitoring tasks. 66 67The rfkill-input module also provides EPO (emergency power-off) functionality 68for all wireless transmitters. This function cannot be overridden, and it is 69always active. rfkill EPO is related to *_RFKILL_ALL input layer events. 70 71 72Important terms for the rfkill subsystem: 73 74In order to avoid confusion, we avoid the term "switch" in rfkill when it is 75referring to an electronic control circuit that enables or disables a 76transmitter. We reserve it for the physical device a human manipulates 77(which is an input device, by the way): 78 79rfkill switch: 80 81 A physical device a human manipulates. Its state can be perceived by 82 the kernel either directly (through a GPIO pin, ACPI GPE) or by its 83 effect on a rfkill line of a wireless device. 84 85rfkill controller: 86 87 A hardware circuit that controls the state of a rfkill line, which a 88 kernel driver can interact with *to modify* that state (i.e. it has 89 either write-only or read/write access). 90 91rfkill line: 92 93 An input channel (hardware or software) of a wireless device, which 94 causes a wireless transmitter to stop emitting energy (BLOCK) when it 95 is active. Point of view is extremely important here: rfkill lines are 96 always seen from the PoV of a wireless device (and its driver). 97 98soft rfkill line/software rfkill line: 99 100 A rfkill line the wireless device driver can directly change the state 101 of. Related to rfkill_state RFKILL_STATE_SOFT_BLOCKED. 102 103hard rfkill line/hardware rfkill line: 104 105 A rfkill line that works fully in hardware or firmware, and that cannot 106 be overridden by the kernel driver. The hardware device or the 107 firmware just exports its status to the driver, but it is read-only. 108 Related to rfkill_state RFKILL_STATE_HARD_BLOCKED. 109 110The enum rfkill_state describes the rfkill state of a transmitter: 111 112When a rfkill line or rfkill controller is in the RFKILL_STATE_UNBLOCKED state, 113the wireless transmitter (radio TX circuit for example) is *enabled*. When the 114it is in the RFKILL_STATE_SOFT_BLOCKED or RFKILL_STATE_HARD_BLOCKED, the 115wireless transmitter is to be *blocked* from operating. 116 117RFKILL_STATE_SOFT_BLOCKED indicates that a call to toggle_radio() can change 118that state. RFKILL_STATE_HARD_BLOCKED indicates that a call to toggle_radio() 119will not be able to change the state and will return with a suitable error if 120attempts are made to set the state to RFKILL_STATE_UNBLOCKED. 121 122RFKILL_STATE_HARD_BLOCKED is used by drivers to signal that the device is 123locked in the BLOCKED state by a hardwire rfkill line (typically an input pin 124that, when active, forces the transmitter to be disabled) which the driver 125CANNOT override. 126 127Full rfkill functionality requires two different subsystems to cooperate: the 128input layer and the rfkill class. The input layer issues *commands* to the 129entire system requesting that devices registered to the rfkill class change 130state. The way this interaction happens is not complex, but it is not obvious 131either: 132 133Kernel Input layer: 134 135 * Generates KEY_WWAN, KEY_WLAN, KEY_BLUETOOTH, SW_RFKILL_ALL, and 136 other such events when the user presses certain keys, buttons, or 137 toggles certain physical switches. 138 139 THE INPUT LAYER IS NEVER USED TO PROPAGATE STATUS, NOTIFICATIONS OR THE 140 KIND OF STUFF AN ON-SCREEN-DISPLAY APPLICATION WOULD REPORT. It is 141 used to issue *commands* for the system to change behaviour, and these 142 commands may or may not be carried out by some kernel driver or 143 userspace application. It follows that doing user feedback based only 144 on input events is broken, as there is no guarantee that an input event 145 will be acted upon. 146 147 Most wireless communication device drivers implementing rfkill 148 functionality MUST NOT generate these events, and have no reason to 149 register themselves with the input layer. Doing otherwise is a common 150 misconception. There is an API to propagate rfkill status change 151 information, and it is NOT the input layer. 152 153rfkill class: 154 155 * Calls a hook in a driver to effectively change the wireless 156 transmitter state; 157 * Keeps track of the wireless transmitter state (with help from 158 the driver); 159 * Generates userspace notifications (uevents) and a call to a 160 notification chain (kernel) when there is a wireless transmitter 161 state change; 162 * Connects a wireless communications driver with the common rfkill 163 control system, which, for example, allows actions such as 164 "switch all bluetooth devices offline" to be carried out by 165 userspace or by rfkill-input. 166 167 THE RFKILL CLASS NEVER ISSUES INPUT EVENTS. THE RFKILL CLASS DOES 168 NOT LISTEN TO INPUT EVENTS. NO DRIVER USING THE RFKILL CLASS SHALL 169 EVER LISTEN TO, OR ACT ON RFKILL INPUT EVENTS. Doing otherwise is 170 a layering violation. 171 172 Most wireless data communication drivers in the kernel have just to 173 implement the rfkill class API to work properly. Interfacing to the 174 input layer is not often required (and is very often a *bug*) on 175 wireless drivers. 176 177 Platform drivers often have to attach to the input layer to *issue* 178 (but never to listen to) rfkill events for rfkill switches, and also to 179 the rfkill class to export a control interface for the platform rfkill 180 controllers to the rfkill subsystem. This does NOT mean the rfkill 181 switch is attached to a rfkill class (doing so is almost always wrong). 182 It just means the same kernel module is the driver for different 183 devices (rfkill switches and rfkill controllers). 184 185 186Userspace input handlers (uevents) or kernel input handlers (rfkill-input): 187 188 * Implements the policy of what should happen when one of the input 189 layer events related to rfkill operation is received. 190 * Uses the sysfs interface (userspace) or private rfkill API calls 191 to tell the devices registered with the rfkill class to change 192 their state (i.e. translates the input layer event into real 193 action). 194 195 * rfkill-input implements EPO by handling EV_SW SW_RFKILL_ALL 0 196 (power off all transmitters) in a special way: it ignores any 197 overrides and local state cache and forces all transmitters to the 198 RFKILL_STATE_SOFT_BLOCKED state (including those which are already 199 supposed to be BLOCKED). 200 * rfkill EPO will remain active until rfkill-input receives an 201 EV_SW SW_RFKILL_ALL 1 event. While the EPO is active, transmitters 202 are locked in the blocked state (rfkill will refuse to unblock them). 203 * rfkill-input implements different policies that the user can 204 select for handling EV_SW SW_RFKILL_ALL 1. It will unlock rfkill, 205 and either do nothing (leave transmitters blocked, but now unlocked), 206 restore the transmitters to their state before the EPO, or unblock 207 them all. 208 209Userspace uevent handler or kernel platform-specific drivers hooked to the 210rfkill notifier chain: 211 212 * Taps into the rfkill notifier chain or to KOBJ_CHANGE uevents, 213 in order to know when a device that is registered with the rfkill 214 class changes state; 215 * Issues feedback notifications to the user; 216 * In the rare platforms where this is required, synthesizes an input 217 event to command all *OTHER* rfkill devices to also change their 218 statues when a specific rfkill device changes state. 219 220 221=============================================================================== 2223: Kernel driver guidelines 223 224Remember: point-of-view is everything for a driver that connects to the rfkill 225subsystem. All the details below must be measured/perceived from the point of 226view of the specific driver being modified. 227 228The first thing one needs to know is whether his driver should be talking to 229the rfkill class or to the input layer. In rare cases (platform drivers), it 230could happen that you need to do both, as platform drivers often handle a 231variety of devices in the same driver. 232 233Do not mistake input devices for rfkill controllers. The only type of "rfkill 234switch" device that is to be registered with the rfkill class are those 235directly controlling the circuits that cause a wireless transmitter to stop 236working (or the software equivalent of them), i.e. what we call a rfkill 237controller. Every other kind of "rfkill switch" is just an input device and 238MUST NOT be registered with the rfkill class. 239 240A driver should register a device with the rfkill class when ALL of the 241following conditions are met (they define a rfkill controller): 242 2431. The device is/controls a data communications wireless transmitter; 244 2452. The kernel can interact with the hardware/firmware to CHANGE the wireless 246 transmitter state (block/unblock TX operation); 247 2483. The transmitter can be made to not emit any energy when "blocked": 249 rfkill is not about blocking data transmissions, it is about blocking 250 energy emission; 251 252A driver should register a device with the input subsystem to issue 253rfkill-related events (KEY_WLAN, KEY_BLUETOOTH, KEY_WWAN, KEY_WIMAX, 254SW_RFKILL_ALL, etc) when ALL of the folowing conditions are met: 255 2561. It is directly related to some physical device the user interacts with, to 257 command the O.S./firmware/hardware to enable/disable a data communications 258 wireless transmitter. 259 260 Examples of the physical device are: buttons, keys and switches the user 261 will press/touch/slide/switch to enable or disable the wireless 262 communication device. 263 2642. It is NOT slaved to another device, i.e. there is no other device that 265 issues rfkill-related input events in preference to this one. 266 267 Please refer to the corner cases and examples section for more details. 268 269When in doubt, do not issue input events. For drivers that should generate 270input events in some platforms, but not in others (e.g. b43), the best solution 271is to NEVER generate input events in the first place. That work should be 272deferred to a platform-specific kernel module (which will know when to generate 273events through the rfkill notifier chain) or to userspace. This avoids the 274usual maintenance problems with DMI whitelisting. 275 276 277Corner cases and examples: 278==================================== 279 2801. If the device is an input device that, because of hardware or firmware, 281causes wireless transmitters to be blocked regardless of the kernel's will, it 282is still just an input device, and NOT to be registered with the rfkill class. 283 2842. If the wireless transmitter switch control is read-only, it is an input 285device and not to be registered with the rfkill class (and maybe not to be made 286an input layer event source either, see below). 287 2883. If there is some other device driver *closer* to the actual hardware the 289user interacted with (the button/switch/key) to issue an input event, THAT is 290the device driver that should be issuing input events. 291 292E.g: 293 [RFKILL slider switch] -- [GPIO hardware] -- [WLAN card rf-kill input] 294 (platform driver) (wireless card driver) 295 296The user is closer to the RFKILL slide switch plaform driver, so the driver 297which must issue input events is the platform driver looking at the GPIO 298hardware, and NEVER the wireless card driver (which is just a slave). It is 299very likely that there are other leaves than just the WLAN card rf-kill input 300(e.g. a bluetooth card, etc)... 301 302On the other hand, some embedded devices do this: 303 304 [RFKILL slider switch] -- [WLAN card rf-kill input] 305 (wireless card driver) 306 307In this situation, the wireless card driver *could* register itself as an input 308device and issue rf-kill related input events... but in order to AVOID the need 309for DMI whitelisting, the wireless card driver does NOT do it. Userspace (HAL) 310or a platform driver (that exists only on these embedded devices) will do the 311dirty job of issuing the input events. 312 313 314COMMON MISTAKES in kernel drivers, related to rfkill: 315==================================== 316 3171. NEVER confuse input device keys and buttons with input device switches. 318 319 1a. Switches are always set or reset. They report the current state 320 (on position or off position). 321 322 1b. Keys and buttons are either in the pressed or not-pressed state, and 323 that's it. A "button" that latches down when you press it, and 324 unlatches when you press it again is in fact a switch as far as input 325 devices go. 326 327Add the SW_* events you need for switches, do NOT try to emulate a button using 328KEY_* events just because there is no such SW_* event yet. Do NOT try to use, 329for example, KEY_BLUETOOTH when you should be using SW_BLUETOOTH instead. 330 3312. Input device switches (sources of EV_SW events) DO store their current state 332(so you *must* initialize it by issuing a gratuitous input layer event on 333driver start-up and also when resuming from sleep), and that state CAN be 334queried from userspace through IOCTLs. There is no sysfs interface for this, 335but that doesn't mean you should break things trying to hook it to the rfkill 336class to get a sysfs interface :-) 337 3383. Do not issue *_RFKILL_ALL events by default, unless you are sure it is the 339correct event for your switch/button. These events are emergency power-off 340events when they are trying to turn the transmitters off. An example of an 341input device which SHOULD generate *_RFKILL_ALL events is the wireless-kill 342switch in a laptop which is NOT a hotkey, but a real sliding/rocker switch. 343An example of an input device which SHOULD NOT generate *_RFKILL_ALL events by 344default, is any sort of hot key that is type-specific (e.g. the one for WLAN). 345 346 3473.1 Guidelines for wireless device drivers 348------------------------------------------ 349 350(in this text, rfkill->foo means the foo field of struct rfkill). 351 3521. Each independent transmitter in a wireless device (usually there is only one 353transmitter per device) should have a SINGLE rfkill class attached to it. 354 3552. If the device does not have any sort of hardware assistance to allow the 356driver to rfkill the device, the driver should emulate it by taking all actions 357required to silence the transmitter. 358 3593. If it is impossible to silence the transmitter (i.e. it still emits energy, 360even if it is just in brief pulses, when there is no data to transmit and there 361is no hardware support to turn it off) do NOT lie to the users. Do not attach 362it to a rfkill class. The rfkill subsystem does not deal with data 363transmission, it deals with energy emission. If the transmitter is emitting 364energy, it is not blocked in rfkill terms. 365 3664. It doesn't matter if the device has multiple rfkill input lines affecting 367the same transmitter, their combined state is to be exported as a single state 368per transmitter (see rule 1). 369 370This rule exists because users of the rfkill subsystem expect to get (and set, 371when possible) the overall transmitter rfkill state, not of a particular rfkill 372line. 373 3745. The wireless device driver MUST NOT leave the transmitter enabled during 375suspend and hibernation unless: 376 377 5.1. The transmitter has to be enabled for some sort of functionality 378 like wake-on-wireless-packet or autonomous packed forwarding in a mesh 379 network, and that functionality is enabled for this suspend/hibernation 380 cycle. 381 382AND 383 384 5.2. The device was not on a user-requested BLOCKED state before 385 the suspend (i.e. the driver must NOT unblock a device, not even 386 to support wake-on-wireless-packet or remain in the mesh). 387 388In other words, there is absolutely no allowed scenario where a driver can 389automatically take action to unblock a rfkill controller (obviously, this deals 390with scenarios where soft-blocking or both soft and hard blocking is happening. 391Scenarios where hardware rfkill lines are the only ones blocking the 392transmitter are outside of this rule, since the wireless device driver does not 393control its input hardware rfkill lines in the first place). 394 3956. During resume, rfkill will try to restore its previous state. 396 3977. After a rfkill class is suspended, it will *not* call rfkill->toggle_radio 398until it is resumed. 399 400 401Example of a WLAN wireless driver connected to the rfkill subsystem: 402-------------------------------------------------------------------- 403 404A certain WLAN card has one input pin that causes it to block the transmitter 405and makes the status of that input pin available (only for reading!) to the 406kernel driver. This is a hard rfkill input line (it cannot be overridden by 407the kernel driver). 408 409The card also has one PCI register that, if manipulated by the driver, causes 410it to block the transmitter. This is a soft rfkill input line. 411 412It has also a thermal protection circuitry that shuts down its transmitter if 413the card overheats, and makes the status of that protection available (only for 414reading!) to the kernel driver. This is also a hard rfkill input line. 415 416If either one of these rfkill lines are active, the transmitter is blocked by 417the hardware and forced offline. 418 419The driver should allocate and attach to its struct device *ONE* instance of 420the rfkill class (there is only one transmitter). 421 422It can implement the get_state() hook, and return RFKILL_STATE_HARD_BLOCKED if 423either one of its two hard rfkill input lines are active. If the two hard 424rfkill lines are inactive, it must return RFKILL_STATE_SOFT_BLOCKED if its soft 425rfkill input line is active. Only if none of the rfkill input lines are 426active, will it return RFKILL_STATE_UNBLOCKED. 427 428Since the device has a hardware rfkill line, it IS subject to state changes 429external to rfkill. Therefore, the driver must make sure that it calls 430rfkill_force_state() to keep the status always up-to-date, and it must do a 431rfkill_force_state() on resume from sleep. 432 433Every time the driver gets a notification from the card that one of its rfkill 434lines changed state (polling might be needed on badly designed cards that don't 435generate interrupts for such events), it recomputes the rfkill state as per 436above, and calls rfkill_force_state() to update it. 437 438The driver should implement the toggle_radio() hook, that: 439 4401. Returns an error if one of the hardware rfkill lines are active, and the 441caller asked for RFKILL_STATE_UNBLOCKED. 442 4432. Activates the soft rfkill line if the caller asked for state 444RFKILL_STATE_SOFT_BLOCKED. It should do this even if one of the hard rfkill 445lines are active, effectively double-blocking the transmitter. 446 4473. Deactivates the soft rfkill line if none of the hardware rfkill lines are 448active and the caller asked for RFKILL_STATE_UNBLOCKED. 449 450=============================================================================== 4514: Kernel API 452 453To build a driver with rfkill subsystem support, the driver should depend on 454(or select) the Kconfig symbol RFKILL; it should _not_ depend on RKFILL_INPUT. 455 456The hardware the driver talks to may be write-only (where the current state 457of the hardware is unknown), or read-write (where the hardware can be queried 458about its current state). 459 460The rfkill class will call the get_state hook of a device every time it needs 461to know the *real* current state of the hardware. This can happen often, but 462it does not do any polling, so it is not enough on hardware that is subject 463to state changes outside of the rfkill subsystem. 464 465Therefore, calling rfkill_force_state() when a state change happens is 466mandatory when the device has a hardware rfkill line, or when something else 467like the firmware could cause its state to be changed without going through the 468rfkill class. 469 470Some hardware provides events when its status changes. In these cases, it is 471best for the driver to not provide a get_state hook, and instead register the 472rfkill class *already* with the correct status, and keep it updated using 473rfkill_force_state() when it gets an event from the hardware. 474 475rfkill_force_state() must be used on the device resume handlers to update the 476rfkill status, should there be any chance of the device status changing during 477the sleep. 478 479There is no provision for a statically-allocated rfkill struct. You must 480use rfkill_allocate() to allocate one. 481 482You should: 483 - rfkill_allocate() 484 - modify rfkill fields (flags, name) 485 - modify state to the current hardware state (THIS IS THE ONLY TIME 486 YOU CAN ACCESS state DIRECTLY) 487 - rfkill_register() 488 489The only way to set a device to the RFKILL_STATE_HARD_BLOCKED state is through 490a suitable return of get_state() or through rfkill_force_state(). 491 492When a device is in the RFKILL_STATE_HARD_BLOCKED state, the only way to switch 493it to a different state is through a suitable return of get_state() or through 494rfkill_force_state(). 495 496If toggle_radio() is called to set a device to state RFKILL_STATE_SOFT_BLOCKED 497when that device is already at the RFKILL_STATE_HARD_BLOCKED state, it should 498not return an error. Instead, it should try to double-block the transmitter, 499so that its state will change from RFKILL_STATE_HARD_BLOCKED to 500RFKILL_STATE_SOFT_BLOCKED should the hardware blocking cease. 501 502Please refer to the source for more documentation. 503 504=============================================================================== 5055: Userspace support 506 507rfkill devices issue uevents (with an action of "change"), with the following 508environment variables set: 509 510RFKILL_NAME 511RFKILL_STATE 512RFKILL_TYPE 513 514The ABI for these variables is defined by the sysfs attributes. It is best 515to take a quick look at the source to make sure of the possible values. 516 517It is expected that HAL will trap those, and bridge them to DBUS, etc. These 518events CAN and SHOULD be used to give feedback to the user about the rfkill 519status of the system. 520 521Input devices may issue events that are related to rfkill. These are the 522various KEY_* events and SW_* events supported by rfkill-input.c. 523 524******IMPORTANT****** 525When rfkill-input is ACTIVE, userspace is NOT TO CHANGE THE STATE OF AN RFKILL 526SWITCH IN RESPONSE TO AN INPUT EVENT also handled by rfkill-input, unless it 527has set to true the user_claim attribute for that particular switch. This rule 528is *absolute*; do NOT violate it. 529******IMPORTANT****** 530 531Userspace must not assume it is the only source of control for rfkill switches. 532Their state CAN and WILL change due to firmware actions, direct user actions, 533and the rfkill-input EPO override for *_RFKILL_ALL. 534 535When rfkill-input is not active, userspace must initiate a rfkill status 536change by writing to the "state" attribute in order for anything to happen. 537 538Take particular care to implement EV_SW SW_RFKILL_ALL properly. When that 539switch is set to OFF, *every* rfkill device *MUST* be immediately put into the 540RFKILL_STATE_SOFT_BLOCKED state, no questions asked. 541 542The following sysfs entries will be created: 543 544 name: Name assigned by driver to this key (interface or driver name). 545 type: Name of the key type ("wlan", "bluetooth", etc). 546 state: Current state of the transmitter 547 0: RFKILL_STATE_SOFT_BLOCKED 548 transmitter is forced off, but one can override it 549 by a write to the state attribute; 550 1: RFKILL_STATE_UNBLOCKED 551 transmiter is NOT forced off, and may operate if 552 all other conditions for such operation are met 553 (such as interface is up and configured, etc); 554 2: RFKILL_STATE_HARD_BLOCKED 555 transmitter is forced off by something outside of 556 the driver's control. One cannot set a device to 557 this state through writes to the state attribute; 558 claim: 1: Userspace handles events, 0: Kernel handles events 559 560Both the "state" and "claim" entries are also writable. For the "state" entry 561this means that when 1 or 0 is written, the device rfkill state (if not yet in 562the requested state), will be will be toggled accordingly. 563 564For the "claim" entry writing 1 to it means that the kernel no longer handles 565key events even though RFKILL_INPUT input was enabled. When "claim" has been 566set to 0, userspace should make sure that it listens for the input events or 567check the sysfs "state" entry regularly to correctly perform the required tasks 568when the rkfill key is pressed. 569 570A note about input devices and EV_SW events: 571 572In order to know the current state of an input device switch (like 573SW_RFKILL_ALL), you will need to use an IOCTL. That information is not 574available through sysfs in a generic way at this time, and it is not available 575through the rfkill class AT ALL. 576