ledmon/0001-Ledctl-slots-management-94.patch

From a56e8bf096c04ea0c76ca026e07402f05ce58ca4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Kinga=20Ta=C5=84ska?= <kinga.tanska@intel.com>
Date: Tue, 14 Jun 2022 12:11:45 +0200
Subject: [PATCH 1/2] Ledctl - slots management (#94)

* ledctl: add commands to support empty slots blinking
* ledctl: --get-slot implementation for vmd
* ledctl: --list-slots implementation for vmd
* ledctl: --set-slot implementation for vmd
* ledctl: --get-slot implementation for npem
* ledctl: --list-slots implementation for npem
* ledctl: --set-slot implementation for npem

Add new interface which allows to read or modify led state for devices
by controller's slots. It allows to manage empty slots in cases where:
- drive is not connected.
- drive is connected, but non-standard driver is used (uio, vfio).

Slot identifier will used to manage led state. Following commands are added:
--get-slot
--list-slots
--set-slot
Support for VMD and NPEM is added.

Signed-off-by: Kinga Tanska <kinga.tanska@intel.com>
---
 doc/ledctl.pod  |  36 ++++++
 src/Makefile.am |   2 +-
 src/block.c     |  12 ++
 src/block.h     |  15 ++-
 src/ledctl.c    | 329 ++++++++++++++++++++++++++++++++++++++++++++++--
 src/npem.c      | 145 ++++++++++++++++++---
 src/npem.h      |  28 +++++
 src/pci_slot.c  | 102 ++++++++++++++-
 src/pci_slot.h  |  35 +++++-
 src/slot.h      |  63 ++++++++++
 src/sysfs.c     |   1 -
 src/sysfs.h     |   4 +-
 src/utils.c     |  49 +++++++-
 src/utils.h     |  15 ++-
 src/vmdssd.c    |  63 +++++-----
 src/vmdssd.h    |  11 +-
 16 files changed, 833 insertions(+), 77 deletions(-)
 create mode 100644 src/slot.h

diff --git a/doc/ledctl.pod b/doc/ledctl.pod
index 774d04b2b0e2..a0da95e4c734 100644
--- a/doc/ledctl.pod
+++ b/doc/ledctl.pod
@@ -324,6 +324,42 @@ Displays version of ledctl and information about the license and exits.
 Prints information (system path and type) of all controllers detected by
 ledmon and exits.
 
+=item B<-P> or B<--list-slots> B<--controller>=I<controller>
+
+Prints all slots for the controller. Slot definition depends on the controller
+and is unique across all controllers of the same type.
+
+Definitions for supported controllers are described below:
+
+=over
+
+=item
+
+VMD - PCI Express Hot Plug Controller Driver slot number
+
+=item
+
+NPEM - PCI Express Downstream Port address
+
+=back
+
+Command returns a list of all slots for the controller with current state and
+attached device name (if any). I<controller> is type of controller
+(vmd, NPEM) that should be scanned here.
+
+=item B<-G> or B<--get-slot> B<--controller>=I<controller> B<--device>=I<device>
+
+Displays slot details of given device. I<device> is devnode of selected drive.
+
+=item B<-G> or B<--get-slot> B<--controller>=I<controller> B<--slot>=I<slot>
+
+Displays details of given slot. I<slot> is unique slot identifier.
+
+=item B<-S> or B<--set-slot> B<--controller>=I<controller> B<--slot>=I<slot> B<--state>=I<IBPI_state>
+
+Changes led state for given slot. I<controller> is type of the controller.
+I<slot> is unique slot identifier. I<IBPI_state> is led pattern.
+
 =item B<-x> or B<--listed-only>
 
 With this option ledctl will change state only on devices listed in CLI. The
diff --git a/src/Makefile.am b/src/Makefile.am
index f7786206a510..34311a2699a7 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -26,7 +26,7 @@ COMMON_SRCS      = ahci.c block.c cntrl.c config_file.c enclosure.c list.c \
                    vmdssd.h ipmi.h amd.h amd_ipmi.h npem.h
 
 LEDMON_SRCS      = ledmon.c pidfile.c $(COMMON_SRCS)
-LEDCTL_SRCS      = ledctl.c $(COMMON_SRCS)
+LEDCTL_SRCS      = ledctl.c slot.h $(COMMON_SRCS)
 
 
 sbin_PROGRAMS  = ledmon ledctl
diff --git a/src/block.c b/src/block.c
index c61c577cb2c8..3d1815cb11a3 100644
--- a/src/block.c
+++ b/src/block.c
@@ -215,6 +215,18 @@ struct _host_type *block_get_host(struct cntrl_device *cntrl, int host_id)
 	return hosts;
 }
 
+struct block_device *get_block_device_from_sysfs_path(char *sub_path)
+{
+	struct block_device *device;
+
+	list_for_each(sysfs_get_block_devices(), device) {
+			if (strstr(device->sysfs_path, sub_path))
+				return device;
+	}
+
+	return NULL;
+}
+
 /*
  * Allocates a new block device structure. See block.h for details.
  */
diff --git a/src/block.h b/src/block.h
index 820f2d72325e..00b9fd73a19d 100644
--- a/src/block.h
+++ b/src/block.h
@@ -1,6 +1,6 @@
 /*
  * Intel(R) Enclosure LED Utilities
- * Copyright (C) 2009-2018 Intel Corporation.
+ * Copyright (C) 2009-2022 Intel Corporation.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -25,6 +25,7 @@
 #include "time.h"
 #include "list.h"
 #include "raid.h"
+#include "status.h"
 
 struct block_device;
 
@@ -227,4 +228,16 @@ struct _host_type *block_get_host(struct cntrl_device *cntrl, int host_id);
 int block_compare(const struct block_device *bd_old,
 		  const struct block_device *bd_new);
 
+/**
+ * @brief Finds block device which name contains sub-path.
+ *
+ * This function scans block devices and checks their sysfs path
+ * to find any which contains PCI address specified for device in path.
+ *
+ * @param[in]        sub_path        Sub path.
+ *
+ * @return first block device containing sub-path if any, otherwise NULL.
+ */
+struct block_device *get_block_device_from_sysfs_path(char *sub_path);
+
 #endif				/* _BLOCK_H_INCLUDED_ */
diff --git a/src/ledctl.c b/src/ledctl.c
index caedc1a4834d..c20986230739 100644
--- a/src/ledctl.c
+++ b/src/ledctl.c
@@ -42,12 +42,13 @@
 #include "cntrl.h"
 #include "config.h"
 #include "config_file.h"
-#include "ibpi.h"
+#include "slot.h"
 #include "list.h"
+#include "npem.h"
+#include "pci_slot.h"
 #include "scsi.h"
 #include "status.h"
 #include "sysfs.h"
-#include "utils.h"
 
 /**
  * @brief An IBPI state structure.
@@ -69,6 +70,73 @@ struct ibpi_state {
  */
 static struct list ibpi_list;
 
+/**
+ * @brief Pointer to a get slot function.
+ *
+ * The pointer to a function which will print slot details.
+ *
+ * @param[in]         device        Name of the device.
+ * @param[in]         slot          Unique identifier of the slot.
+ * @param[in]         res           Pointer to slot response.
+ *
+ * @return STATUS_SUCCESS if successful, otherwise a valid status_t status code.
+ */
+typedef status_t (*get_slot_t) (char *device, char *slot, struct slot_response *res);
+
+/**
+ * @brief Pointer to a set slot function.
+ *
+ * The pointer to a function which will set slot details.
+ *
+ * @param[in]         slot          Unique identifier of the slot.
+ * @param[in]         state         IBPI state based on slot request.
+ *
+ * @return STATUS_SUCCESS if successful, otherwise a valid status_t status code.
+ */
+typedef status_t (*set_slot_t) (char *slot, enum ibpi_pattern state);
+
+/**
+ * @brief slot request parametres
+ *
+ * This structure contains all possible parameters for slot related commands.
+ */
+struct slot_request {
+	/**
+	 * Option given in the request.
+	 */
+	int chosen_opt;
+
+	/**
+	 * Name of the device.
+	 */
+	char device[PATH_MAX];
+
+	/**
+	 * Unique slot identifier.
+	 */
+	char slot[PATH_MAX];
+
+	/**
+	 * Type of the controller.
+	 */
+	enum cntrl_type cntrl;
+
+	/**
+	 * IBPI state.
+	 */
+	enum ibpi_pattern state;
+
+	/**
+	 * Pointer to the get slot function.
+	 */
+	get_slot_t get_slot_fn;
+
+	/**
+	 * Pointer to the set slot function.
+	 */
+	set_slot_t set_slot_fn;
+};
+
 /**
  * @brief IBPI pattern names.
  *
@@ -76,7 +144,7 @@ static struct list ibpi_list;
  * this entries to translate enumeration type values into the string.
  */
 const char *ibpi_str[] = {
-	[IBPI_PATTERN_UNKNOWN]        = "",
+	[IBPI_PATTERN_UNKNOWN]        = "UNKNOWN",
 	[IBPI_PATTERN_NORMAL]         = "NORMAL",
 	[IBPI_PATTERN_ONESHOT_NORMAL] = "",
 	[IBPI_PATTERN_DEGRADED]       = "ICA",
@@ -112,6 +180,13 @@ static int possible_params[] = {
 	OPT_VERSION,
 	OPT_LIST_CTRL,
 	OPT_LISTED_ONLY,
+	OPT_LIST_SLOTS,
+	OPT_GET_SLOT,
+	OPT_SET_SLOT,
+	OPT_CONTROLLER,
+	OPT_DEVICE,
+	OPT_SLOT,
+	OPT_STATE,
 	OPT_ALL,
 	OPT_DEBUG,
 	OPT_ERROR,
@@ -126,6 +201,43 @@ static const int possible_params_size = sizeof(possible_params)
 
 static int listed_only;
 
+enum cntrl_type get_cntrl_type(const char *cntrl)
+{
+	if (strcasecmp(cntrl, "vmd") == 0)
+		return CNTRL_TYPE_VMD;
+	else if (strcasecmp(cntrl, "npem") == 0)
+		return CNTRL_TYPE_NPEM;
+	return CNTRL_TYPE_UNKNOWN;
+}
+
+/**
+ * @brief Determines a slot functions based on controller.
+ *
+ * This function determines slot functions based on
+ * controller type.
+ *
+ * @param[in]       ctrl_type       Controller type.
+ * @param[in]       slot_req        Pointer to the slot request.
+ *
+ * @return This function does not return a value.
+ */
+static void _get_slot_ctrl_fn(enum cntrl_type ctrl_type, struct slot_request *slot_req)
+{
+	switch (ctrl_type) {
+	case CNTRL_TYPE_VMD:
+		slot_req->get_slot_fn = pci_get_slot;
+		slot_req->set_slot_fn = pci_set_slot;
+		break;
+	case CNTRL_TYPE_NPEM:
+		slot_req->get_slot_fn = npem_get_slot;
+		slot_req->set_slot_fn = npem_set_slot;
+		break;
+	default:
+		log_debug("Slot functions could not be set because the controller type %s does not "
+			  "support slots managing.", ctrl_type);
+	}
+}
+
 static void ibpi_state_fini(struct ibpi_state *p)
 {
 	list_clear(&p->block_list);
@@ -186,16 +298,25 @@ static void _ledctl_help(void)
 	       progname);
 	printf("Mandatory arguments for long options are mandatory for short options, too.\n\n");
 	print_opt("--listed-only", "-x",
-			  "Ledctl will change state only for given devices.");
+		  "Ledctl will change state only for given devices.");
 	print_opt("--list-controllers", "-L",
-			  "Displays list of controllers detected by ledmon.");
+		  "Displays list of controllers detected by ledmon.");
+	print_opt("--list-slots --controller CONTROLLER", "-P -c CONTROLLER",
+		  "List slots under the controller, their led states, slot numbers and "
+		  "devnodes connected.");
+	print_opt("--get-slot --controller CONTROLLER --device DEVNODE / --slot SLOT",
+		  "-G -c CONTROLLER -d DEVNODE / -p SLOT",
+		  "Prints slot information, its led state, slot number and devnode.");
+	print_opt("--set-slot --controller CONTROLLER --slot SLOT --state STATE",
+		  "-S -c CONTROLLER -p SLOT -s STATE", "Sets given state for chosen slot "
+		  "under the controller.");
 	print_opt("--log=PATH", "-l PATH",
-			  "Use local log file instead /var/log/ledctl.log.");
+		  "Use local log file instead /var/log/ledctl.log.");
 	print_opt("--help", "-h", "Displays this help text.");
 	print_opt("--version", "-v",
-			  "Displays version and license information.");
+		  "Displays version and license information.");
 	print_opt("--log-level=VALUE", "-l VALUE",
-			  "Allows user to set ledctl verbose level in logs.");
+		  "Allows user to set ledctl verbose level in logs.");
 	printf("\nPatterns:\n"
 	       "\tCommon patterns are:\n"
 	       "\t\tlocate, locate_off, normal, off, degraded, rebuild,\n" ""
@@ -555,6 +676,156 @@ static status_t _cmdline_parse_non_root(int argc, char *argv[])
 	return status;
 }
 
+/**
+ * @brief Inits slot request structure with initial values.
+ *
+ * @param[in]       slot_req       structure with slot request
+ *
+ * @return This function does not return a value.
+ */
+static void slot_request_init(struct slot_request *slot_req)
+{
+	memset(slot_req, 0, sizeof(struct slot_request));
+
+	slot_req->chosen_opt = OPT_NULL_ELEMENT;
+	slot_req->state = IBPI_PATTERN_UNKNOWN;
+}
+
+/**
+ * @brief Inits slot response structure with initial values.
+ *
+ * @param[in]       slot_res       structure with slot response
+ *
+ * @return This function does not return a value.
+ */
+static void slot_response_init(struct slot_response *slot_res)
+{
+	memset(slot_res, 0, sizeof(struct slot_response));
+
+	slot_res->state = IBPI_PATTERN_UNKNOWN;
+}
+
+/**
+ * @brief Verifies slot request parameters.
+ *
+ * @param[in]       slot_req       structure with slot request
+ *
+ * @return STATUS_SUCCESS if successful, otherwise a valid status_t status code.
+ */
+static status_t slot_verify_request(struct slot_request *slot_req)
+{
+	if (slot_req->cntrl == CNTRL_TYPE_UNKNOWN) {
+		log_error("Invalid controller in the request.");
+		return STATUS_INVALID_CONTROLLER;
+	}
+	if (slot_req->chosen_opt == OPT_SET_SLOT && slot_req->state == IBPI_PATTERN_UNKNOWN) {
+		log_error("Invalid IBPI state in the request.");
+		return STATUS_INVALID_STATE;
+	}
+	if (!slot_req->get_slot_fn && !slot_req->set_slot_fn) {
+		log_error("The controller type %s doesn't support slot functionality.",
+			  slot_req->cntrl);
+		return STATUS_INVALID_CONTROLLER;
+	}
+	if (slot_req->device[0] && slot_req->slot[0]) {
+		log_error("Device and slot parameters are exclusive.");
+		return STATUS_DATA_ERROR;
+	}
+
+	return STATUS_SUCCESS;
+}
+
+static status_t get_state_for_slot(char *slot, struct slot_request *slot_req)
+{
+	struct slot_response slot_res;
+	status_t status = STATUS_SUCCESS;
+
+	slot_response_init(&slot_res);
+	status = slot_req->get_slot_fn(NULL, slot, &slot_res);
+	if (status == STATUS_SUCCESS)
+		print_slot_state(&slot_res);
+	
+	return status;
+}
+
+/**
+ * @brief List slots connected to given controller
+ *
+ * This function scans all available slots connected to given controller
+ * and prints their led states and names of the connected devices (if exist).
+ *
+ * @param[in]       slot_req       Structure with slot request.
+ *
+ * @return STATUS_SUCCESS if successful, otherwise a valid status_t status code.
+ */
+static status_t list_slots(struct slot_request *slot_req)
+{
+	status_t status = STATUS_SUCCESS;
+
+	switch (slot_req->cntrl) {
+	case CNTRL_TYPE_VMD:
+	{
+		struct pci_slot *slot;
+
+		list_for_each(sysfs_get_pci_slots(), slot)
+			status = get_state_for_slot(slot->sysfs_path, slot_req);
+		return status;
+	}
+	case CNTRL_TYPE_NPEM:
+	{
+		struct cntrl_device *ctrl_dev;
+
+		list_for_each(sysfs_get_cntrl_devices(), ctrl_dev) {
+			if (ctrl_dev->cntrl_type != CNTRL_TYPE_NPEM)
+				continue;
+			status = get_state_for_slot(ctrl_dev->sysfs_path, slot_req);
+		}
+		return status;
+	}
+	default:
+		return STATUS_NOT_SUPPORTED;
+	}
+}
+
+/**
+ * @brief Executes proper slot mode function.
+ *
+ * @param[in]       slot_req       Structure with slot request.
+ *
+ * @return STATUS_SUCCESS if successful, otherwise a valid status_t status code.
+ */
+status_t slot_execute(struct slot_request *slot_req)
+{
+	struct slot_response slot_res;
+	status_t status = STATUS_SUCCESS;
+
+	slot_response_init(&slot_res);
+
+	switch (slot_req->chosen_opt) {
+	case OPT_LIST_SLOTS:
+		return list_slots(slot_req);
+	case OPT_SET_SLOT:
+		status = slot_req->get_slot_fn(slot_req->device, slot_req->slot, &slot_res);
+		if (slot_res.state == slot_req->state) {
+			log_warning("Led state: %s is already set for the slot.",
+				    ibpi2str(slot_req->state));
+			return STATUS_SUCCESS;
+		}
+		if (status != STATUS_SUCCESS)
+			return status;
+		status = slot_req->set_slot_fn(slot_res.slot, slot_req->state);
+		if (status != STATUS_SUCCESS)
+			return status;
+	case OPT_GET_SLOT:
+		status = slot_req->get_slot_fn(slot_req->device, slot_req->slot, &slot_res);
+		if (status == STATUS_SUCCESS)
+			print_slot_state(&slot_res);
+		return status;
+	default:
+		return STATUS_NOT_SUPPORTED;
+	}
+}
+
 /**
  * @brief Command line parser - options.
  *
@@ -567,7 +838,7 @@ static status_t _cmdline_parse_non_root(int argc, char *argv[])
  *
  * @return STATUS_SUCCESS if successful, otherwise a valid status_t status code.
  */
-static status_t _cmdline_parse(int argc, char *argv[])
+static status_t _cmdline_parse(int argc, char *argv[], struct slot_request *req)
 {
 	int opt, opt_index = -1;
 	status_t status = STATUS_SUCCESS;
@@ -614,6 +885,34 @@ static status_t _cmdline_parse(int argc, char *argv[])
 			sysfs_reset();
 			exit(EXIT_SUCCESS);
 		}
+		case 'G':
+			req->chosen_opt = OPT_GET_SLOT;
+			break;
+		case 'P':
+			req->chosen_opt = OPT_LIST_SLOTS;
+			break;
+		case 'S':
+			req->chosen_opt = OPT_SET_SLOT;
+			break;
+		case 'c':
+			req->cntrl = get_cntrl_type(optarg);
+			_get_slot_ctrl_fn(req->cntrl, req);
+			break;
+		case 's':
+		{
+			struct ibpi_state *state = _ibpi_state_get(optarg);
+
+			if (state)
+				req->state = state->ibpi;
+			free(state);
+			break;
+		}
+		case 'd':
+			strncpy(req->device, optarg, PATH_MAX - 1);
+			break;
+		case 'p':
+			strncpy(req->slot, optarg, PATH_MAX - 1);
+			break;
 		case ':':
 		case '?':
 		default:
@@ -712,6 +1011,7 @@ static status_t _init_ledctl_conf(void)
 int main(int argc, char *argv[])
 {
 	status_t status;
+	struct slot_request slot_req;
 
 	setup_options(&longopt, &shortopt, possible_params,
 			possible_params_size);
@@ -732,7 +1032,9 @@ int main(int argc, char *argv[])
 		return status;
 	if (on_exit(_ledctl_fini, progname))
 		exit(STATUS_ONEXIT_ERROR);
-	if (_cmdline_parse(argc, argv))
+	slot_request_init(&slot_req);
+	status = _cmdline_parse(argc, argv, &slot_req);
+	if (status != STATUS_SUCCESS)
 		exit(STATUS_CMDLINE_ERROR);
 	free(shortopt);
 	free(longopt);
@@ -746,6 +1048,13 @@ int main(int argc, char *argv[])
 	list_init(&ibpi_list, (item_free_t)ibpi_state_fini);
 	sysfs_init();
 	sysfs_scan();
+	if (slot_req.chosen_opt != OPT_NULL_ELEMENT) {
+		status = slot_verify_request(&slot_req);
+		if (status == STATUS_SUCCESS)
+			return slot_execute(&slot_req);
+		else
+			exit(status);
+	}
 	status = _cmdline_ibpi_parse(argc, argv);
 	if (status != STATUS_SUCCESS) {
 		log_debug("main(): _ibpi_parse() failed (status=%s).",
diff --git a/src/npem.c b/src/npem.c
index 4f836ee8571d..4b08966bd13a 100644
--- a/src/npem.c
+++ b/src/npem.c
@@ -25,7 +25,9 @@
 
 #include "config.h"
 #include "cntrl.h"
+#include "list.h"
 #include "npem.h"
+#include "sysfs.h"
 #include "utils.h"
 
 #define PCI_EXT_CAP_ID_NPEM	0x29	/* Native PCIe Enclosure Management */
@@ -57,19 +59,32 @@
 
 #define PCI_NPEM_STATUS_CC	0x01  /* NPEM Command Completed */
 
-const int ibpi_to_npem_capability[] = {
-	[IBPI_PATTERN_NORMAL]		= PCI_NPEM_OK_CAP,
-	[IBPI_PATTERN_ONESHOT_NORMAL]	= PCI_NPEM_OK_CAP,
-	[IBPI_PATTERN_DEGRADED]		= PCI_NPEM_CRA_CAP,
-	[IBPI_PATTERN_HOTSPARE]		= PCI_NPEM_HOT_SPARE_CAP,
-	[IBPI_PATTERN_REBUILD]		= PCI_NPEM_REBUILD_CAP,
-	[IBPI_PATTERN_FAILED_ARRAY]	= PCI_NPEM_FA_CAP,
-	[IBPI_PATTERN_PFA]		= PCI_NPEM_PFA_CAP,
-	[IBPI_PATTERN_FAILED_DRIVE]	= PCI_NPEM_FAIL_CAP,
-	[IBPI_PATTERN_LOCATE]		= PCI_NPEM_LOCATE_CAP,
-	[IBPI_PATTERN_LOCATE_OFF]	= PCI_NPEM_OK_CAP,
+const struct ibpi_value ibpi_to_npem_capability[] = {
+	{IBPI_PATTERN_NORMAL, PCI_NPEM_OK_CAP},
+	{IBPI_PATTERN_ONESHOT_NORMAL, PCI_NPEM_OK_CAP},
+	{IBPI_PATTERN_DEGRADED, PCI_NPEM_CRA_CAP},
+	{IBPI_PATTERN_HOTSPARE, PCI_NPEM_HOT_SPARE_CAP},
+	{IBPI_PATTERN_REBUILD, PCI_NPEM_REBUILD_CAP},
+	{IBPI_PATTERN_FAILED_ARRAY, PCI_NPEM_FA_CAP},
+	{IBPI_PATTERN_PFA, PCI_NPEM_PFA_CAP},
+	{IBPI_PATTERN_FAILED_DRIVE, PCI_NPEM_FAIL_CAP},
+	{IBPI_PATTERN_LOCATE, PCI_NPEM_LOCATE_CAP},
+	{IBPI_PATTERN_LOCATE_OFF, PCI_NPEM_OK_CAP},
+	{IBPI_PATTERN_UNKNOWN}
 };
 
+static enum ibpi_pattern npem_capability_to_ibpi(const u32 reg)
+{
+	const struct ibpi_value *tmp = ibpi_to_npem_capability;
+
+	while (tmp->ibpi != IBPI_PATTERN_UNKNOWN) {
+		if (reg & tmp->value)
+			break;
+		tmp++;
+	}
+	return tmp->ibpi;
+}
+
 static struct pci_access *get_pci_access()
 {
 	struct pci_access *pacc;
@@ -131,8 +146,10 @@ int is_npem_capable(const char *path)
 	struct pci_access *pacc = get_pci_access();
 	struct pci_dev *pdev;
 
-	if (!pacc)
+	if (!pacc) {
+		log_error("NPEM: Unable to initialize pci access for %s\n", path);
 		return 0;
+	}
 
 	pdev = get_pci_dev(pacc, path);
 
@@ -215,7 +232,9 @@ int npem_write(struct block_device *device, enum ibpi_pattern ibpi)
 	}
 
 	reg = read_npem_register(pdev, PCI_NPEM_CAP_REG);
-	if ((reg & ibpi_to_npem_capability[ibpi]) == 0) {
+	u32 cap = (u32)get_value_for_ibpi(ibpi, ibpi_to_npem_capability);
+
+	if ((reg & cap) == 0) {
 		log_debug("NPEM: Controller %s doesn't support %s pattern\n",
 			  npem_cntrl->sysfs_path, ibpi_str[ibpi]);
 		ibpi = IBPI_PATTERN_NORMAL;
@@ -223,7 +242,8 @@ int npem_write(struct block_device *device, enum ibpi_pattern ibpi)
 
 	reg = read_npem_register(pdev, PCI_NPEM_CTRL_REG);
 	val = (reg & PCI_NPEM_RESERVED);
-	val = (val | PCI_NPEM_CAP | ibpi_to_npem_capability[ibpi]);
+	cap = (u32)get_value_for_ibpi(ibpi, ibpi_to_npem_capability);
+	val = (val | PCI_NPEM_CAP | cap);
 
 	write_npem_register(pdev, PCI_NPEM_CTRL_REG, val);
 	if (npem_wait_command(pdev)) {
@@ -244,3 +264,100 @@ char *npem_get_path(const char *cntrl_path)
 {
 	return str_dup(cntrl_path);
 }
+
+status_t npem_get_slot(char *device, char *slot_path, struct slot_response *slot_res)
+{
+	struct pci_dev *pdev = NULL;
+	struct block_device *block_device = NULL;
+	struct pci_access *pacc = get_pci_access();
+	status_t status = STATUS_SUCCESS;
+	char *path = NULL;
+	u32 reg;
+
+	if (!pacc) {
+		log_error("NPEM: Unable to initialize pci access for %s\n", path);
+		return STATUS_NULL_POINTER;
+	}
+
+	if (device && device[0] != '\0') {
+		block_device = get_block_device_from_sysfs_path(basename(device));
+		if (block_device)
+			path = block_device->cntrl->sysfs_path;
+	} else if (slot_path && slot_path[0] != '\0') {
+		struct cntrl_device *ctrl_dev;
+
+		list_for_each(sysfs_get_cntrl_devices(), ctrl_dev) {
+			if (ctrl_dev->cntrl_type != CNTRL_TYPE_NPEM)
+				continue;
+			if (strcmp(basename(ctrl_dev->sysfs_path), basename(slot_path)) != 0)
+				continue;
+			path = ctrl_dev->sysfs_path;
+			block_device = get_block_device_from_sysfs_path(path);
+			break;
+		}
+	}
+
+	if (path) {
+		pdev = get_pci_dev(pacc, path);
+	} else {
+		log_debug("NPEM: unable to get sysfs path for the controller.");
+		pci_cleanup(pacc);
+		return STATUS_INVALID_PATH;
+	}
+
+	if (!pdev) {
+		log_error("NPEM: Unable to get pci device for %s\n", path);
+		pci_cleanup(pacc);
+		return STATUS_NULL_POINTER;
+	}
+
+	reg = read_npem_register(pdev, PCI_NPEM_CTRL_REG);
+	slot_res->state = npem_capability_to_ibpi(reg);
+	snprintf(slot_res->slot, PATH_MAX, "%s", path);
+
+	if (block_device)
+		snprintf(slot_res->device, PATH_MAX, "/dev/%s", basename(block_device->sysfs_path));
+	else
+		snprintf(slot_res->device, PATH_MAX, "(empty)");
+
+	pci_free_dev(pdev);
+	pci_cleanup(pacc);
+	return status;
+}
+
+status_t npem_set_slot(char *slot_path, enum ibpi_pattern state)
+{
+	struct pci_dev *pdev = NULL;
+	struct pci_access *pacc = get_pci_access();
+	status_t status = STATUS_SUCCESS;
+	u32 val;
+	u32 reg;
+	u32 cap;
+
+	if (!pacc) {
+		log_error("NPEM: Unable to initialize pci access for %s\n", slot_path);
+		return STATUS_NULL_POINTER;
+	}
+
+	pdev = get_pci_dev(pacc, slot_path);
+	if (!pdev) {
+		log_error("NPEM: Unable to get pci device for %s\n", slot_path);
+		pci_cleanup(pacc);
+		return STATUS_NULL_POINTER;
+	}
+
+	reg = read_npem_register(pdev, PCI_NPEM_CTRL_REG);
+	val = (reg & PCI_NPEM_RESERVED);
+	cap = (u32)get_value_for_ibpi(state, ibpi_to_npem_capability);
+	val = (val | PCI_NPEM_CAP | cap);
+
+	write_npem_register(pdev, PCI_NPEM_CTRL_REG, val);
+	if (npem_wait_command(pdev)) {
+		log_error("NPEM: Write timeout for %s\n", slot_path);
+		status = STATUS_FILE_WRITE_ERROR;
+	}
+
+	pci_free_dev(pdev);
+	pci_cleanup(pacc);
+	return status;
+}
diff --git a/src/npem.h b/src/npem.h
index 5fa3f11d0ba3..8f4dd7b96151 100644
--- a/src/npem.h
+++ b/src/npem.h
@@ -21,9 +21,37 @@
 #define NPEM_H_INCLUDED_
 #include "block.h"
 #include "ibpi.h"
+#include "slot.h"
+#include "status.h"
 
 int is_npem_capable(const char *path);
 int npem_write(struct block_device *device, enum ibpi_pattern ibpi);
 char *npem_get_path(const char *cntrl_path);
 
+/**
+ * @brief Gets led state for slot.
+ *
+ * This function finds slot connected to given identifier
+ * and fills slot response related to the slot.
+ *
+ * @param[in]         device         Requested device name.
+ * @param[in]         slot_num       Requested identifier of the slot.
+ * @param[in]         slot_res       Pointer to the slot response.
+ *
+ * @return STATUS_SUCCESS if successful, otherwise a valid status_t status code.
+ */
+status_t npem_get_slot(char *device, char *slot_num, struct slot_response *slot_res);
+
+/**
+ * @brief Sets led state for slot.
+ *
+ * This function finds slot connected to given number or device name
+ * and set given led state.
+ *
+ * @param[in]         slot_num       Requested number of the slot.
+ * @param[in]         state          IBPI state based on slot request.
+ *
+ * @return STATUS_SUCCESS if successful, otherwise a valid status_t status code.
+ */
+status_t npem_set_slot(char *slot_num, enum ibpi_pattern state);
 #endif // NPEM_H_INCLUDED_
diff --git a/src/pci_slot.c b/src/pci_slot.c
index b15e1947c043..1e03dbabe91d 100644
--- a/src/pci_slot.c
+++ b/src/pci_slot.c
@@ -29,7 +29,9 @@
 
 #include "config.h"
 #include "pci_slot.h"
+#include "sysfs.h"
 #include "utils.h"
+#include "vmdssd.h"
 
 /*
  * Allocates memory for PCI hotplug slot structure and initializes fields of
@@ -44,12 +46,6 @@ struct pci_slot *pci_slot_init(const char *path)
 		return NULL;
 	result->sysfs_path = str_dup(path);
 	result->address = get_text(path, "address");
-	result->attention = get_int(path, -1, "attention");
-
-	if (result->attention == -1) {
-		pci_slot_fini(result);
-		return NULL;
-	}
 
 	return result;
 }
@@ -66,3 +62,97 @@ void pci_slot_fini(struct pci_slot *slot)
 		free(slot);
 	}
 }
+
+/**
+ * @brief Finds PCI slot by number of the slot.
+ *
+ * @param[in]       slot_number       Number of the slot
+ *
+ * @return Struct with pci slot if successful, otherwise the function returns NULL pointer.
+ */
+static struct pci_slot *find_pci_slot_by_number(char *slot_number)
+{
+	struct pci_slot *slot = NULL;
+	char *temp;
+
+	if (slot_number == NULL)
+		return NULL;
+
+	list_for_each(sysfs_get_pci_slots(), slot) {
+		temp = basename(slot->sysfs_path);
+		if (temp && strncmp(temp, slot_number, PATH_MAX) == 0)
+			return slot;
+	}
+	return NULL;
+}
+
+/**
+ * @brief Sets the slot response.
+ *
+ * @param[in]        slot       Struct with PCI slot parameters.
+ *
+ * @return STATUS_SUCCESS if successful, otherwise a valid status_t status code.
+ */
+static status_t set_slot_response(struct pci_slot *slot, struct slot_response *slot_res)
+{
+	struct block_device *bl_device;
+	status_t status = STATUS_SUCCESS;
+	int attention = get_int(slot->sysfs_path, -1, "attention");
+
+	if (attention == -1)
+		return STATUS_INVALID_STATE;
+
+	slot_res->state = get_ibpi_for_value(attention, ibpi_to_attention);
+	snprintf(slot_res->slot, PATH_MAX, "%s", basename(slot->sysfs_path));
+
+	bl_device = get_block_device_from_sysfs_path(slot->address);
+	if (bl_device)
+		snprintf(slot_res->device, PATH_MAX, "/dev/%s", basename(bl_device->sysfs_path));
+	else
+		snprintf(slot_res->device, PATH_MAX, "(empty)");
+
+	return status;
+}
+
+status_t pci_get_slot(char *device, char *slot_path, struct slot_response *slot_res)
+{
+	struct pci_slot *slot = NULL;
+	struct block_device *block_device = NULL;
+
+	if (device && device[0] != '\0') {
+		char *sub_path = basename(device);
+		if (sub_path == NULL) {
+			log_error("Device name %s is invalid.", device);
+			return STATUS_DATA_ERROR;
+		}
+
+		block_device = get_block_device_from_sysfs_path(sub_path + 1);
+		if (block_device == NULL) {
+			log_error("Device %s not found.", device);
+			return STATUS_DATA_ERROR;
+		}
+		slot = vmdssd_find_pci_slot(block_device->sysfs_path);
+	} else if (slot_path && slot_path[0] != '\0') {
+		slot = find_pci_slot_by_number(basename(slot_path));
+	}
+
+	if (slot == NULL) {
+		log_error("Specified slot was not found.");
+		return STATUS_DATA_ERROR;
+	}
+
+	return set_slot_response(slot, slot_res);
+}
+
+status_t pci_set_slot(char *slot_path, enum ibpi_pattern state)
+{
+	struct pci_slot *slot = NULL;
+
+	slot = find_pci_slot_by_number(basename(slot_path));
+	if (slot == NULL) {
+		log_error("Slot %s not found.", slot_path);
+		return STATUS_NULL_POINTER;
+	}
+
+	return vmdssd_write_attention_buf(slot, state);
+}
diff --git a/src/pci_slot.h b/src/pci_slot.h
index b971de3d89b7..9a181ce6057e 100644
--- a/src/pci_slot.h
+++ b/src/pci_slot.h
@@ -20,6 +20,10 @@
 #ifndef PCI_SLOT_H_INCLUDED_
 #define PCI_SLOT_H_INCLUDED_
 
+#include "ibpi.h"
+#include "slot.h"
+#include "status.h"
+
 /**
  * @brief PCI hotplug slot structure.
  *
@@ -35,11 +39,6 @@ struct pci_slot {
  * PCI hotplug slot address.
  */
 	char *address;
-
- /**
- * State of the Amber LED of the PCI slot.
- */
-	int attention;
 };
 
 /**
@@ -69,4 +68,30 @@ struct pci_slot *pci_slot_init(const char *path);
  */
 void pci_slot_fini(struct pci_slot *slot);
 
+/**
+ * @brief Gets led state for slot.
+ *
+ * This function finds slot connected to given identifier
+ * and fills slot response related to the slot.
+ *
+ * @param[in]         device         Requested device name.
+ * @param[in]         slot_num       Requested identifier of the slot.
+ * @param[in]         slot_res       Pointer to the slot response.
+ *
+ * @return STATUS_SUCCESS if successful, otherwise a valid status_t status code.
+ */
+status_t pci_get_slot(char *device, char *slot_num, struct slot_response *slot_res);
+
+/**
+ * @brief Sets led state for slot.
+ *
+ * This function finds slot connected to given number or device name
+ * and set given led state.
+ *
+ * @param[in]         slot_num       Requested number of the slot.
+ * @param[in]         state          IBPI state based on slot request.
+ *
+ * @return STATUS_SUCCESS if successful, otherwise a valid status_t status code.
+ */
+status_t pci_set_slot(char *slot_num, enum ibpi_pattern state);
 #endif // PCI_SLOT_H_INCLUDED_
diff --git a/src/slot.h b/src/slot.h
new file mode 100644
index 000000000000..82b2e9405b89
--- /dev/null
+++ b/src/slot.h
@@ -0,0 +1,63 @@
+/*
+ * Intel(R) Enclosure LED Utilities
+ * Copyright (C) 2022-2022 Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ */
+
+#ifndef SLOT_H_
+#define SLOT_H_
+
+#include <stdio.h>
+
+#include "ibpi.h"
+#include "utils.h"
+
+/**
+ * @brief slot response parameters
+ *
+ * This structure contains slot properties.
+ */
+struct slot_response {
+	/**
+	 * Name of the device.
+	 */
+	char device[PATH_MAX];
+
+	/**
+	 * Unique slot identifier.
+	 */
+	char slot[PATH_MAX];
+
+	/**
+	 * IBPI state.
+	 */
+	enum ibpi_pattern state;
+};
+
+/**
+ * @brief Print address, slot identifier and led state.
+ *
+ * @param[in]        res        Structure with slot response.
+ *
+ * @return This function does not return a value.
+ */
+static inline void print_slot_state(struct slot_response *res)
+{
+	printf("slot: %-15s led state: %-15s device: %-15s\n",
+	       basename(res->slot), ibpi2str(res->state), res->device);
+}
+
+#endif // SLOT_H_INCLUDED_
diff --git a/src/sysfs.c b/src/sysfs.c
index 87e83391f328..f1f9caad05a3 100644
--- a/src/sysfs.c
+++ b/src/sysfs.c
@@ -48,7 +48,6 @@
  */
 #define SYSFS_CLASS_BLOCK       "/sys/block"
 #define SYSFS_CLASS_ENCLOSURE   "/sys/class/enclosure"
-#define SYSFS_PCI_DEVICES       "/sys/bus/pci/devices"
 #define SYSFS_PCI_SLOTS         "/sys/bus/pci/slots"
 
 /**
diff --git a/src/sysfs.h b/src/sysfs.h
index efebea840cee..ea0109f6aa33 100644
--- a/src/sysfs.h
+++ b/src/sysfs.h
@@ -1,6 +1,6 @@
 /*
  * Intel(R) Enclosure LED Utilities
- * Copyright (C) 2009-2018 Intel Corporation.
+ * Copyright (C) 2009-2022 Intel Corporation.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -22,6 +22,8 @@
 
 #include "status.h"
 
+#define SYSFS_PCI_DEVICES       "/sys/bus/pci/devices"
+
 /**
  * @brief Initializes sysfs module.
  *
diff --git a/src/utils.c b/src/utils.c
index 7f52194f5d1c..085cdb1d5c2f 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -505,7 +505,7 @@ int get_log_fd(void)
 
 void print_opt(const char *long_opt, const char *short_opt, const char *desc)
 {
-	printf("%-20s%-10s%s\n", long_opt, short_opt, desc);
+	printf("%-70s%-40s%s\n", long_opt, short_opt, desc);
 }
 
 /**
@@ -581,6 +581,13 @@ struct option longopt_all[] = {
 	[OPT_LIST_CTRL]    = {"list-controllers", no_argument, NULL, 'L'},
 	[OPT_LISTED_ONLY]  = {"listed-only", no_argument, NULL, 'x'},
 	[OPT_FOREGROUND]   = {"foreground", no_argument, NULL, '\0'},
+	[OPT_LIST_SLOTS]   = {"list-slots", no_argument, NULL, 'P'},
+	[OPT_GET_SLOT]     = {"get-slot", no_argument, NULL, 'G'},
+	[OPT_SET_SLOT]     = {"set-slot", no_argument, NULL, 'S'},
+	[OPT_CONTROLLER]   = {"controller", required_argument, NULL, 'c'},
+	[OPT_DEVICE]       = {"device", required_argument, NULL, 'd'},
+	[OPT_SLOT]         = {"slot", required_argument, NULL, 'p'},
+	[OPT_STATE]        = {"state", required_argument, NULL, 's'},
 	[OPT_NULL_ELEMENT] = {NULL, no_argument, NULL, '\0'}
 };
 
@@ -699,3 +706,43 @@ const char *ibpi2str(enum ibpi_pattern ibpi)
 
 	return ret;
 }
+
+/**
+ * @brief Returns value based on IBPI state
+ *
+ * @param[in]       value       Value for led state.
+ * @param[in]       ibpi_values    Array with defined IBPI states and values.
+ *
+ * @return Integer value which represents given IBPI state.
+ */
+int get_value_for_ibpi(enum ibpi_pattern ibpi, const struct ibpi_value ibpi_values[])
+{
+	const struct ibpi_value *tmp = ibpi_values;
+
+	while (tmp->ibpi != IBPI_PATTERN_UNKNOWN) {
+		if (tmp->ibpi == ibpi)
+			break;
+		tmp++;
+	}
+	return tmp->value;
+}
+
+/**
+ * @brief Returns IBPI pattern based on value
+ *
+ * @param[in]       value          Value for led state.
+ * @param[in]       ibpi_values    Array with defined IBPI states and values.
+ *
+ * @return Enum with IBPI value, which represents given value.
+ */
+enum ibpi_pattern get_ibpi_for_value(const int value, const struct ibpi_value ibpi_values[])
+{
+	const struct ibpi_value *tmp = ibpi_values;
+
+	while (tmp->ibpi != IBPI_PATTERN_UNKNOWN) {
+		if (tmp->value == value)
+			break;
+		tmp++;
+	}
+	return tmp->ibpi;
+}
diff --git a/src/utils.h b/src/utils.h
index 3f5a77fc6f74..5ef3020e6dce 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -1,6 +1,6 @@
 /*
  * Intel(R) Enclosure LED Utilities
- * Copyright (C) 2009-2019 Intel Corporation.
+ * Copyright (C) 2009-2022 Intel Corporation.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -59,6 +59,10 @@ struct log_level_info {
 	int priority;
 };
 
+struct ibpi_value {
+	int ibpi, value;
+};
+
 /**
  */
 #define PREFIX_DEBUG          "  DEBUG: "
@@ -418,6 +422,13 @@ enum opt {
 	OPT_LIST_CTRL,
 	OPT_LISTED_ONLY,
 	OPT_FOREGROUND,
+	OPT_LIST_SLOTS,
+	OPT_GET_SLOT,
+	OPT_SET_SLOT,
+	OPT_CONTROLLER,
+	OPT_DEVICE,
+	OPT_SLOT,
+	OPT_STATE,
 	OPT_NULL_ELEMENT
 };
 
@@ -428,5 +439,7 @@ int get_option_id(const char *optarg);
 status_t set_verbose_level(int log_level);
 
 const char *ibpi2str(enum ibpi_pattern ibpi);
+int get_value_for_ibpi(enum ibpi_pattern ibpi, const struct ibpi_value ibpi_values[]);
+enum ibpi_pattern get_ibpi_for_value(const int value, const struct ibpi_value ibpi_values[]);
 
 #endif				/* _UTILS_H_INCLUDED_ */
diff --git a/src/vmdssd.c b/src/vmdssd.c
index 3c6d24bdc604..015d3489c276 100644
--- a/src/vmdssd.c
+++ b/src/vmdssd.c
@@ -1,6 +1,6 @@
 /*
  * Intel(R) Enclosure LED Utilities
- * Copyright (c) 2016-2019, Intel Corporation
+ * Copyright (c) 2016-2022, Intel Corporation
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -37,6 +37,13 @@
 #define ATTENTION_REBUILD    0x5  /* (0101) Attention On, Power On */
 #define ATTENTION_FAILURE    0xD  /* (1101) Attention On, Power Off */
 
+struct ibpi_value ibpi_to_attention[] = {
+	{IBPI_PATTERN_LOCATE, ATTENTION_LOCATE},
+	{IBPI_PATTERN_FAILED_DRIVE, ATTENTION_FAILURE},
+	{IBPI_PATTERN_REBUILD, ATTENTION_REBUILD},
+	{IBPI_PATTERN_LOCATE_OFF, ATTENTION_OFF}
+};
+
 #define SYSFS_PCIEHP         "/sys/module/pciehp"
 
 static char *get_slot_from_syspath(char *path)
@@ -61,24 +68,6 @@ static char *get_slot_from_syspath(char *path)
 	return ret;
 }
 
-static void get_ctrl(enum ibpi_pattern ibpi, uint16_t *new)
-{
-	switch (ibpi) {
-	case IBPI_PATTERN_LOCATE:
-		*new = ATTENTION_LOCATE;
-		break;
-	case IBPI_PATTERN_FAILED_DRIVE:
-		*new = ATTENTION_FAILURE;
-		break;
-	case IBPI_PATTERN_REBUILD:
-		*new = ATTENTION_REBUILD;
-		break;
-	default:
-		*new = ATTENTION_OFF;
-		break;
-	}
-}
-
 static int check_slot_module(const char *slot_path)
 {
 	char module_path[PATH_MAX], real_module_path[PATH_MAX];
@@ -120,11 +109,29 @@ struct pci_slot *vmdssd_find_pci_slot(char *device_path)
 	return slot;
 }
 
-int vmdssd_write(struct block_device *device, enum ibpi_pattern ibpi)
+status_t vmdssd_write_attention_buf(struct pci_slot *slot, enum ibpi_pattern ibpi)
 {
 	char attention_path[PATH_MAX];
 	char buf[WRITE_BUFFER_SIZE];
 	uint16_t val;
+
+	log_debug("%s before: 0x%x\n", slot->address,
+		  get_int(slot->sysfs_path, 0, "attention"));
+	val = get_value_for_ibpi(ibpi, ibpi_to_attention);
+	snprintf(buf, WRITE_BUFFER_SIZE, "%u", val);
+	snprintf(attention_path, PATH_MAX, "%s/attention", slot->sysfs_path);
+	if (buf_write(attention_path, buf) != (ssize_t) strnlen(buf, WRITE_BUFFER_SIZE)) {
+		log_error("%s write error: %d\n", slot->sysfs_path, errno);
+		return STATUS_FILE_WRITE_ERROR;
+	}
+	log_debug("%s after: 0x%x\n", slot->address,
+		  get_int(slot->sysfs_path, 0, "attention"));
+
+	return STATUS_SUCCESS;
+}
+
+int vmdssd_write(struct block_device *device, enum ibpi_pattern ibpi)
+{
 	struct pci_slot *slot;
 	char *short_name = strrchr(device->sysfs_path, '/');
 
@@ -145,21 +152,7 @@ int vmdssd_write(struct block_device *device, enum ibpi_pattern ibpi)
 		__set_errno_and_return(ENODEV);
 	}
 
-	log_debug("%s before: 0x%x\n", short_name,
-		  get_int(slot->sysfs_path, 0, "attention"));
-
-	get_ctrl(ibpi, &val);
-	snprintf(buf, WRITE_BUFFER_SIZE, "%u", val);
-	snprintf(attention_path, PATH_MAX, "%s/attention", slot->sysfs_path);
-	if (buf_write(attention_path, buf) != (ssize_t) strnlen(buf, WRITE_BUFFER_SIZE)) {
-		log_error("%s write error: %d\n", slot->sysfs_path, errno);
-		return -1;
-	}
-
-	log_debug("%s after: 0x%x\n", short_name,
-		  get_int(slot->sysfs_path, 0, "attention"));
-
-	return 0;
+	return vmdssd_write_attention_buf(slot, ibpi);
 }
 
 char *vmdssd_get_path(const char *cntrl_path)
diff --git a/src/vmdssd.h b/src/vmdssd.h
index 4c90fcb35ea2..f07d989280bc 100644
--- a/src/vmdssd.h
+++ b/src/vmdssd.h
@@ -1,6 +1,6 @@
 /*
  * Intel(R) Enclosure LED Utilities
- * Copyright (c) 2016-2019, Intel Corporation
+ * Copyright (c) 2016-2022, Intel Corporation
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -22,9 +22,18 @@
 
 #include "block.h"
 #include "ibpi.h"
+#include "utils.h"
+
+#define ATTENTION_OFF        0xF  /* (1111) Attention Off, Power Off */
+#define ATTENTION_LOCATE     0x7  /* (0111) Attention Off, Power On */
+#define ATTENTION_REBUILD    0x5  /* (0101) Attention On, Power On */
+#define ATTENTION_FAILURE    0xD  /* (1101) Attention On, Power Off */
+
+extern struct ibpi_value ibpi_to_attention[];
 
 int vmdssd_write(struct block_device *device, enum ibpi_pattern ibpi);
 char *vmdssd_get_path(const char *cntrl_path);
 struct pci_slot *vmdssd_find_pci_slot(char *device_path);
+status_t vmdssd_write_attention_buf(struct pci_slot *slot, enum ibpi_pattern ibpi);
 
 #endif
-- 
2.34.1