/*

 * Copyright (c) 2010, 2014, Oracle and/or its affiliates. All rights reserved.

 *

 * This software is available to you under a choice of one of two

 * licenses.  You may choose to be licensed under the terms of the GNU

 * General Public License (GPL) Version 2, available from the file

 * COPYING in the main directory of this source tree, or the

 * OpenIB.org BSD license below:

 *

 *     Redistribution and use in source and binary forms, with or

 *     without modification, are permitted provided that the following

 *     conditions are met:

 *

 *      - Redistributions of source code must retain the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer.

 *

 *      - Redistributions in binary form must reproduce the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer in the documentation and/or other materials

 *        provided with the distribution.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 */

#if HAVE_CONFIG_H

#include <config.h>

#endif /* HAVE_CONFIG_H */

/*

 * OFED Solaris wrapper

 */

#if defined(__SVR4) && defined(__sun)

#include <stdarg.h>

#include <fcntl.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/processor.h>

#include <stdio.h>

#include <stdlib.h>

#include <strings.h>

#include <sys/param.h>

#include <sys/ib/adapters/hermon/hermon_ioctl.h>

#include <sys/ib/adapters/tavor/tavor_ioctl.h>

#include <sys/ib/clients/of/sol_uverbs/sol_uverbs_ioctl.h>

#include <sys/ib/clients/of/sol_umad/sol_umad_ioctl.h>

#include <sys/ib/adapters/MELLANOX.h>

#include <alloca.h>

#include "../include/infiniband/arch.h"

#include "../include/infiniband/verbs.h"

#include <errno.h>

#include <pthread.h>

#include <kstat.h>

#define	min(a, b)	((a) < (b) ? (a) : (b))

/*

 * The followings will be removed when changes in hermon_ioctl.h

 * are delivered through ON.

 */

#ifndef	HERMON_GET_HWINFO_IOCTL_SUP

#define	HERMON_IOCTL_GET_HWINFO	(('t' << 8) | 0x32)

#pragma	pack(1)

/* Structure used for getting HW info */

typedef struct hermon_hw_info_ioctl_s {

	uint32_t	af_hw_info_version;

	uint32_t	af_padding1;	/* Padding for af_hwpn to be on */

					/* 64 byte boundary */

	char		af_hwpn[64];

	uint16_t	af_pn_len;

	uint64_t	af_padding2:48;	/* Padding for af_psid to be on */

					/* 64 byte boundary */

	char		af_psid[16];

	uint16_t	af_psid_len;

	uint32_t	af_padding3;	/* Padding for reserved to be on */

					/* 64 byte boundary */

	uint8_t		reserved[64];

} hermon_hw_info_ioctl_t;

#pragma	pack()

#endif

/*

 * duplicate ABI definitions for HCAs as the HCA abi headers are not

 * installed in proto.

 */

#define	MLX4_UVERBS_MAX_ABI_VERSION	3 /* mlx4-abi.h */

#define	RDMA_USER_CM_MIN_ABI_VERSION	3 /* rdma_cma_abi.h */

#define	RDMA_USER_CM_MAX_ABI_VERSION	4 /* rdma_cma_abi.h */

#define	MLX4	0

#define	HW_DRIVER_MAX_NAME_LEN			20

#define	UVERBS_KERNEL_SYSFS_NAME_BASE		"uverbs"

#define	UMAD_KERNEL_SYSFS_NAME_BASE		"umad"

#define	IB_HCA_DEVPATH_PREFIX			"/dev/infiniband/hca"

#define	IB_OFS_DEVPATH_PREFIX			"/dev/infiniband/ofs"

#define	CONNECTX_NAME				"mlx4_"

#define	MELLANOX_VENDOR_ID			0x15b3

#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

#define	INFINIHOST_DEVICE_ID_2			0x5a45

#define	INFINIHOST_DEVICE_ID_4			0x6279

#define	MAX_HCAS				(64*16)

#define	MAX_PORTS				(MAX_HCAS*2)

/*

 * sol_uverbs_drv_status is the status of what libibverbs knows

 * about the status of sol_uverbs driver.

 */

#define	SOL_UVERBS_DRV_STATUS_UNKNOWN	0x0

#define	SOL_UVERBS_DRV_STATUS_LOADED	0x1

#define	SOL_UVERBS_DRV_STATUS_UNLOADED	0x02

static kstat_ctl_t	*kc = NULL;	/* libkstat cookie */

static int sol_uverbs_drv_status = SOL_UVERBS_DRV_STATUS_UNKNOWN;

static int sol_uverbs_minor_dev = -1;

/*

 * check_path() prefixs

 */

typedef enum cp_prefix_e {

	CP_SOL_UVERBS		= 1,

	CP_DEVICE		= 2,

	CP_D			= 3,

	CP_GIDS			= 4,

	CP_PKEYS		= 5,

	CP_MLX4			= 6,

	CP_PORTS		= 7,

	CP_UMAD			= 8,

	CP_SLASH		= 9,

	CP_SYS			= 10,

	CP_CLASS		= 11,

	CP_INFINIBAND_VERBS	= 12,

	CP_INFINIBAND		= 13,

	CP_INFINIBAND_MAD	= 14,

	CP_MISC			= 15,

	CP_RDMA_CM		= 16

} cp_prefix_t;

/*

 * 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_node_guid_external_str[20];

	char		ibd_sys_image_guid[20];

	char		ibd_fw_ver[16];

	char		ibd_name[16];

	int		ibd_boardid_index;

	uint_t		ibd_device_id;

} ibdev_cache_info_t;

/* 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_ibdev_abi_version;

	uint_t		uvc_vendor_id;

	uint_t		uvc_device_id;

	int		uvc_hca_instance;

	char		uvc_ibdev_name[16];

	char		uvc_ibdev_hca_path[MAXPATHLEN];

} uverbs_cache_info_t;

static uverbs_cache_info_t	uverbs_dev_cache[MAX_HCAS];

static int			uverbs_abi_version = -1;

typedef struct umad_cache_info_s {

	uint_t		umc_valid;

	int		umc_port;

	char		umc_ib_dev[16];

} umad_cache_info_t;

static umad_cache_info_t	umad_dev_cache[MAX_PORTS];

static int			umad_abi_version = -1;

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;

int sol_ibv_query_gid(struct ibv_context *, uint8_t, int, union ibv_gid *);

int sol_ibv_query_pkey(struct ibv_context *, uint8_t, int, uint16_t *);

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

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

void

solaris_init(void)

{

	while ((kc = kstat_open()) == NULL) {

		if (errno == EAGAIN)

			(void) poll(NULL, 0, 200);

		else

			fprintf(stderr, "cannot open /dev/kstat: %s\n",

			    strerror(errno));

	}

}

void

solaris_fini(void)

{

	(void) kstat_close(kc);

}

static int

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

{

	if ((dev_num >= MAX_PORTS) || (umad_cache_cnt >= MAX_PORTS)) {

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

		return (1);

	}

	umad_dev_cache[dev_num].umc_port = port;

	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 {

		fprintf(stderr, "dev %d: has no proper ibdev name\n", dev_num);

		return (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_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++) {

			    *dev_list);

			goto error_exit2;

		}

		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.node_guid_external);

		sprintf(info.ibd_node_guid_external_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;

		info.ibd_device_id = device_attr.vendor_part_id;

		ibdev = ibv_get_device_name(*dev_list);

		if (strncmp(ibdev, "mlx4_", 5) == 0) {

			p = ibdev + (strlen("mlx4_"));

		} else {

			fprintf(stderr, "Invalid device %s\n", ibdev);

		}

		dev_num = atoi(p);

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

		info.ibd_boardid_index = -1;

		if (ibdev_cache_add(dev_num, &info)) {

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

			    dev_num);

		}

	}

	ret = 0;

	/* clean up and Return */

error_exit2:

	if (root_dev_list)

		ibv_free_device_list(root_dev_list);

error_exit1:

	return (ret);

}

static int

uverbs_cache_init()

{

	uverbs_cache_info_t	info;

	int			dev_num, fd, i, bufsize, hca_cnt;

	char			uverbs_devpath[MAXPATHLEN];

#ifndef	IB_USER_VERBS_V2_IN_V1

	sol_uverbs_info_t	*uverbs_infop;

	sol_uverbs_hca_info_t	*hca_infop;

#else

	sol_uverbs_info_v2_t	*uverbs_infop;

	sol_uverbs_hca_info_v2_t	*hca_infop;

#endif

	char *buf;

	snprintf(uverbs_devpath, MAXPATHLEN, "%s/%s%d",

	    IB_OFS_DEVPATH_PREFIX, UVERBS_KERNEL_SYSFS_NAME_BASE,

	    sol_uverbs_minor_dev);

	/*

	 * using the first sol_uverbs minor node that can be opened to get

	 * all the HCA information

	 */

	if ((fd = open(uverbs_devpath, O_RDWR)) < 0) {

		fprintf(stderr, "sol_uverbs failed to open: %s\n",

		    strerror(errno));

		goto error_exit1;

	}

#ifndef	IB_USER_VERBS_V2_IN_V1

	bufsize = sizeof (sol_uverbs_info_t) + sizeof (sol_uverbs_hca_info_t) *

	    MAX_HCAS;

#else

	bufsize = sizeof (sol_uverbs_info_v2_t) +

	    sizeof (sol_uverbs_hca_info_v2_t) * MAX_HCAS;

#endif

	buf = malloc(bufsize);

	memset(buf, 0, bufsize);

#ifndef	IB_USER_VERBS_V2_IN_V1

	uverbs_infop = (sol_uverbs_info_t *)buf;

#else

	uverbs_infop = (sol_uverbs_info_v2_t *)buf;

#endif

	uverbs_infop->uverbs_hca_cnt = MAX_HCAS;

	if (ioctl(fd, UVERBS_IOCTL_GET_HCA_INFO, uverbs_infop) != 0) {

		fprintf(stderr, "sol_uverbs ioctl failed: %s\n",

		    strerror(errno));

		goto error_exit2;

	}

	if (uverbs_infop->uverbs_solaris_abi_version !=

	    IB_USER_VERBS_SOLARIS_ABI_VERSION) {

		fprintf(stderr, "sol_uverbs solaris_abi_version !="

		    "IB_USER_VERBS_SOLARIS_ABI_VERSION : %d\n",

		    uverbs_infop->uverbs_solaris_abi_version);

		goto error_exit2;

	}

	hca_cnt = uverbs_infop->uverbs_hca_cnt;	/* hca count returned */

	hca_infop = uverbs_infop->uverbs_hca_info;

	if (uverbs_abi_version == -1)

		uverbs_abi_version = uverbs_infop->uverbs_abi_version;

	for (i = 0; i < hca_cnt; i++, hca_infop++) {

		info.uvc_vendor_id = hca_infop->uverbs_hca_vendorid;

		info.uvc_device_id = hca_infop->uverbs_hca_deviceid;

		info.uvc_hca_instance =

		    hca_infop->uverbs_hca_driver_instance;

		snprintf(info.uvc_ibdev_hca_path,

		    sizeof (info.uvc_ibdev_hca_path),

		    "%s/%s%d", IB_HCA_DEVPATH_PREFIX,

		    hca_infop->uverbs_hca_driver_name,

		    hca_infop->uverbs_hca_driver_instance);

		if (strncmp(hca_infop->uverbs_hca_ibdev_name, "mlx4_", 5) == 0)

			info.uvc_ibdev_abi_version =

			    MLX4_UVERBS_MAX_ABI_VERSION;

		else {

			fprintf(stderr, "libibverbs: sol_uverbs unsupported "

			    "device: %s\n", hca_infop->uverbs_hca_ibdev_name);

			goto error_exit2;

		}

		strcpy(info.uvc_ibdev_name, hca_infop->uverbs_hca_ibdev_name);

		dev_num = hca_infop->uverbs_hca_devidx;

		if (uverbs_cache_add(dev_num, &info)) {

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

			    "cache\n", dev_num);

			goto error_exit2;

		}

	}

	free(buf);

	close(fd);

	return (1);

error_exit2:

	free(buf);

	close(fd);

error_exit1:

	return (0);

}

static int

umad_cache_init()

{

	int				i, fd, minor;

	int				save_errno = 0;

	int				port_cnt, bufsize;

	char				umad_devpath[MAXPATHLEN], *buf;

	sol_umad_ioctl_info_t		*umad_infop;

	sol_umad_ioctl_port_info_t	*port_infop;

	for (minor = 0; minor < MAX_PORTS; minor++) {

		snprintf(umad_devpath, MAXPATHLEN, "%s/%s%d",

		    IB_OFS_DEVPATH_PREFIX, UMAD_KERNEL_SYSFS_NAME_BASE,

		    minor);

		if ((fd = open(umad_devpath, O_RDWR)) > 0)

			break;

		if ((! save_errno) && (errno != ENOENT))

			save_errno = errno;

	}

	if ((minor == MAX_PORTS) && (fd < 0)) {

		if (! save_errno)

			save_errno = errno;

		fprintf(stderr, "failed to open sol_umad: %s\n",

		    strerror(save_errno));

		return (0);

	}

	bufsize = sizeof (sol_umad_ioctl_info_t) +

	    (sizeof (sol_umad_ioctl_port_info_t) * MAX_PORTS);

	buf = malloc(bufsize);

	memset(buf, 0, bufsize);

	umad_infop = (sol_umad_ioctl_info_t *)buf;

	umad_infop->umad_port_cnt = MAX_PORTS;

	if (ioctl(fd, IB_USER_MAD_GET_PORT_INFO, umad_infop) != 0) {