Gh0st
/
linux
mirror of https://github.com/torvalds/linux.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

auxdisplay for v6.19-1 

* Support linedisp attribute attachment to auxdisplay parent devices
 -----BEGIN PGP SIGNATURE-----
 
 iQIzBAABCgAdFiEEqaflIX74DDDzMJJtb7wzTHR8rCgFAmkljLUACgkQb7wzTHR8
 rCgecQ//b6nPYBZsdtg9ZkOKmepHLu4mkHJIsNL2X+8aHvYC+lV24J9ABnbfKMlN
 R3DGSCoFH83ZuBXM0ZhAxs+xn3STCecC6t3g3ZP2QzG/5TQXvB2iHsNnAo401SLu
 buhu+EwTyawXJB8v4f7FZG+8UXz2pkk1uEV0zMaDE+nqzy+FplopPANQTYp0MFcz
 oxlxvkdQwxos8SqPeqsRsbr/6MSHLnKnUVgellbNyHwJa2C7d7gGmQ51aQkYM3zZ
 PAKrj9ruaoEBRXxDWZzForYLbPNyKe3c0aCY0T6AgcYmVT5ooPhoNWVGHYB9Q9F8
 RrwZMJYA7lA8ml68vGPpftyEFUpZd9nHkXhIapFkv+jwFfhGId0F+b+3a2lLY7t4
 PUJsjFkHoMlZpWJ03AAeJN6u2wFZEkpg7EfvOlzVl9b3QFcGHkvdjzQVNg8JQ5v8
 rJ2ANkQPmdxwR2NFZHfrHW1WckLmnxBlYXFx/41Hx/bZD9H5XoYhj/j7izLPADEv
 wKxraS91db0RWzacQwlQTDPw/vG94F+OvW4t+lw5yxmVYWfnGjkH4R4Y2//yQqGh
 UmT+/t+Dms6/wyugBUSCjk0AE4i8Fs66Yyu6HALMqV7Fb2jhSPNyF1y5dtPQ5HOz
 hvWQwV6BOoOULbdbrdRwgp8h4qPAIyMMLcxXQHrxRn104R9RPzI=
 =4qpF
 -----END PGP SIGNATURE-----

Merge tag 'auxdisplay-v6.19-1' of git://git.kernel.org/pub/scm/linux/kernel/git/andy/linux-auxdisplay

Pull auxdisplay updates from Andy Shevchenko:

 - Support linedisp attribute attachment to auxdisplay parent devices

* tag 'auxdisplay-v6.19-1' of git://git.kernel.org/pub/scm/linux/kernel/git/andy/linux-auxdisplay:
  auxdisplay: linedisp: support attribute attachment to auxdisplay devices
  auxdisplay: linedisp: add num_chars sysfs attribute
  auxdisplay: linedisp: display static message when length <= display size
  auxdisplay: linedisp: encapsulate container_of usage within to_linedisp
  docs: ABI: auxdisplay: document linedisp library sysfs attributes
This commit is contained in:
Linus Torvalds 2025-12-04 08:29:28 -08:00
parent d7aa60d966 00de283c53
commit 94e244d9cc
3 changed files with 312 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
Documentation/ABI/testing/sysfs-auxdisplay-linedisp Normal file
View File

@ -0,0 +1,90 @@
What: /sys/.../message
Date: October 2021
KernelVersion: 5.16
Description:
Controls the text message displayed on character line displays.
Reading returns the current message with a trailing newline.
Writing updates the displayed message. Messages longer than the
display width will automatically scroll. Trailing newlines in
input are automatically trimmed.
Writing an empty string clears the display.
Example:
echo "Hello World" > message
cat message # Returns "Hello World\n"
What: /sys/.../num_chars
Date: November 2025
KernelVersion: 6.18
Contact: Jean-François Lessard <jefflessard3@gmail.com>
Description:
Read-only attribute showing the character width capacity of
the line display device. Messages longer than this will scroll.
Example:
cat num_chars # Returns "16\n" for 16-char display
What: /sys/.../scroll_step_ms
Date: October 2021
KernelVersion: 5.16
Description:
Controls the scrolling speed for messages longer than the display
width, specified in milliseconds per scroll step.
Setting to 0 disables scrolling. Default is 500ms.
Example:
echo "250" > scroll_step_ms # 4Hz scrolling
cat scroll_step_ms # Returns "250\n"
What: /sys/.../map_seg7
Date: January 2024
KernelVersion: 6.9
Description:
Read/write binary blob representing the ASCII-to-7-segment
display conversion table used by the linedisp driver, as defined
by struct seg7_conversion_map in <linux/map_to_7segment.h>.
Only visible on displays with 7-segment capability.
This attribute is not human-readable. Writes must match the
struct size exactly, else -EINVAL is returned; reads return the
entire mapping as a binary blob.
This interface and its implementation match existing conventions
used in segment-mapped display drivers since 2005.
ABI note: This style of binary sysfs attribute *is an exception*
to current "one value per file, text only" sysfs rules, for
historical compatibility and driver uniformity. New drivers are
discouraged from introducing additional binary sysfs ABIs.
Reference interface guidance:
- include/uapi/linux/map_to_7segment.h
What: /sys/.../map_seg14
Date: January 2024
KernelVersion: 6.9
Description:
Read/write binary blob representing the ASCII-to-14-segment
display conversion table used by the linedisp driver, as defined
by struct seg14_conversion_map in <linux/map_to_14segment.h>.
Only visible on displays with 14-segment capability.
This attribute is not human-readable. Writes must match the
struct size exactly, else -EINVAL is returned; reads return the
entire mapping as a binary blob.
This interface and its implementation match existing conventions
used by segment-mapped display drivers since 2005.
ABI note: This style of binary sysfs attribute *is an exception*
to current "one value per file, text only" sysfs rules, for
historical compatibility and driver uniformity. New drivers are
discouraged from introducing additional binary sysfs ABIs.
Reference interface guidance:
- include/uapi/linux/map_to_14segment.h

240
drivers/auxdisplay/line-display.c
View File

@ -6,20 +6,23 @@
* Author: Paul Burton <paul.burton@mips.com> * Author: Paul Burton <paul.burton@mips.com>
* *
* Copyright (C) 2021 Glider bv * Copyright (C) 2021 Glider bv
* Copyright (C) 2025 Jean-François Lessard
*/ */
#ifndef CONFIG_PANEL_BOOT_MESSAGE #ifndef CONFIG_PANEL_BOOT_MESSAGE
#include <generated/utsrelease.h> #include <generated/utsrelease.h>
#endif #endif
#include <linux/container_of.h> #include <linux/cleanup.h>
#include <linux/device.h> #include <linux/device.h>
#include <linux/export.h> #include <linux/export.h>
#include <linux/idr.h> #include <linux/idr.h>
#include <linux/jiffies.h> #include <linux/jiffies.h>
#include <linux/kstrtox.h> #include <linux/kstrtox.h>
#include <linux/list.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/string.h> #include <linux/string.h>
#include <linux/sysfs.h> #include <linux/sysfs.h>
#include <linux/timer.h> #include <linux/timer.h>
@ -31,6 +34,87 @@
#define DEFAULT_SCROLL_RATE (HZ / 2) #define DEFAULT_SCROLL_RATE (HZ / 2)
/**
* struct linedisp_attachment - Holds the device to linedisp mapping
* @list: List entry for the linedisp_attachments list
* @device: Pointer to the device where linedisp attributes are added
* @linedisp: Pointer to the linedisp mapped to the device
* @direct: true for directly attached device using linedisp_attach(),
* false for child registered device using linedisp_register()
*/
struct linedisp_attachment {
struct list_head list;
struct device *device;
struct linedisp *linedisp;
bool direct;
};
static LIST_HEAD(linedisp_attachments);
static DEFINE_SPINLOCK(linedisp_attachments_lock);
static int create_attachment(struct device *dev, struct linedisp *linedisp, bool direct)
{
struct linedisp_attachment *attachment;
attachment = kzalloc(sizeof(*attachment), GFP_KERNEL);
if (!attachment)
return -ENOMEM;
attachment->device = dev;
attachment->linedisp = linedisp;
attachment->direct = direct;
guard(spinlock)(&linedisp_attachments_lock);
list_add(&attachment->list, &linedisp_attachments);
return 0;
}
static struct linedisp *delete_attachment(struct device *dev, bool direct)
{
struct linedisp_attachment *attachment;
struct linedisp *linedisp;
guard(spinlock)(&linedisp_attachments_lock);
list_for_each_entry(attachment, &linedisp_attachments, list) {
if (attachment->device == dev &&
attachment->direct == direct)
break;
}
if (list_entry_is_head(attachment, &linedisp_attachments, list))
return NULL;
linedisp = attachment->linedisp;
list_del(&attachment->list);
kfree(attachment);
return linedisp;
}
static struct linedisp *to_linedisp(struct device *dev)
{
struct linedisp_attachment *attachment;
guard(spinlock)(&linedisp_attachments_lock);
list_for_each_entry(attachment, &linedisp_attachments, list) {
if (attachment->device == dev)
break;
}
if (list_entry_is_head(attachment, &linedisp_attachments, list))
return NULL;
return attachment->linedisp;
}
static inline bool should_scroll(struct linedisp *linedisp)
{
return linedisp->message_len > linedisp->num_chars && linedisp->scroll_rate;
}
/** /**
* linedisp_scroll() - scroll the display by a character * linedisp_scroll() - scroll the display by a character
* @t: really a pointer to the private data structure * @t: really a pointer to the private data structure
@ -62,8 +146,7 @@ static void linedisp_scroll(struct timer_list *t)
linedisp->scroll_pos %= linedisp->message_len; linedisp->scroll_pos %= linedisp->message_len;
/* rearm the timer */ /* rearm the timer */
if (linedisp->message_len > num_chars && linedisp->scroll_rate) mod_timer(&linedisp->timer, jiffies + linedisp->scroll_rate);
mod_timer(&linedisp->timer, jiffies + linedisp->scroll_rate);
} }
/** /**
@ -113,8 +196,16 @@ static int linedisp_display(struct linedisp *linedisp, const char *msg,
linedisp->message_len = count; linedisp->message_len = count;
linedisp->scroll_pos = 0; linedisp->scroll_pos = 0;
/* update the display */ if (should_scroll(linedisp)) {
linedisp_scroll(&linedisp->timer); /* display scrolling message */
linedisp_scroll(&linedisp->timer);
} else {
/* display static message */
memset(linedisp->buf, ' ', linedisp->num_chars);
memcpy(linedisp->buf, linedisp->message,
umin(linedisp->num_chars, linedisp->message_len));
linedisp->ops->update(linedisp);
}
return 0; return 0;
} }
@ -133,7 +224,7 @@ static int linedisp_display(struct linedisp *linedisp, const char *msg,
static ssize_t message_show(struct device *dev, struct device_attribute *attr, static ssize_t message_show(struct device *dev, struct device_attribute *attr,
char *buf) char *buf)
{ {
struct linedisp *linedisp = container_of(dev, struct linedisp, dev); struct linedisp *linedisp = to_linedisp(dev);
return sysfs_emit(buf, "%s\n", linedisp->message); return sysfs_emit(buf, "%s\n", linedisp->message);
} }
@ -152,7 +243,7 @@ static ssize_t message_show(struct device *dev, struct device_attribute *attr,
static ssize_t message_store(struct device *dev, struct device_attribute *attr, static ssize_t message_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count) const char *buf, size_t count)
{ {
struct linedisp *linedisp = container_of(dev, struct linedisp, dev); struct linedisp *linedisp = to_linedisp(dev);
int err; int err;
err = linedisp_display(linedisp, buf, count); err = linedisp_display(linedisp, buf, count);
@ -161,10 +252,20 @@ static ssize_t message_store(struct device *dev, struct device_attribute *attr,
static DEVICE_ATTR_RW(message); static DEVICE_ATTR_RW(message);
static ssize_t num_chars_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct linedisp *linedisp = to_linedisp(dev);
return sysfs_emit(buf, "%u\n", linedisp->num_chars);
}
static DEVICE_ATTR_RO(num_chars);
static ssize_t scroll_step_ms_show(struct device *dev, static ssize_t scroll_step_ms_show(struct device *dev,
struct device_attribute *attr, char *buf) struct device_attribute *attr, char *buf)
{ {
struct linedisp *linedisp = container_of(dev, struct linedisp, dev); struct linedisp *linedisp = to_linedisp(dev);
return sysfs_emit(buf, "%u\n", jiffies_to_msecs(linedisp->scroll_rate)); return sysfs_emit(buf, "%u\n", jiffies_to_msecs(linedisp->scroll_rate));
} }
@ -173,7 +274,7 @@ static ssize_t scroll_step_ms_store(struct device *dev,
struct device_attribute *attr, struct device_attribute *attr,
const char *buf, size_t count) const char *buf, size_t count)
{ {
struct linedisp *linedisp = container_of(dev, struct linedisp, dev); struct linedisp *linedisp = to_linedisp(dev);
unsigned int ms; unsigned int ms;
int err; int err;
@ -181,12 +282,12 @@ static ssize_t scroll_step_ms_store(struct device *dev,
if (err) if (err)
return err; return err;
timer_delete_sync(&linedisp->timer);
linedisp->scroll_rate = msecs_to_jiffies(ms); linedisp->scroll_rate = msecs_to_jiffies(ms);
if (linedisp->message && linedisp->message_len > linedisp->num_chars) {
timer_delete_sync(&linedisp->timer); if (should_scroll(linedisp))
if (linedisp->scroll_rate) linedisp_scroll(&linedisp->timer);
linedisp_scroll(&linedisp->timer);
}
return count; return count;
} }
@ -195,7 +296,7 @@ static DEVICE_ATTR_RW(scroll_step_ms);
static ssize_t map_seg_show(struct device *dev, struct device_attribute *attr, char *buf) static ssize_t map_seg_show(struct device *dev, struct device_attribute *attr, char *buf)
{ {
struct linedisp *linedisp = container_of(dev, struct linedisp, dev); struct linedisp *linedisp = to_linedisp(dev);
struct linedisp_map *map = linedisp->map; struct linedisp_map *map = linedisp->map;
memcpy(buf, &map->map, map->size); memcpy(buf, &map->map, map->size);
@ -205,7 +306,7 @@ static ssize_t map_seg_show(struct device *dev, struct device_attribute *attr, c
static ssize_t map_seg_store(struct device *dev, struct device_attribute *attr, static ssize_t map_seg_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count) const char *buf, size_t count)
{ {
struct linedisp *linedisp = container_of(dev, struct linedisp, dev); struct linedisp *linedisp = to_linedisp(dev);
struct linedisp_map *map = linedisp->map; struct linedisp_map *map = linedisp->map;
if (count != map->size) if (count != map->size)
@ -223,6 +324,7 @@ static DEVICE_ATTR(map_seg14, 0644, map_seg_show, map_seg_store);
static struct attribute *linedisp_attrs[] = { static struct attribute *linedisp_attrs[] = {
&dev_attr_message.attr, &dev_attr_message.attr,
&dev_attr_num_chars.attr,
&dev_attr_scroll_step_ms.attr, &dev_attr_scroll_step_ms.attr,
&dev_attr_map_seg7.attr, &dev_attr_map_seg7.attr,
&dev_attr_map_seg14.attr, &dev_attr_map_seg14.attr,
@ -232,7 +334,7 @@ static struct attribute *linedisp_attrs[] = {
static umode_t linedisp_attr_is_visible(struct kobject *kobj, struct attribute *attr, int n) static umode_t linedisp_attr_is_visible(struct kobject *kobj, struct attribute *attr, int n)
{ {
struct device *dev = kobj_to_dev(kobj); struct device *dev = kobj_to_dev(kobj);
struct linedisp *linedisp = container_of(dev, struct linedisp, dev); struct linedisp *linedisp = to_linedisp(dev);
struct linedisp_map *map = linedisp->map; struct linedisp_map *map = linedisp->map;
umode_t mode = attr->mode; umode_t mode = attr->mode;
@ -263,7 +365,7 @@ static DEFINE_IDA(linedisp_id);
static void linedisp_release(struct device *dev) static void linedisp_release(struct device *dev)
{ {
struct linedisp *linedisp = container_of(dev, struct linedisp, dev); struct linedisp *linedisp = to_linedisp(dev);
kfree(linedisp->map); kfree(linedisp->map);
kfree(linedisp->message); kfree(linedisp->message);
@ -320,6 +422,90 @@ static int linedisp_init_map(struct linedisp *linedisp)
#define LINEDISP_INIT_TEXT "Linux " UTS_RELEASE " " #define LINEDISP_INIT_TEXT "Linux " UTS_RELEASE " "
#endif #endif
/**
* linedisp_attach - attach a character line display
* @linedisp: pointer to character line display structure
* @dev: pointer of the device to attach to
* @num_chars: the number of characters that can be displayed
* @ops: character line display operations
*
* Directly attach the line-display sysfs attributes to the passed device.
* The caller is responsible for calling linedisp_detach() to release resources
* after use.
*
* Return: zero on success, else a negative error code.
*/
int linedisp_attach(struct linedisp *linedisp, struct device *dev,
unsigned int num_chars, const struct linedisp_ops *ops)
{
int err;
memset(linedisp, 0, sizeof(*linedisp));
linedisp->ops = ops;
linedisp->num_chars = num_chars;
linedisp->scroll_rate = DEFAULT_SCROLL_RATE;
linedisp->buf = kzalloc(linedisp->num_chars, GFP_KERNEL);
if (!linedisp->buf)
return -ENOMEM;
/* initialise a character mapping, if required */
err = linedisp_init_map(linedisp);
if (err)
goto out_free_buf;
/* initialise a timer for scrolling the message */
timer_setup(&linedisp->timer, linedisp_scroll, 0);
err = create_attachment(dev, linedisp, true);
if (err)
goto out_del_timer;
/* display a default message */
err = linedisp_display(linedisp, LINEDISP_INIT_TEXT, -1);
if (err)
goto out_del_attach;
/* add attribute groups to target device */
err = device_add_groups(dev, linedisp_groups);
if (err)
goto out_del_attach;
return 0;
out_del_attach:
delete_attachment(dev, true);
out_del_timer:
timer_delete_sync(&linedisp->timer);
out_free_buf:
kfree(linedisp->buf);
return err;
}
EXPORT_SYMBOL_NS_GPL(linedisp_attach, "LINEDISP");
/**
* linedisp_detach - detach a character line display
* @dev: pointer of the device to detach from, that was previously
* attached with linedisp_attach()
*/
void linedisp_detach(struct device *dev)
{
struct linedisp *linedisp;
linedisp = delete_attachment(dev, true);
if (!linedisp)
return;
timer_delete_sync(&linedisp->timer);
device_remove_groups(dev, linedisp_groups);
kfree(linedisp->map);
kfree(linedisp->message);
kfree(linedisp->buf);
}
EXPORT_SYMBOL_NS_GPL(linedisp_detach, "LINEDISP");
/** /**
* linedisp_register - register a character line display * linedisp_register - register a character line display
* @linedisp: pointer to character line display structure * @linedisp: pointer to character line display structure
@ -327,6 +513,11 @@ static int linedisp_init_map(struct linedisp *linedisp)
* @num_chars: the number of characters that can be displayed * @num_chars: the number of characters that can be displayed
* @ops: character line display operations * @ops: character line display operations
* *
* Register the line-display sysfs attributes to a new device named
* "linedisp.N" added to the passed parent device.
* The caller is responsible for calling linedisp_unregister() to release
* resources after use.
*
* Return: zero on success, else a negative error code. * Return: zero on success, else a negative error code.
*/ */
int linedisp_register(struct linedisp *linedisp, struct device *parent, int linedisp_register(struct linedisp *linedisp, struct device *parent,
@ -362,19 +553,23 @@ int linedisp_register(struct linedisp *linedisp, struct device *parent,
/* initialise a timer for scrolling the message */ /* initialise a timer for scrolling the message */
timer_setup(&linedisp->timer, linedisp_scroll, 0); timer_setup(&linedisp->timer, linedisp_scroll, 0);
err = device_add(&linedisp->dev); err = create_attachment(&linedisp->dev, linedisp, false);
if (err) if (err)
goto out_del_timer; goto out_del_timer;
/* display a default message */ /* display a default message */
err = linedisp_display(linedisp, LINEDISP_INIT_TEXT, -1); err = linedisp_display(linedisp, LINEDISP_INIT_TEXT, -1);
if (err) if (err)
goto out_del_dev; goto out_del_attach;
err = device_add(&linedisp->dev);
if (err)
goto out_del_attach;
return 0; return 0;
out_del_dev: out_del_attach:
device_del(&linedisp->dev); delete_attachment(&linedisp->dev, false);
out_del_timer: out_del_timer:
timer_delete_sync(&linedisp->timer); timer_delete_sync(&linedisp->timer);
out_put_device: out_put_device:
@ -391,6 +586,7 @@ EXPORT_SYMBOL_NS_GPL(linedisp_register, "LINEDISP");
void linedisp_unregister(struct linedisp *linedisp) void linedisp_unregister(struct linedisp *linedisp)
{ {
device_del(&linedisp->dev); device_del(&linedisp->dev);
delete_attachment(&linedisp->dev, false);
timer_delete_sync(&linedisp->timer); timer_delete_sync(&linedisp->timer);
put_device(&linedisp->dev); put_device(&linedisp->dev);
} }

4
drivers/auxdisplay/line-display.h
View File

@ -6,6 +6,7 @@
* Author: Paul Burton <paul.burton@mips.com> * Author: Paul Burton <paul.burton@mips.com>
* *
* Copyright (C) 2021 Glider bv * Copyright (C) 2021 Glider bv
* Copyright (C) 2025 Jean-François Lessard
*/ */
#ifndef _LINEDISP_H #ifndef _LINEDISP_H
@ -81,6 +82,9 @@ struct linedisp {
unsigned int id; unsigned int id;
}; };
int linedisp_attach(struct linedisp *linedisp, struct device *dev,
unsigned int num_chars, const struct linedisp_ops *ops);
void linedisp_detach(struct device *dev);
int linedisp_register(struct linedisp *linedisp, struct device *parent, int linedisp_register(struct linedisp *linedisp, struct device *parent,
unsigned int num_chars, const struct linedisp_ops *ops); unsigned int num_chars, const struct linedisp_ops *ops);
void linedisp_unregister(struct linedisp *linedisp); void linedisp_unregister(struct linedisp *linedisp);