]>
Commit | Line | Data |
---|---|---|
891c668b AN |
1 | /* |
2 | * LED Heartbeat Trigger | |
3 | * | |
4 | * Copyright (C) 2006 Atsushi Nemoto <anemo@mba.ocn.ne.jp> | |
5 | * | |
6 | * Based on Richard Purdie's ledtrig-timer.c and some arch's | |
7 | * CONFIG_HEARTBEAT code. | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License version 2 as | |
11 | * published by the Free Software Foundation. | |
12 | * | |
13 | */ | |
14 | #include <linux/module.h> | |
15 | #include <linux/kernel.h> | |
16 | #include <linux/init.h> | |
5a0e3ad6 | 17 | #include <linux/slab.h> |
891c668b AN |
18 | #include <linux/timer.h> |
19 | #include <linux/sched.h> | |
20 | #include <linux/leds.h> | |
49dca5ae | 21 | #include <linux/reboot.h> |
5ab92a7c | 22 | #include <linux/suspend.h> |
f07fb521 | 23 | #include "../leds.h" |
891c668b | 24 | |
fb31fbeb AH |
25 | static int panic_heartbeats; |
26 | ||
891c668b AN |
27 | struct heartbeat_trig_data { |
28 | unsigned int phase; | |
29 | unsigned int period; | |
30 | struct timer_list timer; | |
1c7b9d0e | 31 | unsigned int invert; |
891c668b AN |
32 | }; |
33 | ||
34 | static void led_heartbeat_function(unsigned long data) | |
35 | { | |
36 | struct led_classdev *led_cdev = (struct led_classdev *) data; | |
37 | struct heartbeat_trig_data *heartbeat_data = led_cdev->trigger_data; | |
38 | unsigned long brightness = LED_OFF; | |
39 | unsigned long delay = 0; | |
40 | ||
fb31fbeb | 41 | if (unlikely(panic_heartbeats)) { |
81fe8e5b | 42 | led_set_brightness_nosleep(led_cdev, LED_OFF); |
fb31fbeb AH |
43 | return; |
44 | } | |
45 | ||
fb3d7691 JA |
46 | if (test_and_clear_bit(LED_BLINK_BRIGHTNESS_CHANGE, &led_cdev->work_flags)) |
47 | led_cdev->blink_brightness = led_cdev->new_blink_brightness; | |
48 | ||
891c668b AN |
49 | /* acts like an actual heart beat -- ie thump-thump-pause... */ |
50 | switch (heartbeat_data->phase) { | |
51 | case 0: | |
52 | /* | |
53 | * The hyperbolic function below modifies the | |
54 | * heartbeat period length in dependency of the | |
55 | * current (1min) load. It goes through the points | |
56 | * f(0)=1260, f(1)=860, f(5)=510, f(inf)->300. | |
57 | */ | |
58 | heartbeat_data->period = 300 + | |
59 | (6720 << FSHIFT) / (5 * avenrun[0] + (7 << FSHIFT)); | |
60 | heartbeat_data->period = | |
61 | msecs_to_jiffies(heartbeat_data->period); | |
62 | delay = msecs_to_jiffies(70); | |
63 | heartbeat_data->phase++; | |
1c7b9d0e | 64 | if (!heartbeat_data->invert) |
fb3d7691 | 65 | brightness = led_cdev->blink_brightness; |
891c668b AN |
66 | break; |
67 | case 1: | |
68 | delay = heartbeat_data->period / 4 - msecs_to_jiffies(70); | |
69 | heartbeat_data->phase++; | |
1c7b9d0e | 70 | if (heartbeat_data->invert) |
fb3d7691 | 71 | brightness = led_cdev->blink_brightness; |
891c668b AN |
72 | break; |
73 | case 2: | |
74 | delay = msecs_to_jiffies(70); | |
75 | heartbeat_data->phase++; | |
1c7b9d0e | 76 | if (!heartbeat_data->invert) |
fb3d7691 | 77 | brightness = led_cdev->blink_brightness; |
891c668b AN |
78 | break; |
79 | default: | |
80 | delay = heartbeat_data->period - heartbeat_data->period / 4 - | |
81 | msecs_to_jiffies(70); | |
82 | heartbeat_data->phase = 0; | |
1c7b9d0e | 83 | if (heartbeat_data->invert) |
fb3d7691 | 84 | brightness = led_cdev->blink_brightness; |
891c668b AN |
85 | break; |
86 | } | |
87 | ||
81fe8e5b | 88 | led_set_brightness_nosleep(led_cdev, brightness); |
891c668b AN |
89 | mod_timer(&heartbeat_data->timer, jiffies + delay); |
90 | } | |
91 | ||
1c7b9d0e JP |
92 | static ssize_t led_invert_show(struct device *dev, |
93 | struct device_attribute *attr, char *buf) | |
94 | { | |
95 | struct led_classdev *led_cdev = dev_get_drvdata(dev); | |
96 | struct heartbeat_trig_data *heartbeat_data = led_cdev->trigger_data; | |
97 | ||
98 | return sprintf(buf, "%u\n", heartbeat_data->invert); | |
99 | } | |
100 | ||
101 | static ssize_t led_invert_store(struct device *dev, | |
102 | struct device_attribute *attr, const char *buf, size_t size) | |
103 | { | |
104 | struct led_classdev *led_cdev = dev_get_drvdata(dev); | |
105 | struct heartbeat_trig_data *heartbeat_data = led_cdev->trigger_data; | |
106 | unsigned long state; | |
107 | int ret; | |
108 | ||
109 | ret = kstrtoul(buf, 0, &state); | |
110 | if (ret) | |
111 | return ret; | |
112 | ||
113 | heartbeat_data->invert = !!state; | |
114 | ||
115 | return size; | |
116 | } | |
117 | ||
118 | static DEVICE_ATTR(invert, 0644, led_invert_show, led_invert_store); | |
119 | ||
891c668b AN |
120 | static void heartbeat_trig_activate(struct led_classdev *led_cdev) |
121 | { | |
122 | struct heartbeat_trig_data *heartbeat_data; | |
1c7b9d0e | 123 | int rc; |
891c668b AN |
124 | |
125 | heartbeat_data = kzalloc(sizeof(*heartbeat_data), GFP_KERNEL); | |
126 | if (!heartbeat_data) | |
127 | return; | |
128 | ||
129 | led_cdev->trigger_data = heartbeat_data; | |
1c7b9d0e JP |
130 | rc = device_create_file(led_cdev->dev, &dev_attr_invert); |
131 | if (rc) { | |
132 | kfree(led_cdev->trigger_data); | |
133 | return; | |
134 | } | |
135 | ||
891c668b AN |
136 | setup_timer(&heartbeat_data->timer, |
137 | led_heartbeat_function, (unsigned long) led_cdev); | |
138 | heartbeat_data->phase = 0; | |
fb3d7691 JA |
139 | if (!led_cdev->blink_brightness) |
140 | led_cdev->blink_brightness = led_cdev->max_brightness; | |
891c668b | 141 | led_heartbeat_function(heartbeat_data->timer.data); |
fb3d7691 | 142 | set_bit(LED_BLINK_SW, &led_cdev->work_flags); |
03c091e5 | 143 | led_cdev->activated = true; |
891c668b AN |
144 | } |
145 | ||
146 | static void heartbeat_trig_deactivate(struct led_classdev *led_cdev) | |
147 | { | |
148 | struct heartbeat_trig_data *heartbeat_data = led_cdev->trigger_data; | |
149 | ||
03c091e5 | 150 | if (led_cdev->activated) { |
891c668b | 151 | del_timer_sync(&heartbeat_data->timer); |
1c7b9d0e | 152 | device_remove_file(led_cdev->dev, &dev_attr_invert); |
891c668b | 153 | kfree(heartbeat_data); |
fb3d7691 | 154 | clear_bit(LED_BLINK_SW, &led_cdev->work_flags); |
03c091e5 | 155 | led_cdev->activated = false; |
891c668b AN |
156 | } |
157 | } | |
158 | ||
159 | static struct led_trigger heartbeat_led_trigger = { | |
160 | .name = "heartbeat", | |
161 | .activate = heartbeat_trig_activate, | |
162 | .deactivate = heartbeat_trig_deactivate, | |
163 | }; | |
164 | ||
5ab92a7c LW |
165 | static int heartbeat_pm_notifier(struct notifier_block *nb, |
166 | unsigned long pm_event, void *unused) | |
167 | { | |
168 | int rc; | |
169 | ||
170 | switch (pm_event) { | |
171 | case PM_SUSPEND_PREPARE: | |
172 | case PM_HIBERNATION_PREPARE: | |
173 | case PM_RESTORE_PREPARE: | |
174 | led_trigger_unregister(&heartbeat_led_trigger); | |
175 | break; | |
176 | case PM_POST_SUSPEND: | |
177 | case PM_POST_HIBERNATION: | |
178 | case PM_POST_RESTORE: | |
179 | rc = led_trigger_register(&heartbeat_led_trigger); | |
180 | if (rc) | |
181 | pr_err("could not re-register heartbeat trigger\n"); | |
182 | break; | |
183 | default: | |
184 | break; | |
185 | } | |
186 | return NOTIFY_DONE; | |
187 | } | |
188 | ||
49dca5ae AH |
189 | static int heartbeat_reboot_notifier(struct notifier_block *nb, |
190 | unsigned long code, void *unused) | |
191 | { | |
192 | led_trigger_unregister(&heartbeat_led_trigger); | |
193 | return NOTIFY_DONE; | |
194 | } | |
195 | ||
fb31fbeb AH |
196 | static int heartbeat_panic_notifier(struct notifier_block *nb, |
197 | unsigned long code, void *unused) | |
198 | { | |
199 | panic_heartbeats = 1; | |
200 | return NOTIFY_DONE; | |
201 | } | |
202 | ||
5ab92a7c LW |
203 | static struct notifier_block heartbeat_pm_nb = { |
204 | .notifier_call = heartbeat_pm_notifier, | |
205 | }; | |
206 | ||
49dca5ae AH |
207 | static struct notifier_block heartbeat_reboot_nb = { |
208 | .notifier_call = heartbeat_reboot_notifier, | |
209 | }; | |
210 | ||
211 | static struct notifier_block heartbeat_panic_nb = { | |
fb31fbeb | 212 | .notifier_call = heartbeat_panic_notifier, |
49dca5ae AH |
213 | }; |
214 | ||
891c668b AN |
215 | static int __init heartbeat_trig_init(void) |
216 | { | |
49dca5ae AH |
217 | int rc = led_trigger_register(&heartbeat_led_trigger); |
218 | ||
219 | if (!rc) { | |
220 | atomic_notifier_chain_register(&panic_notifier_list, | |
221 | &heartbeat_panic_nb); | |
222 | register_reboot_notifier(&heartbeat_reboot_nb); | |
5ab92a7c | 223 | register_pm_notifier(&heartbeat_pm_nb); |
49dca5ae AH |
224 | } |
225 | return rc; | |
891c668b AN |
226 | } |
227 | ||
228 | static void __exit heartbeat_trig_exit(void) | |
229 | { | |
5ab92a7c | 230 | unregister_pm_notifier(&heartbeat_pm_nb); |
49dca5ae AH |
231 | unregister_reboot_notifier(&heartbeat_reboot_nb); |
232 | atomic_notifier_chain_unregister(&panic_notifier_list, | |
233 | &heartbeat_panic_nb); | |
891c668b AN |
234 | led_trigger_unregister(&heartbeat_led_trigger); |
235 | } | |
236 | ||
237 | module_init(heartbeat_trig_init); | |
238 | module_exit(heartbeat_trig_exit); | |
239 | ||
240 | MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>"); | |
241 | MODULE_DESCRIPTION("Heartbeat LED trigger"); | |
242 | MODULE_LICENSE("GPL"); |