1 /* 2 * Generic pwmlib implementation 3 * 4 * Copyright (C) 2011 Sascha Hauer <s.hauer@pengutronix.de> 5 * Copyright (C) 2011-2012 Avionic Design GmbH 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2, or (at your option) 10 * any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; see the file COPYING. If not, write to 19 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22 #include <linux/module.h> 23 #include <linux/pwm.h> 24 #include <linux/radix-tree.h> 25 #include <linux/list.h> 26 #include <linux/mutex.h> 27 #include <linux/err.h> 28 #include <linux/slab.h> 29 #include <linux/device.h> 30 #include <linux/debugfs.h> 31 #include <linux/seq_file.h> 32 33 #define MAX_PWMS 1024 34 35 /* flags in the third cell of the DT PWM specifier */ 36 #define PWM_SPEC_POLARITY (1 << 0) 37 38 static DEFINE_MUTEX(pwm_lookup_lock); 39 static LIST_HEAD(pwm_lookup_list); 40 static DEFINE_MUTEX(pwm_lock); 41 static LIST_HEAD(pwm_chips); 42 static DECLARE_BITMAP(allocated_pwms, MAX_PWMS); 43 static RADIX_TREE(pwm_tree, GFP_KERNEL); 44 45 static struct pwm_device *pwm_to_device(unsigned int pwm) 46 { 47 return radix_tree_lookup(&pwm_tree, pwm); 48 } 49 50 static int alloc_pwms(int pwm, unsigned int count) 51 { 52 unsigned int from = 0; 53 unsigned int start; 54 55 if (pwm >= MAX_PWMS) 56 return -EINVAL; 57 58 if (pwm >= 0) 59 from = pwm; 60 61 start = bitmap_find_next_zero_area(allocated_pwms, MAX_PWMS, from, 62 count, 0); 63 64 if (pwm >= 0 && start != pwm) 65 return -EEXIST; 66 67 if (start + count > MAX_PWMS) 68 return -ENOSPC; 69 70 return start; 71 } 72 73 static void free_pwms(struct pwm_chip *chip) 74 { 75 unsigned int i; 76 77 for (i = 0; i < chip->npwm; i++) { 78 struct pwm_device *pwm = &chip->pwms[i]; 79 radix_tree_delete(&pwm_tree, pwm->pwm); 80 } 81 82 bitmap_clear(allocated_pwms, chip->base, chip->npwm); 83 84 kfree(chip->pwms); 85 chip->pwms = NULL; 86 } 87 88 static struct pwm_chip *pwmchip_find_by_name(const char *name) 89 { 90 struct pwm_chip *chip; 91 92 if (!name) 93 return NULL; 94 95 mutex_lock(&pwm_lock); 96 97 list_for_each_entry(chip, &pwm_chips, list) { 98 const char *chip_name = dev_name(chip->dev); 99 100 if (chip_name && strcmp(chip_name, name) == 0) { 101 mutex_unlock(&pwm_lock); 102 return chip; 103 } 104 } 105 106 mutex_unlock(&pwm_lock); 107 108 return NULL; 109 } 110 111 static int pwm_device_request(struct pwm_device *pwm, const char *label) 112 { 113 int err; 114 115 if (test_bit(PWMF_REQUESTED, &pwm->flags)) 116 return -EBUSY; 117 118 if (!try_module_get(pwm->chip->ops->owner)) 119 return -ENODEV; 120 121 if (pwm->chip->ops->request) { 122 err = pwm->chip->ops->request(pwm->chip, pwm); 123 if (err) { 124 module_put(pwm->chip->ops->owner); 125 return err; 126 } 127 } 128 129 set_bit(PWMF_REQUESTED, &pwm->flags); 130 pwm->label = label; 131 132 return 0; 133 } 134 135 struct pwm_device * 136 of_pwm_xlate_with_flags(struct pwm_chip *pc, const struct of_phandle_args *args) 137 { 138 struct pwm_device *pwm; 139 140 if (pc->of_pwm_n_cells < 3) 141 return ERR_PTR(-EINVAL); 142 143 if (args->args[0] >= pc->npwm) 144 return ERR_PTR(-EINVAL); 145 146 pwm = pwm_request_from_chip(pc, args->args[0], NULL); 147 if (IS_ERR(pwm)) 148 return pwm; 149 150 pwm_set_period(pwm, args->args[1]); 151 152 if (args->args[2] & PWM_SPEC_POLARITY) 153 pwm_set_polarity(pwm, PWM_POLARITY_INVERSED); 154 else 155 pwm_set_polarity(pwm, PWM_POLARITY_NORMAL); 156 157 return pwm; 158 } 159 EXPORT_SYMBOL_GPL(of_pwm_xlate_with_flags); 160 161 static struct pwm_device * 162 of_pwm_simple_xlate(struct pwm_chip *pc, const struct of_phandle_args *args) 163 { 164 struct pwm_device *pwm; 165 166 if (pc->of_pwm_n_cells < 2) 167 return ERR_PTR(-EINVAL); 168 169 if (args->args[0] >= pc->npwm) 170 return ERR_PTR(-EINVAL); 171 172 pwm = pwm_request_from_chip(pc, args->args[0], NULL); 173 if (IS_ERR(pwm)) 174 return pwm; 175 176 pwm_set_period(pwm, args->args[1]); 177 178 return pwm; 179 } 180 181 static void of_pwmchip_add(struct pwm_chip *chip) 182 { 183 if (!chip->dev || !chip->dev->of_node) 184 return; 185 186 if (!chip->of_xlate) { 187 chip->of_xlate = of_pwm_simple_xlate; 188 chip->of_pwm_n_cells = 2; 189 } 190 191 of_node_get(chip->dev->of_node); 192 } 193 194 static void of_pwmchip_remove(struct pwm_chip *chip) 195 { 196 if (chip->dev && chip->dev->of_node) 197 of_node_put(chip->dev->of_node); 198 } 199 200 /** 201 * pwm_set_chip_data() - set private chip data for a PWM 202 * @pwm: PWM device 203 * @data: pointer to chip-specific data 204 */ 205 int pwm_set_chip_data(struct pwm_device *pwm, void *data) 206 { 207 if (!pwm) 208 return -EINVAL; 209 210 pwm->chip_data = data; 211 212 return 0; 213 } 214 215 /** 216 * pwm_get_chip_data() - get private chip data for a PWM 217 * @pwm: PWM device 218 */ 219 void *pwm_get_chip_data(struct pwm_device *pwm) 220 { 221 return pwm ? pwm->chip_data : NULL; 222 } 223 224 /** 225 * pwmchip_add() - register a new PWM chip 226 * @chip: the PWM chip to add 227 * 228 * Register a new PWM chip. If chip->base < 0 then a dynamically assigned base 229 * will be used. 230 */ 231 int pwmchip_add(struct pwm_chip *chip) 232 { 233 struct pwm_device *pwm; 234 unsigned int i; 235 int ret; 236 237 if (!chip || !chip->dev || !chip->ops || !chip->ops->config || 238 !chip->ops->enable || !chip->ops->disable) 239 return -EINVAL; 240 241 mutex_lock(&pwm_lock); 242 243 ret = alloc_pwms(chip->base, chip->npwm); 244 if (ret < 0) 245 goto out; 246 247 chip->pwms = kzalloc(chip->npwm * sizeof(*pwm), GFP_KERNEL); 248 if (!chip->pwms) { 249 ret = -ENOMEM; 250 goto out; 251 } 252 253 chip->base = ret; 254 255 for (i = 0; i < chip->npwm; i++) { 256 pwm = &chip->pwms[i]; 257 258 pwm->chip = chip; 259 pwm->pwm = chip->base + i; 260 pwm->hwpwm = i; 261 262 radix_tree_insert(&pwm_tree, pwm->pwm, pwm); 263 } 264 265 bitmap_set(allocated_pwms, chip->base, chip->npwm); 266 267 INIT_LIST_HEAD(&chip->list); 268 list_add(&chip->list, &pwm_chips); 269 270 ret = 0; 271 272 if (IS_ENABLED(CONFIG_OF)) 273 of_pwmchip_add(chip); 274 275 out: 276 mutex_unlock(&pwm_lock); 277 return ret; 278 } 279 EXPORT_SYMBOL_GPL(pwmchip_add); 280 281 /** 282 * pwmchip_remove() - remove a PWM chip 283 * @chip: the PWM chip to remove 284 * 285 * Removes a PWM chip. This function may return busy if the PWM chip provides 286 * a PWM device that is still requested. 287 */ 288 int pwmchip_remove(struct pwm_chip *chip) 289 { 290 unsigned int i; 291 int ret = 0; 292 293 mutex_lock(&pwm_lock); 294 295 for (i = 0; i < chip->npwm; i++) { 296 struct pwm_device *pwm = &chip->pwms[i]; 297 298 if (test_bit(PWMF_REQUESTED, &pwm->flags)) { 299 ret = -EBUSY; 300 goto out; 301 } 302 } 303 304 list_del_init(&chip->list); 305 306 if (IS_ENABLED(CONFIG_OF)) 307 of_pwmchip_remove(chip); 308 309 free_pwms(chip); 310 311 out: 312 mutex_unlock(&pwm_lock); 313 return ret; 314 } 315 EXPORT_SYMBOL_GPL(pwmchip_remove); 316 317 /** 318 * pwm_request() - request a PWM device 319 * @pwm_id: global PWM device index 320 * @label: PWM device label 321 * 322 * This function is deprecated, use pwm_get() instead. 323 */ 324 struct pwm_device *pwm_request(int pwm, const char *label) 325 { 326 struct pwm_device *dev; 327 int err; 328 329 if (pwm < 0 || pwm >= MAX_PWMS) 330 return ERR_PTR(-EINVAL); 331 332 mutex_lock(&pwm_lock); 333 334 dev = pwm_to_device(pwm); 335 if (!dev) { 336 dev = ERR_PTR(-EPROBE_DEFER); 337 goto out; 338 } 339 340 err = pwm_device_request(dev, label); 341 if (err < 0) 342 dev = ERR_PTR(err); 343 344 out: 345 mutex_unlock(&pwm_lock); 346 347 return dev; 348 } 349 EXPORT_SYMBOL_GPL(pwm_request); 350 351 /** 352 * pwm_request_from_chip() - request a PWM device relative to a PWM chip 353 * @chip: PWM chip 354 * @index: per-chip index of the PWM to request 355 * @label: a literal description string of this PWM 356 * 357 * Returns the PWM at the given index of the given PWM chip. A negative error 358 * code is returned if the index is not valid for the specified PWM chip or 359 * if the PWM device cannot be requested. 360 */ 361 struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip, 362 unsigned int index, 363 const char *label) 364 { 365 struct pwm_device *pwm; 366 int err; 367 368 if (!chip || index >= chip->npwm) 369 return ERR_PTR(-EINVAL); 370 371 mutex_lock(&pwm_lock); 372 pwm = &chip->pwms[index]; 373 374 err = pwm_device_request(pwm, label); 375 if (err < 0) 376 pwm = ERR_PTR(err); 377 378 mutex_unlock(&pwm_lock); 379 return pwm; 380 } 381 EXPORT_SYMBOL_GPL(pwm_request_from_chip); 382 383 /** 384 * pwm_free() - free a PWM device 385 * @pwm: PWM device 386 * 387 * This function is deprecated, use pwm_put() instead. 388 */ 389 void pwm_free(struct pwm_device *pwm) 390 { 391 pwm_put(pwm); 392 } 393 EXPORT_SYMBOL_GPL(pwm_free); 394 395 /** 396 * pwm_config() - change a PWM device configuration 397 * @pwm: PWM device 398 * @duty_ns: "on" time (in nanoseconds) 399 * @period_ns: duration (in nanoseconds) of one cycle 400 */ 401 int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns) 402 { 403 if (!pwm || duty_ns < 0 || period_ns <= 0 || duty_ns > period_ns) 404 return -EINVAL; 405 406 return pwm->chip->ops->config(pwm->chip, pwm, duty_ns, period_ns); 407 } 408 EXPORT_SYMBOL_GPL(pwm_config); 409 410 /** 411 * pwm_set_polarity() - configure the polarity of a PWM signal 412 * @pwm: PWM device 413 * @polarity: new polarity of the PWM signal 414 * 415 * Note that the polarity cannot be configured while the PWM device is enabled 416 */ 417 int pwm_set_polarity(struct pwm_device *pwm, enum pwm_polarity polarity) 418 { 419 if (!pwm || !pwm->chip->ops) 420 return -EINVAL; 421 422 if (!pwm->chip->ops->set_polarity) 423 return -ENOSYS; 424 425 if (test_bit(PWMF_ENABLED, &pwm->flags)) 426 return -EBUSY; 427 428 return pwm->chip->ops->set_polarity(pwm->chip, pwm, polarity); 429 } 430 EXPORT_SYMBOL_GPL(pwm_set_polarity); 431 432 /** 433 * pwm_enable() - start a PWM output toggling 434 * @pwm: PWM device 435 */ 436 int pwm_enable(struct pwm_device *pwm) 437 { 438 if (pwm && !test_and_set_bit(PWMF_ENABLED, &pwm->flags)) 439 return pwm->chip->ops->enable(pwm->chip, pwm); 440 441 return pwm ? 0 : -EINVAL; 442 } 443 EXPORT_SYMBOL_GPL(pwm_enable); 444 445 /** 446 * pwm_disable() - stop a PWM output toggling 447 * @pwm: PWM device 448 */ 449 void pwm_disable(struct pwm_device *pwm) 450 { 451 if (pwm && test_and_clear_bit(PWMF_ENABLED, &pwm->flags)) 452 pwm->chip->ops->disable(pwm->chip, pwm); 453 } 454 EXPORT_SYMBOL_GPL(pwm_disable); 455 456 static struct pwm_chip *of_node_to_pwmchip(struct device_node *np) 457 { 458 struct pwm_chip *chip; 459 460 mutex_lock(&pwm_lock); 461 462 list_for_each_entry(chip, &pwm_chips, list) 463 if (chip->dev && chip->dev->of_node == np) { 464 mutex_unlock(&pwm_lock); 465 return chip; 466 } 467 468 mutex_unlock(&pwm_lock); 469 470 return ERR_PTR(-EPROBE_DEFER); 471 } 472 473 /** 474 * of_pwm_request() - request a PWM via the PWM framework 475 * @np: device node to get the PWM from 476 * @con_id: consumer name 477 * 478 * Returns the PWM device parsed from the phandle and index specified in the 479 * "pwms" property of a device tree node or a negative error-code on failure. 480 * Values parsed from the device tree are stored in the returned PWM device 481 * object. 482 * 483 * If con_id is NULL, the first PWM device listed in the "pwms" property will 484 * be requested. Otherwise the "pwm-names" property is used to do a reverse 485 * lookup of the PWM index. This also means that the "pwm-names" property 486 * becomes mandatory for devices that look up the PWM device via the con_id 487 * parameter. 488 */ 489 static struct pwm_device *of_pwm_request(struct device_node *np, 490 const char *con_id) 491 { 492 struct pwm_device *pwm = NULL; 493 struct of_phandle_args args; 494 struct pwm_chip *pc; 495 int index = 0; 496 int err; 497 498 if (con_id) { 499 index = of_property_match_string(np, "pwm-names", con_id); 500 if (index < 0) 501 return ERR_PTR(index); 502 } 503 504 err = of_parse_phandle_with_args(np, "pwms", "#pwm-cells", index, 505 &args); 506 if (err) { 507 pr_debug("%s(): can't parse \"pwms\" property\n", __func__); 508 return ERR_PTR(err); 509 } 510 511 pc = of_node_to_pwmchip(args.np); 512 if (IS_ERR(pc)) { 513 pr_debug("%s(): PWM chip not found\n", __func__); 514 pwm = ERR_CAST(pc); 515 goto put; 516 } 517 518 if (args.args_count != pc->of_pwm_n_cells) { 519 pr_debug("%s: wrong #pwm-cells for %s\n", np->full_name, 520 args.np->full_name); 521 pwm = ERR_PTR(-EINVAL); 522 goto put; 523 } 524 525 pwm = pc->of_xlate(pc, &args); 526 if (IS_ERR(pwm)) 527 goto put; 528 529 /* 530 * If a consumer name was not given, try to look it up from the 531 * "pwm-names" property if it exists. Otherwise use the name of 532 * the user device node. 533 */ 534 if (!con_id) { 535 err = of_property_read_string_index(np, "pwm-names", index, 536 &con_id); 537 if (err < 0) 538 con_id = np->name; 539 } 540 541 pwm->label = con_id; 542 543 put: 544 of_node_put(args.np); 545 546 return pwm; 547 } 548 549 /** 550 * pwm_add_table() - register PWM device consumers 551 * @table: array of consumers to register 552 * @num: number of consumers in table 553 */ 554 void __init pwm_add_table(struct pwm_lookup *table, size_t num) 555 { 556 mutex_lock(&pwm_lookup_lock); 557 558 while (num--) { 559 list_add_tail(&table->list, &pwm_lookup_list); 560 table++; 561 } 562 563 mutex_unlock(&pwm_lookup_lock); 564 } 565 566 /** 567 * pwm_get() - look up and request a PWM device 568 * @dev: device for PWM consumer 569 * @con_id: consumer name 570 * 571 * Lookup is first attempted using DT. If the device was not instantiated from 572 * a device tree, a PWM chip and a relative index is looked up via a table 573 * supplied by board setup code (see pwm_add_table()). 574 * 575 * Once a PWM chip has been found the specified PWM device will be requested 576 * and is ready to be used. 577 */ 578 struct pwm_device *pwm_get(struct device *dev, const char *con_id) 579 { 580 struct pwm_device *pwm = ERR_PTR(-EPROBE_DEFER); 581 const char *dev_id = dev ? dev_name(dev) : NULL; 582 struct pwm_chip *chip = NULL; 583 unsigned int index = 0; 584 unsigned int best = 0; 585 struct pwm_lookup *p; 586 unsigned int match; 587 588 /* look up via DT first */ 589 if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node) 590 return of_pwm_request(dev->of_node, con_id); 591 592 /* 593 * We look up the provider in the static table typically provided by 594 * board setup code. We first try to lookup the consumer device by 595 * name. If the consumer device was passed in as NULL or if no match 596 * was found, we try to find the consumer by directly looking it up 597 * by name. 598 * 599 * If a match is found, the provider PWM chip is looked up by name 600 * and a PWM device is requested using the PWM device per-chip index. 601 * 602 * The lookup algorithm was shamelessly taken from the clock 603 * framework: 604 * 605 * We do slightly fuzzy matching here: 606 * An entry with a NULL ID is assumed to be a wildcard. 607 * If an entry has a device ID, it must match 608 * If an entry has a connection ID, it must match 609 * Then we take the most specific entry - with the following order 610 * of precedence: dev+con > dev only > con only. 611 */ 612 mutex_lock(&pwm_lookup_lock); 613 614 list_for_each_entry(p, &pwm_lookup_list, list) { 615 match = 0; 616 617 if (p->dev_id) { 618 if (!dev_id || strcmp(p->dev_id, dev_id)) 619 continue; 620 621 match += 2; 622 } 623 624 if (p->con_id) { 625 if (!con_id || strcmp(p->con_id, con_id)) 626 continue; 627 628 match += 1; 629 } 630 631 if (match > best) { 632 chip = pwmchip_find_by_name(p->provider); 633 index = p->index; 634 635 if (match != 3) 636 best = match; 637 else 638 break; 639 } 640 } 641 642 if (chip) 643 pwm = pwm_request_from_chip(chip, index, con_id ?: dev_id); 644 645 mutex_unlock(&pwm_lookup_lock); 646 647 return pwm; 648 } 649 EXPORT_SYMBOL_GPL(pwm_get); 650 651 /** 652 * pwm_put() - release a PWM device 653 * @pwm: PWM device 654 */ 655 void pwm_put(struct pwm_device *pwm) 656 { 657 if (!pwm) 658 return; 659 660 mutex_lock(&pwm_lock); 661 662 if (!test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) { 663 pr_warn("PWM device already freed\n"); 664 goto out; 665 } 666 667 if (pwm->chip->ops->free) 668 pwm->chip->ops->free(pwm->chip, pwm); 669 670 pwm->label = NULL; 671 672 module_put(pwm->chip->ops->owner); 673 out: 674 mutex_unlock(&pwm_lock); 675 } 676 EXPORT_SYMBOL_GPL(pwm_put); 677 678 static void devm_pwm_release(struct device *dev, void *res) 679 { 680 pwm_put(*(struct pwm_device **)res); 681 } 682 683 /** 684 * devm_pwm_get() - resource managed pwm_get() 685 * @dev: device for PWM consumer 686 * @con_id: consumer name 687 * 688 * This function performs like pwm_get() but the acquired PWM device will 689 * automatically be released on driver detach. 690 */ 691 struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id) 692 { 693 struct pwm_device **ptr, *pwm; 694 695 ptr = devres_alloc(devm_pwm_release, sizeof(**ptr), GFP_KERNEL); 696 if (!ptr) 697 return ERR_PTR(-ENOMEM); 698 699 pwm = pwm_get(dev, con_id); 700 if (!IS_ERR(pwm)) { 701 *ptr = pwm; 702 devres_add(dev, ptr); 703 } else { 704 devres_free(ptr); 705 } 706 707 return pwm; 708 } 709 EXPORT_SYMBOL_GPL(devm_pwm_get); 710 711 static int devm_pwm_match(struct device *dev, void *res, void *data) 712 { 713 struct pwm_device **p = res; 714 715 if (WARN_ON(!p || !*p)) 716 return 0; 717 718 return *p == data; 719 } 720 721 /** 722 * devm_pwm_put() - resource managed pwm_put() 723 * @dev: device for PWM consumer 724 * @pwm: PWM device 725 * 726 * Release a PWM previously allocated using devm_pwm_get(). Calling this 727 * function is usually not needed because devm-allocated resources are 728 * automatically released on driver detach. 729 */ 730 void devm_pwm_put(struct device *dev, struct pwm_device *pwm) 731 { 732 WARN_ON(devres_release(dev, devm_pwm_release, devm_pwm_match, pwm)); 733 } 734 EXPORT_SYMBOL_GPL(devm_pwm_put); 735 736 #ifdef CONFIG_DEBUG_FS 737 static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s) 738 { 739 unsigned int i; 740 741 for (i = 0; i < chip->npwm; i++) { 742 struct pwm_device *pwm = &chip->pwms[i]; 743 744 seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label); 745 746 if (test_bit(PWMF_REQUESTED, &pwm->flags)) 747 seq_printf(s, " requested"); 748 749 if (test_bit(PWMF_ENABLED, &pwm->flags)) 750 seq_printf(s, " enabled"); 751 752 seq_printf(s, "\n"); 753 } 754 } 755 756 static void *pwm_seq_start(struct seq_file *s, loff_t *pos) 757 { 758 mutex_lock(&pwm_lock); 759 s->private = ""; 760 761 return seq_list_start(&pwm_chips, *pos); 762 } 763 764 static void *pwm_seq_next(struct seq_file *s, void *v, loff_t *pos) 765 { 766 s->private = "\n"; 767 768 return seq_list_next(v, &pwm_chips, pos); 769 } 770 771 static void pwm_seq_stop(struct seq_file *s, void *v) 772 { 773 mutex_unlock(&pwm_lock); 774 } 775 776 static int pwm_seq_show(struct seq_file *s, void *v) 777 { 778 struct pwm_chip *chip = list_entry(v, struct pwm_chip, list); 779 780 seq_printf(s, "%s%s/%s, %d PWM device%s\n", (char *)s->private, 781 chip->dev->bus ? chip->dev->bus->name : "no-bus", 782 dev_name(chip->dev), chip->npwm, 783 (chip->npwm != 1) ? "s" : ""); 784 785 if (chip->ops->dbg_show) 786 chip->ops->dbg_show(chip, s); 787 else 788 pwm_dbg_show(chip, s); 789 790 return 0; 791 } 792 793 static const struct seq_operations pwm_seq_ops = { 794 .start = pwm_seq_start, 795 .next = pwm_seq_next, 796 .stop = pwm_seq_stop, 797 .show = pwm_seq_show, 798 }; 799 800 static int pwm_seq_open(struct inode *inode, struct file *file) 801 { 802 return seq_open(file, &pwm_seq_ops); 803 } 804 805 static const struct file_operations pwm_debugfs_ops = { 806 .owner = THIS_MODULE, 807 .open = pwm_seq_open, 808 .read = seq_read, 809 .llseek = seq_lseek, 810 .release = seq_release, 811 }; 812 813 static int __init pwm_debugfs_init(void) 814 { 815 debugfs_create_file("pwm", S_IFREG | S_IRUGO, NULL, NULL, 816 &pwm_debugfs_ops); 817 818 return 0; 819 } 820 821 subsys_initcall(pwm_debugfs_init); 822 #endif /* CONFIG_DEBUG_FS */ 823