drivers/auxdisplay/line-display.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Character line display core support
   4  *
   5  * Copyright (C) 2016 Imagination Technologies
   6  * Author: Paul Burton <paul.burton@mips.com>
   7  *
   8  * Copyright (C) 2021 Glider bv
   9  */
  10
  11 #include <generated/utsrelease.h>
  12
  13 #include <linux/device.h>
  14 #include <linux/module.h>
  15 #include <linux/slab.h>
  16 #include <linux/string.h>
  17 #include <linux/sysfs.h>
  18 #include <linux/timer.h>
  19
  20 #include "line-display.h"
  21
  22 #define DEFAULT_SCROLL_RATE     (HZ / 2)
  23
  24 /**
  25  * linedisp_scroll() - scroll the display by a character
  26  * @t: really a pointer to the private data structure
  27  *
  28  * Scroll the current message along the display by one character, rearming the
  29  * timer if required.
  30  */
  31 static void linedisp_scroll(struct timer_list *t)
  32 {
  33         struct linedisp *linedisp = from_timer(linedisp, t, timer);
  34         unsigned int i, ch = linedisp->scroll_pos;
  35         unsigned int num_chars = linedisp->num_chars;
  36
  37         /* update the current message string */
  38         for (i = 0; i < num_chars;) {
  39                 /* copy as many characters from the string as possible */
  40                 for (; i < num_chars && ch < linedisp->message_len; i++, ch++)
  41                         linedisp->buf[i] = linedisp->message[ch];
  42
  43                 /* wrap around to the start of the string */
  44                 ch = 0;
  45         }
  46
  47         /* update the display */
  48         linedisp->update(linedisp);
  49
  50         /* move on to the next character */
  51         linedisp->scroll_pos++;
  52         linedisp->scroll_pos %= linedisp->message_len;
  53
  54         /* rearm the timer */
  55         if (linedisp->message_len > num_chars && linedisp->scroll_rate)
  56                 mod_timer(&linedisp->timer, jiffies + linedisp->scroll_rate);
  57 }
  58
  59 /**
  60  * linedisp_display() - set the message to be displayed
  61  * @linedisp: pointer to the private data structure
  62  * @msg: the message to display
  63  * @count: length of msg, or -1
  64  *
  65  * Display a new message @msg on the display. @msg can be longer than the
  66  * number of characters the display can display, in which case it will begin
  67  * scrolling across the display.
  68  *
  69  * Return: 0 on success, -ENOMEM on memory allocation failure
  70  */
  71 static int linedisp_display(struct linedisp *linedisp, const char *msg,
  72                             ssize_t count)
  73 {
  74         char *new_msg;
  75
  76         /* stop the scroll timer */
  77         del_timer_sync(&linedisp->timer);
  78
  79         if (count == -1)
  80                 count = strlen(msg);
  81
  82         /* if the string ends with a newline, trim it */
  83         if (msg[count - 1] == '\n')
  84                 count--;
  85
  86         if (!count) {
  87                 /* Clear the display */
  88                 kfree(linedisp->message);
  89                 linedisp->message = NULL;
  90                 linedisp->message_len = 0;
  91                 memset(linedisp->buf, ' ', linedisp->num_chars);
  92                 linedisp->update(linedisp);
  93                 return 0;
  94         }
  95
  96         new_msg = kmemdup_nul(msg, count, GFP_KERNEL);
  97         if (!new_msg)
  98                 return -ENOMEM;
  99
 100         kfree(linedisp->message);
 101
 102         linedisp->message = new_msg;
 103         linedisp->message_len = count;
 104         linedisp->scroll_pos = 0;
 105
 106         /* update the display */
 107         linedisp_scroll(&linedisp->timer);
 108
 109         return 0;
 110 }
 111
 112 /**
 113  * message_show() - read message via sysfs
 114  * @dev: the display device
 115  * @attr: the display message attribute
 116  * @buf: the buffer to read the message into
 117  *
 118  * Read the current message being displayed or scrolled across the display into
 119  * @buf, for reads from sysfs.
 120  *
 121  * Return: the number of characters written to @buf
 122  */
 123 static ssize_t message_show(struct device *dev, struct device_attribute *attr,
 124                             char *buf)
 125 {
 126         struct linedisp *linedisp = container_of(dev, struct linedisp, dev);
 127
 128         return sysfs_emit(buf, "%s\n", linedisp->message);
 129 }
 130
 131 /**
 132  * message_store() - write a new message via sysfs
 133  * @dev: the display device
 134  * @attr: the display message attribute
 135  * @buf: the buffer containing the new message
 136  * @count: the size of the message in @buf
 137  *
 138  * Write a new message to display or scroll across the display from sysfs.
 139  *
 140  * Return: the size of the message on success, else -ERRNO
 141  */
 142 static ssize_t message_store(struct device *dev, struct device_attribute *attr,
 143                              const char *buf, size_t count)
 144 {
 145         struct linedisp *linedisp = container_of(dev, struct linedisp, dev);
 146         int err;
 147
 148         err = linedisp_display(linedisp, buf, count);
 149         return err ?: count;
 150 }
 151
 152 static DEVICE_ATTR_RW(message);
 153
 154 static ssize_t scroll_step_ms_show(struct device *dev,
 155                                    struct device_attribute *attr, char *buf)
 156 {
 157         struct linedisp *linedisp = container_of(dev, struct linedisp, dev);
 158
 159         return sysfs_emit(buf, "%u\n", jiffies_to_msecs(linedisp->scroll_rate));
 160 }
 161
 162 static ssize_t scroll_step_ms_store(struct device *dev,
 163                                     struct device_attribute *attr,
 164                                     const char *buf, size_t count)
 165 {
 166         struct linedisp *linedisp = container_of(dev, struct linedisp, dev);
 167         unsigned int ms;
 168
 169         if (kstrtouint(buf, 10, &ms) != 0)
 170                 return -EINVAL;
 171
 172         linedisp->scroll_rate = msecs_to_jiffies(ms);
 173         if (linedisp->message && linedisp->message_len > linedisp->num_chars) {
 174                 del_timer_sync(&linedisp->timer);
 175                 if (linedisp->scroll_rate)
 176                         linedisp_scroll(&linedisp->timer);
 177         }
 178
 179         return count;
 180 }
 181
 182 static DEVICE_ATTR_RW(scroll_step_ms);
 183
 184 static struct attribute *linedisp_attrs[] = {
 185         &dev_attr_message.attr,
 186         &dev_attr_scroll_step_ms.attr,
 187         NULL,
 188 };
 189 ATTRIBUTE_GROUPS(linedisp);
 190
 191 static const struct device_type linedisp_type = {
 192         .groups = linedisp_groups,
 193 };
 194
 195 /**
 196  * linedisp_register - register a character line display
 197  * @linedisp: pointer to character line display structure
 198  * @parent: parent device
 199  * @num_chars: the number of characters that can be displayed
 200  * @buf: pointer to a buffer that can hold @num_chars characters
 201  * @update: Function called to update the display.  This must not sleep!
 202  *
 203  * Return: zero on success, else a negative error code.
 204  */
 205 int linedisp_register(struct linedisp *linedisp, struct device *parent,
 206                       unsigned int num_chars, char *buf,
 207                       void (*update)(struct linedisp *linedisp))
 208 {
 209         static atomic_t linedisp_id = ATOMIC_INIT(-1);
 210         int err;
 211
 212         memset(linedisp, 0, sizeof(*linedisp));
 213         linedisp->dev.parent = parent;
 214         linedisp->dev.type = &linedisp_type;
 215         linedisp->update = update;
 216         linedisp->buf = buf;
 217         linedisp->num_chars = num_chars;
 218         linedisp->scroll_rate = DEFAULT_SCROLL_RATE;
 219
 220         device_initialize(&linedisp->dev);
 221         dev_set_name(&linedisp->dev, "linedisp.%lu",
 222                      (unsigned long)atomic_inc_return(&linedisp_id));
 223
 224         /* initialise a timer for scrolling the message */
 225         timer_setup(&linedisp->timer, linedisp_scroll, 0);
 226
 227         err = device_add(&linedisp->dev);
 228         if (err)
 229                 goto out_del_timer;
 230
 231         /* display a default message */
 232         err = linedisp_display(linedisp, "Linux " UTS_RELEASE "       ", -1);
 233         if (err)
 234                 goto out_del_dev;
 235
 236         return 0;
 237
 238 out_del_dev:
 239         device_del(&linedisp->dev);
 240 out_del_timer:
 241         del_timer_sync(&linedisp->timer);
 242         put_device(&linedisp->dev);
 243         return err;
 244 }
 245 EXPORT_SYMBOL_GPL(linedisp_register);
 246
 247 /**
 248  * linedisp_unregister - unregister a character line display
 249  * @linedisp: pointer to character line display structure registered previously
 250  *            with linedisp_register()
 251  */
 252 void linedisp_unregister(struct linedisp *linedisp)
 253 {
 254         device_del(&linedisp->dev);
 255         del_timer_sync(&linedisp->timer);
 256         kfree(linedisp->message);
 257         put_device(&linedisp->dev);
 258 }
 259 EXPORT_SYMBOL_GPL(linedisp_unregister);
 260
 261 MODULE_LICENSE("GPL");