static int __init llc_init(void)
{
	if (dev_base->next)
		memcpy(llc_station_mac_sa, dev_base->next->dev_addr, ETH_ALEN);
	else
		memset(llc_station_mac_sa, 0, ETH_ALEN);
	dev_add_pack(&llc_packet_type);
	dev_add_pack(&llc_tr_packet_type);
	return 0;
}

static int __init llc_init(void)
{
	struct net_device *dev;

	dev = first_net_device(&init_net);
	if (dev != NULL)
		dev = next_net_device(dev);

	dev_add_pack(&llc_packet_type);
	dev_add_pack(&llc_tr_packet_type);
	return 0;
}

/*
 * Function irda_init (void)
 *
 *  Protocol stack initialisation entry point.
 *  Initialise the various components of the IrDA stack
 */
int __init irda_init(void)
{
	IRDA_DEBUG(0, "%s()\n", __FUNCTION__);

	/* Lower layer of the stack */
 	irlmp_init();
	irlap_init();
	
	/* Higher layers of the stack */
	iriap_init();
 	irttp_init();
	irsock_init();
	
	/* Add IrDA packet type (Start receiving packets) */
        dev_add_pack(&irda_packet_type);

	/* External APIs */
#ifdef CONFIG_PROC_FS
	irda_proc_register();
#endif
#ifdef CONFIG_SYSCTL
	irda_sysctl_register();
#endif

	/* Driver/dongle support */
 	irda_device_init();

	return 0;
}

/************************************************************
 * Module init procedure.
 ************************************************************/
static int __init goose_init(void)
{	
	printk("--------------------------------------\n");
	printk("GOOSE: Stand by.\n");

	printk("GOOSE: initiating proc file systems.\n");
	if (proc_fs_init() != 0) {
		printk("GOOSE: Fatal error in initializing proc_fs!\n");
		return -1;
	}
	
	printk("GOOSE: initiating netlink interface.\n");
	if (netlink_init() != 0) {
		printk("GOOSE: Fatal error in initializing netlink!\n");
		return -1;
	}

	/* initialize default dev*/
	def_dev = dev_get_by_name(&init_net, buf_proc_def_dev);
	
	if (def_dev == NULL) {
		printk("GOOSE: Can not find %s, choose another device.\n", buf_proc_def_dev);
	}

	/* register GOOSE protocol */
	dev_add_pack(&goose_packet_type);
	
	/* kernel_thread(daemon, NULL, 0); */

	return 0;
}

/* @brief HIF GMAC init module */
int
os_gmac_init(void)
{
    hif_gmac_softc_t  *sc;

    init_wlan();
    
    sc = __gmac_pkt.af_packet_priv  = hif_gmac_init();
    
    sc->attach          = __gmac_defer_attach;
    sc->detach          = __gmac_detach;
    sc->discv  = __gmac_dev_discv;

    dev_add_pack(&__gmac_pkt);

    fwd_module_init();

    MpHtcInit();

    if (ath_create_htc_thread(NULL) != 0)
        printk(KERN_ERR "%s: create thread fail\n", __func__);

    /* register_netdevice_notifier(&__gmac_notifier); */

    return 0;
}

/**
 * setup_bearer - setup association between InfiniBand bearer and interface
 */
static void setup_bearer(struct work_struct *work)
{
    struct ib_bearer *ib_ptr =
        container_of(work, struct ib_bearer, setup);

    dev_add_pack(&ib_ptr->tipc_packet_type);
}

/* Module registration */
static int __init phonet_init(void)
{
    int err;

    err = phonet_device_init();
    if (err)
        return err;

    err = sock_register(&phonet_proto_family);
    if (err) {
        printk(KERN_ALERT
               "phonet protocol family initialization failed\n");
        goto err_sock;
    }

    dev_add_pack(&phonet_packet_type);
    phonet_sysctl_init();

    err = isi_register();
    if (err)
        goto err;
    return 0;

err:
    phonet_sysctl_exit();
    sock_unregister(PF_PHONET);
    dev_remove_pack(&phonet_packet_type);
err_sock:
    phonet_device_exit();
    return err;
}

static int __init llc_init(void)
{
	struct net_device *dev;

	dev = first_net_device(&init_net);
	if (dev != NULL)
		dev = next_net_device(dev);

	if (dev != NULL)
		memcpy(llc_station_mac_sa, dev->dev_addr, ETH_ALEN);
	else
		memset(llc_station_mac_sa, 0, ETH_ALEN);
	dev_add_pack(&llc_packet_type);
	dev_add_pack(&llc_tr_packet_type);
	return 0;
}

/*
 * Function vlan_proto_init (pro)
 *
 *    Initialize VLAN protocol layer, 
 *
 */
static int __init vlan_proto_init(void)
{
	int err;

	printk(VLAN_INF "%s v%u.%u %s\n",
	       vlan_fullname, vlan_version, vlan_release, vlan_copyright);
	printk(VLAN_INF "Other stuff added by %s\n",
	       vlan_buggyright);

	/* proc file system initialization */
	err = vlan_proc_init();
	if (err < 0) {
		printk(KERN_ERR 
		       "%s %s: can't create entry in proc filesystem!\n",
		       __FUNCTION__, VLAN_NAME);
		return 1;
	}

	dev_add_pack(&vlan_packet_type);

	/* Register us to receive netdevice events */
	register_netdevice_notifier(&vlan_notifier_block);

	vlan_ioctl_hook = vlan_ioctl_handler;

	return 0;
}

static int __init af_ieee802154_init(void)
{
	int rc = -EINVAL;

	rc = proto_register(&ieee802154_raw_prot, 1);
	if (rc)
		goto out;

	rc = proto_register(&ieee802154_dgram_prot, 1);
	if (rc)
		goto err_dgram;

	/* Tell SOCKET that we are alive */
	rc = sock_register(&ieee802154_family_ops);
	if (rc)
		goto err_sock;
	dev_add_pack(&ieee802154_packet_type);

	rc = 0;
	goto out;

err_sock:
	proto_unregister(&ieee802154_dgram_prot);
err_dgram:
	proto_unregister(&ieee802154_raw_prot);
out:
	return rc;
}

/*
 * Function vlan_proto_init (pro)
 *
 *    Initialize VLAN protocol layer,
 *
 */
static int __init vlan_proto_init(void)
{
	int err;

	printk(VLAN_INF "%s v%s\n",
	       vlan_fullname, vlan_version);

	/* proc file system initialization */
	err = vlan_proc_init();
	if (err < 0) {
		printk(KERN_ERR
		       "%s: can't create entry in proc filesystem!\n",
		       __FUNCTION__);
		return err;
	}

	dev_add_pack(&vlan_packet_type);

	/* Register us to receive netdevice events */
	err = register_netdevice_notifier(&vlan_notifier_block);
	if (err < 0) {
		dev_remove_pack(&vlan_packet_type);
		vlan_proc_cleanup();
		return err;
	}

	vlan_ioctl_set(vlan_ioctl_handler);

	return 0;
}

void disable_tarp(void)
{      
   dev_add_pack(arp_packet_type);
         
   printk(KERN_INFO "[arpsec_mod] disabled\n");
   printk(KERN_INFO "[arpsec_mod] kernel can now receive \"classic\" "\
                          "ARP packets\n");
}

//Initialize the module
static int __init vrr_init(void)
{
	/* 1. Initialize an empty routing table
	   2. create empty pset (tree/CLL?)
	   3. create empty vset (tree/CLL?)
	   4. create vrr_node structure
	   5. Initialize sysfs hooks ??
	   6. Build hello packet and send to establish a proxy 
	   7. There is probably alot more than this */

	int err;
	unsigned long tdelay;

	WARN_ATOMIC;

	VRR_INFO("Begin init");

	vrr_node_init();
	vrr_data_init();
	pset_state_init();
	vrr_init_rcv();

	err = proto_register(&vrr_proto, 1);
	if (err) {
		goto out;
	}

	/* Initialize routing/sysfs stuff here */
	/* TODO: Split these into separate functions */
	vrr_obj = kobject_create_and_add("vrr", kernel_kobj);
	if (!vrr_obj) {
		err = -ENOMEM;
		goto out;
	}

	err = sysfs_create_group(vrr_obj, &attr_group);
	if (err) {
		kobject_put(vrr_obj);
	}
	/* --- */

	/* Register our sockets protocol handler */
	err = sock_register(&vrr_family_ops);
	if (err) {
		goto out;
	}

	dev_add_pack(&vrr_packet_type);

	//start hello packet timer
	tdelay = jiffies + (VRR_HPKT_DELAY * HZ / 1000);
	mod_timer(&vrr_timer, tdelay);

	VRR_INFO("End init");

 out:
	return err;
}

int tipc_bearer_setup(void)
{
	int err;

	err = register_netdevice_notifier(&notifier);
	if (err)
		return err;
	dev_add_pack(&tipc_packet_type);
	return 0;
}

static int __init ztdeth_init(void)
{
	skb_queue_head_init(&skbs);

	dev_add_pack(&ztdeth_ptype);
	register_netdevice_notifier(&ztdeth_nblock);
	dahdi_dynamic_register_driver(&ztd_eth);

	return 0;
}

/******************************************************************************
 ** Function name:DyS_dist_mac_net_device_open
 ** Descriptions:called when we use ifconfig up
 ** Input: 
 ** Output: 
 ** Returns: 
 ** Created by: 
 ** Created Date:2010/07/07 
 **-------------------------------------- --------------------
 ** Modified by:
 ** Modified Date: 
 ******************************************************************************/
int fsm_dev_open(struct net_device *dev)
{
    /*-----------------now we need to register the special protocol_type */
	fsm_core_intf_set(STRM_TO_MAC, DEV_INTF_IND, DEV_PROTO_MAC, "LTE_MAC0");
	fsm_core_intf_set(STRM_TO_ETH, DEV_INTF_REQ, DEV_PROTO_SRIO, "eth0");
    dev_add_pack(&pk_t); 
	netif_start_queue(dev);   
    fsm_core_open();	 
    return 0;    
}

/******************************************************************************
 ** Function name:DyS_dist_mac_net_device_open
 ** Descriptions:called when we use ifconfig up
 ** Input: 
 ** Output: 
 ** Returns: 
 ** Created by: 
 ** Created Date:2010/07/07 
 **-------------------------------------- --------------------
 ** Modified by:
 ** Modified Date: 
 ******************************************************************************/
int fsm_dev_open(struct net_device *dev)
{		
    /*-----------------now we need to register the special protocol_type */
	fsm_core_intf_set(STRM_TO_IP, DEV_INTF_IND, DEV_PROTO_IP, NULL);	
	fsm_core_intf_set(STRM_TO_PDCP, DEV_INTF_REQ, DEV_PROTO_IPADP, "LTE_PDCP0");
	//fsm_core_intf_set(STRM_TO_RLC, DEV_INTF_REQ, DEV_PROTO_IPADP, "LTE_RLC0");
	fsm_core_intf_set(STRM_TO_MAC, DEV_INTF_REQ, DEV_PROTO_IPADP, "LTE_MAC0");
    	dev_add_pack(&pk_t); 
	netif_start_queue(dev);   
    	fsm_core_open();	 
    	return 0;    
}

void mpls_enable(void)
{
	if( !mpls_forward_on )
	{
		dev_add_pack(&mpls_uc_ptype);
		mpls_forward_on = 1 ;
	}

	if (SWITCHOVER_MAIN_BOARD)
	{
		MPLS_NOTIFY_SEND(enable);
	}
}

// sniff device open function
int sniff_open(struct inode *i, struct file *f){

	printk("Opening IPSniff device\n");

	dev_add_pack(&sniff_hook);
	
	if((rules=(filter_t *)kmalloc(sizeof(filter_t)*10,GFP_KERNEL))==NULL){
		printk("Unable to allocate mem to filter\n");
		return -1;
	}
//	MOD_INC_USE_COUNT;
	return 0;
}

/* Pre IP Protocol Init */
int __init preIP_Init(void)
{
#ifdef PRE_IP_DEBUG
    printk("preIP_Init: in\n");
#endif
    preip_nlfd = netlink_kernel_create(&init_net, NETLINK_PREIP,1, nl_preip_receive, NULL, THIS_MODULE);
    if (preip_nlfd == NULL) {
        printk("%s: failed to create netlink socket\n",__func__);
        return -EBUSY;
    }
    dev_add_pack(&preIP_packet_type);
	
    return 0;
}