}
return -ENOENT;
}
-EXPORT_SYMBOL(__dev_addr_delete);
+EXPORT_SYMBOL_GPL(__dev_addr_delete);
/* On net/core/dev.c as of 2.6.24. This is not yet used by mac80211 but
* might as well add it */
(*count)++;
return 0;
}
-EXPORT_SYMBOL(__dev_addr_add);
+EXPORT_SYMBOL_GPL(__dev_addr_add);
/* Part of net/core/dev_mcast.c as of 2.6.23. This is a slightly different version.
return err;
}
-EXPORT_SYMBOL(dev_mc_sync);
+EXPORT_SYMBOL_GPL(dev_mc_sync);
/* Part of net/core/dev_mcast.c as of 2.6.23. This is a slighty different version.
netif_tx_unlock_bh(to);
netif_tx_unlock_bh(from);
}
-EXPORT_SYMBOL(dev_mc_unsync);
+EXPORT_SYMBOL_GPL(dev_mc_unsync);
/* Added as of 2.6.23 on net/core/dev.c. Slightly modifed, no dev->set_rx_mode on
* 2.6.22 so ignore that. */
#endif
return rc;
}
-EXPORT_SYMBOL(pci_try_set_mwi);
+EXPORT_SYMBOL_GPL(pci_try_set_mwi);
#endif
* for usage with tons of code that makes mention to it.
*/
struct net init_net;
-EXPORT_SYMBOL(init_net);
+EXPORT_SYMBOL_GPL(init_net);
/* 2.6.22 and 2.6.23 have eth_header_cache_update defined as extern in include/linux/etherdevice.h
* and actually defined in net/ethernet/eth.c but 2.6.24 exports it. Lets export it here */
memcpy(((u8 *) hh->hh_data) + HH_DATA_OFF(sizeof(struct ethhdr)),
haddr, ETH_ALEN);
}
-EXPORT_SYMBOL(eth_header_cache_update);
+EXPORT_SYMBOL_GPL(eth_header_cache_update);
/* 2.6.22 and 2.6.23 have eth_header_cache defined as extern in include/linux/etherdevice.h
* and actually defined in net/ethernet/eth.c but 2.6.24 exports it. Lets export it here */
hh->hh_len = ETH_HLEN;
return 0;
}
-EXPORT_SYMBOL(eth_header_cache);
+EXPORT_SYMBOL_GPL(eth_header_cache);
/* 2.6.22 and 2.6.23 have eth_header() defined as extern in include/linux/etherdevice.h
* and actually defined in net/ethernet/eth.c but 2.6.24 exports it. Lets export it here */
return -ETH_HLEN;
}
-EXPORT_SYMBOL(eth_header);
+EXPORT_SYMBOL_GPL(eth_header);
/* 2.6.22 and 2.6.23 have eth_rebuild_header defined as extern in include/linux/etherdevice.h
* and actually defined in net/ethernet/eth.c but 2.6.24 exports it. Lets export it here */
return 0;
}
-EXPORT_SYMBOL(eth_rebuild_header);
+EXPORT_SYMBOL_GPL(eth_rebuild_header);
define_strict_strtoux(l, unsigned long)
define_strict_strtox(l, long)
-EXPORT_SYMBOL(strict_strtoul);
-EXPORT_SYMBOL(strict_strtol);
+EXPORT_SYMBOL_GPL(strict_strtoul);
+EXPORT_SYMBOL_GPL(strict_strtol);
return !!(pme_support & (1 << state));
}
-EXPORT_SYMBOL(pci_pme_capable);
+EXPORT_SYMBOL_GPL(pci_pme_capable);
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
/**
return sz;
}
-EXPORT_SYMBOL(mmc_align_data_size);
+EXPORT_SYMBOL_GPL(mmc_align_data_size);
/*
* Calculate the maximum byte mode transfer size
return ret;
}
-EXPORT_SYMBOL(pcmcia_loop_config);
+EXPORT_SYMBOL_GPL(pcmcia_loop_config);
#endif /* CONFIG_PCMCIA */
skb->data_len += size;
skb->truesize += size;
}
-EXPORT_SYMBOL(skb_add_rx_frag);
+EXPORT_SYMBOL_GPL(skb_add_rx_frag);
void tty_write_unlock(struct tty_struct *tty)
{
return tty_mode_ioctl(tty, file, cmd, arg);
}
}
-EXPORT_SYMBOL(n_tty_ioctl_helper);
+EXPORT_SYMBOL_GPL(n_tty_ioctl_helper);
/**
* pci_wake_from_d3 - enable/disable device to wake up from D3_hot or D3_cold
pci_enable_wake(dev, PCI_D3cold, enable) :
pci_enable_wake(dev, PCI_D3hot, enable);
}
-EXPORT_SYMBOL(pci_wake_from_d3);
+EXPORT_SYMBOL_GPL(pci_wake_from_d3);
dev->select_queue = ops->ndo_select_queue;
#endif
}
-EXPORT_SYMBOL(netdev_attach_ops);
+EXPORT_SYMBOL_GPL(netdev_attach_ops);
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23))
#if defined(CONFIG_USB) || defined(CONFIG_USB_MODULE)
memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
return 0;
}
-EXPORT_SYMBOL(eth_mac_addr);
+EXPORT_SYMBOL_GPL(eth_mac_addr);
/**
* eth_change_mtu - set new MTU size
dev->mtu = new_mtu;
return 0;
}
-EXPORT_SYMBOL(eth_change_mtu);
+EXPORT_SYMBOL_GPL(eth_change_mtu);
int eth_validate_addr(struct net_device *dev)
{
return 0;
}
-EXPORT_SYMBOL(eth_validate_addr);
+EXPORT_SYMBOL_GPL(eth_validate_addr);
/* Source: net/ethernet/eth.c */
#define NETREG_DUMMY 5
result->tm_mon = y;
result->tm_mday = days + 1;
}
-EXPORT_SYMBOL(time_to_tm);
+EXPORT_SYMBOL_GPL(time_to_tm);
/* source: kernel/time/timeconv.c*/
kfree(buf);
return ret;
}
-EXPORT_SYMBOL(pccard_loop_tuple);
+EXPORT_SYMBOL_GPL(pccard_loop_tuple);
/* Source: drivers/pcmcia/cistpl.c */
#if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE)
return pccard_loop_tuple(p_dev->socket, p_dev->func, code, NULL,
&loop, pcmcia_do_loop_tuple);
}
-EXPORT_SYMBOL(pcmcia_loop_tuple);
+EXPORT_SYMBOL_GPL(pcmcia_loop_tuple);
/* Source: drivers/pcmcia/pcmcia_resource.c */
#endif /* CONFIG_PCMCIA */
return ch - 'a' + 10;
return -1;
}
-EXPORT_SYMBOL(compat_hex_to_bin);
+EXPORT_SYMBOL_GPL(compat_hex_to_bin);
/**
* noop_llseek - No Operation Performed llseek implementation
{
return file->f_pos;
}
-EXPORT_SYMBOL(noop_llseek);
+EXPORT_SYMBOL_GPL(noop_llseek);
compat_genl_unregister_family(family);
return ret;
}
-EXPORT_SYMBOL(compat_genl_register_family_with_ops);
+EXPORT_SYMBOL_GPL(compat_genl_register_family_with_ops);
int compat_genl_unregister_family(struct genl_family *family)
{
list_del(&family->list);
return err;
}
-EXPORT_SYMBOL(compat_genl_unregister_family);
+EXPORT_SYMBOL_GPL(compat_genl_unregister_family);
#if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE)
mod_timer(&led->blink_timer, jiffies + 1);
}
-EXPORT_SYMBOL(led_blink_set);
+EXPORT_SYMBOL_GPL(led_blink_set);
void compat_led_brightness_set(struct led_classdev *led_cdev,
enum led_brightness brightness)
return led_cdev->brightness_set(led_cdev, brightness);
}
-EXPORT_SYMBOL(compat_led_brightness_set);
+EXPORT_SYMBOL_GPL(compat_led_brightness_set);
void compat_led_classdev_unregister(struct led_classdev *led_cdev)
{
led_classdev_unregister(led_cdev);
}
-EXPORT_SYMBOL(compat_led_classdev_unregister);
+EXPORT_SYMBOL_GPL(compat_led_classdev_unregister);
/**
* vzalloc - allocate virtually contiguous memory with zero fill
memset(buf, 0, size);
return buf;
}
-EXPORT_SYMBOL(compat_vzalloc);
+EXPORT_SYMBOL_GPL(compat_vzalloc);
#endif
avg->weight = weight;
avg->factor = factor;
}
-EXPORT_SYMBOL(ewma_init);
+EXPORT_SYMBOL_GPL(ewma_init);
/**
* ewma_add() - Exponentially weighted moving average (EWMA)
(val * avg->factor);
return avg;
}
-EXPORT_SYMBOL(ewma_add);
+EXPORT_SYMBOL_GPL(ewma_add);
}
return 1;
}
-EXPORT_SYMBOL(mac_pton);
+EXPORT_SYMBOL_GPL(mac_pton);
#define kstrto_from_user(f, g, type) \
int f(const char __user *s, size_t count, unsigned int base, type *res) \
buf[count] = '\0'; \
return g(buf, base, res); \
} \
-EXPORT_SYMBOL(f)
+EXPORT_SYMBOL_GPL(f)
kstrto_from_user(kstrtoull_from_user, kstrtoull, unsigned long long);
kstrto_from_user(kstrtoll_from_user, kstrtoll, long long);
return r;
}
-EXPORT_SYMBOL(__netdev_printk);
+EXPORT_SYMBOL_GPL(__netdev_printk);
spin_unlock_irqrestore(&lock, flags);
return val;
}
-EXPORT_SYMBOL(atomic64_read);
+EXPORT_SYMBOL_GPL(atomic64_read);
long long atomic64_add_return(long long a, atomic64_t *v)
{
spin_unlock_irqrestore(&lock, flags);
return val;
}
-EXPORT_SYMBOL(atomic64_add_return);
+EXPORT_SYMBOL_GPL(atomic64_add_return);
#endif
fs_initcall(firmware_class_init);
module_exit(firmware_class_exit);
-EXPORT_SYMBOL(release_firmware);
-EXPORT_SYMBOL(request_firmware);
-EXPORT_SYMBOL(request_firmware_nowait);
+EXPORT_SYMBOL_GPL(release_firmware);
+EXPORT_SYMBOL_GPL(request_firmware);
+EXPORT_SYMBOL_GPL(request_firmware_nowait);
coord.q *= signx;
return coord;
}
-EXPORT_SYMBOL(cordic_calc_iq);
+EXPORT_SYMBOL_GPL(cordic_calc_iq);
MODULE_DESCRIPTION("Cordic functions");
MODULE_AUTHOR("Broadcom Corporation");
table[i+j] = table[j] ^ t;
}
}
-EXPORT_SYMBOL(crc8_populate_msb);
+EXPORT_SYMBOL_GPL(crc8_populate_msb);
/*
* crc8_populate_lsb - fill crc table for given polynomial in regular bit order.
table[i+j] = table[j] ^ t;
}
}
-EXPORT_SYMBOL(crc8_populate_lsb);
+EXPORT_SYMBOL_GPL(crc8_populate_lsb);
/*
* crc8 - calculate a crc8 over the given input data.
return crc;
}
-EXPORT_SYMBOL(crc8);
+EXPORT_SYMBOL_GPL(crc8);
MODULE_DESCRIPTION("CRC8 (by Williams, Ross N.) function");
MODULE_AUTHOR("Broadcom Corporation");
return 0;
}
-EXPORT_SYMBOL(__kfifo_alloc);
+EXPORT_SYMBOL_GPL(__kfifo_alloc);
void __kfifo_free(struct __kfifo *fifo)
{
fifo->data = NULL;
fifo->mask = 0;
}
-EXPORT_SYMBOL(__kfifo_free);
+EXPORT_SYMBOL_GPL(__kfifo_free);
int __kfifo_init(struct __kfifo *fifo, void *buffer,
unsigned int size, size_t esize)
return 0;
}
-EXPORT_SYMBOL(__kfifo_init);
+EXPORT_SYMBOL_GPL(__kfifo_init);
static void kfifo_copy_in(struct __kfifo *fifo, const void *src,
unsigned int len, unsigned int off)
fifo->in += len;
return len;
}
-EXPORT_SYMBOL(__kfifo_in);
+EXPORT_SYMBOL_GPL(__kfifo_in);
static void kfifo_copy_out(struct __kfifo *fifo, void *dst,
unsigned int len, unsigned int off)
kfifo_copy_out(fifo, buf, len, fifo->out);
return len;
}
-EXPORT_SYMBOL(__kfifo_out_peek);
+EXPORT_SYMBOL_GPL(__kfifo_out_peek);
unsigned int __kfifo_out(struct __kfifo *fifo,
void *buf, unsigned int len)
fifo->out += len;
return len;
}
-EXPORT_SYMBOL(__kfifo_out);
+EXPORT_SYMBOL_GPL(__kfifo_out);
static unsigned long kfifo_copy_from_user(struct __kfifo *fifo,
const void __user *from, unsigned int len, unsigned int off,
fifo->in += len;
return err;
}
-EXPORT_SYMBOL(__kfifo_from_user);
+EXPORT_SYMBOL_GPL(__kfifo_from_user);
static unsigned long kfifo_copy_to_user(struct __kfifo *fifo, void __user *to,
unsigned int len, unsigned int off, unsigned int *copied)
fifo->out += len;
return err;
}
-EXPORT_SYMBOL(__kfifo_to_user);
+EXPORT_SYMBOL_GPL(__kfifo_to_user);
static int setup_sgl_buf(struct scatterlist *sgl, void *buf,
int nents, unsigned int len)
return setup_sgl(fifo, sgl, nents, len, fifo->in);
}
-EXPORT_SYMBOL(__kfifo_dma_in_prepare);
+EXPORT_SYMBOL_GPL(__kfifo_dma_in_prepare);
unsigned int __kfifo_dma_out_prepare(struct __kfifo *fifo,
struct scatterlist *sgl, int nents, unsigned int len)
return setup_sgl(fifo, sgl, nents, len, fifo->out);
}
-EXPORT_SYMBOL(__kfifo_dma_out_prepare);
+EXPORT_SYMBOL_GPL(__kfifo_dma_out_prepare);
unsigned int __kfifo_max_r(unsigned int len, size_t recsize)
{
{
return __kfifo_peek_n(fifo, recsize);
}
-EXPORT_SYMBOL(__kfifo_len_r);
+EXPORT_SYMBOL_GPL(__kfifo_len_r);
unsigned int __kfifo_in_r(struct __kfifo *fifo, const void *buf,
unsigned int len, size_t recsize)
fifo->in += len + recsize;
return len;
}
-EXPORT_SYMBOL(__kfifo_in_r);
+EXPORT_SYMBOL_GPL(__kfifo_in_r);
static unsigned int kfifo_out_copy_r(struct __kfifo *fifo,
void *buf, unsigned int len, size_t recsize, unsigned int *n)
return kfifo_out_copy_r(fifo, buf, len, recsize, &n);
}
-EXPORT_SYMBOL(__kfifo_out_peek_r);
+EXPORT_SYMBOL_GPL(__kfifo_out_peek_r);
unsigned int __kfifo_out_r(struct __kfifo *fifo, void *buf,
unsigned int len, size_t recsize)
fifo->out += n + recsize;
return len;
}
-EXPORT_SYMBOL(__kfifo_out_r);
+EXPORT_SYMBOL_GPL(__kfifo_out_r);
void __kfifo_skip_r(struct __kfifo *fifo, size_t recsize)
{
n = __kfifo_peek_n(fifo, recsize);
fifo->out += n + recsize;
}
-EXPORT_SYMBOL(__kfifo_skip_r);
+EXPORT_SYMBOL_GPL(__kfifo_skip_r);
int __kfifo_from_user_r(struct __kfifo *fifo, const void __user *from,
unsigned long len, unsigned int *copied, size_t recsize)
fifo->in += len + recsize;
return 0;
}
-EXPORT_SYMBOL(__kfifo_from_user_r);
+EXPORT_SYMBOL_GPL(__kfifo_from_user_r);
int __kfifo_to_user_r(struct __kfifo *fifo, void __user *to,
unsigned long len, unsigned int *copied, size_t recsize)
fifo->out += n + recsize;
return 0;
}
-EXPORT_SYMBOL(__kfifo_to_user_r);
+EXPORT_SYMBOL_GPL(__kfifo_to_user_r);
unsigned int __kfifo_dma_in_prepare_r(struct __kfifo *fifo,
struct scatterlist *sgl, int nents, unsigned int len, size_t recsize)
return setup_sgl(fifo, sgl, nents, len, fifo->in + recsize);
}
-EXPORT_SYMBOL(__kfifo_dma_in_prepare_r);
+EXPORT_SYMBOL_GPL(__kfifo_dma_in_prepare_r);
void __kfifo_dma_in_finish_r(struct __kfifo *fifo,
unsigned int len, size_t recsize)
__kfifo_poke_n(fifo, len, recsize);
fifo->in += len + recsize;
}
-EXPORT_SYMBOL(__kfifo_dma_in_finish_r);
+EXPORT_SYMBOL_GPL(__kfifo_dma_in_finish_r);
unsigned int __kfifo_dma_out_prepare_r(struct __kfifo *fifo,
struct scatterlist *sgl, int nents, unsigned int len, size_t recsize)
return setup_sgl(fifo, sgl, nents, len, fifo->out + recsize);
}
-EXPORT_SYMBOL(__kfifo_dma_out_prepare_r);
+EXPORT_SYMBOL_GPL(__kfifo_dma_out_prepare_r);
void __kfifo_dma_out_finish_r(struct __kfifo *fifo, size_t recsize)
{
len = __kfifo_peek_n(fifo, recsize);
fifo->out += len + recsize;
}
-EXPORT_SYMBOL(__kfifo_dma_out_finish_r);
+EXPORT_SYMBOL_GPL(__kfifo_dma_out_finish_r);
s++;
return _kstrtoull(s, base, res);
}
-EXPORT_SYMBOL(kstrtoull);
+EXPORT_SYMBOL_GPL(kstrtoull);
int kstrtoll(const char *s, unsigned int base, long long *res)
{
}
return 0;
}
-EXPORT_SYMBOL(kstrtoll);
+EXPORT_SYMBOL_GPL(kstrtoll);
/* Internal, do not use. */
int _kstrtoul(const char *s, unsigned int base, unsigned long *res)
*res = tmp;
return 0;
}
-EXPORT_SYMBOL(_kstrtoul);
+EXPORT_SYMBOL_GPL(_kstrtoul);
/* Internal, do not use. */
int _kstrtol(const char *s, unsigned int base, long *res)
*res = tmp;
return 0;
}
-EXPORT_SYMBOL(_kstrtol);
+EXPORT_SYMBOL_GPL(_kstrtol);
int kstrtouint(const char *s, unsigned int base, unsigned int *res)
{
*res = tmp;
return 0;
}
-EXPORT_SYMBOL(kstrtouint);
+EXPORT_SYMBOL_GPL(kstrtouint);
int kstrtoint(const char *s, unsigned int base, int *res)
{
*res = tmp;
return 0;
}
-EXPORT_SYMBOL(kstrtoint);
+EXPORT_SYMBOL_GPL(kstrtoint);
int kstrtou16(const char *s, unsigned int base, u16 *res)
{
*res = tmp;
return 0;
}
-EXPORT_SYMBOL(kstrtou16);
+EXPORT_SYMBOL_GPL(kstrtou16);
int kstrtos16(const char *s, unsigned int base, s16 *res)
{
*res = tmp;
return 0;
}
-EXPORT_SYMBOL(kstrtos16);
+EXPORT_SYMBOL_GPL(kstrtos16);
int kstrtou8(const char *s, unsigned int base, u8 *res)
{
*res = tmp;
return 0;
}
-EXPORT_SYMBOL(kstrtou8);
+EXPORT_SYMBOL_GPL(kstrtou8);
int kstrtos8(const char *s, unsigned int base, s8 *res)
{
*res = tmp;
return 0;
}
-EXPORT_SYMBOL(kstrtos8);
+EXPORT_SYMBOL_GPL(kstrtos8);
#endif /* #ifndef strict_strtol */
projects / ~emulex / for-vlad / compat.git / commitdiff