drivers/net/ethernet/ti/cpts.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * TI Common Platform Time Sync
   4  *
   5  * Copyright (C) 2012 Richard Cochran <richardcochran@gmail.com>
   6  *
   7  */
   8 #include <linux/clk-provider.h>
   9 #include <linux/err.h>
  10 #include <linux/if.h>
  11 #include <linux/hrtimer.h>
  12 #include <linux/module.h>
  13 #include <linux/net_tstamp.h>
  14 #include <linux/ptp_classify.h>
  15 #include <linux/time.h>
  16 #include <linux/uaccess.h>
  17 #include <linux/workqueue.h>
  18 #include <linux/if_ether.h>
  19 #include <linux/if_vlan.h>
  20
  21 #include "cpts.h"
  22
  23 #define CPTS_SKB_TX_WORK_TIMEOUT 1 /* jiffies */
  24
  25 struct cpts_skb_cb_data {
  26         unsigned long tmo;
  27 };
  28
  29 #define cpts_read32(c, r)       readl_relaxed(&c->reg->r)
  30 #define cpts_write32(c, v, r)   writel_relaxed(v, &c->reg->r)
  31
  32 static int cpts_match(struct sk_buff *skb, unsigned int ptp_class,
  33                       u16 ts_seqid, u8 ts_msgtype);
  34
  35 static int event_expired(struct cpts_event *event)
  36 {
  37         return time_after(jiffies, event->tmo);
  38 }
  39
  40 static int event_type(struct cpts_event *event)
  41 {
  42         return (event->high >> EVENT_TYPE_SHIFT) & EVENT_TYPE_MASK;
  43 }
  44
  45 static int cpts_fifo_pop(struct cpts *cpts, u32 *high, u32 *low)
  46 {
  47         u32 r = cpts_read32(cpts, intstat_raw);
  48
  49         if (r & TS_PEND_RAW) {
  50                 *high = cpts_read32(cpts, event_high);
  51                 *low  = cpts_read32(cpts, event_low);
  52                 cpts_write32(cpts, EVENT_POP, event_pop);
  53                 return 0;
  54         }
  55         return -1;
  56 }
  57
  58 static int cpts_purge_events(struct cpts *cpts)
  59 {
  60         struct list_head *this, *next;
  61         struct cpts_event *event;
  62         int removed = 0;
  63
  64         list_for_each_safe(this, next, &cpts->events) {
  65                 event = list_entry(this, struct cpts_event, list);
  66                 if (event_expired(event)) {
  67                         list_del_init(&event->list);
  68                         list_add(&event->list, &cpts->pool);
  69                         ++removed;
  70                 }
  71         }
  72
  73         if (removed)
  74                 dev_dbg(cpts->dev, "cpts: event pool cleaned up %d\n", removed);
  75         return removed ? 0 : -1;
  76 }
  77
  78 static void cpts_purge_txq(struct cpts *cpts)
  79 {
  80         struct cpts_skb_cb_data *skb_cb;
  81         struct sk_buff *skb, *tmp;
  82         int removed = 0;
  83
  84         skb_queue_walk_safe(&cpts->txq, skb, tmp) {
  85                 skb_cb = (struct cpts_skb_cb_data *)skb->cb;
  86                 if (time_after(jiffies, skb_cb->tmo)) {
  87                         __skb_unlink(skb, &cpts->txq);
  88                         dev_consume_skb_any(skb);
  89                         ++removed;
  90                 }
  91         }
  92
  93         if (removed)
  94                 dev_dbg(cpts->dev, "txq cleaned up %d\n", removed);
  95 }
  96
  97 static bool cpts_match_tx_ts(struct cpts *cpts, struct cpts_event *event)
  98 {
  99         struct sk_buff *skb, *tmp;
 100         u16 seqid;
 101         u8 mtype;
 102         bool found = false;
 103
 104         mtype = (event->high >> MESSAGE_TYPE_SHIFT) & MESSAGE_TYPE_MASK;
 105         seqid = (event->high >> SEQUENCE_ID_SHIFT) & SEQUENCE_ID_MASK;
 106
 107         /* no need to grab txq.lock as access is always done under cpts->lock */
 108         skb_queue_walk_safe(&cpts->txq, skb, tmp) {
 109                 struct skb_shared_hwtstamps ssh;
 110                 unsigned int class = ptp_classify_raw(skb);
 111                 struct cpts_skb_cb_data *skb_cb =
 112                                         (struct cpts_skb_cb_data *)skb->cb;
 113
 114                 if (cpts_match(skb, class, seqid, mtype)) {
 115                         memset(&ssh, 0, sizeof(ssh));
 116                         ssh.hwtstamp = ns_to_ktime(event->timestamp);
 117                         skb_tstamp_tx(skb, &ssh);
 118                         found = true;
 119                         __skb_unlink(skb, &cpts->txq);
 120                         dev_consume_skb_any(skb);
 121                         dev_dbg(cpts->dev, "match tx timestamp mtype %u seqid %04x\n",
 122                                 mtype, seqid);
 123                         break;
 124                 }
 125
 126                 if (time_after(jiffies, skb_cb->tmo)) {
 127                         /* timeout any expired skbs over 1s */
 128                         dev_dbg(cpts->dev, "expiring tx timestamp from txq\n");
 129                         __skb_unlink(skb, &cpts->txq);
 130                         dev_consume_skb_any(skb);
 131                 }
 132         }
 133
 134         return found;
 135 }
 136
 137 /*
 138  * Returns zero if matching event type was found.
 139  */
 140 static int cpts_fifo_read(struct cpts *cpts, int match)
 141 {
 142         int i, type = -1;
 143         u32 hi, lo;
 144         struct cpts_event *event;
 145
 146         for (i = 0; i < CPTS_FIFO_DEPTH; i++) {
 147                 if (cpts_fifo_pop(cpts, &hi, &lo))
 148                         break;
 149
 150                 if (list_empty(&cpts->pool) && cpts_purge_events(cpts)) {
 151                         dev_warn(cpts->dev, "cpts: event pool empty\n");
 152                         return -1;
 153                 }
 154
 155                 event = list_first_entry(&cpts->pool, struct cpts_event, list);
 156                 event->tmo = jiffies + 2;
 157                 event->high = hi;
 158                 event->low = lo;
 159                 event->timestamp = timecounter_cyc2time(&cpts->tc, event->low);
 160                 type = event_type(event);
 161
 162                 dev_dbg(cpts->dev, "CPTS_EV: %d high:%08X low:%08x\n",
 163                         type, event->high, event->low);
 164                 switch (type) {
 165                 case CPTS_EV_PUSH:
 166                         WRITE_ONCE(cpts->cur_timestamp, lo);
 167                         timecounter_read(&cpts->tc);
 168                         if (cpts->mult_new) {
 169                                 cpts->cc.mult = cpts->mult_new;
 170                                 cpts->mult_new = 0;
 171                         }
 172                         break;
 173                 case CPTS_EV_TX:
 174                         if (cpts_match_tx_ts(cpts, event)) {
 175                                 /* if the new event matches an existing skb,
 176                                  * then don't queue it
 177                                  */
 178                                 break;
 179                         }
 180                         /* fall through */
 181                 case CPTS_EV_RX:
 182                         list_del_init(&event->list);
 183                         list_add_tail(&event->list, &cpts->events);
 184                         break;
 185                 case CPTS_EV_ROLL:
 186                 case CPTS_EV_HALF:
 187                 case CPTS_EV_HW:
 188                         break;
 189                 default:
 190                         dev_err(cpts->dev, "cpts: unknown event type\n");
 191                         break;
 192                 }
 193                 if (type == match)
 194                         break;
 195         }
 196         return type == match ? 0 : -1;
 197 }
 198
 199 static u64 cpts_systim_read(const struct cyclecounter *cc)
 200 {
 201         struct cpts *cpts = container_of(cc, struct cpts, cc);
 202
 203         return READ_ONCE(cpts->cur_timestamp);
 204 }
 205
 206 static void cpts_update_cur_time(struct cpts *cpts, int match)
 207 {
 208         cpts_write32(cpts, TS_PUSH, ts_push);
 209
 210         if (cpts_fifo_read(cpts, match) && match != -1)
 211                 dev_err(cpts->dev, "cpts: unable to obtain a time stamp\n");
 212 }
 213
 214 /* PTP clock operations */
 215
 216 static int cpts_ptp_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
 217 {
 218         u64 adj;
 219         u32 diff, mult;
 220         int neg_adj = 0;
 221         unsigned long flags;
 222         struct cpts *cpts = container_of(ptp, struct cpts, info);
 223
 224         if (ppb < 0) {
 225                 neg_adj = 1;
 226                 ppb = -ppb;
 227         }
 228         mult = cpts->cc_mult;
 229         adj = mult;
 230         adj *= ppb;
 231         diff = div_u64(adj, 1000000000ULL);
 232
 233         spin_lock_irqsave(&cpts->lock, flags);
 234
 235         cpts->mult_new = neg_adj ? mult - diff : mult + diff;
 236
 237         cpts_update_cur_time(cpts, CPTS_EV_PUSH);
 238
 239         spin_unlock_irqrestore(&cpts->lock, flags);
 240
 241         return 0;
 242 }
 243
 244 static int cpts_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
 245 {
 246         unsigned long flags;
 247         struct cpts *cpts = container_of(ptp, struct cpts, info);
 248
 249         spin_lock_irqsave(&cpts->lock, flags);
 250         timecounter_adjtime(&cpts->tc, delta);
 251         spin_unlock_irqrestore(&cpts->lock, flags);
 252
 253         return 0;
 254 }
 255
 256 static int cpts_ptp_gettime(struct ptp_clock_info *ptp, struct timespec64 *ts)
 257 {
 258         u64 ns;
 259         unsigned long flags;
 260         struct cpts *cpts = container_of(ptp, struct cpts, info);
 261
 262         spin_lock_irqsave(&cpts->lock, flags);
 263
 264         cpts_update_cur_time(cpts, CPTS_EV_PUSH);
 265
 266         ns = timecounter_read(&cpts->tc);
 267         spin_unlock_irqrestore(&cpts->lock, flags);
 268
 269         *ts = ns_to_timespec64(ns);
 270
 271         return 0;
 272 }
 273
 274 static int cpts_ptp_settime(struct ptp_clock_info *ptp,
 275                             const struct timespec64 *ts)
 276 {
 277         u64 ns;
 278         unsigned long flags;
 279         struct cpts *cpts = container_of(ptp, struct cpts, info);
 280
 281         ns = timespec64_to_ns(ts);
 282
 283         spin_lock_irqsave(&cpts->lock, flags);
 284         timecounter_init(&cpts->tc, &cpts->cc, ns);
 285         spin_unlock_irqrestore(&cpts->lock, flags);
 286
 287         return 0;
 288 }
 289
 290 static int cpts_ptp_enable(struct ptp_clock_info *ptp,
 291                            struct ptp_clock_request *rq, int on)
 292 {
 293         return -EOPNOTSUPP;
 294 }
 295
 296 static long cpts_overflow_check(struct ptp_clock_info *ptp)
 297 {
 298         struct cpts *cpts = container_of(ptp, struct cpts, info);
 299         unsigned long delay = cpts->ov_check_period;
 300         unsigned long flags;
 301         u64 ns;
 302
 303         spin_lock_irqsave(&cpts->lock, flags);
 304
 305         cpts_update_cur_time(cpts, -1);
 306
 307         ns = timecounter_read(&cpts->tc);
 308
 309         if (!skb_queue_empty(&cpts->txq)) {
 310                 cpts_purge_txq(cpts);
 311                 if (!skb_queue_empty(&cpts->txq))
 312                         delay = CPTS_SKB_TX_WORK_TIMEOUT;
 313         }
 314         spin_unlock_irqrestore(&cpts->lock, flags);
 315
 316         dev_dbg(cpts->dev, "cpts overflow check at %lld\n", ns);
 317         return (long)delay;
 318 }
 319
 320 static const struct ptp_clock_info cpts_info = {
 321         .owner          = THIS_MODULE,
 322         .name           = "CTPS timer",
 323         .max_adj        = 1000000,
 324         .n_ext_ts       = 0,
 325         .n_pins         = 0,
 326         .pps            = 0,
 327         .adjfreq        = cpts_ptp_adjfreq,
 328         .adjtime        = cpts_ptp_adjtime,
 329         .gettime64      = cpts_ptp_gettime,
 330         .settime64      = cpts_ptp_settime,
 331         .enable         = cpts_ptp_enable,
 332         .do_aux_work    = cpts_overflow_check,
 333 };
 334
 335 static int cpts_match(struct sk_buff *skb, unsigned int ptp_class,
 336                       u16 ts_seqid, u8 ts_msgtype)
 337 {
 338         u16 *seqid;
 339         unsigned int offset = 0;
 340         u8 *msgtype, *data = skb->data;
 341
 342         if (ptp_class & PTP_CLASS_VLAN)
 343                 offset += VLAN_HLEN;
 344
 345         switch (ptp_class & PTP_CLASS_PMASK) {
 346         case PTP_CLASS_IPV4:
 347                 offset += ETH_HLEN + IPV4_HLEN(data + offset) + UDP_HLEN;
 348                 break;
 349         case PTP_CLASS_IPV6:
 350                 offset += ETH_HLEN + IP6_HLEN + UDP_HLEN;
 351                 break;
 352         case PTP_CLASS_L2:
 353                 offset += ETH_HLEN;
 354                 break;
 355         default:
 356                 return 0;
 357         }
 358
 359         if (skb->len + ETH_HLEN < offset + OFF_PTP_SEQUENCE_ID + sizeof(*seqid))
 360                 return 0;
 361
 362         if (unlikely(ptp_class & PTP_CLASS_V1))
 363                 msgtype = data + offset + OFF_PTP_CONTROL;
 364         else
 365                 msgtype = data + offset;
 366
 367         seqid = (u16 *)(data + offset + OFF_PTP_SEQUENCE_ID);
 368
 369         return (ts_msgtype == (*msgtype & 0xf) && ts_seqid == ntohs(*seqid));
 370 }
 371
 372 static u64 cpts_find_ts(struct cpts *cpts, struct sk_buff *skb, int ev_type)
 373 {
 374         u64 ns = 0;
 375         struct cpts_event *event;
 376         struct list_head *this, *next;
 377         unsigned int class = ptp_classify_raw(skb);
 378         unsigned long flags;
 379         u16 seqid;
 380         u8 mtype;
 381
 382         if (class == PTP_CLASS_NONE)
 383                 return 0;
 384
 385         spin_lock_irqsave(&cpts->lock, flags);
 386         cpts_fifo_read(cpts, -1);
 387         list_for_each_safe(this, next, &cpts->events) {
 388                 event = list_entry(this, struct cpts_event, list);
 389                 if (event_expired(event)) {
 390                         list_del_init(&event->list);
 391                         list_add(&event->list, &cpts->pool);
 392                         continue;
 393                 }
 394                 mtype = (event->high >> MESSAGE_TYPE_SHIFT) & MESSAGE_TYPE_MASK;
 395                 seqid = (event->high >> SEQUENCE_ID_SHIFT) & SEQUENCE_ID_MASK;
 396                 if (ev_type == event_type(event) &&
 397                     cpts_match(skb, class, seqid, mtype)) {
 398                         ns = event->timestamp;
 399                         list_del_init(&event->list);
 400                         list_add(&event->list, &cpts->pool);
 401                         break;
 402                 }
 403         }
 404
 405         if (ev_type == CPTS_EV_TX && !ns) {
 406                 struct cpts_skb_cb_data *skb_cb =
 407                                 (struct cpts_skb_cb_data *)skb->cb;
 408                 /* Not found, add frame to queue for processing later.
 409                  * The periodic FIFO check will handle this.
 410                  */
 411                 skb_get(skb);
 412                 /* get the timestamp for timeouts */
 413                 skb_cb->tmo = jiffies + msecs_to_jiffies(100);
 414                 __skb_queue_tail(&cpts->txq, skb);
 415                 ptp_schedule_worker(cpts->clock, 0);
 416         }
 417         spin_unlock_irqrestore(&cpts->lock, flags);
 418
 419         return ns;
 420 }
 421
 422 void cpts_rx_timestamp(struct cpts *cpts, struct sk_buff *skb)
 423 {
 424         u64 ns;
 425         struct skb_shared_hwtstamps *ssh;
 426
 427         ns = cpts_find_ts(cpts, skb, CPTS_EV_RX);
 428         if (!ns)
 429                 return;
 430         ssh = skb_hwtstamps(skb);
 431         memset(ssh, 0, sizeof(*ssh));
 432         ssh->hwtstamp = ns_to_ktime(ns);
 433 }
 434 EXPORT_SYMBOL_GPL(cpts_rx_timestamp);
 435
 436 void cpts_tx_timestamp(struct cpts *cpts, struct sk_buff *skb)
 437 {
 438         u64 ns;
 439         struct skb_shared_hwtstamps ssh;
 440
 441         if (!(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS))
 442                 return;
 443         ns = cpts_find_ts(cpts, skb, CPTS_EV_TX);
 444         if (!ns)
 445                 return;
 446         memset(&ssh, 0, sizeof(ssh));
 447         ssh.hwtstamp = ns_to_ktime(ns);
 448         skb_tstamp_tx(skb, &ssh);
 449 }
 450 EXPORT_SYMBOL_GPL(cpts_tx_timestamp);
 451
 452 int cpts_register(struct cpts *cpts)
 453 {
 454         int err, i;
 455
 456         skb_queue_head_init(&cpts->txq);
 457         INIT_LIST_HEAD(&cpts->events);
 458         INIT_LIST_HEAD(&cpts->pool);
 459         for (i = 0; i < CPTS_MAX_EVENTS; i++)
 460                 list_add(&cpts->pool_data[i].list, &cpts->pool);
 461
 462         clk_enable(cpts->refclk);
 463
 464         cpts_write32(cpts, CPTS_EN, control);
 465         cpts_write32(cpts, TS_PEND_EN, int_enable);
 466
 467         timecounter_init(&cpts->tc, &cpts->cc, ktime_get_real_ns());
 468
 469         cpts->clock = ptp_clock_register(&cpts->info, cpts->dev);
 470         if (IS_ERR(cpts->clock)) {
 471                 err = PTR_ERR(cpts->clock);
 472                 cpts->clock = NULL;
 473                 goto err_ptp;
 474         }
 475         cpts->phc_index = ptp_clock_index(cpts->clock);
 476
 477         ptp_schedule_worker(cpts->clock, cpts->ov_check_period);
 478         return 0;
 479
 480 err_ptp:
 481         clk_disable(cpts->refclk);
 482         return err;
 483 }
 484 EXPORT_SYMBOL_GPL(cpts_register);
 485
 486 void cpts_unregister(struct cpts *cpts)
 487 {
 488         if (WARN_ON(!cpts->clock))
 489                 return;
 490
 491         ptp_clock_unregister(cpts->clock);
 492         cpts->clock = NULL;
 493
 494         cpts_write32(cpts, 0, int_enable);
 495         cpts_write32(cpts, 0, control);
 496
 497         /* Drop all packet */
 498         skb_queue_purge(&cpts->txq);
 499
 500         clk_disable(cpts->refclk);
 501 }
 502 EXPORT_SYMBOL_GPL(cpts_unregister);
 503
 504 static void cpts_calc_mult_shift(struct cpts *cpts)
 505 {
 506         u64 frac, maxsec, ns;
 507         u32 freq;
 508
 509         freq = clk_get_rate(cpts->refclk);
 510
 511         /* Calc the maximum number of seconds which we can run before
 512          * wrapping around.
 513          */
 514         maxsec = cpts->cc.mask;
 515         do_div(maxsec, freq);
 516         /* limit conversation rate to 10 sec as higher values will produce
 517          * too small mult factors and so reduce the conversion accuracy
 518          */
 519         if (maxsec > 10)
 520                 maxsec = 10;
 521
 522         /* Calc overflow check period (maxsec / 2) */
 523         cpts->ov_check_period = (HZ * maxsec) / 2;
 524         dev_info(cpts->dev, "cpts: overflow check period %lu (jiffies)\n",
 525                  cpts->ov_check_period);
 526
 527         if (cpts->cc.mult || cpts->cc.shift)
 528                 return;
 529
 530         clocks_calc_mult_shift(&cpts->cc.mult, &cpts->cc.shift,
 531                                freq, NSEC_PER_SEC, maxsec);
 532
 533         frac = 0;
 534         ns = cyclecounter_cyc2ns(&cpts->cc, freq, cpts->cc.mask, &frac);
 535
 536         dev_info(cpts->dev,
 537                  "CPTS: ref_clk_freq:%u calc_mult:%u calc_shift:%u error:%lld nsec/sec\n",
 538                  freq, cpts->cc.mult, cpts->cc.shift, (ns - NSEC_PER_SEC));
 539 }
 540
 541 static int cpts_of_mux_clk_setup(struct cpts *cpts, struct device_node *node)
 542 {
 543         struct device_node *refclk_np;
 544         const char **parent_names;
 545         unsigned int num_parents;
 546         struct clk_hw *clk_hw;
 547         int ret = -EINVAL;
 548         u32 *mux_table;
 549
 550         refclk_np = of_get_child_by_name(node, "cpts-refclk-mux");
 551         if (!refclk_np)
 552                 /* refclk selection supported not for all SoCs */
 553                 return 0;
 554
 555         num_parents = of_clk_get_parent_count(refclk_np);
 556         if (num_parents < 1) {
 557                 dev_err(cpts->dev, "mux-clock %s must have parents\n",
 558                         refclk_np->name);
 559                 goto mux_fail;
 560         }
 561
 562         parent_names = devm_kzalloc(cpts->dev, (sizeof(char *) * num_parents),
 563                                     GFP_KERNEL);
 564
 565         mux_table = devm_kzalloc(cpts->dev, sizeof(*mux_table) * num_parents,
 566                                  GFP_KERNEL);
 567         if (!mux_table || !parent_names) {
 568                 ret = -ENOMEM;
 569                 goto mux_fail;
 570         }
 571
 572         of_clk_parent_fill(refclk_np, parent_names, num_parents);
 573
 574         ret = of_property_read_variable_u32_array(refclk_np, "ti,mux-tbl",
 575                                                   mux_table,
 576                                                   num_parents, num_parents);
 577         if (ret < 0)
 578                 goto mux_fail;
 579
 580         clk_hw = clk_hw_register_mux_table(cpts->dev, refclk_np->name,
 581                                            parent_names, num_parents,
 582                                            0,
 583                                            &cpts->reg->rftclk_sel, 0, 0x1F,
 584                                            0, mux_table, NULL);
 585         if (IS_ERR(clk_hw)) {
 586                 ret = PTR_ERR(clk_hw);
 587                 goto mux_fail;
 588         }
 589
 590         ret = devm_add_action_or_reset(cpts->dev,
 591                                        (void(*)(void *))clk_hw_unregister_mux,
 592                                        clk_hw);
 593         if (ret) {
 594                 dev_err(cpts->dev, "add clkmux unreg action %d", ret);
 595                 goto mux_fail;
 596         }
 597
 598         ret = of_clk_add_hw_provider(refclk_np, of_clk_hw_simple_get, clk_hw);
 599         if (ret)
 600                 goto mux_fail;
 601
 602         ret = devm_add_action_or_reset(cpts->dev,
 603                                        (void(*)(void *))of_clk_del_provider,
 604                                        refclk_np);
 605         if (ret) {
 606                 dev_err(cpts->dev, "add clkmux provider unreg action %d", ret);
 607                 goto mux_fail;
 608         }
 609
 610         return ret;
 611
 612 mux_fail:
 613         of_node_put(refclk_np);
 614         return ret;
 615 }
 616
 617 static int cpts_of_parse(struct cpts *cpts, struct device_node *node)
 618 {
 619         int ret = -EINVAL;
 620         u32 prop;
 621
 622         if (!of_property_read_u32(node, "cpts_clock_mult", &prop))
 623                 cpts->cc.mult = prop;
 624
 625         if (!of_property_read_u32(node, "cpts_clock_shift", &prop))
 626                 cpts->cc.shift = prop;
 627
 628         if ((cpts->cc.mult && !cpts->cc.shift) ||
 629             (!cpts->cc.mult && cpts->cc.shift))
 630                 goto of_error;
 631
 632         return cpts_of_mux_clk_setup(cpts, node);
 633
 634 of_error:
 635         dev_err(cpts->dev, "CPTS: Missing property in the DT.\n");
 636         return ret;
 637 }
 638
 639 struct cpts *cpts_create(struct device *dev, void __iomem *regs,
 640                          struct device_node *node)
 641 {
 642         struct cpts *cpts;
 643         int ret;
 644
 645         cpts = devm_kzalloc(dev, sizeof(*cpts), GFP_KERNEL);
 646         if (!cpts)
 647                 return ERR_PTR(-ENOMEM);
 648
 649         cpts->dev = dev;
 650         cpts->reg = (struct cpsw_cpts __iomem *)regs;
 651         spin_lock_init(&cpts->lock);
 652
 653         ret = cpts_of_parse(cpts, node);
 654         if (ret)
 655                 return ERR_PTR(ret);
 656
 657         cpts->refclk = devm_get_clk_from_child(dev, node, "cpts");
 658         if (IS_ERR(cpts->refclk))
 659                 /* try get clk from dev node for compatibility */
 660                 cpts->refclk = devm_clk_get(dev, "cpts");
 661
 662         if (IS_ERR(cpts->refclk)) {
 663                 dev_err(dev, "Failed to get cpts refclk %ld\n",
 664                         PTR_ERR(cpts->refclk));
 665                 return ERR_CAST(cpts->refclk);
 666         }
 667
 668         ret = clk_prepare(cpts->refclk);
 669         if (ret)
 670                 return ERR_PTR(ret);
 671
 672         cpts->cc.read = cpts_systim_read;
 673         cpts->cc.mask = CLOCKSOURCE_MASK(32);
 674         cpts->info = cpts_info;
 675
 676         cpts_calc_mult_shift(cpts);
 677         /* save cc.mult original value as it can be modified
 678          * by cpts_ptp_adjfreq().
 679          */
 680         cpts->cc_mult = cpts->cc.mult;
 681
 682         return cpts;
 683 }
 684 EXPORT_SYMBOL_GPL(cpts_create);
 685
 686 void cpts_release(struct cpts *cpts)
 687 {
 688         if (!cpts)
 689                 return;
 690
 691         if (WARN_ON(!cpts->refclk))
 692                 return;
 693
 694         clk_unprepare(cpts->refclk);
 695 }
 696 EXPORT_SYMBOL_GPL(cpts_release);
 697
 698 MODULE_LICENSE("GPL v2");
 699 MODULE_DESCRIPTION("TI CPTS driver");
 700 MODULE_AUTHOR("Richard Cochran <richardcochran@gmail.com>");