[PATCH 0/7] misc: introduce STATUS LED activity function

[Quentin Schulz]

Hi Christian,

On 6/6/24 11:52 AM, Christian Marangi wrote:
> On Thu, Jun 06, 2024 at 11:12:11AM +0200, Quentin Schulz wrote:
>> Hi Christian,
>>
>> On 6/5/24 9:21 PM, Christian Marangi wrote:
>>> This series expand the STATUS LED framework with a new color
>>> and a big new feature. One thing that many device need is a way
>>> to communicate to the user that the device is actually doing
>>> something.
>>>
>>> This is especially useful for recovery steps where an
>>> user (for example) insert an USB drive, keep a button pressed
>>> and the device autorecover.
>>>
>>> There is currently no way to signal the user externally that
>>> the bootloader is processing/recoverying aside from setting
>>> a LED on.
>>>
>>> A solid LED on is not enough and won't actually signal any
>>> kind of progress.
>>> Solution is the good old blinking LED but uboot doesn't
>>> suggest (and support) interrupts and almost all the LED
>>> are usually GPIO LED that doesn't support HW blink.
>>>
>>
>> I haven't used it yet but we do have a cyclic framework now for things
>> happening in the background. I think this is a good use-case for this
>> framework? Something would set the blinking frequency (could be from CLI
>> directly, or as part of board files, or architecture, etc...) and the LED
>> would just blink then. This would allow to highlight stages in the boot
>> process, though that is not like an activity LED so if you're stuck in a
>> stage, you wouldn't know if something is still happening or if you're really
>> stuck (e.g. no packet on TFTP or TFTP very slow). The benefit is that it
>> would be way less intrusive than patching all commands that could make use
>> of that LED. Right now, this only adds support to MTD, SPI and TFTP, but
>> what about MMC, NVMe, USB, other net stuff (e.g. wget), etc...
>>
> 
> Can you hint me on where is this framework? Checking the tftp code i
> couldn't find extra call to it. Maybe it's attached to the schedule()
> function?
> 

https://docs.u-boot.org/en/latest/develop/cyclic.html

> Also notice that it's really not a one setting since almost all device
> have GPIO LEDs and doesn't have a way to support HW Blink so the
> "activity" function needs to be called multiple time to increase the
> counter and toggle the LED.
> 

Cyclic callback would be called twice per expected blink period, where 
you would toggle the GPIO (essentially making it 50% duty cycle, but 
could be more fine-grained if you want a different duty cycle).

> Also this have the extra feature that you can check if something gets
> stuck in the process. The lifecycle is:
> - Turn on the ACTIVITY LED at the start of the thing
> - Blink once in a while (for very little task this might not happen)
> - Turn off the ACTIVITY LED at the end of the thing
> 
> Soo if something goes wrong the LED would never turn OFF but would stay
> solid ON.
> 

Yes, that's something that wouldn't be covered by cyclic framework here. 
It all depends what you want to do, if it's an activity LED, then we 
need to hook ourselves deep into frameworks where stuff is actually 
happening. If it's just to specify which stage of the boot we reached, 
then cyclic would be good enough probably (register for stage 1, 
unregister stage1+register for stage2 for different frequency, etc...).

> More than happy to rework this to a less intrusive implementation.
> 
> Maybe this can be generalized to some generic API like task_start(),
> task_processing() and task_end()? Might make more sense than having to
> add specific LED function to each function?
> 

This also likely would introduce a hit in performance if we need to 
toggle the GPIO in the same thread that we do TFTP/storage medium 
reading/writing? I assume we could still adapt cyclic to make it spawn a 
one time event instead of looping (e.g. by unregistering itself at the 
end of its own callback?).

> (AFAIK linux kernel have something similar used for all the trace
> framework so having something in uboot to trace these kind of operation
> might be interesting)
> 

Indeed, that's what's being done with ledtrig_.* functions, they are 
however scheduled on a workqueue and called from the subsystem directly.

I'm a bit confused also as to why we control the LED blinking from the 
cmd/ ? E.g. for cmd/mtd.c I would assume that the changes made to the 
mtd subsystem should be enough to handle those? Similarly, since UBI is 
for use over NAND/MTD, shouldn't that already be handled by the MTD 
subsystem, and if not, why not in the UBI subsystem instead of the 
CMD_UBI? One of the issues is that you may not necessarily go through 
the cmd/ to do stuff with storage medium or network (e.g. directly from 
board files).

For the net protocols, why not hook this to the net_[sg]et_*_handler for 
example so it's protocol-agnostic? No clue how difficult this would be, 
or if you'd rather have something like per-protocol activity?

Finally, maybe we also want to have a Kconfig symbol per "type" of 
activity to control what should be "monitored", and I would also suggest 
if we go this route to have a Kconfig symbol for the frequency per 
"type" of activity as well, so that one can know which activity is 
happening right now.

Nothing against this patch series or its current implementation, just 
throwing ideas :)

Cheers,
Quentin