1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Toggles a GPIO pin to restart a device 4 * 5 * Copyright (C) 2014 Google, Inc. 6 * 7 * Based on the gpio-poweroff driver. 8 */ 9 #include <linux/reboot.h> 10 #include <linux/kernel.h> 11 #include <linux/init.h> 12 #include <linux/delay.h> 13 #include <linux/platform_device.h> 14 #include <linux/gpio/consumer.h> 15 #include <linux/of_platform.h> 16 #include <linux/module.h> 17 18 struct gpio_restart { 19 struct gpio_desc *reset_gpio; 20 struct notifier_block restart_handler; 21 u32 active_delay_ms; 22 u32 inactive_delay_ms; 23 u32 wait_delay_ms; 24 }; 25 26 static int gpio_restart_notify(struct notifier_block *this, 27 unsigned long mode, void *cmd) 28 { 29 struct gpio_restart *gpio_restart = 30 container_of(this, struct gpio_restart, restart_handler); 31 32 /* drive it active, also inactive->active edge */ 33 gpiod_direction_output(gpio_restart->reset_gpio, 1); 34 mdelay(gpio_restart->active_delay_ms); 35 36 /* drive inactive, also active->inactive edge */ 37 gpiod_set_value(gpio_restart->reset_gpio, 0); 38 mdelay(gpio_restart->inactive_delay_ms); 39 40 /* drive it active, also inactive->active edge */ 41 gpiod_set_value(gpio_restart->reset_gpio, 1); 42 43 /* give it some time */ 44 mdelay(gpio_restart->wait_delay_ms); 45 46 WARN_ON(1); 47 48 return NOTIFY_DONE; 49 } 50 51 static int gpio_restart_probe(struct platform_device *pdev) 52 { 53 struct gpio_restart *gpio_restart; 54 bool open_source = false; 55 u32 property; 56 int ret; 57 58 gpio_restart = devm_kzalloc(&pdev->dev, sizeof(*gpio_restart), 59 GFP_KERNEL); 60 if (!gpio_restart) 61 return -ENOMEM; 62 63 open_source = of_property_read_bool(pdev->dev.of_node, "open-source"); 64 65 gpio_restart->reset_gpio = devm_gpiod_get(&pdev->dev, NULL, 66 open_source ? GPIOD_IN : GPIOD_OUT_LOW); 67 ret = PTR_ERR_OR_ZERO(gpio_restart->reset_gpio); 68 if (ret) { 69 if (ret != -EPROBE_DEFER) 70 dev_err(&pdev->dev, "Could not get reset GPIO\n"); 71 return ret; 72 } 73 74 gpio_restart->restart_handler.notifier_call = gpio_restart_notify; 75 gpio_restart->restart_handler.priority = 129; 76 gpio_restart->active_delay_ms = 100; 77 gpio_restart->inactive_delay_ms = 100; 78 gpio_restart->wait_delay_ms = 3000; 79 80 ret = of_property_read_u32(pdev->dev.of_node, "priority", &property); 81 if (!ret) { 82 if (property > 255) 83 dev_err(&pdev->dev, "Invalid priority property: %u\n", 84 property); 85 else 86 gpio_restart->restart_handler.priority = property; 87 } 88 89 of_property_read_u32(pdev->dev.of_node, "active-delay", 90 &gpio_restart->active_delay_ms); 91 of_property_read_u32(pdev->dev.of_node, "inactive-delay", 92 &gpio_restart->inactive_delay_ms); 93 of_property_read_u32(pdev->dev.of_node, "wait-delay", 94 &gpio_restart->wait_delay_ms); 95 96 platform_set_drvdata(pdev, gpio_restart); 97 98 ret = register_restart_handler(&gpio_restart->restart_handler); 99 if (ret) { 100 dev_err(&pdev->dev, "%s: cannot register restart handler, %d\n", 101 __func__, ret); 102 return -ENODEV; 103 } 104 105 return 0; 106 } 107 108 static int gpio_restart_remove(struct platform_device *pdev) 109 { 110 struct gpio_restart *gpio_restart = platform_get_drvdata(pdev); 111 int ret; 112 113 ret = unregister_restart_handler(&gpio_restart->restart_handler); 114 if (ret) { 115 dev_err(&pdev->dev, 116 "%s: cannot unregister restart handler, %d\n", 117 __func__, ret); 118 return -ENODEV; 119 } 120 121 return 0; 122 } 123 124 static const struct of_device_id of_gpio_restart_match[] = { 125 { .compatible = "gpio-restart", }, 126 {}, 127 }; 128 129 static struct platform_driver gpio_restart_driver = { 130 .probe = gpio_restart_probe, 131 .remove = gpio_restart_remove, 132 .driver = { 133 .name = "restart-gpio", 134 .of_match_table = of_gpio_restart_match, 135 }, 136 }; 137 138 module_platform_driver(gpio_restart_driver); 139 140 MODULE_AUTHOR("David Riley <davidriley@chromium.org>"); 141 MODULE_DESCRIPTION("GPIO restart driver"); 142 MODULE_LICENSE("GPL"); 143