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

TOMOYO Linux Cross Reference
Linux/net/rfkill/core.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ 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  * This program is free software; you can redistribute it and/or modify
  7  * it under the terms of the GNU General Public License as published by
  8  * the Free Software Foundation; either version 2 of the License, or
  9  * (at your option) any later version.
 10  *
 11  * This program is distributed in the hope that it will be useful,
 12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 14  * GNU General Public License for more details.
 15  *
 16  * You should have received a copy of the GNU General Public License
 17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
 18  */
 19 
 20 #include <linux/kernel.h>
 21 #include <linux/module.h>
 22 #include <linux/init.h>
 23 #include <linux/workqueue.h>
 24 #include <linux/capability.h>
 25 #include <linux/list.h>
 26 #include <linux/mutex.h>
 27 #include <linux/rfkill.h>
 28 #include <linux/sched.h>
 29 #include <linux/spinlock.h>
 30 #include <linux/device.h>
 31 #include <linux/miscdevice.h>
 32 #include <linux/wait.h>
 33 #include <linux/poll.h>
 34 #include <linux/fs.h>
 35 #include <linux/slab.h>
 36 
 37 #include "rfkill.h"
 38 
 39 #define POLL_INTERVAL           (5 * HZ)
 40 
 41 #define RFKILL_BLOCK_HW         BIT(0)
 42 #define RFKILL_BLOCK_SW         BIT(1)
 43 #define RFKILL_BLOCK_SW_PREV    BIT(2)
 44 #define RFKILL_BLOCK_ANY        (RFKILL_BLOCK_HW |\
 45                                  RFKILL_BLOCK_SW |\
 46                                  RFKILL_BLOCK_SW_PREV)
 47 #define RFKILL_BLOCK_SW_SETCALL BIT(31)
 48 
 49 struct rfkill {
 50         spinlock_t              lock;
 51 
 52         const char              *name;
 53         enum rfkill_type        type;
 54 
 55         unsigned long           state;
 56 
 57         u32                     idx;
 58 
 59         bool                    registered;
 60         bool                    persistent;
 61 
 62         const struct rfkill_ops *ops;
 63         void                    *data;
 64 
 65 #ifdef CONFIG_RFKILL_LEDS
 66         struct led_trigger      led_trigger;
 67         const char              *ledtrigname;
 68 #endif
 69 
 70         struct device           dev;
 71         struct list_head        node;
 72 
 73         struct delayed_work     poll_work;
 74         struct work_struct      uevent_work;
 75         struct work_struct      sync_work;
 76 };
 77 #define to_rfkill(d)    container_of(d, struct rfkill, dev)
 78 
 79 struct rfkill_int_event {
 80         struct list_head        list;
 81         struct rfkill_event     ev;
 82 };
 83 
 84 struct rfkill_data {
 85         struct list_head        list;
 86         struct list_head        events;
 87         struct mutex            mtx;
 88         wait_queue_head_t       read_wait;
 89         bool                    input_handler;
 90 };
 91 
 92 
 93 MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>");
 94 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
 95 MODULE_DESCRIPTION("RF switch support");
 96 MODULE_LICENSE("GPL");
 97 
 98 
 99 /*
100  * The locking here should be made much smarter, we currently have
101  * a bit of a stupid situation because drivers might want to register
102  * the rfkill struct under their own lock, and take this lock during
103  * rfkill method calls -- which will cause an AB-BA deadlock situation.
104  *
105  * To fix that, we need to rework this code here to be mostly lock-free
106  * and only use the mutex for list manipulations, not to protect the
107  * various other global variables. Then we can avoid holding the mutex
108  * around driver operations, and all is happy.
109  */
110 static LIST_HEAD(rfkill_list);  /* list of registered rf switches */
111 static DEFINE_MUTEX(rfkill_global_mutex);
112 static LIST_HEAD(rfkill_fds);   /* list of open fds of /dev/rfkill */
113 
114 static unsigned int rfkill_default_state = 1;
115 module_param_named(default_state, rfkill_default_state, uint, 0444);
116 MODULE_PARM_DESC(default_state,
117                  "Default initial state for all radio types, 0 = radio off");
118 
119 static struct {
120         bool cur, sav;
121 } rfkill_global_states[NUM_RFKILL_TYPES];
122 
123 static bool rfkill_epo_lock_active;
124 
125 
126 #ifdef CONFIG_RFKILL_LEDS
127 static void rfkill_led_trigger_event(struct rfkill *rfkill)
128 {
129         struct led_trigger *trigger;
130 
131         if (!rfkill->registered)
132                 return;
133 
134         trigger = &rfkill->led_trigger;
135 
136         if (rfkill->state & RFKILL_BLOCK_ANY)
137                 led_trigger_event(trigger, LED_OFF);
138         else
139                 led_trigger_event(trigger, LED_FULL);
140 }
141 
142 static void rfkill_led_trigger_activate(struct led_classdev *led)
143 {
144         struct rfkill *rfkill;
145 
146         rfkill = container_of(led->trigger, struct rfkill, led_trigger);
147 
148         rfkill_led_trigger_event(rfkill);
149 }
150 
151 const char *rfkill_get_led_trigger_name(struct rfkill *rfkill)
152 {
153         return rfkill->led_trigger.name;
154 }
155 EXPORT_SYMBOL(rfkill_get_led_trigger_name);
156 
157 void rfkill_set_led_trigger_name(struct rfkill *rfkill, const char *name)
158 {
159         BUG_ON(!rfkill);
160 
161         rfkill->ledtrigname = name;
162 }
163 EXPORT_SYMBOL(rfkill_set_led_trigger_name);
164 
165 static int rfkill_led_trigger_register(struct rfkill *rfkill)
166 {
167         rfkill->led_trigger.name = rfkill->ledtrigname
168                                         ? : dev_name(&rfkill->dev);
169         rfkill->led_trigger.activate = rfkill_led_trigger_activate;
170         return led_trigger_register(&rfkill->led_trigger);
171 }
172 
173 static void rfkill_led_trigger_unregister(struct rfkill *rfkill)
174 {
175         led_trigger_unregister(&rfkill->led_trigger);
176 }
177 #else
178 static void rfkill_led_trigger_event(struct rfkill *rfkill)
179 {
180 }
181 
182 static inline int rfkill_led_trigger_register(struct rfkill *rfkill)
183 {
184         return 0;
185 }
186 
187 static inline void rfkill_led_trigger_unregister(struct rfkill *rfkill)
188 {
189 }
190 #endif /* CONFIG_RFKILL_LEDS */
191 
192 static void rfkill_fill_event(struct rfkill_event *ev, struct rfkill *rfkill,
193                               enum rfkill_operation op)
194 {
195         unsigned long flags;
196 
197         ev->idx = rfkill->idx;
198         ev->type = rfkill->type;
199         ev->op = op;
200 
201         spin_lock_irqsave(&rfkill->lock, flags);
202         ev->hard = !!(rfkill->state & RFKILL_BLOCK_HW);
203         ev->soft = !!(rfkill->state & (RFKILL_BLOCK_SW |
204                                         RFKILL_BLOCK_SW_PREV));
205         spin_unlock_irqrestore(&rfkill->lock, flags);
206 }
207 
208 static void rfkill_send_events(struct rfkill *rfkill, enum rfkill_operation op)
209 {
210         struct rfkill_data *data;
211         struct rfkill_int_event *ev;
212 
213         list_for_each_entry(data, &rfkill_fds, list) {
214                 ev = kzalloc(sizeof(*ev), GFP_KERNEL);
215                 if (!ev)
216                         continue;
217                 rfkill_fill_event(&ev->ev, rfkill, op);
218                 mutex_lock(&data->mtx);
219                 list_add_tail(&ev->list, &data->events);
220                 mutex_unlock(&data->mtx);
221                 wake_up_interruptible(&data->read_wait);
222         }
223 }
224 
225 static void rfkill_event(struct rfkill *rfkill)
226 {
227         if (!rfkill->registered)
228                 return;
229 
230         kobject_uevent(&rfkill->dev.kobj, KOBJ_CHANGE);
231 
232         /* also send event to /dev/rfkill */
233         rfkill_send_events(rfkill, RFKILL_OP_CHANGE);
234 }
235 
236 static bool __rfkill_set_hw_state(struct rfkill *rfkill,
237                                   bool blocked, bool *change)
238 {
239         unsigned long flags;
240         bool prev, any;
241 
242         BUG_ON(!rfkill);
243 
244         spin_lock_irqsave(&rfkill->lock, flags);
245         prev = !!(rfkill->state & RFKILL_BLOCK_HW);
246         if (blocked)
247                 rfkill->state |= RFKILL_BLOCK_HW;
248         else
249                 rfkill->state &= ~RFKILL_BLOCK_HW;
250         *change = prev != blocked;
251         any = !!(rfkill->state & RFKILL_BLOCK_ANY);
252         spin_unlock_irqrestore(&rfkill->lock, flags);
253 
254         rfkill_led_trigger_event(rfkill);
255 
256         return any;
257 }
258 
259 /**
260  * rfkill_set_block - wrapper for set_block method
261  *
262  * @rfkill: the rfkill struct to use
263  * @blocked: the new software state
264  *
265  * Calls the set_block method (when applicable) and handles notifications
266  * etc. as well.
267  */
268 static void rfkill_set_block(struct rfkill *rfkill, bool blocked)
269 {
270         unsigned long flags;
271         bool prev, curr;
272         int err;
273 
274         if (unlikely(rfkill->dev.power.power_state.event & PM_EVENT_SLEEP))
275                 return;
276 
277         /*
278          * Some platforms (...!) generate input events which affect the
279          * _hard_ kill state -- whenever something tries to change the
280          * current software state query the hardware state too.
281          */
282         if (rfkill->ops->query)
283                 rfkill->ops->query(rfkill, rfkill->data);
284 
285         spin_lock_irqsave(&rfkill->lock, flags);
286         prev = rfkill->state & RFKILL_BLOCK_SW;
287 
288         if (rfkill->state & RFKILL_BLOCK_SW)
289                 rfkill->state |= RFKILL_BLOCK_SW_PREV;
290         else
291                 rfkill->state &= ~RFKILL_BLOCK_SW_PREV;
292 
293         if (blocked)
294                 rfkill->state |= RFKILL_BLOCK_SW;
295         else
296                 rfkill->state &= ~RFKILL_BLOCK_SW;
297 
298         rfkill->state |= RFKILL_BLOCK_SW_SETCALL;
299         spin_unlock_irqrestore(&rfkill->lock, flags);
300 
301         err = rfkill->ops->set_block(rfkill->data, blocked);
302 
303         spin_lock_irqsave(&rfkill->lock, flags);
304         if (err) {
305                 /*
306                  * Failed -- reset status to _prev, this may be different
307                  * from what set set _PREV to earlier in this function
308                  * if rfkill_set_sw_state was invoked.
309                  */
310                 if (rfkill->state & RFKILL_BLOCK_SW_PREV)
311                         rfkill->state |= RFKILL_BLOCK_SW;
312                 else
313                         rfkill->state &= ~RFKILL_BLOCK_SW;
314         }
315         rfkill->state &= ~RFKILL_BLOCK_SW_SETCALL;
316         rfkill->state &= ~RFKILL_BLOCK_SW_PREV;
317         curr = rfkill->state & RFKILL_BLOCK_SW;
318         spin_unlock_irqrestore(&rfkill->lock, flags);
319 
320         rfkill_led_trigger_event(rfkill);
321 
322         if (prev != curr)
323                 rfkill_event(rfkill);
324 }
325 
326 #ifdef CONFIG_RFKILL_INPUT
327 static atomic_t rfkill_input_disabled = ATOMIC_INIT(0);
328 
329 /**
330  * __rfkill_switch_all - Toggle state of all switches of given type
331  * @type: type of interfaces to be affected
332  * @blocked: the new state
333  *
334  * This function sets the state of all switches of given type,
335  * unless a specific switch is claimed by userspace (in which case,
336  * that switch is left alone) or suspended.
337  *
338  * Caller must have acquired rfkill_global_mutex.
339  */
340 static void __rfkill_switch_all(const enum rfkill_type type, bool blocked)
341 {
342         struct rfkill *rfkill;
343 
344         if (type == RFKILL_TYPE_ALL) {
345                 int i;
346 
347                 for (i = 0; i < NUM_RFKILL_TYPES; i++)
348                         rfkill_global_states[i].cur = blocked;
349         } else {
350                 rfkill_global_states[type].cur = blocked;
351         }
352 
353         list_for_each_entry(rfkill, &rfkill_list, node) {
354                 if (rfkill->type != type && type != RFKILL_TYPE_ALL)
355                         continue;
356 
357                 rfkill_set_block(rfkill, blocked);
358         }
359 }
360 
361 /**
362  * rfkill_switch_all - Toggle state of all switches of given type
363  * @type: type of interfaces to be affected
364  * @blocked: the new state
365  *
366  * Acquires rfkill_global_mutex and calls __rfkill_switch_all(@type, @state).
367  * Please refer to __rfkill_switch_all() for details.
368  *
369  * Does nothing if the EPO lock is active.
370  */
371 void rfkill_switch_all(enum rfkill_type type, bool blocked)
372 {
373         if (atomic_read(&rfkill_input_disabled))
374                 return;
375 
376         mutex_lock(&rfkill_global_mutex);
377 
378         if (!rfkill_epo_lock_active)
379                 __rfkill_switch_all(type, blocked);
380 
381         mutex_unlock(&rfkill_global_mutex);
382 }
383 
384 /**
385  * rfkill_epo - emergency power off all transmitters
386  *
387  * This kicks all non-suspended rfkill devices to RFKILL_STATE_SOFT_BLOCKED,
388  * ignoring everything in its path but rfkill_global_mutex and rfkill->mutex.
389  *
390  * The global state before the EPO is saved and can be restored later
391  * using rfkill_restore_states().
392  */
393 void rfkill_epo(void)
394 {
395         struct rfkill *rfkill;
396         int i;
397 
398         if (atomic_read(&rfkill_input_disabled))
399                 return;
400 
401         mutex_lock(&rfkill_global_mutex);
402 
403         rfkill_epo_lock_active = true;
404         list_for_each_entry(rfkill, &rfkill_list, node)
405                 rfkill_set_block(rfkill, true);
406 
407         for (i = 0; i < NUM_RFKILL_TYPES; i++) {
408                 rfkill_global_states[i].sav = rfkill_global_states[i].cur;
409                 rfkill_global_states[i].cur = true;
410         }
411 
412         mutex_unlock(&rfkill_global_mutex);
413 }
414 
415 /**
416  * rfkill_restore_states - restore global states
417  *
418  * Restore (and sync switches to) the global state from the
419  * states in rfkill_default_states.  This can undo the effects of
420  * a call to rfkill_epo().
421  */
422 void rfkill_restore_states(void)
423 {
424         int i;
425 
426         if (atomic_read(&rfkill_input_disabled))
427                 return;
428 
429         mutex_lock(&rfkill_global_mutex);
430 
431         rfkill_epo_lock_active = false;
432         for (i = 0; i < NUM_RFKILL_TYPES; i++)
433                 __rfkill_switch_all(i, rfkill_global_states[i].sav);
434         mutex_unlock(&rfkill_global_mutex);
435 }
436 
437 /**
438  * rfkill_remove_epo_lock - unlock state changes
439  *
440  * Used by rfkill-input manually unlock state changes, when
441  * the EPO switch is deactivated.
442  */
443 void rfkill_remove_epo_lock(void)
444 {
445         if (atomic_read(&rfkill_input_disabled))
446                 return;
447 
448         mutex_lock(&rfkill_global_mutex);
449         rfkill_epo_lock_active = false;
450         mutex_unlock(&rfkill_global_mutex);
451 }
452 
453 /**
454  * rfkill_is_epo_lock_active - returns true EPO is active
455  *
456  * Returns 0 (false) if there is NOT an active EPO contidion,
457  * and 1 (true) if there is an active EPO contition, which
458  * locks all radios in one of the BLOCKED states.
459  *
460  * Can be called in atomic context.
461  */
462 bool rfkill_is_epo_lock_active(void)
463 {
464         return rfkill_epo_lock_active;
465 }
466 
467 /**
468  * rfkill_get_global_sw_state - returns global state for a type
469  * @type: the type to get the global state of
470  *
471  * Returns the current global state for a given wireless
472  * device type.
473  */
474 bool rfkill_get_global_sw_state(const enum rfkill_type type)
475 {
476         return rfkill_global_states[type].cur;
477 }
478 #endif
479 
480 
481 bool rfkill_set_hw_state(struct rfkill *rfkill, bool blocked)
482 {
483         bool ret, change;
484 
485         ret = __rfkill_set_hw_state(rfkill, blocked, &change);
486 
487         if (!rfkill->registered)
488                 return ret;
489 
490         if (change)
491                 schedule_work(&rfkill->uevent_work);
492 
493         return ret;
494 }
495 EXPORT_SYMBOL(rfkill_set_hw_state);
496 
497 static void __rfkill_set_sw_state(struct rfkill *rfkill, bool blocked)
498 {
499         u32 bit = RFKILL_BLOCK_SW;
500 
501         /* if in a ops->set_block right now, use other bit */
502         if (rfkill->state & RFKILL_BLOCK_SW_SETCALL)
503                 bit = RFKILL_BLOCK_SW_PREV;
504 
505         if (blocked)
506                 rfkill->state |= bit;
507         else
508                 rfkill->state &= ~bit;
509 }
510 
511 bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked)
512 {
513         unsigned long flags;
514         bool prev, hwblock;
515 
516         BUG_ON(!rfkill);
517 
518         spin_lock_irqsave(&rfkill->lock, flags);
519         prev = !!(rfkill->state & RFKILL_BLOCK_SW);
520         __rfkill_set_sw_state(rfkill, blocked);
521         hwblock = !!(rfkill->state & RFKILL_BLOCK_HW);
522         blocked = blocked || hwblock;
523         spin_unlock_irqrestore(&rfkill->lock, flags);
524 
525         if (!rfkill->registered)
526                 return blocked;
527 
528         if (prev != blocked && !hwblock)
529                 schedule_work(&rfkill->uevent_work);
530 
531         rfkill_led_trigger_event(rfkill);
532 
533         return blocked;
534 }
535 EXPORT_SYMBOL(rfkill_set_sw_state);
536 
537 void rfkill_init_sw_state(struct rfkill *rfkill, bool blocked)
538 {
539         unsigned long flags;
540 
541         BUG_ON(!rfkill);
542         BUG_ON(rfkill->registered);
543 
544         spin_lock_irqsave(&rfkill->lock, flags);
545         __rfkill_set_sw_state(rfkill, blocked);
546         rfkill->persistent = true;
547         spin_unlock_irqrestore(&rfkill->lock, flags);
548 }
549 EXPORT_SYMBOL(rfkill_init_sw_state);
550 
551 void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw)
552 {
553         unsigned long flags;
554         bool swprev, hwprev;
555 
556         BUG_ON(!rfkill);
557 
558         spin_lock_irqsave(&rfkill->lock, flags);
559 
560         /*
561          * No need to care about prev/setblock ... this is for uevent only
562          * and that will get triggered by rfkill_set_block anyway.
563          */
564         swprev = !!(rfkill->state & RFKILL_BLOCK_SW);
565         hwprev = !!(rfkill->state & RFKILL_BLOCK_HW);
566         __rfkill_set_sw_state(rfkill, sw);
567         if (hw)
568                 rfkill->state |= RFKILL_BLOCK_HW;
569         else
570                 rfkill->state &= ~RFKILL_BLOCK_HW;
571 
572         spin_unlock_irqrestore(&rfkill->lock, flags);
573 
574         if (!rfkill->registered) {
575                 rfkill->persistent = true;
576         } else {
577                 if (swprev != sw || hwprev != hw)
578                         schedule_work(&rfkill->uevent_work);
579 
580                 rfkill_led_trigger_event(rfkill);
581         }
582 }
583 EXPORT_SYMBOL(rfkill_set_states);
584 
585 static ssize_t name_show(struct device *dev, struct device_attribute *attr,
586                          char *buf)
587 {
588         struct rfkill *rfkill = to_rfkill(dev);
589 
590         return sprintf(buf, "%s\n", rfkill->name);
591 }
592 static DEVICE_ATTR_RO(name);
593 
594 static const char *rfkill_get_type_str(enum rfkill_type type)
595 {
596         BUILD_BUG_ON(NUM_RFKILL_TYPES != RFKILL_TYPE_NFC + 1);
597 
598         switch (type) {
599         case RFKILL_TYPE_WLAN:
600                 return "wlan";
601         case RFKILL_TYPE_BLUETOOTH:
602                 return "bluetooth";
603         case RFKILL_TYPE_UWB:
604                 return "ultrawideband";
605         case RFKILL_TYPE_WIMAX:
606                 return "wimax";
607         case RFKILL_TYPE_WWAN:
608                 return "wwan";
609         case RFKILL_TYPE_GPS:
610                 return "gps";
611         case RFKILL_TYPE_FM:
612                 return "fm";
613         case RFKILL_TYPE_NFC:
614                 return "nfc";
615         default:
616                 BUG();
617         }
618 }
619 
620 static ssize_t type_show(struct device *dev, struct device_attribute *attr,
621                          char *buf)
622 {
623         struct rfkill *rfkill = to_rfkill(dev);
624 
625         return sprintf(buf, "%s\n", rfkill_get_type_str(rfkill->type));
626 }
627 static DEVICE_ATTR_RO(type);
628 
629 static ssize_t index_show(struct device *dev, struct device_attribute *attr,
630                           char *buf)
631 {
632         struct rfkill *rfkill = to_rfkill(dev);
633 
634         return sprintf(buf, "%d\n", rfkill->idx);
635 }
636 static DEVICE_ATTR_RO(index);
637 
638 static ssize_t persistent_show(struct device *dev,
639                                struct device_attribute *attr, char *buf)
640 {
641         struct rfkill *rfkill = to_rfkill(dev);
642 
643         return sprintf(buf, "%d\n", rfkill->persistent);
644 }
645 static DEVICE_ATTR_RO(persistent);
646 
647 static ssize_t hard_show(struct device *dev, struct device_attribute *attr,
648                          char *buf)
649 {
650         struct rfkill *rfkill = to_rfkill(dev);
651 
652         return sprintf(buf, "%d\n", (rfkill->state & RFKILL_BLOCK_HW) ? 1 : 0 );
653 }
654 static DEVICE_ATTR_RO(hard);
655 
656 static ssize_t soft_show(struct device *dev, struct device_attribute *attr,
657                          char *buf)
658 {
659         struct rfkill *rfkill = to_rfkill(dev);
660 
661         return sprintf(buf, "%d\n", (rfkill->state & RFKILL_BLOCK_SW) ? 1 : 0 );
662 }
663 
664 static ssize_t soft_store(struct device *dev, struct device_attribute *attr,
665                           const char *buf, size_t count)
666 {
667         struct rfkill *rfkill = to_rfkill(dev);
668         unsigned long state;
669         int err;
670 
671         if (!capable(CAP_NET_ADMIN))
672                 return -EPERM;
673 
674         err = kstrtoul(buf, 0, &state);
675         if (err)
676                 return err;
677 
678         if (state > 1 )
679                 return -EINVAL;
680 
681         mutex_lock(&rfkill_global_mutex);
682         rfkill_set_block(rfkill, state);
683         mutex_unlock(&rfkill_global_mutex);
684 
685         return count;
686 }
687 static DEVICE_ATTR_RW(soft);
688 
689 static u8 user_state_from_blocked(unsigned long state)
690 {
691         if (state & RFKILL_BLOCK_HW)
692                 return RFKILL_USER_STATE_HARD_BLOCKED;
693         if (state & RFKILL_BLOCK_SW)
694                 return RFKILL_USER_STATE_SOFT_BLOCKED;
695 
696         return RFKILL_USER_STATE_UNBLOCKED;
697 }
698 
699 static ssize_t state_show(struct device *dev, struct device_attribute *attr,
700                           char *buf)
701 {
702         struct rfkill *rfkill = to_rfkill(dev);
703 
704         return sprintf(buf, "%d\n", user_state_from_blocked(rfkill->state));
705 }
706 
707 static ssize_t state_store(struct device *dev, struct device_attribute *attr,
708                            const char *buf, size_t count)
709 {
710         struct rfkill *rfkill = to_rfkill(dev);
711         unsigned long state;
712         int err;
713 
714         if (!capable(CAP_NET_ADMIN))
715                 return -EPERM;
716 
717         err = kstrtoul(buf, 0, &state);
718         if (err)
719                 return err;
720 
721         if (state != RFKILL_USER_STATE_SOFT_BLOCKED &&
722             state != RFKILL_USER_STATE_UNBLOCKED)
723                 return -EINVAL;
724 
725         mutex_lock(&rfkill_global_mutex);
726         rfkill_set_block(rfkill, state == RFKILL_USER_STATE_SOFT_BLOCKED);
727         mutex_unlock(&rfkill_global_mutex);
728 
729         return count;
730 }
731 static DEVICE_ATTR_RW(state);
732 
733 static ssize_t claim_show(struct device *dev, struct device_attribute *attr,
734                           char *buf)
735 {
736         return sprintf(buf, "%d\n", 0);
737 }
738 static DEVICE_ATTR_RO(claim);
739 
740 static struct attribute *rfkill_dev_attrs[] = {
741         &dev_attr_name.attr,
742         &dev_attr_type.attr,
743         &dev_attr_index.attr,
744         &dev_attr_persistent.attr,
745         &dev_attr_state.attr,
746         &dev_attr_claim.attr,
747         &dev_attr_soft.attr,
748         &dev_attr_hard.attr,
749         NULL,
750 };
751 ATTRIBUTE_GROUPS(rfkill_dev);
752 
753 static void rfkill_release(struct device *dev)
754 {
755         struct rfkill *rfkill = to_rfkill(dev);
756 
757         kfree(rfkill);
758 }
759 
760 static int rfkill_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
761 {
762         struct rfkill *rfkill = to_rfkill(dev);
763         unsigned long flags;
764         u32 state;
765         int error;
766 
767         error = add_uevent_var(env, "RFKILL_NAME=%s", rfkill->name);
768         if (error)
769                 return error;
770         error = add_uevent_var(env, "RFKILL_TYPE=%s",
771                                rfkill_get_type_str(rfkill->type));
772         if (error)
773                 return error;
774         spin_lock_irqsave(&rfkill->lock, flags);
775         state = rfkill->state;
776         spin_unlock_irqrestore(&rfkill->lock, flags);
777         error = add_uevent_var(env, "RFKILL_STATE=%d",
778                                user_state_from_blocked(state));
779         return error;
780 }
781 
782 void rfkill_pause_polling(struct rfkill *rfkill)
783 {
784         BUG_ON(!rfkill);
785 
786         if (!rfkill->ops->poll)
787                 return;
788 
789         cancel_delayed_work_sync(&rfkill->poll_work);
790 }
791 EXPORT_SYMBOL(rfkill_pause_polling);
792 
793 void rfkill_resume_polling(struct rfkill *rfkill)
794 {
795         BUG_ON(!rfkill);
796 
797         if (!rfkill->ops->poll)
798                 return;
799 
800         queue_delayed_work(system_power_efficient_wq,
801                            &rfkill->poll_work, 0);
802 }
803 EXPORT_SYMBOL(rfkill_resume_polling);
804 
805 #ifdef CONFIG_PM_SLEEP
806 static int rfkill_suspend(struct device *dev)
807 {
808         struct rfkill *rfkill = to_rfkill(dev);
809 
810         rfkill_pause_polling(rfkill);
811 
812         return 0;
813 }
814 
815 static int rfkill_resume(struct device *dev)
816 {
817         struct rfkill *rfkill = to_rfkill(dev);
818         bool cur;
819 
820         if (!rfkill->persistent) {
821                 cur = !!(rfkill->state & RFKILL_BLOCK_SW);
822                 rfkill_set_block(rfkill, cur);
823         }
824 
825         rfkill_resume_polling(rfkill);
826 
827         return 0;
828 }
829 
830 static SIMPLE_DEV_PM_OPS(rfkill_pm_ops, rfkill_suspend, rfkill_resume);
831 #define RFKILL_PM_OPS (&rfkill_pm_ops)
832 #else
833 #define RFKILL_PM_OPS NULL
834 #endif
835 
836 static struct class rfkill_class = {
837         .name           = "rfkill",
838         .dev_release    = rfkill_release,
839         .dev_groups     = rfkill_dev_groups,
840         .dev_uevent     = rfkill_dev_uevent,
841         .pm             = RFKILL_PM_OPS,
842 };
843 
844 bool rfkill_blocked(struct rfkill *rfkill)
845 {
846         unsigned long flags;
847         u32 state;
848 
849         spin_lock_irqsave(&rfkill->lock, flags);
850         state = rfkill->state;
851         spin_unlock_irqrestore(&rfkill->lock, flags);
852 
853         return !!(state & RFKILL_BLOCK_ANY);
854 }
855 EXPORT_SYMBOL(rfkill_blocked);
856 
857 
858 struct rfkill * __must_check rfkill_alloc(const char *name,
859                                           struct device *parent,
860                                           const enum rfkill_type type,
861                                           const struct rfkill_ops *ops,
862                                           void *ops_data)
863 {
864         struct rfkill *rfkill;
865         struct device *dev;
866 
867         if (WARN_ON(!ops))
868                 return NULL;
869 
870         if (WARN_ON(!ops->set_block))
871                 return NULL;
872 
873         if (WARN_ON(!name))
874                 return NULL;
875 
876         if (WARN_ON(type == RFKILL_TYPE_ALL || type >= NUM_RFKILL_TYPES))
877                 return NULL;
878 
879         rfkill = kzalloc(sizeof(*rfkill), GFP_KERNEL);
880         if (!rfkill)
881                 return NULL;
882 
883         spin_lock_init(&rfkill->lock);
884         INIT_LIST_HEAD(&rfkill->node);
885         rfkill->type = type;
886         rfkill->name = name;
887         rfkill->ops = ops;
888         rfkill->data = ops_data;
889 
890         dev = &rfkill->dev;
891         dev->class = &rfkill_class;
892         dev->parent = parent;
893         device_initialize(dev);
894 
895         return rfkill;
896 }
897 EXPORT_SYMBOL(rfkill_alloc);
898 
899 static void rfkill_poll(struct work_struct *work)
900 {
901         struct rfkill *rfkill;
902 
903         rfkill = container_of(work, struct rfkill, poll_work.work);
904 
905         /*
906          * Poll hardware state -- driver will use one of the
907          * rfkill_set{,_hw,_sw}_state functions and use its
908          * return value to update the current status.
909          */
910         rfkill->ops->poll(rfkill, rfkill->data);
911 
912         queue_delayed_work(system_power_efficient_wq,
913                 &rfkill->poll_work,
914                 round_jiffies_relative(POLL_INTERVAL));
915 }
916 
917 static void rfkill_uevent_work(struct work_struct *work)
918 {
919         struct rfkill *rfkill;
920 
921         rfkill = container_of(work, struct rfkill, uevent_work);
922 
923         mutex_lock(&rfkill_global_mutex);
924         rfkill_event(rfkill);
925         mutex_unlock(&rfkill_global_mutex);
926 }
927 
928 static void rfkill_sync_work(struct work_struct *work)
929 {
930         struct rfkill *rfkill;
931         bool cur;
932 
933         rfkill = container_of(work, struct rfkill, sync_work);
934 
935         mutex_lock(&rfkill_global_mutex);
936         cur = rfkill_global_states[rfkill->type].cur;
937         rfkill_set_block(rfkill, cur);
938         mutex_unlock(&rfkill_global_mutex);
939 }
940 
941 int __must_check rfkill_register(struct rfkill *rfkill)
942 {
943         static unsigned long rfkill_no;
944         struct device *dev = &rfkill->dev;
945         int error;
946 
947         BUG_ON(!rfkill);
948 
949         mutex_lock(&rfkill_global_mutex);
950 
951         if (rfkill->registered) {
952                 error = -EALREADY;
953                 goto unlock;
954         }
955 
956         rfkill->idx = rfkill_no;
957         dev_set_name(dev, "rfkill%lu", rfkill_no);
958         rfkill_no++;
959 
960         list_add_tail(&rfkill->node, &rfkill_list);
961 
962         error = device_add(dev);
963         if (error)
964                 goto remove;
965 
966         error = rfkill_led_trigger_register(rfkill);
967         if (error)
968                 goto devdel;
969 
970         rfkill->registered = true;
971 
972         INIT_DELAYED_WORK(&rfkill->poll_work, rfkill_poll);
973         INIT_WORK(&rfkill->uevent_work, rfkill_uevent_work);
974         INIT_WORK(&rfkill->sync_work, rfkill_sync_work);
975 
976         if (rfkill->ops->poll)
977                 queue_delayed_work(system_power_efficient_wq,
978                         &rfkill->poll_work,
979                         round_jiffies_relative(POLL_INTERVAL));
980 
981         if (!rfkill->persistent || rfkill_epo_lock_active) {
982                 schedule_work(&rfkill->sync_work);
983         } else {
984 #ifdef CONFIG_RFKILL_INPUT
985                 bool soft_blocked = !!(rfkill->state & RFKILL_BLOCK_SW);
986 
987                 if (!atomic_read(&rfkill_input_disabled))
988                         __rfkill_switch_all(rfkill->type, soft_blocked);
989 #endif
990         }
991 
992         rfkill_send_events(rfkill, RFKILL_OP_ADD);
993 
994         mutex_unlock(&rfkill_global_mutex);
995         return 0;
996 
997  devdel:
998         device_del(&rfkill->dev);
999  remove:
1000         list_del_init(&rfkill->node);
1001  unlock:
1002         mutex_unlock(&rfkill_global_mutex);
1003         return error;
1004 }
1005 EXPORT_SYMBOL(rfkill_register);
1006 
1007 void rfkill_unregister(struct rfkill *rfkill)
1008 {
1009         BUG_ON(!rfkill);
1010 
1011         if (rfkill->ops->poll)
1012                 cancel_delayed_work_sync(&rfkill->poll_work);
1013 
1014         cancel_work_sync(&rfkill->uevent_work);
1015         cancel_work_sync(&rfkill->sync_work);
1016 
1017         rfkill->registered = false;
1018 
1019         device_del(&rfkill->dev);
1020 
1021         mutex_lock(&rfkill_global_mutex);
1022         rfkill_send_events(rfkill, RFKILL_OP_DEL);
1023         list_del_init(&rfkill->node);
1024         mutex_unlock(&rfkill_global_mutex);
1025 
1026         rfkill_led_trigger_unregister(rfkill);
1027 }
1028 EXPORT_SYMBOL(rfkill_unregister);
1029 
1030 void rfkill_destroy(struct rfkill *rfkill)
1031 {
1032         if (rfkill)
1033                 put_device(&rfkill->dev);
1034 }
1035 EXPORT_SYMBOL(rfkill_destroy);
1036 
1037 static int rfkill_fop_open(struct inode *inode, struct file *file)
1038 {
1039         struct rfkill_data *data;
1040         struct rfkill *rfkill;
1041         struct rfkill_int_event *ev, *tmp;
1042 
1043         data = kzalloc(sizeof(*data), GFP_KERNEL);
1044         if (!data)
1045                 return -ENOMEM;
1046 
1047         INIT_LIST_HEAD(&data->events);
1048         mutex_init(&data->mtx);
1049         init_waitqueue_head(&data->read_wait);
1050 
1051         mutex_lock(&rfkill_global_mutex);
1052         mutex_lock(&data->mtx);
1053         /*
1054          * start getting events from elsewhere but hold mtx to get
1055          * startup events added first
1056          */
1057 
1058         list_for_each_entry(rfkill, &rfkill_list, node) {
1059                 ev = kzalloc(sizeof(*ev), GFP_KERNEL);
1060                 if (!ev)
1061                         goto free;
1062                 rfkill_fill_event(&ev->ev, rfkill, RFKILL_OP_ADD);
1063                 list_add_tail(&ev->list, &data->events);
1064         }
1065         list_add(&data->list, &rfkill_fds);
1066         mutex_unlock(&data->mtx);
1067         mutex_unlock(&rfkill_global_mutex);
1068 
1069         file->private_data = data;
1070 
1071         return nonseekable_open(inode, file);
1072 
1073  free:
1074         mutex_unlock(&data->mtx);
1075         mutex_unlock(&rfkill_global_mutex);
1076         mutex_destroy(&data->mtx);
1077         list_for_each_entry_safe(ev, tmp, &data->events, list)
1078                 kfree(ev);
1079         kfree(data);
1080         return -ENOMEM;
1081 }
1082 
1083 static unsigned int rfkill_fop_poll(struct file *file, poll_table *wait)
1084 {
1085         struct rfkill_data *data = file->private_data;
1086         unsigned int res = POLLOUT | POLLWRNORM;
1087 
1088         poll_wait(file, &data->read_wait, wait);
1089 
1090         mutex_lock(&data->mtx);
1091         if (!list_empty(&data->events))
1092                 res = POLLIN | POLLRDNORM;
1093         mutex_unlock(&data->mtx);
1094 
1095         return res;
1096 }
1097 
1098 static bool rfkill_readable(struct rfkill_data *data)
1099 {
1100         bool r;
1101 
1102         mutex_lock(&data->mtx);
1103         r = !list_empty(&data->events);
1104         mutex_unlock(&data->mtx);
1105 
1106         return r;
1107 }
1108 
1109 static ssize_t rfkill_fop_read(struct file *file, char __user *buf,
1110                                size_t count, loff_t *pos)
1111 {
1112         struct rfkill_data *data = file->private_data;
1113         struct rfkill_int_event *ev;
1114         unsigned long sz;
1115         int ret;
1116 
1117         mutex_lock(&data->mtx);
1118 
1119         while (list_empty(&data->events)) {
1120                 if (file->f_flags & O_NONBLOCK) {
1121                         ret = -EAGAIN;
1122                         goto out;
1123                 }
1124                 mutex_unlock(&data->mtx);
1125                 ret = wait_event_interruptible(data->read_wait,
1126                                                rfkill_readable(data));
1127                 mutex_lock(&data->mtx);
1128 
1129                 if (ret)
1130                         goto out;
1131         }
1132 
1133         ev = list_first_entry(&data->events, struct rfkill_int_event,
1134                                 list);
1135 
1136         sz = min_t(unsigned long, sizeof(ev->ev), count);
1137         ret = sz;
1138         if (copy_to_user(buf, &ev->ev, sz))
1139                 ret = -EFAULT;
1140 
1141         list_del(&ev->list);
1142         kfree(ev);
1143  out:
1144         mutex_unlock(&data->mtx);
1145         return ret;
1146 }
1147 
1148 static ssize_t rfkill_fop_write(struct file *file, const char __user *buf,
1149                                 size_t count, loff_t *pos)
1150 {
1151         struct rfkill *rfkill;
1152         struct rfkill_event ev;
1153 
1154         /* we don't need the 'hard' variable but accept it */
1155         if (count < RFKILL_EVENT_SIZE_V1 - 1)
1156                 return -EINVAL;
1157 
1158         /*
1159          * Copy as much data as we can accept into our 'ev' buffer,
1160          * but tell userspace how much we've copied so it can determine
1161          * our API version even in a write() call, if it cares.
1162          */
1163         count = min(count, sizeof(ev));
1164         if (copy_from_user(&ev, buf, count))
1165                 return -EFAULT;
1166 
1167         if (ev.op != RFKILL_OP_CHANGE && ev.op != RFKILL_OP_CHANGE_ALL)
1168                 return -EINVAL;
1169 
1170         if (ev.type >= NUM_RFKILL_TYPES)
1171                 return -EINVAL;
1172 
1173         mutex_lock(&rfkill_global_mutex);
1174 
1175         if (ev.op == RFKILL_OP_CHANGE_ALL) {
1176                 if (ev.type == RFKILL_TYPE_ALL) {
1177                         enum rfkill_type i;
1178                         for (i = 0; i < NUM_RFKILL_TYPES; i++)
1179                                 rfkill_global_states[i].cur = ev.soft;
1180                 } else {
1181                         rfkill_global_states[ev.type].cur = ev.soft;
1182                 }
1183         }
1184 
1185         list_for_each_entry(rfkill, &rfkill_list, node) {
1186                 if (rfkill->idx != ev.idx && ev.op != RFKILL_OP_CHANGE_ALL)
1187                         continue;
1188 
1189                 if (rfkill->type != ev.type && ev.type != RFKILL_TYPE_ALL)
1190                         continue;
1191 
1192                 rfkill_set_block(rfkill, ev.soft);
1193         }
1194         mutex_unlock(&rfkill_global_mutex);
1195 
1196         return count;
1197 }
1198 
1199 static int rfkill_fop_release(struct inode *inode, struct file *file)
1200 {
1201         struct rfkill_data *data = file->private_data;
1202         struct rfkill_int_event *ev, *tmp;
1203 
1204         mutex_lock(&rfkill_global_mutex);
1205         list_del(&data->list);
1206         mutex_unlock(&rfkill_global_mutex);
1207 
1208         mutex_destroy(&data->mtx);
1209         list_for_each_entry_safe(ev, tmp, &data->events, list)
1210                 kfree(ev);
1211 
1212 #ifdef CONFIG_RFKILL_INPUT
1213         if (data->input_handler)
1214                 if (atomic_dec_return(&rfkill_input_disabled) == 0)
1215                         printk(KERN_DEBUG "rfkill: input handler enabled\n");
1216 #endif
1217 
1218         kfree(data);
1219 
1220         return 0;
1221 }
1222 
1223 #ifdef CONFIG_RFKILL_INPUT
1224 static long rfkill_fop_ioctl(struct file *file, unsigned int cmd,
1225                              unsigned long arg)
1226 {
1227         struct rfkill_data *data = file->private_data;
1228 
1229         if (_IOC_TYPE(cmd) != RFKILL_IOC_MAGIC)
1230                 return -ENOSYS;
1231 
1232         if (_IOC_NR(cmd) != RFKILL_IOC_NOINPUT)
1233                 return -ENOSYS;
1234 
1235         mutex_lock(&data->mtx);
1236 
1237         if (!data->input_handler) {
1238                 if (atomic_inc_return(&rfkill_input_disabled) == 1)
1239                         printk(KERN_DEBUG "rfkill: input handler disabled\n");
1240                 data->input_handler = true;
1241         }
1242 
1243         mutex_unlock(&data->mtx);
1244 
1245         return 0;
1246 }
1247 #endif
1248 
1249 static const struct file_operations rfkill_fops = {
1250         .owner          = THIS_MODULE,
1251         .open           = rfkill_fop_open,
1252         .read           = rfkill_fop_read,
1253         .write          = rfkill_fop_write,
1254         .poll           = rfkill_fop_poll,
1255         .release        = rfkill_fop_release,
1256 #ifdef CONFIG_RFKILL_INPUT
1257         .unlocked_ioctl = rfkill_fop_ioctl,
1258         .compat_ioctl   = rfkill_fop_ioctl,
1259 #endif
1260         .llseek         = no_llseek,
1261 };
1262 
1263 static struct miscdevice rfkill_miscdev = {
1264         .name   = "rfkill",
1265         .fops   = &rfkill_fops,
1266         .minor  = MISC_DYNAMIC_MINOR,
1267 };
1268 
1269 static int __init rfkill_init(void)
1270 {
1271         int error;
1272         int i;
1273 
1274         for (i = 0; i < NUM_RFKILL_TYPES; i++)
1275                 rfkill_global_states[i].cur = !rfkill_default_state;
1276 
1277         error = class_register(&rfkill_class);
1278         if (error)
1279                 goto out;
1280 
1281         error = misc_register(&rfkill_miscdev);
1282         if (error) {
1283                 class_unregister(&rfkill_class);
1284                 goto out;
1285         }
1286 
1287 #ifdef CONFIG_RFKILL_INPUT
1288         error = rfkill_handler_init();
1289         if (error) {
1290                 misc_deregister(&rfkill_miscdev);
1291                 class_unregister(&rfkill_class);
1292                 goto out;
1293         }
1294 #endif
1295 
1296  out:
1297         return error;
1298 }
1299 subsys_initcall(rfkill_init);
1300 
1301 static void __exit rfkill_exit(void)
1302 {
1303 #ifdef CONFIG_RFKILL_INPUT
1304         rfkill_handler_exit();
1305 #endif
1306         misc_deregister(&rfkill_miscdev);
1307         class_unregister(&rfkill_class);
1308 }
1309 module_exit(rfkill_exit);
1310 

~ [ 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