drivers/ptp/ptp_qoriq.c

   1 /*
   2  * PTP 1588 clock for Freescale QorIQ 1588 timer
   3  *
   4  * Copyright (C) 2010 OMICRON electronics GmbH
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  22
  23 #include <linux/device.h>
  24 #include <linux/hrtimer.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/kernel.h>
  27 #include <linux/module.h>
  28 #include <linux/of.h>
  29 #include <linux/of_platform.h>
  30 #include <linux/timex.h>
  31 #include <linux/slab.h>
  32
  33 #include <linux/fsl/ptp_qoriq.h>
  34
  35 /*
  36  * Register access functions
  37  */
  38
  39 /* Caller must hold qoriq_ptp->lock. */
  40 static u64 tmr_cnt_read(struct qoriq_ptp *qoriq_ptp)
  41 {
  42         u64 ns;
  43         u32 lo, hi;
  44
  45         lo = qoriq_read(&qoriq_ptp->regs->tmr_cnt_l);
  46         hi = qoriq_read(&qoriq_ptp->regs->tmr_cnt_h);
  47         ns = ((u64) hi) << 32;
  48         ns |= lo;
  49         return ns;
  50 }
  51
  52 /* Caller must hold qoriq_ptp->lock. */
  53 static void tmr_cnt_write(struct qoriq_ptp *qoriq_ptp, u64 ns)
  54 {
  55         u32 hi = ns >> 32;
  56         u32 lo = ns & 0xffffffff;
  57
  58         qoriq_write(&qoriq_ptp->regs->tmr_cnt_l, lo);
  59         qoriq_write(&qoriq_ptp->regs->tmr_cnt_h, hi);
  60 }
  61
  62 /* Caller must hold qoriq_ptp->lock. */
  63 static void set_alarm(struct qoriq_ptp *qoriq_ptp)
  64 {
  65         u64 ns;
  66         u32 lo, hi;
  67
  68         ns = tmr_cnt_read(qoriq_ptp) + 1500000000ULL;
  69         ns = div_u64(ns, 1000000000UL) * 1000000000ULL;
  70         ns -= qoriq_ptp->tclk_period;
  71         hi = ns >> 32;
  72         lo = ns & 0xffffffff;
  73         qoriq_write(&qoriq_ptp->regs->tmr_alarm1_l, lo);
  74         qoriq_write(&qoriq_ptp->regs->tmr_alarm1_h, hi);
  75 }
  76
  77 /* Caller must hold qoriq_ptp->lock. */
  78 static void set_fipers(struct qoriq_ptp *qoriq_ptp)
  79 {
  80         set_alarm(qoriq_ptp);
  81         qoriq_write(&qoriq_ptp->regs->tmr_fiper1, qoriq_ptp->tmr_fiper1);
  82         qoriq_write(&qoriq_ptp->regs->tmr_fiper2, qoriq_ptp->tmr_fiper2);
  83 }
  84
  85 /*
  86  * Interrupt service routine
  87  */
  88
  89 static irqreturn_t isr(int irq, void *priv)
  90 {
  91         struct qoriq_ptp *qoriq_ptp = priv;
  92         struct ptp_clock_event event;
  93         u64 ns;
  94         u32 ack = 0, lo, hi, mask, val;
  95
  96         val = qoriq_read(&qoriq_ptp->regs->tmr_tevent);
  97
  98         if (val & ETS1) {
  99                 ack |= ETS1;
 100                 hi = qoriq_read(&qoriq_ptp->regs->tmr_etts1_h);
 101                 lo = qoriq_read(&qoriq_ptp->regs->tmr_etts1_l);
 102                 event.type = PTP_CLOCK_EXTTS;
 103                 event.index = 0;
 104                 event.timestamp = ((u64) hi) << 32;
 105                 event.timestamp |= lo;
 106                 ptp_clock_event(qoriq_ptp->clock, &event);
 107         }
 108
 109         if (val & ETS2) {
 110                 ack |= ETS2;
 111                 hi = qoriq_read(&qoriq_ptp->regs->tmr_etts2_h);
 112                 lo = qoriq_read(&qoriq_ptp->regs->tmr_etts2_l);
 113                 event.type = PTP_CLOCK_EXTTS;
 114                 event.index = 1;
 115                 event.timestamp = ((u64) hi) << 32;
 116                 event.timestamp |= lo;
 117                 ptp_clock_event(qoriq_ptp->clock, &event);
 118         }
 119
 120         if (val & ALM2) {
 121                 ack |= ALM2;
 122                 if (qoriq_ptp->alarm_value) {
 123                         event.type = PTP_CLOCK_ALARM;
 124                         event.index = 0;
 125                         event.timestamp = qoriq_ptp->alarm_value;
 126                         ptp_clock_event(qoriq_ptp->clock, &event);
 127                 }
 128                 if (qoriq_ptp->alarm_interval) {
 129                         ns = qoriq_ptp->alarm_value + qoriq_ptp->alarm_interval;
 130                         hi = ns >> 32;
 131                         lo = ns & 0xffffffff;
 132                         spin_lock(&qoriq_ptp->lock);
 133                         qoriq_write(&qoriq_ptp->regs->tmr_alarm2_l, lo);
 134                         qoriq_write(&qoriq_ptp->regs->tmr_alarm2_h, hi);
 135                         spin_unlock(&qoriq_ptp->lock);
 136                         qoriq_ptp->alarm_value = ns;
 137                 } else {
 138                         qoriq_write(&qoriq_ptp->regs->tmr_tevent, ALM2);
 139                         spin_lock(&qoriq_ptp->lock);
 140                         mask = qoriq_read(&qoriq_ptp->regs->tmr_temask);
 141                         mask &= ~ALM2EN;
 142                         qoriq_write(&qoriq_ptp->regs->tmr_temask, mask);
 143                         spin_unlock(&qoriq_ptp->lock);
 144                         qoriq_ptp->alarm_value = 0;
 145                         qoriq_ptp->alarm_interval = 0;
 146                 }
 147         }
 148
 149         if (val & PP1) {
 150                 ack |= PP1;
 151                 event.type = PTP_CLOCK_PPS;
 152                 ptp_clock_event(qoriq_ptp->clock, &event);
 153         }
 154
 155         if (ack) {
 156                 qoriq_write(&qoriq_ptp->regs->tmr_tevent, ack);
 157                 return IRQ_HANDLED;
 158         } else
 159                 return IRQ_NONE;
 160 }
 161
 162 /*
 163  * PTP clock operations
 164  */
 165
 166 static int ptp_qoriq_adjfine(struct ptp_clock_info *ptp, long scaled_ppm)
 167 {
 168         u64 adj, diff;
 169         u32 tmr_add;
 170         int neg_adj = 0;
 171         struct qoriq_ptp *qoriq_ptp = container_of(ptp, struct qoriq_ptp, caps);
 172
 173         if (scaled_ppm < 0) {
 174                 neg_adj = 1;
 175                 scaled_ppm = -scaled_ppm;
 176         }
 177         tmr_add = qoriq_ptp->tmr_add;
 178         adj = tmr_add;
 179
 180         /* calculate diff as adj*(scaled_ppm/65536)/1000000
 181          * and round() to the nearest integer
 182          */
 183         adj *= scaled_ppm;
 184         diff = div_u64(adj, 8000000);
 185         diff = (diff >> 13) + ((diff >> 12) & 1);
 186
 187         tmr_add = neg_adj ? tmr_add - diff : tmr_add + diff;
 188
 189         qoriq_write(&qoriq_ptp->regs->tmr_add, tmr_add);
 190
 191         return 0;
 192 }
 193
 194 static int ptp_qoriq_adjtime(struct ptp_clock_info *ptp, s64 delta)
 195 {
 196         s64 now;
 197         unsigned long flags;
 198         struct qoriq_ptp *qoriq_ptp = container_of(ptp, struct qoriq_ptp, caps);
 199
 200         spin_lock_irqsave(&qoriq_ptp->lock, flags);
 201
 202         now = tmr_cnt_read(qoriq_ptp);
 203         now += delta;
 204         tmr_cnt_write(qoriq_ptp, now);
 205         set_fipers(qoriq_ptp);
 206
 207         spin_unlock_irqrestore(&qoriq_ptp->lock, flags);
 208
 209         return 0;
 210 }
 211
 212 static int ptp_qoriq_gettime(struct ptp_clock_info *ptp,
 213                                struct timespec64 *ts)
 214 {
 215         u64 ns;
 216         unsigned long flags;
 217         struct qoriq_ptp *qoriq_ptp = container_of(ptp, struct qoriq_ptp, caps);
 218
 219         spin_lock_irqsave(&qoriq_ptp->lock, flags);
 220
 221         ns = tmr_cnt_read(qoriq_ptp);
 222
 223         spin_unlock_irqrestore(&qoriq_ptp->lock, flags);
 224
 225         *ts = ns_to_timespec64(ns);
 226
 227         return 0;
 228 }
 229
 230 static int ptp_qoriq_settime(struct ptp_clock_info *ptp,
 231                                const struct timespec64 *ts)
 232 {
 233         u64 ns;
 234         unsigned long flags;
 235         struct qoriq_ptp *qoriq_ptp = container_of(ptp, struct qoriq_ptp, caps);
 236
 237         ns = timespec64_to_ns(ts);
 238
 239         spin_lock_irqsave(&qoriq_ptp->lock, flags);
 240
 241         tmr_cnt_write(qoriq_ptp, ns);
 242         set_fipers(qoriq_ptp);
 243
 244         spin_unlock_irqrestore(&qoriq_ptp->lock, flags);
 245
 246         return 0;
 247 }
 248
 249 static int ptp_qoriq_enable(struct ptp_clock_info *ptp,
 250                               struct ptp_clock_request *rq, int on)
 251 {
 252         struct qoriq_ptp *qoriq_ptp = container_of(ptp, struct qoriq_ptp, caps);
 253         unsigned long flags;
 254         u32 bit, mask;
 255
 256         switch (rq->type) {
 257         case PTP_CLK_REQ_EXTTS:
 258                 switch (rq->extts.index) {
 259                 case 0:
 260                         bit = ETS1EN;
 261                         break;
 262                 case 1:
 263                         bit = ETS2EN;
 264                         break;
 265                 default:
 266                         return -EINVAL;
 267                 }
 268                 spin_lock_irqsave(&qoriq_ptp->lock, flags);
 269                 mask = qoriq_read(&qoriq_ptp->regs->tmr_temask);
 270                 if (on)
 271                         mask |= bit;
 272                 else
 273                         mask &= ~bit;
 274                 qoriq_write(&qoriq_ptp->regs->tmr_temask, mask);
 275                 spin_unlock_irqrestore(&qoriq_ptp->lock, flags);
 276                 return 0;
 277
 278         case PTP_CLK_REQ_PPS:
 279                 spin_lock_irqsave(&qoriq_ptp->lock, flags);
 280                 mask = qoriq_read(&qoriq_ptp->regs->tmr_temask);
 281                 if (on)
 282                         mask |= PP1EN;
 283                 else
 284                         mask &= ~PP1EN;
 285                 qoriq_write(&qoriq_ptp->regs->tmr_temask, mask);
 286                 spin_unlock_irqrestore(&qoriq_ptp->lock, flags);
 287                 return 0;
 288
 289         default:
 290                 break;
 291         }
 292
 293         return -EOPNOTSUPP;
 294 }
 295
 296 static const struct ptp_clock_info ptp_qoriq_caps = {
 297         .owner          = THIS_MODULE,
 298         .name           = "qoriq ptp clock",
 299         .max_adj        = 512000,
 300         .n_alarm        = 0,
 301         .n_ext_ts       = N_EXT_TS,
 302         .n_per_out      = 0,
 303         .n_pins         = 0,
 304         .pps            = 1,
 305         .adjfine        = ptp_qoriq_adjfine,
 306         .adjtime        = ptp_qoriq_adjtime,
 307         .gettime64      = ptp_qoriq_gettime,
 308         .settime64      = ptp_qoriq_settime,
 309         .enable         = ptp_qoriq_enable,
 310 };
 311
 312 static int qoriq_ptp_probe(struct platform_device *dev)
 313 {
 314         struct device_node *node = dev->dev.of_node;
 315         struct qoriq_ptp *qoriq_ptp;
 316         struct timespec64 now;
 317         int err = -ENOMEM;
 318         u32 tmr_ctrl;
 319         unsigned long flags;
 320
 321         qoriq_ptp = kzalloc(sizeof(*qoriq_ptp), GFP_KERNEL);
 322         if (!qoriq_ptp)
 323                 goto no_memory;
 324
 325         err = -ENODEV;
 326
 327         qoriq_ptp->caps = ptp_qoriq_caps;
 328
 329         if (of_property_read_u32(node, "fsl,cksel", &qoriq_ptp->cksel))
 330                 qoriq_ptp->cksel = DEFAULT_CKSEL;
 331
 332         if (of_property_read_u32(node,
 333                                  "fsl,tclk-period", &qoriq_ptp->tclk_period) ||
 334             of_property_read_u32(node,
 335                                  "fsl,tmr-prsc", &qoriq_ptp->tmr_prsc) ||
 336             of_property_read_u32(node,
 337                                  "fsl,tmr-add", &qoriq_ptp->tmr_add) ||
 338             of_property_read_u32(node,
 339                                  "fsl,tmr-fiper1", &qoriq_ptp->tmr_fiper1) ||
 340             of_property_read_u32(node,
 341                                  "fsl,tmr-fiper2", &qoriq_ptp->tmr_fiper2) ||
 342             of_property_read_u32(node,
 343                                  "fsl,max-adj", &qoriq_ptp->caps.max_adj)) {
 344                 pr_err("device tree node missing required elements\n");
 345                 goto no_node;
 346         }
 347
 348         qoriq_ptp->irq = platform_get_irq(dev, 0);
 349
 350         if (qoriq_ptp->irq < 0) {
 351                 pr_err("irq not in device tree\n");
 352                 goto no_node;
 353         }
 354         if (request_irq(qoriq_ptp->irq, isr, 0, DRIVER, qoriq_ptp)) {
 355                 pr_err("request_irq failed\n");
 356                 goto no_node;
 357         }
 358
 359         qoriq_ptp->rsrc = platform_get_resource(dev, IORESOURCE_MEM, 0);
 360         if (!qoriq_ptp->rsrc) {
 361                 pr_err("no resource\n");
 362                 goto no_resource;
 363         }
 364         if (request_resource(&iomem_resource, qoriq_ptp->rsrc)) {
 365                 pr_err("resource busy\n");
 366                 goto no_resource;
 367         }
 368
 369         spin_lock_init(&qoriq_ptp->lock);
 370
 371         qoriq_ptp->regs = ioremap(qoriq_ptp->rsrc->start,
 372                                 resource_size(qoriq_ptp->rsrc));
 373         if (!qoriq_ptp->regs) {
 374                 pr_err("ioremap ptp registers failed\n");
 375                 goto no_ioremap;
 376         }
 377         getnstimeofday64(&now);
 378         ptp_qoriq_settime(&qoriq_ptp->caps, &now);
 379
 380         tmr_ctrl =
 381           (qoriq_ptp->tclk_period & TCLK_PERIOD_MASK) << TCLK_PERIOD_SHIFT |
 382           (qoriq_ptp->cksel & CKSEL_MASK) << CKSEL_SHIFT;
 383
 384         spin_lock_irqsave(&qoriq_ptp->lock, flags);
 385
 386         qoriq_write(&qoriq_ptp->regs->tmr_ctrl,   tmr_ctrl);
 387         qoriq_write(&qoriq_ptp->regs->tmr_add,    qoriq_ptp->tmr_add);
 388         qoriq_write(&qoriq_ptp->regs->tmr_prsc,   qoriq_ptp->tmr_prsc);
 389         qoriq_write(&qoriq_ptp->regs->tmr_fiper1, qoriq_ptp->tmr_fiper1);
 390         qoriq_write(&qoriq_ptp->regs->tmr_fiper2, qoriq_ptp->tmr_fiper2);
 391         set_alarm(qoriq_ptp);
 392         qoriq_write(&qoriq_ptp->regs->tmr_ctrl,   tmr_ctrl|FIPERST|RTPE|TE|FRD);
 393
 394         spin_unlock_irqrestore(&qoriq_ptp->lock, flags);
 395
 396         qoriq_ptp->clock = ptp_clock_register(&qoriq_ptp->caps, &dev->dev);
 397         if (IS_ERR(qoriq_ptp->clock)) {
 398                 err = PTR_ERR(qoriq_ptp->clock);
 399                 goto no_clock;
 400         }
 401         qoriq_ptp->phc_index = ptp_clock_index(qoriq_ptp->clock);
 402
 403         platform_set_drvdata(dev, qoriq_ptp);
 404
 405         return 0;
 406
 407 no_clock:
 408         iounmap(qoriq_ptp->regs);
 409 no_ioremap:
 410         release_resource(qoriq_ptp->rsrc);
 411 no_resource:
 412         free_irq(qoriq_ptp->irq, qoriq_ptp);
 413 no_node:
 414         kfree(qoriq_ptp);
 415 no_memory:
 416         return err;
 417 }
 418
 419 static int qoriq_ptp_remove(struct platform_device *dev)
 420 {
 421         struct qoriq_ptp *qoriq_ptp = platform_get_drvdata(dev);
 422
 423         qoriq_write(&qoriq_ptp->regs->tmr_temask, 0);
 424         qoriq_write(&qoriq_ptp->regs->tmr_ctrl,   0);
 425
 426         ptp_clock_unregister(qoriq_ptp->clock);
 427         iounmap(qoriq_ptp->regs);
 428         release_resource(qoriq_ptp->rsrc);
 429         free_irq(qoriq_ptp->irq, qoriq_ptp);
 430         kfree(qoriq_ptp);
 431
 432         return 0;
 433 }
 434
 435 static const struct of_device_id match_table[] = {
 436         { .compatible = "fsl,etsec-ptp" },
 437         {},
 438 };
 439 MODULE_DEVICE_TABLE(of, match_table);
 440
 441 static struct platform_driver qoriq_ptp_driver = {
 442         .driver = {
 443                 .name           = "ptp_qoriq",
 444                 .of_match_table = match_table,
 445         },
 446         .probe       = qoriq_ptp_probe,
 447         .remove      = qoriq_ptp_remove,
 448 };
 449
 450 module_platform_driver(qoriq_ptp_driver);
 451
 452 MODULE_AUTHOR("Richard Cochran <richardcochran@gmail.com>");
 453 MODULE_DESCRIPTION("PTP clock for Freescale QorIQ 1588 timer");
 454 MODULE_LICENSE("GPL");