3 * Ethernet-type device handling.
5 * Authors: Ben Greear <greearb@candelatech.com>
6 * Please send support related email to: netdev@vger.kernel.org
7 * VLAN Home Page: http://www.candelatech.com/~greear/vlan.html
9 * Fixes: Mar 22 2001: Martin Bokaemper <mbokaemper@unispherenetworks.com>
10 * - reset skb->pkt_type on incoming packets when MAC was changed
11 * - see that changed MAC is saddr for outgoing packets
12 * Oct 20, 2001: Ard van Breeman:
13 * - Fix MC-list, finally.
14 * - Flush MC-list on VLAN destroy.
17 * This program is free software; you can redistribute it and/or
18 * modify it under the terms of the GNU General Public License
19 * as published by the Free Software Foundation; either version
20 * 2 of the License, or (at your option) any later version.
23 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <asm/uaccess.h> /* for copy_from_user */
28 #include <linux/skbuff.h>
29 #include <linux/netdevice.h>
30 #include <linux/etherdevice.h>
31 #include <linux/ethtool.h>
32 #include <net/datalink.h>
33 #include <net/p8022.h>
38 #include <linux/if_vlan.h>
42 * Rebuild the Ethernet MAC header. This is called after an ARP
43 * (or in future other address resolution) has completed on this
44 * sk_buff. We now let ARP fill in the other fields.
46 * This routine CANNOT use cached dst->neigh!
47 * Really, it is used only when dst->neigh is wrong.
49 * TODO: This needs a checkup, I'm ignorant here. --BLG
51 static int vlan_dev_rebuild_header(struct sk_buff
*skb
)
53 struct net_device
*dev
= skb
->dev
;
54 struct vlan_ethhdr
*veth
= (struct vlan_ethhdr
*)(skb
->data
);
56 switch (veth
->h_vlan_encapsulated_proto
) {
58 case __constant_htons(ETH_P_IP
):
60 /* TODO: Confirm this will work with VLAN headers... */
61 return arp_find(veth
->h_dest
, skb
);
64 pr_debug("%s: unable to resolve type %X addresses.\n",
65 dev
->name
, ntohs(veth
->h_vlan_encapsulated_proto
));
67 memcpy(veth
->h_source
, dev
->dev_addr
, ETH_ALEN
);
74 static inline struct sk_buff
*vlan_check_reorder_header(struct sk_buff
*skb
)
76 if (vlan_dev_info(skb
->dev
)->flags
& VLAN_FLAG_REORDER_HDR
) {
77 if (skb_cow(skb
, skb_headroom(skb
)) < 0)
80 /* Lifted from Gleb's VLAN code... */
81 memmove(skb
->data
- ETH_HLEN
,
82 skb
->data
- VLAN_ETH_HLEN
, 12);
83 skb
->mac_header
+= VLAN_HLEN
;
90 static inline void vlan_set_encap_proto(struct sk_buff
*skb
,
91 struct vlan_hdr
*vhdr
)
97 * Was a VLAN packet, grab the encapsulated protocol, which the layer
98 * three protocols care about.
101 proto
= vhdr
->h_vlan_encapsulated_proto
;
102 if (ntohs(proto
) >= 1536) {
103 skb
->protocol
= proto
;
108 if (*(unsigned short *)rawp
== 0xFFFF)
110 * This is a magic hack to spot IPX packets. Older Novell
111 * breaks the protocol design and runs IPX over 802.3 without
112 * an 802.2 LLC layer. We look for FFFF which isn't a used
113 * 802.2 SSAP/DSAP. This won't work for fault tolerant netware
114 * but does for the rest.
116 skb
->protocol
= htons(ETH_P_802_3
);
121 skb
->protocol
= htons(ETH_P_802_2
);
125 * Determine the packet's protocol ID. The rule here is that we
126 * assume 802.3 if the type field is short enough to be a length.
127 * This is normal practice and works for any 'now in use' protocol.
129 * Also, at this point we assume that we ARE dealing exclusively with
130 * VLAN packets, or packets that should be made into VLAN packets based
131 * on a default VLAN ID.
133 * NOTE: Should be similar to ethernet/eth.c.
135 * SANITY NOTE: This method is called when a packet is moving up the stack
136 * towards userland. To get here, it would have already passed
137 * through the ethernet/eth.c eth_type_trans() method.
138 * SANITY NOTE 2: We are referencing to the VLAN_HDR frields, which MAY be
139 * stored UNALIGNED in the memory. RISC systems don't like
140 * such cases very much...
141 * SANITY NOTE 2a: According to Dave Miller & Alexey, it will always be
142 * aligned, so there doesn't need to be any of the unaligned
143 * stuff. It has been commented out now... --Ben
146 int vlan_skb_recv(struct sk_buff
*skb
, struct net_device
*dev
,
147 struct packet_type
*ptype
, struct net_device
*orig_dev
)
149 struct vlan_hdr
*vhdr
;
150 struct net_device_stats
*stats
;
154 skb
= skb_share_check(skb
, GFP_ATOMIC
);
158 if (unlikely(!pskb_may_pull(skb
, VLAN_HLEN
)))
161 vhdr
= (struct vlan_hdr
*)skb
->data
;
162 vlan_tci
= ntohs(vhdr
->h_vlan_TCI
);
163 vlan_id
= vlan_tci
& VLAN_VID_MASK
;
166 skb
->dev
= __find_vlan_dev(dev
, vlan_id
);
168 pr_debug("%s: ERROR: No net_device for VID: %u on dev: %s\n",
169 __func__
, vlan_id
, dev
->name
);
173 skb
->dev
->last_rx
= jiffies
;
175 stats
= &skb
->dev
->stats
;
177 stats
->rx_bytes
+= skb
->len
;
179 skb_pull_rcsum(skb
, VLAN_HLEN
);
181 skb
->priority
= vlan_get_ingress_priority(skb
->dev
, vlan_tci
);
183 pr_debug("%s: priority: %u for TCI: %hu\n",
184 __func__
, skb
->priority
, vlan_tci
);
186 switch (skb
->pkt_type
) {
187 case PACKET_BROADCAST
: /* Yeah, stats collect these together.. */
188 /* stats->broadcast ++; // no such counter :-( */
191 case PACKET_MULTICAST
:
195 case PACKET_OTHERHOST
:
196 /* Our lower layer thinks this is not local, let's make sure.
197 * This allows the VLAN to have a different MAC than the
198 * underlying device, and still route correctly.
200 if (!compare_ether_addr(eth_hdr(skb
)->h_dest
,
202 skb
->pkt_type
= PACKET_HOST
;
208 vlan_set_encap_proto(skb
, vhdr
);
210 skb
= vlan_check_reorder_header(skb
);
218 return NET_RX_SUCCESS
;
228 vlan_dev_get_egress_qos_mask(struct net_device
*dev
, struct sk_buff
*skb
)
230 struct vlan_priority_tci_mapping
*mp
;
232 mp
= vlan_dev_info(dev
)->egress_priority_map
[(skb
->priority
& 0xF)];
234 if (mp
->priority
== skb
->priority
) {
235 return mp
->vlan_qos
; /* This should already be shifted
236 * to mask correctly with the
245 * Create the VLAN header for an arbitrary protocol layer
247 * saddr=NULL means use device source address
248 * daddr=NULL means leave destination address (eg unresolved arp)
250 * This is called when the SKB is moving down the stack towards the
253 static int vlan_dev_hard_header(struct sk_buff
*skb
, struct net_device
*dev
,
255 const void *daddr
, const void *saddr
,
258 struct vlan_hdr
*vhdr
;
261 int build_vlan_header
= 0;
263 pr_debug("%s: skb: %p type: %hx len: %u vlan_id: %hx, daddr: %p\n",
264 __func__
, skb
, type
, len
, vlan_dev_info(dev
)->vlan_id
,
267 if (WARN_ON(skb_headroom(skb
) < dev
->hard_header_len
))
270 /* build vlan header only if re_order_header flag is NOT set. This
271 * fixes some programs that get confused when they see a VLAN device
272 * sending a frame that is VLAN encoded (the consensus is that the VLAN
273 * device should look completely like an Ethernet device when the
274 * REORDER_HEADER flag is set) The drawback to this is some extra
275 * header shuffling in the hard_start_xmit. Users can turn off this
276 * REORDER behaviour with the vconfig tool.
278 if (!(vlan_dev_info(dev
)->flags
& VLAN_FLAG_REORDER_HDR
))
279 build_vlan_header
= 1;
281 if (build_vlan_header
) {
282 vhdr
= (struct vlan_hdr
*) skb_push(skb
, VLAN_HLEN
);
284 /* build the four bytes that make this a VLAN header. */
286 /* Now, construct the second two bytes. This field looks
288 * usr_priority: 3 bits (high bits)
290 * VLAN ID 12 bits (low bits)
293 vlan_tci
= vlan_dev_info(dev
)->vlan_id
;
294 vlan_tci
|= vlan_dev_get_egress_qos_mask(dev
, skb
);
296 vhdr
->h_vlan_TCI
= htons(vlan_tci
);
299 * Set the protocol type. For a packet of type ETH_P_802_3 we
300 * put the length in here instead. It is up to the 802.2
301 * layer to carry protocol information.
304 if (type
!= ETH_P_802_3
)
305 vhdr
->h_vlan_encapsulated_proto
= htons(type
);
307 vhdr
->h_vlan_encapsulated_proto
= htons(len
);
309 skb
->protocol
= htons(ETH_P_8021Q
);
312 /* Before delegating work to the lower layer, enter our MAC-address */
314 saddr
= dev
->dev_addr
;
316 dev
= vlan_dev_info(dev
)->real_dev
;
318 if (build_vlan_header
) {
319 /* Now make the underlying real hard header */
320 rc
= dev_hard_header(skb
, dev
, ETH_P_8021Q
, daddr
, saddr
,
327 /* If here, then we'll just make a normal looking ethernet
328 * frame, but, the hard_start_xmit method will insert the tag
329 * (it has to be able to do this for bridged and other skbs
330 * that don't come down the protocol stack in an orderly manner.
332 rc
= dev_hard_header(skb
, dev
, type
, daddr
, saddr
, len
);
337 static int vlan_dev_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
339 struct net_device_stats
*stats
= &dev
->stats
;
340 struct vlan_ethhdr
*veth
= (struct vlan_ethhdr
*)(skb
->data
);
342 /* Handle non-VLAN frames if they are sent to us, for example by DHCP.
344 * NOTE: THIS ASSUMES DIX ETHERNET, SPECIFICALLY NOT SUPPORTING
345 * OTHER THINGS LIKE FDDI/TokenRing/802.3 SNAPs...
348 if (veth
->h_vlan_proto
!= htons(ETH_P_8021Q
) ||
349 vlan_dev_info(dev
)->flags
& VLAN_FLAG_REORDER_HDR
) {
350 int orig_headroom
= skb_headroom(skb
);
353 /* This is not a VLAN frame...but we can fix that! */
354 vlan_dev_info(dev
)->cnt_encap_on_xmit
++;
356 pr_debug("%s: proto to encap: 0x%hx\n",
357 __func__
, ntohs(veth
->h_vlan_proto
));
358 /* Construct the second two bytes. This field looks something
360 * usr_priority: 3 bits (high bits)
362 * VLAN ID 12 bits (low bits)
364 vlan_tci
= vlan_dev_info(dev
)->vlan_id
;
365 vlan_tci
|= vlan_dev_get_egress_qos_mask(dev
, skb
);
367 skb
= __vlan_put_tag(skb
, vlan_tci
);
373 if (orig_headroom
< VLAN_HLEN
)
374 vlan_dev_info(dev
)->cnt_inc_headroom_on_tx
++;
377 pr_debug("%s: about to send skb: %p to dev: %s\n",
378 __func__
, skb
, skb
->dev
->name
);
379 pr_debug(" " MAC_FMT
" " MAC_FMT
" %4hx %4hx %4hx\n",
380 veth
->h_dest
[0], veth
->h_dest
[1], veth
->h_dest
[2],
381 veth
->h_dest
[3], veth
->h_dest
[4], veth
->h_dest
[5],
382 veth
->h_source
[0], veth
->h_source
[1], veth
->h_source
[2],
383 veth
->h_source
[3], veth
->h_source
[4], veth
->h_source
[5],
384 veth
->h_vlan_proto
, veth
->h_vlan_TCI
,
385 veth
->h_vlan_encapsulated_proto
);
387 stats
->tx_packets
++; /* for statics only */
388 stats
->tx_bytes
+= skb
->len
;
390 skb
->dev
= vlan_dev_info(dev
)->real_dev
;
396 static int vlan_dev_hwaccel_hard_start_xmit(struct sk_buff
*skb
,
397 struct net_device
*dev
)
399 struct net_device_stats
*stats
= &dev
->stats
;
402 /* Construct the second two bytes. This field looks something
404 * usr_priority: 3 bits (high bits)
406 * VLAN ID 12 bits (low bits)
408 vlan_tci
= vlan_dev_info(dev
)->vlan_id
;
409 vlan_tci
|= vlan_dev_get_egress_qos_mask(dev
, skb
);
410 skb
= __vlan_hwaccel_put_tag(skb
, vlan_tci
);
413 stats
->tx_bytes
+= skb
->len
;
415 skb
->dev
= vlan_dev_info(dev
)->real_dev
;
421 static int vlan_dev_change_mtu(struct net_device
*dev
, int new_mtu
)
423 /* TODO: gotta make sure the underlying layer can handle it,
424 * maybe an IFF_VLAN_CAPABLE flag for devices?
426 if (vlan_dev_info(dev
)->real_dev
->mtu
< new_mtu
)
434 void vlan_dev_set_ingress_priority(const struct net_device
*dev
,
435 u32 skb_prio
, u16 vlan_prio
)
437 struct vlan_dev_info
*vlan
= vlan_dev_info(dev
);
439 if (vlan
->ingress_priority_map
[vlan_prio
& 0x7] && !skb_prio
)
440 vlan
->nr_ingress_mappings
--;
441 else if (!vlan
->ingress_priority_map
[vlan_prio
& 0x7] && skb_prio
)
442 vlan
->nr_ingress_mappings
++;
444 vlan
->ingress_priority_map
[vlan_prio
& 0x7] = skb_prio
;
447 int vlan_dev_set_egress_priority(const struct net_device
*dev
,
448 u32 skb_prio
, u16 vlan_prio
)
450 struct vlan_dev_info
*vlan
= vlan_dev_info(dev
);
451 struct vlan_priority_tci_mapping
*mp
= NULL
;
452 struct vlan_priority_tci_mapping
*np
;
453 u32 vlan_qos
= (vlan_prio
<< 13) & 0xE000;
455 /* See if a priority mapping exists.. */
456 mp
= vlan
->egress_priority_map
[skb_prio
& 0xF];
458 if (mp
->priority
== skb_prio
) {
459 if (mp
->vlan_qos
&& !vlan_qos
)
460 vlan
->nr_egress_mappings
--;
461 else if (!mp
->vlan_qos
&& vlan_qos
)
462 vlan
->nr_egress_mappings
++;
463 mp
->vlan_qos
= vlan_qos
;
469 /* Create a new mapping then. */
470 mp
= vlan
->egress_priority_map
[skb_prio
& 0xF];
471 np
= kmalloc(sizeof(struct vlan_priority_tci_mapping
), GFP_KERNEL
);
476 np
->priority
= skb_prio
;
477 np
->vlan_qos
= vlan_qos
;
478 vlan
->egress_priority_map
[skb_prio
& 0xF] = np
;
480 vlan
->nr_egress_mappings
++;
484 /* Flags are defined in the vlan_flags enum in include/linux/if_vlan.h file. */
485 int vlan_dev_change_flags(const struct net_device
*dev
, u32 flags
, u32 mask
)
487 struct vlan_dev_info
*vlan
= vlan_dev_info(dev
);
488 u32 old_flags
= vlan
->flags
;
490 if (mask
& ~(VLAN_FLAG_REORDER_HDR
| VLAN_FLAG_GVRP
))
493 vlan
->flags
= (old_flags
& ~mask
) | (flags
& mask
);
495 if (netif_running(dev
) && (vlan
->flags
^ old_flags
) & VLAN_FLAG_GVRP
) {
496 if (vlan
->flags
& VLAN_FLAG_GVRP
)
497 vlan_gvrp_request_join(dev
);
499 vlan_gvrp_request_leave(dev
);
504 void vlan_dev_get_realdev_name(const struct net_device
*dev
, char *result
)
506 strncpy(result
, vlan_dev_info(dev
)->real_dev
->name
, 23);
509 static int vlan_dev_open(struct net_device
*dev
)
511 struct vlan_dev_info
*vlan
= vlan_dev_info(dev
);
512 struct net_device
*real_dev
= vlan
->real_dev
;
515 if (!(real_dev
->flags
& IFF_UP
))
518 if (compare_ether_addr(dev
->dev_addr
, real_dev
->dev_addr
)) {
519 err
= dev_unicast_add(real_dev
, dev
->dev_addr
, ETH_ALEN
);
524 if (dev
->flags
& IFF_ALLMULTI
) {
525 err
= dev_set_allmulti(real_dev
, 1);
529 if (dev
->flags
& IFF_PROMISC
) {
530 err
= dev_set_promiscuity(real_dev
, 1);
535 memcpy(vlan
->real_dev_addr
, real_dev
->dev_addr
, ETH_ALEN
);
537 if (vlan
->flags
& VLAN_FLAG_GVRP
)
538 vlan_gvrp_request_join(dev
);
543 if (dev
->flags
& IFF_ALLMULTI
)
544 dev_set_allmulti(real_dev
, -1);
546 if (compare_ether_addr(dev
->dev_addr
, real_dev
->dev_addr
))
547 dev_unicast_delete(real_dev
, dev
->dev_addr
, ETH_ALEN
);
552 static int vlan_dev_stop(struct net_device
*dev
)
554 struct vlan_dev_info
*vlan
= vlan_dev_info(dev
);
555 struct net_device
*real_dev
= vlan
->real_dev
;
557 if (vlan
->flags
& VLAN_FLAG_GVRP
)
558 vlan_gvrp_request_leave(dev
);
560 dev_mc_unsync(real_dev
, dev
);
561 dev_unicast_unsync(real_dev
, dev
);
562 if (dev
->flags
& IFF_ALLMULTI
)
563 dev_set_allmulti(real_dev
, -1);
564 if (dev
->flags
& IFF_PROMISC
)
565 dev_set_promiscuity(real_dev
, -1);
567 if (compare_ether_addr(dev
->dev_addr
, real_dev
->dev_addr
))
568 dev_unicast_delete(real_dev
, dev
->dev_addr
, dev
->addr_len
);
573 static int vlan_dev_set_mac_address(struct net_device
*dev
, void *p
)
575 struct net_device
*real_dev
= vlan_dev_info(dev
)->real_dev
;
576 struct sockaddr
*addr
= p
;
579 if (!is_valid_ether_addr(addr
->sa_data
))
580 return -EADDRNOTAVAIL
;
582 if (!(dev
->flags
& IFF_UP
))
585 if (compare_ether_addr(addr
->sa_data
, real_dev
->dev_addr
)) {
586 err
= dev_unicast_add(real_dev
, addr
->sa_data
, ETH_ALEN
);
591 if (compare_ether_addr(dev
->dev_addr
, real_dev
->dev_addr
))
592 dev_unicast_delete(real_dev
, dev
->dev_addr
, ETH_ALEN
);
595 memcpy(dev
->dev_addr
, addr
->sa_data
, ETH_ALEN
);
599 static int vlan_dev_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
601 struct net_device
*real_dev
= vlan_dev_info(dev
)->real_dev
;
603 int err
= -EOPNOTSUPP
;
605 strncpy(ifrr
.ifr_name
, real_dev
->name
, IFNAMSIZ
);
606 ifrr
.ifr_ifru
= ifr
->ifr_ifru
;
612 if (real_dev
->do_ioctl
&& netif_device_present(real_dev
))
613 err
= real_dev
->do_ioctl(real_dev
, &ifrr
, cmd
);
618 ifr
->ifr_ifru
= ifrr
.ifr_ifru
;
623 static void vlan_dev_change_rx_flags(struct net_device
*dev
, int change
)
625 struct net_device
*real_dev
= vlan_dev_info(dev
)->real_dev
;
627 if (change
& IFF_ALLMULTI
)
628 dev_set_allmulti(real_dev
, dev
->flags
& IFF_ALLMULTI
? 1 : -1);
629 if (change
& IFF_PROMISC
)
630 dev_set_promiscuity(real_dev
, dev
->flags
& IFF_PROMISC
? 1 : -1);
633 static void vlan_dev_set_rx_mode(struct net_device
*vlan_dev
)
635 dev_mc_sync(vlan_dev_info(vlan_dev
)->real_dev
, vlan_dev
);
636 dev_unicast_sync(vlan_dev_info(vlan_dev
)->real_dev
, vlan_dev
);
640 * vlan network devices have devices nesting below it, and are a special
641 * "super class" of normal network devices; split their locks off into a
642 * separate class since they always nest.
644 static struct lock_class_key vlan_netdev_xmit_lock_key
;
646 static void vlan_dev_set_lockdep_one(struct netdev_queue
*txq
,
649 lockdep_set_class_and_subclass(&txq
->_xmit_lock
,
650 &vlan_netdev_xmit_lock_key
, subclass
);
653 static void vlan_dev_set_lockdep_class(struct net_device
*dev
, int subclass
)
655 vlan_dev_set_lockdep_one(&dev
->tx_queue
, subclass
);
658 static const struct header_ops vlan_header_ops
= {
659 .create
= vlan_dev_hard_header
,
660 .rebuild
= vlan_dev_rebuild_header
,
661 .parse
= eth_header_parse
,
664 static int vlan_dev_init(struct net_device
*dev
)
666 struct net_device
*real_dev
= vlan_dev_info(dev
)->real_dev
;
669 /* IFF_BROADCAST|IFF_MULTICAST; ??? */
670 dev
->flags
= real_dev
->flags
& ~(IFF_UP
| IFF_PROMISC
| IFF_ALLMULTI
);
671 dev
->iflink
= real_dev
->ifindex
;
672 dev
->state
= (real_dev
->state
& ((1<<__LINK_STATE_NOCARRIER
) |
673 (1<<__LINK_STATE_DORMANT
))) |
674 (1<<__LINK_STATE_PRESENT
);
676 dev
->features
|= real_dev
->features
& real_dev
->vlan_features
;
678 /* ipv6 shared card related stuff */
679 dev
->dev_id
= real_dev
->dev_id
;
681 if (is_zero_ether_addr(dev
->dev_addr
))
682 memcpy(dev
->dev_addr
, real_dev
->dev_addr
, dev
->addr_len
);
683 if (is_zero_ether_addr(dev
->broadcast
))
684 memcpy(dev
->broadcast
, real_dev
->broadcast
, dev
->addr_len
);
686 if (real_dev
->features
& NETIF_F_HW_VLAN_TX
) {
687 dev
->header_ops
= real_dev
->header_ops
;
688 dev
->hard_header_len
= real_dev
->hard_header_len
;
689 dev
->hard_start_xmit
= vlan_dev_hwaccel_hard_start_xmit
;
691 dev
->header_ops
= &vlan_header_ops
;
692 dev
->hard_header_len
= real_dev
->hard_header_len
+ VLAN_HLEN
;
693 dev
->hard_start_xmit
= vlan_dev_hard_start_xmit
;
696 if (is_vlan_dev(real_dev
))
699 vlan_dev_set_lockdep_class(dev
, subclass
);
703 static void vlan_dev_uninit(struct net_device
*dev
)
705 struct vlan_priority_tci_mapping
*pm
;
706 struct vlan_dev_info
*vlan
= vlan_dev_info(dev
);
709 for (i
= 0; i
< ARRAY_SIZE(vlan
->egress_priority_map
); i
++) {
710 while ((pm
= vlan
->egress_priority_map
[i
]) != NULL
) {
711 vlan
->egress_priority_map
[i
] = pm
->next
;
717 static u32
vlan_ethtool_get_rx_csum(struct net_device
*dev
)
719 const struct vlan_dev_info
*vlan
= vlan_dev_info(dev
);
720 struct net_device
*real_dev
= vlan
->real_dev
;
722 if (real_dev
->ethtool_ops
== NULL
||
723 real_dev
->ethtool_ops
->get_rx_csum
== NULL
)
725 return real_dev
->ethtool_ops
->get_rx_csum(real_dev
);
728 static u32
vlan_ethtool_get_flags(struct net_device
*dev
)
730 const struct vlan_dev_info
*vlan
= vlan_dev_info(dev
);
731 struct net_device
*real_dev
= vlan
->real_dev
;
733 if (!(real_dev
->features
& NETIF_F_HW_VLAN_RX
) ||
734 real_dev
->ethtool_ops
== NULL
||
735 real_dev
->ethtool_ops
->get_flags
== NULL
)
737 return real_dev
->ethtool_ops
->get_flags(real_dev
);
740 static const struct ethtool_ops vlan_ethtool_ops
= {
741 .get_link
= ethtool_op_get_link
,
742 .get_rx_csum
= vlan_ethtool_get_rx_csum
,
743 .get_flags
= vlan_ethtool_get_flags
,
746 void vlan_setup(struct net_device
*dev
)
750 dev
->priv_flags
|= IFF_802_1Q_VLAN
;
751 dev
->tx_queue_len
= 0;
753 dev
->change_mtu
= vlan_dev_change_mtu
;
754 dev
->init
= vlan_dev_init
;
755 dev
->uninit
= vlan_dev_uninit
;
756 dev
->open
= vlan_dev_open
;
757 dev
->stop
= vlan_dev_stop
;
758 dev
->set_mac_address
= vlan_dev_set_mac_address
;
759 dev
->set_rx_mode
= vlan_dev_set_rx_mode
;
760 dev
->set_multicast_list
= vlan_dev_set_rx_mode
;
761 dev
->change_rx_flags
= vlan_dev_change_rx_flags
;
762 dev
->do_ioctl
= vlan_dev_ioctl
;
763 dev
->destructor
= free_netdev
;
764 dev
->ethtool_ops
= &vlan_ethtool_ops
;
766 memset(dev
->broadcast
, 0, ETH_ALEN
);