256 lines
6.3 KiB
C
256 lines
6.3 KiB
C
#ifndef LINUX_26_31_COMPAT_H
|
|
#define LINUX_26_31_COMPAT_H
|
|
|
|
#include <linux/version.h>
|
|
|
|
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31))
|
|
|
|
#include <linux/skbuff.h>
|
|
#include <linux/workqueue.h>
|
|
#include <linux/interrupt.h>
|
|
#include <net/dst.h>
|
|
#include <net/genetlink.h>
|
|
#include <linux/ethtool.h>
|
|
#include <net/sock.h>
|
|
|
|
/*
|
|
* These macros allow us to backport rfkill without any
|
|
* changes on cfg80211 through compat.diff. Note that this
|
|
* file will be included by rfkill_backport.h so we must
|
|
* not conflict with things there.
|
|
*/
|
|
#define rfkill_get_led_trigger_name backport_rfkill_get_led_trigger_name
|
|
#define rfkill_set_led_trigger_name backport_rfkill_set_led_trigger_name
|
|
#define rfkill_set_hw_state backport_rfkill_set_hw_state
|
|
#define rfkill_set_sw_state backport_rfkill_set_sw_state
|
|
#define rfkill_init_sw_state backport_rfkill_init_sw_state
|
|
#define rfkill_set_states backport_rfkill_set_states
|
|
#define rfkill_pause_polling backport_rfkill_pause_polling
|
|
#define rfkill_resume_polling backport_rfkill_resume_polling
|
|
#define rfkill_blocked backport_rfkill_blocked
|
|
#define rfkill_alloc backport_rfkill_alloc
|
|
#define rfkill_register backport_rfkill_register
|
|
#define rfkill_unregister backport_rfkill_unregister
|
|
#define rfkill_destroy backport_rfkill_destroy
|
|
|
|
#ifndef ERFKILL
|
|
#if !defined(CONFIG_ALPHA) && !defined(CONFIG_MIPS) && !defined(CONFIG_PARISC) && !defined(CONFIG_SPARC)
|
|
#define ERFKILL 132 /* Operation not possible due to RF-kill */
|
|
#endif
|
|
#ifdef CONFIG_ALPHA
|
|
#define ERFKILL 138 /* Operation not possible due to RF-kill */
|
|
#endif
|
|
#ifdef CONFIG_MIPS
|
|
#define ERFKILL 167 /* Operation not possible due to RF-kill */
|
|
#endif
|
|
#ifdef CONFIG_PARISC
|
|
#define ERFKILL 256 /* Operation not possible due to RF-kill */
|
|
#endif
|
|
#ifdef CONFIG_SPARC
|
|
#define ERFKILL 134 /* Operation not possible due to RF-kill */
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef NETDEV_PRE_UP
|
|
#define NETDEV_PRE_UP 0x000D
|
|
#endif
|
|
|
|
#ifndef SDIO_DEVICE_ID_MARVELL_8688WLAN
|
|
#define SDIO_DEVICE_ID_MARVELL_8688WLAN 0x9104
|
|
#endif
|
|
|
|
struct compat_threaded_irq {
|
|
unsigned int irq;
|
|
irq_handler_t handler;
|
|
irq_handler_t thread_fn;
|
|
void *dev_id;
|
|
char wq_name[64];
|
|
struct workqueue_struct *wq;
|
|
struct work_struct work;
|
|
};
|
|
|
|
/*
|
|
* kmemleak was introduced on 2.6.31, since older kernels do not have
|
|
* we simply ignore its tuning.
|
|
*/
|
|
static inline void kmemleak_ignore(const void *ptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
static inline void kmemleak_not_leak(const void *ptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
static inline void kmemleak_no_scan(const void *ptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Added via adf30907d63893e4208dfe3f5c88ae12bc2f25d5
|
|
*
|
|
* There is no _sk_dst on older kernels, so just set the
|
|
* old dst to NULL and release it directly.
|
|
*/
|
|
static inline void skb_dst_drop(struct sk_buff *skb)
|
|
{
|
|
dst_release(skb->dst);
|
|
skb->dst = NULL;
|
|
}
|
|
|
|
static inline struct dst_entry *skb_dst(const struct sk_buff *skb)
|
|
{
|
|
return (struct dst_entry *)skb->dst;
|
|
}
|
|
|
|
static inline void skb_dst_set(struct sk_buff *skb, struct dst_entry *dst)
|
|
{
|
|
skb->dst = dst;
|
|
}
|
|
|
|
static inline struct rtable *skb_rtable(const struct sk_buff *skb)
|
|
{
|
|
return (struct rtable *)skb_dst(skb);
|
|
}
|
|
|
|
/* Backport threaded IRQ support */
|
|
|
|
static inline
|
|
void compat_irq_work(struct work_struct *work)
|
|
{
|
|
struct compat_threaded_irq *comp = container_of(work, struct compat_threaded_irq, work);
|
|
comp->thread_fn(comp->irq, comp->dev_id);
|
|
}
|
|
|
|
static inline
|
|
irqreturn_t compat_irq_dispatcher(int irq, void *dev_id)
|
|
{
|
|
struct compat_threaded_irq *comp = dev_id;
|
|
irqreturn_t res;
|
|
|
|
res = comp->handler(irq, comp->dev_id);
|
|
if (res == IRQ_WAKE_THREAD) {
|
|
queue_work(comp->wq, &comp->work);
|
|
res = IRQ_HANDLED;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static inline
|
|
int compat_request_threaded_irq(struct compat_threaded_irq *comp,
|
|
unsigned int irq,
|
|
irq_handler_t handler,
|
|
irq_handler_t thread_fn,
|
|
unsigned long flags,
|
|
const char *name,
|
|
void *dev_id)
|
|
{
|
|
comp->irq = irq;
|
|
comp->handler = handler;
|
|
comp->thread_fn = thread_fn;
|
|
comp->dev_id = dev_id;
|
|
INIT_WORK(&comp->work, compat_irq_work);
|
|
|
|
if (!comp->wq) {
|
|
snprintf(comp->wq_name, sizeof(comp->wq_name),
|
|
"compirq/%u-%s", irq, name);
|
|
comp->wq = create_singlethread_workqueue(comp->wq_name);
|
|
if (!comp->wq) {
|
|
printk(KERN_ERR "Failed to create compat-threaded-IRQ workqueue %s\n",
|
|
comp->wq_name);
|
|
return -ENOMEM;
|
|
}
|
|
}
|
|
return request_irq(irq, compat_irq_dispatcher, flags, name, comp);
|
|
}
|
|
|
|
static inline
|
|
void compat_free_threaded_irq(struct compat_threaded_irq *comp)
|
|
{
|
|
free_irq(comp->irq, comp);
|
|
}
|
|
|
|
static inline
|
|
void compat_destroy_threaded_irq(struct compat_threaded_irq *comp)
|
|
{
|
|
if (comp->wq)
|
|
destroy_workqueue(comp->wq);
|
|
comp->wq = NULL;
|
|
}
|
|
|
|
static inline
|
|
void compat_synchronize_threaded_irq(struct compat_threaded_irq *comp)
|
|
{
|
|
synchronize_irq(comp->irq);
|
|
cancel_work_sync(&comp->work);
|
|
}
|
|
|
|
/**
|
|
* list_entry_rcu - get the struct for this entry
|
|
* @ptr: the &struct list_head pointer.
|
|
* @type: the type of the struct this is embedded in.
|
|
* @member: the name of the list_struct within the struct.
|
|
*
|
|
* This primitive may safely run concurrently with the _rcu list-mutation
|
|
* primitives such as list_add_rcu() as long as it's guarded by rcu_read_lock().
|
|
*/
|
|
#define list_entry_rcu(ptr, type, member) \
|
|
container_of(rcu_dereference(ptr), type, member)
|
|
|
|
#define skb_walk_frags(skb, iter) \
|
|
for (iter = skb_shinfo(skb)->frag_list; iter; iter = iter->next)
|
|
|
|
#ifndef CONFIG_64BIT
|
|
|
|
typedef struct {
|
|
long long counter;
|
|
} atomic64_t;
|
|
|
|
extern long long atomic64_read(const atomic64_t *v);
|
|
extern long long atomic64_add_return(long long a, atomic64_t *v);
|
|
|
|
#define atomic64_inc_return(v) atomic64_add_return(1LL, (v))
|
|
|
|
#endif
|
|
|
|
/**
|
|
* sk_rmem_alloc_get - returns read allocations
|
|
* @sk: socket
|
|
*
|
|
* Returns sk_rmem_alloc
|
|
*/
|
|
static inline int sk_rmem_alloc_get(const struct sock *sk)
|
|
{
|
|
return atomic_read(&sk->sk_rmem_alloc);
|
|
}
|
|
|
|
/**
|
|
* sk_wmem_alloc_get - returns write allocations
|
|
* @sk: socket
|
|
*
|
|
* Returns sk_wmem_alloc minus initial offset of one
|
|
*/
|
|
static inline int sk_wmem_alloc_get(const struct sock *sk)
|
|
{
|
|
return atomic_read(&sk->sk_wmem_alloc) - 1;
|
|
}
|
|
|
|
/**
|
|
* sk_has_allocations - check if allocations are outstanding
|
|
* @sk: socket
|
|
*
|
|
* Returns true if socket has write or read allocations
|
|
*/
|
|
static inline bool sk_has_allocations(const struct sock *sk)
|
|
{
|
|
return sk_wmem_alloc_get(sk) || sk_rmem_alloc_get(sk);
|
|
}
|
|
|
|
|
|
#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)) */
|
|
|
|
#endif /* LINUX_26_31_COMPAT_H */
|