Loading...
1// SPDX-License-Identifier: GPL-2.0
2
3#include <linux/completion.h>
4#include <linux/delay.h>
5#include <linux/leds.h>
6#include <linux/module.h>
7#include <linux/slab.h>
8#include <linux/tty.h>
9#include <uapi/linux/serial.h>
10
11#define LEDTRIG_TTY_INTERVAL 50
12
13struct ledtrig_tty_data {
14 struct led_classdev *led_cdev;
15 struct delayed_work dwork;
16 struct completion sysfs;
17 const char *ttyname;
18 struct tty_struct *tty;
19 int rx, tx;
20 bool mode_rx;
21 bool mode_tx;
22 bool mode_cts;
23 bool mode_dsr;
24 bool mode_dcd;
25 bool mode_rng;
26};
27
28/* Indicates which state the LED should now display */
29enum led_trigger_tty_state {
30 TTY_LED_BLINK,
31 TTY_LED_ENABLE,
32 TTY_LED_DISABLE,
33};
34
35enum led_trigger_tty_modes {
36 TRIGGER_TTY_RX = 0,
37 TRIGGER_TTY_TX,
38 TRIGGER_TTY_CTS,
39 TRIGGER_TTY_DSR,
40 TRIGGER_TTY_DCD,
41 TRIGGER_TTY_RNG,
42};
43
44static int ledtrig_tty_wait_for_completion(struct device *dev)
45{
46 struct ledtrig_tty_data *trigger_data = led_trigger_get_drvdata(dev);
47 int ret;
48
49 ret = wait_for_completion_timeout(&trigger_data->sysfs,
50 msecs_to_jiffies(LEDTRIG_TTY_INTERVAL * 20));
51 if (ret == 0)
52 return -ETIMEDOUT;
53
54 return ret;
55}
56
57static ssize_t ttyname_show(struct device *dev,
58 struct device_attribute *attr, char *buf)
59{
60 struct ledtrig_tty_data *trigger_data = led_trigger_get_drvdata(dev);
61 ssize_t len = 0;
62 int completion;
63
64 reinit_completion(&trigger_data->sysfs);
65 completion = ledtrig_tty_wait_for_completion(dev);
66 if (completion < 0)
67 return completion;
68
69 if (trigger_data->ttyname)
70 len = sprintf(buf, "%s\n", trigger_data->ttyname);
71
72 return len;
73}
74
75static ssize_t ttyname_store(struct device *dev,
76 struct device_attribute *attr, const char *buf,
77 size_t size)
78{
79 struct ledtrig_tty_data *trigger_data = led_trigger_get_drvdata(dev);
80 char *ttyname;
81 ssize_t ret = size;
82 int completion;
83
84 if (size > 0 && buf[size - 1] == '\n')
85 size -= 1;
86
87 if (size) {
88 ttyname = kmemdup_nul(buf, size, GFP_KERNEL);
89 if (!ttyname)
90 return -ENOMEM;
91 } else {
92 ttyname = NULL;
93 }
94
95 reinit_completion(&trigger_data->sysfs);
96 completion = ledtrig_tty_wait_for_completion(dev);
97 if (completion < 0)
98 return completion;
99
100 kfree(trigger_data->ttyname);
101 tty_kref_put(trigger_data->tty);
102 trigger_data->tty = NULL;
103
104 trigger_data->ttyname = ttyname;
105
106 return ret;
107}
108static DEVICE_ATTR_RW(ttyname);
109
110static ssize_t ledtrig_tty_attr_show(struct device *dev, char *buf,
111 enum led_trigger_tty_modes attr)
112{
113 struct ledtrig_tty_data *trigger_data = led_trigger_get_drvdata(dev);
114 bool state;
115
116 switch (attr) {
117 case TRIGGER_TTY_RX:
118 state = trigger_data->mode_rx;
119 break;
120 case TRIGGER_TTY_TX:
121 state = trigger_data->mode_tx;
122 break;
123 case TRIGGER_TTY_CTS:
124 state = trigger_data->mode_cts;
125 break;
126 case TRIGGER_TTY_DSR:
127 state = trigger_data->mode_dsr;
128 break;
129 case TRIGGER_TTY_DCD:
130 state = trigger_data->mode_dcd;
131 break;
132 case TRIGGER_TTY_RNG:
133 state = trigger_data->mode_rng;
134 break;
135 }
136
137 return sysfs_emit(buf, "%u\n", state);
138}
139
140static ssize_t ledtrig_tty_attr_store(struct device *dev, const char *buf,
141 size_t size, enum led_trigger_tty_modes attr)
142{
143 struct ledtrig_tty_data *trigger_data = led_trigger_get_drvdata(dev);
144 bool state;
145 int ret;
146
147 ret = kstrtobool(buf, &state);
148 if (ret)
149 return ret;
150
151 switch (attr) {
152 case TRIGGER_TTY_RX:
153 trigger_data->mode_rx = state;
154 break;
155 case TRIGGER_TTY_TX:
156 trigger_data->mode_tx = state;
157 break;
158 case TRIGGER_TTY_CTS:
159 trigger_data->mode_cts = state;
160 break;
161 case TRIGGER_TTY_DSR:
162 trigger_data->mode_dsr = state;
163 break;
164 case TRIGGER_TTY_DCD:
165 trigger_data->mode_dcd = state;
166 break;
167 case TRIGGER_TTY_RNG:
168 trigger_data->mode_rng = state;
169 break;
170 }
171
172 return size;
173}
174
175#define DEFINE_TTY_TRIGGER(trigger_name, trigger) \
176 static ssize_t trigger_name##_show(struct device *dev, \
177 struct device_attribute *attr, char *buf) \
178 { \
179 return ledtrig_tty_attr_show(dev, buf, trigger); \
180 } \
181 static ssize_t trigger_name##_store(struct device *dev, \
182 struct device_attribute *attr, const char *buf, size_t size) \
183 { \
184 return ledtrig_tty_attr_store(dev, buf, size, trigger); \
185 } \
186 static DEVICE_ATTR_RW(trigger_name)
187
188DEFINE_TTY_TRIGGER(rx, TRIGGER_TTY_RX);
189DEFINE_TTY_TRIGGER(tx, TRIGGER_TTY_TX);
190DEFINE_TTY_TRIGGER(cts, TRIGGER_TTY_CTS);
191DEFINE_TTY_TRIGGER(dsr, TRIGGER_TTY_DSR);
192DEFINE_TTY_TRIGGER(dcd, TRIGGER_TTY_DCD);
193DEFINE_TTY_TRIGGER(rng, TRIGGER_TTY_RNG);
194
195static void ledtrig_tty_work(struct work_struct *work)
196{
197 struct ledtrig_tty_data *trigger_data =
198 container_of(work, struct ledtrig_tty_data, dwork.work);
199 enum led_trigger_tty_state state = TTY_LED_DISABLE;
200 unsigned long interval = LEDTRIG_TTY_INTERVAL;
201 bool invert = false;
202 int status;
203 int ret;
204
205 if (!trigger_data->ttyname)
206 goto out;
207
208 /* try to get the tty corresponding to $ttyname */
209 if (!trigger_data->tty) {
210 dev_t devno;
211 struct tty_struct *tty;
212 int ret;
213
214 ret = tty_dev_name_to_number(trigger_data->ttyname, &devno);
215 if (ret < 0)
216 /*
217 * A device with this name might appear later, so keep
218 * retrying.
219 */
220 goto out;
221
222 tty = tty_kopen_shared(devno);
223 if (IS_ERR(tty) || !tty)
224 /* What to do? retry or abort */
225 goto out;
226
227 trigger_data->tty = tty;
228 }
229
230 status = tty_get_tiocm(trigger_data->tty);
231 if (status > 0) {
232 if (trigger_data->mode_cts) {
233 if (status & TIOCM_CTS)
234 state = TTY_LED_ENABLE;
235 }
236
237 if (trigger_data->mode_dsr) {
238 if (status & TIOCM_DSR)
239 state = TTY_LED_ENABLE;
240 }
241
242 if (trigger_data->mode_dcd) {
243 if (status & TIOCM_CAR)
244 state = TTY_LED_ENABLE;
245 }
246
247 if (trigger_data->mode_rng) {
248 if (status & TIOCM_RNG)
249 state = TTY_LED_ENABLE;
250 }
251 }
252
253 /*
254 * The evaluation of rx/tx must be done after the evaluation
255 * of TIOCM_*, because rx/tx has priority.
256 */
257 if (trigger_data->mode_rx || trigger_data->mode_tx) {
258 struct serial_icounter_struct icount;
259
260 ret = tty_get_icount(trigger_data->tty, &icount);
261 if (ret)
262 goto out;
263
264 if (trigger_data->mode_tx && (icount.tx != trigger_data->tx)) {
265 trigger_data->tx = icount.tx;
266 invert = state == TTY_LED_ENABLE;
267 state = TTY_LED_BLINK;
268 }
269
270 if (trigger_data->mode_rx && (icount.rx != trigger_data->rx)) {
271 trigger_data->rx = icount.rx;
272 invert = state == TTY_LED_ENABLE;
273 state = TTY_LED_BLINK;
274 }
275 }
276
277out:
278 switch (state) {
279 case TTY_LED_BLINK:
280 led_blink_set_oneshot(trigger_data->led_cdev, &interval,
281 &interval, invert);
282 break;
283 case TTY_LED_ENABLE:
284 led_set_brightness(trigger_data->led_cdev,
285 trigger_data->led_cdev->blink_brightness);
286 break;
287 case TTY_LED_DISABLE:
288 fallthrough;
289 default:
290 led_set_brightness(trigger_data->led_cdev, LED_OFF);
291 break;
292 }
293
294 complete_all(&trigger_data->sysfs);
295 schedule_delayed_work(&trigger_data->dwork,
296 msecs_to_jiffies(LEDTRIG_TTY_INTERVAL * 2));
297}
298
299static struct attribute *ledtrig_tty_attrs[] = {
300 &dev_attr_ttyname.attr,
301 &dev_attr_rx.attr,
302 &dev_attr_tx.attr,
303 &dev_attr_cts.attr,
304 &dev_attr_dsr.attr,
305 &dev_attr_dcd.attr,
306 &dev_attr_rng.attr,
307 NULL
308};
309ATTRIBUTE_GROUPS(ledtrig_tty);
310
311static int ledtrig_tty_activate(struct led_classdev *led_cdev)
312{
313 struct ledtrig_tty_data *trigger_data;
314
315 trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
316 if (!trigger_data)
317 return -ENOMEM;
318
319 /* Enable default rx/tx mode */
320 trigger_data->mode_rx = true;
321 trigger_data->mode_tx = true;
322
323 led_set_trigger_data(led_cdev, trigger_data);
324
325 INIT_DELAYED_WORK(&trigger_data->dwork, ledtrig_tty_work);
326 trigger_data->led_cdev = led_cdev;
327 init_completion(&trigger_data->sysfs);
328
329 schedule_delayed_work(&trigger_data->dwork, 0);
330
331 return 0;
332}
333
334static void ledtrig_tty_deactivate(struct led_classdev *led_cdev)
335{
336 struct ledtrig_tty_data *trigger_data = led_get_trigger_data(led_cdev);
337
338 cancel_delayed_work_sync(&trigger_data->dwork);
339
340 kfree(trigger_data->ttyname);
341 tty_kref_put(trigger_data->tty);
342 trigger_data->tty = NULL;
343
344 kfree(trigger_data);
345}
346
347static struct led_trigger ledtrig_tty = {
348 .name = "tty",
349 .activate = ledtrig_tty_activate,
350 .deactivate = ledtrig_tty_deactivate,
351 .groups = ledtrig_tty_groups,
352};
353module_led_trigger(ledtrig_tty);
354
355MODULE_AUTHOR("Uwe Kleine-König <u.kleine-koenig@pengutronix.de>");
356MODULE_DESCRIPTION("UART LED trigger");
357MODULE_LICENSE("GPL v2");
1// SPDX-License-Identifier: GPL-2.0
2
3#include <linux/delay.h>
4#include <linux/leds.h>
5#include <linux/module.h>
6#include <linux/slab.h>
7#include <linux/tty.h>
8#include <uapi/linux/serial.h>
9
10struct ledtrig_tty_data {
11 struct led_classdev *led_cdev;
12 struct delayed_work dwork;
13 struct mutex mutex;
14 const char *ttyname;
15 struct tty_struct *tty;
16 int rx, tx;
17};
18
19static void ledtrig_tty_restart(struct ledtrig_tty_data *trigger_data)
20{
21 schedule_delayed_work(&trigger_data->dwork, 0);
22}
23
24static ssize_t ttyname_show(struct device *dev,
25 struct device_attribute *attr, char *buf)
26{
27 struct ledtrig_tty_data *trigger_data = led_trigger_get_drvdata(dev);
28 ssize_t len = 0;
29
30 mutex_lock(&trigger_data->mutex);
31
32 if (trigger_data->ttyname)
33 len = sprintf(buf, "%s\n", trigger_data->ttyname);
34
35 mutex_unlock(&trigger_data->mutex);
36
37 return len;
38}
39
40static ssize_t ttyname_store(struct device *dev,
41 struct device_attribute *attr, const char *buf,
42 size_t size)
43{
44 struct ledtrig_tty_data *trigger_data = led_trigger_get_drvdata(dev);
45 char *ttyname;
46 ssize_t ret = size;
47 bool running;
48
49 if (size > 0 && buf[size - 1] == '\n')
50 size -= 1;
51
52 if (size) {
53 ttyname = kmemdup_nul(buf, size, GFP_KERNEL);
54 if (!ttyname)
55 return -ENOMEM;
56 } else {
57 ttyname = NULL;
58 }
59
60 mutex_lock(&trigger_data->mutex);
61
62 running = trigger_data->ttyname != NULL;
63
64 kfree(trigger_data->ttyname);
65 tty_kref_put(trigger_data->tty);
66 trigger_data->tty = NULL;
67
68 trigger_data->ttyname = ttyname;
69
70 mutex_unlock(&trigger_data->mutex);
71
72 if (ttyname && !running)
73 ledtrig_tty_restart(trigger_data);
74
75 return ret;
76}
77static DEVICE_ATTR_RW(ttyname);
78
79static void ledtrig_tty_work(struct work_struct *work)
80{
81 struct ledtrig_tty_data *trigger_data =
82 container_of(work, struct ledtrig_tty_data, dwork.work);
83 struct serial_icounter_struct icount;
84 int ret;
85
86 mutex_lock(&trigger_data->mutex);
87
88 if (!trigger_data->ttyname) {
89 /* exit without rescheduling */
90 mutex_unlock(&trigger_data->mutex);
91 return;
92 }
93
94 /* try to get the tty corresponding to $ttyname */
95 if (!trigger_data->tty) {
96 dev_t devno;
97 struct tty_struct *tty;
98 int ret;
99
100 ret = tty_dev_name_to_number(trigger_data->ttyname, &devno);
101 if (ret < 0)
102 /*
103 * A device with this name might appear later, so keep
104 * retrying.
105 */
106 goto out;
107
108 tty = tty_kopen_shared(devno);
109 if (IS_ERR(tty) || !tty)
110 /* What to do? retry or abort */
111 goto out;
112
113 trigger_data->tty = tty;
114 }
115
116 ret = tty_get_icount(trigger_data->tty, &icount);
117 if (ret) {
118 dev_info(trigger_data->tty->dev, "Failed to get icount, stopped polling\n");
119 mutex_unlock(&trigger_data->mutex);
120 return;
121 }
122
123 if (icount.rx != trigger_data->rx ||
124 icount.tx != trigger_data->tx) {
125 led_set_brightness_sync(trigger_data->led_cdev, LED_ON);
126
127 trigger_data->rx = icount.rx;
128 trigger_data->tx = icount.tx;
129 } else {
130 led_set_brightness_sync(trigger_data->led_cdev, LED_OFF);
131 }
132
133out:
134 mutex_unlock(&trigger_data->mutex);
135 schedule_delayed_work(&trigger_data->dwork, msecs_to_jiffies(100));
136}
137
138static struct attribute *ledtrig_tty_attrs[] = {
139 &dev_attr_ttyname.attr,
140 NULL
141};
142ATTRIBUTE_GROUPS(ledtrig_tty);
143
144static int ledtrig_tty_activate(struct led_classdev *led_cdev)
145{
146 struct ledtrig_tty_data *trigger_data;
147
148 trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
149 if (!trigger_data)
150 return -ENOMEM;
151
152 led_set_trigger_data(led_cdev, trigger_data);
153
154 INIT_DELAYED_WORK(&trigger_data->dwork, ledtrig_tty_work);
155 trigger_data->led_cdev = led_cdev;
156 mutex_init(&trigger_data->mutex);
157
158 return 0;
159}
160
161static void ledtrig_tty_deactivate(struct led_classdev *led_cdev)
162{
163 struct ledtrig_tty_data *trigger_data = led_get_trigger_data(led_cdev);
164
165 cancel_delayed_work_sync(&trigger_data->dwork);
166
167 kfree(trigger_data);
168}
169
170static struct led_trigger ledtrig_tty = {
171 .name = "tty",
172 .activate = ledtrig_tty_activate,
173 .deactivate = ledtrig_tty_deactivate,
174 .groups = ledtrig_tty_groups,
175};
176module_led_trigger(ledtrig_tty);
177
178MODULE_AUTHOR("Uwe Kleine-König <u.kleine-koenig@pengutronix.de>");
179MODULE_DESCRIPTION("UART LED trigger");
180MODULE_LICENSE("GPL v2");