include/qtn/qtn_vlan.h - kernel/skids - Git at Google

 /*
  * Copyright (c) 2014 Quantenna Communications, Inc.
  * All rights reserved.
  */

 #ifndef _QTN_VLAN_H_
 #define _QTN_VLAN_H_

 #include "../common/ruby_mem.h"
 #include <qtn/qtn_debug.h>
 #include <qtn/qtn_uc_comm.h>
 #include <qtn/qtn_net_packet.h>
 #if defined(__KERNEL__) || defined(MUC_BUILD) || defined(AUC_BUILD)
 #include <qtn/topaz_tqe_cpuif.h>
 #endif
 #if defined(__KERNEL__)
 #include <qtn/dmautil.h>
 #endif

 #define QVLAN_MODE_ACCESS		0
 #define QVLAN_MODE_TRUNK		1
 #define QVLAN_MODE_HYBRID		2
 #define QVLAN_MODE_DYNAMIC		3
 #define QVLAN_MODE_MAX			QVLAN_MODE_DYNAMIC
 #define QVLAN_SHIFT_MODE		16
 #define QVLAN_MASK_MODE			0xffff0000
 #define QVLAN_MASK_VID			0x00000fff

 #define QVLAN_MODE(x)			(uint16_t)((x) >> QVLAN_SHIFT_MODE)
 #define QVLAN_VID(x)			(uint16_t)((x) & QVLAN_MASK_VID)

 #define QVLAN_MODE_STR_ACCESS	"Access mode"
 #define QVLAN_MODE_STR_TRUNK	"Trunk mode"
 #define QVLAN_MODE_STR_HYBRID	"Hybrid mode"
 #define QVLAN_MODE_STR_DYNAMIC	"Dynamic mode"

 /* default port vlan id */
 #define QVLAN_DEF_PVID			1

 #define QVLAN_VID_MAX			4096
 #define QVLAN_VID_MAX_S			12
 #define QVLAN_VID_ALL			0xffff

 #ifndef NBBY
 #define NBBY		8
 #endif

 #ifndef NBDW
 #define NBDW		32
 #endif

 #ifdef CONFIG_TOPAZ_DBDC_HOST
 #define VLAN_INTERFACE_MAX	(QTN_MAX_VAPS + 2 + MAX_QFP_NETDEV)
 #define QFP_VDEV_IDX(dev_id)	(QTN_MAX_VAPS + 2 + (dev_id))
 #else
 #define VLAN_INTERFACE_MAX	(QTN_MAX_VAPS + 2)
 #endif
 #define WMAC_VDEV_IDX_MAX	QTN_MAX_VAPS
 #define EMAC_VDEV_IDX(port)	(QTN_MAX_VAPS + (port))
 #define PCIE_VDEV_IDX		(QTN_MAX_VAPS + 0)

 #ifndef howmany
 #define howmany(x, y)			(((x) + ((y) - 1)) / (y))
 #endif

 #define bitsz_var(var)			(sizeof(var) * 8)
 #define bitsz_ptr(ptr)			bitsz_var((ptr)[0])

 #define set_bit_a(a, i)			((a)[(i) / bitsz_ptr(a)] |= 1 << ((i) % bitsz_ptr(a)))
 #define clr_bit_a(a, i)			((a)[(i) / bitsz_ptr(a)] &= ~(1 << ((i) % bitsz_ptr(a))))
 #define is_set_a(a, i)			((a)[(i) / bitsz_ptr(a)] & (1 << ((i) % bitsz_ptr(a))))
 #define is_clr_a(a, i)			(is_set_a(a, i) == 0)

 struct qtn_vlan_stats {
 	uint32_t lhost;
 	uint32_t auc;
 	uint32_t muc;
 };

 struct qtn_vlan_user_interface {
 	unsigned long bus_addr;
 	uint8_t mode;
 };

 struct qtn_vlan_dev {
 	uint8_t		idx;
 	uint8_t		port;
 	uint16_t	pvid;
 #define QVLAN_DEV_F_DYNAMIC	BIT(0)
 	uint32_t	flags;
 	unsigned long	bus_addr;
 	int		ifindex;
 	union {
 		uint32_t	member_bitmap[howmany(QVLAN_VID_MAX, NBDW)];
 		uint16_t	node_vlan[QTN_NCIDX_MAX];
 	}u;
 	uint32_t	tag_bitmap[howmany(QVLAN_VID_MAX, NBDW)];
 	struct qtn_vlan_stats ig_pass;
 	struct qtn_vlan_stats ig_drop;
 	struct qtn_vlan_stats eg_pass;
 	struct qtn_vlan_stats eg_drop;
 	void		*user_data;
 };
 #define QVLAN_IS_DYNAMIC(vdev)		((vdev)->flags & QVLAN_DEV_F_DYNAMIC)

 struct qtn_vlan_pkt {
 #define QVLAN_PKT_MAGIC			0x1234
 	uint16_t	magic;
 #define QVLAN_TAGGED			0x8000
 #define QVLAN_SKIP_CHECK		0x4000
 	uint16_t	vlan_info;
 } __packed;

 #define QVLAN_PKTCTRL_LEN	sizeof(struct qtn_vlan_pkt)

 struct qtn_vlan_info {
 #define QVLAN_TAGRX_UNTOUCH		0
 #define QVLAN_TAGRX_STRIP		1
 #define QVLAN_TAGRX_TAG			2
 #define QVLAN_TAGRX_BITMASK		0x3
 #define QVLAN_TAGRX_BITWIDTH		2
 #define QVLAN_TAGRX_BITSHIFT		1
 #define QVLAN_TAGRX_NUM_PER_DW		(32 / QVLAN_TAGRX_BITWIDTH)
 #define QVLAN_TAGRX_NUM_PER_DW_S	4
 	uint32_t vlan_tagrx_bitmap[howmany(QVLAN_VID_MAX * QVLAN_TAGRX_BITWIDTH, NBDW)];
 };

 RUBY_INLINE int qvlan_tagrx_index(int vid)
 {
 	return (vid >> QVLAN_TAGRX_NUM_PER_DW_S);
 }

 RUBY_INLINE int qvlan_tagrx_shift(int vid)
 {
 	int shift;

 	shift = vid & (QVLAN_TAGRX_NUM_PER_DW - 1);
 	return (shift << QVLAN_TAGRX_BITSHIFT);
 }

 struct qtn_vlan_config {
 	uint32_t	vlan_cfg;
 	union {
 		struct vlan_dev_config {
 			uint32_t	member_bitmap[howmany(QVLAN_VID_MAX, NBDW)];
 			uint32_t	tag_bitmap[howmany(QVLAN_VID_MAX, NBDW)];
 		} dev_config;
 		uint32_t	tagrx_config[howmany(QVLAN_VID_MAX * QVLAN_TAGRX_BITWIDTH, NBDW)];
 	} u;
 };

 /*
 * VLAN forward/drop table
 *|	traffic direction	|  frame	|  Access(MBSS/Dynamic mode)	  | Trunk(Passthrough mode)
 *|--------------------------------------------------------------------------------------------------------------
 *|	wifi tx			|  no vlan	|  drop				  | forward
 *|--------------------------------------------------------------------------------------------------------------
 *|				|  vlan tagged	| compare tag with PVID:	  | compare tag against VID list
 *|				|		| 1.equal:untag and forward	  | 1.Found:forward
 *|				|		| 2.not equal:drop		  | 2.Not found:drop
 *|--------------------------------------------------------------------------------------------------------------
 *|	wifi rx			|  no vlan	| Add PVID tag and forward	  | forward
 *|--------------------------------------------------------------------------------------------------------------
 *|				|  vlan tagged	| Compare tag with PVID:	  | compare tag against VID list
 *|				|		| 1.equal:forward		  | 1. Found:forward
 *|				|		| 2.not equal:drop		  | 2. Not found:drop
 *|--------------------------------------------------------------------------------------------------------------
 */

 #define QVLAN_BYTES_PER_VID		((QTN_MAX_BSS_VAPS + NBBY - 1) / NBBY)
 #define QVLAN_BYTES_PER_VID_SHIFT	0

 RUBY_INLINE int
 qtn_vlan_is_valid(int vid)
 {
 	/* VLAN ID 0 is reserved */
 	return (vid > 0 && vid < QVLAN_VID_MAX);
 }

 RUBY_INLINE int
 qtn_vlan_is_member(volatile struct qtn_vlan_dev *vdev, uint16_t vid)
 {
 	return !!is_set_a(vdev->u.member_bitmap, vid);
 }

 RUBY_INLINE int
 qtn_vlan_is_tagged_member(volatile struct qtn_vlan_dev *vdev, uint16_t vid)
 {
 	return !!is_set_a(vdev->tag_bitmap, vid);
 }

 RUBY_INLINE int
 qtn_vlan_is_pvid(volatile struct qtn_vlan_dev *vdev, uint16_t vid)
 {
 	return vdev->pvid == vid;
 }

 RUBY_INLINE int
 qtn_vlan_is_mode(volatile struct qtn_vlan_dev *vdev, uint16_t mode)
 {
 	return ((struct qtn_vlan_user_interface *)vdev->user_data)->mode == mode;
 }

 #if defined(__KERNEL__) || defined(MUC_BUILD) || defined(AUC_BUILD)
 RUBY_INLINE int
 qtn_vlan_port_indexable(uint8_t port)
 {
 	return ((port == TOPAZ_TQE_EMAC_0_PORT)
 		|| (port == TOPAZ_TQE_EMAC_1_PORT)
 		|| (port == TOPAZ_TQE_PCIE_PORT)
 		|| (port == TOPAZ_TQE_DSP_PORT));
 }
 #endif

 RUBY_INLINE int
 qtn_vlan_get_tagrx(uint32_t *tagrx_bitmap, uint16_t vlanid)
 {
 	return (tagrx_bitmap[vlanid >> QVLAN_TAGRX_NUM_PER_DW_S] >>
 				((vlanid & (QVLAN_TAGRX_NUM_PER_DW - 1)) << QVLAN_TAGRX_BITSHIFT)) &
 		QVLAN_TAGRX_BITMASK;
 }

 RUBY_INLINE void
 qtn_vlan_gen_group_addr(uint8_t *mac, uint16_t vid, uint8_t vapid)
 {
 	uint16_t encode;

 	mac[0] = 0xff;
 	mac[1] = 0xff;
 	mac[2] = 0xff;
 	mac[3] = 0xff;

 	encode = ((uint16_t)vapid << QVLAN_VID_MAX_S) | vid;
 	mac[4] = encode >> 8;
 	mac[5] = (uint8_t)(encode & 0xff);
 }

 RUBY_INLINE int
 qtn_vlan_is_group_addr(const uint8_t *mac)
 {
 	return (mac[0] == 0xff && mac[1] == 0xff
 		&& mac[2] == 0xff && mac[3] == 0xff
 		&& mac[4] != 0xff);
 }

 #if defined(__KERNEL__) || defined(MUC_BUILD) || defined(AUC_BUILD)
 RUBY_INLINE struct qtn_vlan_pkt*
 qtn_vlan_get_info(const void *data)
 {
 	struct qtn_vlan_pkt *pkt;
 #if defined(AUC_BUILD)
 #pragma Off(Behaved)
 #endif
 	pkt = (struct qtn_vlan_pkt *)((const uint8_t *)data - QVLAN_PKTCTRL_LEN);
 #if defined(AUC_BUILD)
 #pragma On(Behaved)
 #endif
 	return pkt;
 }

 RUBY_INLINE int
 qtn_vlan_magic_check(struct qtn_vlan_pkt *pkt)
 {
 #define QVLAN_EGRESS_MAGIC_MSG	"VLAN-egress: magic number incorrect(0x%04x)\n"

 	if (unlikely(pkt->magic != QVLAN_PKT_MAGIC)) {
 #if defined (__KERNEL__)
 		printk(KERN_WARNING QVLAN_EGRESS_MAGIC_MSG, pkt->magic);
 #elif defined(AUC_BUILD)
 		auc_os_printf(QVLAN_EGRESS_MAGIC_MSG, pkt->magic);
 #elif defined(MUC_BUILD)
 		uc_printk(QVLAN_EGRESS_MAGIC_MSG, pkt->magic);
 #endif
 		return 0;
 	}

 	return 1;
 }

 RUBY_INLINE void
 qtn_vlan_inc_stats(struct qtn_vlan_stats *stats) {
 #if defined(__KERNEL__)
 	stats->lhost++;
 #elif defined(AUC_BUILD)
 	stats->auc++;
 #elif defined(MUC_BUILD)
 	stats->muc++;
 #endif
 }

 RUBY_INLINE int
 qtn_vlan_vlanid_check(struct qtn_vlan_dev *vdev, uint16_t ncidx, uint16_t vlanid)
 {
 	if (QVLAN_IS_DYNAMIC(vdev))
 		return (vdev->u.node_vlan[ncidx] == vlanid);
 	else
 		return qtn_vlan_is_member(vdev, vlanid);
 }

 RUBY_INLINE int
 qtn_vlan_egress(struct qtn_vlan_dev *outdev, uint16_t ncidx, void *data)
 {
 	struct qtn_vlan_pkt *pkt = qtn_vlan_get_info(data);

 	if (!qtn_vlan_magic_check(pkt)
 			|| (pkt->vlan_info & QVLAN_SKIP_CHECK)
 			|| qtn_vlan_vlanid_check(outdev, ncidx, pkt->vlan_info & QVLAN_MASK_VID)) {
 		qtn_vlan_inc_stats(&outdev->eg_pass);
 		return 1;
 	}

 	qtn_vlan_inc_stats(&outdev->eg_drop);
 	return 0;
 }
 #endif

 #if defined(__KERNEL__) || defined(MUC_BUILD)
 RUBY_INLINE int
 qtn_vlan_ingress(struct qtn_vlan_dev *indev, uint16_t ncidx,
 		void *data, uint16_t known_vlanid, uint8_t cache_op)
 {
 	struct ether_header *eh = (struct ether_header *)data;
 	struct qtn_vlan_pkt *pkt = qtn_vlan_get_info(data);
 	uint16_t vlanid;
 	const uint16_t magic = QVLAN_PKT_MAGIC;

 	if (eh->ether_type == htons(ETHERTYPE_8021Q)) {
 		vlanid = ntohs(*(uint16_t *)(eh + 1)) & QVLAN_MASK_VID;

 		if (!qtn_vlan_vlanid_check(indev, ncidx, vlanid)) {
 			qtn_vlan_inc_stats(&indev->ig_drop);
 			return 0;
 		}

 		vlanid |= QVLAN_TAGGED;
 	} else if (known_vlanid) {
 		vlanid = known_vlanid;

 		if (!qtn_vlan_vlanid_check(indev, ncidx, vlanid)) {
 			qtn_vlan_inc_stats(&indev->ig_drop);
 			return 0;
 		}
 	} else {
 		vlanid = indev->pvid;
 	}

 	pkt->magic = magic;
 	pkt->vlan_info = vlanid;

 	if (cache_op) {
 #if defined(__KERNEL__)
 		flush_and_inv_dcache_sizerange_safe(pkt, QVLAN_PKTCTRL_LEN);
 #elif defined(MUC_BUILD)
 		flush_and_inv_dcache_range_safe(pkt, QVLAN_PKTCTRL_LEN);
 #endif
 	}

 	qtn_vlan_inc_stats(&indev->ig_pass);
 	return 1;
 }
 #endif

 RUBY_INLINE int
 qtn_vlancfg_reform(struct qtn_vlan_config *vcfg)
 {
 	/* remove 0,15,16,31 bits to restore vlan_cfg */
 	vcfg->vlan_cfg &= 0x7ffe7ffe;
 	vcfg->vlan_cfg >>= 1;

 	return ((vcfg->vlan_cfg & QVLAN_MASK_MODE) >> QVLAN_SHIFT_MODE);
 }

 #if defined(__KERNEL__)
 extern uint8_t vlan_enabled;
 extern struct qtn_vlan_dev *vdev_tbl_lhost[VLAN_INTERFACE_MAX];
 extern struct qtn_vlan_dev *vdev_tbl_bus[VLAN_INTERFACE_MAX];
 extern struct qtn_vlan_dev *vport_tbl_lhost[TOPAZ_TQE_NUM_PORTS];
 extern struct qtn_vlan_dev *vport_tbl_bus[TOPAZ_TQE_NUM_PORTS];
 extern struct qtn_vlan_info qtn_vlan_info;

 extern struct qtn_vlan_dev *switch_alloc_vlan_dev(uint8_t port, uint8_t idx, int ifindex);
 extern void switch_free_vlan_dev(struct qtn_vlan_dev *dev);
 extern void switch_free_vlan_dev_by_idx(uint8_t idx);
 extern struct qtn_vlan_dev *switch_vlan_dev_get_by_port(uint8_t port);
 extern struct qtn_vlan_dev *switch_vlan_dev_get_by_idx(uint8_t idx);

 extern int switch_vlan_add_member(struct qtn_vlan_dev *vdev, uint16_t vid, uint8_t tag);
 extern int switch_vlan_del_member(struct qtn_vlan_dev *vdev, uint16_t vid);
 extern int switch_vlan_tag_member(struct qtn_vlan_dev *vdev, uint16_t vid);
 extern int switch_vlan_untag_member(struct qtn_vlan_dev *vdev, uint16_t vid);
 extern int switch_vlan_set_pvid(struct qtn_vlan_dev *vdev, uint16_t vid);

 /* dynamic VLAN support */
 extern void switch_vlan_dyn_enable(struct qtn_vlan_dev *vdev);
 extern void switch_vlan_dyn_disable(struct qtn_vlan_dev *vdev);
 extern int switch_vlan_set_node(struct qtn_vlan_dev *vdev, uint16_t ncidx, uint16_t vlan);
 extern int switch_vlan_clr_node(struct qtn_vlan_dev *vdev, uint16_t ncidx);

 extern int switch_vlan_is_local(const uint8_t *data);
 extern struct sk_buff *switch_vlan_strip_tag(struct sk_buff *, int copy);
 extern struct sk_buff *switch_vlan_restore_tag(struct sk_buff *, int copy);
 extern void switch_vlan_reset(void);
 extern void switch_vlan_dev_reset(struct qtn_vlan_dev *vdev, uint8_t mode);
 extern void switch_vlan_emac_to_lhost(uint32_t enable);
 #endif

 #endif
	/*
	* Copyright (c) 2014 Quantenna Communications, Inc.
	* All rights reserved.
	*/

	#ifndef _QTN_VLAN_H_
	#define _QTN_VLAN_H_

	#include "../common/ruby_mem.h"
	#include <qtn/qtn_debug.h>
	#include <qtn/qtn_uc_comm.h>
	#include <qtn/qtn_net_packet.h>
	#if defined(__KERNEL__) \|\| defined(MUC_BUILD) \|\| defined(AUC_BUILD)
	#include <qtn/topaz_tqe_cpuif.h>
	#endif
	#if defined(__KERNEL__)
	#include <qtn/dmautil.h>
	#endif

	#define QVLAN_MODE_ACCESS 0
	#define QVLAN_MODE_TRUNK 1
	#define QVLAN_MODE_HYBRID 2
	#define QVLAN_MODE_DYNAMIC 3
	#define QVLAN_MODE_MAX QVLAN_MODE_DYNAMIC
	#define QVLAN_SHIFT_MODE 16
	#define QVLAN_MASK_MODE 0xffff0000
	#define QVLAN_MASK_VID 0x00000fff

	#define QVLAN_MODE(x) (uint16_t)((x) >> QVLAN_SHIFT_MODE)
	#define QVLAN_VID(x) (uint16_t)((x) & QVLAN_MASK_VID)

	#define QVLAN_MODE_STR_ACCESS "Access mode"
	#define QVLAN_MODE_STR_TRUNK "Trunk mode"
	#define QVLAN_MODE_STR_HYBRID "Hybrid mode"
	#define QVLAN_MODE_STR_DYNAMIC "Dynamic mode"

	/* default port vlan id */
	#define QVLAN_DEF_PVID 1

	#define QVLAN_VID_MAX 4096
	#define QVLAN_VID_MAX_S 12
	#define QVLAN_VID_ALL 0xffff

	#ifndef NBBY
	#define NBBY 8
	#endif

	#ifndef NBDW
	#define NBDW 32
	#endif

	#ifdef CONFIG_TOPAZ_DBDC_HOST
	#define VLAN_INTERFACE_MAX (QTN_MAX_VAPS + 2 + MAX_QFP_NETDEV)
	#define QFP_VDEV_IDX(dev_id) (QTN_MAX_VAPS + 2 + (dev_id))
	#else
	#define VLAN_INTERFACE_MAX (QTN_MAX_VAPS + 2)
	#endif
	#define WMAC_VDEV_IDX_MAX QTN_MAX_VAPS
	#define EMAC_VDEV_IDX(port) (QTN_MAX_VAPS + (port))
	#define PCIE_VDEV_IDX (QTN_MAX_VAPS + 0)

	#ifndef howmany
	#define howmany(x, y) (((x) + ((y) - 1)) / (y))
	#endif

	#define bitsz_var(var) (sizeof(var) * 8)
	#define bitsz_ptr(ptr) bitsz_var((ptr)[0])

	#define set_bit_a(a, i) ((a)[(i) / bitsz_ptr(a)] \|= 1 << ((i) % bitsz_ptr(a)))
	#define clr_bit_a(a, i) ((a)[(i) / bitsz_ptr(a)] &= ~(1 << ((i) % bitsz_ptr(a))))
	#define is_set_a(a, i) ((a)[(i) / bitsz_ptr(a)] & (1 << ((i) % bitsz_ptr(a))))
	#define is_clr_a(a, i) (is_set_a(a, i) == 0)

	struct qtn_vlan_stats {
	uint32_t lhost;
	uint32_t auc;
	uint32_t muc;
	};

	struct qtn_vlan_user_interface {
	unsigned long bus_addr;
	uint8_t mode;
	};

	struct qtn_vlan_dev {
	uint8_t idx;
	uint8_t port;
	uint16_t pvid;
	#define QVLAN_DEV_F_DYNAMIC BIT(0)
	uint32_t flags;
	unsigned long bus_addr;
	int ifindex;
	union {
	uint32_t member_bitmap[howmany(QVLAN_VID_MAX, NBDW)];
	uint16_t node_vlan[QTN_NCIDX_MAX];
	}u;
	uint32_t tag_bitmap[howmany(QVLAN_VID_MAX, NBDW)];
	struct qtn_vlan_stats ig_pass;
	struct qtn_vlan_stats ig_drop;
	struct qtn_vlan_stats eg_pass;
	struct qtn_vlan_stats eg_drop;
	void *user_data;
	};
	#define QVLAN_IS_DYNAMIC(vdev) ((vdev)->flags & QVLAN_DEV_F_DYNAMIC)

	struct qtn_vlan_pkt {
	#define QVLAN_PKT_MAGIC 0x1234
	uint16_t magic;
	#define QVLAN_TAGGED 0x8000
	#define QVLAN_SKIP_CHECK 0x4000
	uint16_t vlan_info;
	} __packed;

	#define QVLAN_PKTCTRL_LEN sizeof(struct qtn_vlan_pkt)

	struct qtn_vlan_info {
	#define QVLAN_TAGRX_UNTOUCH 0
	#define QVLAN_TAGRX_STRIP 1
	#define QVLAN_TAGRX_TAG 2
	#define QVLAN_TAGRX_BITMASK 0x3
	#define QVLAN_TAGRX_BITWIDTH 2
	#define QVLAN_TAGRX_BITSHIFT 1
	#define QVLAN_TAGRX_NUM_PER_DW (32 / QVLAN_TAGRX_BITWIDTH)
	#define QVLAN_TAGRX_NUM_PER_DW_S 4
	uint32_t vlan_tagrx_bitmap[howmany(QVLAN_VID_MAX * QVLAN_TAGRX_BITWIDTH, NBDW)];
	};

	RUBY_INLINE int qvlan_tagrx_index(int vid)
	{
	return (vid >> QVLAN_TAGRX_NUM_PER_DW_S);
	}

	RUBY_INLINE int qvlan_tagrx_shift(int vid)
	{
	int shift;

	shift = vid & (QVLAN_TAGRX_NUM_PER_DW - 1);
	return (shift << QVLAN_TAGRX_BITSHIFT);
	}

	struct qtn_vlan_config {
	uint32_t vlan_cfg;
	union {
	struct vlan_dev_config {
	uint32_t member_bitmap[howmany(QVLAN_VID_MAX, NBDW)];
	uint32_t tag_bitmap[howmany(QVLAN_VID_MAX, NBDW)];
	} dev_config;
	uint32_t tagrx_config[howmany(QVLAN_VID_MAX * QVLAN_TAGRX_BITWIDTH, NBDW)];
	} u;
	};

	/*
	* VLAN forward/drop table
	*\| traffic direction \| frame \| Access(MBSS/Dynamic mode) \| Trunk(Passthrough mode)
	*\|--------------------------------------------------------------------------------------------------------------
	*\| wifi tx \| no vlan \| drop \| forward
	*\|--------------------------------------------------------------------------------------------------------------
	*\| \| vlan tagged \| compare tag with PVID: \| compare tag against VID list
	*\| \| \| 1.equal:untag and forward \| 1.Found:forward
	*\| \| \| 2.not equal:drop \| 2.Not found:drop
	*\|--------------------------------------------------------------------------------------------------------------
	*\| wifi rx \| no vlan \| Add PVID tag and forward \| forward
	*\|--------------------------------------------------------------------------------------------------------------
	*\| \| vlan tagged \| Compare tag with PVID: \| compare tag against VID list
	*\| \| \| 1.equal:forward \| 1. Found:forward
	*\| \| \| 2.not equal:drop \| 2. Not found:drop
	*\|--------------------------------------------------------------------------------------------------------------
	*/

	#define QVLAN_BYTES_PER_VID ((QTN_MAX_BSS_VAPS + NBBY - 1) / NBBY)
	#define QVLAN_BYTES_PER_VID_SHIFT 0

	RUBY_INLINE int
	qtn_vlan_is_valid(int vid)
	{
	/* VLAN ID 0 is reserved */
	return (vid > 0 && vid < QVLAN_VID_MAX);
	}

	RUBY_INLINE int
	qtn_vlan_is_member(volatile struct qtn_vlan_dev *vdev, uint16_t vid)
	{
	return !!is_set_a(vdev->u.member_bitmap, vid);
	}

	RUBY_INLINE int
	qtn_vlan_is_tagged_member(volatile struct qtn_vlan_dev *vdev, uint16_t vid)
	{
	return !!is_set_a(vdev->tag_bitmap, vid);
	}

	RUBY_INLINE int
	qtn_vlan_is_pvid(volatile struct qtn_vlan_dev *vdev, uint16_t vid)
	{
	return vdev->pvid == vid;
	}

	RUBY_INLINE int
	qtn_vlan_is_mode(volatile struct qtn_vlan_dev *vdev, uint16_t mode)
	{
	return ((struct qtn_vlan_user_interface *)vdev->user_data)->mode == mode;
	}

	#if defined(__KERNEL__) \|\| defined(MUC_BUILD) \|\| defined(AUC_BUILD)
	RUBY_INLINE int
	qtn_vlan_port_indexable(uint8_t port)
	{
	return ((port == TOPAZ_TQE_EMAC_0_PORT)
	\|\| (port == TOPAZ_TQE_EMAC_1_PORT)
	\|\| (port == TOPAZ_TQE_PCIE_PORT)
	\|\| (port == TOPAZ_TQE_DSP_PORT));
	}
	#endif

	RUBY_INLINE int
	qtn_vlan_get_tagrx(uint32_t *tagrx_bitmap, uint16_t vlanid)
	{
	return (tagrx_bitmap[vlanid >> QVLAN_TAGRX_NUM_PER_DW_S] >>
	((vlanid & (QVLAN_TAGRX_NUM_PER_DW - 1)) << QVLAN_TAGRX_BITSHIFT)) &
	QVLAN_TAGRX_BITMASK;
	}

	RUBY_INLINE void
	qtn_vlan_gen_group_addr(uint8_t *mac, uint16_t vid, uint8_t vapid)
	{
	uint16_t encode;

	mac[0] = 0xff;
	mac[1] = 0xff;
	mac[2] = 0xff;
	mac[3] = 0xff;

	encode = ((uint16_t)vapid << QVLAN_VID_MAX_S) \| vid;
	mac[4] = encode >> 8;
	mac[5] = (uint8_t)(encode & 0xff);
	}

	RUBY_INLINE int
	qtn_vlan_is_group_addr(const uint8_t *mac)
	{
	return (mac[0] == 0xff && mac[1] == 0xff
	&& mac[2] == 0xff && mac[3] == 0xff
	&& mac[4] != 0xff);
	}

	#if defined(__KERNEL__) \|\| defined(MUC_BUILD) \|\| defined(AUC_BUILD)
	RUBY_INLINE struct qtn_vlan_pkt*
	qtn_vlan_get_info(const void *data)
	{
	struct qtn_vlan_pkt *pkt;
	#if defined(AUC_BUILD)
	#pragma Off(Behaved)
	#endif
	pkt = (struct qtn_vlan_pkt )((const uint8_t )data - QVLAN_PKTCTRL_LEN);
	#if defined(AUC_BUILD)
	#pragma On(Behaved)
	#endif
	return pkt;
	}

	RUBY_INLINE int
	qtn_vlan_magic_check(struct qtn_vlan_pkt *pkt)
	{
	#define QVLAN_EGRESS_MAGIC_MSG "VLAN-egress: magic number incorrect(0x%04x)\n"

	if (unlikely(pkt->magic != QVLAN_PKT_MAGIC)) {
	#if defined (__KERNEL__)
	printk(KERN_WARNING QVLAN_EGRESS_MAGIC_MSG, pkt->magic);
	#elif defined(AUC_BUILD)
	auc_os_printf(QVLAN_EGRESS_MAGIC_MSG, pkt->magic);
	#elif defined(MUC_BUILD)
	uc_printk(QVLAN_EGRESS_MAGIC_MSG, pkt->magic);
	#endif
	return 0;
	}

	return 1;
	}

	RUBY_INLINE void
	qtn_vlan_inc_stats(struct qtn_vlan_stats *stats) {
	#if defined(__KERNEL__)
	stats->lhost++;
	#elif defined(AUC_BUILD)
	stats->auc++;
	#elif defined(MUC_BUILD)
	stats->muc++;
	#endif
	}

	RUBY_INLINE int
	qtn_vlan_vlanid_check(struct qtn_vlan_dev *vdev, uint16_t ncidx, uint16_t vlanid)
	{
	if (QVLAN_IS_DYNAMIC(vdev))
	return (vdev->u.node_vlan[ncidx] == vlanid);
	else
	return qtn_vlan_is_member(vdev, vlanid);
	}

	RUBY_INLINE int
	qtn_vlan_egress(struct qtn_vlan_dev outdev, uint16_t ncidx, void data)
	{
	struct qtn_vlan_pkt *pkt = qtn_vlan_get_info(data);

	if (!qtn_vlan_magic_check(pkt)
	\|\| (pkt->vlan_info & QVLAN_SKIP_CHECK)
	\|\| qtn_vlan_vlanid_check(outdev, ncidx, pkt->vlan_info & QVLAN_MASK_VID)) {
	qtn_vlan_inc_stats(&outdev->eg_pass);
	return 1;
	}

	qtn_vlan_inc_stats(&outdev->eg_drop);
	return 0;
	}
	#endif

	#if defined(__KERNEL__) \|\| defined(MUC_BUILD)
	RUBY_INLINE int
	qtn_vlan_ingress(struct qtn_vlan_dev *indev, uint16_t ncidx,
	void *data, uint16_t known_vlanid, uint8_t cache_op)
	{
	struct ether_header eh = (struct ether_header )data;
	struct qtn_vlan_pkt *pkt = qtn_vlan_get_info(data);
	uint16_t vlanid;
	const uint16_t magic = QVLAN_PKT_MAGIC;

	if (eh->ether_type == htons(ETHERTYPE_8021Q)) {
	vlanid = ntohs((uint16_t )(eh + 1)) & QVLAN_MASK_VID;

	if (!qtn_vlan_vlanid_check(indev, ncidx, vlanid)) {
	qtn_vlan_inc_stats(&indev->ig_drop);
	return 0;
	}

	vlanid \|= QVLAN_TAGGED;
	} else if (known_vlanid) {
	vlanid = known_vlanid;

	if (!qtn_vlan_vlanid_check(indev, ncidx, vlanid)) {
	qtn_vlan_inc_stats(&indev->ig_drop);
	return 0;
	}
	} else {
	vlanid = indev->pvid;
	}

	pkt->magic = magic;
	pkt->vlan_info = vlanid;

	if (cache_op) {
	#if defined(__KERNEL__)
	flush_and_inv_dcache_sizerange_safe(pkt, QVLAN_PKTCTRL_LEN);
	#elif defined(MUC_BUILD)
	flush_and_inv_dcache_range_safe(pkt, QVLAN_PKTCTRL_LEN);
	#endif
	}

	qtn_vlan_inc_stats(&indev->ig_pass);
	return 1;
	}
	#endif

	RUBY_INLINE int
	qtn_vlancfg_reform(struct qtn_vlan_config *vcfg)
	{
	/* remove 0,15,16,31 bits to restore vlan_cfg */
	vcfg->vlan_cfg &= 0x7ffe7ffe;
	vcfg->vlan_cfg >>= 1;

	return ((vcfg->vlan_cfg & QVLAN_MASK_MODE) >> QVLAN_SHIFT_MODE);
	}

	#if defined(__KERNEL__)
	extern uint8_t vlan_enabled;
	extern struct qtn_vlan_dev *vdev_tbl_lhost[VLAN_INTERFACE_MAX];
	extern struct qtn_vlan_dev *vdev_tbl_bus[VLAN_INTERFACE_MAX];
	extern struct qtn_vlan_dev *vport_tbl_lhost[TOPAZ_TQE_NUM_PORTS];
	extern struct qtn_vlan_dev *vport_tbl_bus[TOPAZ_TQE_NUM_PORTS];
	extern struct qtn_vlan_info qtn_vlan_info;

	extern struct qtn_vlan_dev *switch_alloc_vlan_dev(uint8_t port, uint8_t idx, int ifindex);
	extern void switch_free_vlan_dev(struct qtn_vlan_dev *dev);
	extern void switch_free_vlan_dev_by_idx(uint8_t idx);
	extern struct qtn_vlan_dev *switch_vlan_dev_get_by_port(uint8_t port);
	extern struct qtn_vlan_dev *switch_vlan_dev_get_by_idx(uint8_t idx);

	extern int switch_vlan_add_member(struct qtn_vlan_dev *vdev, uint16_t vid, uint8_t tag);
	extern int switch_vlan_del_member(struct qtn_vlan_dev *vdev, uint16_t vid);
	extern int switch_vlan_tag_member(struct qtn_vlan_dev *vdev, uint16_t vid);
	extern int switch_vlan_untag_member(struct qtn_vlan_dev *vdev, uint16_t vid);
	extern int switch_vlan_set_pvid(struct qtn_vlan_dev *vdev, uint16_t vid);

	/* dynamic VLAN support */
	extern void switch_vlan_dyn_enable(struct qtn_vlan_dev *vdev);
	extern void switch_vlan_dyn_disable(struct qtn_vlan_dev *vdev);
	extern int switch_vlan_set_node(struct qtn_vlan_dev *vdev, uint16_t ncidx, uint16_t vlan);
	extern int switch_vlan_clr_node(struct qtn_vlan_dev *vdev, uint16_t ncidx);

	extern int switch_vlan_is_local(const uint8_t *data);
	extern struct sk_buff switch_vlan_strip_tag(struct sk_buff , int copy);
	extern struct sk_buff switch_vlan_restore_tag(struct sk_buff , int copy);
	extern void switch_vlan_reset(void);
	extern void switch_vlan_dev_reset(struct qtn_vlan_dev *vdev, uint8_t mode);
	extern void switch_vlan_emac_to_lhost(uint32_t enable);
	#endif

	#endif