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 */
linedisp_scroll(struct timer_list * t)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 */
linedisp_display(struct linedisp * linedisp,const char * msg,ssize_t count)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 */
message_show(struct device * dev,struct device_attribute * attr,char * buf)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 */
message_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
scroll_step_ms_show(struct device * dev,struct device_attribute * attr,char * buf)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
scroll_step_ms_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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 */
linedisp_register(struct linedisp * linedisp,struct device * parent,unsigned int num_chars,char * buf,void (* update)(struct linedisp * linedisp))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 */
linedisp_unregister(struct linedisp * linedisp)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