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