mlx4: /dev/ -> /dev_vfs/
[akaros.git] / kern / drivers / net / mlx4 / en_clock.c
1 /*
2  * Copyright (c) 2012 Mellanox Technologies. All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  *
32  */
33
34 #include <linux/mlx4/device.h>
35
36 #include "mlx4_en.h"
37
38 #if 0 // AKAROS_PORT
39 /* mlx4_en_read_clock - read raw cycle counter (to be used by time counter)
40  */
41 static uint64_t mlx4_en_read_clock(const struct cyclecounter *tc)
42 {
43         struct mlx4_en_dev *mdev =
44                 container_of(tc, struct mlx4_en_dev, cycles);
45         struct mlx4_dev *dev = mdev->dev;
46
47         return mlx4_read_clock(dev) & tc->mask;
48 }
49 #endif
50
51 uint64_t mlx4_en_get_cqe_ts(struct mlx4_cqe *cqe)
52 {
53         panic("Disabled");
54 #if 0 // AKAROS_PORT
55         uint64_t hi, lo;
56         struct mlx4_ts_cqe *ts_cqe = (struct mlx4_ts_cqe *)cqe;
57
58         lo = (uint64_t)be16_to_cpu(ts_cqe->timestamp_lo);
59         hi = ((uint64_t)be32_to_cpu(ts_cqe->timestamp_hi) + !lo) << 16;
60
61         return hi | lo;
62 #endif
63 }
64
65 void mlx4_en_fill_hwtstamps(struct mlx4_en_dev *mdev,
66                             struct skb_shared_hwtstamps *hwts,
67                             uint64_t timestamp)
68 {
69         panic("Disabled");
70 #if 0 // AKAROS_PORT
71         unsigned long flags;
72         uint64_t nsec;
73
74         read_lock_irqsave(&mdev->clock_lock, flags);
75         nsec = timecounter_cyc2time(&mdev->clock, timestamp);
76         read_unlock_irqrestore(&mdev->clock_lock, flags);
77
78         memset(hwts, 0, sizeof(struct skb_shared_hwtstamps));
79         hwts->hwtstamp = ns_to_ktime(nsec);
80 #endif
81 }
82
83 /**
84  * mlx4_en_remove_timestamp - disable PTP device
85  * @mdev: board private structure
86  *
87  * Stop the PTP support.
88  **/
89 void mlx4_en_remove_timestamp(struct mlx4_en_dev *mdev)
90 {
91         panic("Disabled");
92 #if 0 // AKAROS_PORT
93         if (mdev->ptp_clock) {
94                 ptp_clock_unregister(mdev->ptp_clock);
95                 mdev->ptp_clock = NULL;
96                 mlx4_info(mdev, "removed PHC\n");
97         }
98 #endif
99 }
100
101 void mlx4_en_ptp_overflow_check(struct mlx4_en_dev *mdev)
102 {
103         panic("Disabled");
104 #if 0 // AKAROS_PORT
105         bool timeout = time_is_before_jiffies(mdev->last_overflow_check +
106                                               mdev->overflow_period);
107         unsigned long flags;
108
109         if (timeout) {
110                 write_lock_irqsave(&mdev->clock_lock, flags);
111                 timecounter_read(&mdev->clock);
112                 write_unlock_irqrestore(&mdev->clock_lock, flags);
113                 mdev->last_overflow_check = jiffies;
114         }
115 #endif
116 }
117
118 #if 0 // AKAROS_PORT
119 /**
120  * mlx4_en_phc_adjfreq - adjust the frequency of the hardware clock
121  * @ptp: ptp clock structure
122  * @delta: Desired frequency change in parts per billion
123  *
124  * Adjust the frequency of the PHC cycle counter by the indicated delta from
125  * the base frequency.
126  **/
127 static int mlx4_en_phc_adjfreq(struct ptp_clock_info *ptp, int32_t delta)
128 {
129         uint64_t adj;
130         uint32_t diff, mult;
131         int neg_adj = 0;
132         unsigned long flags;
133         struct mlx4_en_dev *mdev = container_of(ptp, struct mlx4_en_dev,
134                                                 ptp_clock_info);
135
136         if (delta < 0) {
137                 neg_adj = 1;
138                 delta = -delta;
139         }
140         mult = mdev->nominal_c_mult;
141         adj = mult;
142         adj *= delta;
143         diff = div_u64(adj, 1000000000ULL);
144
145         write_lock_irqsave(&mdev->clock_lock, flags);
146         timecounter_read(&mdev->clock);
147         mdev->cycles.mult = neg_adj ? mult - diff : mult + diff;
148         write_unlock_irqrestore(&mdev->clock_lock, flags);
149
150         return 0;
151 }
152
153 /**
154  * mlx4_en_phc_adjtime - Shift the time of the hardware clock
155  * @ptp: ptp clock structure
156  * @delta: Desired change in nanoseconds
157  *
158  * Adjust the timer by resetting the timecounter structure.
159  **/
160 static int mlx4_en_phc_adjtime(struct ptp_clock_info *ptp, int64_t delta)
161 {
162         struct mlx4_en_dev *mdev = container_of(ptp, struct mlx4_en_dev,
163                                                 ptp_clock_info);
164         unsigned long flags;
165
166         write_lock_irqsave(&mdev->clock_lock, flags);
167         timecounter_adjtime(&mdev->clock, delta);
168         write_unlock_irqrestore(&mdev->clock_lock, flags);
169
170         return 0;
171 }
172
173 /**
174  * mlx4_en_phc_gettime - Reads the current time from the hardware clock
175  * @ptp: ptp clock structure
176  * @ts: timespec structure to hold the current time value
177  *
178  * Read the timecounter and return the correct value in ns after converting
179  * it into a struct timespec.
180  **/
181 static int mlx4_en_phc_gettime(struct ptp_clock_info *ptp,
182                                struct timespec64 *ts)
183 {
184         struct mlx4_en_dev *mdev = container_of(ptp, struct mlx4_en_dev,
185                                                 ptp_clock_info);
186         unsigned long flags;
187         uint64_t ns;
188
189         write_lock_irqsave(&mdev->clock_lock, flags);
190         ns = timecounter_read(&mdev->clock);
191         write_unlock_irqrestore(&mdev->clock_lock, flags);
192
193         *ts = ns_to_timespec64(ns);
194
195         return 0;
196 }
197
198 /**
199  * mlx4_en_phc_settime - Set the current time on the hardware clock
200  * @ptp: ptp clock structure
201  * @ts: timespec containing the new time for the cycle counter
202  *
203  * Reset the timecounter to use a new base value instead of the kernel
204  * wall timer value.
205  **/
206 static int mlx4_en_phc_settime(struct ptp_clock_info *ptp,
207                                const struct timespec64 *ts)
208 {
209         struct mlx4_en_dev *mdev = container_of(ptp, struct mlx4_en_dev,
210                                                 ptp_clock_info);
211         uint64_t ns = timespec64_to_ns(ts);
212         unsigned long flags;
213
214         /* reset the timecounter */
215         write_lock_irqsave(&mdev->clock_lock, flags);
216         timecounter_init(&mdev->clock, &mdev->cycles, ns);
217         write_unlock_irqrestore(&mdev->clock_lock, flags);
218
219         return 0;
220 }
221
222 /**
223  * mlx4_en_phc_enable - enable or disable an ancillary feature
224  * @ptp: ptp clock structure
225  * @request: Desired resource to enable or disable
226  * @on: Caller passes one to enable or zero to disable
227  *
228  * Enable (or disable) ancillary features of the PHC subsystem.
229  * Currently, no ancillary features are supported.
230  **/
231 static int mlx4_en_phc_enable(struct ptp_clock_info __always_unused *ptp,
232                               struct ptp_clock_request __always_unused *request,
233                               int __always_unused on)
234 {
235         return -EOPNOTSUPP;
236 }
237
238 static const struct ptp_clock_info mlx4_en_ptp_clock_info = {
239         .owner          = THIS_MODULE,
240         .max_adj        = 100000000,
241         .n_alarm        = 0,
242         .n_ext_ts       = 0,
243         .n_per_out      = 0,
244         .n_pins         = 0,
245         .pps            = 0,
246         .adjfreq        = mlx4_en_phc_adjfreq,
247         .adjtime        = mlx4_en_phc_adjtime,
248         .gettime64      = mlx4_en_phc_gettime,
249         .settime64      = mlx4_en_phc_settime,
250         .enable         = mlx4_en_phc_enable,
251 };
252 #endif
253
254 void mlx4_en_init_timestamp(struct mlx4_en_dev *mdev)
255 {
256         panic("Disabled");
257 #if 0 // AKAROS_PORT
258         struct mlx4_dev *dev = mdev->dev;
259         unsigned long flags;
260         uint64_t ns, zero = 0;
261
262         rwlock_init(&mdev->clock_lock);
263
264         memset(&mdev->cycles, 0, sizeof(mdev->cycles));
265         mdev->cycles.read = mlx4_en_read_clock;
266         mdev->cycles.mask = CLOCKSOURCE_MASK(48);
267         /* Using shift to make calculation more accurate. Since current HW
268          * clock frequency is 427 MHz, and cycles are given using a 48 bits
269          * register, the biggest shift when calculating using u64, is 14
270          * (max_cycles * multiplier < 2^64)
271          */
272         mdev->cycles.shift = 14;
273         mdev->cycles.mult =
274                 clocksource_khz2mult(1000 * dev->caps.hca_core_clock, mdev->cycles.shift);
275         mdev->nominal_c_mult = mdev->cycles.mult;
276
277         write_lock_irqsave(&mdev->clock_lock, flags);
278         timecounter_init(&mdev->clock, &mdev->cycles,
279                          epoch_nsec());
280         write_unlock_irqrestore(&mdev->clock_lock, flags);
281
282         /* Calculate period in seconds to call the overflow watchdog - to make
283          * sure counter is checked at least once every wrap around.
284          */
285         ns = cyclecounter_cyc2ns(&mdev->cycles, mdev->cycles.mask, zero, &zero);
286         do_div(ns, NSEC_PER_SEC / 2 / HZ);
287         mdev->overflow_period = ns;
288
289         /* Configure the PHC */
290         mdev->ptp_clock_info = mlx4_en_ptp_clock_info;
291         snprintf(mdev->ptp_clock_info.name, 16, "mlx4 ptp");
292
293         mdev->ptp_clock = ptp_clock_register(&mdev->ptp_clock_info,
294                                              &mdev->pdev->dev);
295         if (IS_ERR(mdev->ptp_clock)) {
296                 mdev->ptp_clock = NULL;
297                 mlx4_err(mdev, "ptp_clock_register failed\n");
298         } else {
299                 mlx4_info(mdev, "registered PHC clock\n");
300         }
301
302 #endif
303 }