1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. 4 * Author: Manivannan Sadhasivam <manivannan.sadhasivam@oss.qualcomm.com> 5 */ 6 7 #include <linux/device.h> 8 #include <linux/delay.h> 9 #include <linux/gpio/consumer.h> 10 #include <linux/list.h> 11 #include <linux/module.h> 12 #include <linux/of.h> 13 #include <linux/of_graph.h> 14 #include <linux/of_platform.h> 15 #include <linux/pci.h> 16 #include <linux/platform_device.h> 17 #include <linux/pwrseq/provider.h> 18 #include <linux/regulator/consumer.h> 19 #include <linux/serdev.h> 20 #include <linux/slab.h> 21 22 struct pwrseq_pci_dev { 23 struct serdev_device *serdev; 24 struct of_changeset *ocs; 25 struct pci_dev *pdev; 26 struct list_head list; 27 }; 28 29 struct pwrseq_pcie_m2_pdata { 30 const struct pwrseq_target_data **targets; 31 }; 32 33 struct pwrseq_pcie_m2_ctx { 34 struct pwrseq_device *pwrseq; 35 struct device_node *of_node; 36 const struct pwrseq_pcie_m2_pdata *pdata; 37 struct regulator_bulk_data *regs; 38 size_t num_vregs; 39 struct notifier_block nb; 40 struct gpio_desc *w_disable1_gpio; 41 struct gpio_desc *w_disable2_gpio; 42 struct device *dev; 43 struct list_head pci_devices; 44 struct mutex list_lock; 45 }; 46 47 static int pwrseq_pcie_m2_vregs_enable(struct pwrseq_device *pwrseq) 48 { 49 struct pwrseq_pcie_m2_ctx *ctx = pwrseq_device_get_drvdata(pwrseq); 50 51 return regulator_bulk_enable(ctx->num_vregs, ctx->regs); 52 } 53 54 static int pwrseq_pcie_m2_vregs_disable(struct pwrseq_device *pwrseq) 55 { 56 struct pwrseq_pcie_m2_ctx *ctx = pwrseq_device_get_drvdata(pwrseq); 57 58 return regulator_bulk_disable(ctx->num_vregs, ctx->regs); 59 } 60 61 static const struct pwrseq_unit_data pwrseq_pcie_m2_vregs_unit_data = { 62 .name = "regulators-enable", 63 .enable = pwrseq_pcie_m2_vregs_enable, 64 .disable = pwrseq_pcie_m2_vregs_disable, 65 }; 66 67 static const struct pwrseq_unit_data *pwrseq_pcie_m2_unit_deps[] = { 68 &pwrseq_pcie_m2_vregs_unit_data, 69 NULL 70 }; 71 72 static int pwrseq_pci_m2_e_uart_enable(struct pwrseq_device *pwrseq) 73 { 74 struct pwrseq_pcie_m2_ctx *ctx = pwrseq_device_get_drvdata(pwrseq); 75 76 return gpiod_set_value_cansleep(ctx->w_disable2_gpio, 0); 77 } 78 79 static int pwrseq_pci_m2_e_uart_disable(struct pwrseq_device *pwrseq) 80 { 81 struct pwrseq_pcie_m2_ctx *ctx = pwrseq_device_get_drvdata(pwrseq); 82 83 return gpiod_set_value_cansleep(ctx->w_disable2_gpio, 1); 84 } 85 86 static bool pwrseq_pci_m2_e_uart_is_controllable(struct pwrseq_device *pwrseq) 87 { 88 struct pwrseq_pcie_m2_ctx *ctx = pwrseq_device_get_drvdata(pwrseq); 89 90 /* 91 * The UART enable is driven through the W_DISABLE2# line. When it is not 92 * wired up on this connector the enable/disable callbacks are no-ops, so 93 * the host cannot gate the Bluetooth function on its own. 94 */ 95 return !!ctx->w_disable2_gpio; 96 } 97 98 static const struct pwrseq_unit_data pwrseq_pcie_m2_e_uart_unit_data = { 99 .name = "uart-enable", 100 .deps = pwrseq_pcie_m2_unit_deps, 101 .enable = pwrseq_pci_m2_e_uart_enable, 102 .disable = pwrseq_pci_m2_e_uart_disable, 103 }; 104 105 static int pwrseq_pci_m2_e_pcie_enable(struct pwrseq_device *pwrseq) 106 { 107 struct pwrseq_pcie_m2_ctx *ctx = pwrseq_device_get_drvdata(pwrseq); 108 109 return gpiod_set_value_cansleep(ctx->w_disable1_gpio, 0); 110 } 111 112 static int pwrseq_pci_m2_e_pcie_disable(struct pwrseq_device *pwrseq) 113 { 114 struct pwrseq_pcie_m2_ctx *ctx = pwrseq_device_get_drvdata(pwrseq); 115 116 return gpiod_set_value_cansleep(ctx->w_disable1_gpio, 1); 117 } 118 119 static bool pwrseq_pci_m2_e_pcie_is_controllable(struct pwrseq_device *pwrseq) 120 { 121 struct pwrseq_pcie_m2_ctx *ctx = pwrseq_device_get_drvdata(pwrseq); 122 123 /* 124 * The PCIe/WiFi enable is driven through the W_DISABLE1# line. When it 125 * is not wired up on this connector the enable/disable callbacks are 126 * no-ops, so the host cannot gate the PCIe/WiFi function on its own. 127 */ 128 return !!ctx->w_disable1_gpio; 129 } 130 131 static const struct pwrseq_unit_data pwrseq_pcie_m2_e_pcie_unit_data = { 132 .name = "pcie-enable", 133 .deps = pwrseq_pcie_m2_unit_deps, 134 .enable = pwrseq_pci_m2_e_pcie_enable, 135 .disable = pwrseq_pci_m2_e_pcie_disable, 136 }; 137 138 static const struct pwrseq_unit_data pwrseq_pcie_m2_m_pcie_unit_data = { 139 .name = "pcie-enable", 140 .deps = pwrseq_pcie_m2_unit_deps, 141 }; 142 143 static int pwrseq_pcie_m2_e_pwup_delay(struct pwrseq_device *pwrseq) 144 { 145 /* 146 * FIXME: This delay is only required for some Qcom WLAN/BT cards like 147 * WCN7850 and not for all devices. But currently, there is no way to 148 * identify the device model before enumeration. 149 */ 150 msleep(50); 151 152 return 0; 153 } 154 155 static const struct pwrseq_target_data pwrseq_pcie_m2_e_uart_target_data = { 156 .name = "uart", 157 .unit = &pwrseq_pcie_m2_e_uart_unit_data, 158 .post_enable = pwrseq_pcie_m2_e_pwup_delay, 159 .is_controllable = pwrseq_pci_m2_e_uart_is_controllable, 160 }; 161 162 static const struct pwrseq_target_data pwrseq_pcie_m2_e_pcie_target_data = { 163 .name = "pcie", 164 .unit = &pwrseq_pcie_m2_e_pcie_unit_data, 165 .post_enable = pwrseq_pcie_m2_e_pwup_delay, 166 .is_controllable = pwrseq_pci_m2_e_pcie_is_controllable, 167 }; 168 169 static const struct pwrseq_target_data pwrseq_pcie_m2_m_pcie_target_data = { 170 .name = "pcie", 171 .unit = &pwrseq_pcie_m2_m_pcie_unit_data, 172 }; 173 174 static const struct pwrseq_target_data *pwrseq_pcie_m2_e_targets[] = { 175 &pwrseq_pcie_m2_e_pcie_target_data, 176 &pwrseq_pcie_m2_e_uart_target_data, 177 NULL 178 }; 179 180 static const struct pwrseq_target_data *pwrseq_pcie_m2_m_targets[] = { 181 &pwrseq_pcie_m2_m_pcie_target_data, 182 NULL 183 }; 184 185 static const struct pwrseq_pcie_m2_pdata pwrseq_pcie_m2_e_of_data = { 186 .targets = pwrseq_pcie_m2_e_targets, 187 }; 188 189 static const struct pwrseq_pcie_m2_pdata pwrseq_pcie_m2_m_of_data = { 190 .targets = pwrseq_pcie_m2_m_targets, 191 }; 192 193 static int pwrseq_pcie_m2_match(struct pwrseq_device *pwrseq, 194 struct device *dev) 195 { 196 struct pwrseq_pcie_m2_ctx *ctx = pwrseq_device_get_drvdata(pwrseq); 197 struct device_node *endpoint __free(device_node) = NULL; 198 199 /* 200 * Traverse the 'remote-endpoint' nodes and check if the remote node's 201 * parent matches the OF node of 'dev'. 202 */ 203 for_each_endpoint_of_node(ctx->of_node, endpoint) { 204 struct device_node *remote __free(device_node) = 205 of_graph_get_remote_port_parent(endpoint); 206 if (remote && (remote == dev_of_node(dev))) 207 return PWRSEQ_MATCH_OK; 208 } 209 210 return PWRSEQ_NO_MATCH; 211 } 212 213 static const struct pci_device_id pwrseq_m2_pci_ids[] = { 214 { PCI_DEVICE(PCI_VENDOR_ID_MARVELL_EXT, 0x2b43), 215 .driver_data = (kernel_ulong_t)"nxp,88w8987-bt" }, 216 { PCI_DEVICE(PCI_VENDOR_ID_PHILIPS, 0x3003), 217 .driver_data = (kernel_ulong_t)"nxp,88w8987-bt" }, 218 { PCI_DEVICE_SUB(PCI_VENDOR_ID_QCOM, 0x1103, PCI_VENDOR_ID_QCOM, 0x0108), 219 .driver_data = (kernel_ulong_t)"qcom,qca2066-bt" }, 220 { PCI_DEVICE_SUB(PCI_VENDOR_ID_QCOM, 0x1103, PCI_VENDOR_ID_FOXCONN, 0xe105), 221 .driver_data = (kernel_ulong_t)"qcom,wcn6855-bt" }, 222 { PCI_DEVICE_SUB(PCI_VENDOR_ID_QCOM, 0x1103, PCI_VENDOR_ID_QCOM, 0x337e), 223 .driver_data = (kernel_ulong_t)"qcom,wcn6855-bt" }, 224 { PCI_DEVICE_SUB(PCI_VENDOR_ID_QCOM, 0x1107, PCI_VENDOR_ID_QCOM, 0x337c), 225 .driver_data = (kernel_ulong_t)"qcom,wcn7850-bt" }, 226 { PCI_DEVICE_SUB(PCI_VENDOR_ID_QCOM, 0x1107, PCI_VENDOR_ID_LENOVO, 0xe0e9), 227 .driver_data = (kernel_ulong_t)"qcom,wcn7850-bt" }, 228 { PCI_DEVICE_SUB(PCI_VENDOR_ID_QCOM, 0x1107, PCI_VENDOR_ID_FOXCONN, 0xe0ee), 229 .driver_data = (kernel_ulong_t)"qcom,wcn7850-bt" }, 230 { } /* Sentinel */ 231 }; 232 233 static int pwrseq_pcie_m2_create_bt_node(struct pwrseq_pcie_m2_ctx *ctx, 234 struct pwrseq_pci_dev *pci_dev, 235 struct device_node *parent, 236 struct pci_dev *pdev) 237 { 238 const struct pci_device_id *id; 239 struct device *dev = ctx->dev; 240 const char *compatible; 241 struct device_node *np; 242 int ret; 243 244 id = pci_match_id(pwrseq_m2_pci_ids, pdev); 245 if (WARN_ON_ONCE(!id)) /* Shouldn't happen */ 246 return -ENODEV; 247 248 compatible = (const char *)id->driver_data; 249 250 pci_dev->ocs = kzalloc_obj(*pci_dev->ocs); 251 if (!pci_dev->ocs) 252 return -ENOMEM; 253 254 of_changeset_init(pci_dev->ocs); 255 256 np = of_changeset_create_node(pci_dev->ocs, parent, "bluetooth"); 257 if (!np) { 258 dev_err(dev, "Failed to create bluetooth node\n"); 259 ret = -ENODEV; 260 goto err_destroy_changeset; 261 } 262 263 ret = of_changeset_add_prop_string(pci_dev->ocs, np, "compatible", compatible); 264 if (ret) { 265 dev_err(dev, "Failed to add bluetooth compatible: %d\n", ret); 266 goto err_destroy_changeset; 267 } 268 269 ret = of_changeset_apply(pci_dev->ocs); 270 if (ret) { 271 dev_err(dev, "Failed to apply changeset: %d\n", ret); 272 goto err_destroy_changeset; 273 } 274 275 ret = device_add_of_node(&pci_dev->serdev->dev, np); 276 if (ret) { 277 dev_err(dev, "Failed to add OF node: %d\n", ret); 278 goto err_revert_changeset; 279 } 280 281 return 0; 282 283 err_revert_changeset: 284 of_changeset_revert(pci_dev->ocs); 285 err_destroy_changeset: 286 of_changeset_destroy(pci_dev->ocs); 287 kfree(pci_dev->ocs); 288 pci_dev->ocs = NULL; 289 290 return ret; 291 } 292 293 static int pwrseq_pcie_m2_create_serdev_one(struct pwrseq_pcie_m2_ctx *ctx, 294 struct pci_dev *pdev) 295 { 296 struct serdev_controller *serdev_ctrl; 297 struct device *dev = ctx->dev; 298 struct pwrseq_pci_dev *pci_dev; 299 int ret; 300 301 struct device_node *serdev_parent __free(device_node) = 302 of_graph_get_remote_node(dev_of_node(ctx->dev), 3, 0); 303 if (!serdev_parent) 304 return 0; 305 306 serdev_ctrl = of_find_serdev_controller_by_node(serdev_parent); 307 if (!serdev_ctrl) 308 return 0; 309 310 /* Bail out if the device was already attached to this controller */ 311 if (serdev_ctrl->serdev) { 312 serdev_controller_put(serdev_ctrl); 313 return 0; 314 } 315 316 /* Bail out if the serdev device was already created for the PCI dev */ 317 scoped_guard(mutex, &ctx->list_lock) { 318 list_for_each_entry(pci_dev, &ctx->pci_devices, list) { 319 if (pci_dev->pdev == pdev) 320 return 0; 321 } 322 } 323 324 pci_dev = kzalloc_obj(*pci_dev); 325 if (!pci_dev) { 326 ret = -ENOMEM; 327 goto err_put_ctrl; 328 } 329 330 pci_dev->serdev = serdev_device_alloc(serdev_ctrl); 331 if (!pci_dev->serdev) { 332 ret = -ENOMEM; 333 goto err_free_pci_dev; 334 } 335 336 ret = pwrseq_pcie_m2_create_bt_node(ctx, pci_dev, serdev_parent, pdev); 337 if (ret) 338 goto err_free_serdev; 339 340 ret = serdev_device_add(pci_dev->serdev); 341 if (ret) { 342 dev_err(dev, "Failed to add serdev for PCI device (%s): %d\n", 343 pci_name(pdev), ret); 344 goto err_free_dt_node; 345 } 346 347 serdev_controller_put(serdev_ctrl); 348 349 pci_dev->pdev = pci_dev_get(pdev); 350 351 mutex_lock(&ctx->list_lock); 352 list_add_tail(&pci_dev->list, &ctx->pci_devices); 353 mutex_unlock(&ctx->list_lock); 354 355 return 0; 356 357 err_free_dt_node: 358 device_remove_of_node(&pci_dev->serdev->dev); 359 of_changeset_revert(pci_dev->ocs); 360 of_changeset_destroy(pci_dev->ocs); 361 kfree(pci_dev->ocs); 362 pci_dev->ocs = NULL; 363 err_free_serdev: 364 serdev_device_put(pci_dev->serdev); 365 pci_dev->serdev = NULL; 366 err_free_pci_dev: 367 kfree(pci_dev); 368 err_put_ctrl: 369 serdev_controller_put(serdev_ctrl); 370 371 return ret; 372 } 373 374 static void __pwrseq_pcie_m2_remove_serdev(struct pwrseq_pcie_m2_ctx *ctx, 375 struct pwrseq_pci_dev *pci_dev) 376 { 377 if (pci_dev->serdev) { 378 device_remove_of_node(&pci_dev->serdev->dev); 379 serdev_device_remove(pci_dev->serdev); 380 } 381 382 if (pci_dev->ocs) { 383 of_changeset_revert(pci_dev->ocs); 384 of_changeset_destroy(pci_dev->ocs); 385 kfree(pci_dev->ocs); 386 } 387 388 pci_dev_put(pci_dev->pdev); 389 list_del(&pci_dev->list); 390 kfree(pci_dev); 391 } 392 393 static void pwrseq_pcie_m2_remove_serdev(struct pwrseq_pcie_m2_ctx *ctx, 394 struct pci_dev *pdev) 395 { 396 struct pwrseq_pci_dev *pci_dev, *tmp; 397 398 mutex_lock(&ctx->list_lock); 399 list_for_each_entry_safe(pci_dev, tmp, &ctx->pci_devices, list) { 400 if (!pdev || pci_dev->pdev == pdev) { 401 __pwrseq_pcie_m2_remove_serdev(ctx, pci_dev); 402 if (pdev) 403 break; 404 } 405 } 406 mutex_unlock(&ctx->list_lock); 407 } 408 409 static bool pwrseq_pcie_m2_pci_parent_matches(struct pci_dev *pdev, 410 struct device_node *pci_parent) 411 { 412 struct device *dev = pdev->dev.parent; 413 414 while (dev) { 415 if (dev->of_node == pci_parent) 416 return true; 417 if (!dev_is_pci(dev)) 418 break; 419 dev = dev->parent; 420 } 421 return false; 422 } 423 424 static int pwrseq_pcie_m2_notify(struct notifier_block *nb, unsigned long action, 425 void *data) 426 { 427 struct pwrseq_pcie_m2_ctx *ctx = container_of(nb, struct pwrseq_pcie_m2_ctx, nb); 428 struct pci_dev *pdev = to_pci_dev(data); 429 int ret; 430 431 /* 432 * Check whether the PCI device is associated with this M.2 connector or 433 * not, by comparing the OF node of the PCI device parent and the Port 0 434 * (PCIe) remote node parent OF node. 435 */ 436 struct device_node *pci_parent __free(device_node) = 437 of_graph_get_remote_node(dev_of_node(ctx->dev), 0, 0); 438 if (!pci_parent || !pwrseq_pcie_m2_pci_parent_matches(pdev, pci_parent)) 439 return NOTIFY_DONE; 440 441 switch (action) { 442 case BUS_NOTIFY_ADD_DEVICE: 443 if (pci_match_id(pwrseq_m2_pci_ids, pdev)) { 444 ret = pwrseq_pcie_m2_create_serdev_one(ctx, pdev); 445 if (ret) 446 return notifier_from_errno(ret); 447 } 448 break; 449 case BUS_NOTIFY_REMOVED_DEVICE: 450 if (pci_match_id(pwrseq_m2_pci_ids, pdev)) 451 pwrseq_pcie_m2_remove_serdev(ctx, pdev); 452 453 break; 454 } 455 456 return NOTIFY_OK; 457 } 458 459 static bool pwrseq_pcie_m2_check_remote_node(struct device *dev, u8 port, u8 endpoint, 460 const char *node) 461 { 462 struct device_node *remote __free(device_node) = 463 of_graph_get_remote_node(dev_of_node(dev), port, endpoint); 464 465 if (remote && of_node_name_eq(remote, node)) 466 return true; 467 468 return false; 469 } 470 471 /* 472 * If the connector exposes a non-discoverable bus like UART, the respective 473 * protocol device needs to be created manually with the help of the notifier 474 * of the discoverable bus like PCIe. 475 */ 476 static int pwrseq_pcie_m2_register_notifier(struct pwrseq_pcie_m2_ctx *ctx) 477 { 478 int ret; 479 480 /* 481 * Register a PCI notifier for Key E connector that has PCIe as Port 482 * 0/Endpoint 0 interface and Serial as Port 3/Endpoint 0 interface. 483 */ 484 if (!pwrseq_pcie_m2_check_remote_node(ctx->dev, 3, 0, "serial") || 485 !pwrseq_pcie_m2_check_remote_node(ctx->dev, 0, 0, "pcie")) 486 return 0; 487 488 ctx->nb.notifier_call = pwrseq_pcie_m2_notify; 489 ret = bus_register_notifier(&pci_bus_type, &ctx->nb); 490 if (ret) 491 return dev_err_probe(ctx->dev, ret, 492 "Failed to register notifier for serdev\n"); 493 return 0; 494 } 495 496 static int pwrseq_pcie_m2_create_serdev(struct pwrseq_pcie_m2_ctx *ctx) 497 { 498 struct pci_dev *pdev = NULL; 499 int ret; 500 501 if (!pwrseq_pcie_m2_check_remote_node(ctx->dev, 3, 0, "serial") || 502 !pwrseq_pcie_m2_check_remote_node(ctx->dev, 0, 0, "pcie")) 503 return 0; 504 505 struct device_node *pci_parent __free(device_node) = 506 of_graph_get_remote_node(dev_of_node(ctx->dev), 0, 0); 507 if (!pci_parent) 508 return 0; 509 510 /* Create serdev for existing PCI devices if required */ 511 for_each_pci_dev(pdev) { 512 if (!pwrseq_pcie_m2_pci_parent_matches(pdev, pci_parent)) 513 continue; 514 515 if (!pci_match_id(pwrseq_m2_pci_ids, pdev)) 516 continue; 517 518 ret = pwrseq_pcie_m2_create_serdev_one(ctx, pdev); 519 if (ret) { 520 dev_err_probe(ctx->dev, ret, 521 "Failed to create serdev for PCI device (%s)\n", 522 pci_name(pdev)); 523 pci_dev_put(pdev); 524 goto err_remove_serdev; 525 } 526 } 527 528 return 0; 529 530 err_remove_serdev: 531 pwrseq_pcie_m2_remove_serdev(ctx, NULL); 532 533 return ret; 534 } 535 536 static int pwrseq_pcie_m2_probe(struct platform_device *pdev) 537 { 538 struct device *dev = &pdev->dev; 539 struct pwrseq_pcie_m2_ctx *ctx; 540 struct pwrseq_config config = {}; 541 int ret; 542 543 ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL); 544 if (!ctx) 545 return -ENOMEM; 546 547 platform_set_drvdata(pdev, ctx); 548 ctx->of_node = dev_of_node(dev); 549 ctx->pdata = device_get_match_data(dev); 550 if (!ctx->pdata) 551 return dev_err_probe(dev, -ENODEV, 552 "Failed to obtain platform data\n"); 553 554 /* 555 * Currently, of_regulator_bulk_get_all() is the only regulator API that 556 * allows to get all supplies in the devicetree node without manually 557 * specifying them. 558 */ 559 ret = of_regulator_bulk_get_all(dev, dev_of_node(dev), &ctx->regs); 560 if (ret < 0) 561 return dev_err_probe(dev, ret, 562 "Failed to get all regulators\n"); 563 564 ctx->num_vregs = ret; 565 566 ctx->w_disable1_gpio = devm_gpiod_get_optional(dev, "w-disable1", GPIOD_OUT_HIGH); 567 if (IS_ERR(ctx->w_disable1_gpio)) { 568 ret = dev_err_probe(dev, PTR_ERR(ctx->w_disable1_gpio), 569 "Failed to get the W_DISABLE_1# GPIO\n"); 570 goto err_free_regulators; 571 } 572 573 ctx->w_disable2_gpio = devm_gpiod_get_optional(dev, "w-disable2", GPIOD_OUT_HIGH); 574 if (IS_ERR(ctx->w_disable2_gpio)) { 575 ret = dev_err_probe(dev, PTR_ERR(ctx->w_disable2_gpio), 576 "Failed to get the W_DISABLE_2# GPIO\n"); 577 goto err_free_regulators; 578 } 579 580 config.parent = dev; 581 config.owner = THIS_MODULE; 582 config.drvdata = ctx; 583 config.match = pwrseq_pcie_m2_match; 584 config.targets = ctx->pdata->targets; 585 586 ctx->pwrseq = devm_pwrseq_device_register(dev, &config); 587 if (IS_ERR(ctx->pwrseq)) { 588 ret = dev_err_probe(dev, PTR_ERR(ctx->pwrseq), 589 "Failed to register the power sequencer\n"); 590 goto err_free_regulators; 591 } 592 593 mutex_init(&ctx->list_lock); 594 INIT_LIST_HEAD(&ctx->pci_devices); 595 ctx->dev = dev; 596 597 /* Create serdev for available PCI devices (if required) */ 598 ret = pwrseq_pcie_m2_create_serdev(ctx); 599 if (ret) 600 goto err_destroy_mutex; 601 602 /* 603 * Register a notifier for creating protocol devices for 604 * non-discoverable busses like UART. 605 */ 606 ret = pwrseq_pcie_m2_register_notifier(ctx); 607 if (ret) 608 goto err_remove_serdev; 609 610 return 0; 611 612 err_remove_serdev: 613 pwrseq_pcie_m2_remove_serdev(ctx, NULL); 614 err_destroy_mutex: 615 mutex_destroy(&ctx->list_lock); 616 err_free_regulators: 617 regulator_bulk_free(ctx->num_vregs, ctx->regs); 618 kfree(ctx->regs); 619 620 return ret; 621 } 622 623 static void pwrseq_pcie_m2_remove(struct platform_device *pdev) 624 { 625 struct pwrseq_pcie_m2_ctx *ctx = platform_get_drvdata(pdev); 626 627 bus_unregister_notifier(&pci_bus_type, &ctx->nb); 628 pwrseq_pcie_m2_remove_serdev(ctx, NULL); 629 mutex_destroy(&ctx->list_lock); 630 631 regulator_bulk_free(ctx->num_vregs, ctx->regs); 632 kfree(ctx->regs); 633 } 634 635 static const struct of_device_id pwrseq_pcie_m2_of_match[] = { 636 { 637 .compatible = "pcie-m2-m-connector", 638 .data = &pwrseq_pcie_m2_m_of_data, 639 }, 640 { 641 .compatible = "pcie-m2-e-connector", 642 .data = &pwrseq_pcie_m2_e_of_data, 643 }, 644 { } 645 }; 646 MODULE_DEVICE_TABLE(of, pwrseq_pcie_m2_of_match); 647 648 static struct platform_driver pwrseq_pcie_m2_driver = { 649 .driver = { 650 .name = "pwrseq-pcie-m2", 651 .of_match_table = pwrseq_pcie_m2_of_match, 652 }, 653 .probe = pwrseq_pcie_m2_probe, 654 .remove = pwrseq_pcie_m2_remove, 655 }; 656 module_platform_driver(pwrseq_pcie_m2_driver); 657 658 MODULE_AUTHOR("Manivannan Sadhasivam <manivannan.sadhasivam@oss.qualcomm.com>"); 659 MODULE_DESCRIPTION("Power Sequencing driver for PCIe M.2 connector"); 660 MODULE_LICENSE("GPL"); 661