[linux-block.git] / drivers / auxdisplay / line-display.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Character line display core support
 *
 * Copyright (C) 2016 Imagination Technologies
 * Author: Paul Burton <paul.burton@mips.com>
 *
 * Copyright (C) 2021 Glider bv
 */

#include <generated/utsrelease.h>

#include <linux/device.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/sysfs.h>
#include <linux/timer.h>

#include "line-display.h"

#define DEFAULT_SCROLL_RATE	(HZ / 2)

/**
 * linedisp_scroll() - scroll the display by a character
 * @t: really a pointer to the private data structure
 *
 * Scroll the current message along the display by one character, rearming the
 * timer if required.
 */
static void linedisp_scroll(struct timer_list *t)
{
	struct linedisp *linedisp = from_timer(linedisp, t, timer);
	unsigned int i, ch = linedisp->scroll_pos;
	unsigned int num_chars = linedisp->num_chars;

	/* update the current message string */
	for (i = 0; i < num_chars;) {
		/* copy as many characters from the string as possible */
		for (; i < num_chars && ch < linedisp->message_len; i++, ch++)
			linedisp->buf[i] = linedisp->message[ch];

		/* wrap around to the start of the string */
		ch = 0;
	}

	/* update the display */
	linedisp->update(linedisp);

	/* move on to the next character */
	linedisp->scroll_pos++;
	linedisp->scroll_pos %= linedisp->message_len;

	/* rearm the timer */
	if (linedisp->message_len > num_chars && linedisp->scroll_rate)
		mod_timer(&linedisp->timer, jiffies + linedisp->scroll_rate);
}

/**
 * linedisp_display() - set the message to be displayed
 * @linedisp: pointer to the private data structure
 * @msg: the message to display
 * @count: length of msg, or -1
 *
 * Display a new message @msg on the display. @msg can be longer than the
 * number of characters the display can display, in which case it will begin
 * scrolling across the display.
 *
 * Return: 0 on success, -ENOMEM on memory allocation failure
 */
static int linedisp_display(struct linedisp *linedisp, const char *msg,
			    ssize_t count)
{
	char *new_msg;

	/* stop the scroll timer */
	del_timer_sync(&linedisp->timer);

	if (count == -1)
		count = strlen(msg);

	/* if the string ends with a newline, trim it */
	if (msg[count - 1] == '\n')
		count--;

	if (!count) {
		/* Clear the display */
		kfree(linedisp->message);
		linedisp->message = NULL;
		linedisp->message_len = 0;
		memset(linedisp->buf, ' ', linedisp->num_chars);
		linedisp->update(linedisp);
		return 0;
	}

	new_msg = kmemdup_nul(msg, count, GFP_KERNEL);
	if (!new_msg)
		return -ENOMEM;

	kfree(linedisp->message);

	linedisp->message = new_msg;
	linedisp->message_len = count;
	linedisp->scroll_pos = 0;

	/* update the display */
	linedisp_scroll(&linedisp->timer);

	return 0;
}

/**
 * message_show() - read message via sysfs
 * @dev: the display device
 * @attr: the display message attribute
 * @buf: the buffer to read the message into
 *
 * Read the current message being displayed or scrolled across the display into
 * @buf, for reads from sysfs.
 *
 * Return: the number of characters written to @buf
 */
static ssize_t message_show(struct device *dev, struct device_attribute *attr,
			    char *buf)
{
	struct linedisp *linedisp = container_of(dev, struct linedisp, dev);

	return sysfs_emit(buf, "%s\n", linedisp->message);
}

/**
 * message_store() - write a new message via sysfs
 * @dev: the display device
 * @attr: the display message attribute
 * @buf: the buffer containing the new message
 * @count: the size of the message in @buf
 *
 * Write a new message to display or scroll across the display from sysfs.
 *
 * Return: the size of the message on success, else -ERRNO
 */
static ssize_t message_store(struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count)
{
	struct linedisp *linedisp = container_of(dev, struct linedisp, dev);
	int err;

	err = linedisp_display(linedisp, buf, count);
	return err ?: count;
}

static DEVICE_ATTR_RW(message);

static ssize_t scroll_step_ms_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	struct linedisp *linedisp = container_of(dev, struct linedisp, dev);

	return sysfs_emit(buf, "%u\n", jiffies_to_msecs(linedisp->scroll_rate));
}

static ssize_t scroll_step_ms_store(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf, size_t count)
{
	struct linedisp *linedisp = container_of(dev, struct linedisp, dev);
	unsigned int ms;

	if (kstrtouint(buf, 10, &ms) != 0)
		return -EINVAL;

	linedisp->scroll_rate = msecs_to_jiffies(ms);
	if (linedisp->message && linedisp->message_len > linedisp->num_chars) {
		del_timer_sync(&linedisp->timer);
		if (linedisp->scroll_rate)
			linedisp_scroll(&linedisp->timer);
	}

	return count;
}

static DEVICE_ATTR_RW(scroll_step_ms);

static struct attribute *linedisp_attrs[] = {
	&dev_attr_message.attr,
	&dev_attr_scroll_step_ms.attr,
	NULL,
};
ATTRIBUTE_GROUPS(linedisp);

static const struct device_type linedisp_type = {
	.groups	= linedisp_groups,
};

/**
 * linedisp_register - register a character line display
 * @linedisp: pointer to character line display structure
 * @parent: parent device
 * @num_chars: the number of characters that can be displayed
 * @buf: pointer to a buffer that can hold @num_chars characters
 * @update: Function called to update the display.  This must not sleep!
 *
 * Return: zero on success, else a negative error code.
 */
int linedisp_register(struct linedisp *linedisp, struct device *parent,
		      unsigned int num_chars, char *buf,
		      void (*update)(struct linedisp *linedisp))
{
	static atomic_t linedisp_id = ATOMIC_INIT(-1);
	int err;

	memset(linedisp, 0, sizeof(*linedisp));
	linedisp->dev.parent = parent;
	linedisp->dev.type = &linedisp_type;
	linedisp->update = update;
	linedisp->buf = buf;
	linedisp->num_chars = num_chars;
	linedisp->scroll_rate = DEFAULT_SCROLL_RATE;

	device_initialize(&linedisp->dev);
	dev_set_name(&linedisp->dev, "linedisp.%lu",
		     (unsigned long)atomic_inc_return(&linedisp_id));

	/* initialise a timer for scrolling the message */
	timer_setup(&linedisp->timer, linedisp_scroll, 0);

	err = device_add(&linedisp->dev);
	if (err)
		goto out_del_timer;

	/* display a default message */
	err = linedisp_display(linedisp, "Linux " UTS_RELEASE "       ", -1);
	if (err)
		goto out_del_dev;

	return 0;

out_del_dev:
	device_del(&linedisp->dev);
out_del_timer:
	del_timer_sync(&linedisp->timer);
	put_device(&linedisp->dev);
	return err;
}
EXPORT_SYMBOL_GPL(linedisp_register);

/**
 * linedisp_unregister - unregister a character line display
 * @linedisp: pointer to character line display structure registered previously
 *	      with linedisp_register()
 */
void linedisp_unregister(struct linedisp *linedisp)
{
	device_del(&linedisp->dev);
	del_timer_sync(&linedisp->timer);
	kfree(linedisp->message);
	put_device(&linedisp->dev);
}
EXPORT_SYMBOL_GPL(linedisp_unregister);

MODULE_LICENSE("GPL");
Commit	Line	Data
7e76aece GU	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
d79141c3 GU	22	#define DEFAULT_SCROLL_RATE (HZ / 2)
d79141c3 GU	23
7e76aece GU	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 */
d79141c3	55	if (linedisp->message_len > num_chars && linedisp->scroll_rate)
7e76aece GU	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
364f2c39	96	new_msg = kmemdup_nul(msg, count, GFP_KERNEL);
7e76aece GU	97	if (!new_msg)
	98	return -ENOMEM;
	99
7e76aece GU	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
d79141c3 GU	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
7e76aece GU	184	static struct attribute *linedisp_attrs[] = {
7e76aece GU	185	&dev_attr_message.attr,
d79141c3	186	&dev_attr_scroll_step_ms.attr,
7e76aece GU	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;
d79141c3	218	linedisp->scroll_rate = DEFAULT_SCROLL_RATE;
7e76aece GU	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");