/*

 * Copyright (c) 2010, 2011, 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 <alloca.h>

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

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

#include <errno.h>

#include <pthread.h>

#include <kstat.h>

/*

 * The followings will be removed when sol_uverbs_ioctl.h and sol_umad_ioctl.h

 * are delivered through ON.

 */

#define	UVERBS_IOCTL		('v' << 8)

#define	IB_USER_VERBS_SOLARIS_ABI_VERSION	1

typedef enum {

	UVERBS_IOCTL_GET_HCA_INFO	= UVERBS_IOCTL | 0x01

} uverbs_ioctl_enum_t;

typedef struct sol_uverbs_hca_info_s {

	char		uverbs_hca_psid_string[MAXNAMELEN];

	char		uverbs_hca_ibdev_name[MAXNAMELEN];

	char		uverbs_hca_driver_name[MAXNAMELEN];

	uint32_t	uverbs_hca_driver_instance;

	uint32_t	uverbs_hca_vendorid;

	uint16_t	uverbs_hca_deviceid;

	uint8_t		uverbs_hca_devidx;

	uint8_t		uverbs_hca_pad1[5];

} sol_uverbs_hca_info_t;

typedef struct sol_uverbs_info_s {

	int32_t			uverbs_abi_version;

	int32_t			uverbs_solaris_abi_version;

	int16_t			uverbs_hca_cnt;

	int8_t			uverbs_pad1[6];    /* Padding for alignment */

	sol_uverbs_hca_info_t	uverbs_hca_info[];

} sol_uverbs_info_t;

#define	UMAD_IOCTL		('m' << 8)

#define	IB_USER_MAD_SOLARIS_ABI_VERSION	1

typedef enum {

	IB_USER_MAD_GET_PORT_INFO	= UMAD_IOCTL | 0x01

} umad_ioctl_enum_t;

typedef struct sol_umad_ioctl_port_info_s {

	char		umad_port_ibdev_name[MAXNAMELEN];

	uint32_t	umad_port_num;

	uint16_t	umad_port_idx;

	uint8_t		umad_port_pad1[2];

} sol_umad_ioctl_port_info_t;

typedef struct sol_umad_ioctl_info_s {

	int32_t				umad_abi_version;

	int32_t				umad_solaris_abi_version;

	int16_t				umad_port_cnt;

	int8_t				umad_pad1[6];    /* alignment padding */

	sol_umad_ioctl_port_info_t	umad_port_info[];

} sol_umad_ioctl_info_t;

/* end of sol_uverbs_ioctl.h and sol_umad_ioctl.h contents */

/*

 * 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	MAX_HCAS				16

#define	MAX_HCA_PORTS				16

#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

/*

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

	char		ibd_fw_ver[16];

	char		ibd_name[8];

	int		ibd_boardid_index;

} ibdev_cache_info_t;

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[8];

	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_HCAS * MAX_HCA_PORTS];

static int			umad_abi_version = -1;

/*

 * Structure to hold the part number  & PSID for an HCA card

 * This is a sub-set of the file :

 * /ws/onnv-clone/usr/src/cmd/fwflash/plugins/hdrs/MELLANOX.h

 */

typedef struct mlx_mdr_s {

	char *mlx_pn;

	char *mlx_psid;

} mlx_mdr_t;

/*

 * Magic decoder ring for matching HCA hardware/firmware.

 * Part Number / PSID / String ID

 */

mlx_mdr_t mlx_mdr[] = {

	/* For failure case, use unknown as "board-id" */

	{ "unknown",		"unknown"	},

	/* Part No		PSID		*/

	{ "375-3605-01",	"SUN0160000001" },

	{ "375-3382-01",	"SUN0030000001" },

	{ "375-3481-01",	"SUN0040000001" },

	{ "375-3418-01",	"SUN0040000001" },

	{ "375-3259-01",	"SUN0010000001" },

	{ "375-3259-03",	"SUN0010000001" },

	{ "X1289A-Z",		"SUN0010010001" },

	{ "375-3548-01",	"SUN0060000001" },

	{ "375-3549-01",	"SUN0070000001" },

	{ "375-3549-01",	"SUN0070130001" },

	{ "375-3481-01",	"SUN0050000001" },

	{ "375-3439-01",	"SUN0051000001" },

	{ "375-3260-03",	"SUN0020000001" },

	{ "375-3605-01",	"SUN0160000002" },

	{ "375-3697-01",	"SUN0160000002" },

	{ "375-3606-01",	"SUN0150000001" },

	{ "375-3606-02",	"SUN0150000009" },

	{ "375-3606-03",	"SUN0150000009" },

	{ "375-3606-02",	"SUN0170000009" },

	{ "375-3696-01",	"SUN0170000009" },

	{ "375-3551-05",	"SUN0080000001" },

	{ "MHEA28-XS",		"MT_0250000001" },

	{ "MHEA28-XSC",		"MT_0390110001" },

	{ "MHEA28-XT",		"MT_0150000001" },

	{ "MHEA28-XTC",		"MT_0370110001" },

	{ "MHGA28-XT",		"MT_0150000002" },

	{ "MHGA28-XTC",		"MT_0370110002" },

	{ "MHGA28-XTC",		"MT_0370130002" },

	{ "MHGA28-XS",		"MT_0250000002" },

	{ "MHGA28-XSC",		"MT_0390110002" },

	{ "MHGA28-XSC",		"MT_0390130002" },

	{ "MHEL-CF128",		"MT_0190000001" },

	{ "MHEL-CF128-T",	"MT_00A0000001" },

	{ "MTLP25208-CF128T",	"MT_00A0000001" },

	{ "MHEL-CF128-TC",	"MT_00A0010001" },

	{ "MHEL-CF128-TC",	"MT_0140010001" },

	{ "MHEL-CF128-SC",	"MT_0190010001" },

	{ "MHEA28-1TC",		"MT_02F0110001" },

	{ "MHEA28-1SC",		"MT_0330110001" },

	{ "MHGA28-1T",		"MT_0200000001" },

	{ "MHGA28-1TC",		"MT_02F0110002" },

	{ "MHGA28-1SC",		"MT_0330110002" },

	{ "MHGA28-1S",		"MT_0430000001" },

	{ "MHEL-CF256-T",	"MT_00B0000001" },

	{ "MTLP25208-CF256T",	"MT_00B0000001" },

	{ "MHEL-CF256-TC",	"MT_00B0010001" },

	{ "MHEA28-2TC",		"MT_0300110001" },

	{ "MHEA28-2SC",		"MT_0340110001" },

	{ "MHGA28-2T",		"MT_0210000001" },

	{ "MHGA28-2TC",		"MT_0300110002" },

	{ "MHGA28-2SC",		"MT_0340110002" },

	{ "MHEL-CF512-T",	"MT_00C0000001" },

	{ "MTLP25208-CF512T",	"MT_00C0000001" },

	{ "MHGA28-5T",		"MT_0220000001" },

	{ "MHES14-XSC",		"MT_0410110001" },

	{ "MHES14-XT",		"MT_01F0000001" },

	{ "MHES14-XTC",		"MT_03F0110001" },

	{ "MHES18-XS",		"MT_0260000001" },

	{ "MHES18-XS",		"MT_0260010001" },

	{ "MHES18-XSC",		"MT_03D0110001" },

	{ "MHES18-XSC",		"MT_03D0120001" },

	{ "MHES18-XSC",		"MT_03D0130001" },

	{ "MHES18-XT",		"MT_0230000002" },

	{ "MHES18-XT",		"MT_0230010002" },

	{ "MHES18-XTC",		"MT_03B0110001" },

	{ "MHES18-XTC",		"MT_03B0120001" },

	{ "MHES18-XTC",		"MT_03B0140001" },

	{ "MHGS18-XS",		"MT_0260000002" },

	{ "MHGS18-XSC",		"MT_03D0110002" },

	{ "MHGS18-XSC",		"MT_03D0120002" },

	{ "MHGS18-XSC",		"MT_03D0130002" },

	{ "MHGS18-XT",		"MT_0230000001" },

	{ "MHGS18-XTC",		"MT_03B0110002" },

	{ "MHGS18-XTC",		"MT_03B0120002" },

	{ "MHGS18-XTC",		"MT_03B0140002" },

	{ "MHXL-CF128",		"MT_0180000001" },

	{ "MHXL-CF128-T",	"MT_0030000001" },

	{ "MTLP23108-CF128T",	"MT_0030000001" },

	{ "MHET2X-1SC",		"MT_0280110001" },

	{ "MHET2X-1SC",		"MT_0280120001" },

	{ "MHET2X-1TC",		"MT_0270110001" },

	{ "MHET2X-1TC",		"MT_0270120001" },

	{ "MHXL-CF256-T",	"MT_0040000001" },

	{ "MHET2X-2SC",		"MT_02D0110001" },

	{ "MHET2X-2SC",		"MT_02D0120001" },

	{ "MHET2X-2TC",		"MT_02B0110001" },

	{ "MHET2X-2TC",		"MT_02B0120001" },

	{ "MHX-CE128-T",	"MT_0000000001" },

	{ "MTPB23108-CE128",	"MT_0000000001" },

	{ "MHX-CE256-T",	"MT_0010000001" },

	{ "MTPB23108-CE256",	"MT_0010000001" },

	{ "MHX-CE512-T",	"MT_0050000001" },

	{ "MTPB23108-CE512",	"MT_0050000001" },

	{ "MHEH28-XSC",		"MT_04C0110001" },

	{ "MHEH28-XSC",		"MT_04C0130005" },

	{ "MHEH28-XTC",		"MT_04A0110001" },

	{ "MHEH28-XTC",		"MT_04A0130005" },

	{ "MHGH28-XSC",		"MT_04C0110002" },

	{ "MHGH28-XSC",		"MT_04C0120002" },

	{ "MHGH28-XSC",		"MT_04C0140005" },

	{ "MHGH28-XTC",		"MT_04A0110002" },

	{ "MHGH28-XTC",		"MT_04A0120002" },

	{ "MHGH28-XTC",		"MT_04A0140005" },

	{ "MHGH29-XSC",		"MT_0A60110002" },

	{ "MHGH29-XSC",		"MT_0A60120005" },

	{ "MHGH29-XTC",		"MT_0A50110002" },

	{ "MHGH29-XTC",		"MT_0A50120005" },

	{ "MHJH29-XTC",		"MT_04E0110003" },

	{ "MHJH29-XSC",		"MT_0500120005" },

	{ "MHQH29-XTC",		"MT_04E0120005" },

	{ "MHQH19-XTC",		"MT_0C40110009" },

	{ "MHQH29-XTC",		"MT_0BB0110003" },

	{ "MHQH29-XTC",		"MT_0BB0120003" },

	{ "MHEH28B-XSR",	"MT_0D10110001" },

	{ "MHEH28B-XTR",	"MT_0D20110001" },

	{ "MHGH28B-XSR",	"MT_0D10110002" },

	{ "MHGH28B-XTR",	"MT_0D20110002" },

	{ "MHGH18B-XTR",	"MT_0D30110002" },

	{ "MNEH28B-XSR",	"MT_0D40110004" },

	{ "MNEH28B-XTR",	"MT_0D50110004" },

	{ "MNEH29B-XSR",	"MT_0D40110010" },

	{ "MNEH29B-XTR",	"MT_0D50110010" },

	{ "MHGH29B-XSR",	"MT_0D10110008" },

	{ "MHGH29B-XTR",	"MT_0D20110008" },

	{ "MHJH29B-XSR",	"MT_0D10110009" },

	{ "MHJH29B-XSR",	"MT_0D10120009" },

	{ "MHJH29B-XTR",	"MT_0D20110009" },

	{ "MHJH29B-XTR",	"MT_0D20120009" },

	{ "MHGH19B-XSR",	"MT_0D60110008" },

	{ "MHGH19B-XTR",	"MT_0D30110008" },

	{ "MHJH19B-XTR",	"MT_0D30110009" },

	{ "MHQH29B-XSR",	"MT_0D70110009" },

	{ "MHQH29B-XTR",	"MT_0D80110009" },

	{ "MHQH29B-XTR",	"MT_0D80120009" },

	{ "MHQH29B-XTR",	"MT_0D80130009" },

	{ "MHQH29B-XTR",	"MT_0E30110009" },

	{ "MHRH29B-XSR",	"MT_0D70110008" },

	{ "MHRH29B-XTR",	"MT_0D80110008" },

	{ "MHQH19B-XTR",	"MT_0D90110009" },

	{ "MHRH19B-XSR",	"MT_0E40110009" },

	{ "MHRH19B-XTR",	"MT_0D90110008" },

	{ "MNPH28C-XSR",	"MT_0DA0110004" },

	{ "MNPH28C-XTR",	"MT_0DB0110004" },

	{ "MNPH29C-XSR",	"MT_0DA0110010" },

	{ "MNPH29C-XTR",	"MT_0DB0110010" },

	{ "MNPH29C-XTR",	"MT_0DB0120010" },

	{ "MNPH29C-XTR",	"MT_0DB0130010" },

	{ "MNZH29-XSR",		"MT_0DC0110009" },

	{ "MNZH29-XTR",		"MT_0DD0110009" },

	{ "MNZH29-XTR",		"MT_0DD0120009" },

	{ "MHQH19B-XNR",	"MT_0DF0110009" },

	{ "MHQH19B-XNR",	"MT_0DF0120009" },

	{ "MNQH19-XTR",		"MT_0D80110017" },

	{ "MNQH19C-XTR",	"MT_0E20110017" },

	{ "MHZH29B-XSR",	"MT_0E80110009" },

	{ "MHZH29B-XTR",	"MT_0E90110009" },

	{ "MHZH29B-XTR",	"MT_0E90110009" },

	{ "MHQA19-XTR",		"MT_0EA0110009" },

	{ "MHRA19-XTR",		"MT_0EB0110008" },

	{ "MHQH29C-XTR",	"MT_0EF0110009" },

	{ "MHQH29C-XSR",	"MT_0F00110009" },

	{ "MHRH29C-XTR",	"MT_0F10110008" },

	{ "MHRH29C-XSR",	"MT_0F20110008" },

	{ "MHPH29D-XTR",	"MT_0F30110010" },

	{ "MHPH29D-XSR",	"MT_0F40110010" },

	{ "MNPA19-XTR",		"MT_0F60110010" },

	{ "MNPA19-XSR",		"MT_0F70110010" },

	/* Ethernet cards */

	{ "MNEH28B-XTR",	"MT_0D50110004" },

	{ "MNEH29B-XSR",	"MT_0D40110010" },

	{ "MNEH29B-XTR",	"MT_0D50110010" },

	{ "MNPH28C-XSR",	"MT_0DA0110004" },

	{ "MNPH28C-XTR",	"MT_0DB0110004" },

	{ "MNPH29C-XSR",	"MT_0DA0110010" },

	{ "MNPH29C-XTR",	"MT_0DB0110010" },

	{ "X6275 M2 10GbE",	"X6275M2_10G"   }

};

/* Get mlx_mdr[] array size */

#define	MLX_SZ_MLX_MDR		sizeof (mlx_mdr)

#define	MLX_SZ_MLX_MDR_STRUCT	sizeof (mlx_mdr[0])

#define	MLX_MAX_ID		(MLX_SZ_MLX_MDR / MLX_SZ_MLX_MDR_STRUCT)

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;

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_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;

	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 {

	}

	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;