/*

 * Intel(R) Enclosure LED Utilities

 * Copyright (C) 2009-2020 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.

 *

 */

#include <dirent.h>

#include <limits.h>

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#if _HAVE_DMALLOC_H

#include <dmalloc.h>

#endif

#include "cntrl.h"

#include "config.h"

#include "config_file.h"

#include "list.h"

#include "smp.h"

#include "status.h"

#include "sysfs.h"

#include "utils.h"

#include "amd.h"

#include "npem.h"

/**

 * @brief Name of controllers types.

 *

 * This is internal array with names of controller types. Array can be use to

 * translate enumeration type into the string.

 */

static const char * const ctrl_type_str[] = {

	[CNTRL_TYPE_UNKNOWN] = "?",

	[CNTRL_TYPE_DELLSSD] = "Dell SSD",

	[CNTRL_TYPE_VMD]     = "VMD",

	[CNTRL_TYPE_SCSI]    = "SCSI",

	[CNTRL_TYPE_AHCI]    = "AHCI",

	[CNTRL_TYPE_NPEM]    = "NPEM",

	[CNTRL_TYPE_AMD]     = "AMD",

};

/**

 */

static int _is_storage_controller(const char *path)

{

	uint64_t class = get_uint64(path, 0, "class");

	return (class & 0xff0000L) == 0x010000L;

}

/**

 */

static int _is_isci_cntrl(const char *path)

{

	return sysfs_check_driver(path, "isci");

}

/**

 */

static int _is_cntrl(const char *path, const char *type)

{

	char temp[PATH_MAX], link[PATH_MAX], *t;

	snprintf(temp, sizeof(temp), "%s/driver", path);

	if (realpath(temp, link) == NULL)

		return 0;

	t = strrchr(link, '/');

	if ((t != NULL) && (strcmp(t + 1, type) != 0))

		return 0;

	return 1;

}

static int _is_ahci_cntrl(const char *path)

{

	return _is_cntrl(path, "ahci");

}

static int _is_nvme_cntrl(const char *path)

{

	return _is_cntrl(path, "nvme");

}

static int _is_intel_ahci_cntrl(const char *path)

{

	if (!_is_ahci_cntrl(path))

		return 0;

	return get_uint64(path, 0, "vendor") == 0x8086L;

}

static int _is_amd_ahci_cntrl(const char *path)

{

	if (!_is_ahci_cntrl(path))

		return 0;

	return get_uint64(path, 0, "vendor") == 0x1022L;

}

static int _is_amd_nvme_cntrl(const char *path)

{

	char tmp[PATH_MAX];

	char *t;

	if (!_is_nvme_cntrl(path))

		return 0;

	sprintf(tmp, "%s", path);

	t = strrchr(tmp, '/');

	if (!t)

		return 0;

	t++;

	*t = '\0';

	return get_uint64(tmp, 0, "vendor") == 0x1022L;

}

static int _is_amd_cntrl(const char *path)

{

	if (_is_amd_ahci_cntrl(path))

		return 1;

	if (_is_amd_nvme_cntrl(path))

		return 1;

	return 0;

}

extern int get_dell_server_type(void);

static int _is_dellssd_cntrl(const char *path)

{

	uint64_t vdr, dev, svdr, cls;

	int gen = 0;

	vdr = get_uint64(path, 0, "vendor");

	dev = get_uint64(path, 0, "device");

	cls = get_uint64(path, 0, "class");

	svdr = get_uint64(path, 0, "subsystem_vendor");

	if (cls == 0x10802)

		gen = get_dell_server_type();

	return ((vdr == 0x1344L && dev == 0x5150L) || /* micron ssd */

		(gen != 0) ||			      /* Dell Server+NVME */

	        (svdr == 0x1028 && cls == 0x10802));  /* nvmhci ssd */

}

/**

 */

static int _is_smp_cntrl(const char *path)

{

	int result = 0;

	struct list dir;

	char *p;

	char host_path[PATH_MAX] = { 0 };

	if (scan_dir(path, &dir) == 0) {

		const char *dir_path;

		list_for_each(&dir, dir_path) {

			p = strrchr(dir_path, '/');

			if (!p++)

				break;

			if (strncmp(p, "host", strlen("host")) == 0) {

				snprintf(host_path, sizeof(host_path),

					"%s/%s/bsg/sas_%s", path, p, p);

				result = smp_write_gpio(host_path,

					GPIO_REG_TYPE_TX,

					0,

					0,

					"",

					0) == 0;

			}

		}

		list_erase(&dir;;

	}

	return result;

}

static int _is_vmd_cntrl(const char *path)

{

	return sysfs_check_driver(path, "vmd");

}

static int _is_npem_cntrl(const char *path)

{

	return is_npem_capable(path);

}

/**

 * @brief Determines the type of controller.

 *

 * This is internal function of 'controller device' module. The function

 * determines the type of controller device. It might be AHCI, SCSI or

 * UNKNOWN device type.

 *

 * @param[in]      path           path to controller device in sysfs tree.

 *

 * @return The type of controller device. If the type returned is

 *         CNTRL_TYPE_UNKNOWN this means a controller device is not

 *         supported.

 */

static enum cntrl_type _get_type(const char *path)

{

	enum cntrl_type type = CNTRL_TYPE_UNKNOWN;

	if (_is_npem_cntrl(path)) {

		type = CNTRL_TYPE_NPEM;

	} else if (_is_vmd_cntrl(path)) {

		type = CNTRL_TYPE_VMD;

	} else if (_is_dellssd_cntrl(path)) {

		type = CNTRL_TYPE_DELLSSD;

	} else if (_is_storage_controller(path)) {

		if (_is_intel_ahci_cntrl(path))

			type = CNTRL_TYPE_AHCI;

		else if (_is_amd_cntrl(path))

			type = CNTRL_TYPE_AMD;

		else if (_is_isci_cntrl(path)

				|| sysfs_enclosure_attached_to_cntrl(path)

				|| _is_smp_cntrl(path))

			type = CNTRL_TYPE_SCSI;

	}

	return type;

}

struct _host_type *alloc_host(int id, struct _host_type *next)

{

	struct _host_type *host = NULL;

	host = malloc(sizeof(struct _host_type));

	if (host) {

		host->host_id = id;

		host->ibpi_state_buffer = NULL;

		memset(host->bitstream, 0, sizeof(host->bitstream));

		host->flush = 0;

		host->ports = 0;

		host->next = next;

	}

	return host;

}

void free_hosts(struct _host_type *h)

{

	struct _host_type *t;

	while (h) {

		t = h->next;

		free(h->ibpi_state_buffer);

		free(h);

		h = t;

	}

}

void _find_host(const char *path, struct _host_type **hosts)

{

	const int host_len = sizeof("host") - 1;

	char *p;

	int index = -1;

	struct _host_type *th;

	DIR *d;

	struct dirent *de;

	p = strrchr(path, '/');

	if (!p++)

		return;

	if (strncmp(p, "host", host_len - 1) == 0) {

		index = atoi(p + host_len);

		th = alloc_host(index, (*hosts) ? (*hosts) : NULL);

		if (!th)

			return;

		d = opendir(path);

		if(!d) {

			free(th);

			return;

		}

		while ((de = readdir(d))) {

			if (strncmp(de->d_name, "phy-", strlen("phy-")) == 0) {

				th->ports++;

			}

		}

		closedir(d);

		*hosts = th;

	}

}

/**

 * @brief Get all instances of separate hosts on isci controller.

 *

 */

static struct _host_type *_cntrl_get_hosts(const char *path)

{

	struct _host_type *hosts = NULL;

	struct list dir;

	if (scan_dir(path, &dir) == 0) {

		const char *dir_path;

		list_for_each(&dir, dir_path)

			_find_host(dir_path, &hosts);

		list_erase(&dir;;

	}

	return hosts;

}

/**

 * @brief Check if enclosure management is enabled.

 *

 * This is internal function of 'controller device' module. The function checks

 * whether enclosure management is enabled for AHCI controller.

 *

 * @param[in]      path           path to controller device in sysfs tree.

 *

 * @return 1 if enclosure management is enabled, otherwise the function returns 0.

 */

static unsigned int _ahci_em_messages(const char *path)

{

	/* first, open ...driver/module/parameters/ahci_em_messages

	 * then open /sys/module/libahci/parameters/ahci_em_messages

	 * and check if it is set to enabled.

	 * if so, check if 'holders' of libahci points the same driver name

	 * as device given by path

	 */

	char buf[PATH_MAX];

	char *link, *name;

	DIR *dh;

	struct dirent *de = NULL;

	/* old kernel (prior to 2.6.36) */

	if (get_int(path, 0, "driver/module/parameters/ahci_em_messages") != 0)

		return 1;

	/* parameter type changed from int to bool since kernel v3.13 */

	if (!get_int("", 0, "sys/module/libahci/parameters/ahci_em_messages")) {

		if (!get_bool("", 0, "sys/module/libahci/parameters/ahci_em_messages"))

			return 0;

	}

	if (snprintf(buf, sizeof(buf), "%s/%s", path, "driver") < 0)

		return 0;

	link = realpath(buf, NULL);

	if (!link)

		return 0;

	name = strrchr(link, '/');

	if (!name++) {

		free(link);

		return 0;

	}

	/* check if the directory /sys/module/libahci/holders exists */

	dh = opendir("/sys/module/libahci/holders");

	if (dh) {

		/* name contain controller name (ie. ahci),*/

		/* so check if libahci holds this driver   */

		while ((de = readdir(dh))) {

			if (!strcmp(de->d_name, name))

				break;

		}

		closedir(dh);

		free(link);

		return de ? 1 : 0;

	} else {

		free(link);

		return 1;

	}

}

/*

 * Allocates memory for a new controller device structure. See cntrl.h for

 * details.

 */

struct cntrl_device *cntrl_device_init(const char *path)

{

	unsigned int em_enabled;

	enum cntrl_type type;

	struct cntrl_device *device = NULL;

	type = _get_type(path);

	if (type != CNTRL_TYPE_UNKNOWN) {

		switch (type) {

		case CNTRL_TYPE_DELLSSD:

		case CNTRL_TYPE_SCSI:

		case CNTRL_TYPE_VMD:

		case CNTRL_TYPE_NPEM:

			em_enabled = 1;

			break;

		case CNTRL_TYPE_AHCI:

			em_enabled = _ahci_em_messages(path);

			break;

		case CNTRL_TYPE_AMD:

			em_enabled = amd_em_enabled(path);

			break;

		default:

			em_enabled = 0;

		}

		if (em_enabled) {

			if (!list_is_empty(&conf.cntrls_whitelist)) {

				char *cntrl = NULL;

				list_for_each(&conf.cntrls_whitelist, cntrl) {

					if (match_string(cntrl, path))

						break;

					cntrl = NULL;

				}

				if (!cntrl) {

					log_debug("%s not found on whitelist, ignoring", path);

					return NULL;

				}

			} else if (!list_is_empty(&conf.cntrls_blacklist)) {

				char *cntrl;

				list_for_each(&conf.cntrls_blacklist, cntrl) {

					if (match_string(cntrl, path)) {

						log_debug("%s found on blacklist, ignoring",

							  path);

						return NULL;

					}

				}

			}

			device = malloc(sizeof(struct cntrl_device));

			if (device) {

				if (type == CNTRL_TYPE_SCSI) {

					device->isci_present = _is_isci_cntrl(path);

					device->hosts = _cntrl_get_hosts(path);

				} else {

					device->isci_present = 0;

					device->hosts = NULL;

				}

				device->cntrl_type = type;

				device->sysfs_path = str_dup(path);

			}

		} else {

			log_error

			    ("controller discovery: %s - enclosure " \

			     "management not supported.", path);

		}

	}

	return device;

}

/*

 * Frees memory allocated for controller device structure. See cntrl.h for

 * details.

 */

void cntrl_device_fini(struct cntrl_device *device)

{

	if (device) {

		free(device->sysfs_path);

		free_hosts(device->hosts);

		free(device);

	}

}

void print_cntrl(struct cntrl_device *ctrl_dev)

{

		printf("%s (%s)\n", ctrl_dev->sysfs_path,

			ctrl_type_str[ctrl_dev->cntrl_type]);

}