diff --git a/ledmon-0.93.tar.gz b/ledmon-0.93.tar.gz new file mode 100644 index 0000000..414238c --- /dev/null +++ b/ledmon-0.93.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:26570aee3f98a4eb47e0d9f92bd9d2d2efa3385b0e9be23e60daba54471d276c +size 76411 diff --git a/ledmon-amd_sgpio.patch b/ledmon-amd_sgpio.patch new file mode 100644 index 0000000..3f0eb4c --- /dev/null +++ b/ledmon-amd_sgpio.patch @@ -0,0 +1,322 @@ +From d4687596f64190afd772bfd5404e56b411424eab Mon Sep 17 00:00:00 2001 +From: Nathan Fontenot +Date: Mon, 2 Dec 2019 10:59:04 -0600 +Subject: [PATCH] amd_sgpio: Correct use of packed structs + +With gcc-9 the -Waddress-of-packed-member flag is enabled by default to +prevent access to unaligned members of a struct on systems that do not +support unaligned accesses. + +To correct this the amd_sgpio code is updated to no longer use pointers +to packed structures. + +Signed-off-by: Nathan Fontenot +--- + src/amd_sgpio.c | 220 +++++++++++++++++++++++------------------------- + 1 file changed, 105 insertions(+), 115 deletions(-) + +diff --git a/src/amd_sgpio.c b/src/amd_sgpio.c +index 8150e4c..efe1c26 100644 +--- a/src/amd_sgpio.c ++++ b/src/amd_sgpio.c +@@ -330,112 +330,114 @@ static int _send_sgpio_register(const char *em_buffer_path, void *reg, + return 0; + } + +-static void _init_sgpio_hdr(sgpio_hdr_t *hdr, int data_size, int msg_size) ++static sgpio_hdr_t _init_sgpio_hdr(int data_size, int msg_size) + { +- memset(hdr, 0, sizeof(*hdr)); ++ sgpio_hdr_t hdr = 0; + +- set_sgpio_hdr_msg_type(hdr, SGPIO_HDR_MSG_TYPE_SGPIO); +- set_sgpio_hdr_data_size(hdr, data_size); +- set_sgpio_hdr_msg_size(hdr, msg_size); ++ set_sgpio_hdr_msg_type(&hdr, SGPIO_HDR_MSG_TYPE_SGPIO); ++ set_sgpio_hdr_data_size(&hdr, data_size); ++ set_sgpio_hdr_msg_size(&hdr, msg_size); ++ ++ return hdr; + } + +-static void _dump_sgpio_hdr(sgpio_hdr_t *hdr) ++static void _dump_sgpio_hdr(const char *type, sgpio_hdr_t hdr) + { +- log_debug("SGPIO Header\n"); +- log_debug(REG_FMT_2, "message type", get_sgpio_hdr_msg_type(hdr), +- "data size", get_sgpio_hdr_data_size(hdr)); +- log_debug(REG_FMT_1, "message size", get_sgpio_hdr_msg_size(hdr)); ++ log_debug("%s SGPIO Header: %08x\n", type, hdr); ++ log_debug(REG_FMT_2, "message type", get_sgpio_hdr_msg_type(&hdr), ++ "data size", get_sgpio_hdr_data_size(&hdr)); ++ log_debug(REG_FMT_1, "message size", get_sgpio_hdr_msg_size(&hdr)); + } + +-static void _init_sgpio_req(sgpio_req_t *req, int frame_type, int function, +- int reg_type, int reg_index, int reg_count) ++static sgpio_req_t _init_sgpio_req(int frame_type, int function, ++ int reg_type, int reg_index, ++ int reg_count) + { +- memset(req, 0, sizeof(*req)); ++ sgpio_req_t req = 0; ++ ++ set_sgpio_req_frame_type(&req, frame_type); ++ set_sgpio_req_function(&req, function); ++ set_sgpio_req_reg_type(&req, reg_type); ++ set_sgpio_req_reg_index(&req, reg_index); ++ set_sgpio_req_reg_count(&req, reg_count); + +- set_sgpio_req_frame_type(req, frame_type); +- set_sgpio_req_function(req, function); +- set_sgpio_req_reg_type(req, reg_type); +- set_sgpio_req_reg_index(req, reg_index); +- set_sgpio_req_reg_count(req, reg_count); ++ return req; + } + +-static void _dump_sgpio_req(sgpio_req_t *req) ++static void _dump_sgpio_req(const char *type, sgpio_req_t req) + { +- log_debug("SGPIO Request Register:\n"); +- log_debug(REG_FMT_2, "frame type", get_sgpio_req_frame_type(req), +- "function", get_sgpio_req_function(req)); +- log_debug(REG_FMT_2, "register type", get_sgpio_req_reg_type(req), +- "register index", get_sgpio_req_reg_index(req)); +- log_debug(REG_FMT_1, "register count", get_sgpio_req_reg_count(req)); ++ uint32_t *r = (uint32_t *)&req; ++ ++ log_debug("%s SGPIO Request Register: %08x %08x\n", type, r[0], r[1]); ++ log_debug(REG_FMT_2, "frame type", get_sgpio_req_frame_type(&req), ++ "function", get_sgpio_req_function(&req)); ++ log_debug(REG_FMT_2, "register type", get_sgpio_req_reg_type(&req), ++ "register index", get_sgpio_req_reg_index(&req)); ++ log_debug(REG_FMT_1, "register count", get_sgpio_req_reg_count(&req)); + } + +-static void _init_sgpio_cfg(sgpio_cfg_t *cfg, int gpio_enable, int blink_a, +- int blink_b, int force_off, int max_on, +- int stretch_off, int stretch_on) ++static sgpio_cfg_t _init_sgpio_cfg(int gpio_enable, int blink_a, ++ int blink_b, int force_off, int max_on, ++ int stretch_off, int stretch_on) + { +- memset(cfg, 0, sizeof(*cfg)); ++ sgpio_cfg_t cfg = 0; + + if (gpio_enable) +- set_sgpio_cfg_gpio_enable(cfg, 1); +- +- set_sgpio_cfg_blink_gen_a(cfg, blink_a); +- set_sgpio_cfg_blink_gen_b(cfg, blink_b); +- set_sgpio_cfg_max_on(cfg, max_on); +- set_sgpio_cfg_force_off(cfg, force_off); +- set_sgpio_cfg_stretch_on(cfg, stretch_on); +- set_sgpio_cfg_stretch_off(cfg, stretch_off); ++ set_sgpio_cfg_gpio_enable(&cfg, 1); ++ ++ set_sgpio_cfg_blink_gen_a(&cfg, blink_a); ++ set_sgpio_cfg_blink_gen_b(&cfg, blink_b); ++ set_sgpio_cfg_max_on(&cfg, max_on); ++ set_sgpio_cfg_force_off(&cfg, force_off); ++ set_sgpio_cfg_stretch_on(&cfg, stretch_on); ++ set_sgpio_cfg_stretch_off(&cfg, stretch_off); ++ ++ return cfg; + } + +-static void _dump_sgpio_cfg(sgpio_cfg_t *cfg) ++static void _dump_sgpio_cfg(const char *type, sgpio_cfg_t cfg) + { +- log_debug("SGPIO Configuration Register:\n"); +- log_debug(REG_FMT_2, "version", get_sgpio_cfg_version(cfg), +- "gp register count", get_sgpio_cfg_gp_reg_count(cfg)); ++ uint32_t *r = (uint32_t *)&cfg; ++ ++ log_debug("%s SGPIO Configuration Register: %08x %08x\n", type, ++ r[0], r[1]); ++ log_debug(REG_FMT_2, "version", get_sgpio_cfg_version(&cfg), ++ "gp register count", get_sgpio_cfg_gp_reg_count(&cfg)); + log_debug(REG_FMT_2, "cfg register count", +- get_sgpio_cfg_cfg_reg_count(cfg), "gpio enabled", +- get_sgpio_cfg_gpio_enable(cfg)); +- log_debug(REG_FMT_2, "drive count", get_sgpio_cfg_drive_count(cfg), +- "blink gen rate A", get_sgpio_cfg_blink_gen_a(cfg)); ++ get_sgpio_cfg_cfg_reg_count(&cfg), "gpio enabled", ++ get_sgpio_cfg_gpio_enable(&cfg)); ++ log_debug(REG_FMT_2, "drive count", get_sgpio_cfg_drive_count(&cfg), ++ "blink gen rate A", get_sgpio_cfg_blink_gen_a(&cfg)); + + log_debug(REG_FMT_2, "blink gen rate B", +- get_sgpio_cfg_blink_gen_b(cfg), "force activity off", +- get_sgpio_cfg_force_off(cfg)); +- log_debug(REG_FMT_2, "max activity on", get_sgpio_cfg_max_on(cfg), +- "stretch activity off", get_sgpio_cfg_stretch_off(cfg)); ++ get_sgpio_cfg_blink_gen_b(&cfg), "force activity off", ++ get_sgpio_cfg_force_off(&cfg)); ++ log_debug(REG_FMT_2, "max activity on", get_sgpio_cfg_max_on(&cfg), ++ "stretch activity off", get_sgpio_cfg_stretch_off(&cfg)); + log_debug(REG_FMT_1, "stretch activity on", +- get_sgpio_cfg_stretch_on(cfg)); ++ get_sgpio_cfg_stretch_on(&cfg)); + } + +-static void _init_sgpio_amd(sgpio_amd_t *amd, int initiator, int polarity, +- int bypass, int normal) ++static sgpio_amd_t _init_sgpio_amd(int initiator, int polarity, ++ int bypass, int normal) + { +- memset(amd, 0, sizeof(*amd)); ++ sgpio_amd_t amd = 0; + +- set_sgpio_amd_initiator(amd, initiator); +- set_sgpio_amd_polarity_flip(amd, polarity); +- set_sgpio_amd_bypass_enable(amd, bypass); +- set_sgpio_amd_return_to_normal(amd, normal); +-} ++ set_sgpio_amd_initiator(&amd, initiator); ++ set_sgpio_amd_polarity_flip(&amd, polarity); ++ set_sgpio_amd_bypass_enable(&amd, bypass); ++ set_sgpio_amd_return_to_normal(&amd, normal); + +-static void _dump_sgpio_amd(sgpio_amd_t *amd) +-{ +- log_debug("SGPIO AMD Register\n"); +- log_debug(REG_FMT_2, "initiator", get_sgpio_amd_initiator(amd), +- "polarity", get_sgpio_amd_polarity_flip(amd)); +- log_debug(REG_FMT_2, "bypass enable", get_sgpio_amd_bypass_enable(amd), +- "return to normal", get_sgpio_amd_return_to_normal(amd)); ++ return amd; + } + +-static void _dump_cfg_register(struct config_register *cfg_reg) ++static void _dump_sgpio_amd(const char *type, sgpio_amd_t amd) + { +- uint32_t *reg = (uint32_t *)cfg_reg; +- +- log_info("CFG Register: %08x %08x %08x %08x %08x", +- reg[0], reg[1], reg[2], reg[3], reg[4]); +- +- _dump_sgpio_hdr(&cfg_reg->hdr); +- _dump_sgpio_req(&cfg_reg->req); +- _dump_sgpio_cfg(&cfg_reg->cfg); ++ log_debug("%s SGPIO AMD Register: %08x\n", type, amd); ++ log_debug(REG_FMT_2, "initiator", get_sgpio_amd_initiator(&amd), ++ "polarity", get_sgpio_amd_polarity_flip(&amd)); ++ log_debug(REG_FMT_2, "bypass enable", get_sgpio_amd_bypass_enable(&amd), ++ "return to normal", get_sgpio_amd_return_to_normal(&amd)); + } + + static int _write_cfg_register(const char *em_buffer_path, +@@ -443,53 +445,49 @@ static int _write_cfg_register(const char *em_buffer_path, + { + struct config_register cfg_reg; + +- _init_sgpio_hdr(&cfg_reg.hdr, 0, sizeof(cfg_reg)); +- _init_sgpio_req(&cfg_reg.req, 0x40, 0x82, SGPIO_REQ_REG_TYPE_CFG, 0, 2); ++ cfg_reg.hdr = _init_sgpio_hdr(0, sizeof(cfg_reg)); ++ cfg_reg.req = _init_sgpio_req(0x40, 0x82, SGPIO_REQ_REG_TYPE_CFG, ++ 0, 2); + + if (cache->blink_gen_a) + cache->blink_gen_b = ibpi_pattern[ibpi]; + else + cache->blink_gen_a = ibpi_pattern[ibpi]; + +- _init_sgpio_cfg(&cfg_reg.cfg, 1, cache->blink_gen_a, cache->blink_gen_b, +- 2, 1, 0, 0); ++ cfg_reg.cfg = _init_sgpio_cfg(1, cache->blink_gen_a, ++ cache->blink_gen_b, 2, 1, 0, 0); ++ ++ _dump_sgpio_hdr("CFG", cfg_reg.hdr); ++ _dump_sgpio_req("CFG", cfg_reg.req); ++ _dump_sgpio_cfg("CFG", cfg_reg.cfg); + +- _dump_cfg_register(&cfg_reg); + return _send_sgpio_register(em_buffer_path, &cfg_reg, sizeof(cfg_reg)); + } + +-static void _dump_sgpio_tx(sgpio_tx_t *tx) ++static void _dump_sgpio_tx(const char *type, sgpio_tx_t tx) + { + int i; + +- log_debug("SGPIO TX Register:\n"); ++ log_debug("%s SGPIO TX Register: %08x\n", type, tx); + for (i = 0; i < 4; i++) { + log_debug("\tdrive %d: error %x, locate %x, activity %x\n", i, +- get_error_led(&tx->drive[i]), +- get_locate_led(&tx->drive[i]), +- get_activity_led(&tx->drive[i])); ++ get_error_led(&tx.drive[i]), ++ get_locate_led(&tx.drive[i]), ++ get_activity_led(&tx.drive[i])); + } + } + +-static void _dump_tx_register(struct transmit_register *tx_reg) +-{ +- uint32_t *reg = (uint32_t *)tx_reg; +- +- log_info("TX Register: %08x %08x %08x %08x", reg[0], reg[1], +- reg[2], reg[3]); +- +- _dump_sgpio_hdr(&tx_reg->hdr); +- _dump_sgpio_req(&tx_reg->req); +- _dump_sgpio_tx(&tx_reg->tx); +-} +- + static int _write_tx_register(const char *em_buffer_path, + struct transmit_register *tx_reg) + { +- _init_sgpio_hdr(&tx_reg->hdr, 0, sizeof(*tx_reg)); +- _init_sgpio_req(&tx_reg->req, 0x40, 0x82, SGPIO_REQ_REG_TYPE_TX, 0, 1); ++ tx_reg->hdr = _init_sgpio_hdr(0, sizeof(*tx_reg)); ++ tx_reg->req = _init_sgpio_req(0x40, 0x82, SGPIO_REQ_REG_TYPE_TX, ++ 0, 1); ++ ++ _dump_sgpio_hdr("TX", tx_reg->hdr); ++ _dump_sgpio_req("TX", tx_reg->req); ++ _dump_sgpio_tx("TX", tx_reg->tx); + +- _dump_tx_register(tx_reg); + return _send_sgpio_register(em_buffer_path, tx_reg, sizeof(*tx_reg)); + } + +@@ -538,28 +536,20 @@ static int _init_tx_drive_leds(struct transmit_register *tx_reg, + return init_done; + } + +-static void _dump_amd_register(struct amd_register *amd_reg) +-{ +- uint32_t *reg = (uint32_t *)amd_reg; +- +- log_info("AMD Register: %08x %08x %08x %08x", reg[0], reg[1], +- reg[2], reg[3]); +- +- _dump_sgpio_hdr(&amd_reg->hdr); +- _dump_sgpio_req(&amd_reg->req); +- _dump_sgpio_amd(&amd_reg->amd); +-} +- + static int _write_amd_register(const char *em_buffer_path, + struct amd_drive *drive) + { + struct amd_register amd_reg; + +- _init_sgpio_hdr(&amd_reg.hdr, 0, sizeof(amd_reg)); +- _init_sgpio_req(&amd_reg.req, 0x40, 0x82, SGPIO_REQ_REG_TYPE_AMD, 0, 1); +- _init_sgpio_amd(&amd_reg.amd, drive->initiator, 0, 1, 1); ++ amd_reg.hdr = _init_sgpio_hdr(0, sizeof(amd_reg)); ++ amd_reg.req = _init_sgpio_req(0x40, 0x82, SGPIO_REQ_REG_TYPE_AMD, ++ 0, 1); ++ amd_reg.amd = _init_sgpio_amd(drive->initiator, 0, 1, 1); ++ ++ _dump_sgpio_hdr("AMD", amd_reg.hdr); ++ _dump_sgpio_req("AMD", amd_reg.req); ++ _dump_sgpio_amd("AMD", amd_reg.amd); + +- _dump_amd_register(&amd_reg); + return _send_sgpio_register(em_buffer_path, &amd_reg, sizeof(amd_reg)); + } + diff --git a/ledmon.changes b/ledmon.changes index 91c6de8..61295bf 100644 --- a/ledmon.changes +++ b/ledmon.changes @@ -1,3 +1,10 @@ +------------------------------------------------------------------- +Tue Dec 17 08:46:55 UTC 2019 - Martin Pluskal + +- Fix download url +- Fix jira reference in changelog +- Add ledmon-amd_sgpio.patch to fix issues with building on TW + ------------------------------------------------------------------- Wed Dec 11 09:32:32 UTC 2019 - Martin Pluskal @@ -6,7 +13,7 @@ Wed Dec 11 09:32:32 UTC 2019 - Martin Pluskal ------------------------------------------------------------------- Wed Dec 11 03:05:00 UTC 2019 - heming.zhao@suse.com -- Update to version 0.93 per https://jira.suse.com/browse/SLE-8004 +- Update to version 0.93 per jsc#SLE-8004 * modified spec file according to changes in source code - Enhancements diff --git a/ledmon.spec b/ledmon.spec index 3f1cada..32a91b4 100644 --- a/ledmon.spec +++ b/ledmon.spec @@ -23,7 +23,9 @@ Summary: Enclosure LED Utilities License: GPL-2.0-only Group: Hardware/Other URL: https://github.com/intel/ledmon/ -Source0: https://github.com/intel/ledmon/archive/v%{version}.tar.gz +Source0: https://github.com/intel/ledmon/archive/%{version}.tar.gz#/%{name}-%{version}.tar.gz +# PATCH-FEATURE-UPSTREAM ledmon-amd_sgpio.patch +Patch0: ledmon-amd_sgpio.patch BuildRequires: autoconf BuildRequires: automake BuildRequires: libsgutils-devel @@ -41,7 +43,7 @@ ControlUtilities. They help to enable LED management for software RAID solutions. %prep -%setup -q +%autosetup -p1 %build %define _lto_cflags %{nil} diff --git a/v0.93.tar.gz b/v0.93.tar.gz deleted file mode 100644 index 271a743..0000000 --- a/v0.93.tar.gz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:5e74804e74491096c771016dd78e7e0f935defb99383bcf7f19cf5d5e308abcf -size 80027