tree 15e1e732a57e1517bf1a11445a5c860e6f89f21f
parent ebff85d320dc2e99c5c682b678a6ae0ea291c043
author HuyLe <hule@amperecomputing.com> 1662351942 +0000
committer Thang Q. Nguyen <thang@os.amperecomputing.com> 1663651490 +0700

meta-ampere: mtjade: handle UID button via phosphor-buttons

Replace Ampere implementation for UID button by the use of
phosphor-button.

Tested:
1. By default, the UID LED status is OFF.
 - Press UID button and check if the UID LED is ON
 - Press UID button again and check if the UID LED is OFF
2. Turn on the UID LED via ipmi command
 $ ipmitool chassis identify
3. Turn Lit/Blinking/Off UID LED via Redfish:
 $ curl -X PATCH --user root:0penBmc -H "Content-Type: application/json"
     -H "If-Match: *" --insecure https://<bmc_ip>/redfish/v1/Systems/system
     -d '{"IndicatorLED": "Lit|Blinking|Off"}'
 --> check if the UID LED is ON, blinking or OFF, respectively

Signed-off-by: HuyLe <hule@amperecomputing.com>
Change-Id: I912e26be827167a201dad5d81be6728101405521
