#include <config.h>

#include <pthread.h>

#define	MLX4	0

#define	MTHCA	1

#define	MAX_HCAS				16

#define	MAX_HCA_PORTS				16

#define	HW_DRIVER_MAX_NAME_LEN			20

#define	UVERBS_KERNEL_SYSFS_NAME		"sol_uverbs@0:uverbs0"

#define	UVERBS					"sol_uverbs"

#define	UMAD					"sol_umad"

#define	CONNECTX_NAME				"mlx4_"

#define	INFINIHOST_NAME				"mthca"

#define	MAX_HCA_DEVCTRL_PATH_LEN		MAXPATHLEN/4

#define	PCI_DEVICE_ID_MELLANOX_TAVOR		0x5a44

#define	PCI_DEVICE_ID_MELLANOX_ARBEL		0x6282

#define	PCI_DEVICE_ID_MELLANOX_ARBEL_COMPAT	0x6278

#define	PCI_DEVICE_ID_MELLANOX_HERMON_SDR	0x6340

#define	PCI_DEVICE_ID_MELLANOX_HERMON_DDR	0x634a

#define	PCI_DEVICE_ID_MELLANOX_HERMON_QDR	0x6354

#define	PCI_DEVICE_ID_MELLANOX_HERMON_DDR_PCIE2	0x6732

#define	PCI_DEVICE_ID_MELLANOX_HERMON_QDR_PCIE2	0x673c

	CP_DEVICE		= 2,

 * Some temporary cache code, until things are cleaned up as part of DR

 * work. This will speed up the sysfs emulation.

 */

typedef struct ibdev_cache_info_s {

	uint_t		ibd_valid;

	uint_t		ibd_hw_rev;

	char		ibd_node_guid_str[20];

	char		ibd_sys_image_guid[20];

	char		ibd_fw_ver[16];

	char		ibd_name[8];

} ibdev_cache_info_t;

/* tavor and hermon - hence 2 */

static ibdev_cache_info_t ibdev_cache[2][MAX_HCAS];

typedef struct uverbs_cache_info_s {

	uint_t		uvc_valid;

	uint_t		uvc_abi_version;

	uint_t		uvc_ibdev_abi_version;

	uint_t		uvc_vendor_id;

	uint_t		uvc_device_id;

	int		uvc_hca_instance;

	char		uvc_ibdev_name[8];

	char		uvc_ibdev_hca_path[MAX_HCA_DEVCTRL_PATH_LEN];

} uverbs_cache_info_t;

static uverbs_cache_info_t uverbs_dev_cache[MAX_HCAS];

typedef struct umad_cache_info_s {

	uint_t		umc_valid;

	int		umc_port;

	int		umc_abi_version;

	char		umc_ib_dev[16];

} umad_cache_info_t;

static umad_cache_info_t umad_dev_cache[MAX_HCAS * MAX_HCA_PORTS];

pthread_once_t		oneTimeInit = PTHREAD_ONCE_INIT;

static int 		umad_cache_cnt = 0;

static int 		ibdev_cache_cnt = 0;

static int 		uverbs_cache_cnt = 0;

static boolean_t	initialized = B_FALSE;

static boolean_t	umad_cache_initialized = B_FALSE;

static boolean_t	ibdev_cache_initialized = B_FALSE;

static boolean_t	uverbs_cache_initialized = B_FALSE;

static pthread_mutex_t	umad_cache_mutex = PTHREAD_MUTEX_INITIALIZER;

static pthread_mutex_t	ibdev_cache_mutex = PTHREAD_MUTEX_INITIALIZER;

static pthread_mutex_t	uverbs_cache_mutex = PTHREAD_MUTEX_INITIALIZER;

static di_node_t	root_node;

void __attribute__ ((constructor)) solaris_init(void);

void __attribute__ ((destructor)) solaris_fini(void);

void

solaris_init(void)

{

	root_node = di_init("/", DINFOCPYALL);

	if (root_node == DI_NODE_NIL) {

		fprintf(stderr, "di_init failed: %s\n", strerror(errno));

		exit(1);

	}

}

void

solaris_fini(void)

{

	di_fini(root_node);

}

static void

vendor_device_id_to_name(int vendor, int device, char *name)

{

	char *hca_name = "<unknown>";

	if (vendor == MELLANOX_VENDOR_ID) {

		switch (device) {

		case PCI_DEVICE_ID_MELLANOX_HERMON_SDR:

		case PCI_DEVICE_ID_MELLANOX_HERMON_DDR:

		case PCI_DEVICE_ID_MELLANOX_HERMON_QDR:

		case PCI_DEVICE_ID_MELLANOX_HERMON_DDR_PCIE2:

		case PCI_DEVICE_ID_MELLANOX_HERMON_QDR_PCIE2:

			hca_name = CONNECTX_NAME;

			break;

		case PCI_DEVICE_ID_MELLANOX_TAVOR:

		case PCI_DEVICE_ID_MELLANOX_ARBEL_COMPAT:

		case INFINIHOST_DEVICE_ID_2:

		case INFINIHOST_DEVICE_ID_4:

			hca_name = INFINIHOST_NAME;

			break;

		}

	}

	(void) strcpy(name, hca_name);

}

static int

umad_cache_add(uint_t dev_num, int port, char *ibdev, int abi_version)

{

	if ((dev_num >= (MAX_HCAS  * MAX_HCA_PORTS)) ||

	    (umad_cache_cnt >= (MAX_HCAS  * MAX_HCA_PORTS))) {

		fprintf(stderr, "dev %d: exceeds umad cache size\n", dev_num);

		return (1);

	}

	umad_dev_cache[dev_num].umc_port = port;

	umad_dev_cache[dev_num].umc_abi_version = abi_version;

	strcpy(umad_dev_cache[dev_num].umc_ib_dev, ibdev);

	umad_dev_cache[dev_num].umc_valid = 1;

	umad_cache_cnt++;

	return (0);

}

static int

ibdev_cache_add(uint_t dev_num, ibdev_cache_info_t *info_p)

{

	if ((dev_num >= MAX_HCAS) || (ibdev_cache_cnt >= (MAX_HCAS * 2))) {

		fprintf(stderr, "dev %d: exceeds hca cache size\n", dev_num);

		return (1);

	}

	if (!(strncmp(info_p->ibd_name, "mlx4", 4))) {

		memcpy(&(ibdev_cache[MLX4][dev_num]), info_p,

		    sizeof (ibdev_cache_info_t));

		ibdev_cache[MLX4][dev_num].ibd_valid = 1;

	} else {

		memcpy(&(ibdev_cache[MTHCA][dev_num]), info_p,

		    sizeof (ibdev_cache_info_t));

		ibdev_cache[MTHCA][dev_num].ibd_valid = 1;

	}

	ibdev_cache_cnt++;

	return (0);

}

static int

uverbs_cache_add(uint_t dev_num, uverbs_cache_info_t *info_p)

{

	if ((dev_num >= MAX_HCAS) || (uverbs_cache_cnt >= MAX_HCAS)) {

		fprintf(stderr, "dev %d: exceeds uverbs cache size\n", dev_num);

		return (1);

	}

	memcpy(&(uverbs_dev_cache[dev_num]), info_p,

	    sizeof (uverbs_cache_info_t));

	uverbs_dev_cache[dev_num].uvc_valid = 1;

	uverbs_cache_cnt++;

	return (0);

}

static int

ibdev_cache_init()

{

	ibdev_cache_info_t	info;

	struct ibv_device	**root_dev_list, **dev_list = NULL;

	struct ibv_context	*ctx = NULL;

	struct ibv_device_attr	device_attr;

	int			i, num_dev, dev_num, ret = 1;

	uint64_t		guid;

	const char		*p, *ibdev;

	root_dev_list = dev_list = ibv_get_device_list(&num_dev);

	if (!dev_list) {

		fprintf(stderr, "No HCA devices found");

		goto error_exit1;

	}

	for (i = 0; i < num_dev; i++, dev_list++) {

		if (!(ctx = ibv_open_device(*dev_list))) {

			fprintf(stderr, "failed to open device %p\n",

			    *dev_list);

			goto error_exit2;

		}

		if (ibv_query_device(ctx, &device_attr)) {

			fprintf(stderr, "failed to query device %p\n", ctx);

			goto error_exit3;

		}

		guid = ntohll(device_attr.node_guid);

		sprintf(info.ibd_node_guid_str, "%04x:%04x:%04x:%04x",

		    (unsigned) (guid >> 48) & 0xffff,

		    (unsigned) (guid >> 32) & 0xffff,

		    (unsigned) (guid >> 16) & 0xffff,

		    (unsigned) (guid >>  0) & 0xffff);

		guid = ntohll(device_attr.sys_image_guid);

		sprintf(info.ibd_sys_image_guid, "%04x:%04x:%04x:%04x",

		    (unsigned) (guid >> 48) & 0xffff,

		    (unsigned) (guid >> 32) & 0xffff,

		    (unsigned) (guid >> 16) & 0xffff,

		    (unsigned) (guid >>  0) & 0xffff);

		(void) strcpy(info.ibd_fw_ver, device_attr.fw_ver);

		info.ibd_hw_rev = device_attr.hw_ver;

		ibdev = ibv_get_device_name(*dev_list);

		p = ibdev + (strlen(ibdev)-1);

		dev_num = atoi(p);

		(void) strcpy(info.ibd_name, ibdev);

		if (ibdev_cache_add(dev_num, &info)) {

			fprintf(stderr, "failed to add dev %d to ibdev cache\n",

			    dev_num);

			goto error_exit3;

		}

	}

	ret = 0;

	/* clean up and Return */

error_exit3:

	if (ctx)

		ibv_close_device(ctx);

error_exit2:

	if (root_dev_list)

		ibv_free_device_list(root_dev_list);

error_exit1:

	return (ret);

}

static void

uverbs_cache_init()

{

	uverbs_cache_info_t	info;

	di_node_t		node, node_child, hca_node;

	di_minor_t		node_minor;

	dev_t			devt;

	int64_t			*guid, *hca_guid;

	int			*intv;

	int			minor_num, dev_num, hca_type;

	int			mlx4_devs = 0;

	int			mthca_devs = 0;

	char			*p, *minor_str, *path;

	char			ibdev[8];

	if (sol_uverbs_drv_status != SOL_UVERBS_DRV_STATUS_LOADED) {

		fprintf(stderr, "sol_uverbs not loaded\n");

		goto error_exit1;

	}

	node = di_drv_first_node(UVERBS, root_node);

	if (node == DI_NODE_NIL) {

		fprintf(stderr, "no sol_verbs device node\n");

		goto error_exit1;

	}

	node_minor = di_minor_next(node, DI_MINOR_NIL);

	while (node_minor != DI_MINOR_NIL) {

		devt = di_minor_devt(node_minor);

		minor_num = (devt & 0x0000FFFF);

		minor_str = di_minor_name(node_minor);

		p = minor_str;

		p = p + (strlen(p)-1);

		dev_num = atoi(p);

		/* minor_num should match uverbs num */

		if (minor_num != dev_num) {

			node_minor = di_minor_next(node, node_minor);

			continue;

		}

		if (di_prop_lookup_ints(devt, node, "vendor-id", &intv) != 1) {

			goto error_exit1;

		}

		info.uvc_vendor_id = *intv;

		if (di_prop_lookup_ints(devt, node, "device-id", &intv) != 1) {

		    goto error_exit1;

		}

		info.uvc_device_id = *intv;

		if (di_prop_lookup_int64(devt, node, "guid", &guid) != 1) {

		    goto error_exit1;

		}

		/* abi version only on minor node 0 */

		if (minor_num == 0) {

			if (di_prop_lookup_ints(devt, node, "abi-version",

			    &intv) != 1) {

				goto error_exit1;

			}

			info.uvc_abi_version = *intv;

		}

		/*

		 * Find the HCA device instance that has an ibport child

		 * with the same GUID as our ibdev.

		 */

		vendor_device_id_to_name(info.uvc_vendor_id, info.uvc_device_id,

		    ibdev);

		if (!(strncmp(ibdev, "mlx4_", 5))) {

			info.uvc_ibdev_abi_version =

			    MLX4_UVERBS_MAX_ABI_VERSION;

			sprintf(info.uvc_ibdev_name, "mlx4_%d", mlx4_devs);

			mlx4_devs++;

			hca_type = MLX4;

			hca_node = di_drv_first_node("hermon", root_node);

		} else if (!(strncmp(ibdev, "mthca", 5))) {

			sprintf(info.uvc_ibdev_name, "mthca%d", mthca_devs);

			mthca_devs++;

			hca_type = MTHCA;

			info.uvc_ibdev_abi_version = MTHCA_UVERBS_ABI_VERSION;

			hca_node = di_drv_first_node("tavor", root_node);

		} else {

			fprintf(stderr, "Unsupported driver, device %s\n",

			    ibdev);

			goto error_exit1;

		}

		while (hca_node != DI_NODE_NIL) {

			node_child = di_child_node(hca_node);

			while (node_child != DI_MINOR_NIL) {

				if (di_prop_lookup_int64(DDI_DEV_T_ANY,

				    node_child, "hca-guid", &hca_guid) != 1) {

					node_child =

					    di_sibling_node(node_child);

				} else {

					break;

				}

			}

			if (*hca_guid == *guid) {

				break;

			}

			hca_node = di_drv_next_node(hca_node);

		}

		if (hca_node == DI_NODE_NIL) {

			fprintf(stderr, "Could not find hca hardware driver");

			goto error_exit1;

		}

		path = di_devfs_path(hca_node);

		strcpy(info.uvc_ibdev_hca_path, path);

		di_devfs_path_free(path);

		info.uvc_hca_instance = di_instance(hca_node);

		if (uverbs_cache_add(dev_num, &info)) {

			fprintf(stderr, "failed to add dev %d to uverbs "

			    "cache\n", dev_num);

			goto error_exit1;

		}

		node_minor = di_minor_next(node, node_minor);

	}

	return;

error_exit1:

	exit(1);

}

static void

umad_cache_init()

{

	di_node_t		umad_node;

	di_minor_t		minor_node;

	di_prop_t		prop, next;

	char			*minor_str;

	dev_t			dev;

	int			*vendorids, *deviceids, *ports;

	int			*abi_version, *hcas;

	int			dev_num, type, i;

	char			*p, *name;

	umad_node = di_drv_first_node("sol_umad", root_node);

	if (umad_node == DI_NODE_NIL) {

		fprintf(stderr, "no sol_umad device node\n");

		goto error_exit1;

	}

	/*

	 * get sol_umad abi_version property which is a major node proprty.

	 */

	if ((next = di_prop_next(umad_node, DI_PROP_NIL)) == DI_PROP_NIL) {