int init_module(void)
{
srq = rt_request_srq(0xcacca, rtai_srq_handler, user_srq_handler);
init_timer(&timer);
timer.function = rt_timer_handler;
mod_timer(&timer, (HZ/TIMER_FREQ));
return 0 ;
}
/***
* rtskb_pool_init
*/
int rtskb_pool_init(void)
{
unsigned int i;
int err = 0;
struct rtskb* skb;
rtskb_queue_head_init(&rtskb_pool);
rtskb_cache = kmem_cache_create
(RTSKB_CACHE, sizeof (struct rtskb), 0, SLAB_HWCACHE_ALIGN, NULL, NULL);
if ( !rtskb_cache ) {
rt_printk("RTnet: allocating 'rtskb_cache' failed.");
return -ENOMEM;
}
rtskb_data_cache = kmem_cache_create
(RTSKB_DATA_CACHE, SKB_DATA_ALIGN(rtskb_max_size), 0, SLAB_HWCACHE_ALIGN, NULL, NULL);
if ( !rtskb_data_cache ) {
rt_printk("RTnet: allocating 'rtskb_data_cache' failed.");
return -ENOMEM;
}
for (i=0; i<rtskb_pool_default; i++) {
skb = new_rtskb(); /* might return NULL */
if (skb) {
__rtskb_queue_tail(&rtskb_pool, skb);
} else {
printk("%s(): new_rtskb() returned NULL, qlen=%d\n", __FUNCTION__, rtskb_pool.qlen);
break;
}
}
if ( (inc_pool_srq=rt_request_srq (0, inc_pool_handler, 0)) < 0) {
rt_printk("RTnet: allocating 'inc_pool_srq=%d' failed.\n", inc_pool_srq);
return inc_pool_srq;
}
if ( (dec_pool_srq=rt_request_srq (0, dec_pool_handler, 0)) < 0) {
rt_printk("RTnet: allocating 'dec_pool_srq=%d' failed.\n", dec_pool_srq);
return dec_pool_srq;
}
return err;
}
int init_module(void)
{
#ifdef CONFIG_X86_LOCAL_APIC
params.mp = 1;
#endif /* CONFIG_X86_LOCAL_APIC */
params.freq_apic = RTAI_FREQ_APIC;
params.cpu_freq = RTAI_CPU_FREQ;
rtf_create(0, FIFOBUFSIZE);
if ((srq = rt_request_srq(CALSRQ, (void *)user_srq, user_srq)) < 0) {
printk("No sysrq available for the calibration.\n");
return srq;
}
return 0;
}
/* ************************************************************************
* ************************************************************************
* I N I T
* ************************************************************************
* ************************************************************************ */
static int __init rtnetproxy_init_module(void)
{
int err;
dev_rtnetproxy.init = rtnetproxy_init;
SET_MODULE_OWNER(&dev_rtnetproxy);
/* Define the name for this unit */
err=dev_alloc_name(&dev_rtnetproxy,"rtproxy");
if(err<0)
return err;
err = register_netdev(&dev_rtnetproxy);
if (err<0)
return err;
/* Initialize the ringbuffers: */
memset(&ring_rtskb_kernel_rtnet, 0, sizeof(ring_rtskb_kernel_rtnet));
memset(&ring_rtskb_rtnet_kernel, 0, sizeof(ring_rtskb_rtnet_kernel));
memset(&ring_skb_kernel_rtnet, 0, sizeof(ring_skb_kernel_rtnet));
memset(&ring_skb_rtnet_kernel, 0, sizeof(ring_skb_rtnet_kernel));
/* Init the task for transmission */
rt_task_init(&rtnetproxy_thread, rtnetproxy_transmit_thread, 0, 2000,
RT_LOWEST_PRIORITY, 0, 0);
/* Register srq */
rtnetproxy_srq = rt_request_srq(0, rtnetproxy_rtai_srq, 0);
/* rtNet stuff: */
rt_ip_register_fallback(rtnetproxy_recv);
printk("rtnetproxy installed as \"%s\"\n", dev_rtnetproxy.name);
return 0;
}
//---------------------------------------------------------------------------
int init_module (void) {
//---------------------------------------------------------------------------
int err,inst;
struct nas_priv *priv;
char devicename[100];
// Initialize parameters shared with RRC
printk("Starting NASMESH, number of IMEI paramters %d, IMEI %X%X\n",m_arg,nas_IMEI[0],nas_IMEI[1]);
#ifndef NAS_NETLINK
#ifdef RTAI //with RTAI you have to indicate which irq# you want
pdcp_2_nas_irq=rt_request_srq(0, nas_interrupt, NULL);
#endif
if (pdcp_2_nas_irq == -EBUSY || pdcp_2_nas_irq == -EINVAL){
printk("[NAS][INIT] No interrupt resource available\n");
return -EBUSY;
}
else
printk("[NAS][INIT]: Interrupt %d\n", pdcp_2_nas_irq);
//rt_startup_irq(RTAI_IRQ);
//rt_enable_irq(RTAI_IRQ);
#endif //NETLINK
for (inst=0;inst<NB_INSTANCES_MAX;inst++) {
printk("[NAS][INIT] nasmesh_init_module: begin init instance %d\n",inst);
sprintf(devicename,"oai%d",inst);
nasdev[inst] = alloc_netdev(sizeof(struct nas_priv),devicename, nas_init);
priv = netdev_priv(nasdev[inst]);
if (nasdev[inst]){
nas_mesh_init(inst);
//memcpy(nasdev[inst]->dev_addr,&nas_IMEI[0],8);
nas_TOOL_imei2iid(nas_IMEI, nasdev[inst]->dev_addr);// IMEI to device address (for stateless autoconfiguration address)
nas_TOOL_imei2iid(nas_IMEI, (u8 *)priv->cx[0].iid6);
// TO HAVE DIFFERENT HW @
((unsigned char*)nasdev[inst]->dev_addr)[7] = ((unsigned char*)nasdev[inst]->dev_addr)[7] + (unsigned char)inst + 1;
printk("Setting HW addr for INST %d to : %X%X\n",inst,*((unsigned int *)&nasdev[inst]->dev_addr[0]),*((unsigned int *)&nasdev[inst]->dev_addr[4]));
}
err= register_netdev(nasdev[inst]);
if (err){
printk("[NAS][INIT] nasmesh_init_module (inst %d): error %i registering device %s\n", inst,err, nasdev[inst]->name);
}else{
printk("nasmesh_init_module: registering device %s, ifindex = %d\n\n",nasdev[inst]->name, nasdev[inst]->ifindex);
}
}
#ifdef NAS_NETLINK
if ((err=nas_netlink_init()) == -1)
printk("[NAS][INIT] NETLINK failed\n");
printk("[NAS][INIT] NETLINK INIT\n");
#endif //NETLINK
return err;
}
//---------------------------------------------------------------------------
int init_module (void)
{
//---------------------------------------------------------------------------
int err;
int inst = 0;
int index;
struct nas_priv *priv;
char devicename[100];
printk("\n\n\ninit_module: begin \n");
// check IMEI parameter
printk("number of IMEI parameters %d, IMEI ", m_arg);
for (index = 0; index < m_arg; index++) {
printk("%02X ", nas_IMEI[index]);
}
printk("\n");
#ifndef PDCP_USE_NETLINK
// Initialize parameters shared with RRC (done first to avoid going further)
if (pt_nas_ue_irq==NULL) {
printk("init_module: shared irq parameter not initialised\n");
err = -EBUSY;
printk("init_module: returning %d \n\n", err);
return err;
}
printk("init_module: pt_nas_ue_irq valid \n");
#endif
// Allocate device structure
sprintf(devicename,"oai%d",inst);
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 17, 0)
gdev = alloc_netdev(sizeof(struct nas_priv), devicename, nasmt_init);
#else
gdev = alloc_netdev(sizeof(struct nas_priv), devicename, NET_NAME_PREDICTABLE, nasmt_init);
#endif
priv = netdev_priv(gdev);
////
#ifndef PDCP_USE_NETLINK
priv->irq=rt_request_srq(0, nasmt_interrupt, NULL);
if (priv->irq == -EBUSY || priv->irq == -EINVAL) {
printk("\n init_module: No interrupt resource available\n");
if (gdev) {
free_netdev(gdev);
printk("init_module: free_netdev ..\n");
}
return -EBUSY;
} else
printk("init_module: Interrupt %d, ret = %d \n", priv->irq , ret);
if (pt_nas_ue_irq==NULL) {
printk("init_module: shared irq parameter has been reset\n");
} else {
*pt_nas_ue_irq=priv->irq;
}
#endif
#ifdef PDCP_USE_NETLINK
if ((err=nasmt_netlink_init()) == -1)
printk("init_module: NETLINK failed\n");
printk("init_module: NETLINK INIT successful\n");
#endif //NETLINK
//
err= register_netdev(gdev);
if (err) {
printk("init_module: error %i registering device %s\n", err, gdev->name);
} else {
printk("init_module: registering device %s, ifindex = %d\n\n",gdev->name, gdev->ifindex);
}
return err;
}
//---------------------------------------------------------------------------
int init_module (void)
{
//---------------------------------------------------------------------------
int err;
int inst = 0;
struct nas_priv *priv;
char devicename[100];
printk("\n\n\n\nnasrg_init_module: begin \n");
// Initialize parameters shared with RRC
#ifndef PDCP_USE_NETLINK
if (pt_nas_rg_irq==NULL) {
printk("nasrg_init_module: shared irq parameter not initialised\n");
err = -EBUSY;
printk("nasrg_init_module: returning %d \n\n", err);
return err;
}
printk("nasrg_init_module: pt_nas_rg_irq valid \n");
#endif
/*
if (pt_rg_own_cell_id==NULL){
printk("nasrg_init_module: shared cell_id parameter not initialised\n");
err = -EBUSY;
printk("nasrg_init_module: returning %d \n\n\n", err);
return err;
}
printk("nasrg_init_module: pt_rg_own_cell_id valid \n");
*pt_rg_own_cell_id = NASRG_OWN_CELLID;
*/
local_rg_cell_id = NASRG_OWN_CELLID;
// Allocate device structure
sprintf(devicename,"oai%d",inst);
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 17, 0)
gdev = alloc_netdev(sizeof(struct nas_priv), devicename, nasrg_init);
#else
gdev = alloc_netdev(sizeof(struct nas_priv), devicename, NET_NAME_PREDICTABLE, nasrg_init);
#endif
printk("nasrg_init_module: after alloc_netdev \n");
priv = netdev_priv(gdev);
////
//
#ifndef PDCP_USE_NETLINK
priv->irq=rt_request_srq(0, nasrg_interrupt, NULL);
if (priv->irq == -EBUSY || priv->irq == -EINVAL) {
printk("nasrg_init_module: No interrupt resource available\n");
if (gdev) {
free_netdev(gdev);
printk("nasrg_init_module: free_netdev ..\n");
}
return -EBUSY;
} else
printk("nasrg_init_module: Interrupt %d, ret = %d \n", priv->irq , ret);
if (pt_nas_rg_irq==NULL) {
printk("nasmt_init_module: shared irq parameter has been reset\n");
} else {
*pt_nas_rg_irq=priv->irq;
}
#endif
//
//////
#ifdef PDCP_USE_NETLINK
if ((err=nasrg_netlink_init()) < 0)
printk("nasrg_init_module: NETLINK failed\n");
printk("nasrg_init_module: NETLINK INIT successful\n");
#endif //NETLINK
err= register_netdev(gdev);
if (err) {
printk("nasrg_init_module: error %i registering device %s\n", err, gdev->name);
} else {
printk("nasrg_init_module: registering device %s, ifindex = %d\n\n",gdev->name, gdev->ifindex);
}
return err;
}
