blob: 08f4cf0ad9e3cacb8ac0e55f6f6003c74d53453a [file] [log] [blame]
Thomas Gleixner74ba9202019-05-20 09:19:02 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Yangbo Luceefc71d2018-05-25 12:40:34 +08002/*
3 * PTP 1588 clock for Freescale QorIQ 1588 timer
4 *
5 * Copyright (C) 2010 OMICRON electronics GmbH
Yangbo Luceefc71d2018-05-25 12:40:34 +08006 */
7
8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10#include <linux/device.h>
11#include <linux/hrtimer.h>
Yangbo Luceefc71d2018-05-25 12:40:34 +080012#include <linux/kernel.h>
13#include <linux/module.h>
14#include <linux/of.h>
15#include <linux/of_platform.h>
16#include <linux/timex.h>
Yangbo Luceefc71d2018-05-25 12:40:34 +080017#include <linux/slab.h>
Yangbo Lu91305f22018-08-01 18:05:54 +080018#include <linux/clk.h>
Yangbo Luceefc71d2018-05-25 12:40:34 +080019
Yangbo Lu6c50c1e2018-05-25 12:40:35 +080020#include <linux/fsl/ptp_qoriq.h>
Yangbo Luceefc71d2018-05-25 12:40:34 +080021
22/*
23 * Register access functions
24 */
25
Yangbo Lu1e562c82019-02-12 12:23:56 +080026/* Caller must hold ptp_qoriq->lock. */
27static u64 tmr_cnt_read(struct ptp_qoriq *ptp_qoriq)
Yangbo Luceefc71d2018-05-25 12:40:34 +080028{
Yangbo Lu1e562c82019-02-12 12:23:56 +080029 struct ptp_qoriq_registers *regs = &ptp_qoriq->regs;
Yangbo Luceefc71d2018-05-25 12:40:34 +080030 u64 ns;
31 u32 lo, hi;
32
Yangbo Luf038ddf2019-02-12 12:23:59 +080033 lo = ptp_qoriq->read(&regs->ctrl_regs->tmr_cnt_l);
34 hi = ptp_qoriq->read(&regs->ctrl_regs->tmr_cnt_h);
Yangbo Luceefc71d2018-05-25 12:40:34 +080035 ns = ((u64) hi) << 32;
36 ns |= lo;
37 return ns;
38}
39
Yangbo Lu1e562c82019-02-12 12:23:56 +080040/* Caller must hold ptp_qoriq->lock. */
41static void tmr_cnt_write(struct ptp_qoriq *ptp_qoriq, u64 ns)
Yangbo Luceefc71d2018-05-25 12:40:34 +080042{
Yangbo Lu1e562c82019-02-12 12:23:56 +080043 struct ptp_qoriq_registers *regs = &ptp_qoriq->regs;
Yangbo Luceefc71d2018-05-25 12:40:34 +080044 u32 hi = ns >> 32;
45 u32 lo = ns & 0xffffffff;
46
Yangbo Luf038ddf2019-02-12 12:23:59 +080047 ptp_qoriq->write(&regs->ctrl_regs->tmr_cnt_l, lo);
48 ptp_qoriq->write(&regs->ctrl_regs->tmr_cnt_h, hi);
Yangbo Luceefc71d2018-05-25 12:40:34 +080049}
50
Yangbo Lu1e562c82019-02-12 12:23:56 +080051/* Caller must hold ptp_qoriq->lock. */
52static void set_alarm(struct ptp_qoriq *ptp_qoriq)
Yangbo Luceefc71d2018-05-25 12:40:34 +080053{
Yangbo Lu1e562c82019-02-12 12:23:56 +080054 struct ptp_qoriq_registers *regs = &ptp_qoriq->regs;
Yangbo Luceefc71d2018-05-25 12:40:34 +080055 u64 ns;
56 u32 lo, hi;
57
Yangbo Lu1e562c82019-02-12 12:23:56 +080058 ns = tmr_cnt_read(ptp_qoriq) + 1500000000ULL;
Yangbo Luceefc71d2018-05-25 12:40:34 +080059 ns = div_u64(ns, 1000000000UL) * 1000000000ULL;
Yangbo Lu1e562c82019-02-12 12:23:56 +080060 ns -= ptp_qoriq->tclk_period;
Yangbo Luceefc71d2018-05-25 12:40:34 +080061 hi = ns >> 32;
62 lo = ns & 0xffffffff;
Yangbo Luf038ddf2019-02-12 12:23:59 +080063 ptp_qoriq->write(&regs->alarm_regs->tmr_alarm1_l, lo);
64 ptp_qoriq->write(&regs->alarm_regs->tmr_alarm1_h, hi);
Yangbo Luceefc71d2018-05-25 12:40:34 +080065}
66
Yangbo Lu1e562c82019-02-12 12:23:56 +080067/* Caller must hold ptp_qoriq->lock. */
68static void set_fipers(struct ptp_qoriq *ptp_qoriq)
Yangbo Luceefc71d2018-05-25 12:40:34 +080069{
Yangbo Lu1e562c82019-02-12 12:23:56 +080070 struct ptp_qoriq_registers *regs = &ptp_qoriq->regs;
Yangbo Lua8f62d02018-06-25 20:37:08 +080071
Yangbo Lu1e562c82019-02-12 12:23:56 +080072 set_alarm(ptp_qoriq);
Yangbo Luf038ddf2019-02-12 12:23:59 +080073 ptp_qoriq->write(&regs->fiper_regs->tmr_fiper1, ptp_qoriq->tmr_fiper1);
74 ptp_qoriq->write(&regs->fiper_regs->tmr_fiper2, ptp_qoriq->tmr_fiper2);
Yangbo Lu6d23d832020-09-18 17:48:01 +080075
76 if (ptp_qoriq->fiper3_support)
77 ptp_qoriq->write(&regs->fiper_regs->tmr_fiper3,
78 ptp_qoriq->tmr_fiper3);
Yangbo Luceefc71d2018-05-25 12:40:34 +080079}
80
Yangbo Lu94294392019-12-12 18:08:05 +080081int extts_clean_up(struct ptp_qoriq *ptp_qoriq, int index, bool update_event)
Yangbo Lu6815d8b2019-01-21 18:41:39 +080082{
Yangbo Lu1e562c82019-02-12 12:23:56 +080083 struct ptp_qoriq_registers *regs = &ptp_qoriq->regs;
Yangbo Lu6815d8b2019-01-21 18:41:39 +080084 struct ptp_clock_event event;
85 void __iomem *reg_etts_l;
86 void __iomem *reg_etts_h;
Yangbo Lu10bc8772019-12-12 18:08:04 +080087 u32 valid, lo, hi;
Yangbo Lu6815d8b2019-01-21 18:41:39 +080088
89 switch (index) {
90 case 0:
91 valid = ETS1_VLD;
92 reg_etts_l = &regs->etts_regs->tmr_etts1_l;
93 reg_etts_h = &regs->etts_regs->tmr_etts1_h;
94 break;
95 case 1:
96 valid = ETS2_VLD;
97 reg_etts_l = &regs->etts_regs->tmr_etts2_l;
98 reg_etts_h = &regs->etts_regs->tmr_etts2_h;
99 break;
100 default:
101 return -EINVAL;
102 }
103
104 event.type = PTP_CLOCK_EXTTS;
105 event.index = index;
106
Yangbo Lu10bc8772019-12-12 18:08:04 +0800107 if (ptp_qoriq->extts_fifo_support)
108 if (!(ptp_qoriq->read(&regs->ctrl_regs->tmr_stat) & valid))
109 return 0;
110
Yangbo Lu6815d8b2019-01-21 18:41:39 +0800111 do {
Yangbo Luf038ddf2019-02-12 12:23:59 +0800112 lo = ptp_qoriq->read(reg_etts_l);
113 hi = ptp_qoriq->read(reg_etts_h);
Yangbo Lu6815d8b2019-01-21 18:41:39 +0800114
115 if (update_event) {
116 event.timestamp = ((u64) hi) << 32;
117 event.timestamp |= lo;
Yangbo Lu1e562c82019-02-12 12:23:56 +0800118 ptp_clock_event(ptp_qoriq->clock, &event);
Yangbo Lu6815d8b2019-01-21 18:41:39 +0800119 }
120
Yangbo Lu10bc8772019-12-12 18:08:04 +0800121 if (!ptp_qoriq->extts_fifo_support)
122 break;
123 } while (ptp_qoriq->read(&regs->ctrl_regs->tmr_stat) & valid);
Yangbo Lu6815d8b2019-01-21 18:41:39 +0800124
125 return 0;
126}
Yangbo Lu94294392019-12-12 18:08:05 +0800127EXPORT_SYMBOL_GPL(extts_clean_up);
Yangbo Lu6815d8b2019-01-21 18:41:39 +0800128
Yangbo Luceefc71d2018-05-25 12:40:34 +0800129/*
130 * Interrupt service routine
131 */
132
Yangbo Lu73356e42019-02-12 12:23:57 +0800133irqreturn_t ptp_qoriq_isr(int irq, void *priv)
Yangbo Luceefc71d2018-05-25 12:40:34 +0800134{
Yangbo Lu1e562c82019-02-12 12:23:56 +0800135 struct ptp_qoriq *ptp_qoriq = priv;
136 struct ptp_qoriq_registers *regs = &ptp_qoriq->regs;
Yangbo Luceefc71d2018-05-25 12:40:34 +0800137 struct ptp_clock_event event;
Yangbo Lud71151a2020-02-11 12:52:49 +0800138 u32 ack = 0, mask, val, irqs;
Yangbo Lub0bc10c2019-01-21 18:41:38 +0800139
Yangbo Lu1e562c82019-02-12 12:23:56 +0800140 spin_lock(&ptp_qoriq->lock);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800141
Yangbo Luf038ddf2019-02-12 12:23:59 +0800142 val = ptp_qoriq->read(&regs->ctrl_regs->tmr_tevent);
143 mask = ptp_qoriq->read(&regs->ctrl_regs->tmr_temask);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800144
Yangbo Lu1e562c82019-02-12 12:23:56 +0800145 spin_unlock(&ptp_qoriq->lock);
Yangbo Lub0bc10c2019-01-21 18:41:38 +0800146
147 irqs = val & mask;
148
149 if (irqs & ETS1) {
Yangbo Luceefc71d2018-05-25 12:40:34 +0800150 ack |= ETS1;
Yangbo Lu1e562c82019-02-12 12:23:56 +0800151 extts_clean_up(ptp_qoriq, 0, true);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800152 }
153
Yangbo Lub0bc10c2019-01-21 18:41:38 +0800154 if (irqs & ETS2) {
Yangbo Luceefc71d2018-05-25 12:40:34 +0800155 ack |= ETS2;
Yangbo Lu1e562c82019-02-12 12:23:56 +0800156 extts_clean_up(ptp_qoriq, 1, true);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800157 }
158
Yangbo Lub0bc10c2019-01-21 18:41:38 +0800159 if (irqs & PP1) {
Yangbo Luceefc71d2018-05-25 12:40:34 +0800160 ack |= PP1;
161 event.type = PTP_CLOCK_PPS;
Yangbo Lu1e562c82019-02-12 12:23:56 +0800162 ptp_clock_event(ptp_qoriq->clock, &event);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800163 }
164
165 if (ack) {
Yangbo Luf038ddf2019-02-12 12:23:59 +0800166 ptp_qoriq->write(&regs->ctrl_regs->tmr_tevent, ack);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800167 return IRQ_HANDLED;
168 } else
169 return IRQ_NONE;
170}
Yangbo Lu73356e42019-02-12 12:23:57 +0800171EXPORT_SYMBOL_GPL(ptp_qoriq_isr);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800172
173/*
174 * PTP clock operations
175 */
176
Yangbo Lu73356e42019-02-12 12:23:57 +0800177int ptp_qoriq_adjfine(struct ptp_clock_info *ptp, long scaled_ppm)
Yangbo Luceefc71d2018-05-25 12:40:34 +0800178{
179 u64 adj, diff;
180 u32 tmr_add;
181 int neg_adj = 0;
Yangbo Lu1e562c82019-02-12 12:23:56 +0800182 struct ptp_qoriq *ptp_qoriq = container_of(ptp, struct ptp_qoriq, caps);
183 struct ptp_qoriq_registers *regs = &ptp_qoriq->regs;
Yangbo Luceefc71d2018-05-25 12:40:34 +0800184
185 if (scaled_ppm < 0) {
186 neg_adj = 1;
187 scaled_ppm = -scaled_ppm;
188 }
Yangbo Lu1e562c82019-02-12 12:23:56 +0800189 tmr_add = ptp_qoriq->tmr_add;
Yangbo Luceefc71d2018-05-25 12:40:34 +0800190 adj = tmr_add;
191
Yangbo Luf51d7bf2021-03-23 16:02:29 +0800192 /*
193 * Calculate diff and round() to the nearest integer
194 *
195 * diff = adj * (ppb / 1000000000)
196 * = adj * scaled_ppm / 65536000000
Yangbo Luceefc71d2018-05-25 12:40:34 +0800197 */
Yangbo Luf51d7bf2021-03-23 16:02:29 +0800198 diff = mul_u64_u64_div_u64(adj, scaled_ppm, 32768000000);
199 diff = DIV64_U64_ROUND_UP(diff, 2);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800200
201 tmr_add = neg_adj ? tmr_add - diff : tmr_add + diff;
Yangbo Luf038ddf2019-02-12 12:23:59 +0800202 ptp_qoriq->write(&regs->ctrl_regs->tmr_add, tmr_add);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800203
204 return 0;
205}
Yangbo Lu73356e42019-02-12 12:23:57 +0800206EXPORT_SYMBOL_GPL(ptp_qoriq_adjfine);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800207
Yangbo Lu73356e42019-02-12 12:23:57 +0800208int ptp_qoriq_adjtime(struct ptp_clock_info *ptp, s64 delta)
Yangbo Luceefc71d2018-05-25 12:40:34 +0800209{
210 s64 now;
211 unsigned long flags;
Yangbo Lu1e562c82019-02-12 12:23:56 +0800212 struct ptp_qoriq *ptp_qoriq = container_of(ptp, struct ptp_qoriq, caps);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800213
Yangbo Lu1e562c82019-02-12 12:23:56 +0800214 spin_lock_irqsave(&ptp_qoriq->lock, flags);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800215
Yangbo Lu1e562c82019-02-12 12:23:56 +0800216 now = tmr_cnt_read(ptp_qoriq);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800217 now += delta;
Yangbo Lu1e562c82019-02-12 12:23:56 +0800218 tmr_cnt_write(ptp_qoriq, now);
219 set_fipers(ptp_qoriq);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800220
Yangbo Lu1e562c82019-02-12 12:23:56 +0800221 spin_unlock_irqrestore(&ptp_qoriq->lock, flags);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800222
223 return 0;
224}
Yangbo Lu73356e42019-02-12 12:23:57 +0800225EXPORT_SYMBOL_GPL(ptp_qoriq_adjtime);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800226
Yangbo Lu73356e42019-02-12 12:23:57 +0800227int ptp_qoriq_gettime(struct ptp_clock_info *ptp, struct timespec64 *ts)
Yangbo Luceefc71d2018-05-25 12:40:34 +0800228{
229 u64 ns;
230 unsigned long flags;
Yangbo Lu1e562c82019-02-12 12:23:56 +0800231 struct ptp_qoriq *ptp_qoriq = container_of(ptp, struct ptp_qoriq, caps);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800232
Yangbo Lu1e562c82019-02-12 12:23:56 +0800233 spin_lock_irqsave(&ptp_qoriq->lock, flags);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800234
Yangbo Lu1e562c82019-02-12 12:23:56 +0800235 ns = tmr_cnt_read(ptp_qoriq);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800236
Yangbo Lu1e562c82019-02-12 12:23:56 +0800237 spin_unlock_irqrestore(&ptp_qoriq->lock, flags);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800238
239 *ts = ns_to_timespec64(ns);
240
241 return 0;
242}
Yangbo Lu73356e42019-02-12 12:23:57 +0800243EXPORT_SYMBOL_GPL(ptp_qoriq_gettime);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800244
Yangbo Lu73356e42019-02-12 12:23:57 +0800245int ptp_qoriq_settime(struct ptp_clock_info *ptp,
246 const struct timespec64 *ts)
Yangbo Luceefc71d2018-05-25 12:40:34 +0800247{
248 u64 ns;
249 unsigned long flags;
Yangbo Lu1e562c82019-02-12 12:23:56 +0800250 struct ptp_qoriq *ptp_qoriq = container_of(ptp, struct ptp_qoriq, caps);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800251
252 ns = timespec64_to_ns(ts);
253
Yangbo Lu1e562c82019-02-12 12:23:56 +0800254 spin_lock_irqsave(&ptp_qoriq->lock, flags);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800255
Yangbo Lu1e562c82019-02-12 12:23:56 +0800256 tmr_cnt_write(ptp_qoriq, ns);
257 set_fipers(ptp_qoriq);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800258
Yangbo Lu1e562c82019-02-12 12:23:56 +0800259 spin_unlock_irqrestore(&ptp_qoriq->lock, flags);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800260
261 return 0;
262}
Yangbo Lu73356e42019-02-12 12:23:57 +0800263EXPORT_SYMBOL_GPL(ptp_qoriq_settime);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800264
Yangbo Lu73356e42019-02-12 12:23:57 +0800265int ptp_qoriq_enable(struct ptp_clock_info *ptp,
266 struct ptp_clock_request *rq, int on)
Yangbo Luceefc71d2018-05-25 12:40:34 +0800267{
Yangbo Lu1e562c82019-02-12 12:23:56 +0800268 struct ptp_qoriq *ptp_qoriq = container_of(ptp, struct ptp_qoriq, caps);
269 struct ptp_qoriq_registers *regs = &ptp_qoriq->regs;
Yangbo Luceefc71d2018-05-25 12:40:34 +0800270 unsigned long flags;
Yangbo Lub0bc10c2019-01-21 18:41:38 +0800271 u32 bit, mask = 0;
Yangbo Luceefc71d2018-05-25 12:40:34 +0800272
273 switch (rq->type) {
274 case PTP_CLK_REQ_EXTTS:
275 switch (rq->extts.index) {
276 case 0:
277 bit = ETS1EN;
278 break;
279 case 1:
280 bit = ETS2EN;
281 break;
282 default:
283 return -EINVAL;
284 }
Yangbo Lu6815d8b2019-01-21 18:41:39 +0800285
286 if (on)
Yangbo Lu1e562c82019-02-12 12:23:56 +0800287 extts_clean_up(ptp_qoriq, rq->extts.index, false);
Yangbo Lu6815d8b2019-01-21 18:41:39 +0800288
Yangbo Luceefc71d2018-05-25 12:40:34 +0800289 break;
Yangbo Lub0bc10c2019-01-21 18:41:38 +0800290 case PTP_CLK_REQ_PPS:
291 bit = PP1EN;
292 break;
293 default:
294 return -EOPNOTSUPP;
Yangbo Luceefc71d2018-05-25 12:40:34 +0800295 }
296
Yangbo Lu1e562c82019-02-12 12:23:56 +0800297 spin_lock_irqsave(&ptp_qoriq->lock, flags);
Yangbo Lub0bc10c2019-01-21 18:41:38 +0800298
Yangbo Luf038ddf2019-02-12 12:23:59 +0800299 mask = ptp_qoriq->read(&regs->ctrl_regs->tmr_temask);
Yangbo Lub0bc10c2019-01-21 18:41:38 +0800300 if (on) {
301 mask |= bit;
Yangbo Luf038ddf2019-02-12 12:23:59 +0800302 ptp_qoriq->write(&regs->ctrl_regs->tmr_tevent, bit);
Yangbo Lub0bc10c2019-01-21 18:41:38 +0800303 } else {
304 mask &= ~bit;
305 }
306
Yangbo Luf038ddf2019-02-12 12:23:59 +0800307 ptp_qoriq->write(&regs->ctrl_regs->tmr_temask, mask);
Yangbo Lub0bc10c2019-01-21 18:41:38 +0800308
Yangbo Lu1e562c82019-02-12 12:23:56 +0800309 spin_unlock_irqrestore(&ptp_qoriq->lock, flags);
Yangbo Lub0bc10c2019-01-21 18:41:38 +0800310 return 0;
Yangbo Luceefc71d2018-05-25 12:40:34 +0800311}
Yangbo Lu73356e42019-02-12 12:23:57 +0800312EXPORT_SYMBOL_GPL(ptp_qoriq_enable);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800313
314static const struct ptp_clock_info ptp_qoriq_caps = {
315 .owner = THIS_MODULE,
316 .name = "qoriq ptp clock",
317 .max_adj = 512000,
318 .n_alarm = 0,
319 .n_ext_ts = N_EXT_TS,
320 .n_per_out = 0,
321 .n_pins = 0,
322 .pps = 1,
323 .adjfine = ptp_qoriq_adjfine,
324 .adjtime = ptp_qoriq_adjtime,
325 .gettime64 = ptp_qoriq_gettime,
326 .settime64 = ptp_qoriq_settime,
327 .enable = ptp_qoriq_enable,
328};
329
Yangbo Lu91305f22018-08-01 18:05:54 +0800330/**
Yangbo Lu1e562c82019-02-12 12:23:56 +0800331 * ptp_qoriq_nominal_freq - calculate nominal frequency according to
Yangbo Lu91305f22018-08-01 18:05:54 +0800332 * reference clock frequency
333 *
334 * @clk_src: reference clock frequency
335 *
336 * The nominal frequency is the desired clock frequency.
337 * It should be less than the reference clock frequency.
338 * It should be a factor of 1000MHz.
339 *
340 * Return the nominal frequency
341 */
Yangbo Lu1e562c82019-02-12 12:23:56 +0800342static u32 ptp_qoriq_nominal_freq(u32 clk_src)
Yangbo Lu91305f22018-08-01 18:05:54 +0800343{
344 u32 remainder = 0;
345
346 clk_src /= 1000000;
347 remainder = clk_src % 100;
348 if (remainder) {
349 clk_src -= remainder;
350 clk_src += 100;
351 }
352
353 do {
354 clk_src -= 100;
355
356 } while (1000 % clk_src);
357
358 return clk_src * 1000000;
359}
360
361/**
Yangbo Lu1e562c82019-02-12 12:23:56 +0800362 * ptp_qoriq_auto_config - calculate a set of default configurations
Yangbo Lu91305f22018-08-01 18:05:54 +0800363 *
Yangbo Lu1e562c82019-02-12 12:23:56 +0800364 * @ptp_qoriq: pointer to ptp_qoriq
Yangbo Lu91305f22018-08-01 18:05:54 +0800365 * @node: pointer to device_node
366 *
367 * If below dts properties are not provided, this function will be
368 * called to calculate a set of default configurations for them.
369 * "fsl,tclk-period"
370 * "fsl,tmr-prsc"
371 * "fsl,tmr-add"
372 * "fsl,tmr-fiper1"
373 * "fsl,tmr-fiper2"
Yangbo Lu6d23d832020-09-18 17:48:01 +0800374 * "fsl,tmr-fiper3" (required only for DPAA2 and ENETC hardware)
Yangbo Lu91305f22018-08-01 18:05:54 +0800375 * "fsl,max-adj"
376 *
377 * Return 0 if success
378 */
Yangbo Lu1e562c82019-02-12 12:23:56 +0800379static int ptp_qoriq_auto_config(struct ptp_qoriq *ptp_qoriq,
Yangbo Lu91305f22018-08-01 18:05:54 +0800380 struct device_node *node)
381{
382 struct clk *clk;
383 u64 freq_comp;
384 u64 max_adj;
385 u32 nominal_freq;
Yangbo Lu74c05a32018-08-06 12:39:11 +0800386 u32 remainder = 0;
Yangbo Lu91305f22018-08-01 18:05:54 +0800387 u32 clk_src = 0;
388
Yangbo Lu1e562c82019-02-12 12:23:56 +0800389 ptp_qoriq->cksel = DEFAULT_CKSEL;
Yangbo Lu91305f22018-08-01 18:05:54 +0800390
391 clk = of_clk_get(node, 0);
392 if (!IS_ERR(clk)) {
393 clk_src = clk_get_rate(clk);
394 clk_put(clk);
395 }
396
397 if (clk_src <= 100000000UL) {
398 pr_err("error reference clock value, or lower than 100MHz\n");
399 return -EINVAL;
400 }
401
Yangbo Lu1e562c82019-02-12 12:23:56 +0800402 nominal_freq = ptp_qoriq_nominal_freq(clk_src);
Yangbo Lu91305f22018-08-01 18:05:54 +0800403 if (!nominal_freq)
404 return -EINVAL;
405
Yangbo Lu1e562c82019-02-12 12:23:56 +0800406 ptp_qoriq->tclk_period = 1000000000UL / nominal_freq;
407 ptp_qoriq->tmr_prsc = DEFAULT_TMR_PRSC;
Yangbo Lu91305f22018-08-01 18:05:54 +0800408
409 /* Calculate initial frequency compensation value for TMR_ADD register.
410 * freq_comp = ceil(2^32 / freq_ratio)
411 * freq_ratio = reference_clock_freq / nominal_freq
412 */
413 freq_comp = ((u64)1 << 32) * nominal_freq;
Yangbo Lu74c05a32018-08-06 12:39:11 +0800414 freq_comp = div_u64_rem(freq_comp, clk_src, &remainder);
415 if (remainder)
Yangbo Lu91305f22018-08-01 18:05:54 +0800416 freq_comp++;
417
Yangbo Lu1e562c82019-02-12 12:23:56 +0800418 ptp_qoriq->tmr_add = freq_comp;
419 ptp_qoriq->tmr_fiper1 = DEFAULT_FIPER1_PERIOD - ptp_qoriq->tclk_period;
420 ptp_qoriq->tmr_fiper2 = DEFAULT_FIPER2_PERIOD - ptp_qoriq->tclk_period;
Yangbo Lu6d23d832020-09-18 17:48:01 +0800421 ptp_qoriq->tmr_fiper3 = DEFAULT_FIPER3_PERIOD - ptp_qoriq->tclk_period;
Yangbo Lu91305f22018-08-01 18:05:54 +0800422
423 /* max_adj = 1000000000 * (freq_ratio - 1.0) - 1
424 * freq_ratio = reference_clock_freq / nominal_freq
425 */
426 max_adj = 1000000000ULL * (clk_src - nominal_freq);
Yangbo Lu74c05a32018-08-06 12:39:11 +0800427 max_adj = div_u64(max_adj, nominal_freq) - 1;
Yangbo Lu1e562c82019-02-12 12:23:56 +0800428 ptp_qoriq->caps.max_adj = max_adj;
Yangbo Lu91305f22018-08-01 18:05:54 +0800429
430 return 0;
431}
432
Yangbo Luff545712019-02-12 12:23:58 +0800433int ptp_qoriq_init(struct ptp_qoriq *ptp_qoriq, void __iomem *base,
Colin Ian King58066ac2019-02-19 14:21:20 +0000434 const struct ptp_clock_info *caps)
Yangbo Luceefc71d2018-05-25 12:40:34 +0800435{
Yangbo Luff545712019-02-12 12:23:58 +0800436 struct device_node *node = ptp_qoriq->dev->of_node;
Yangbo Lu1e562c82019-02-12 12:23:56 +0800437 struct ptp_qoriq_registers *regs;
Yangbo Luceefc71d2018-05-25 12:40:34 +0800438 struct timespec64 now;
Yangbo Luceefc71d2018-05-25 12:40:34 +0800439 unsigned long flags;
Yangbo Luff545712019-02-12 12:23:58 +0800440 u32 tmr_ctrl;
Yangbo Luceefc71d2018-05-25 12:40:34 +0800441
Claudiu Manoil7f4399b2019-05-09 03:07:12 +0000442 if (!node)
443 return -ENODEV;
444
Yangbo Luff545712019-02-12 12:23:58 +0800445 ptp_qoriq->base = base;
Colin Ian King58066ac2019-02-19 14:21:20 +0000446 ptp_qoriq->caps = *caps;
Yangbo Luceefc71d2018-05-25 12:40:34 +0800447
Yangbo Lu1e562c82019-02-12 12:23:56 +0800448 if (of_property_read_u32(node, "fsl,cksel", &ptp_qoriq->cksel))
449 ptp_qoriq->cksel = DEFAULT_CKSEL;
Yangbo Luceefc71d2018-05-25 12:40:34 +0800450
Yangbo Lu6815d8b2019-01-21 18:41:39 +0800451 if (of_property_read_bool(node, "fsl,extts-fifo"))
Yangbo Lu1e562c82019-02-12 12:23:56 +0800452 ptp_qoriq->extts_fifo_support = true;
Yangbo Lu6815d8b2019-01-21 18:41:39 +0800453 else
Yangbo Lu1e562c82019-02-12 12:23:56 +0800454 ptp_qoriq->extts_fifo_support = false;
Yangbo Lu6815d8b2019-01-21 18:41:39 +0800455
Yangbo Lu6d23d832020-09-18 17:48:01 +0800456 if (of_device_is_compatible(node, "fsl,dpaa2-ptp") ||
457 of_device_is_compatible(node, "fsl,enetc-ptp"))
458 ptp_qoriq->fiper3_support = true;
459
Yangbo Luceefc71d2018-05-25 12:40:34 +0800460 if (of_property_read_u32(node,
Yangbo Lu1e562c82019-02-12 12:23:56 +0800461 "fsl,tclk-period", &ptp_qoriq->tclk_period) ||
Yangbo Luceefc71d2018-05-25 12:40:34 +0800462 of_property_read_u32(node,
Yangbo Lu1e562c82019-02-12 12:23:56 +0800463 "fsl,tmr-prsc", &ptp_qoriq->tmr_prsc) ||
Yangbo Luceefc71d2018-05-25 12:40:34 +0800464 of_property_read_u32(node,
Yangbo Lu1e562c82019-02-12 12:23:56 +0800465 "fsl,tmr-add", &ptp_qoriq->tmr_add) ||
Yangbo Luceefc71d2018-05-25 12:40:34 +0800466 of_property_read_u32(node,
Yangbo Lu1e562c82019-02-12 12:23:56 +0800467 "fsl,tmr-fiper1", &ptp_qoriq->tmr_fiper1) ||
Yangbo Luceefc71d2018-05-25 12:40:34 +0800468 of_property_read_u32(node,
Yangbo Lu1e562c82019-02-12 12:23:56 +0800469 "fsl,tmr-fiper2", &ptp_qoriq->tmr_fiper2) ||
Yangbo Luceefc71d2018-05-25 12:40:34 +0800470 of_property_read_u32(node,
Yangbo Lu6d23d832020-09-18 17:48:01 +0800471 "fsl,max-adj", &ptp_qoriq->caps.max_adj) ||
472 (ptp_qoriq->fiper3_support &&
473 of_property_read_u32(node, "fsl,tmr-fiper3",
474 &ptp_qoriq->tmr_fiper3))) {
Yangbo Lu91305f22018-08-01 18:05:54 +0800475 pr_warn("device tree node missing required elements, try automatic configuration\n");
476
Yangbo Lu1e562c82019-02-12 12:23:56 +0800477 if (ptp_qoriq_auto_config(ptp_qoriq, node))
Yangbo Luff545712019-02-12 12:23:58 +0800478 return -ENODEV;
Yangbo Luceefc71d2018-05-25 12:40:34 +0800479 }
480
Yangbo Luf038ddf2019-02-12 12:23:59 +0800481 if (of_property_read_bool(node, "little-endian")) {
482 ptp_qoriq->read = qoriq_read_le;
483 ptp_qoriq->write = qoriq_write_le;
484 } else {
485 ptp_qoriq->read = qoriq_read_be;
486 ptp_qoriq->write = qoriq_write_be;
487 }
488
Yangbo Lud4e17682019-02-12 12:24:01 +0800489 /* The eTSEC uses differnt memory map with DPAA/ENETC */
490 if (of_device_is_compatible(node, "fsl,etsec-ptp")) {
491 ptp_qoriq->regs.ctrl_regs = base + ETSEC_CTRL_REGS_OFFSET;
492 ptp_qoriq->regs.alarm_regs = base + ETSEC_ALARM_REGS_OFFSET;
493 ptp_qoriq->regs.fiper_regs = base + ETSEC_FIPER_REGS_OFFSET;
494 ptp_qoriq->regs.etts_regs = base + ETSEC_ETTS_REGS_OFFSET;
Yangbo Lua8f62d02018-06-25 20:37:08 +0800495 } else {
Yangbo Lu1e562c82019-02-12 12:23:56 +0800496 ptp_qoriq->regs.ctrl_regs = base + CTRL_REGS_OFFSET;
497 ptp_qoriq->regs.alarm_regs = base + ALARM_REGS_OFFSET;
498 ptp_qoriq->regs.fiper_regs = base + FIPER_REGS_OFFSET;
499 ptp_qoriq->regs.etts_regs = base + ETTS_REGS_OFFSET;
Yangbo Lua8f62d02018-06-25 20:37:08 +0800500 }
501
Vladimir Olteandb34a472019-10-01 22:07:01 +0300502 spin_lock_init(&ptp_qoriq->lock);
503
Arnd Bergmannf696a212018-06-18 16:20:39 +0200504 ktime_get_real_ts64(&now);
Yangbo Lu1e562c82019-02-12 12:23:56 +0800505 ptp_qoriq_settime(&ptp_qoriq->caps, &now);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800506
507 tmr_ctrl =
Yangbo Lu1e562c82019-02-12 12:23:56 +0800508 (ptp_qoriq->tclk_period & TCLK_PERIOD_MASK) << TCLK_PERIOD_SHIFT |
509 (ptp_qoriq->cksel & CKSEL_MASK) << CKSEL_SHIFT;
Yangbo Luceefc71d2018-05-25 12:40:34 +0800510
Yangbo Lu1e562c82019-02-12 12:23:56 +0800511 spin_lock_irqsave(&ptp_qoriq->lock, flags);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800512
Yangbo Lu1e562c82019-02-12 12:23:56 +0800513 regs = &ptp_qoriq->regs;
Yangbo Luf038ddf2019-02-12 12:23:59 +0800514 ptp_qoriq->write(&regs->ctrl_regs->tmr_ctrl, tmr_ctrl);
515 ptp_qoriq->write(&regs->ctrl_regs->tmr_add, ptp_qoriq->tmr_add);
516 ptp_qoriq->write(&regs->ctrl_regs->tmr_prsc, ptp_qoriq->tmr_prsc);
517 ptp_qoriq->write(&regs->fiper_regs->tmr_fiper1, ptp_qoriq->tmr_fiper1);
518 ptp_qoriq->write(&regs->fiper_regs->tmr_fiper2, ptp_qoriq->tmr_fiper2);
Yangbo Lu6d23d832020-09-18 17:48:01 +0800519
520 if (ptp_qoriq->fiper3_support)
521 ptp_qoriq->write(&regs->fiper_regs->tmr_fiper3,
522 ptp_qoriq->tmr_fiper3);
523
Yangbo Lu1e562c82019-02-12 12:23:56 +0800524 set_alarm(ptp_qoriq);
Yangbo Luf038ddf2019-02-12 12:23:59 +0800525 ptp_qoriq->write(&regs->ctrl_regs->tmr_ctrl,
526 tmr_ctrl|FIPERST|RTPE|TE|FRD);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800527
Yangbo Lu1e562c82019-02-12 12:23:56 +0800528 spin_unlock_irqrestore(&ptp_qoriq->lock, flags);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800529
Yangbo Luff545712019-02-12 12:23:58 +0800530 ptp_qoriq->clock = ptp_clock_register(&ptp_qoriq->caps, ptp_qoriq->dev);
531 if (IS_ERR(ptp_qoriq->clock))
532 return PTR_ERR(ptp_qoriq->clock);
533
Yangbo Lu1e562c82019-02-12 12:23:56 +0800534 ptp_qoriq->phc_index = ptp_clock_index(ptp_qoriq->clock);
Yangbo Lu1e562c82019-02-12 12:23:56 +0800535 ptp_qoriq_create_debugfs(ptp_qoriq);
Yangbo Luff545712019-02-12 12:23:58 +0800536 return 0;
537}
538EXPORT_SYMBOL_GPL(ptp_qoriq_init);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800539
Yangbo Luff545712019-02-12 12:23:58 +0800540void ptp_qoriq_free(struct ptp_qoriq *ptp_qoriq)
541{
542 struct ptp_qoriq_registers *regs = &ptp_qoriq->regs;
543
Yangbo Luf038ddf2019-02-12 12:23:59 +0800544 ptp_qoriq->write(&regs->ctrl_regs->tmr_temask, 0);
545 ptp_qoriq->write(&regs->ctrl_regs->tmr_ctrl, 0);
Yangbo Luff545712019-02-12 12:23:58 +0800546
547 ptp_qoriq_remove_debugfs(ptp_qoriq);
548 ptp_clock_unregister(ptp_qoriq->clock);
549 iounmap(ptp_qoriq->base);
550 free_irq(ptp_qoriq->irq, ptp_qoriq);
551}
552EXPORT_SYMBOL_GPL(ptp_qoriq_free);
553
554static int ptp_qoriq_probe(struct platform_device *dev)
555{
556 struct ptp_qoriq *ptp_qoriq;
557 int err = -ENOMEM;
558 void __iomem *base;
559
560 ptp_qoriq = kzalloc(sizeof(*ptp_qoriq), GFP_KERNEL);
561 if (!ptp_qoriq)
562 goto no_memory;
563
564 ptp_qoriq->dev = &dev->dev;
565
566 err = -ENODEV;
567
568 ptp_qoriq->irq = platform_get_irq(dev, 0);
569 if (ptp_qoriq->irq < 0) {
570 pr_err("irq not in device tree\n");
571 goto no_node;
572 }
573 if (request_irq(ptp_qoriq->irq, ptp_qoriq_isr, IRQF_SHARED,
574 DRIVER, ptp_qoriq)) {
575 pr_err("request_irq failed\n");
576 goto no_node;
577 }
578
579 ptp_qoriq->rsrc = platform_get_resource(dev, IORESOURCE_MEM, 0);
580 if (!ptp_qoriq->rsrc) {
581 pr_err("no resource\n");
582 goto no_resource;
583 }
584 if (request_resource(&iomem_resource, ptp_qoriq->rsrc)) {
585 pr_err("resource busy\n");
586 goto no_resource;
587 }
588
589 base = ioremap(ptp_qoriq->rsrc->start,
590 resource_size(ptp_qoriq->rsrc));
591 if (!base) {
592 pr_err("ioremap ptp registers failed\n");
593 goto no_ioremap;
594 }
595
Colin Ian King58066ac2019-02-19 14:21:20 +0000596 err = ptp_qoriq_init(ptp_qoriq, base, &ptp_qoriq_caps);
Yangbo Luff545712019-02-12 12:23:58 +0800597 if (err)
598 goto no_clock;
599
600 platform_set_drvdata(dev, ptp_qoriq);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800601 return 0;
602
603no_clock:
Yangbo Lu1e562c82019-02-12 12:23:56 +0800604 iounmap(ptp_qoriq->base);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800605no_ioremap:
Yangbo Lu1e562c82019-02-12 12:23:56 +0800606 release_resource(ptp_qoriq->rsrc);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800607no_resource:
Yangbo Lu1e562c82019-02-12 12:23:56 +0800608 free_irq(ptp_qoriq->irq, ptp_qoriq);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800609no_node:
Yangbo Lu1e562c82019-02-12 12:23:56 +0800610 kfree(ptp_qoriq);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800611no_memory:
612 return err;
613}
614
Yangbo Lu1e562c82019-02-12 12:23:56 +0800615static int ptp_qoriq_remove(struct platform_device *dev)
Yangbo Luceefc71d2018-05-25 12:40:34 +0800616{
Yangbo Lu1e562c82019-02-12 12:23:56 +0800617 struct ptp_qoriq *ptp_qoriq = platform_get_drvdata(dev);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800618
Yangbo Luff545712019-02-12 12:23:58 +0800619 ptp_qoriq_free(ptp_qoriq);
Yangbo Lu1e562c82019-02-12 12:23:56 +0800620 release_resource(ptp_qoriq->rsrc);
Yangbo Lu1e562c82019-02-12 12:23:56 +0800621 kfree(ptp_qoriq);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800622 return 0;
623}
624
625static const struct of_device_id match_table[] = {
626 { .compatible = "fsl,etsec-ptp" },
Yangbo Lua8f62d02018-06-25 20:37:08 +0800627 { .compatible = "fsl,fman-ptp-timer" },
Yangbo Luceefc71d2018-05-25 12:40:34 +0800628 {},
629};
630MODULE_DEVICE_TABLE(of, match_table);
631
Yangbo Lu1e562c82019-02-12 12:23:56 +0800632static struct platform_driver ptp_qoriq_driver = {
Yangbo Luceefc71d2018-05-25 12:40:34 +0800633 .driver = {
634 .name = "ptp_qoriq",
635 .of_match_table = match_table,
636 },
Yangbo Lu1e562c82019-02-12 12:23:56 +0800637 .probe = ptp_qoriq_probe,
638 .remove = ptp_qoriq_remove,
Yangbo Luceefc71d2018-05-25 12:40:34 +0800639};
640
Yangbo Lu1e562c82019-02-12 12:23:56 +0800641module_platform_driver(ptp_qoriq_driver);
Yangbo Luceefc71d2018-05-25 12:40:34 +0800642
643MODULE_AUTHOR("Richard Cochran <richardcochran@gmail.com>");
644MODULE_DESCRIPTION("PTP clock for Freescale QorIQ 1588 timer");
645MODULE_LICENSE("GPL");