1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * PTP 1588 clock support - character device implementation. 4 * 5 * Copyright (C) 2010 OMICRON electronics GmbH 6 */ 7 #include <linux/module.h> 8 #include <linux/posix-clock.h> 9 #include <linux/poll.h> 10 #include <linux/sched.h> 11 #include <linux/slab.h> 12 #include <linux/timekeeping.h> 13 #include <linux/debugfs.h> 14 15 #include <linux/nospec.h> 16 17 #include "ptp_private.h" 18 19 static int ptp_disable_pinfunc(struct ptp_clock_info *ops, 20 enum ptp_pin_function func, unsigned int chan) 21 { 22 struct ptp_clock_request rq; 23 int err = 0; 24 25 memset(&rq, 0, sizeof(rq)); 26 27 switch (func) { 28 case PTP_PF_NONE: 29 break; 30 case PTP_PF_EXTTS: 31 rq.type = PTP_CLK_REQ_EXTTS; 32 rq.extts.index = chan; 33 err = ops->enable(ops, &rq, 0); 34 break; 35 case PTP_PF_PEROUT: 36 rq.type = PTP_CLK_REQ_PEROUT; 37 rq.perout.index = chan; 38 err = ops->enable(ops, &rq, 0); 39 break; 40 case PTP_PF_PHYSYNC: 41 break; 42 default: 43 return -EINVAL; 44 } 45 46 return err; 47 } 48 49 int ptp_set_pinfunc(struct ptp_clock *ptp, unsigned int pin, 50 enum ptp_pin_function func, unsigned int chan) 51 { 52 struct ptp_clock_info *info = ptp->info; 53 struct ptp_pin_desc *pin1 = NULL, *pin2 = &info->pin_config[pin]; 54 unsigned int i; 55 56 /* Check to see if any other pin previously had this function. */ 57 for (i = 0; i < info->n_pins; i++) { 58 if (info->pin_config[i].func == func && 59 info->pin_config[i].chan == chan) { 60 pin1 = &info->pin_config[i]; 61 break; 62 } 63 } 64 if (pin1 && i == pin) 65 return 0; 66 67 /* Check the desired function and channel. */ 68 switch (func) { 69 case PTP_PF_NONE: 70 break; 71 case PTP_PF_EXTTS: 72 if (chan >= info->n_ext_ts) 73 return -EINVAL; 74 break; 75 case PTP_PF_PEROUT: 76 if (chan >= info->n_per_out) 77 return -EINVAL; 78 break; 79 case PTP_PF_PHYSYNC: 80 if (chan != 0) 81 return -EINVAL; 82 break; 83 default: 84 return -EINVAL; 85 } 86 87 if (info->verify(info, pin, func, chan)) { 88 pr_err("driver cannot use function %u on pin %u\n", func, chan); 89 return -EOPNOTSUPP; 90 } 91 92 /* Disable whatever function was previously assigned. */ 93 if (pin1) { 94 ptp_disable_pinfunc(info, func, chan); 95 pin1->func = PTP_PF_NONE; 96 pin1->chan = 0; 97 } 98 ptp_disable_pinfunc(info, pin2->func, pin2->chan); 99 pin2->func = func; 100 pin2->chan = chan; 101 102 return 0; 103 } 104 105 int ptp_open(struct posix_clock_context *pccontext, fmode_t fmode) 106 { 107 struct ptp_clock *ptp = 108 container_of(pccontext->clk, struct ptp_clock, clock); 109 struct timestamp_event_queue *queue; 110 char debugfsname[32]; 111 112 queue = kzalloc(sizeof(*queue), GFP_KERNEL); 113 if (!queue) 114 return -EINVAL; 115 queue->mask = bitmap_alloc(PTP_MAX_CHANNELS, GFP_KERNEL); 116 if (!queue->mask) { 117 kfree(queue); 118 return -EINVAL; 119 } 120 bitmap_set(queue->mask, 0, PTP_MAX_CHANNELS); 121 spin_lock_init(&queue->lock); 122 list_add_tail(&queue->qlist, &ptp->tsevqs); 123 pccontext->private_clkdata = queue; 124 125 /* Debugfs contents */ 126 sprintf(debugfsname, "0x%p", queue); 127 queue->debugfs_instance = 128 debugfs_create_dir(debugfsname, ptp->debugfs_root); 129 queue->dfs_bitmap.array = (u32 *)queue->mask; 130 queue->dfs_bitmap.n_elements = 131 DIV_ROUND_UP(PTP_MAX_CHANNELS, BITS_PER_BYTE * sizeof(u32)); 132 debugfs_create_u32_array("mask", 0444, queue->debugfs_instance, 133 &queue->dfs_bitmap); 134 135 return 0; 136 } 137 138 int ptp_release(struct posix_clock_context *pccontext) 139 { 140 struct timestamp_event_queue *queue = pccontext->private_clkdata; 141 unsigned long flags; 142 143 if (queue) { 144 debugfs_remove(queue->debugfs_instance); 145 pccontext->private_clkdata = NULL; 146 spin_lock_irqsave(&queue->lock, flags); 147 list_del(&queue->qlist); 148 spin_unlock_irqrestore(&queue->lock, flags); 149 bitmap_free(queue->mask); 150 kfree(queue); 151 } 152 return 0; 153 } 154 155 long ptp_ioctl(struct posix_clock_context *pccontext, unsigned int cmd, 156 unsigned long arg) 157 { 158 struct ptp_clock *ptp = 159 container_of(pccontext->clk, struct ptp_clock, clock); 160 struct ptp_sys_offset_extended *extoff = NULL; 161 struct ptp_sys_offset_precise precise_offset; 162 struct system_device_crosststamp xtstamp; 163 struct ptp_clock_info *ops = ptp->info; 164 struct ptp_sys_offset *sysoff = NULL; 165 struct timestamp_event_queue *tsevq; 166 struct ptp_system_timestamp sts; 167 struct ptp_clock_request req; 168 struct ptp_clock_caps caps; 169 struct ptp_clock_time *pct; 170 unsigned int i, pin_index; 171 struct ptp_pin_desc pd; 172 struct timespec64 ts; 173 int enable, err = 0; 174 175 tsevq = pccontext->private_clkdata; 176 177 switch (cmd) { 178 179 case PTP_CLOCK_GETCAPS: 180 case PTP_CLOCK_GETCAPS2: 181 memset(&caps, 0, sizeof(caps)); 182 183 caps.max_adj = ptp->info->max_adj; 184 caps.n_alarm = ptp->info->n_alarm; 185 caps.n_ext_ts = ptp->info->n_ext_ts; 186 caps.n_per_out = ptp->info->n_per_out; 187 caps.pps = ptp->info->pps; 188 caps.n_pins = ptp->info->n_pins; 189 caps.cross_timestamping = ptp->info->getcrosststamp != NULL; 190 caps.adjust_phase = ptp->info->adjphase != NULL && 191 ptp->info->getmaxphase != NULL; 192 if (caps.adjust_phase) 193 caps.max_phase_adj = ptp->info->getmaxphase(ptp->info); 194 if (copy_to_user((void __user *)arg, &caps, sizeof(caps))) 195 err = -EFAULT; 196 break; 197 198 case PTP_EXTTS_REQUEST: 199 case PTP_EXTTS_REQUEST2: 200 memset(&req, 0, sizeof(req)); 201 202 if (copy_from_user(&req.extts, (void __user *)arg, 203 sizeof(req.extts))) { 204 err = -EFAULT; 205 break; 206 } 207 if (cmd == PTP_EXTTS_REQUEST2) { 208 /* Tell the drivers to check the flags carefully. */ 209 req.extts.flags |= PTP_STRICT_FLAGS; 210 /* Make sure no reserved bit is set. */ 211 if ((req.extts.flags & ~PTP_EXTTS_VALID_FLAGS) || 212 req.extts.rsv[0] || req.extts.rsv[1]) { 213 err = -EINVAL; 214 break; 215 } 216 /* Ensure one of the rising/falling edge bits is set. */ 217 if ((req.extts.flags & PTP_ENABLE_FEATURE) && 218 (req.extts.flags & PTP_EXTTS_EDGES) == 0) { 219 err = -EINVAL; 220 break; 221 } 222 } else if (cmd == PTP_EXTTS_REQUEST) { 223 req.extts.flags &= PTP_EXTTS_V1_VALID_FLAGS; 224 req.extts.rsv[0] = 0; 225 req.extts.rsv[1] = 0; 226 } 227 if (req.extts.index >= ops->n_ext_ts) { 228 err = -EINVAL; 229 break; 230 } 231 req.type = PTP_CLK_REQ_EXTTS; 232 enable = req.extts.flags & PTP_ENABLE_FEATURE ? 1 : 0; 233 if (mutex_lock_interruptible(&ptp->pincfg_mux)) 234 return -ERESTARTSYS; 235 err = ops->enable(ops, &req, enable); 236 mutex_unlock(&ptp->pincfg_mux); 237 break; 238 239 case PTP_PEROUT_REQUEST: 240 case PTP_PEROUT_REQUEST2: 241 memset(&req, 0, sizeof(req)); 242 243 if (copy_from_user(&req.perout, (void __user *)arg, 244 sizeof(req.perout))) { 245 err = -EFAULT; 246 break; 247 } 248 if (cmd == PTP_PEROUT_REQUEST2) { 249 struct ptp_perout_request *perout = &req.perout; 250 251 if (perout->flags & ~PTP_PEROUT_VALID_FLAGS) { 252 err = -EINVAL; 253 break; 254 } 255 /* 256 * The "on" field has undefined meaning if 257 * PTP_PEROUT_DUTY_CYCLE isn't set, we must still treat 258 * it as reserved, which must be set to zero. 259 */ 260 if (!(perout->flags & PTP_PEROUT_DUTY_CYCLE) && 261 (perout->rsv[0] || perout->rsv[1] || 262 perout->rsv[2] || perout->rsv[3])) { 263 err = -EINVAL; 264 break; 265 } 266 if (perout->flags & PTP_PEROUT_DUTY_CYCLE) { 267 /* The duty cycle must be subunitary. */ 268 if (perout->on.sec > perout->period.sec || 269 (perout->on.sec == perout->period.sec && 270 perout->on.nsec > perout->period.nsec)) { 271 err = -ERANGE; 272 break; 273 } 274 } 275 if (perout->flags & PTP_PEROUT_PHASE) { 276 /* 277 * The phase should be specified modulo the 278 * period, therefore anything equal or larger 279 * than 1 period is invalid. 280 */ 281 if (perout->phase.sec > perout->period.sec || 282 (perout->phase.sec == perout->period.sec && 283 perout->phase.nsec >= perout->period.nsec)) { 284 err = -ERANGE; 285 break; 286 } 287 } 288 } else if (cmd == PTP_PEROUT_REQUEST) { 289 req.perout.flags &= PTP_PEROUT_V1_VALID_FLAGS; 290 req.perout.rsv[0] = 0; 291 req.perout.rsv[1] = 0; 292 req.perout.rsv[2] = 0; 293 req.perout.rsv[3] = 0; 294 } 295 if (req.perout.index >= ops->n_per_out) { 296 err = -EINVAL; 297 break; 298 } 299 req.type = PTP_CLK_REQ_PEROUT; 300 enable = req.perout.period.sec || req.perout.period.nsec; 301 if (mutex_lock_interruptible(&ptp->pincfg_mux)) 302 return -ERESTARTSYS; 303 err = ops->enable(ops, &req, enable); 304 mutex_unlock(&ptp->pincfg_mux); 305 break; 306 307 case PTP_ENABLE_PPS: 308 case PTP_ENABLE_PPS2: 309 memset(&req, 0, sizeof(req)); 310 311 if (!capable(CAP_SYS_TIME)) 312 return -EPERM; 313 req.type = PTP_CLK_REQ_PPS; 314 enable = arg ? 1 : 0; 315 if (mutex_lock_interruptible(&ptp->pincfg_mux)) 316 return -ERESTARTSYS; 317 err = ops->enable(ops, &req, enable); 318 mutex_unlock(&ptp->pincfg_mux); 319 break; 320 321 case PTP_SYS_OFFSET_PRECISE: 322 case PTP_SYS_OFFSET_PRECISE2: 323 if (!ptp->info->getcrosststamp) { 324 err = -EOPNOTSUPP; 325 break; 326 } 327 err = ptp->info->getcrosststamp(ptp->info, &xtstamp); 328 if (err) 329 break; 330 331 memset(&precise_offset, 0, sizeof(precise_offset)); 332 ts = ktime_to_timespec64(xtstamp.device); 333 precise_offset.device.sec = ts.tv_sec; 334 precise_offset.device.nsec = ts.tv_nsec; 335 ts = ktime_to_timespec64(xtstamp.sys_realtime); 336 precise_offset.sys_realtime.sec = ts.tv_sec; 337 precise_offset.sys_realtime.nsec = ts.tv_nsec; 338 ts = ktime_to_timespec64(xtstamp.sys_monoraw); 339 precise_offset.sys_monoraw.sec = ts.tv_sec; 340 precise_offset.sys_monoraw.nsec = ts.tv_nsec; 341 if (copy_to_user((void __user *)arg, &precise_offset, 342 sizeof(precise_offset))) 343 err = -EFAULT; 344 break; 345 346 case PTP_SYS_OFFSET_EXTENDED: 347 case PTP_SYS_OFFSET_EXTENDED2: 348 if (!ptp->info->gettimex64) { 349 err = -EOPNOTSUPP; 350 break; 351 } 352 extoff = memdup_user((void __user *)arg, sizeof(*extoff)); 353 if (IS_ERR(extoff)) { 354 err = PTR_ERR(extoff); 355 extoff = NULL; 356 break; 357 } 358 if (extoff->n_samples > PTP_MAX_SAMPLES 359 || extoff->rsv[0] || extoff->rsv[1] || extoff->rsv[2]) { 360 err = -EINVAL; 361 break; 362 } 363 for (i = 0; i < extoff->n_samples; i++) { 364 err = ptp->info->gettimex64(ptp->info, &ts, &sts); 365 if (err) 366 goto out; 367 extoff->ts[i][0].sec = sts.pre_ts.tv_sec; 368 extoff->ts[i][0].nsec = sts.pre_ts.tv_nsec; 369 extoff->ts[i][1].sec = ts.tv_sec; 370 extoff->ts[i][1].nsec = ts.tv_nsec; 371 extoff->ts[i][2].sec = sts.post_ts.tv_sec; 372 extoff->ts[i][2].nsec = sts.post_ts.tv_nsec; 373 } 374 if (copy_to_user((void __user *)arg, extoff, sizeof(*extoff))) 375 err = -EFAULT; 376 break; 377 378 case PTP_SYS_OFFSET: 379 case PTP_SYS_OFFSET2: 380 sysoff = memdup_user((void __user *)arg, sizeof(*sysoff)); 381 if (IS_ERR(sysoff)) { 382 err = PTR_ERR(sysoff); 383 sysoff = NULL; 384 break; 385 } 386 if (sysoff->n_samples > PTP_MAX_SAMPLES) { 387 err = -EINVAL; 388 break; 389 } 390 pct = &sysoff->ts[0]; 391 for (i = 0; i < sysoff->n_samples; i++) { 392 ktime_get_real_ts64(&ts); 393 pct->sec = ts.tv_sec; 394 pct->nsec = ts.tv_nsec; 395 pct++; 396 if (ops->gettimex64) 397 err = ops->gettimex64(ops, &ts, NULL); 398 else 399 err = ops->gettime64(ops, &ts); 400 if (err) 401 goto out; 402 pct->sec = ts.tv_sec; 403 pct->nsec = ts.tv_nsec; 404 pct++; 405 } 406 ktime_get_real_ts64(&ts); 407 pct->sec = ts.tv_sec; 408 pct->nsec = ts.tv_nsec; 409 if (copy_to_user((void __user *)arg, sysoff, sizeof(*sysoff))) 410 err = -EFAULT; 411 break; 412 413 case PTP_PIN_GETFUNC: 414 case PTP_PIN_GETFUNC2: 415 if (copy_from_user(&pd, (void __user *)arg, sizeof(pd))) { 416 err = -EFAULT; 417 break; 418 } 419 if ((pd.rsv[0] || pd.rsv[1] || pd.rsv[2] 420 || pd.rsv[3] || pd.rsv[4]) 421 && cmd == PTP_PIN_GETFUNC2) { 422 err = -EINVAL; 423 break; 424 } else if (cmd == PTP_PIN_GETFUNC) { 425 pd.rsv[0] = 0; 426 pd.rsv[1] = 0; 427 pd.rsv[2] = 0; 428 pd.rsv[3] = 0; 429 pd.rsv[4] = 0; 430 } 431 pin_index = pd.index; 432 if (pin_index >= ops->n_pins) { 433 err = -EINVAL; 434 break; 435 } 436 pin_index = array_index_nospec(pin_index, ops->n_pins); 437 if (mutex_lock_interruptible(&ptp->pincfg_mux)) 438 return -ERESTARTSYS; 439 pd = ops->pin_config[pin_index]; 440 mutex_unlock(&ptp->pincfg_mux); 441 if (!err && copy_to_user((void __user *)arg, &pd, sizeof(pd))) 442 err = -EFAULT; 443 break; 444 445 case PTP_PIN_SETFUNC: 446 case PTP_PIN_SETFUNC2: 447 if (copy_from_user(&pd, (void __user *)arg, sizeof(pd))) { 448 err = -EFAULT; 449 break; 450 } 451 if ((pd.rsv[0] || pd.rsv[1] || pd.rsv[2] 452 || pd.rsv[3] || pd.rsv[4]) 453 && cmd == PTP_PIN_SETFUNC2) { 454 err = -EINVAL; 455 break; 456 } else if (cmd == PTP_PIN_SETFUNC) { 457 pd.rsv[0] = 0; 458 pd.rsv[1] = 0; 459 pd.rsv[2] = 0; 460 pd.rsv[3] = 0; 461 pd.rsv[4] = 0; 462 } 463 pin_index = pd.index; 464 if (pin_index >= ops->n_pins) { 465 err = -EINVAL; 466 break; 467 } 468 pin_index = array_index_nospec(pin_index, ops->n_pins); 469 if (mutex_lock_interruptible(&ptp->pincfg_mux)) 470 return -ERESTARTSYS; 471 err = ptp_set_pinfunc(ptp, pin_index, pd.func, pd.chan); 472 mutex_unlock(&ptp->pincfg_mux); 473 break; 474 475 case PTP_MASK_CLEAR_ALL: 476 bitmap_clear(tsevq->mask, 0, PTP_MAX_CHANNELS); 477 break; 478 479 case PTP_MASK_EN_SINGLE: 480 if (copy_from_user(&i, (void __user *)arg, sizeof(i))) { 481 err = -EFAULT; 482 break; 483 } 484 if (i >= PTP_MAX_CHANNELS) { 485 err = -EFAULT; 486 break; 487 } 488 set_bit(i, tsevq->mask); 489 break; 490 491 default: 492 err = -ENOTTY; 493 break; 494 } 495 496 out: 497 kfree(extoff); 498 kfree(sysoff); 499 return err; 500 } 501 502 __poll_t ptp_poll(struct posix_clock_context *pccontext, struct file *fp, 503 poll_table *wait) 504 { 505 struct ptp_clock *ptp = 506 container_of(pccontext->clk, struct ptp_clock, clock); 507 struct timestamp_event_queue *queue; 508 509 queue = pccontext->private_clkdata; 510 if (!queue) 511 return EPOLLERR; 512 513 poll_wait(fp, &ptp->tsev_wq, wait); 514 515 return queue_cnt(queue) ? EPOLLIN : 0; 516 } 517 518 #define EXTTS_BUFSIZE (PTP_BUF_TIMESTAMPS * sizeof(struct ptp_extts_event)) 519 520 ssize_t ptp_read(struct posix_clock_context *pccontext, uint rdflags, 521 char __user *buf, size_t cnt) 522 { 523 struct ptp_clock *ptp = 524 container_of(pccontext->clk, struct ptp_clock, clock); 525 struct timestamp_event_queue *queue; 526 struct ptp_extts_event *event; 527 unsigned long flags; 528 size_t qcnt, i; 529 int result; 530 531 queue = pccontext->private_clkdata; 532 if (!queue) { 533 result = -EINVAL; 534 goto exit; 535 } 536 537 if (cnt % sizeof(struct ptp_extts_event) != 0) { 538 result = -EINVAL; 539 goto exit; 540 } 541 542 if (cnt > EXTTS_BUFSIZE) 543 cnt = EXTTS_BUFSIZE; 544 545 cnt = cnt / sizeof(struct ptp_extts_event); 546 547 if (wait_event_interruptible(ptp->tsev_wq, 548 ptp->defunct || queue_cnt(queue))) { 549 return -ERESTARTSYS; 550 } 551 552 if (ptp->defunct) { 553 result = -ENODEV; 554 goto exit; 555 } 556 557 event = kmalloc(EXTTS_BUFSIZE, GFP_KERNEL); 558 if (!event) { 559 result = -ENOMEM; 560 goto exit; 561 } 562 563 spin_lock_irqsave(&queue->lock, flags); 564 565 qcnt = queue_cnt(queue); 566 567 if (cnt > qcnt) 568 cnt = qcnt; 569 570 for (i = 0; i < cnt; i++) { 571 event[i] = queue->buf[queue->head]; 572 queue->head = (queue->head + 1) % PTP_MAX_TIMESTAMPS; 573 } 574 575 spin_unlock_irqrestore(&queue->lock, flags); 576 577 cnt = cnt * sizeof(struct ptp_extts_event); 578 579 result = cnt; 580 if (copy_to_user(buf, event, cnt)) { 581 result = -EFAULT; 582 goto free_event; 583 } 584 585 free_event: 586 kfree(event); 587 exit: 588 if (result < 0) 589 ptp_release(pccontext); 590 return result; 591 } 592