litmus-rt.git - The LITMUS^RT kernel.

The LITMUS^RT kernel.

Bjoern Brandenburg

about summary refs log tree commit diff stats

diff options

author	Luciano Coelho <coelho@ti.com>	2011-05-27 08:34:46 -0400
committer	John W. Linville <linville@tuxdriver.com>	2011-05-31 14:47:25 -0400
commit	2497a246e880d1fb537f754f551177c01fa39242 (patch)
tree	530cd6f0533ae65ec3336e3b85e7f94f051d54d7 /fs/file_table.c
parent	dd08682150e1815fe5cdd0673a2f2e9cd2d55a7a (diff)

wl12xx: fix DFS channels handling in scheduled scan

DFS channels were never getting included in the scheduled scans, because they always contain the passive flag as well and the call was asking for DFS and active channels. Fix this by ignoring the passive flag when collecting DFS channels. Also, move the DFS channels in the channel list before the 5GHz active channels (this was implemented in the FW differently than specified). Signed-off-by: Luciano Coelho <coelho@ti.com> Signed-off-by: John W. Linville <linville@tuxdriver.com>

Diffstat (limited to 'fs/file_table.c')

0 files changed, 0 insertions, 0 deletions

_fn_t fn; void *arg; }; static inline int stop_one_cpu(unsigned int cpu, cpu_stop_fn_t fn, void *arg) { int ret = -ENOENT; preempt_disable(); if (cpu == smp_processor_id()) ret = fn(arg); preempt_enable(); return ret; } static void stop_one_cpu_nowait_workfn(struct work_struct *work) { struct cpu_stop_work *stwork = container_of(work, struct cpu_stop_work, work); preempt_disable(); stwork->fn(stwork->arg); preempt_enable(); } static inline void stop_one_cpu_nowait(unsigned int cpu, cpu_stop_fn_t fn, void *arg, struct cpu_stop_work *work_buf) { if (cpu == smp_processor_id()) { INIT_WORK(&work_buf->work, stop_one_cpu_nowait_workfn); work_buf->fn = fn; work_buf->arg = arg; schedule_work(&work_buf->work); } } static inline int stop_cpus(const struct cpumask *cpumask, cpu_stop_fn_t fn, void *arg) { if (cpumask_test_cpu(raw_smp_processor_id(), cpumask)) return stop_one_cpu(raw_smp_processor_id(), fn, arg); return -ENOENT; } static inline int try_stop_cpus(const struct cpumask *cpumask, cpu_stop_fn_t fn, void *arg) { return stop_cpus(cpumask, fn, arg); } #endif /* CONFIG_SMP */ /* * stop_machine "Bogolock": stop the entire machine, disable * interrupts. This is a very heavy lock, which is equivalent to * grabbing every spinlock (and more). So the "read" side to such a * lock is anything which disables preemption. */ #if defined(CONFIG_STOP_MACHINE) && defined(CONFIG_SMP) /** * stop_machine: freeze the machine on all CPUs and run this function * @fn: the function to run * @data: the data ptr for the @fn() * @cpus: the cpus to run the @fn() on (NULL = any online cpu) * * Description: This causes a thread to be scheduled on every cpu, * each of which disables interrupts. The result is that no one is * holding a spinlock or inside any other preempt-disabled region when * @fn() runs. * * This can be thought of as a very heavy write lock, equivalent to * grabbing every spinlock in the kernel. */ int stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus); /** * __stop_machine: freeze the machine on all CPUs and run this function * @fn: the function to run * @data: the data ptr for the @fn * @cpus: the cpus to run the @fn() on (NULL = any online cpu) * * Description: This is a special version of the above, which assumes cpus * won't come or go while it's being called. Used by hotplug cpu. */ int __stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus); int stop_machine_from_inactive_cpu(int (*fn)(void *), void *data, const struct cpumask *cpus); #else /* CONFIG_STOP_MACHINE && CONFIG_SMP */ static inline int __stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus) { unsigned long flags; int ret; local_irq_save(flags); ret = fn(data); local_irq_restore(flags); return ret; } static inline int stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus) { return __stop_machine(fn, data, cpus); } static inline int stop_machine_from_inactive_cpu(int (*fn)(void *), void *data, const struct cpumask *cpus) { return __stop_machine(fn, data, cpus); } #endif /* CONFIG_STOP_MACHINE && CONFIG_SMP */ #endif /* _LINUX_STOP_MACHINE */


context:
space:
mode: