1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * PTP 1588 clock support 4 * 5 * Copyright (C) 2010 OMICRON electronics GmbH 6 */ 7 #include <linux/device.h> 8 #include <linux/err.h> 9 #include <linux/init.h> 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/posix-clock.h> 13 #include <linux/pps_kernel.h> 14 #include <linux/property.h> 15 #include <linux/slab.h> 16 #include <linux/syscalls.h> 17 #include <linux/uaccess.h> 18 #include <linux/debugfs.h> 19 #include <linux/xarray.h> 20 #include <uapi/linux/sched/types.h> 21 22 #include "ptp_private.h" 23 24 #define PTP_MAX_ALARMS 4 25 #define PTP_PPS_DEFAULTS (PPS_CAPTUREASSERT | PPS_OFFSETASSERT) 26 #define PTP_PPS_EVENT PPS_CAPTUREASSERT 27 #define PTP_PPS_MODE (PTP_PPS_DEFAULTS | PPS_CANWAIT | PPS_TSFMT_TSPEC) 28 29 const struct class ptp_class = { 30 .name = "ptp", 31 .dev_groups = ptp_groups 32 }; 33 34 /* private globals */ 35 36 static dev_t ptp_devt; 37 38 static DEFINE_XARRAY_ALLOC(ptp_clocks_map); 39 40 /* time stamp event queue operations */ 41 42 static inline int queue_free(struct timestamp_event_queue *q) 43 { 44 return PTP_MAX_TIMESTAMPS - queue_cnt(q) - 1; 45 } 46 47 static void enqueue_external_timestamp(struct timestamp_event_queue *queue, 48 struct ptp_clock_event *src) 49 { 50 struct ptp_extts_event *dst; 51 struct timespec64 offset_ts; 52 unsigned long flags; 53 s64 seconds; 54 u32 remainder; 55 56 if (src->type == PTP_CLOCK_EXTTS) { 57 seconds = div_u64_rem(src->timestamp, 1000000000, &remainder); 58 } else if (src->type == PTP_CLOCK_EXTOFF) { 59 offset_ts = ns_to_timespec64(src->offset); 60 seconds = offset_ts.tv_sec; 61 remainder = offset_ts.tv_nsec; 62 } else { 63 WARN(1, "%s: unknown type %d\n", __func__, src->type); 64 return; 65 } 66 67 spin_lock_irqsave(&queue->lock, flags); 68 69 dst = &queue->buf[queue->tail]; 70 dst->index = src->index; 71 dst->flags = PTP_EXTTS_EVENT_VALID; 72 dst->t.sec = seconds; 73 dst->t.nsec = remainder; 74 if (src->type == PTP_CLOCK_EXTOFF) 75 dst->flags |= PTP_EXT_OFFSET; 76 77 /* Both WRITE_ONCE() are paired with READ_ONCE() in queue_cnt() */ 78 if (!queue_free(queue)) 79 WRITE_ONCE(queue->head, (queue->head + 1) % PTP_MAX_TIMESTAMPS); 80 81 WRITE_ONCE(queue->tail, (queue->tail + 1) % PTP_MAX_TIMESTAMPS); 82 83 spin_unlock_irqrestore(&queue->lock, flags); 84 } 85 86 /* posix clock implementation */ 87 88 static int ptp_clock_getres(struct posix_clock *pc, struct timespec64 *tp) 89 { 90 tp->tv_sec = 0; 91 tp->tv_nsec = 1; 92 return 0; 93 } 94 95 static int ptp_clock_settime(struct posix_clock *pc, const struct timespec64 *tp) 96 { 97 struct ptp_clock *ptp = container_of(pc, struct ptp_clock, clock); 98 99 if (ptp_clock_freerun(ptp)) { 100 pr_err_ratelimited("ptp: physical clock is free running\n"); 101 return -EBUSY; 102 } 103 104 if (!timespec64_valid_settod(tp)) 105 return -EINVAL; 106 107 return ptp->info->settime64(ptp->info, tp); 108 } 109 110 static int ptp_clock_gettime(struct posix_clock *pc, struct timespec64 *tp) 111 { 112 struct ptp_clock *ptp = container_of(pc, struct ptp_clock, clock); 113 int err; 114 115 if (ptp->info->gettimex64) 116 err = ptp->info->gettimex64(ptp->info, tp, NULL); 117 else 118 err = ptp->info->gettime64(ptp->info, tp); 119 return err; 120 } 121 122 static int ptp_clock_adjtime(struct posix_clock *pc, struct __kernel_timex *tx) 123 { 124 struct ptp_clock *ptp = container_of(pc, struct ptp_clock, clock); 125 struct ptp_clock_info *ops; 126 int err = -EOPNOTSUPP; 127 128 if (tx->modes & (ADJ_SETOFFSET | ADJ_FREQUENCY | ADJ_OFFSET) && 129 ptp_clock_freerun(ptp)) { 130 pr_err("ptp: physical clock is free running\n"); 131 return -EBUSY; 132 } 133 134 ops = ptp->info; 135 136 if (tx->modes & ADJ_SETOFFSET) { 137 struct timespec64 ts, ts2; 138 ktime_t kt; 139 s64 delta; 140 141 ts.tv_sec = tx->time.tv_sec; 142 ts.tv_nsec = tx->time.tv_usec; 143 144 if (!(tx->modes & ADJ_NANO)) 145 ts.tv_nsec *= 1000; 146 147 if ((unsigned long) ts.tv_nsec >= NSEC_PER_SEC) 148 return -EINVAL; 149 150 /* Make sure the offset is valid */ 151 err = ptp_clock_gettime(pc, &ts2); 152 if (err) 153 return err; 154 ts2 = timespec64_add(ts2, ts); 155 if (!timespec64_valid_settod(&ts2)) 156 return -EINVAL; 157 158 kt = timespec64_to_ktime(ts); 159 delta = ktime_to_ns(kt); 160 err = ops->adjtime(ops, delta); 161 } else if (tx->modes & ADJ_FREQUENCY) { 162 long ppb = scaled_ppm_to_ppb(tx->freq); 163 if (ppb > ops->max_adj || ppb < -ops->max_adj) 164 return -ERANGE; 165 err = ops->adjfine(ops, tx->freq); 166 if (!err) 167 ptp->dialed_frequency = tx->freq; 168 } else if (tx->modes & ADJ_OFFSET) { 169 if (ops->adjphase) { 170 s32 max_phase_adj = ops->getmaxphase(ops); 171 s32 offset = tx->offset; 172 173 if (!(tx->modes & ADJ_NANO)) 174 offset *= NSEC_PER_USEC; 175 176 if (offset > max_phase_adj || offset < -max_phase_adj) 177 return -ERANGE; 178 179 err = ops->adjphase(ops, offset); 180 } 181 } else if (tx->modes == 0) { 182 tx->freq = ptp->dialed_frequency; 183 err = 0; 184 } 185 186 return err; 187 } 188 189 static struct posix_clock_operations ptp_clock_ops = { 190 .owner = THIS_MODULE, 191 .clock_adjtime = ptp_clock_adjtime, 192 .clock_gettime = ptp_clock_gettime, 193 .clock_getres = ptp_clock_getres, 194 .clock_settime = ptp_clock_settime, 195 .ioctl = ptp_ioctl, 196 .open = ptp_open, 197 .release = ptp_release, 198 .poll = ptp_poll, 199 .read = ptp_read, 200 }; 201 202 static void ptp_clock_release(struct device *dev) 203 { 204 struct ptp_clock *ptp = container_of(dev, struct ptp_clock, dev); 205 struct timestamp_event_queue *tsevq; 206 unsigned long flags; 207 208 ptp_cleanup_pin_groups(ptp); 209 kfree(ptp->vclock_index); 210 mutex_destroy(&ptp->pincfg_mux); 211 mutex_destroy(&ptp->n_vclocks_mux); 212 /* Delete first entry */ 213 spin_lock_irqsave(&ptp->tsevqs_lock, flags); 214 tsevq = list_first_entry(&ptp->tsevqs, struct timestamp_event_queue, 215 qlist); 216 list_del(&tsevq->qlist); 217 spin_unlock_irqrestore(&ptp->tsevqs_lock, flags); 218 bitmap_free(tsevq->mask); 219 kfree(tsevq); 220 debugfs_remove(ptp->debugfs_root); 221 xa_erase(&ptp_clocks_map, ptp->index); 222 kfree(ptp); 223 } 224 225 static int ptp_getcycles64(struct ptp_clock_info *info, struct timespec64 *ts) 226 { 227 if (info->getcyclesx64) 228 return info->getcyclesx64(info, ts, NULL); 229 else 230 return info->gettime64(info, ts); 231 } 232 233 static int ptp_enable(struct ptp_clock_info *ptp, struct ptp_clock_request *request, int on) 234 { 235 return -EOPNOTSUPP; 236 } 237 238 static void ptp_aux_kworker(struct kthread_work *work) 239 { 240 struct ptp_clock *ptp = container_of(work, struct ptp_clock, 241 aux_work.work); 242 struct ptp_clock_info *info = ptp->info; 243 long delay; 244 245 delay = info->do_aux_work(info); 246 247 if (delay >= 0) 248 kthread_queue_delayed_work(ptp->kworker, &ptp->aux_work, delay); 249 } 250 251 static ssize_t ptp_n_perout_loopback_read(struct file *filep, 252 char __user *buffer, 253 size_t count, loff_t *pos) 254 { 255 struct ptp_clock *ptp = filep->private_data; 256 char buf[12] = {}; 257 258 snprintf(buf, sizeof(buf), "%d\n", ptp->info->n_per_lp); 259 260 return simple_read_from_buffer(buffer, count, pos, buf, strlen(buf)); 261 } 262 263 static const struct file_operations ptp_n_perout_loopback_fops = { 264 .owner = THIS_MODULE, 265 .open = simple_open, 266 .read = ptp_n_perout_loopback_read, 267 }; 268 269 static ssize_t ptp_perout_loopback_write(struct file *filep, 270 const char __user *buffer, 271 size_t count, loff_t *ppos) 272 { 273 struct ptp_clock *ptp = filep->private_data; 274 struct ptp_clock_info *ops = ptp->info; 275 unsigned int index, enable; 276 int len, cnt, err; 277 char buf[32] = {}; 278 279 if (*ppos || !count) 280 return -EINVAL; 281 282 if (count >= sizeof(buf)) 283 return -ENOSPC; 284 285 len = simple_write_to_buffer(buf, sizeof(buf) - 1, 286 ppos, buffer, count); 287 if (len < 0) 288 return len; 289 290 buf[len] = '\0'; 291 cnt = sscanf(buf, "%u %u", &index, &enable); 292 if (cnt != 2) 293 return -EINVAL; 294 295 if (index >= ops->n_per_lp) 296 return -EINVAL; 297 298 if (enable != 0 && enable != 1) 299 return -EINVAL; 300 301 err = ops->perout_loopback(ops, index, enable); 302 if (err) 303 return err; 304 305 return count; 306 } 307 308 static const struct file_operations ptp_perout_loopback_ops = { 309 .owner = THIS_MODULE, 310 .open = simple_open, 311 .write = ptp_perout_loopback_write, 312 }; 313 314 /* public interface */ 315 316 struct ptp_clock *ptp_clock_register(struct ptp_clock_info *info, 317 struct device *parent) 318 { 319 struct ptp_clock *ptp; 320 struct timestamp_event_queue *queue = NULL; 321 int err, index, major = MAJOR(ptp_devt); 322 char debugfsname[16]; 323 size_t size; 324 325 if (WARN_ON_ONCE(info->n_alarm > PTP_MAX_ALARMS || 326 (!info->gettimex64 && !info->gettime64) || 327 !info->settime64)) 328 return ERR_PTR(-EINVAL); 329 330 /* Initialize a clock structure. */ 331 ptp = kzalloc(sizeof(struct ptp_clock), GFP_KERNEL); 332 if (!ptp) { 333 err = -ENOMEM; 334 goto no_memory; 335 } 336 337 err = xa_alloc(&ptp_clocks_map, &index, ptp, xa_limit_31b, 338 GFP_KERNEL); 339 if (err) 340 goto no_slot; 341 342 ptp->clock.ops = ptp_clock_ops; 343 ptp->info = info; 344 ptp->devid = MKDEV(major, index); 345 ptp->index = index; 346 INIT_LIST_HEAD(&ptp->tsevqs); 347 queue = kzalloc(sizeof(*queue), GFP_KERNEL); 348 if (!queue) { 349 err = -ENOMEM; 350 goto no_memory_queue; 351 } 352 list_add_tail(&queue->qlist, &ptp->tsevqs); 353 spin_lock_init(&ptp->tsevqs_lock); 354 queue->mask = bitmap_alloc(PTP_MAX_CHANNELS, GFP_KERNEL); 355 if (!queue->mask) { 356 err = -ENOMEM; 357 goto no_memory_bitmap; 358 } 359 bitmap_set(queue->mask, 0, PTP_MAX_CHANNELS); 360 spin_lock_init(&queue->lock); 361 mutex_init(&ptp->pincfg_mux); 362 mutex_init(&ptp->n_vclocks_mux); 363 init_waitqueue_head(&ptp->tsev_wq); 364 365 if (ptp->info->getcycles64 || ptp->info->getcyclesx64) { 366 ptp->has_cycles = true; 367 if (!ptp->info->getcycles64 && ptp->info->getcyclesx64) 368 ptp->info->getcycles64 = ptp_getcycles64; 369 } else { 370 /* Free running cycle counter not supported, use time. */ 371 ptp->info->getcycles64 = ptp_getcycles64; 372 373 if (ptp->info->gettimex64) 374 ptp->info->getcyclesx64 = ptp->info->gettimex64; 375 376 if (ptp->info->getcrosststamp) 377 ptp->info->getcrosscycles = ptp->info->getcrosststamp; 378 } 379 380 if (!ptp->info->enable) 381 ptp->info->enable = ptp_enable; 382 383 if (ptp->info->do_aux_work) { 384 kthread_init_delayed_work(&ptp->aux_work, ptp_aux_kworker); 385 ptp->kworker = kthread_run_worker(0, "ptp%d", ptp->index); 386 if (IS_ERR(ptp->kworker)) { 387 err = PTR_ERR(ptp->kworker); 388 pr_err("failed to create ptp aux_worker %d\n", err); 389 goto kworker_err; 390 } 391 } 392 393 /* PTP virtual clock is being registered under physical clock */ 394 if (parent && parent->class && parent->class->name && 395 strcmp(parent->class->name, "ptp") == 0) 396 ptp->is_virtual_clock = true; 397 398 if (!ptp->is_virtual_clock) { 399 ptp->max_vclocks = PTP_DEFAULT_MAX_VCLOCKS; 400 401 size = sizeof(int) * ptp->max_vclocks; 402 ptp->vclock_index = kzalloc(size, GFP_KERNEL); 403 if (!ptp->vclock_index) { 404 err = -ENOMEM; 405 goto no_mem_for_vclocks; 406 } 407 } 408 409 err = ptp_populate_pin_groups(ptp); 410 if (err) 411 goto no_pin_groups; 412 413 /* Register a new PPS source. */ 414 if (info->pps) { 415 struct pps_source_info pps; 416 memset(&pps, 0, sizeof(pps)); 417 snprintf(pps.name, PPS_MAX_NAME_LEN, "ptp%d", index); 418 pps.mode = PTP_PPS_MODE; 419 pps.owner = info->owner; 420 ptp->pps_source = pps_register_source(&pps, PTP_PPS_DEFAULTS); 421 if (IS_ERR(ptp->pps_source)) { 422 err = PTR_ERR(ptp->pps_source); 423 pr_err("failed to register pps source\n"); 424 goto no_pps; 425 } 426 ptp->pps_source->lookup_cookie = ptp; 427 } 428 429 /* Initialize a new device of our class in our clock structure. */ 430 device_initialize(&ptp->dev); 431 ptp->dev.devt = ptp->devid; 432 ptp->dev.class = &ptp_class; 433 ptp->dev.parent = parent; 434 ptp->dev.groups = ptp->pin_attr_groups; 435 ptp->dev.release = ptp_clock_release; 436 dev_set_drvdata(&ptp->dev, ptp); 437 dev_set_name(&ptp->dev, "ptp%d", ptp->index); 438 439 /* Create a posix clock and link it to the device. */ 440 err = posix_clock_register(&ptp->clock, &ptp->dev); 441 if (err) { 442 if (ptp->pps_source) 443 pps_unregister_source(ptp->pps_source); 444 445 if (ptp->kworker) 446 kthread_destroy_worker(ptp->kworker); 447 448 put_device(&ptp->dev); 449 450 pr_err("failed to create posix clock\n"); 451 return ERR_PTR(err); 452 } 453 454 /* Debugfs initialization */ 455 snprintf(debugfsname, sizeof(debugfsname), "ptp%d", ptp->index); 456 ptp->debugfs_root = debugfs_create_dir(debugfsname, NULL); 457 if (info->n_per_lp > 0 && info->perout_loopback) { 458 debugfs_create_file("n_perout_loopback", 0400, ptp->debugfs_root, 459 ptp, &ptp_n_perout_loopback_fops); 460 debugfs_create_file("perout_loopback", 0200, ptp->debugfs_root, 461 ptp, &ptp_perout_loopback_ops); 462 } 463 464 return ptp; 465 466 no_pps: 467 ptp_cleanup_pin_groups(ptp); 468 no_pin_groups: 469 kfree(ptp->vclock_index); 470 no_mem_for_vclocks: 471 if (ptp->kworker) 472 kthread_destroy_worker(ptp->kworker); 473 kworker_err: 474 mutex_destroy(&ptp->pincfg_mux); 475 mutex_destroy(&ptp->n_vclocks_mux); 476 bitmap_free(queue->mask); 477 no_memory_bitmap: 478 list_del(&queue->qlist); 479 kfree(queue); 480 no_memory_queue: 481 xa_erase(&ptp_clocks_map, index); 482 no_slot: 483 kfree(ptp); 484 no_memory: 485 return ERR_PTR(err); 486 } 487 EXPORT_SYMBOL(ptp_clock_register); 488 489 static int unregister_vclock(struct device *dev, void *data) 490 { 491 struct ptp_clock *ptp = dev_get_drvdata(dev); 492 493 ptp_vclock_unregister(info_to_vclock(ptp->info)); 494 return 0; 495 } 496 497 int ptp_clock_unregister(struct ptp_clock *ptp) 498 { 499 if (ptp_vclock_in_use(ptp)) { 500 device_for_each_child(&ptp->dev, NULL, unregister_vclock); 501 } 502 503 /* Get the device to stop posix_clock_unregister() doing the last put 504 * and freeing the structure(s) 505 */ 506 get_device(&ptp->dev); 507 508 /* Wake up any userspace waiting for an event. */ 509 ptp->defunct = 1; 510 wake_up_interruptible(&ptp->tsev_wq); 511 512 /* Tear down the POSIX clock, which removes the user interface. */ 513 posix_clock_unregister(&ptp->clock); 514 515 /* Disable all sources of event generation. */ 516 ptp_disable_all_events(ptp); 517 518 if (ptp->kworker) { 519 kthread_cancel_delayed_work_sync(&ptp->aux_work); 520 kthread_destroy_worker(ptp->kworker); 521 } 522 523 /* Release the clock's resources. */ 524 if (ptp->pps_source) 525 pps_unregister_source(ptp->pps_source); 526 527 /* The final put, normally here, will invoke ptp_clock_release(). */ 528 put_device(&ptp->dev); 529 530 return 0; 531 } 532 EXPORT_SYMBOL(ptp_clock_unregister); 533 534 void ptp_clock_event(struct ptp_clock *ptp, struct ptp_clock_event *event) 535 { 536 struct timestamp_event_queue *tsevq; 537 struct pps_event_time evt; 538 unsigned long flags; 539 540 switch (event->type) { 541 542 case PTP_CLOCK_ALARM: 543 break; 544 545 case PTP_CLOCK_EXTTS: 546 case PTP_CLOCK_EXTOFF: 547 /* Enqueue timestamp on selected queues */ 548 spin_lock_irqsave(&ptp->tsevqs_lock, flags); 549 list_for_each_entry(tsevq, &ptp->tsevqs, qlist) { 550 if (test_bit((unsigned int)event->index, tsevq->mask)) 551 enqueue_external_timestamp(tsevq, event); 552 } 553 spin_unlock_irqrestore(&ptp->tsevqs_lock, flags); 554 wake_up_interruptible(&ptp->tsev_wq); 555 break; 556 557 case PTP_CLOCK_PPS: 558 pps_get_ts(&evt); 559 pps_event(ptp->pps_source, &evt, PTP_PPS_EVENT, NULL); 560 break; 561 562 case PTP_CLOCK_PPSUSR: 563 pps_event(ptp->pps_source, &event->pps_times, 564 PTP_PPS_EVENT, NULL); 565 break; 566 } 567 } 568 EXPORT_SYMBOL(ptp_clock_event); 569 570 int ptp_clock_index(struct ptp_clock *ptp) 571 { 572 return ptp->index; 573 } 574 EXPORT_SYMBOL(ptp_clock_index); 575 576 static int ptp_clock_of_node_match(struct device *dev, const void *data) 577 { 578 const struct device_node *parent_np = data; 579 580 return (dev->parent && dev_of_node(dev->parent) == parent_np); 581 } 582 583 int ptp_clock_index_by_of_node(struct device_node *np) 584 { 585 struct ptp_clock *ptp; 586 struct device *dev; 587 int phc_index; 588 589 dev = class_find_device(&ptp_class, NULL, np, 590 ptp_clock_of_node_match); 591 if (!dev) 592 return -1; 593 594 ptp = dev_get_drvdata(dev); 595 phc_index = ptp_clock_index(ptp); 596 put_device(dev); 597 598 return phc_index; 599 } 600 EXPORT_SYMBOL_GPL(ptp_clock_index_by_of_node); 601 602 static int ptp_clock_dev_match(struct device *dev, const void *data) 603 { 604 const struct device *parent = data; 605 606 return dev->parent == parent; 607 } 608 609 int ptp_clock_index_by_dev(struct device *parent) 610 { 611 struct ptp_clock *ptp; 612 struct device *dev; 613 int phc_index; 614 615 dev = class_find_device(&ptp_class, NULL, parent, 616 ptp_clock_dev_match); 617 if (!dev) 618 return -1; 619 620 ptp = dev_get_drvdata(dev); 621 phc_index = ptp_clock_index(ptp); 622 put_device(dev); 623 624 return phc_index; 625 } 626 EXPORT_SYMBOL_GPL(ptp_clock_index_by_dev); 627 628 int ptp_find_pin(struct ptp_clock *ptp, 629 enum ptp_pin_function func, unsigned int chan) 630 { 631 struct ptp_pin_desc *pin = NULL; 632 int i; 633 634 for (i = 0; i < ptp->info->n_pins; i++) { 635 if (ptp->info->pin_config[i].func == func && 636 ptp->info->pin_config[i].chan == chan) { 637 pin = &ptp->info->pin_config[i]; 638 break; 639 } 640 } 641 642 return pin ? i : -1; 643 } 644 EXPORT_SYMBOL(ptp_find_pin); 645 646 int ptp_find_pin_unlocked(struct ptp_clock *ptp, 647 enum ptp_pin_function func, unsigned int chan) 648 { 649 int result; 650 651 mutex_lock(&ptp->pincfg_mux); 652 653 result = ptp_find_pin(ptp, func, chan); 654 655 mutex_unlock(&ptp->pincfg_mux); 656 657 return result; 658 } 659 EXPORT_SYMBOL(ptp_find_pin_unlocked); 660 661 int ptp_schedule_worker(struct ptp_clock *ptp, unsigned long delay) 662 { 663 return kthread_mod_delayed_work(ptp->kworker, &ptp->aux_work, delay); 664 } 665 EXPORT_SYMBOL(ptp_schedule_worker); 666 667 void ptp_cancel_worker_sync(struct ptp_clock *ptp) 668 { 669 kthread_cancel_delayed_work_sync(&ptp->aux_work); 670 } 671 EXPORT_SYMBOL(ptp_cancel_worker_sync); 672 673 /* module operations */ 674 675 static void __exit ptp_exit(void) 676 { 677 class_unregister(&ptp_class); 678 unregister_chrdev_region(ptp_devt, MINORMASK + 1); 679 xa_destroy(&ptp_clocks_map); 680 } 681 682 static int __init ptp_init(void) 683 { 684 int err; 685 686 err = class_register(&ptp_class); 687 if (err) { 688 pr_err("ptp: failed to allocate class\n"); 689 return err; 690 } 691 692 err = alloc_chrdev_region(&ptp_devt, 0, MINORMASK + 1, "ptp"); 693 if (err < 0) { 694 pr_err("ptp: failed to allocate device region\n"); 695 goto no_region; 696 } 697 698 pr_info("PTP clock support registered\n"); 699 return 0; 700 701 no_region: 702 class_unregister(&ptp_class); 703 return err; 704 } 705 706 subsys_initcall(ptp_init); 707 module_exit(ptp_exit); 708 709 MODULE_AUTHOR("Richard Cochran <richardcochran@gmail.com>"); 710 MODULE_DESCRIPTION("PTP clocks support"); 711 MODULE_LICENSE("GPL"); 712