diff options
author | Patrick Ohly <patrick.ohly@intel.com> | 2009-02-12 00:03:43 -0500 |
---|---|---|
committer | David S. Miller <davem@davemloft.net> | 2009-02-16 02:13:27 -0500 |
commit | 33af6bcc005a826726b48e8775df5d58112bc10b (patch) | |
tree | f56d49b32b2183e076741b590bb7ebd797d53c99 /drivers/net/igb/igb_main.c | |
parent | c6cb090ba7cd88aec03718dab76e4dad56862cae (diff) |
igb: use timecompare to implement hardware time stamping
Both TX and RX hardware time stamping are implemented. Due to
hardware limitations it is not possible to verify reliably which
packet was time stamped when multiple were pending for sending; this
could be solved by only allowing one packet marked for hardware time
stamping into the queue (not implemented yet).
RX time stamping relies on the flag in the packet descriptor which
marks packets that were time stamped. In "all packet" mode this flag
is not set. TODO: also support that mode (even though it'll suffer
from race conditions).
Signed-off-by: John Ronciak <john.ronciak@intel.com>
Signed-off-by: Patrick Ohly <patrick.ohly@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
Diffstat (limited to 'drivers/net/igb/igb_main.c')
-rw-r--r-- | drivers/net/igb/igb_main.c | 266 |
1 files changed, 258 insertions, 8 deletions
diff --git a/drivers/net/igb/igb_main.c b/drivers/net/igb/igb_main.c index 90090bb26044..f9d576bfef90 100644 --- a/drivers/net/igb/igb_main.c +++ b/drivers/net/igb/igb_main.c | |||
@@ -250,7 +250,8 @@ static char *igb_get_time_str(struct igb_adapter *adapter, | |||
250 | delta = timespec_sub(nic, sys); | 250 | delta = timespec_sub(nic, sys); |
251 | 251 | ||
252 | sprintf(buffer, | 252 | sprintf(buffer, |
253 | "NIC %ld.%09lus, SYS %ld.%09lus, NIC-SYS %lds + %09luns", | 253 | "HW %llu, NIC %ld.%09lus, SYS %ld.%09lus, NIC-SYS %lds + %09luns", |
254 | hw, | ||
254 | (long)nic.tv_sec, nic.tv_nsec, | 255 | (long)nic.tv_sec, nic.tv_nsec, |
255 | (long)sys.tv_sec, sys.tv_nsec, | 256 | (long)sys.tv_sec, sys.tv_nsec, |
256 | (long)delta.tv_sec, delta.tv_nsec); | 257 | (long)delta.tv_sec, delta.tv_nsec); |
@@ -1400,6 +1401,18 @@ static int __devinit igb_probe(struct pci_dev *pdev, | |||
1400 | &adapter->cycles, | 1401 | &adapter->cycles, |
1401 | ktime_to_ns(ktime_get_real())); | 1402 | ktime_to_ns(ktime_get_real())); |
1402 | 1403 | ||
1404 | /* | ||
1405 | * Synchronize our NIC clock against system wall clock. NIC | ||
1406 | * time stamp reading requires ~3us per sample, each sample | ||
1407 | * was pretty stable even under load => only require 10 | ||
1408 | * samples for each offset comparison. | ||
1409 | */ | ||
1410 | memset(&adapter->compare, 0, sizeof(adapter->compare)); | ||
1411 | adapter->compare.source = &adapter->clock; | ||
1412 | adapter->compare.target = ktime_get_real; | ||
1413 | adapter->compare.num_samples = 10; | ||
1414 | timecompare_update(&adapter->compare, 0); | ||
1415 | |||
1403 | #ifdef DEBUG | 1416 | #ifdef DEBUG |
1404 | { | 1417 | { |
1405 | char buffer[160]; | 1418 | char buffer[160]; |
@@ -2748,6 +2761,7 @@ set_itr_now: | |||
2748 | #define IGB_TX_FLAGS_VLAN 0x00000002 | 2761 | #define IGB_TX_FLAGS_VLAN 0x00000002 |
2749 | #define IGB_TX_FLAGS_TSO 0x00000004 | 2762 | #define IGB_TX_FLAGS_TSO 0x00000004 |
2750 | #define IGB_TX_FLAGS_IPV4 0x00000008 | 2763 | #define IGB_TX_FLAGS_IPV4 0x00000008 |
2764 | #define IGB_TX_FLAGS_TSTAMP 0x00000010 | ||
2751 | #define IGB_TX_FLAGS_VLAN_MASK 0xffff0000 | 2765 | #define IGB_TX_FLAGS_VLAN_MASK 0xffff0000 |
2752 | #define IGB_TX_FLAGS_VLAN_SHIFT 16 | 2766 | #define IGB_TX_FLAGS_VLAN_SHIFT 16 |
2753 | 2767 | ||
@@ -2975,6 +2989,9 @@ static inline void igb_tx_queue_adv(struct igb_adapter *adapter, | |||
2975 | if (tx_flags & IGB_TX_FLAGS_VLAN) | 2989 | if (tx_flags & IGB_TX_FLAGS_VLAN) |
2976 | cmd_type_len |= E1000_ADVTXD_DCMD_VLE; | 2990 | cmd_type_len |= E1000_ADVTXD_DCMD_VLE; |
2977 | 2991 | ||
2992 | if (tx_flags & IGB_TX_FLAGS_TSTAMP) | ||
2993 | cmd_type_len |= E1000_ADVTXD_MAC_TSTAMP; | ||
2994 | |||
2978 | if (tx_flags & IGB_TX_FLAGS_TSO) { | 2995 | if (tx_flags & IGB_TX_FLAGS_TSO) { |
2979 | cmd_type_len |= E1000_ADVTXD_DCMD_TSE; | 2996 | cmd_type_len |= E1000_ADVTXD_DCMD_TSE; |
2980 | 2997 | ||
@@ -3065,6 +3082,7 @@ static int igb_xmit_frame_ring_adv(struct sk_buff *skb, | |||
3065 | unsigned int tx_flags = 0; | 3082 | unsigned int tx_flags = 0; |
3066 | u8 hdr_len = 0; | 3083 | u8 hdr_len = 0; |
3067 | int tso = 0; | 3084 | int tso = 0; |
3085 | union skb_shared_tx *shtx; | ||
3068 | 3086 | ||
3069 | if (test_bit(__IGB_DOWN, &adapter->state)) { | 3087 | if (test_bit(__IGB_DOWN, &adapter->state)) { |
3070 | dev_kfree_skb_any(skb); | 3088 | dev_kfree_skb_any(skb); |
@@ -3085,7 +3103,29 @@ static int igb_xmit_frame_ring_adv(struct sk_buff *skb, | |||
3085 | /* this is a hard error */ | 3103 | /* this is a hard error */ |
3086 | return NETDEV_TX_BUSY; | 3104 | return NETDEV_TX_BUSY; |
3087 | } | 3105 | } |
3088 | skb_orphan(skb); | 3106 | |
3107 | /* | ||
3108 | * TODO: check that there currently is no other packet with | ||
3109 | * time stamping in the queue | ||
3110 | * | ||
3111 | * When doing time stamping, keep the connection to the socket | ||
3112 | * a while longer: it is still needed by skb_hwtstamp_tx(), | ||
3113 | * called either in igb_tx_hwtstamp() or by our caller when | ||
3114 | * doing software time stamping. | ||
3115 | */ | ||
3116 | shtx = skb_tx(skb); | ||
3117 | if (unlikely(shtx->hardware)) { | ||
3118 | shtx->in_progress = 1; | ||
3119 | tx_flags |= IGB_TX_FLAGS_TSTAMP; | ||
3120 | } else if (likely(!shtx->software)) { | ||
3121 | /* | ||
3122 | * TODO: can this be solved in dev.c:dev_hard_start_xmit()? | ||
3123 | * There are probably unmodified driver which do something | ||
3124 | * like this and thus don't work in combination with | ||
3125 | * SOF_TIMESTAMPING_TX_SOFTWARE. | ||
3126 | */ | ||
3127 | skb_orphan(skb); | ||
3128 | } | ||
3089 | 3129 | ||
3090 | if (adapter->vlgrp && vlan_tx_tag_present(skb)) { | 3130 | if (adapter->vlgrp && vlan_tx_tag_present(skb)) { |
3091 | tx_flags |= IGB_TX_FLAGS_VLAN; | 3131 | tx_flags |= IGB_TX_FLAGS_VLAN; |
@@ -3744,6 +3784,43 @@ static int igb_clean_rx_ring_msix(struct napi_struct *napi, int budget) | |||
3744 | } | 3784 | } |
3745 | 3785 | ||
3746 | /** | 3786 | /** |
3787 | * igb_hwtstamp - utility function which checks for TX time stamp | ||
3788 | * @adapter: board private structure | ||
3789 | * @skb: packet that was just sent | ||
3790 | * | ||
3791 | * If we were asked to do hardware stamping and such a time stamp is | ||
3792 | * available, then it must have been for this skb here because we only | ||
3793 | * allow only one such packet into the queue. | ||
3794 | */ | ||
3795 | static void igb_tx_hwtstamp(struct igb_adapter *adapter, struct sk_buff *skb) | ||
3796 | { | ||
3797 | union skb_shared_tx *shtx = skb_tx(skb); | ||
3798 | struct e1000_hw *hw = &adapter->hw; | ||
3799 | |||
3800 | if (unlikely(shtx->hardware)) { | ||
3801 | u32 valid = rd32(E1000_TSYNCTXCTL) & E1000_TSYNCTXCTL_VALID; | ||
3802 | if (valid) { | ||
3803 | u64 regval = rd32(E1000_TXSTMPL); | ||
3804 | u64 ns; | ||
3805 | struct skb_shared_hwtstamps shhwtstamps; | ||
3806 | |||
3807 | memset(&shhwtstamps, 0, sizeof(shhwtstamps)); | ||
3808 | regval |= (u64)rd32(E1000_TXSTMPH) << 32; | ||
3809 | ns = timecounter_cyc2time(&adapter->clock, | ||
3810 | regval); | ||
3811 | timecompare_update(&adapter->compare, ns); | ||
3812 | shhwtstamps.hwtstamp = ns_to_ktime(ns); | ||
3813 | shhwtstamps.syststamp = | ||
3814 | timecompare_transform(&adapter->compare, ns); | ||
3815 | skb_tstamp_tx(skb, &shhwtstamps); | ||
3816 | } | ||
3817 | |||
3818 | /* delayed orphaning: skb_tstamp_tx() needs the socket */ | ||
3819 | skb_orphan(skb); | ||
3820 | } | ||
3821 | } | ||
3822 | |||
3823 | /** | ||
3747 | * igb_clean_tx_irq - Reclaim resources after transmit completes | 3824 | * igb_clean_tx_irq - Reclaim resources after transmit completes |
3748 | * @adapter: board private structure | 3825 | * @adapter: board private structure |
3749 | * returns true if ring is completely cleaned | 3826 | * returns true if ring is completely cleaned |
@@ -3781,6 +3858,8 @@ static bool igb_clean_tx_irq(struct igb_ring *tx_ring) | |||
3781 | skb->len; | 3858 | skb->len; |
3782 | total_packets += segs; | 3859 | total_packets += segs; |
3783 | total_bytes += bytecount; | 3860 | total_bytes += bytecount; |
3861 | |||
3862 | igb_tx_hwtstamp(adapter, skb); | ||
3784 | } | 3863 | } |
3785 | 3864 | ||
3786 | igb_unmap_and_free_tx_resource(adapter, buffer_info); | 3865 | igb_unmap_and_free_tx_resource(adapter, buffer_info); |
@@ -3914,6 +3993,7 @@ static bool igb_clean_rx_irq_adv(struct igb_ring *rx_ring, | |||
3914 | { | 3993 | { |
3915 | struct igb_adapter *adapter = rx_ring->adapter; | 3994 | struct igb_adapter *adapter = rx_ring->adapter; |
3916 | struct net_device *netdev = adapter->netdev; | 3995 | struct net_device *netdev = adapter->netdev; |
3996 | struct e1000_hw *hw = &adapter->hw; | ||
3917 | struct pci_dev *pdev = adapter->pdev; | 3997 | struct pci_dev *pdev = adapter->pdev; |
3918 | union e1000_adv_rx_desc *rx_desc , *next_rxd; | 3998 | union e1000_adv_rx_desc *rx_desc , *next_rxd; |
3919 | struct igb_buffer *buffer_info , *next_buffer; | 3999 | struct igb_buffer *buffer_info , *next_buffer; |
@@ -4006,6 +4086,47 @@ static bool igb_clean_rx_irq_adv(struct igb_ring *rx_ring, | |||
4006 | goto next_desc; | 4086 | goto next_desc; |
4007 | } | 4087 | } |
4008 | send_up: | 4088 | send_up: |
4089 | /* | ||
4090 | * If this bit is set, then the RX registers contain | ||
4091 | * the time stamp. No other packet will be time | ||
4092 | * stamped until we read these registers, so read the | ||
4093 | * registers to make them available again. Because | ||
4094 | * only one packet can be time stamped at a time, we | ||
4095 | * know that the register values must belong to this | ||
4096 | * one here and therefore we don't need to compare | ||
4097 | * any of the additional attributes stored for it. | ||
4098 | * | ||
4099 | * If nothing went wrong, then it should have a | ||
4100 | * skb_shared_tx that we can turn into a | ||
4101 | * skb_shared_hwtstamps. | ||
4102 | * | ||
4103 | * TODO: can time stamping be triggered (thus locking | ||
4104 | * the registers) without the packet reaching this point | ||
4105 | * here? In that case RX time stamping would get stuck. | ||
4106 | * | ||
4107 | * TODO: in "time stamp all packets" mode this bit is | ||
4108 | * not set. Need a global flag for this mode and then | ||
4109 | * always read the registers. Cannot be done without | ||
4110 | * a race condition. | ||
4111 | */ | ||
4112 | if (unlikely(staterr & E1000_RXD_STAT_TS)) { | ||
4113 | u64 regval; | ||
4114 | u64 ns; | ||
4115 | struct skb_shared_hwtstamps *shhwtstamps = | ||
4116 | skb_hwtstamps(skb); | ||
4117 | |||
4118 | WARN(!(rd32(E1000_TSYNCRXCTL) & E1000_TSYNCRXCTL_VALID), | ||
4119 | "igb: no RX time stamp available for time stamped packet"); | ||
4120 | regval = rd32(E1000_RXSTMPL); | ||
4121 | regval |= (u64)rd32(E1000_RXSTMPH) << 32; | ||
4122 | ns = timecounter_cyc2time(&adapter->clock, regval); | ||
4123 | timecompare_update(&adapter->compare, ns); | ||
4124 | memset(shhwtstamps, 0, sizeof(*shhwtstamps)); | ||
4125 | shhwtstamps->hwtstamp = ns_to_ktime(ns); | ||
4126 | shhwtstamps->syststamp = | ||
4127 | timecompare_transform(&adapter->compare, ns); | ||
4128 | } | ||
4129 | |||
4009 | if (staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK) { | 4130 | if (staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK) { |
4010 | dev_kfree_skb_irq(skb); | 4131 | dev_kfree_skb_irq(skb); |
4011 | goto next_desc; | 4132 | goto next_desc; |
@@ -4188,13 +4309,33 @@ static int igb_mii_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd) | |||
4188 | * @ifreq: | 4309 | * @ifreq: |
4189 | * @cmd: | 4310 | * @cmd: |
4190 | * | 4311 | * |
4191 | * Currently cannot enable any kind of hardware time stamping, but | 4312 | * Outgoing time stamping can be enabled and disabled. Play nice and |
4192 | * supports SIOCSHWTSTAMP in general. | 4313 | * disable it when requested, although it shouldn't case any overhead |
4314 | * when no packet needs it. At most one packet in the queue may be | ||
4315 | * marked for time stamping, otherwise it would be impossible to tell | ||
4316 | * for sure to which packet the hardware time stamp belongs. | ||
4317 | * | ||
4318 | * Incoming time stamping has to be configured via the hardware | ||
4319 | * filters. Not all combinations are supported, in particular event | ||
4320 | * type has to be specified. Matching the kind of event packet is | ||
4321 | * not supported, with the exception of "all V2 events regardless of | ||
4322 | * level 2 or 4". | ||
4323 | * | ||
4193 | **/ | 4324 | **/ |
4194 | static int igb_hwtstamp_ioctl(struct net_device *netdev, | 4325 | static int igb_hwtstamp_ioctl(struct net_device *netdev, |
4195 | struct ifreq *ifr, int cmd) | 4326 | struct ifreq *ifr, int cmd) |
4196 | { | 4327 | { |
4328 | struct igb_adapter *adapter = netdev_priv(netdev); | ||
4329 | struct e1000_hw *hw = &adapter->hw; | ||
4197 | struct hwtstamp_config config; | 4330 | struct hwtstamp_config config; |
4331 | u32 tsync_tx_ctl_bit = E1000_TSYNCTXCTL_ENABLED; | ||
4332 | u32 tsync_rx_ctl_bit = E1000_TSYNCRXCTL_ENABLED; | ||
4333 | u32 tsync_rx_ctl_type = 0; | ||
4334 | u32 tsync_rx_cfg = 0; | ||
4335 | int is_l4 = 0; | ||
4336 | int is_l2 = 0; | ||
4337 | short port = 319; /* PTP */ | ||
4338 | u32 regval; | ||
4198 | 4339 | ||
4199 | if (copy_from_user(&config, ifr->ifr_data, sizeof(config))) | 4340 | if (copy_from_user(&config, ifr->ifr_data, sizeof(config))) |
4200 | return -EFAULT; | 4341 | return -EFAULT; |
@@ -4203,11 +4344,120 @@ static int igb_hwtstamp_ioctl(struct net_device *netdev, | |||
4203 | if (config.flags) | 4344 | if (config.flags) |
4204 | return -EINVAL; | 4345 | return -EINVAL; |
4205 | 4346 | ||
4206 | if (config.tx_type == HWTSTAMP_TX_OFF && | 4347 | switch (config.tx_type) { |
4207 | config.rx_filter == HWTSTAMP_FILTER_NONE) | 4348 | case HWTSTAMP_TX_OFF: |
4208 | return 0; | 4349 | tsync_tx_ctl_bit = 0; |
4350 | break; | ||
4351 | case HWTSTAMP_TX_ON: | ||
4352 | tsync_tx_ctl_bit = E1000_TSYNCTXCTL_ENABLED; | ||
4353 | break; | ||
4354 | default: | ||
4355 | return -ERANGE; | ||
4356 | } | ||
4357 | |||
4358 | switch (config.rx_filter) { | ||
4359 | case HWTSTAMP_FILTER_NONE: | ||
4360 | tsync_rx_ctl_bit = 0; | ||
4361 | break; | ||
4362 | case HWTSTAMP_FILTER_PTP_V1_L4_EVENT: | ||
4363 | case HWTSTAMP_FILTER_PTP_V2_L4_EVENT: | ||
4364 | case HWTSTAMP_FILTER_PTP_V2_L2_EVENT: | ||
4365 | case HWTSTAMP_FILTER_ALL: | ||
4366 | /* | ||
4367 | * register TSYNCRXCFG must be set, therefore it is not | ||
4368 | * possible to time stamp both Sync and Delay_Req messages | ||
4369 | * => fall back to time stamping all packets | ||
4370 | */ | ||
4371 | tsync_rx_ctl_type = E1000_TSYNCRXCTL_TYPE_ALL; | ||
4372 | config.rx_filter = HWTSTAMP_FILTER_ALL; | ||
4373 | break; | ||
4374 | case HWTSTAMP_FILTER_PTP_V1_L4_SYNC: | ||
4375 | tsync_rx_ctl_type = E1000_TSYNCRXCTL_TYPE_L4_V1; | ||
4376 | tsync_rx_cfg = E1000_TSYNCRXCFG_PTP_V1_SYNC_MESSAGE; | ||
4377 | is_l4 = 1; | ||
4378 | break; | ||
4379 | case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ: | ||
4380 | tsync_rx_ctl_type = E1000_TSYNCRXCTL_TYPE_L4_V1; | ||
4381 | tsync_rx_cfg = E1000_TSYNCRXCFG_PTP_V1_DELAY_REQ_MESSAGE; | ||
4382 | is_l4 = 1; | ||
4383 | break; | ||
4384 | case HWTSTAMP_FILTER_PTP_V2_L2_SYNC: | ||
4385 | case HWTSTAMP_FILTER_PTP_V2_L4_SYNC: | ||
4386 | tsync_rx_ctl_type = E1000_TSYNCRXCTL_TYPE_L2_L4_V2; | ||
4387 | tsync_rx_cfg = E1000_TSYNCRXCFG_PTP_V2_SYNC_MESSAGE; | ||
4388 | is_l2 = 1; | ||
4389 | is_l4 = 1; | ||
4390 | config.rx_filter = HWTSTAMP_FILTER_SOME; | ||
4391 | break; | ||
4392 | case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ: | ||
4393 | case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ: | ||
4394 | tsync_rx_ctl_type = E1000_TSYNCRXCTL_TYPE_L2_L4_V2; | ||
4395 | tsync_rx_cfg = E1000_TSYNCRXCFG_PTP_V2_DELAY_REQ_MESSAGE; | ||
4396 | is_l2 = 1; | ||
4397 | is_l4 = 1; | ||
4398 | config.rx_filter = HWTSTAMP_FILTER_SOME; | ||
4399 | break; | ||
4400 | case HWTSTAMP_FILTER_PTP_V2_EVENT: | ||
4401 | case HWTSTAMP_FILTER_PTP_V2_SYNC: | ||
4402 | case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ: | ||
4403 | tsync_rx_ctl_type = E1000_TSYNCRXCTL_TYPE_EVENT_V2; | ||
4404 | config.rx_filter = HWTSTAMP_FILTER_PTP_V2_EVENT; | ||
4405 | is_l2 = 1; | ||
4406 | break; | ||
4407 | default: | ||
4408 | return -ERANGE; | ||
4409 | } | ||
4410 | |||
4411 | /* enable/disable TX */ | ||
4412 | regval = rd32(E1000_TSYNCTXCTL); | ||
4413 | regval = (regval & ~E1000_TSYNCTXCTL_ENABLED) | tsync_tx_ctl_bit; | ||
4414 | wr32(E1000_TSYNCTXCTL, regval); | ||
4415 | |||
4416 | /* enable/disable RX, define which PTP packets are time stamped */ | ||
4417 | regval = rd32(E1000_TSYNCRXCTL); | ||
4418 | regval = (regval & ~E1000_TSYNCRXCTL_ENABLED) | tsync_rx_ctl_bit; | ||
4419 | regval = (regval & ~0xE) | tsync_rx_ctl_type; | ||
4420 | wr32(E1000_TSYNCRXCTL, regval); | ||
4421 | wr32(E1000_TSYNCRXCFG, tsync_rx_cfg); | ||
4422 | |||
4423 | /* | ||
4424 | * Ethertype Filter Queue Filter[0][15:0] = 0x88F7 | ||
4425 | * (Ethertype to filter on) | ||
4426 | * Ethertype Filter Queue Filter[0][26] = 0x1 (Enable filter) | ||
4427 | * Ethertype Filter Queue Filter[0][30] = 0x1 (Enable Timestamping) | ||
4428 | */ | ||
4429 | wr32(E1000_ETQF0, is_l2 ? 0x440088f7 : 0); | ||
4430 | |||
4431 | /* L4 Queue Filter[0]: only filter by source and destination port */ | ||
4432 | wr32(E1000_SPQF0, htons(port)); | ||
4433 | wr32(E1000_IMIREXT(0), is_l4 ? | ||
4434 | ((1<<12) | (1<<19) /* bypass size and control flags */) : 0); | ||
4435 | wr32(E1000_IMIR(0), is_l4 ? | ||
4436 | (htons(port) | ||
4437 | | (0<<16) /* immediate interrupt disabled */ | ||
4438 | | 0 /* (1<<17) bit cleared: do not bypass | ||
4439 | destination port check */) | ||
4440 | : 0); | ||
4441 | wr32(E1000_FTQF0, is_l4 ? | ||
4442 | (0x11 /* UDP */ | ||
4443 | | (1<<15) /* VF not compared */ | ||
4444 | | (1<<27) /* Enable Timestamping */ | ||
4445 | | (7<<28) /* only source port filter enabled, | ||
4446 | source/target address and protocol | ||
4447 | masked */) | ||
4448 | : ((1<<15) | (15<<28) /* all mask bits set = filter not | ||
4449 | enabled */)); | ||
4450 | |||
4451 | wrfl(); | ||
4452 | |||
4453 | adapter->hwtstamp_config = config; | ||
4454 | |||
4455 | /* clear TX/RX time stamp registers, just to be sure */ | ||
4456 | regval = rd32(E1000_TXSTMPH); | ||
4457 | regval = rd32(E1000_RXSTMPH); | ||
4209 | 4458 | ||
4210 | return -ERANGE; | 4459 | return copy_to_user(ifr->ifr_data, &config, sizeof(config)) ? |
4460 | -EFAULT : 0; | ||
4211 | } | 4461 | } |
4212 | 4462 | ||
4213 | /** | 4463 | /** |