| /* |
| * 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_CMD_DEF_PRIORITY 4 |
| #define QVLAN_MODE_MAX QVLAN_CMD_DEF_PRIORITY |
| #define QVLAN_MODE_DISABLED (QVLAN_MODE_MAX + 1) |
| #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" |
| |
| #define QVLAN_PRIO_VID 0 |
| #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 muc; |
| }; |
| |
| struct qtn_vlan_user_interface { |
| unsigned long bus_addr; |
| uint8_t mode; |
| }; |
| |
| #define QVLAN_PRIO_MAX 7 |
| struct qtn_vlan_dev { |
| uint8_t idx; |
| uint8_t port; |
| uint16_t pvid; |
| uint16_t priority; |
| #define QVLAN_DEV_F_DYNAMIC BIT(0) |
| uint16_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; |
| struct qtn_vlan_stats magic_invalid; |
| void *user_data; |
| }; |
| #define QVLAN_IS_DYNAMIC(vdev) ((vdev)->flags & QVLAN_DEV_F_DYNAMIC) |
| |
| struct qtn_vlan_pkt { |
| #define QVLAN_PKT_MAGIC 0xf8 |
| uint8_t magic; |
| #define QVLAN_PKT_TAGGED BIT(0) |
| #define QVLAN_PKT_ZERO_TAGGED BIT(1) |
| #define QVLAN_PKT_SKIP_CHECK BIT(2) |
| #define QVLAN_PKT_TXACTION_UNTOUCH 0 |
| #define QVLAN_PKT_TXACTION_UNTAG BIT(3) |
| #define QVLAN_PKT_TXACTION_TAG BIT(4) |
| #define QVLAN_PKT_TXACTION_REPLACE (QVLAN_PKT_TXACTION_UNTAG | QVLAN_PKT_TXACTION_TAG) |
| #define QVLAN_PKT_TXACTION_VLAN0 BIT(5) |
| uint8_t flag; |
| #define QVLAN_PKT_VID_MASK 0x0fff |
| #define QVLAN_PKT_PRIORITY_MASK 0xe000 |
| #define QVLAN_PKT_PRIORITY_SHIFT 13 |
| 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); |
| } |
| |
| /* |
| * Must be in sync with qcsapi_vlan_config in qcsapi.h |
| * -- Whenever 'struct qtn_vlan_config' changes, qcsapi.h changes as well |
| */ |
| struct qtn_vlan_config { |
| uint32_t vlan_cfg; |
| uint32_t priority; |
| 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; |
| }; |
| |
| RUBY_INLINE void qtn_vlan_config_htonl(struct qtn_vlan_config *vcfg, int tagrx) |
| { |
| unsigned int i; |
| |
| vcfg->vlan_cfg = htonl(vcfg->vlan_cfg); |
| vcfg->priority = htonl(vcfg->priority); |
| |
| if (tagrx) { |
| for (i = 0; i < ARRAY_SIZE(vcfg->u.tagrx_config); i++) |
| vcfg->u.tagrx_config[i] = htonl(vcfg->u.tagrx_config[i]); |
| } else { |
| for (i = 0; i < ARRAY_SIZE(vcfg->u.dev_config.member_bitmap); i++) |
| vcfg->u.dev_config.member_bitmap[i] = htonl(vcfg->u.dev_config.member_bitmap[i]); |
| |
| for (i = 0; i < ARRAY_SIZE(vcfg->u.dev_config.tag_bitmap); i++) |
| vcfg->u.dev_config.tag_bitmap[i] = htonl(vcfg->u.dev_config.tag_bitmap[i]); |
| } |
| } |
| |
| RUBY_INLINE void qtn_vlan_config_ntohl(struct qtn_vlan_config *vcfg, int tagrx) |
| { |
| unsigned int i; |
| |
| vcfg->vlan_cfg = ntohl(vcfg->vlan_cfg); |
| vcfg->priority = ntohl(vcfg->priority); |
| |
| if (tagrx) { |
| for (i = 0; i < ARRAY_SIZE(vcfg->u.tagrx_config); i++) |
| vcfg->u.tagrx_config[i] = ntohl(vcfg->u.tagrx_config[i]); |
| } else { |
| for (i = 0; i < ARRAY_SIZE(vcfg->u.dev_config.member_bitmap); i++) |
| vcfg->u.dev_config.member_bitmap[i] = ntohl(vcfg->u.dev_config.member_bitmap[i]); |
| |
| for (i = 0; i < ARRAY_SIZE(vcfg->u.dev_config.tag_bitmap); i++) |
| vcfg->u.dev_config.tag_bitmap[i] = ntohl(vcfg->u.dev_config.tag_bitmap[i]); |
| } |
| } |
| |
| /* |
| * 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) |
| { |
| 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 void |
| qtn_vlan_inc_stats(struct qtn_vlan_stats *stats) { |
| #if defined(__KERNEL__) |
| stats->lhost++; |
| #elif defined(MUC_BUILD) |
| stats->muc++; |
| #endif |
| } |
| |
| RUBY_INLINE int |
| qtn_vlan_magic_check(struct qtn_vlan_dev *outdev, struct qtn_vlan_pkt *pkt) |
| { |
| if (unlikely(pkt->magic != QVLAN_PKT_MAGIC)) { |
| qtn_vlan_inc_stats(&outdev->magic_invalid); |
| return 0; |
| } |
| |
| return 1; |
| } |
| |
| 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); |
| } |
| |
| #define QVLAN_PKT_TXACTION_INVALID 0xff |
| /* |
| * VLAN encapsulation action table |
| * | Frame Non-Zero tagged | Frame Zero tagged | Tx Tag | VLAN 0 Tx Tag | Action | |
| * | 0 | 0 | 0 | 0 | DONT_TOUCH | |
| * | 0 | 0 | 0 | 1 | ADD_TAG_0 | |
| * | 0 | 0 | 1 | 0 | ADD_TAG | |
| * | 0 | 0 | 1 | 1 | ADD_TAG | |
| * | 0 | 1 | 0 | 0 | STRIP | |
| * | 0 | 1 | 0 | 1 | DONT_TOUCH | |
| * | 0 | 1 | 1 | 0 | REPLACE | |
| * | 0 | 1 | 1 | 1 | REPLACE | |
| * | 1 | 0 | 0 | 0 | STRIP | |
| * | 1 | 0 | 0 | 1 | REPLACE_0 | |
| * | 1 | 0 | 1 | 0 | DONT_TOUCH | |
| * | 1 | 0 | 1 | 1 | DONT_TOUCH | |
| */ |
| static const uint8_t qvlan_tx_actions[] = { |
| QVLAN_PKT_TXACTION_UNTOUCH, |
| QVLAN_PKT_TXACTION_TAG | QVLAN_PKT_TXACTION_VLAN0, |
| QVLAN_PKT_TXACTION_TAG, |
| QVLAN_PKT_TXACTION_TAG, |
| |
| QVLAN_PKT_TXACTION_UNTAG, |
| QVLAN_PKT_TXACTION_UNTOUCH, |
| QVLAN_PKT_TXACTION_REPLACE, |
| QVLAN_PKT_TXACTION_REPLACE, |
| |
| QVLAN_PKT_TXACTION_UNTAG, |
| QVLAN_PKT_TXACTION_REPLACE | QVLAN_PKT_TXACTION_VLAN0, |
| QVLAN_PKT_TXACTION_UNTOUCH, |
| QVLAN_PKT_TXACTION_UNTOUCH, |
| |
| QVLAN_PKT_TXACTION_INVALID, |
| QVLAN_PKT_TXACTION_INVALID, |
| QVLAN_PKT_TXACTION_INVALID, |
| QVLAN_PKT_TXACTION_INVALID |
| }; |
| |
| RUBY_INLINE void |
| qtn_vlan_tx_action(struct qtn_vlan_dev *vdev, struct qtn_vlan_pkt *pkt) |
| { |
| uint8_t index = 0; |
| uint8_t action; |
| uint16_t vlanid = (pkt->vlan_info & QVLAN_PKT_VID_MASK); |
| |
| index |= (qtn_vlan_is_tagged_member(vdev, QVLAN_PRIO_VID) ? BIT(0): 0); |
| index |= (qtn_vlan_is_tagged_member(vdev, vlanid) ? BIT(1) : 0); |
| index |= ((pkt->flag & QVLAN_PKT_ZERO_TAGGED) ? BIT (2) : 0); |
| index |= ((pkt->flag & QVLAN_PKT_TAGGED) ? BIT(3) : 0); |
| |
| action = qvlan_tx_actions[index]; |
| #if defined(AUC_BUILD) |
| AUC_OS_ASSERT(action != QVLAN_PKT_TXACTION_INVALID, "VLAN action invalid\n"); |
| #elif defined(MUC_BUILD) |
| OS_ASSERT(action != QVLAN_PKT_TXACTION_INVALID, ("VLAN action invalid\n")); |
| #elif defined(__KERNEL__) |
| KASSERT((action != QVLAN_PKT_TXACTION_INVALID), ("VLAN action invalid\n")); |
| #endif |
| |
| pkt->flag |= action; |
| } |
| |
| RUBY_INLINE int |
| qtn_vlan_egress(struct qtn_vlan_dev *outdev, uint16_t ncidx, void *data, |
| int need_encap_info, int cache_op) |
| { |
| struct qtn_vlan_pkt *pkt = qtn_vlan_get_info(data); |
| |
| if (!qtn_vlan_magic_check(outdev, pkt) |
| || (pkt->flag & QVLAN_PKT_SKIP_CHECK) |
| || qtn_vlan_vlanid_check(outdev, ncidx, pkt->vlan_info & QVLAN_PKT_VID_MASK)) { |
| qtn_vlan_inc_stats(&outdev->eg_pass); |
| |
| if (need_encap_info) |
| qtn_vlan_tx_action(outdev, pkt); |
| |
| 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 |
| } |
| |
| 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_vlan, uint16_t known_vlan_tci, uint8_t cache_op) |
| { |
| struct ether_header *eh = (struct ether_header *)data; |
| struct qtn_vlan_pkt *pkt; |
| uint16_t vlan_tci = 0; |
| uint16_t vlan_id = QVLAN_PRIO_VID; |
| uint16_t flag = 0; |
| |
| if (eh->ether_type == htons(ETHERTYPE_8021Q)) { |
| vlan_tci = ntohs(*(uint16_t *)(eh + 1)); |
| vlan_id = vlan_tci & QVLAN_PKT_VID_MASK; |
| |
| flag |= (vlan_id == QVLAN_PRIO_VID ? QVLAN_PKT_ZERO_TAGGED : QVLAN_PKT_TAGGED); |
| |
| if (vlan_id == QVLAN_PRIO_VID && known_vlan) { |
| vlan_tci = known_vlan_tci; |
| vlan_id = vlan_tci & QVLAN_PKT_VID_MASK; |
| } |
| } else if (known_vlan) { |
| vlan_tci = known_vlan_tci; |
| vlan_id = vlan_tci & QVLAN_PKT_VID_MASK; |
| } else { |
| vlan_tci = (indev->priority << QVLAN_PKT_PRIORITY_SHIFT); |
| } |
| |
| if (vlan_id == QVLAN_PRIO_VID) { |
| vlan_tci |= indev->pvid; |
| } else if (!qtn_vlan_vlanid_check(indev, ncidx, vlan_id)) { |
| qtn_vlan_inc_stats(&indev->ig_drop); |
| return 0; |
| } |
| |
| pkt = qtn_vlan_get_info(data); |
| pkt->magic = QVLAN_PKT_MAGIC; |
| pkt->flag = flag; |
| pkt->vlan_info = vlan_tci; |
| |
| 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 |
| |
| #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); |
| extern int switch_vlan_set_priority(struct qtn_vlan_dev *vdev, uint8_t priority); |
| |
| extern int switch_vlan_register_node(uint16_t ncidx, struct qtn_vlan_dev *vdev); |
| extern void switch_vlan_unregister_node(uint16_t ncidx); |
| extern struct qtn_vlan_dev *switch_vlan_dev_from_node(uint16_t ncidx); |
| |
| /* 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 struct sk_buff *switch_vlan_to_proto_stack(struct sk_buff *, int copy); |
| extern struct sk_buff *switch_vlan_from_proto_stack(struct sk_buff *, struct qtn_vlan_dev *, uint16_t ncidx, 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 |
