/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2009, Intel Corporation.
 * All rights reserved.
 */

#include <sys/conf.h>
#include <sys/cmn_err.h>
#include <sys/ddi.h>
#include <sys/file.h>
#include <sys/modctl.h>
#include <sys/pci.h>
#include <sys/policy.h>
#include <sys/stat.h>
#include <sys/sunddi.h>
#include <sys/synch.h>
#include <sys/fipe.h>

/* Configurable through /etc/system. */
int			fipe_allow_attach = 1;
int 			fipe_allow_detach = 1;

static kmutex_t		fipe_drv_lock;
static dev_info_t	*fipe_drv_dip;

/*
 * PCI device ID for supported hardware.
 * For memory controller devices in Intel 5000/7300 series chipset, PCI vendor
 * id and PCI device id is read only, PCI subvendor id and PCI subsystem id is
 * write-once. So we could only rely on PCI vendor id and PCI device id here.
 * For all PCI functions (0,1,2,3) in device 0x10 on bus 0, they will have the
 * same PCI (vendor_id, device_id, subvendor_id, subsystem_id, class_id).
 * We only need to access PCI device (0, 0x10, 1), all other PCI functions will
 * be filtered out by unit address.
 */
static struct fipe_pci_id {
	uint16_t		venid;
	uint16_t		devid;
	uint16_t		subvenid;
	uint16_t		subsysid;
	char			*unitaddr;
} fipe_mc_pciids[] = {
	{ 0x8086, 0x25f0, 0xffff, 0xffff, "10,1" },	/* Intel 5000P/V/X/Z */
	{ 0x8086, 0x360c, 0xffff, 0xffff, "10,1" }	/* Intel 7300 NB */
};

/*ARGSUSED*/
static int
fipe_open(dev_t *devp, int flag, int otyp, cred_t *credp)
{
	if (otyp != OTYP_CHR) {
		cmn_err(CE_NOTE, "!fipe: invalid otyp %d in open.", otyp);
		return (EINVAL);
	}

	return (0);
}

/*ARGSUSED*/
static int
fipe_close(dev_t dev, int flag, int otyp, cred_t *credp)
{
	return (0);
}

/*ARGSUSED*/
static int
fipe_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
    int *rvalp)
{
	int rc = 0;
	fipe_pm_policy_t policy;

	/* First check permission. */
	if (secpolicy_power_mgmt(credp) != 0) {
		return (EPERM);
	}

	switch (cmd) {
	case FIPE_IOCTL_START:
		if ((mode & FWRITE) == 0) {
			rc = EBADF;
		} else {
			mutex_enter(&fipe_drv_lock);
			rc = fipe_start();
			mutex_exit(&fipe_drv_lock);
			rc =  (rc == 0) ? 0 : ENXIO;
		}
		break;

	case FIPE_IOCTL_STOP:
		if ((mode & FWRITE) == 0) {
			rc = EBADF;
		} else {
			mutex_enter(&fipe_drv_lock);
			rc = fipe_stop();
			mutex_exit(&fipe_drv_lock);
			rc =  (rc == 0) ? 0 : ENXIO;
		}
		break;

	case FIPE_IOCTL_GET_PMPOLICY:
		if ((mode & FREAD) == 0) {
			rc = EBADF;
		} else {
			mutex_enter(&fipe_drv_lock);
			policy = fipe_get_pmpolicy();
			mutex_exit(&fipe_drv_lock);
			rc = ddi_copyout(&policy, (void *)arg,
			    sizeof (policy), mode);
			rc = (rc >= 0) ? 0 : EFAULT;
		}
		break;

	case FIPE_IOCTL_SET_PMPOLICY:
		if ((mode & FWRITE) == 0) {
			rc = EBADF;
		} else {
			mutex_enter(&fipe_drv_lock);
			rc = fipe_set_pmpolicy((fipe_pm_policy_t)arg);
			mutex_exit(&fipe_drv_lock);
			rc =  (rc == 0) ? 0 : ENXIO;
		}
		break;

	default:
		cmn_err(CE_NOTE, "!fipe: unknown ioctl command %d.", cmd);
		rc = ENOTSUP;
		break;
	}

	return (rc);
}

/*ARGSUSED*/
static int
fipe_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
	switch (infocmd) {
	case DDI_INFO_DEVT2DEVINFO:
		if (fipe_drv_dip != NULL) {
			*result = fipe_drv_dip;
			return (DDI_SUCCESS);
		} else {
			*result = NULL;
			return (DDI_FAILURE);
		}

	case DDI_INFO_DEVT2INSTANCE:
		if (fipe_drv_dip != NULL) {
			*result = (void *)(uintptr_t)
			    ddi_get_instance(fipe_drv_dip);
			return (DDI_SUCCESS);
		} else {
			*result = NULL;
			return (DDI_FAILURE);
		}

	default:
		*result = NULL;
		return (DDI_FAILURE);
	}
}

/* Validate whether it's supported hardware. */
static int
fipe_validate_dip(dev_info_t *dip)
{
	int i, rc = -1;
	char *unitaddr;
	struct fipe_pci_id *ip;
	ddi_acc_handle_t handle;
	uint16_t venid, devid, subvenid, subsysid;

	/* Get device unit address, it's "devid,funcid" in hexadecimal. */
	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
	    "unit-address", &unitaddr) != DDI_PROP_SUCCESS) {
		cmn_err(CE_CONT, "?fipe: failed to get deivce unit address.");
		return (-1);
	}
	if (pci_config_setup(dip, &handle) != DDI_SUCCESS) {
		cmn_err(CE_CONT, "?fipe: failed to setup pcicfg handler.");
		ddi_prop_free(unitaddr);
		return (-1);
	}
	venid = pci_config_get16(handle, PCI_CONF_VENID);
	devid = pci_config_get16(handle, PCI_CONF_DEVID);
	subvenid = pci_config_get16(handle, PCI_CONF_SUBVENID);
	subsysid = pci_config_get16(handle, PCI_CONF_SUBSYSID);

	/* Validate device. */
	for (rc = -1, i = 0, ip = &fipe_mc_pciids[0];
	    i < sizeof (fipe_mc_pciids) / sizeof (fipe_mc_pciids[0]);
	    i++, ip++) {
		if ((ip->venid == 0xffffu || ip->venid == venid) &&
		    (ip->devid == 0xffffu || ip->devid == devid) &&
		    (ip->subvenid == 0xffffu || ip->subvenid == subvenid) &&
		    (ip->subsysid == 0xffffu || ip->subsysid == subsysid) &&
		    (ip->unitaddr == NULL ||
		    strcmp(ip->unitaddr, unitaddr) == 0)) {
			rc = 0;
			break;
		}
	}

	pci_config_teardown(&handle);
	ddi_prop_free(unitaddr);

	return (rc);
}

static int
fipe_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	char *ptr;
	int ignore = 0, rc = DDI_FAILURE;

	mutex_enter(&fipe_drv_lock);
	switch (cmd) {
	case DDI_ATTACH:
		/* Check whether it has been disabled by user. */
		if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 0,
		    "disable_fipe_pm", &ptr) == DDI_SUCCESS) {
			if (strcasecmp(ptr, "true") == 0 ||
			    strcasecmp(ptr, "yes") == 0) {
				fipe_allow_attach = 0;
			}
			ddi_prop_free(ptr);
		}
		if (fipe_allow_attach == 0) {
			cmn_err(CE_WARN,
			    "fipe: driver has been disabled by user.");
			ignore = 1;
			break;
		}

		/* Filter out unwanted PCI functions. */
		if ((ignore = fipe_validate_dip(dip)) != 0) {
			break;
		/* There should be only one MC device in system. */
		} else if (fipe_drv_dip != NULL) {
			cmn_err(CE_NOTE,
			    "!fipe: more than one hardware instances found.");
			break;
		}
		fipe_drv_dip = dip;

		/* Initialize and start power management subsystem. */
		if (fipe_init(fipe_drv_dip) != 0) {
			fipe_drv_dip = NULL;
			break;
		} else if (fipe_start() != 0) {
			(void) fipe_fini();
			fipe_drv_dip = NULL;
			break;
		}

		/* Ignore error from creating minor node. */
		if (ddi_create_minor_node(dip, "fipe", S_IFCHR, 0,
		    "ddi_mem_pm", 0) != DDI_SUCCESS) {
			cmn_err(CE_CONT,
			    "?fipe: failed to create device minor node.\n");
		}

		rc = DDI_SUCCESS;
		break;

	case DDI_RESUME:
		if (fipe_resume() == 0) {
			rc = DDI_SUCCESS;
		}
		break;

	default:
		break;
	}
	mutex_exit(&fipe_drv_lock);

	if (ignore == 0 && rc != DDI_SUCCESS) {
		cmn_err(CE_NOTE, "!fipe: failed to attach or resume device.");
	}

	return (rc);
}

/*ARGSUSED*/
static int
fipe_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	int rc = DDI_FAILURE;

	mutex_enter(&fipe_drv_lock);
	switch (cmd) {
	case DDI_DETACH:
		if (fipe_allow_detach == 0 || dip != fipe_drv_dip) {
			break;
		}
		if (fipe_stop() != 0) {
			break;
		} else if (fipe_fini() != 0) {
			(void) fipe_start();
			break;
		}
		ddi_remove_minor_node(dip, NULL);
		fipe_drv_dip = NULL;
		rc = DDI_SUCCESS;
		break;

	case DDI_SUSPEND:
		if (fipe_suspend() == 0) {
			rc = DDI_SUCCESS;
		}
		break;

	default:
		break;
	}
	mutex_exit(&fipe_drv_lock);

	if (rc != DDI_SUCCESS) {
		cmn_err(CE_NOTE, "!fipe: failed to detach or suspend device.");
	}

	return (rc);
}

static int
fipe_quiesce(dev_info_t *dip)
{
	if (dip != fipe_drv_dip) {
		return (DDI_SUCCESS);
	}
	/* Quiesce hardware by stopping power management subsystem. */
	if (fipe_suspend() != 0) {
		cmn_err(CE_NOTE, "!fipe: failed to quiesce device.");
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

static struct cb_ops fipe_cb_ops = {
	fipe_open,
	fipe_close,
	nodev,		/* not a block driver */
	nodev,		/* no print routine */
	nodev,		/* no dump routine */
	nodev,		/* no read routine */
	nodev,		/* no write routine */
	fipe_ioctl,
	nodev,		/* no devmap routine */
	nodev,		/* no mmap routine */
	nodev,		/* no segmap routine */
	nochpoll,	/* no chpoll routine */
	ddi_prop_op,
	0,		/* not a STREAMS driver */
	D_NEW | D_MP,	/* safe for multi-thread/multi-processor */
};

static struct dev_ops fipe_ops = {
	DEVO_REV,		/* devo_rev */
	0,			/* devo_refcnt */
	fipe_getinfo,		/* devo_getinfo */
	nulldev,		/* devo_identify */
	nulldev,		/* devo_probe */
	fipe_attach,		/* devo_attach */
	fipe_detach,		/* devo_detach */
	nodev,			/* devo_reset */
	&fipe_cb_ops,		/* devo_cb_ops */
	NULL,			/* devo_bus_ops */
	NULL,			/* devo_power */
	&fipe_quiesce,		/* devo_quiesce */
};

static struct modldrv modldrv = {
	&mod_driverops,
	"Intel 5000/7300 memory controller driver",
	&fipe_ops
};

static struct modlinkage modlinkage = {
	MODREV_1,
	(void *)&modldrv,
	NULL
};

int
_init(void)
{
	fipe_drv_dip = NULL;
	mutex_init(&fipe_drv_lock, NULL, MUTEX_DRIVER, NULL);

	return (mod_install(&modlinkage));
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}

int
_fini(void)
{
	int err;

	if ((err = mod_remove(&modlinkage)) == 0) {
		mutex_destroy(&fipe_drv_lock);
		fipe_drv_dip = NULL;
	}

	return (err);
}