M7350/external/compat-wireless/include/linux/compat-2.6.31.h
2024-09-09 08:52:07 +00:00

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 */