~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/rfkill.h

Version: ~ [ linux-5.10-rc5 ] ~ [ linux-5.9.10 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.79 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.159 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.208 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.245 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.245 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright (C) 2006 - 2007 Ivo van Doorn
  3  * Copyright (C) 2007 Dmitry Torokhov
  4  * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
  5  *
  6  * Permission to use, copy, modify, and/or distribute this software for any
  7  * purpose with or without fee is hereby granted, provided that the above
  8  * copyright notice and this permission notice appear in all copies.
  9  *
 10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 17  */
 18 #ifndef __RFKILL_H
 19 #define __RFKILL_H
 20 
 21 #include <uapi/linux/rfkill.h>
 22 
 23 /* don't allow anyone to use these in the kernel */
 24 enum rfkill_user_states {
 25         RFKILL_USER_STATE_SOFT_BLOCKED  = RFKILL_STATE_SOFT_BLOCKED,
 26         RFKILL_USER_STATE_UNBLOCKED     = RFKILL_STATE_UNBLOCKED,
 27         RFKILL_USER_STATE_HARD_BLOCKED  = RFKILL_STATE_HARD_BLOCKED,
 28 };
 29 #undef RFKILL_STATE_SOFT_BLOCKED
 30 #undef RFKILL_STATE_UNBLOCKED
 31 #undef RFKILL_STATE_HARD_BLOCKED
 32 
 33 #include <linux/kernel.h>
 34 #include <linux/list.h>
 35 #include <linux/mutex.h>
 36 #include <linux/leds.h>
 37 #include <linux/err.h>
 38 
 39 struct device;
 40 /* this is opaque */
 41 struct rfkill;
 42 
 43 /**
 44  * struct rfkill_ops - rfkill driver methods
 45  *
 46  * @poll: poll the rfkill block state(s) -- only assign this method
 47  *      when you need polling. When called, simply call one of the
 48  *      rfkill_set{,_hw,_sw}_state family of functions. If the hw
 49  *      is getting unblocked you need to take into account the return
 50  *      value of those functions to make sure the software block is
 51  *      properly used.
 52  * @query: query the rfkill block state(s) and call exactly one of the
 53  *      rfkill_set{,_hw,_sw}_state family of functions. Assign this
 54  *      method if input events can cause hardware state changes to make
 55  *      the rfkill core query your driver before setting a requested
 56  *      block.
 57  * @set_block: turn the transmitter on (blocked == false) or off
 58  *      (blocked == true) -- ignore and return 0 when hard blocked.
 59  *      This callback must be assigned.
 60  */
 61 struct rfkill_ops {
 62         void    (*poll)(struct rfkill *rfkill, void *data);
 63         void    (*query)(struct rfkill *rfkill, void *data);
 64         int     (*set_block)(void *data, bool blocked);
 65 };
 66 
 67 #if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
 68 /**
 69  * rfkill_alloc - allocate rfkill structure
 70  * @name: name of the struct -- the string is not copied internally
 71  * @parent: device that has rf switch on it
 72  * @type: type of the switch (RFKILL_TYPE_*)
 73  * @ops: rfkill methods
 74  * @ops_data: data passed to each method
 75  *
 76  * This function should be called by the transmitter driver to allocate an
 77  * rfkill structure. Returns %NULL on failure.
 78  */
 79 struct rfkill * __must_check rfkill_alloc(const char *name,
 80                                           struct device *parent,
 81                                           const enum rfkill_type type,
 82                                           const struct rfkill_ops *ops,
 83                                           void *ops_data);
 84 
 85 /**
 86  * rfkill_register - Register a rfkill structure.
 87  * @rfkill: rfkill structure to be registered
 88  *
 89  * This function should be called by the transmitter driver to register
 90  * the rfkill structure. Before calling this function the driver needs
 91  * to be ready to service method calls from rfkill.
 92  *
 93  * If rfkill_init_sw_state() is not called before registration,
 94  * set_block() will be called to initialize the software blocked state
 95  * to a default value.
 96  *
 97  * If the hardware blocked state is not set before registration,
 98  * it is assumed to be unblocked.
 99  */
100 int __must_check rfkill_register(struct rfkill *rfkill);
101 
102 /**
103  * rfkill_pause_polling(struct rfkill *rfkill)
104  *
105  * Pause polling -- say transmitter is off for other reasons.
106  * NOTE: not necessary for suspend/resume -- in that case the
107  * core stops polling anyway
108  */
109 void rfkill_pause_polling(struct rfkill *rfkill);
110 
111 /**
112  * rfkill_resume_polling(struct rfkill *rfkill)
113  *
114  * Pause polling -- say transmitter is off for other reasons.
115  * NOTE: not necessary for suspend/resume -- in that case the
116  * core stops polling anyway
117  */
118 void rfkill_resume_polling(struct rfkill *rfkill);
119 
120 
121 /**
122  * rfkill_unregister - Unregister a rfkill structure.
123  * @rfkill: rfkill structure to be unregistered
124  *
125  * This function should be called by the network driver during device
126  * teardown to destroy rfkill structure. Until it returns, the driver
127  * needs to be able to service method calls.
128  */
129 void rfkill_unregister(struct rfkill *rfkill);
130 
131 /**
132  * rfkill_destroy - free rfkill structure
133  * @rfkill: rfkill structure to be destroyed
134  *
135  * Destroys the rfkill structure.
136  */
137 void rfkill_destroy(struct rfkill *rfkill);
138 
139 /**
140  * rfkill_set_hw_state - Set the internal rfkill hardware block state
141  * @rfkill: pointer to the rfkill class to modify.
142  * @state: the current hardware block state to set
143  *
144  * rfkill drivers that get events when the hard-blocked state changes
145  * use this function to notify the rfkill core (and through that also
146  * userspace) of the current state.  They should also use this after
147  * resume if the state could have changed.
148  *
149  * You need not (but may) call this function if poll_state is assigned.
150  *
151  * This function can be called in any context, even from within rfkill
152  * callbacks.
153  *
154  * The function returns the combined block state (true if transmitter
155  * should be blocked) so that drivers need not keep track of the soft
156  * block state -- which they might not be able to.
157  */
158 bool rfkill_set_hw_state(struct rfkill *rfkill, bool blocked);
159 
160 /**
161  * rfkill_set_sw_state - Set the internal rfkill software block state
162  * @rfkill: pointer to the rfkill class to modify.
163  * @state: the current software block state to set
164  *
165  * rfkill drivers that get events when the soft-blocked state changes
166  * (yes, some platforms directly act on input but allow changing again)
167  * use this function to notify the rfkill core (and through that also
168  * userspace) of the current state.
169  *
170  * Drivers should also call this function after resume if the state has
171  * been changed by the user.  This only makes sense for "persistent"
172  * devices (see rfkill_init_sw_state()).
173  *
174  * This function can be called in any context, even from within rfkill
175  * callbacks.
176  *
177  * The function returns the combined block state (true if transmitter
178  * should be blocked).
179  */
180 bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked);
181 
182 /**
183  * rfkill_init_sw_state - Initialize persistent software block state
184  * @rfkill: pointer to the rfkill class to modify.
185  * @state: the current software block state to set
186  *
187  * rfkill drivers that preserve their software block state over power off
188  * use this function to notify the rfkill core (and through that also
189  * userspace) of their initial state.  It should only be used before
190  * registration.
191  *
192  * In addition, it marks the device as "persistent", an attribute which
193  * can be read by userspace.  Persistent devices are expected to preserve
194  * their own state when suspended.
195  */
196 void rfkill_init_sw_state(struct rfkill *rfkill, bool blocked);
197 
198 /**
199  * rfkill_set_states - Set the internal rfkill block states
200  * @rfkill: pointer to the rfkill class to modify.
201  * @sw: the current software block state to set
202  * @hw: the current hardware block state to set
203  *
204  * This function can be called in any context, even from within rfkill
205  * callbacks.
206  */
207 void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw);
208 
209 /**
210  * rfkill_blocked - query rfkill block
211  *
212  * @rfkill: rfkill struct to query
213  */
214 bool rfkill_blocked(struct rfkill *rfkill);
215 #else /* !RFKILL */
216 static inline struct rfkill * __must_check
217 rfkill_alloc(const char *name,
218              struct device *parent,
219              const enum rfkill_type type,
220              const struct rfkill_ops *ops,
221              void *ops_data)
222 {
223         return ERR_PTR(-ENODEV);
224 }
225 
226 static inline int __must_check rfkill_register(struct rfkill *rfkill)
227 {
228         if (rfkill == ERR_PTR(-ENODEV))
229                 return 0;
230         return -EINVAL;
231 }
232 
233 static inline void rfkill_pause_polling(struct rfkill *rfkill)
234 {
235 }
236 
237 static inline void rfkill_resume_polling(struct rfkill *rfkill)
238 {
239 }
240 
241 static inline void rfkill_unregister(struct rfkill *rfkill)
242 {
243 }
244 
245 static inline void rfkill_destroy(struct rfkill *rfkill)
246 {
247 }
248 
249 static inline bool rfkill_set_hw_state(struct rfkill *rfkill, bool blocked)
250 {
251         return blocked;
252 }
253 
254 static inline bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked)
255 {
256         return blocked;
257 }
258 
259 static inline void rfkill_init_sw_state(struct rfkill *rfkill, bool blocked)
260 {
261 }
262 
263 static inline void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw)
264 {
265 }
266 
267 static inline bool rfkill_blocked(struct rfkill *rfkill)
268 {
269         return false;
270 }
271 #endif /* RFKILL || RFKILL_MODULE */
272 
273 
274 #ifdef CONFIG_RFKILL_LEDS
275 /**
276  * rfkill_get_led_trigger_name - Get the LED trigger name for the button's LED.
277  * This function might return a NULL pointer if registering of the
278  * LED trigger failed. Use this as "default_trigger" for the LED.
279  */
280 const char *rfkill_get_led_trigger_name(struct rfkill *rfkill);
281 
282 /**
283  * rfkill_set_led_trigger_name -- set the LED trigger name
284  * @rfkill: rfkill struct
285  * @name: LED trigger name
286  *
287  * This function sets the LED trigger name of the radio LED
288  * trigger that rfkill creates. It is optional, but if called
289  * must be called before rfkill_register() to be effective.
290  */
291 void rfkill_set_led_trigger_name(struct rfkill *rfkill, const char *name);
292 #else
293 static inline const char *rfkill_get_led_trigger_name(struct rfkill *rfkill)
294 {
295         return NULL;
296 }
297 
298 static inline void
299 rfkill_set_led_trigger_name(struct rfkill *rfkill, const char *name)
300 {
301 }
302 #endif
303 
304 #endif /* RFKILL_H */
305 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp