1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Copyright (c) 2021-2022 NVIDIA Corporation 4 * 5 * Author: Dipen Patel <dipenp@nvidia.com> 6 */ 7 8#include <linux/kernel.h> 9#include <linux/module.h> 10#include <linux/err.h> 11#include <linux/slab.h> 12#include <linux/of.h> 13#include <linux/mutex.h> 14#include <linux/uaccess.h> 15#include <linux/hte.h> 16#include <linux/delay.h> 17#include <linux/debugfs.h> 18#include <linux/device.h> 19 20/* Global list of the HTE devices */ 21static DEFINE_SPINLOCK(hte_lock); 22static LIST_HEAD(hte_devices); 23 24enum { 25 HTE_TS_REGISTERED, 26 HTE_TS_REQ, 27 HTE_TS_DISABLE, 28 HTE_TS_QUEUE_WK, 29}; 30 31/** 32 * struct hte_ts_info - Information related to requested timestamp. 33 * 34 * @xlated_id: Timestamp ID as understood between HTE subsys and HTE provider, 35 * See xlate callback API. 36 * @flags: Flags holding state information. 37 * @hte_cb_flags: Callback related flags. 38 * @seq: Timestamp sequence counter. 39 * @line_name: HTE allocated line name. 40 * @free_attr_name: If set, free the attr name. 41 * @cb: A nonsleeping callback function provided by clients. 42 * @tcb: A secondary sleeping callback function provided by clients. 43 * @dropped_ts: Dropped timestamps. 44 * @slock: Spin lock to synchronize between disable/enable, 45 * request/release APIs. 46 * @cb_work: callback workqueue, used when tcb is specified. 47 * @req_mlock: Lock during timestamp request/release APIs. 48 * @ts_dbg_root: Root for the debug fs. 49 * @gdev: HTE abstract device that this timestamp information belongs to. 50 * @cl_data: Client specific data. 51 */ 52struct hte_ts_info { 53 u32 xlated_id; 54 unsigned long flags; 55 unsigned long hte_cb_flags; 56 u64 seq; 57 char *line_name; 58 bool free_attr_name; 59 hte_ts_cb_t cb; 60 hte_ts_sec_cb_t tcb; 61 atomic_t dropped_ts; 62 spinlock_t slock; 63 struct work_struct cb_work; 64 struct mutex req_mlock; 65 struct dentry *ts_dbg_root; 66 struct hte_device *gdev; 67 void *cl_data; 68}; 69 70/** 71 * struct hte_device - HTE abstract device 72 * @nlines: Number of entities this device supports. 73 * @ts_req: Total number of entities requested. 74 * @sdev: Device used at various debug prints. 75 * @dbg_root: Root directory for debug fs. 76 * @list: List node to store hte_device for each provider. 77 * @chip: HTE chip providing this HTE device. 78 * @owner: helps prevent removal of modules when in use. 79 * @ei: Timestamp information. 80 */ 81struct hte_device { 82 u32 nlines; 83 atomic_t ts_req; 84 struct device *sdev; 85 struct dentry *dbg_root; 86 struct list_head list; 87 struct hte_chip *chip; 88 struct module *owner; 89 struct hte_ts_info ei[] __counted_by(nlines); 90}; 91 92#ifdef CONFIG_DEBUG_FS 93 94static struct dentry *hte_root; 95 96static int __init hte_subsys_dbgfs_init(void) 97{ 98 /* creates /sys/kernel/debug/hte/ */ 99 hte_root = debugfs_create_dir("hte", NULL); 100 101 return 0; 102} 103subsys_initcall(hte_subsys_dbgfs_init); 104 105static void hte_chip_dbgfs_init(struct hte_device *gdev) 106{ 107 const struct hte_chip *chip = gdev->chip; 108 const char *name = chip->name ? chip->name : dev_name(chip->dev); 109 110 gdev->dbg_root = debugfs_create_dir(name, hte_root); 111 112 debugfs_create_atomic_t("ts_requested", 0444, gdev->dbg_root, 113 &gdev->ts_req); 114 debugfs_create_u32("total_ts", 0444, gdev->dbg_root, 115 &gdev->nlines); 116} 117 118static void hte_ts_dbgfs_init(const char *name, struct hte_ts_info *ei) 119{ 120 if (!ei->gdev->dbg_root || !name) 121 return; 122 123 ei->ts_dbg_root = debugfs_create_dir(name, ei->gdev->dbg_root); 124 125 debugfs_create_atomic_t("dropped_timestamps", 0444, ei->ts_dbg_root, 126 &ei->dropped_ts); 127} 128 129#else 130 131static void hte_chip_dbgfs_init(struct hte_device *gdev) 132{ 133} 134 135static void hte_ts_dbgfs_init(const char *name, struct hte_ts_info *ei) 136{ 137} 138 139#endif 140 141/** 142 * hte_ts_put() - Release and disable timestamp for the given desc. 143 * 144 * @desc: timestamp descriptor. 145 * 146 * Context: debugfs_remove_recursive() function call may use sleeping locks, 147 * not suitable from atomic context. 148 * Returns: 0 on success or a negative error code on failure. 149 */ 150int hte_ts_put(struct hte_ts_desc *desc) 151{ 152 int ret = 0; 153 unsigned long flag; 154 struct hte_device *gdev; 155 struct hte_ts_info *ei; 156 157 if (!desc) 158 return -EINVAL; 159 160 ei = desc->hte_data; 161 162 if (!ei || !ei->gdev) 163 return -EINVAL; 164 165 gdev = ei->gdev; 166 167 mutex_lock(&ei->req_mlock); 168 169 if (unlikely(!test_bit(HTE_TS_REQ, &ei->flags) && 170 !test_bit(HTE_TS_REGISTERED, &ei->flags))) { 171 dev_info(gdev->sdev, "id:%d is not requested\n", 172 desc->attr.line_id); 173 ret = -EINVAL; 174 goto unlock; 175 } 176 177 if (unlikely(!test_bit(HTE_TS_REQ, &ei->flags) && 178 test_bit(HTE_TS_REGISTERED, &ei->flags))) { 179 dev_info(gdev->sdev, "id:%d is registered but not requested\n", 180 desc->attr.line_id); 181 ret = -EINVAL; 182 goto unlock; 183 } 184 185 if (test_bit(HTE_TS_REQ, &ei->flags) && 186 !test_bit(HTE_TS_REGISTERED, &ei->flags)) { 187 clear_bit(HTE_TS_REQ, &ei->flags); 188 desc->hte_data = NULL; 189 ret = 0; 190 goto mod_put; 191 } 192 193 ret = gdev->chip->ops->release(gdev->chip, desc, ei->xlated_id); 194 if (ret) { 195 dev_err(gdev->sdev, "id: %d free failed\n", 196 desc->attr.line_id); 197 goto unlock; 198 } 199 200 kfree(ei->line_name); 201 if (ei->free_attr_name) 202 kfree_const(desc->attr.name); 203 204 debugfs_remove_recursive(ei->ts_dbg_root); 205 206 spin_lock_irqsave(&ei->slock, flag); 207 208 if (test_bit(HTE_TS_QUEUE_WK, &ei->flags)) { 209 spin_unlock_irqrestore(&ei->slock, flag); 210 flush_work(&ei->cb_work); 211 spin_lock_irqsave(&ei->slock, flag); 212 } 213 214 atomic_dec(&gdev->ts_req); 215 atomic_set(&ei->dropped_ts, 0); 216 217 ei->seq = 1; 218 ei->flags = 0; 219 desc->hte_data = NULL; 220 221 spin_unlock_irqrestore(&ei->slock, flag); 222 223 ei->cb = NULL; 224 ei->tcb = NULL; 225 ei->cl_data = NULL; 226 227mod_put: 228 module_put(gdev->owner); 229unlock: 230 mutex_unlock(&ei->req_mlock); 231 dev_dbg(gdev->sdev, "release id: %d\n", desc->attr.line_id); 232 233 return ret; 234} 235EXPORT_SYMBOL_GPL(hte_ts_put); 236 237static int hte_ts_dis_en_common(struct hte_ts_desc *desc, bool en) 238{ 239 u32 ts_id; 240 struct hte_device *gdev; 241 struct hte_ts_info *ei; 242 int ret; 243 unsigned long flag; 244 245 if (!desc) 246 return -EINVAL; 247 248 ei = desc->hte_data; 249 250 if (!ei || !ei->gdev) 251 return -EINVAL; 252 253 gdev = ei->gdev; 254 ts_id = desc->attr.line_id; 255 256 mutex_lock(&ei->req_mlock); 257 258 if (!test_bit(HTE_TS_REGISTERED, &ei->flags)) { 259 dev_dbg(gdev->sdev, "id:%d is not registered", ts_id); 260 ret = -EUSERS; 261 goto out; 262 } 263 264 spin_lock_irqsave(&ei->slock, flag); 265 266 if (en) { 267 if (!test_bit(HTE_TS_DISABLE, &ei->flags)) { 268 ret = 0; 269 goto out_unlock; 270 } 271 272 spin_unlock_irqrestore(&ei->slock, flag); 273 ret = gdev->chip->ops->enable(gdev->chip, ei->xlated_id); 274 if (ret) { 275 dev_warn(gdev->sdev, "id: %d enable failed\n", 276 ts_id); 277 goto out; 278 } 279 280 spin_lock_irqsave(&ei->slock, flag); 281 clear_bit(HTE_TS_DISABLE, &ei->flags); 282 } else { 283 if (test_bit(HTE_TS_DISABLE, &ei->flags)) { 284 ret = 0; 285 goto out_unlock; 286 } 287 288 spin_unlock_irqrestore(&ei->slock, flag); 289 ret = gdev->chip->ops->disable(gdev->chip, ei->xlated_id); 290 if (ret) { 291 dev_warn(gdev->sdev, "id: %d disable failed\n", 292 ts_id); 293 goto out; 294 } 295 296 spin_lock_irqsave(&ei->slock, flag); 297 set_bit(HTE_TS_DISABLE, &ei->flags); 298 } 299 300out_unlock: 301 spin_unlock_irqrestore(&ei->slock, flag); 302out: 303 mutex_unlock(&ei->req_mlock); 304 return ret; 305} 306 307/** 308 * hte_disable_ts() - Disable timestamp on given descriptor. 309 * 310 * The API does not release any resources associated with desc. 311 * 312 * @desc: ts descriptor, this is the same as returned by the request API. 313 * 314 * Context: Holds mutex lock, not suitable from atomic context. 315 * Returns: 0 on success or a negative error code on failure. 316 */ 317int hte_disable_ts(struct hte_ts_desc *desc) 318{ 319 return hte_ts_dis_en_common(desc, false); 320} 321EXPORT_SYMBOL_GPL(hte_disable_ts); 322 323/** 324 * hte_enable_ts() - Enable timestamp on given descriptor. 325 * 326 * @desc: ts descriptor, this is the same as returned by the request API. 327 * 328 * Context: Holds mutex lock, not suitable from atomic context. 329 * Returns: 0 on success or a negative error code on failure. 330 */ 331int hte_enable_ts(struct hte_ts_desc *desc) 332{ 333 return hte_ts_dis_en_common(desc, true); 334} 335EXPORT_SYMBOL_GPL(hte_enable_ts); 336 337static void hte_do_cb_work(struct work_struct *w) 338{ 339 unsigned long flag; 340 struct hte_ts_info *ei = container_of(w, struct hte_ts_info, cb_work); 341 342 if (unlikely(!ei->tcb)) 343 return; 344 345 ei->tcb(ei->cl_data); 346 347 spin_lock_irqsave(&ei->slock, flag); 348 clear_bit(HTE_TS_QUEUE_WK, &ei->flags); 349 spin_unlock_irqrestore(&ei->slock, flag); 350} 351 352static int __hte_req_ts(struct hte_ts_desc *desc, hte_ts_cb_t cb, 353 hte_ts_sec_cb_t tcb, void *data) 354{ 355 int ret; 356 struct hte_device *gdev; 357 struct hte_ts_info *ei = desc->hte_data; 358 359 gdev = ei->gdev; 360 /* 361 * There is a chance that multiple consumers requesting same entity, 362 * lock here. 363 */ 364 mutex_lock(&ei->req_mlock); 365 366 if (test_bit(HTE_TS_REGISTERED, &ei->flags) || 367 !test_bit(HTE_TS_REQ, &ei->flags)) { 368 dev_dbg(gdev->chip->dev, "id:%u req failed\n", 369 desc->attr.line_id); 370 ret = -EUSERS; 371 goto unlock; 372 } 373 374 ei->cb = cb; 375 ei->tcb = tcb; 376 if (tcb) 377 INIT_WORK(&ei->cb_work, hte_do_cb_work); 378 379 ret = gdev->chip->ops->request(gdev->chip, desc, ei->xlated_id); 380 if (ret < 0) { 381 dev_err(gdev->chip->dev, "ts request failed\n"); 382 goto unlock; 383 } 384 385 ei->cl_data = data; 386 ei->seq = 1; 387 388 atomic_inc(&gdev->ts_req); 389 390 if (desc->attr.name) 391 ei->line_name = NULL; 392 else 393 ei->line_name = kasprintf(GFP_KERNEL, "ts_%u", desc->attr.line_id); 394 395 hte_ts_dbgfs_init(desc->attr.name == NULL ? 396 ei->line_name : desc->attr.name, ei); 397 set_bit(HTE_TS_REGISTERED, &ei->flags); 398 399 dev_dbg(gdev->chip->dev, "id: %u, xlated id:%u", 400 desc->attr.line_id, ei->xlated_id); 401 402 ret = 0; 403 404unlock: 405 mutex_unlock(&ei->req_mlock); 406 407 return ret; 408} 409 410static int hte_bind_ts_info_locked(struct hte_ts_info *ei, 411 struct hte_ts_desc *desc, u32 x_id) 412{ 413 int ret = 0; 414 415 mutex_lock(&ei->req_mlock); 416 417 if (test_bit(HTE_TS_REQ, &ei->flags)) { 418 dev_dbg(ei->gdev->chip->dev, "id:%u is already requested\n", 419 desc->attr.line_id); 420 ret = -EUSERS; 421 goto out; 422 } 423 424 set_bit(HTE_TS_REQ, &ei->flags); 425 desc->hte_data = ei; 426 ei->xlated_id = x_id; 427 428out: 429 mutex_unlock(&ei->req_mlock); 430 431 return ret; 432} 433 434static struct hte_device *of_node_to_htedevice(struct device_node *np) 435{ 436 struct hte_device *gdev; 437 438 spin_lock(&hte_lock); 439 440 list_for_each_entry(gdev, &hte_devices, list) 441 if (gdev->chip && gdev->chip->dev && 442 device_match_of_node(gdev->chip->dev, np)) { 443 spin_unlock(&hte_lock); 444 return gdev; 445 } 446 447 spin_unlock(&hte_lock); 448 449 return ERR_PTR(-ENODEV); 450} 451 452static struct hte_device *hte_find_dev_from_linedata(struct hte_ts_desc *desc) 453{ 454 struct hte_device *gdev; 455 456 spin_lock(&hte_lock); 457 458 list_for_each_entry(gdev, &hte_devices, list) 459 if (gdev->chip && gdev->chip->match_from_linedata) { 460 if (!gdev->chip->match_from_linedata(gdev->chip, desc)) 461 continue; 462 spin_unlock(&hte_lock); 463 return gdev; 464 } 465 466 spin_unlock(&hte_lock); 467 468 return ERR_PTR(-ENODEV); 469} 470 471/** 472 * of_hte_req_count - Return the number of entities to timestamp. 473 * 474 * The function returns the total count of the requested entities to timestamp 475 * by parsing device tree. 476 * 477 * @dev: The HTE consumer. 478 * 479 * Returns: Positive number on success, -ENOENT if no entries, 480 * -EINVAL for other errors. 481 */ 482int of_hte_req_count(struct device *dev) 483{ 484 int count; 485 486 if (!dev || !dev->of_node) 487 return -EINVAL; 488 489 count = of_count_phandle_with_args(dev->of_node, "timestamps", 490 "#timestamp-cells"); 491 492 return count ? count : -ENOENT; 493} 494EXPORT_SYMBOL_GPL(of_hte_req_count); 495 496static inline struct hte_device *hte_get_dev(struct hte_ts_desc *desc) 497{ 498 return hte_find_dev_from_linedata(desc); 499} 500 501static struct hte_device *hte_of_get_dev(struct device *dev, 502 struct hte_ts_desc *desc, 503 int index, 504 struct of_phandle_args *args, 505 bool *free_name) 506{ 507 int ret; 508 struct device_node *np; 509 char *temp; 510 511 if (!dev->of_node) 512 return ERR_PTR(-EINVAL); 513 514 np = dev->of_node; 515 516 if (!of_property_present(np, "timestamp-names")) { 517 /* Let hte core construct it during request time */ 518 desc->attr.name = NULL; 519 } else { 520 ret = of_property_read_string_index(np, "timestamp-names", 521 index, &desc->attr.name); 522 if (ret) { 523 pr_err("can't parse \"timestamp-names\" property\n"); 524 return ERR_PTR(ret); 525 } 526 *free_name = false; 527 if (desc->attr.name) { 528 temp = skip_spaces(desc->attr.name); 529 if (!*temp) 530 desc->attr.name = NULL; 531 } 532 } 533 534 ret = of_parse_phandle_with_args(np, "timestamps", "#timestamp-cells", 535 index, args); 536 if (ret) { 537 pr_err("%s(): can't parse \"timestamps\" property\n", 538 __func__); 539 return ERR_PTR(ret); 540 } 541 542 of_node_put(args->np); 543 544 return of_node_to_htedevice(args->np); 545} 546 547/** 548 * hte_ts_get() - The function to initialize and obtain HTE desc. 549 * 550 * The function initializes the consumer provided HTE descriptor. If consumer 551 * has device tree node, index is used to parse the line id and other details. 552 * The function needs to be called before using any request APIs. 553 * 554 * @dev: HTE consumer/client device, used in case of parsing device tree node. 555 * @desc: Pre-allocated timestamp descriptor. 556 * @index: The index will be used as an index to parse line_id from the 557 * device tree node if node is present. 558 * 559 * Context: Holds mutex lock. 560 * Returns: Returns 0 on success or negative error code on failure. 561 */ 562int hte_ts_get(struct device *dev, struct hte_ts_desc *desc, int index) 563{ 564 struct hte_device *gdev; 565 struct hte_ts_info *ei; 566 const struct fwnode_handle *fwnode; 567 struct of_phandle_args args; 568 u32 xlated_id; 569 int ret; 570 bool free_name = false; 571 572 if (!desc) 573 return -EINVAL; 574 575 fwnode = dev ? dev_fwnode(dev) : NULL; 576 577 if (is_of_node(fwnode)) 578 gdev = hte_of_get_dev(dev, desc, index, &args, &free_name); 579 else 580 gdev = hte_get_dev(desc); 581 582 if (IS_ERR(gdev)) { 583 pr_err("%s() no hte dev found\n", __func__); 584 return PTR_ERR(gdev); 585 } 586 587 if (!try_module_get(gdev->owner)) 588 return -ENODEV; 589 590 if (!gdev->chip) { 591 pr_err("%s(): requested id does not have provider\n", 592 __func__); 593 ret = -ENODEV; 594 goto put; 595 } 596 597 if (is_of_node(fwnode)) { 598 if (!gdev->chip->xlate_of) 599 ret = -EINVAL; 600 else 601 ret = gdev->chip->xlate_of(gdev->chip, &args, 602 desc, &xlated_id); 603 } else { 604 if (!gdev->chip->xlate_plat) 605 ret = -EINVAL; 606 else 607 ret = gdev->chip->xlate_plat(gdev->chip, desc, 608 &xlated_id); 609 } 610 611 if (ret < 0) 612 goto put; 613 614 ei = &gdev->ei[xlated_id]; 615 616 ret = hte_bind_ts_info_locked(ei, desc, xlated_id); 617 if (ret) 618 goto put; 619 620 ei->free_attr_name = free_name; 621 622 return 0; 623 624put: 625 module_put(gdev->owner); 626 return ret; 627} 628EXPORT_SYMBOL_GPL(hte_ts_get); 629 630static void __devm_hte_release_ts(void *res) 631{ 632 hte_ts_put(res); 633} 634 635/** 636 * hte_request_ts_ns() - The API to request and enable hardware timestamp in 637 * nanoseconds. 638 * 639 * The entity is provider specific for example, GPIO lines, signals, buses 640 * etc...The API allocates necessary resources and enables the timestamp. 641 * 642 * @desc: Pre-allocated and initialized timestamp descriptor. 643 * @cb: Callback to push the timestamp data to consumer. 644 * @tcb: Optional callback. If its provided, subsystem initializes 645 * workqueue. It is called when cb returns HTE_RUN_SECOND_CB. 646 * @data: Client data, used during cb and tcb callbacks. 647 * 648 * Context: Holds mutex lock. 649 * Returns: Returns 0 on success or negative error code on failure. 650 */ 651int hte_request_ts_ns(struct hte_ts_desc *desc, hte_ts_cb_t cb, 652 hte_ts_sec_cb_t tcb, void *data) 653{ 654 int ret; 655 struct hte_ts_info *ei; 656 657 if (!desc || !desc->hte_data || !cb) 658 return -EINVAL; 659 660 ei = desc->hte_data; 661 if (!ei || !ei->gdev) 662 return -EINVAL; 663 664 ret = __hte_req_ts(desc, cb, tcb, data); 665 if (ret < 0) { 666 dev_err(ei->gdev->chip->dev, 667 "failed to request id: %d\n", desc->attr.line_id); 668 return ret; 669 } 670 671 return 0; 672} 673EXPORT_SYMBOL_GPL(hte_request_ts_ns); 674 675/** 676 * devm_hte_request_ts_ns() - Resource managed API to request and enable 677 * hardware timestamp in nanoseconds. 678 * 679 * The entity is provider specific for example, GPIO lines, signals, buses 680 * etc...The API allocates necessary resources and enables the timestamp. It 681 * deallocates and disables automatically when the consumer exits. 682 * 683 * @dev: HTE consumer/client device. 684 * @desc: Pre-allocated and initialized timestamp descriptor. 685 * @cb: Callback to push the timestamp data to consumer. 686 * @tcb: Optional callback. If its provided, subsystem initializes 687 * workqueue. It is called when cb returns HTE_RUN_SECOND_CB. 688 * @data: Client data, used during cb and tcb callbacks. 689 * 690 * Context: Holds mutex lock. 691 * Returns: Returns 0 on success or negative error code on failure. 692 */ 693int devm_hte_request_ts_ns(struct device *dev, struct hte_ts_desc *desc, 694 hte_ts_cb_t cb, hte_ts_sec_cb_t tcb, 695 void *data) 696{ 697 int err; 698 699 if (!dev) 700 return -EINVAL; 701 702 err = hte_request_ts_ns(desc, cb, tcb, data); 703 if (err) 704 return err; 705 706 err = devm_add_action_or_reset(dev, __devm_hte_release_ts, desc); 707 if (err) 708 return err; 709 710 return 0; 711} 712EXPORT_SYMBOL_GPL(devm_hte_request_ts_ns); 713 714/** 715 * hte_init_line_attr() - Initialize line attributes. 716 * 717 * Zeroes out line attributes and initializes with provided arguments. 718 * The function needs to be called before calling any consumer facing 719 * functions. 720 * 721 * @desc: Pre-allocated timestamp descriptor. 722 * @line_id: line id. 723 * @edge_flags: edge flags related to line_id. 724 * @name: name of the line. 725 * @data: line data related to line_id. 726 * 727 * Context: Any. 728 * Returns: 0 on success or negative error code for the failure. 729 */ 730int hte_init_line_attr(struct hte_ts_desc *desc, u32 line_id, 731 unsigned long edge_flags, const char *name, void *data) 732{ 733 if (!desc) 734 return -EINVAL; 735 736 memset(&desc->attr, 0, sizeof(desc->attr)); 737 738 desc->attr.edge_flags = edge_flags; 739 desc->attr.line_id = line_id; 740 desc->attr.line_data = data; 741 if (name) { 742 name = kstrdup_const(name, GFP_KERNEL); 743 if (!name) 744 return -ENOMEM; 745 } 746 747 desc->attr.name = name; 748 749 return 0; 750} 751EXPORT_SYMBOL_GPL(hte_init_line_attr); 752 753/** 754 * hte_get_clk_src_info() - Get the clock source information for a ts 755 * descriptor. 756 * 757 * @desc: ts descriptor, same as returned from request API. 758 * @ci: The API fills this structure with the clock information data. 759 * 760 * Context: Any context. 761 * Returns: 0 on success else negative error code on failure. 762 */ 763int hte_get_clk_src_info(const struct hte_ts_desc *desc, 764 struct hte_clk_info *ci) 765{ 766 struct hte_chip *chip; 767 struct hte_ts_info *ei; 768 769 if (!desc || !desc->hte_data || !ci) { 770 pr_debug("%s:%d\n", __func__, __LINE__); 771 return -EINVAL; 772 } 773 774 ei = desc->hte_data; 775 if (!ei->gdev || !ei->gdev->chip) 776 return -EINVAL; 777 778 chip = ei->gdev->chip; 779 if (!chip->ops->get_clk_src_info) 780 return -EOPNOTSUPP; 781 782 return chip->ops->get_clk_src_info(chip, ci); 783} 784EXPORT_SYMBOL_GPL(hte_get_clk_src_info); 785 786/** 787 * hte_push_ts_ns() - Push timestamp data in nanoseconds. 788 * 789 * It is used by the provider to push timestamp data. 790 * 791 * @chip: The HTE chip, used during the registration. 792 * @xlated_id: entity id understood by both subsystem and provider, this is 793 * obtained from xlate callback during request API. 794 * @data: timestamp data. 795 * 796 * Returns: 0 on success or a negative error code on failure. 797 */ 798int hte_push_ts_ns(const struct hte_chip *chip, u32 xlated_id, 799 struct hte_ts_data *data) 800{ 801 enum hte_return ret; 802 int st = 0; 803 struct hte_ts_info *ei; 804 unsigned long flag; 805 806 if (!chip || !data || !chip->gdev) 807 return -EINVAL; 808 809 if (xlated_id >= chip->nlines) 810 return -EINVAL; 811 812 ei = &chip->gdev->ei[xlated_id]; 813 814 spin_lock_irqsave(&ei->slock, flag); 815 816 /* timestamp sequence counter */ 817 data->seq = ei->seq++; 818 819 if (!test_bit(HTE_TS_REGISTERED, &ei->flags) || 820 test_bit(HTE_TS_DISABLE, &ei->flags)) { 821 dev_dbg(chip->dev, "Unknown timestamp push\n"); 822 atomic_inc(&ei->dropped_ts); 823 st = -EINVAL; 824 goto unlock; 825 } 826 827 ret = ei->cb(data, ei->cl_data); 828 if (ret == HTE_RUN_SECOND_CB && ei->tcb) { 829 queue_work(system_unbound_wq, &ei->cb_work); 830 set_bit(HTE_TS_QUEUE_WK, &ei->flags); 831 } 832 833unlock: 834 spin_unlock_irqrestore(&ei->slock, flag); 835 836 return st; 837} 838EXPORT_SYMBOL_GPL(hte_push_ts_ns); 839 840static int hte_register_chip(struct hte_chip *chip) 841{ 842 struct hte_device *gdev; 843 u32 i; 844 845 if (!chip || !chip->dev || !chip->dev->of_node) 846 return -EINVAL; 847 848 if (!chip->ops || !chip->ops->request || !chip->ops->release) { 849 dev_err(chip->dev, "Driver needs to provide ops\n"); 850 return -EINVAL; 851 } 852 853 gdev = kzalloc(struct_size(gdev, ei, chip->nlines), GFP_KERNEL); 854 if (!gdev) 855 return -ENOMEM; 856 857 gdev->chip = chip; 858 chip->gdev = gdev; 859 gdev->nlines = chip->nlines; 860 gdev->sdev = chip->dev; 861 862 for (i = 0; i < chip->nlines; i++) { 863 gdev->ei[i].gdev = gdev; 864 mutex_init(&gdev->ei[i].req_mlock); 865 spin_lock_init(&gdev->ei[i].slock); 866 } 867 868 if (chip->dev->driver) 869 gdev->owner = chip->dev->driver->owner; 870 else 871 gdev->owner = THIS_MODULE; 872 873 of_node_get(chip->dev->of_node); 874 875 INIT_LIST_HEAD(&gdev->list); 876 877 spin_lock(&hte_lock); 878 list_add_tail(&gdev->list, &hte_devices); 879 spin_unlock(&hte_lock); 880 881 hte_chip_dbgfs_init(gdev); 882 883 dev_dbg(chip->dev, "Added hte chip\n"); 884 885 return 0; 886} 887 888static int hte_unregister_chip(struct hte_chip *chip) 889{ 890 struct hte_device *gdev; 891 892 if (!chip) 893 return -EINVAL; 894 895 gdev = chip->gdev; 896 897 spin_lock(&hte_lock); 898 list_del(&gdev->list); 899 spin_unlock(&hte_lock); 900 901 gdev->chip = NULL; 902 903 of_node_put(chip->dev->of_node); 904 debugfs_remove_recursive(gdev->dbg_root); 905 kfree(gdev); 906 907 dev_dbg(chip->dev, "Removed hte chip\n"); 908 909 return 0; 910} 911 912static void _hte_devm_unregister_chip(void *chip) 913{ 914 hte_unregister_chip(chip); 915} 916 917/** 918 * devm_hte_register_chip() - Resource managed API to register HTE chip. 919 * 920 * It is used by the provider to register itself with the HTE subsystem. 921 * The unregistration is done automatically when the provider exits. 922 * 923 * @chip: the HTE chip to add to subsystem. 924 * 925 * Returns: 0 on success or a negative error code on failure. 926 */ 927int devm_hte_register_chip(struct hte_chip *chip) 928{ 929 int err; 930 931 err = hte_register_chip(chip); 932 if (err) 933 return err; 934 935 err = devm_add_action_or_reset(chip->dev, _hte_devm_unregister_chip, 936 chip); 937 if (err) 938 return err; 939 940 return 0; 941} 942EXPORT_SYMBOL_GPL(devm_hte_register_chip); 943