drivers/net/ethernet/marvell/octeontx2/nic/otx2_ptp.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Marvell RVU Ethernet driver
   3  *
   4  * Copyright (C) 2020 Marvell.
   5  *
   6  */
   7
   8 #include <linux/module.h>
   9
  10 #include "otx2_common.h"
  11 #include "otx2_ptp.h"
  12
  13 static bool is_tstmp_atomic_update_supported(struct otx2_ptp *ptp)
  14 {
  15         struct ptp_get_cap_rsp *rsp;
  16         struct msg_req *req;
  17         int err;
  18
  19         if (!ptp->nic)
  20                 return false;
  21
  22         mutex_lock(&ptp->nic->mbox.lock);
  23         req = otx2_mbox_alloc_msg_ptp_get_cap(&ptp->nic->mbox);
  24         if (!req) {
  25                 mutex_unlock(&ptp->nic->mbox.lock);
  26                 return false;
  27         }
  28
  29         err = otx2_sync_mbox_msg(&ptp->nic->mbox);
  30         if (err) {
  31                 mutex_unlock(&ptp->nic->mbox.lock);
  32                 return false;
  33         }
  34         rsp = (struct ptp_get_cap_rsp *)otx2_mbox_get_rsp(&ptp->nic->mbox.mbox, 0,
  35                                                           &req->hdr);
  36         mutex_unlock(&ptp->nic->mbox.lock);
  37
  38         if (IS_ERR(rsp))
  39                 return false;
  40
  41         if (rsp->cap & PTP_CAP_HW_ATOMIC_UPDATE)
  42                 return true;
  43
  44         return false;
  45 }
  46
  47 static int otx2_ptp_hw_adjtime(struct ptp_clock_info *ptp_info, s64 delta)
  48 {
  49         struct otx2_ptp *ptp = container_of(ptp_info, struct otx2_ptp,
  50                                             ptp_info);
  51         struct otx2_nic *pfvf = ptp->nic;
  52         struct ptp_req *req;
  53         int rc;
  54
  55         if (!ptp->nic)
  56                 return -ENODEV;
  57
  58         mutex_lock(&pfvf->mbox.lock);
  59         req = otx2_mbox_alloc_msg_ptp_op(&ptp->nic->mbox);
  60         if (!req) {
  61                 mutex_unlock(&pfvf->mbox.lock);
  62                 return -ENOMEM;
  63         }
  64         req->op = PTP_OP_ADJTIME;
  65         req->delta = delta;
  66         rc = otx2_sync_mbox_msg(&ptp->nic->mbox);
  67         mutex_unlock(&pfvf->mbox.lock);
  68
  69         return rc;
  70 }
  71
  72 static u64 otx2_ptp_get_clock(struct otx2_ptp *ptp)
  73 {
  74         struct ptp_req *req;
  75         struct ptp_rsp *rsp;
  76         int err;
  77
  78         if (!ptp->nic)
  79                 return 0;
  80
  81         req = otx2_mbox_alloc_msg_ptp_op(&ptp->nic->mbox);
  82         if (!req)
  83                 return 0;
  84
  85         req->op = PTP_OP_GET_CLOCK;
  86
  87         err = otx2_sync_mbox_msg(&ptp->nic->mbox);
  88         if (err)
  89                 return 0;
  90
  91         rsp = (struct ptp_rsp *)otx2_mbox_get_rsp(&ptp->nic->mbox.mbox, 0,
  92                                                   &req->hdr);
  93         if (IS_ERR(rsp))
  94                 return 0;
  95
  96         return rsp->clk;
  97 }
  98
  99 static int otx2_ptp_hw_gettime(struct ptp_clock_info *ptp_info,
 100                                struct timespec64 *ts)
 101 {
 102         struct otx2_ptp *ptp = container_of(ptp_info, struct otx2_ptp,
 103                                             ptp_info);
 104         u64 tstamp;
 105
 106         tstamp = otx2_ptp_get_clock(ptp);
 107
 108         *ts = ns_to_timespec64(tstamp);
 109         return 0;
 110 }
 111
 112 static int otx2_ptp_hw_settime(struct ptp_clock_info *ptp_info,
 113                                const struct timespec64 *ts)
 114 {
 115         struct otx2_ptp *ptp = container_of(ptp_info, struct otx2_ptp,
 116                                             ptp_info);
 117         struct otx2_nic *pfvf = ptp->nic;
 118         struct ptp_req *req;
 119         u64 nsec;
 120         int rc;
 121
 122         if (!ptp->nic)
 123                 return -ENODEV;
 124
 125         nsec = timespec64_to_ns(ts);
 126
 127         mutex_lock(&pfvf->mbox.lock);
 128         req = otx2_mbox_alloc_msg_ptp_op(&ptp->nic->mbox);
 129         if (!req) {
 130                 mutex_unlock(&pfvf->mbox.lock);
 131                 return -ENOMEM;
 132         }
 133
 134         req->op = PTP_OP_SET_CLOCK;
 135         req->clk = nsec;
 136         rc = otx2_sync_mbox_msg(&ptp->nic->mbox);
 137         mutex_unlock(&pfvf->mbox.lock);
 138
 139         return rc;
 140 }
 141
 142 static int otx2_ptp_adjfine(struct ptp_clock_info *ptp_info, long scaled_ppm)
 143 {
 144         struct otx2_ptp *ptp = container_of(ptp_info, struct otx2_ptp,
 145                                             ptp_info);
 146         struct ptp_req *req;
 147
 148         if (!ptp->nic)
 149                 return -ENODEV;
 150
 151         req = otx2_mbox_alloc_msg_ptp_op(&ptp->nic->mbox);
 152         if (!req)
 153                 return -ENOMEM;
 154
 155         req->op = PTP_OP_ADJFINE;
 156         req->scaled_ppm = scaled_ppm;
 157
 158         return otx2_sync_mbox_msg(&ptp->nic->mbox);
 159 }
 160
 161 static int ptp_set_thresh(struct otx2_ptp *ptp, u64 thresh)
 162 {
 163         struct ptp_req *req;
 164
 165         if (!ptp->nic)
 166                 return -ENODEV;
 167
 168         req = otx2_mbox_alloc_msg_ptp_op(&ptp->nic->mbox);
 169         if (!req)
 170                 return -ENOMEM;
 171
 172         req->op = PTP_OP_SET_THRESH;
 173         req->thresh = thresh;
 174
 175         return otx2_sync_mbox_msg(&ptp->nic->mbox);
 176 }
 177
 178 static int ptp_pps_on(struct otx2_ptp *ptp, int on, u64 period)
 179 {
 180         struct ptp_req *req;
 181
 182         if (!ptp->nic)
 183                 return -ENODEV;
 184
 185         req = otx2_mbox_alloc_msg_ptp_op(&ptp->nic->mbox);
 186         if (!req)
 187                 return -ENOMEM;
 188
 189         req->op = PTP_OP_PPS_ON;
 190         req->pps_on = on;
 191         req->period = period;
 192
 193         return otx2_sync_mbox_msg(&ptp->nic->mbox);
 194 }
 195
 196 static u64 ptp_cc_read(const struct cyclecounter *cc)
 197 {
 198         struct otx2_ptp *ptp = container_of(cc, struct otx2_ptp, cycle_counter);
 199
 200         return otx2_ptp_get_clock(ptp);
 201 }
 202
 203 static u64 ptp_tstmp_read(struct otx2_ptp *ptp)
 204 {
 205         struct ptp_req *req;
 206         struct ptp_rsp *rsp;
 207         int err;
 208
 209         if (!ptp->nic)
 210                 return 0;
 211
 212         req = otx2_mbox_alloc_msg_ptp_op(&ptp->nic->mbox);
 213         if (!req)
 214                 return 0;
 215
 216         req->op = PTP_OP_GET_TSTMP;
 217
 218         err = otx2_sync_mbox_msg(&ptp->nic->mbox);
 219         if (err)
 220                 return 0;
 221
 222         rsp = (struct ptp_rsp *)otx2_mbox_get_rsp(&ptp->nic->mbox.mbox, 0,
 223                                                   &req->hdr);
 224         if (IS_ERR(rsp))
 225                 return 0;
 226
 227         return rsp->clk;
 228 }
 229
 230 static int otx2_ptp_tc_adjtime(struct ptp_clock_info *ptp_info, s64 delta)
 231 {
 232         struct otx2_ptp *ptp = container_of(ptp_info, struct otx2_ptp,
 233                                             ptp_info);
 234         struct otx2_nic *pfvf = ptp->nic;
 235
 236         mutex_lock(&pfvf->mbox.lock);
 237         timecounter_adjtime(&ptp->time_counter, delta);
 238         mutex_unlock(&pfvf->mbox.lock);
 239
 240         return 0;
 241 }
 242
 243 static int otx2_ptp_tc_gettime(struct ptp_clock_info *ptp_info,
 244                                struct timespec64 *ts)
 245 {
 246         struct otx2_ptp *ptp = container_of(ptp_info, struct otx2_ptp,
 247                                             ptp_info);
 248         u64 tstamp;
 249
 250         mutex_lock(&ptp->nic->mbox.lock);
 251         tstamp = timecounter_read(&ptp->time_counter);
 252         mutex_unlock(&ptp->nic->mbox.lock);
 253         *ts = ns_to_timespec64(tstamp);
 254
 255         return 0;
 256 }
 257
 258 static int otx2_ptp_tc_settime(struct ptp_clock_info *ptp_info,
 259                                const struct timespec64 *ts)
 260 {
 261         struct otx2_ptp *ptp = container_of(ptp_info, struct otx2_ptp,
 262                                             ptp_info);
 263         u64 nsec;
 264
 265         nsec = timespec64_to_ns(ts);
 266
 267         mutex_lock(&ptp->nic->mbox.lock);
 268         timecounter_init(&ptp->time_counter, &ptp->cycle_counter, nsec);
 269         mutex_unlock(&ptp->nic->mbox.lock);
 270
 271         return 0;
 272 }
 273
 274 static int otx2_ptp_verify_pin(struct ptp_clock_info *ptp, unsigned int pin,
 275                                enum ptp_pin_function func, unsigned int chan)
 276 {
 277         switch (func) {
 278         case PTP_PF_NONE:
 279         case PTP_PF_EXTTS:
 280         case PTP_PF_PEROUT:
 281                 break;
 282         case PTP_PF_PHYSYNC:
 283                 return -1;
 284         }
 285         return 0;
 286 }
 287
 288 static u64 otx2_ptp_hw_tstamp2time(const struct timecounter *time_counter, u64 tstamp)
 289 {
 290         /* On HW which supports atomic updates, timecounter is not initialized */
 291         return tstamp;
 292 }
 293
 294 static void otx2_ptp_extts_check(struct work_struct *work)
 295 {
 296         struct otx2_ptp *ptp = container_of(work, struct otx2_ptp,
 297                                             extts_work.work);
 298         struct ptp_clock_event event;
 299         u64 tstmp, new_thresh;
 300
 301         mutex_lock(&ptp->nic->mbox.lock);
 302         tstmp = ptp_tstmp_read(ptp);
 303         mutex_unlock(&ptp->nic->mbox.lock);
 304
 305         if (tstmp != ptp->last_extts) {
 306                 event.type = PTP_CLOCK_EXTTS;
 307                 event.index = 0;
 308                 event.timestamp = ptp->ptp_tstamp2nsec(&ptp->time_counter, tstmp);
 309                 ptp_clock_event(ptp->ptp_clock, &event);
 310                 new_thresh = tstmp % 500000000;
 311                 if (ptp->thresh != new_thresh) {
 312                         mutex_lock(&ptp->nic->mbox.lock);
 313                         ptp_set_thresh(ptp, new_thresh);
 314                         mutex_unlock(&ptp->nic->mbox.lock);
 315                         ptp->thresh = new_thresh;
 316                 }
 317                 ptp->last_extts = tstmp;
 318         }
 319         schedule_delayed_work(&ptp->extts_work, msecs_to_jiffies(200));
 320 }
 321
 322 static void otx2_sync_tstamp(struct work_struct *work)
 323 {
 324         struct otx2_ptp *ptp = container_of(work, struct otx2_ptp,
 325                                             synctstamp_work.work);
 326         struct otx2_nic *pfvf = ptp->nic;
 327         u64 tstamp;
 328
 329         mutex_lock(&pfvf->mbox.lock);
 330         tstamp = otx2_ptp_get_clock(ptp);
 331         mutex_unlock(&pfvf->mbox.lock);
 332
 333         ptp->tstamp = ptp->ptp_tstamp2nsec(&ptp->time_counter, tstamp);
 334         ptp->base_ns = tstamp % NSEC_PER_SEC;
 335
 336         schedule_delayed_work(&ptp->synctstamp_work, msecs_to_jiffies(250));
 337 }
 338
 339 static int otx2_ptp_enable(struct ptp_clock_info *ptp_info,
 340                            struct ptp_clock_request *rq, int on)
 341 {
 342         struct otx2_ptp *ptp = container_of(ptp_info, struct otx2_ptp,
 343                                             ptp_info);
 344         u64 period = 0;
 345         int pin;
 346
 347         if (!ptp->nic)
 348                 return -ENODEV;
 349
 350         switch (rq->type) {
 351         case PTP_CLK_REQ_EXTTS:
 352                 pin = ptp_find_pin(ptp->ptp_clock, PTP_PF_EXTTS,
 353                                    rq->extts.index);
 354                 if (pin < 0)
 355                         return -EBUSY;
 356                 if (on)
 357                         schedule_delayed_work(&ptp->extts_work, msecs_to_jiffies(200));
 358                 else
 359                         cancel_delayed_work_sync(&ptp->extts_work);
 360
 361                 return 0;
 362         case PTP_CLK_REQ_PEROUT:
 363                 if (rq->perout.flags)
 364                         return -EOPNOTSUPP;
 365
 366                 if (rq->perout.index >= ptp_info->n_pins)
 367                         return -EINVAL;
 368                 if (on) {
 369                         period = rq->perout.period.sec * NSEC_PER_SEC +
 370                                  rq->perout.period.nsec;
 371                         ptp_pps_on(ptp, on, period);
 372                 } else {
 373                         ptp_pps_on(ptp, on, period);
 374                 }
 375                 return 0;
 376         default:
 377                 break;
 378         }
 379         return -EOPNOTSUPP;
 380 }
 381
 382 int otx2_ptp_init(struct otx2_nic *pfvf)
 383 {
 384         struct otx2_ptp *ptp_ptr;
 385         struct cyclecounter *cc;
 386         struct ptp_req *req;
 387         int err;
 388
 389         if (is_otx2_lbkvf(pfvf->pdev)) {
 390                 pfvf->ptp = NULL;
 391                 return 0;
 392         }
 393
 394         mutex_lock(&pfvf->mbox.lock);
 395         /* check if PTP block is available */
 396         req = otx2_mbox_alloc_msg_ptp_op(&pfvf->mbox);
 397         if (!req) {
 398                 mutex_unlock(&pfvf->mbox.lock);
 399                 return -ENOMEM;
 400         }
 401
 402         req->op = PTP_OP_GET_CLOCK;
 403
 404         err = otx2_sync_mbox_msg(&pfvf->mbox);
 405         if (err) {
 406                 mutex_unlock(&pfvf->mbox.lock);
 407                 return err;
 408         }
 409         mutex_unlock(&pfvf->mbox.lock);
 410
 411         ptp_ptr = kzalloc(sizeof(*ptp_ptr), GFP_KERNEL);
 412         if (!ptp_ptr) {
 413                 err = -ENOMEM;
 414                 goto error;
 415         }
 416
 417         ptp_ptr->nic = pfvf;
 418
 419         snprintf(ptp_ptr->extts_config.name, sizeof(ptp_ptr->extts_config.name), "TSTAMP");
 420         ptp_ptr->extts_config.index = 0;
 421         ptp_ptr->extts_config.func = PTP_PF_NONE;
 422
 423         ptp_ptr->ptp_info = (struct ptp_clock_info) {
 424                 .owner          = THIS_MODULE,
 425                 .name           = "OcteonTX2 PTP",
 426                 .max_adj        = 1000000000ull,
 427                 .n_ext_ts       = 1,
 428                 .n_per_out      = 1,
 429                 .n_pins         = 1,
 430                 .pps            = 0,
 431                 .pin_config     = &ptp_ptr->extts_config,
 432                 .adjfine        = otx2_ptp_adjfine,
 433                 .enable         = otx2_ptp_enable,
 434                 .verify         = otx2_ptp_verify_pin,
 435         };
 436
 437         /* Check whether hardware supports atomic updates to timestamp */
 438         if (is_tstmp_atomic_update_supported(ptp_ptr)) {
 439                 ptp_ptr->ptp_info.adjtime = otx2_ptp_hw_adjtime;
 440                 ptp_ptr->ptp_info.gettime64 = otx2_ptp_hw_gettime;
 441                 ptp_ptr->ptp_info.settime64 = otx2_ptp_hw_settime;
 442
 443                 ptp_ptr->ptp_tstamp2nsec = otx2_ptp_hw_tstamp2time;
 444         } else {
 445                 ptp_ptr->ptp_info.adjtime = otx2_ptp_tc_adjtime;
 446                 ptp_ptr->ptp_info.gettime64 = otx2_ptp_tc_gettime;
 447                 ptp_ptr->ptp_info.settime64 = otx2_ptp_tc_settime;
 448
 449                 cc = &ptp_ptr->cycle_counter;
 450                 cc->read = ptp_cc_read;
 451                 cc->mask = CYCLECOUNTER_MASK(64);
 452                 cc->mult = 1;
 453                 cc->shift = 0;
 454                 ptp_ptr->ptp_tstamp2nsec = timecounter_cyc2time;
 455
 456                 timecounter_init(&ptp_ptr->time_counter, &ptp_ptr->cycle_counter,
 457                                  ktime_to_ns(ktime_get_real()));
 458         }
 459
 460         INIT_DELAYED_WORK(&ptp_ptr->extts_work, otx2_ptp_extts_check);
 461
 462         ptp_ptr->ptp_clock = ptp_clock_register(&ptp_ptr->ptp_info, pfvf->dev);
 463         if (IS_ERR_OR_NULL(ptp_ptr->ptp_clock)) {
 464                 err = ptp_ptr->ptp_clock ?
 465                       PTR_ERR(ptp_ptr->ptp_clock) : -ENODEV;
 466                 kfree(ptp_ptr);
 467                 goto error;
 468         }
 469
 470         if (is_dev_otx2(pfvf->pdev)) {
 471                 ptp_ptr->convert_rx_ptp_tstmp = &otx2_ptp_convert_rx_timestamp;
 472                 ptp_ptr->convert_tx_ptp_tstmp = &otx2_ptp_convert_tx_timestamp;
 473         } else {
 474                 ptp_ptr->convert_rx_ptp_tstmp = &cn10k_ptp_convert_timestamp;
 475                 ptp_ptr->convert_tx_ptp_tstmp = &cn10k_ptp_convert_timestamp;
 476         }
 477
 478         INIT_DELAYED_WORK(&ptp_ptr->synctstamp_work, otx2_sync_tstamp);
 479
 480         pfvf->ptp = ptp_ptr;
 481
 482 error:
 483         return err;
 484 }
 485 EXPORT_SYMBOL_GPL(otx2_ptp_init);
 486
 487 void otx2_ptp_destroy(struct otx2_nic *pfvf)
 488 {
 489         struct otx2_ptp *ptp = pfvf->ptp;
 490
 491         if (!ptp)
 492                 return;
 493
 494         cancel_delayed_work(&pfvf->ptp->synctstamp_work);
 495
 496         ptp_clock_unregister(ptp->ptp_clock);
 497         kfree(ptp);
 498         pfvf->ptp = NULL;
 499 }
 500 EXPORT_SYMBOL_GPL(otx2_ptp_destroy);
 501
 502 int otx2_ptp_clock_index(struct otx2_nic *pfvf)
 503 {
 504         if (!pfvf->ptp)
 505                 return -ENODEV;
 506
 507         return ptp_clock_index(pfvf->ptp->ptp_clock);
 508 }
 509 EXPORT_SYMBOL_GPL(otx2_ptp_clock_index);
 510
 511 int otx2_ptp_tstamp2time(struct otx2_nic *pfvf, u64 tstamp, u64 *tsns)
 512 {
 513         if (!pfvf->ptp)
 514                 return -ENODEV;
 515
 516         *tsns = pfvf->ptp->ptp_tstamp2nsec(&pfvf->ptp->time_counter, tstamp);
 517
 518         return 0;
 519 }
 520 EXPORT_SYMBOL_GPL(otx2_ptp_tstamp2time);
 521
 522 MODULE_AUTHOR("Sunil Goutham <sgoutham@marvell.com>");
 523 MODULE_DESCRIPTION("Marvell RVU NIC PTP Driver");
 524 MODULE_LICENSE("GPL v2");