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"); 262