1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // Framework for Ethernet Power Sourcing Equipment 4 // 5 // Copyright (c) 2022 Pengutronix, Oleksij Rempel <kernel@pengutronix.de> 6 // 7 8 #include <linux/device.h> 9 #include <linux/of.h> 10 #include <linux/pse-pd/pse.h> 11 #include <linux/regulator/driver.h> 12 #include <linux/regulator/machine.h> 13 14 static DEFINE_MUTEX(pse_list_mutex); 15 static LIST_HEAD(pse_controller_list); 16 17 /** 18 * struct pse_control - a PSE control 19 * @pcdev: a pointer to the PSE controller device 20 * this PSE control belongs to 21 * @ps: PSE PI supply of the PSE control 22 * @list: list entry for the pcdev's PSE controller list 23 * @id: ID of the PSE line in the PSE controller device 24 * @refcnt: Number of gets of this pse_control 25 */ 26 struct pse_control { 27 struct pse_controller_dev *pcdev; 28 struct regulator *ps; 29 struct list_head list; 30 unsigned int id; 31 struct kref refcnt; 32 }; 33 34 static int of_load_single_pse_pi_pairset(struct device_node *node, 35 struct pse_pi *pi, 36 int pairset_num) 37 { 38 struct device_node *pairset_np; 39 const char *name; 40 int ret; 41 42 ret = of_property_read_string_index(node, "pairset-names", 43 pairset_num, &name); 44 if (ret) 45 return ret; 46 47 if (!strcmp(name, "alternative-a")) { 48 pi->pairset[pairset_num].pinout = ALTERNATIVE_A; 49 } else if (!strcmp(name, "alternative-b")) { 50 pi->pairset[pairset_num].pinout = ALTERNATIVE_B; 51 } else { 52 pr_err("pse: wrong pairset-names value %s (%pOF)\n", 53 name, node); 54 return -EINVAL; 55 } 56 57 pairset_np = of_parse_phandle(node, "pairsets", pairset_num); 58 if (!pairset_np) 59 return -ENODEV; 60 61 pi->pairset[pairset_num].np = pairset_np; 62 63 return 0; 64 } 65 66 /** 67 * of_load_pse_pi_pairsets - load PSE PI pairsets pinout and polarity 68 * @node: a pointer of the device node 69 * @pi: a pointer of the PSE PI to fill 70 * @npairsets: the number of pairsets (1 or 2) used by the PI 71 * 72 * Return: 0 on success and failure value on error 73 */ 74 static int of_load_pse_pi_pairsets(struct device_node *node, 75 struct pse_pi *pi, 76 int npairsets) 77 { 78 int i, ret; 79 80 ret = of_property_count_strings(node, "pairset-names"); 81 if (ret != npairsets) { 82 pr_err("pse: amount of pairsets and pairset-names is not equal %d != %d (%pOF)\n", 83 npairsets, ret, node); 84 return -EINVAL; 85 } 86 87 for (i = 0; i < npairsets; i++) { 88 ret = of_load_single_pse_pi_pairset(node, pi, i); 89 if (ret) 90 goto out; 91 } 92 93 if (npairsets == 2 && 94 pi->pairset[0].pinout == pi->pairset[1].pinout) { 95 pr_err("pse: two PI pairsets can not have identical pinout (%pOF)", 96 node); 97 ret = -EINVAL; 98 } 99 100 out: 101 /* If an error appears, release all the pairset device node kref */ 102 if (ret) { 103 of_node_put(pi->pairset[0].np); 104 pi->pairset[0].np = NULL; 105 of_node_put(pi->pairset[1].np); 106 pi->pairset[1].np = NULL; 107 } 108 109 return ret; 110 } 111 112 static void pse_release_pis(struct pse_controller_dev *pcdev) 113 { 114 int i; 115 116 for (i = 0; i <= pcdev->nr_lines; i++) { 117 of_node_put(pcdev->pi[i].pairset[0].np); 118 of_node_put(pcdev->pi[i].pairset[1].np); 119 of_node_put(pcdev->pi[i].np); 120 } 121 kfree(pcdev->pi); 122 } 123 124 /** 125 * of_load_pse_pis - load all the PSE PIs 126 * @pcdev: a pointer to the PSE controller device 127 * 128 * Return: 0 on success and failure value on error 129 */ 130 static int of_load_pse_pis(struct pse_controller_dev *pcdev) 131 { 132 struct device_node *np = pcdev->dev->of_node; 133 struct device_node *node, *pis; 134 int ret; 135 136 if (!np) 137 return -ENODEV; 138 139 pcdev->pi = kcalloc(pcdev->nr_lines, sizeof(*pcdev->pi), GFP_KERNEL); 140 if (!pcdev->pi) 141 return -ENOMEM; 142 143 pis = of_get_child_by_name(np, "pse-pis"); 144 if (!pis) { 145 /* no description of PSE PIs */ 146 pcdev->no_of_pse_pi = true; 147 return 0; 148 } 149 150 for_each_child_of_node(pis, node) { 151 struct pse_pi pi = {0}; 152 u32 id; 153 154 if (!of_node_name_eq(node, "pse-pi")) 155 continue; 156 157 ret = of_property_read_u32(node, "reg", &id); 158 if (ret) { 159 dev_err(pcdev->dev, 160 "can't get reg property for node '%pOF'", 161 node); 162 goto out; 163 } 164 165 if (id >= pcdev->nr_lines) { 166 dev_err(pcdev->dev, 167 "reg value (%u) is out of range (%u) (%pOF)\n", 168 id, pcdev->nr_lines, node); 169 ret = -EINVAL; 170 goto out; 171 } 172 173 if (pcdev->pi[id].np) { 174 dev_err(pcdev->dev, 175 "other node with same reg value was already registered. %pOF : %pOF\n", 176 pcdev->pi[id].np, node); 177 ret = -EINVAL; 178 goto out; 179 } 180 181 ret = of_count_phandle_with_args(node, "pairsets", NULL); 182 /* npairsets is limited to value one or two */ 183 if (ret == 1 || ret == 2) { 184 ret = of_load_pse_pi_pairsets(node, &pi, ret); 185 if (ret) 186 goto out; 187 } else if (ret != ENOENT) { 188 dev_err(pcdev->dev, 189 "error: wrong number of pairsets. Should be 1 or 2, got %d (%pOF)\n", 190 ret, node); 191 ret = -EINVAL; 192 goto out; 193 } 194 195 of_node_get(node); 196 pi.np = node; 197 memcpy(&pcdev->pi[id], &pi, sizeof(pi)); 198 } 199 200 of_node_put(pis); 201 return 0; 202 203 out: 204 pse_release_pis(pcdev); 205 of_node_put(node); 206 of_node_put(pis); 207 return ret; 208 } 209 210 static int pse_pi_is_enabled(struct regulator_dev *rdev) 211 { 212 struct pse_controller_dev *pcdev = rdev_get_drvdata(rdev); 213 const struct pse_controller_ops *ops; 214 int id, ret; 215 216 ops = pcdev->ops; 217 if (!ops->pi_is_enabled) 218 return -EOPNOTSUPP; 219 220 id = rdev_get_id(rdev); 221 mutex_lock(&pcdev->lock); 222 ret = ops->pi_is_enabled(pcdev, id); 223 mutex_unlock(&pcdev->lock); 224 225 return ret; 226 } 227 228 static int pse_pi_enable(struct regulator_dev *rdev) 229 { 230 struct pse_controller_dev *pcdev = rdev_get_drvdata(rdev); 231 const struct pse_controller_ops *ops; 232 int id, ret; 233 234 ops = pcdev->ops; 235 if (!ops->pi_enable) 236 return -EOPNOTSUPP; 237 238 id = rdev_get_id(rdev); 239 mutex_lock(&pcdev->lock); 240 ret = ops->pi_enable(pcdev, id); 241 if (!ret) 242 pcdev->pi[id].admin_state_enabled = 1; 243 mutex_unlock(&pcdev->lock); 244 245 return ret; 246 } 247 248 static int pse_pi_disable(struct regulator_dev *rdev) 249 { 250 struct pse_controller_dev *pcdev = rdev_get_drvdata(rdev); 251 const struct pse_controller_ops *ops; 252 int id, ret; 253 254 ops = pcdev->ops; 255 if (!ops->pi_disable) 256 return -EOPNOTSUPP; 257 258 id = rdev_get_id(rdev); 259 mutex_lock(&pcdev->lock); 260 ret = ops->pi_disable(pcdev, id); 261 if (!ret) 262 pcdev->pi[id].admin_state_enabled = 0; 263 mutex_unlock(&pcdev->lock); 264 265 return ret; 266 } 267 268 static const struct regulator_ops pse_pi_ops = { 269 .is_enabled = pse_pi_is_enabled, 270 .enable = pse_pi_enable, 271 .disable = pse_pi_disable, 272 }; 273 274 static int 275 devm_pse_pi_regulator_register(struct pse_controller_dev *pcdev, 276 char *name, int id) 277 { 278 struct regulator_init_data *rinit_data; 279 struct regulator_config rconfig = {0}; 280 struct regulator_desc *rdesc; 281 struct regulator_dev *rdev; 282 283 rinit_data = devm_kzalloc(pcdev->dev, sizeof(*rinit_data), 284 GFP_KERNEL); 285 if (!rinit_data) 286 return -ENOMEM; 287 288 rdesc = devm_kzalloc(pcdev->dev, sizeof(*rdesc), GFP_KERNEL); 289 if (!rdesc) 290 return -ENOMEM; 291 292 /* Regulator descriptor id have to be the same as its associated 293 * PSE PI id for the well functioning of the PSE controls. 294 */ 295 rdesc->id = id; 296 rdesc->name = name; 297 rdesc->type = REGULATOR_VOLTAGE; 298 rdesc->ops = &pse_pi_ops; 299 rdesc->owner = pcdev->owner; 300 301 rinit_data->constraints.valid_ops_mask = REGULATOR_CHANGE_STATUS; 302 rinit_data->supply_regulator = "vpwr"; 303 304 rconfig.dev = pcdev->dev; 305 rconfig.driver_data = pcdev; 306 rconfig.init_data = rinit_data; 307 308 rdev = devm_regulator_register(pcdev->dev, rdesc, &rconfig); 309 if (IS_ERR(rdev)) { 310 dev_err_probe(pcdev->dev, PTR_ERR(rdev), 311 "Failed to register regulator\n"); 312 return PTR_ERR(rdev); 313 } 314 315 pcdev->pi[id].rdev = rdev; 316 317 return 0; 318 } 319 320 /** 321 * pse_controller_register - register a PSE controller device 322 * @pcdev: a pointer to the initialized PSE controller device 323 * 324 * Return: 0 on success and failure value on error 325 */ 326 int pse_controller_register(struct pse_controller_dev *pcdev) 327 { 328 size_t reg_name_len; 329 int ret, i; 330 331 mutex_init(&pcdev->lock); 332 INIT_LIST_HEAD(&pcdev->pse_control_head); 333 334 if (!pcdev->nr_lines) 335 pcdev->nr_lines = 1; 336 337 ret = of_load_pse_pis(pcdev); 338 if (ret) 339 return ret; 340 341 if (pcdev->ops->setup_pi_matrix) { 342 ret = pcdev->ops->setup_pi_matrix(pcdev); 343 if (ret) 344 return ret; 345 } 346 347 /* Each regulator name len is pcdev dev name + 7 char + 348 * int max digit number (10) + 1 349 */ 350 reg_name_len = strlen(dev_name(pcdev->dev)) + 18; 351 352 /* Register PI regulators */ 353 for (i = 0; i < pcdev->nr_lines; i++) { 354 char *reg_name; 355 356 /* Do not register regulator for PIs not described */ 357 if (!pcdev->no_of_pse_pi && !pcdev->pi[i].np) 358 continue; 359 360 reg_name = devm_kzalloc(pcdev->dev, reg_name_len, GFP_KERNEL); 361 if (!reg_name) 362 return -ENOMEM; 363 364 snprintf(reg_name, reg_name_len, "pse-%s_pi%d", 365 dev_name(pcdev->dev), i); 366 367 ret = devm_pse_pi_regulator_register(pcdev, reg_name, i); 368 if (ret) 369 return ret; 370 } 371 372 mutex_lock(&pse_list_mutex); 373 list_add(&pcdev->list, &pse_controller_list); 374 mutex_unlock(&pse_list_mutex); 375 376 return 0; 377 } 378 EXPORT_SYMBOL_GPL(pse_controller_register); 379 380 /** 381 * pse_controller_unregister - unregister a PSE controller device 382 * @pcdev: a pointer to the PSE controller device 383 */ 384 void pse_controller_unregister(struct pse_controller_dev *pcdev) 385 { 386 pse_release_pis(pcdev); 387 mutex_lock(&pse_list_mutex); 388 list_del(&pcdev->list); 389 mutex_unlock(&pse_list_mutex); 390 } 391 EXPORT_SYMBOL_GPL(pse_controller_unregister); 392 393 static void devm_pse_controller_release(struct device *dev, void *res) 394 { 395 pse_controller_unregister(*(struct pse_controller_dev **)res); 396 } 397 398 /** 399 * devm_pse_controller_register - resource managed pse_controller_register() 400 * @dev: device that is registering this PSE controller 401 * @pcdev: a pointer to the initialized PSE controller device 402 * 403 * Managed pse_controller_register(). For PSE controllers registered by 404 * this function, pse_controller_unregister() is automatically called on 405 * driver detach. See pse_controller_register() for more information. 406 * 407 * Return: 0 on success and failure value on error 408 */ 409 int devm_pse_controller_register(struct device *dev, 410 struct pse_controller_dev *pcdev) 411 { 412 struct pse_controller_dev **pcdevp; 413 int ret; 414 415 pcdevp = devres_alloc(devm_pse_controller_release, sizeof(*pcdevp), 416 GFP_KERNEL); 417 if (!pcdevp) 418 return -ENOMEM; 419 420 ret = pse_controller_register(pcdev); 421 if (ret) { 422 devres_free(pcdevp); 423 return ret; 424 } 425 426 *pcdevp = pcdev; 427 devres_add(dev, pcdevp); 428 429 return 0; 430 } 431 EXPORT_SYMBOL_GPL(devm_pse_controller_register); 432 433 /* PSE control section */ 434 435 static void __pse_control_release(struct kref *kref) 436 { 437 struct pse_control *psec = container_of(kref, struct pse_control, 438 refcnt); 439 440 lockdep_assert_held(&pse_list_mutex); 441 442 if (psec->pcdev->pi[psec->id].admin_state_enabled) 443 regulator_disable(psec->ps); 444 devm_regulator_put(psec->ps); 445 446 module_put(psec->pcdev->owner); 447 448 list_del(&psec->list); 449 kfree(psec); 450 } 451 452 static void __pse_control_put_internal(struct pse_control *psec) 453 { 454 lockdep_assert_held(&pse_list_mutex); 455 456 kref_put(&psec->refcnt, __pse_control_release); 457 } 458 459 /** 460 * pse_control_put - free the PSE control 461 * @psec: PSE control pointer 462 */ 463 void pse_control_put(struct pse_control *psec) 464 { 465 if (IS_ERR_OR_NULL(psec)) 466 return; 467 468 mutex_lock(&pse_list_mutex); 469 __pse_control_put_internal(psec); 470 mutex_unlock(&pse_list_mutex); 471 } 472 EXPORT_SYMBOL_GPL(pse_control_put); 473 474 static struct pse_control * 475 pse_control_get_internal(struct pse_controller_dev *pcdev, unsigned int index) 476 { 477 struct pse_control *psec; 478 int ret; 479 480 lockdep_assert_held(&pse_list_mutex); 481 482 list_for_each_entry(psec, &pcdev->pse_control_head, list) { 483 if (psec->id == index) { 484 kref_get(&psec->refcnt); 485 return psec; 486 } 487 } 488 489 psec = kzalloc(sizeof(*psec), GFP_KERNEL); 490 if (!psec) 491 return ERR_PTR(-ENOMEM); 492 493 if (!try_module_get(pcdev->owner)) { 494 ret = -ENODEV; 495 goto free_psec; 496 } 497 498 psec->ps = devm_regulator_get_exclusive(pcdev->dev, 499 rdev_get_name(pcdev->pi[index].rdev)); 500 if (IS_ERR(psec->ps)) { 501 ret = PTR_ERR(psec->ps); 502 goto put_module; 503 } 504 505 ret = regulator_is_enabled(psec->ps); 506 if (ret < 0) 507 goto regulator_put; 508 509 pcdev->pi[index].admin_state_enabled = ret; 510 511 psec->pcdev = pcdev; 512 list_add(&psec->list, &pcdev->pse_control_head); 513 psec->id = index; 514 kref_init(&psec->refcnt); 515 516 return psec; 517 518 regulator_put: 519 devm_regulator_put(psec->ps); 520 put_module: 521 module_put(pcdev->owner); 522 free_psec: 523 kfree(psec); 524 525 return ERR_PTR(ret); 526 } 527 528 /** 529 * of_pse_match_pi - Find the PSE PI id matching the device node phandle 530 * @pcdev: a pointer to the PSE controller device 531 * @np: a pointer to the device node 532 * 533 * Return: id of the PSE PI, -EINVAL if not found 534 */ 535 static int of_pse_match_pi(struct pse_controller_dev *pcdev, 536 struct device_node *np) 537 { 538 int i; 539 540 for (i = 0; i <= pcdev->nr_lines; i++) { 541 if (pcdev->pi[i].np == np) 542 return i; 543 } 544 545 return -EINVAL; 546 } 547 548 /** 549 * psec_id_xlate - translate pse_spec to the PSE line number according 550 * to the number of pse-cells in case of no pse_pi node 551 * @pcdev: a pointer to the PSE controller device 552 * @pse_spec: PSE line specifier as found in the device tree 553 * 554 * Return: 0 if #pse-cells = <0>. Return PSE line number otherwise. 555 */ 556 static int psec_id_xlate(struct pse_controller_dev *pcdev, 557 const struct of_phandle_args *pse_spec) 558 { 559 if (!pcdev->of_pse_n_cells) 560 return 0; 561 562 if (pcdev->of_pse_n_cells > 1 || 563 pse_spec->args[0] >= pcdev->nr_lines) 564 return -EINVAL; 565 566 return pse_spec->args[0]; 567 } 568 569 struct pse_control *of_pse_control_get(struct device_node *node) 570 { 571 struct pse_controller_dev *r, *pcdev; 572 struct of_phandle_args args; 573 struct pse_control *psec; 574 int psec_id; 575 int ret; 576 577 if (!node) 578 return ERR_PTR(-EINVAL); 579 580 ret = of_parse_phandle_with_args(node, "pses", "#pse-cells", 0, &args); 581 if (ret) 582 return ERR_PTR(ret); 583 584 mutex_lock(&pse_list_mutex); 585 pcdev = NULL; 586 list_for_each_entry(r, &pse_controller_list, list) { 587 if (!r->no_of_pse_pi) { 588 ret = of_pse_match_pi(r, args.np); 589 if (ret >= 0) { 590 pcdev = r; 591 psec_id = ret; 592 break; 593 } 594 } else if (args.np == r->dev->of_node) { 595 pcdev = r; 596 break; 597 } 598 } 599 600 if (!pcdev) { 601 psec = ERR_PTR(-EPROBE_DEFER); 602 goto out; 603 } 604 605 if (WARN_ON(args.args_count != pcdev->of_pse_n_cells)) { 606 psec = ERR_PTR(-EINVAL); 607 goto out; 608 } 609 610 if (pcdev->no_of_pse_pi) { 611 psec_id = psec_id_xlate(pcdev, &args); 612 if (psec_id < 0) { 613 psec = ERR_PTR(psec_id); 614 goto out; 615 } 616 } 617 618 /* pse_list_mutex also protects the pcdev's pse_control list */ 619 psec = pse_control_get_internal(pcdev, psec_id); 620 621 out: 622 mutex_unlock(&pse_list_mutex); 623 of_node_put(args.np); 624 625 return psec; 626 } 627 EXPORT_SYMBOL_GPL(of_pse_control_get); 628 629 /** 630 * pse_ethtool_get_status - get status of PSE control 631 * @psec: PSE control pointer 632 * @extack: extack for reporting useful error messages 633 * @status: struct to store PSE status 634 * 635 * Return: 0 on success and failure value on error 636 */ 637 int pse_ethtool_get_status(struct pse_control *psec, 638 struct netlink_ext_ack *extack, 639 struct pse_control_status *status) 640 { 641 const struct pse_controller_ops *ops; 642 int err; 643 644 ops = psec->pcdev->ops; 645 646 if (!ops->ethtool_get_status) { 647 NL_SET_ERR_MSG(extack, 648 "PSE driver does not support status report"); 649 return -EOPNOTSUPP; 650 } 651 652 mutex_lock(&psec->pcdev->lock); 653 err = ops->ethtool_get_status(psec->pcdev, psec->id, extack, status); 654 mutex_unlock(&psec->pcdev->lock); 655 656 return err; 657 } 658 EXPORT_SYMBOL_GPL(pse_ethtool_get_status); 659 660 static int pse_ethtool_c33_set_config(struct pse_control *psec, 661 const struct pse_control_config *config) 662 { 663 int err = 0; 664 665 /* Look at admin_state_enabled status to not call regulator_enable 666 * or regulator_disable twice creating a regulator counter mismatch 667 */ 668 switch (config->c33_admin_control) { 669 case ETHTOOL_C33_PSE_ADMIN_STATE_ENABLED: 670 if (!psec->pcdev->pi[psec->id].admin_state_enabled) 671 err = regulator_enable(psec->ps); 672 break; 673 case ETHTOOL_C33_PSE_ADMIN_STATE_DISABLED: 674 if (psec->pcdev->pi[psec->id].admin_state_enabled) 675 err = regulator_disable(psec->ps); 676 break; 677 default: 678 err = -EOPNOTSUPP; 679 } 680 681 return err; 682 } 683 684 static int pse_ethtool_podl_set_config(struct pse_control *psec, 685 const struct pse_control_config *config) 686 { 687 int err = 0; 688 689 /* Look at admin_state_enabled status to not call regulator_enable 690 * or regulator_disable twice creating a regulator counter mismatch 691 */ 692 switch (config->podl_admin_control) { 693 case ETHTOOL_PODL_PSE_ADMIN_STATE_ENABLED: 694 if (!psec->pcdev->pi[psec->id].admin_state_enabled) 695 err = regulator_enable(psec->ps); 696 break; 697 case ETHTOOL_PODL_PSE_ADMIN_STATE_DISABLED: 698 if (psec->pcdev->pi[psec->id].admin_state_enabled) 699 err = regulator_disable(psec->ps); 700 break; 701 default: 702 err = -EOPNOTSUPP; 703 } 704 705 return err; 706 } 707 708 /** 709 * pse_ethtool_set_config - set PSE control configuration 710 * @psec: PSE control pointer 711 * @extack: extack for reporting useful error messages 712 * @config: Configuration of the test to run 713 * 714 * Return: 0 on success and failure value on error 715 */ 716 int pse_ethtool_set_config(struct pse_control *psec, 717 struct netlink_ext_ack *extack, 718 const struct pse_control_config *config) 719 { 720 int err = 0; 721 722 if (pse_has_c33(psec)) { 723 err = pse_ethtool_c33_set_config(psec, config); 724 if (err) 725 return err; 726 } 727 728 if (pse_has_podl(psec)) 729 err = pse_ethtool_podl_set_config(psec, config); 730 731 return err; 732 } 733 EXPORT_SYMBOL_GPL(pse_ethtool_set_config); 734 735 bool pse_has_podl(struct pse_control *psec) 736 { 737 return psec->pcdev->types & ETHTOOL_PSE_PODL; 738 } 739 EXPORT_SYMBOL_GPL(pse_has_podl); 740 741 bool pse_has_c33(struct pse_control *psec) 742 { 743 return psec->pcdev->types & ETHTOOL_PSE_C33; 744 } 745 EXPORT_SYMBOL_GPL(pse_has_c33); 746