leds/trigger/ledtrig-tty.c

0001 // SPDX-License-Identifier: GPL-2.0
0002
0003 #include <linux/delay.h>
0004 #include <linux/leds.h>
0005 #include <linux/module.h>
0006 #include <linux/slab.h>
0007 #include <linux/tty.h>
0008 #include <uapi/linux/serial.h>
0009
0010 struct ledtrig_tty_data {
0011     struct led_classdev *led_cdev;
0012     struct delayed_work dwork;
0013     struct mutex mutex;
0014     const char *ttyname;
0015     struct tty_struct *tty;
0016     int rx, tx;
0017 };
0018
0019 static void ledtrig_tty_restart(struct ledtrig_tty_data *trigger_data)
0020 {
0021     schedule_delayed_work(&trigger_data->dwork, 0);
0022 }
0023
0024 static ssize_t ttyname_show(struct device *dev,
0025                 struct device_attribute *attr, char *buf)
0026 {
0027     struct ledtrig_tty_data *trigger_data = led_trigger_get_drvdata(dev);
0028     ssize_t len = 0;
0029
0030     mutex_lock(&trigger_data->mutex);
0031
0032     if (trigger_data->ttyname)
0033         len = sprintf(buf, "%s\n", trigger_data->ttyname);
0034
0035     mutex_unlock(&trigger_data->mutex);
0036
0037     return len;
0038 }
0039
0040 static ssize_t ttyname_store(struct device *dev,
0041                  struct device_attribute *attr, const char *buf,
0042                  size_t size)
0043 {
0044     struct ledtrig_tty_data *trigger_data = led_trigger_get_drvdata(dev);
0045     char *ttyname;
0046     ssize_t ret = size;
0047     bool running;
0048
0049     if (size > 0 && buf[size - 1] == '\n')
0050         size -= 1;
0051
0052     if (size) {
0053         ttyname = kmemdup_nul(buf, size, GFP_KERNEL);
0054         if (!ttyname)
0055             return -ENOMEM;
0056     } else {
0057         ttyname = NULL;
0058     }
0059
0060     mutex_lock(&trigger_data->mutex);
0061
0062     running = trigger_data->ttyname != NULL;
0063
0064     kfree(trigger_data->ttyname);
0065     tty_kref_put(trigger_data->tty);
0066     trigger_data->tty = NULL;
0067
0068     trigger_data->ttyname = ttyname;
0069
0070     mutex_unlock(&trigger_data->mutex);
0071
0072     if (ttyname && !running)
0073         ledtrig_tty_restart(trigger_data);
0074
0075     return ret;
0076 }
0077 static DEVICE_ATTR_RW(ttyname);
0078
0079 static void ledtrig_tty_work(struct work_struct *work)
0080 {
0081     struct ledtrig_tty_data *trigger_data =
0082         container_of(work, struct ledtrig_tty_data, dwork.work);
0083     struct serial_icounter_struct icount;
0084     int ret;
0085
0086     mutex_lock(&trigger_data->mutex);
0087
0088     if (!trigger_data->ttyname) {
0089         /* exit without rescheduling */
0090         mutex_unlock(&trigger_data->mutex);
0091         return;
0092     }
0093
0094     /* try to get the tty corresponding to $ttyname */
0095     if (!trigger_data->tty) {
0096         dev_t devno;
0097         struct tty_struct *tty;
0098         int ret;
0099
0100         ret = tty_dev_name_to_number(trigger_data->ttyname, &devno);
0101         if (ret < 0)
0102             /*
0103              * A device with this name might appear later, so keep
0104              * retrying.
0105              */
0106             goto out;
0107
0108         tty = tty_kopen_shared(devno);
0109         if (IS_ERR(tty) || !tty)
0110             /* What to do? retry or abort */
0111             goto out;
0112
0113         trigger_data->tty = tty;
0114     }
0115
0116     ret = tty_get_icount(trigger_data->tty, &icount);
0117     if (ret) {
0118         dev_info(trigger_data->tty->dev, "Failed to get icount, stopped polling\n");
0119         mutex_unlock(&trigger_data->mutex);
0120         return;
0121     }
0122
0123     if (icount.rx != trigger_data->rx ||
0124         icount.tx != trigger_data->tx) {
0125         led_set_brightness_sync(trigger_data->led_cdev, LED_ON);
0126
0127         trigger_data->rx = icount.rx;
0128         trigger_data->tx = icount.tx;
0129     } else {
0130         led_set_brightness_sync(trigger_data->led_cdev, LED_OFF);
0131     }
0132
0133 out:
0134     mutex_unlock(&trigger_data->mutex);
0135     schedule_delayed_work(&trigger_data->dwork, msecs_to_jiffies(100));
0136 }
0137
0138 static struct attribute *ledtrig_tty_attrs[] = {
0139     &dev_attr_ttyname.attr,
0140     NULL
0141 };
0142 ATTRIBUTE_GROUPS(ledtrig_tty);
0143
0144 static int ledtrig_tty_activate(struct led_classdev *led_cdev)
0145 {
0146     struct ledtrig_tty_data *trigger_data;
0147
0148     trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
0149     if (!trigger_data)
0150         return -ENOMEM;
0151
0152     led_set_trigger_data(led_cdev, trigger_data);
0153
0154     INIT_DELAYED_WORK(&trigger_data->dwork, ledtrig_tty_work);
0155     trigger_data->led_cdev = led_cdev;
0156     mutex_init(&trigger_data->mutex);
0157
0158     return 0;
0159 }
0160
0161 static void ledtrig_tty_deactivate(struct led_classdev *led_cdev)
0162 {
0163     struct ledtrig_tty_data *trigger_data = led_get_trigger_data(led_cdev);
0164
0165     cancel_delayed_work_sync(&trigger_data->dwork);
0166
0167     kfree(trigger_data);
0168 }
0169
0170 static struct led_trigger ledtrig_tty = {
0171     .name = "tty",
0172     .activate = ledtrig_tty_activate,
0173     .deactivate = ledtrig_tty_deactivate,
0174     .groups = ledtrig_tty_groups,
0175 };
0176 module_led_trigger(ledtrig_tty);
0177
0178 MODULE_AUTHOR("Uwe Kleine-König <u.kleine-koenig@pengutronix.de>");
0179 MODULE_DESCRIPTION("UART LED trigger");
0180 MODULE_LICENSE("GPL v2");