1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * PPS core file 4 * 5 * Copyright (C) 2005-2009 Rodolfo Giometti <giometti@linux.it> 6 */ 7 8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 9 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/init.h> 13 #include <linux/sched.h> 14 #include <linux/uaccess.h> 15 #include <linux/idr.h> 16 #include <linux/mutex.h> 17 #include <linux/cdev.h> 18 #include <linux/poll.h> 19 #include <linux/pps_kernel.h> 20 #include <linux/slab.h> 21 22 #include "kc.h" 23 24 /* 25 * Local variables 26 */ 27 28 static dev_t pps_devt; 29 static struct class *pps_class; 30 31 static DEFINE_MUTEX(pps_idr_lock); 32 static DEFINE_IDR(pps_idr); 33 34 /* 35 * Char device methods 36 */ 37 38 static __poll_t pps_cdev_poll(struct file *file, poll_table *wait) 39 { 40 struct pps_device *pps = file->private_data; 41 42 poll_wait(file, &pps->queue, wait); 43 44 return EPOLLIN | EPOLLRDNORM; 45 } 46 47 static int pps_cdev_fasync(int fd, struct file *file, int on) 48 { 49 struct pps_device *pps = file->private_data; 50 return fasync_helper(fd, file, on, &pps->async_queue); 51 } 52 53 static int pps_cdev_pps_fetch(struct pps_device *pps, struct pps_fdata *fdata) 54 { 55 unsigned int ev = pps->last_ev; 56 int err = 0; 57 58 /* Manage the timeout */ 59 if (fdata->timeout.flags & PPS_TIME_INVALID) 60 err = wait_event_interruptible(pps->queue, 61 ev != pps->last_ev); 62 else { 63 unsigned long ticks; 64 65 dev_dbg(pps->dev, "timeout %lld.%09d\n", 66 (long long) fdata->timeout.sec, 67 fdata->timeout.nsec); 68 ticks = fdata->timeout.sec * HZ; 69 ticks += fdata->timeout.nsec / (NSEC_PER_SEC / HZ); 70 71 if (ticks != 0) { 72 err = wait_event_interruptible_timeout( 73 pps->queue, 74 ev != pps->last_ev, 75 ticks); 76 if (err == 0) 77 return -ETIMEDOUT; 78 } 79 } 80 81 /* Check for pending signals */ 82 if (err == -ERESTARTSYS) { 83 dev_dbg(pps->dev, "pending signal caught\n"); 84 return -EINTR; 85 } 86 87 return 0; 88 } 89 90 static long pps_cdev_ioctl(struct file *file, 91 unsigned int cmd, unsigned long arg) 92 { 93 struct pps_device *pps = file->private_data; 94 struct pps_kparams params; 95 void __user *uarg = (void __user *) arg; 96 int __user *iuarg = (int __user *) arg; 97 int err; 98 99 switch (cmd) { 100 case PPS_GETPARAMS: 101 dev_dbg(pps->dev, "PPS_GETPARAMS\n"); 102 103 spin_lock_irq(&pps->lock); 104 105 /* Get the current parameters */ 106 params = pps->params; 107 108 spin_unlock_irq(&pps->lock); 109 110 err = copy_to_user(uarg, ¶ms, sizeof(struct pps_kparams)); 111 if (err) 112 return -EFAULT; 113 114 break; 115 116 case PPS_SETPARAMS: 117 dev_dbg(pps->dev, "PPS_SETPARAMS\n"); 118 119 /* Check the capabilities */ 120 if (!capable(CAP_SYS_TIME)) 121 return -EPERM; 122 123 err = copy_from_user(¶ms, uarg, sizeof(struct pps_kparams)); 124 if (err) 125 return -EFAULT; 126 if (!(params.mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR))) { 127 dev_dbg(pps->dev, "capture mode unspecified (%x)\n", 128 params.mode); 129 return -EINVAL; 130 } 131 132 /* Check for supported capabilities */ 133 if ((params.mode & ~pps->info.mode) != 0) { 134 dev_dbg(pps->dev, "unsupported capabilities (%x)\n", 135 params.mode); 136 return -EINVAL; 137 } 138 139 spin_lock_irq(&pps->lock); 140 141 /* Save the new parameters */ 142 pps->params = params; 143 144 /* Restore the read only parameters */ 145 if ((params.mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) { 146 /* section 3.3 of RFC 2783 interpreted */ 147 dev_dbg(pps->dev, "time format unspecified (%x)\n", 148 params.mode); 149 pps->params.mode |= PPS_TSFMT_TSPEC; 150 } 151 if (pps->info.mode & PPS_CANWAIT) 152 pps->params.mode |= PPS_CANWAIT; 153 pps->params.api_version = PPS_API_VERS; 154 155 spin_unlock_irq(&pps->lock); 156 157 break; 158 159 case PPS_GETCAP: 160 dev_dbg(pps->dev, "PPS_GETCAP\n"); 161 162 err = put_user(pps->info.mode, iuarg); 163 if (err) 164 return -EFAULT; 165 166 break; 167 168 case PPS_FETCH: { 169 struct pps_fdata fdata; 170 171 dev_dbg(pps->dev, "PPS_FETCH\n"); 172 173 err = copy_from_user(&fdata, uarg, sizeof(struct pps_fdata)); 174 if (err) 175 return -EFAULT; 176 177 err = pps_cdev_pps_fetch(pps, &fdata); 178 if (err) 179 return err; 180 181 /* Return the fetched timestamp */ 182 spin_lock_irq(&pps->lock); 183 184 fdata.info.assert_sequence = pps->assert_sequence; 185 fdata.info.clear_sequence = pps->clear_sequence; 186 fdata.info.assert_tu = pps->assert_tu; 187 fdata.info.clear_tu = pps->clear_tu; 188 fdata.info.current_mode = pps->current_mode; 189 190 spin_unlock_irq(&pps->lock); 191 192 err = copy_to_user(uarg, &fdata, sizeof(struct pps_fdata)); 193 if (err) 194 return -EFAULT; 195 196 break; 197 } 198 case PPS_KC_BIND: { 199 struct pps_bind_args bind_args; 200 201 dev_dbg(pps->dev, "PPS_KC_BIND\n"); 202 203 /* Check the capabilities */ 204 if (!capable(CAP_SYS_TIME)) 205 return -EPERM; 206 207 if (copy_from_user(&bind_args, uarg, 208 sizeof(struct pps_bind_args))) 209 return -EFAULT; 210 211 /* Check for supported capabilities */ 212 if ((bind_args.edge & ~pps->info.mode) != 0) { 213 dev_err(pps->dev, "unsupported capabilities (%x)\n", 214 bind_args.edge); 215 return -EINVAL; 216 } 217 218 /* Validate parameters roughly */ 219 if (bind_args.tsformat != PPS_TSFMT_TSPEC || 220 (bind_args.edge & ~PPS_CAPTUREBOTH) != 0 || 221 bind_args.consumer != PPS_KC_HARDPPS) { 222 dev_err(pps->dev, "invalid kernel consumer bind" 223 " parameters (%x)\n", bind_args.edge); 224 return -EINVAL; 225 } 226 227 err = pps_kc_bind(pps, &bind_args); 228 if (err < 0) 229 return err; 230 231 break; 232 } 233 default: 234 return -ENOTTY; 235 } 236 237 return 0; 238 } 239 240 #ifdef CONFIG_COMPAT 241 static long pps_cdev_compat_ioctl(struct file *file, 242 unsigned int cmd, unsigned long arg) 243 { 244 struct pps_device *pps = file->private_data; 245 void __user *uarg = (void __user *) arg; 246 247 cmd = _IOC(_IOC_DIR(cmd), _IOC_TYPE(cmd), _IOC_NR(cmd), sizeof(void *)); 248 249 if (cmd == PPS_FETCH) { 250 struct pps_fdata_compat compat; 251 struct pps_fdata fdata; 252 int err; 253 254 dev_dbg(pps->dev, "PPS_FETCH\n"); 255 256 err = copy_from_user(&compat, uarg, sizeof(struct pps_fdata_compat)); 257 if (err) 258 return -EFAULT; 259 260 memcpy(&fdata.timeout, &compat.timeout, 261 sizeof(struct pps_ktime_compat)); 262 263 err = pps_cdev_pps_fetch(pps, &fdata); 264 if (err) 265 return err; 266 267 /* Return the fetched timestamp */ 268 spin_lock_irq(&pps->lock); 269 270 compat.info.assert_sequence = pps->assert_sequence; 271 compat.info.clear_sequence = pps->clear_sequence; 272 compat.info.current_mode = pps->current_mode; 273 274 memcpy(&compat.info.assert_tu, &pps->assert_tu, 275 sizeof(struct pps_ktime_compat)); 276 memcpy(&compat.info.clear_tu, &pps->clear_tu, 277 sizeof(struct pps_ktime_compat)); 278 279 spin_unlock_irq(&pps->lock); 280 281 return copy_to_user(uarg, &compat, 282 sizeof(struct pps_fdata_compat)) ? -EFAULT : 0; 283 } 284 285 return pps_cdev_ioctl(file, cmd, arg); 286 } 287 #else 288 #define pps_cdev_compat_ioctl NULL 289 #endif 290 291 static int pps_cdev_open(struct inode *inode, struct file *file) 292 { 293 struct pps_device *pps = container_of(inode->i_cdev, 294 struct pps_device, cdev); 295 file->private_data = pps; 296 kobject_get(&pps->dev->kobj); 297 return 0; 298 } 299 300 static int pps_cdev_release(struct inode *inode, struct file *file) 301 { 302 struct pps_device *pps = container_of(inode->i_cdev, 303 struct pps_device, cdev); 304 kobject_put(&pps->dev->kobj); 305 return 0; 306 } 307 308 /* 309 * Char device stuff 310 */ 311 312 static const struct file_operations pps_cdev_fops = { 313 .owner = THIS_MODULE, 314 .llseek = no_llseek, 315 .poll = pps_cdev_poll, 316 .fasync = pps_cdev_fasync, 317 .compat_ioctl = pps_cdev_compat_ioctl, 318 .unlocked_ioctl = pps_cdev_ioctl, 319 .open = pps_cdev_open, 320 .release = pps_cdev_release, 321 }; 322 323 static void pps_device_destruct(struct device *dev) 324 { 325 struct pps_device *pps = dev_get_drvdata(dev); 326 327 cdev_del(&pps->cdev); 328 329 /* Now we can release the ID for re-use */ 330 pr_debug("deallocating pps%d\n", pps->id); 331 mutex_lock(&pps_idr_lock); 332 idr_remove(&pps_idr, pps->id); 333 mutex_unlock(&pps_idr_lock); 334 335 kfree(dev); 336 kfree(pps); 337 } 338 339 int pps_register_cdev(struct pps_device *pps) 340 { 341 int err; 342 dev_t devt; 343 344 mutex_lock(&pps_idr_lock); 345 /* 346 * Get new ID for the new PPS source. After idr_alloc() calling 347 * the new source will be freely available into the kernel. 348 */ 349 err = idr_alloc(&pps_idr, pps, 0, PPS_MAX_SOURCES, GFP_KERNEL); 350 if (err < 0) { 351 if (err == -ENOSPC) { 352 pr_err("%s: too many PPS sources in the system\n", 353 pps->info.name); 354 err = -EBUSY; 355 } 356 goto out_unlock; 357 } 358 pps->id = err; 359 mutex_unlock(&pps_idr_lock); 360 361 devt = MKDEV(MAJOR(pps_devt), pps->id); 362 363 cdev_init(&pps->cdev, &pps_cdev_fops); 364 pps->cdev.owner = pps->info.owner; 365 366 err = cdev_add(&pps->cdev, devt, 1); 367 if (err) { 368 pr_err("%s: failed to add char device %d:%d\n", 369 pps->info.name, MAJOR(pps_devt), pps->id); 370 goto free_idr; 371 } 372 pps->dev = device_create(pps_class, pps->info.dev, devt, pps, 373 "pps%d", pps->id); 374 if (IS_ERR(pps->dev)) { 375 err = PTR_ERR(pps->dev); 376 goto del_cdev; 377 } 378 379 /* Override the release function with our own */ 380 pps->dev->release = pps_device_destruct; 381 382 pr_debug("source %s got cdev (%d:%d)\n", pps->info.name, 383 MAJOR(pps_devt), pps->id); 384 385 return 0; 386 387 del_cdev: 388 cdev_del(&pps->cdev); 389 390 free_idr: 391 mutex_lock(&pps_idr_lock); 392 idr_remove(&pps_idr, pps->id); 393 out_unlock: 394 mutex_unlock(&pps_idr_lock); 395 return err; 396 } 397 398 void pps_unregister_cdev(struct pps_device *pps) 399 { 400 pr_debug("unregistering pps%d\n", pps->id); 401 pps->lookup_cookie = NULL; 402 device_destroy(pps_class, pps->dev->devt); 403 } 404 405 /* 406 * Look up a pps device by magic cookie. 407 * The cookie is usually a pointer to some enclosing device, but this 408 * code doesn't care; you should never be dereferencing it. 409 * 410 * This is a bit of a kludge that is currently used only by the PPS 411 * serial line discipline. It may need to be tweaked when a second user 412 * is found. 413 * 414 * There is no function interface for setting the lookup_cookie field. 415 * It's initialized to NULL when the pps device is created, and if a 416 * client wants to use it, just fill it in afterward. 417 * 418 * The cookie is automatically set to NULL in pps_unregister_source() 419 * so that it will not be used again, even if the pps device cannot 420 * be removed from the idr due to pending references holding the minor 421 * number in use. 422 */ 423 struct pps_device *pps_lookup_dev(void const *cookie) 424 { 425 struct pps_device *pps; 426 unsigned id; 427 428 rcu_read_lock(); 429 idr_for_each_entry(&pps_idr, pps, id) 430 if (cookie == pps->lookup_cookie) 431 break; 432 rcu_read_unlock(); 433 return pps; 434 } 435 EXPORT_SYMBOL(pps_lookup_dev); 436 437 /* 438 * Module stuff 439 */ 440 441 static void __exit pps_exit(void) 442 { 443 class_destroy(pps_class); 444 unregister_chrdev_region(pps_devt, PPS_MAX_SOURCES); 445 } 446 447 static int __init pps_init(void) 448 { 449 int err; 450 451 pps_class = class_create(THIS_MODULE, "pps"); 452 if (IS_ERR(pps_class)) { 453 pr_err("failed to allocate class\n"); 454 return PTR_ERR(pps_class); 455 } 456 pps_class->dev_groups = pps_groups; 457 458 err = alloc_chrdev_region(&pps_devt, 0, PPS_MAX_SOURCES, "pps"); 459 if (err < 0) { 460 pr_err("failed to allocate char device region\n"); 461 goto remove_class; 462 } 463 464 pr_info("LinuxPPS API ver. %d registered\n", PPS_API_VERS); 465 pr_info("Software ver. %s - Copyright 2005-2007 Rodolfo Giometti " 466 "<giometti@linux.it>\n", PPS_VERSION); 467 468 return 0; 469 470 remove_class: 471 class_destroy(pps_class); 472 473 return err; 474 } 475 476 subsys_initcall(pps_init); 477 module_exit(pps_exit); 478 479 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>"); 480 MODULE_DESCRIPTION("LinuxPPS support (RFC 2783) - ver. " PPS_VERSION); 481 MODULE_LICENSE("GPL"); 482