[net-next-2.6.git] / drivers / staging / crystalhd / crystalhd_lnx.c

/***************************************************************************
  BCM70010 Linux driver
  Copyright (c) 2005-2009, Broadcom Corporation.

  This driver is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, version 2 of the License.

  This driver is distributed in the hope that 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 driver.  If not, see <http://www.gnu.org/licenses/>.
***************************************************************************/

#include <linux/smp_lock.h>
#include <linux/slab.h>

#include "crystalhd_lnx.h"

static struct class *crystalhd_class;

static struct crystalhd_adp *g_adp_info;

static irqreturn_t chd_dec_isr(int irq, void *arg)
{
	struct crystalhd_adp *adp = (struct crystalhd_adp *) arg;
	int rc = 0;
	if (adp)
		rc = crystalhd_cmd_interrupt(&adp->cmds);

	return IRQ_RETVAL(rc);
}

static int chd_dec_enable_int(struct crystalhd_adp *adp)
{
	int rc = 0;

	if (!adp || !adp->pdev) {
		BCMLOG_ERR("Invalid arg!!\n");
		return -EINVAL;
	}

	if (adp->pdev->msi_enabled)
		adp->msi = 1;
	else
		adp->msi = pci_enable_msi(adp->pdev);

	rc = request_irq(adp->pdev->irq, chd_dec_isr, IRQF_SHARED,
			 adp->name, (void *)adp);
	if (rc) {
		BCMLOG_ERR("Interrupt request failed..\n");
		pci_disable_msi(adp->pdev);
	}

	return rc;
}

static int chd_dec_disable_int(struct crystalhd_adp *adp)
{
	if (!adp || !adp->pdev) {
		BCMLOG_ERR("Invalid arg!!\n");
		return -EINVAL;
	}

	free_irq(adp->pdev->irq, adp);

	if (adp->msi)
		pci_disable_msi(adp->pdev);

	return 0;
}

crystalhd_ioctl_data *chd_dec_alloc_iodata(struct crystalhd_adp *adp, bool isr)
{
	unsigned long flags = 0;
	crystalhd_ioctl_data *temp;

	if (!adp)
		return NULL;

	spin_lock_irqsave(&adp->lock, flags);

	temp = adp->idata_free_head;
	if (temp) {
		adp->idata_free_head = adp->idata_free_head->next;
		memset(temp, 0, sizeof(*temp));
	}

	spin_unlock_irqrestore(&adp->lock, flags);
	return temp;
}

void chd_dec_free_iodata(struct crystalhd_adp *adp, crystalhd_ioctl_data *iodata,
			 bool isr)
{
	unsigned long flags = 0;

	if (!adp || !iodata)
		return;

	spin_lock_irqsave(&adp->lock, flags);
	iodata->next = adp->idata_free_head;
	adp->idata_free_head = iodata;
	spin_unlock_irqrestore(&adp->lock, flags);
}

static inline int crystalhd_user_data(unsigned long ud, void *dr, int size, int set)
{
	int rc;

	if (!ud || !dr) {
		BCMLOG_ERR("Invalid arg\n");
		return -EINVAL;
	}

	if (set)
		rc = copy_to_user((void *)ud, dr, size);
	else
		rc = copy_from_user(dr, (void *)ud, size);

	if (rc) {
		BCMLOG_ERR("Invalid args for command\n");
		rc = -EFAULT;
	}

	return rc;
}

static int chd_dec_fetch_cdata(struct crystalhd_adp *adp, crystalhd_ioctl_data *io,
			       uint32_t m_sz, unsigned long ua)
{
	unsigned long ua_off;
	int rc = 0;

	if (!adp || !io || !ua || !m_sz) {
		BCMLOG_ERR("Invalid Arg!!\n");
		return -EINVAL;
	}

	io->add_cdata = vmalloc(m_sz);
	if (!io->add_cdata) {
		BCMLOG_ERR("kalloc fail for sz:%x\n", m_sz);
		return -ENOMEM;
	}

	io->add_cdata_sz = m_sz;
	ua_off = ua + sizeof(io->udata);
	rc = crystalhd_user_data(ua_off, io->add_cdata, io->add_cdata_sz, 0);
	if (rc) {
		BCMLOG_ERR("failed to pull add_cdata sz:%x ua_off:%x\n",
			   io->add_cdata_sz, (unsigned int)ua_off);
		if (io->add_cdata) {
			kfree(io->add_cdata);
			io->add_cdata = NULL;
		}
		return -ENODATA;
	}

	return rc;
}

static int chd_dec_release_cdata(struct crystalhd_adp *adp,
				 crystalhd_ioctl_data *io, unsigned long ua)
{
	unsigned long ua_off;
	int rc;

	if (!adp || !io || !ua) {
		BCMLOG_ERR("Invalid Arg!!\n");
		return -EINVAL;
	}

	if (io->cmd != BCM_IOC_FW_DOWNLOAD) {
		ua_off = ua + sizeof(io->udata);
		rc = crystalhd_user_data(ua_off, io->add_cdata,
					io->add_cdata_sz, 1);
		if (rc) {
			BCMLOG_ERR("failed to push add_cdata sz:%x ua_off:%x\n",
				   io->add_cdata_sz, (unsigned int)ua_off);
			return -ENODATA;
		}
	}

	if (io->add_cdata) {
		vfree(io->add_cdata);
		io->add_cdata = NULL;
	}

	return 0;
}

static int chd_dec_proc_user_data(struct crystalhd_adp *adp,
				  crystalhd_ioctl_data *io,
				  unsigned long ua, int set)
{
	int rc;
	uint32_t m_sz = 0;

	if (!adp || !io || !ua) {
		BCMLOG_ERR("Invalid Arg!!\n");
		return -EINVAL;
	}

	rc = crystalhd_user_data(ua, &io->udata, sizeof(io->udata), set);
	if (rc) {
		BCMLOG_ERR("failed to %s iodata\n", (set ? "set" : "get"));
		return rc;
	}

	switch (io->cmd) {
	case BCM_IOC_MEM_RD:
	case BCM_IOC_MEM_WR:
	case BCM_IOC_FW_DOWNLOAD:
		m_sz = io->udata.u.devMem.NumDwords * 4;
		if (set)
			rc = chd_dec_release_cdata(adp, io, ua);
		else
			rc = chd_dec_fetch_cdata(adp, io, m_sz, ua);
		break;
	default:
		break;
	}

	return rc;
}

static int chd_dec_api_cmd(struct crystalhd_adp *adp, unsigned long ua,
			   uint32_t uid, uint32_t cmd, crystalhd_cmd_proc func)
{
	int rc;
	crystalhd_ioctl_data *temp;
	BC_STATUS sts = BC_STS_SUCCESS;

	temp = chd_dec_alloc_iodata(adp, 0);
	if (!temp) {
		BCMLOG_ERR("Failed to get iodata..\n");
		return -EINVAL;
	}

	temp->u_id = uid;
	temp->cmd  = cmd;

	rc = chd_dec_proc_user_data(adp, temp, ua, 0);
	if (!rc) {
		sts = func(&adp->cmds, temp);
		if (sts == BC_STS_PENDING)
			sts = BC_STS_NOT_IMPL;
		temp->udata.RetSts = sts;
		rc = chd_dec_proc_user_data(adp, temp, ua, 1);
	}

	if (temp) {
		chd_dec_free_iodata(adp, temp, 0);
		temp = NULL;
	}

	return rc;
}

/* API interfaces */
static long chd_dec_ioctl(struct file *fd, unsigned int cmd, unsigned long ua)
{
	struct crystalhd_adp *adp = chd_get_adp();
	crystalhd_cmd_proc cproc;
	struct crystalhd_user *uc;
	int ret;

	if (!adp || !fd) {
		BCMLOG_ERR("Invalid adp\n");
		return -EINVAL;
	}

	uc = (struct crystalhd_user *)fd->private_data;
	if (!uc) {
		BCMLOG_ERR("Failed to get uc\n");
		return -ENODATA;
	}

	lock_kernel();
	cproc = crystalhd_get_cmd_proc(&adp->cmds, cmd, uc);
	if (!cproc) {
		BCMLOG_ERR("Unhandled command: %d\n", cmd);
		unlock_kernel();
		return -EINVAL;
	}

	ret = chd_dec_api_cmd(adp, ua, uc->uid, cmd, cproc);
	unlock_kernel();
	return ret;
}

static int chd_dec_open(struct inode *in, struct file *fd)
{
	struct crystalhd_adp *adp = chd_get_adp();
	int rc = 0;
	BC_STATUS sts = BC_STS_SUCCESS;
	struct crystalhd_user *uc = NULL;

	BCMLOG_ENTER;
	if (!adp) {
		BCMLOG_ERR("Invalid adp\n");
		return -EINVAL;
	}

	if (adp->cfg_users >= BC_LINK_MAX_OPENS) {
		BCMLOG(BCMLOG_INFO, "Already in use.%d\n", adp->cfg_users);
		return -EBUSY;
	}

	sts = crystalhd_user_open(&adp->cmds, &uc);
	if (sts != BC_STS_SUCCESS) {
		BCMLOG_ERR("cmd_user_open - %d\n", sts);
		rc = -EBUSY;
	}

	adp->cfg_users++;

	fd->private_data = uc;

	return rc;
}

static int chd_dec_close(struct inode *in, struct file *fd)
{
	struct crystalhd_adp *adp = chd_get_adp();
	struct crystalhd_user *uc;

	BCMLOG_ENTER;
	if (!adp) {
		BCMLOG_ERR("Invalid adp\n");
		return -EINVAL;
	}

	uc = (struct crystalhd_user *)fd->private_data;
	if (!uc) {
		BCMLOG_ERR("Failed to get uc\n");
		return -ENODATA;
	}

	crystalhd_user_close(&adp->cmds, uc);

	adp->cfg_users--;

	return 0;
}

static const struct file_operations chd_dec_fops = {
	.owner   = THIS_MODULE,
	.unlocked_ioctl = chd_dec_ioctl,
	.open    = chd_dec_open,
	.release = chd_dec_close,
};

static int __devinit chd_dec_init_chdev(struct crystalhd_adp *adp)
{
	crystalhd_ioctl_data *temp;
	struct device *dev;
	int rc = -ENODEV, i = 0;

	if (!adp)
		goto fail;

	adp->chd_dec_major = register_chrdev(0, CRYSTALHD_API_NAME,
					     &chd_dec_fops);
	if (adp->chd_dec_major < 0) {
		BCMLOG_ERR("Failed to create config dev\n");
		rc = adp->chd_dec_major;
		goto fail;
	}

	/* register crystalhd class */
	crystalhd_class = class_create(THIS_MODULE, "crystalhd");
	if (IS_ERR(crystalhd_class)) {
		BCMLOG_ERR("failed to create class\n");
		goto fail;
	}

	dev = device_create(crystalhd_class, NULL, MKDEV(adp->chd_dec_major, 0),
			    NULL, "crystalhd");
	if (IS_ERR(dev)) {
		BCMLOG_ERR("failed to create device\n");
		goto device_create_fail;
	}

	rc = crystalhd_create_elem_pool(adp, BC_LINK_ELEM_POOL_SZ);
	if (rc) {
		BCMLOG_ERR("failed to create device\n");
		goto elem_pool_fail;
	}

	/* Allocate general purpose ioctl pool. */
	for (i = 0; i < CHD_IODATA_POOL_SZ; i++) {
		/* FIXME: jarod: why atomic? */
		temp = kzalloc(sizeof(crystalhd_ioctl_data), GFP_ATOMIC);
		if (!temp) {
			BCMLOG_ERR("ioctl data pool kzalloc failed\n");
			rc = -ENOMEM;
			goto kzalloc_fail;
		}
		/* Add to global pool.. */
		chd_dec_free_iodata(adp, temp, 0);
	}

	return 0;

kzalloc_fail:
	crystalhd_delete_elem_pool(adp);
elem_pool_fail:
	device_destroy(crystalhd_class, MKDEV(adp->chd_dec_major, 0));
device_create_fail:
	class_destroy(crystalhd_class);
fail:
	return rc;
}

static void __devexit chd_dec_release_chdev(struct crystalhd_adp *adp)
{
	crystalhd_ioctl_data *temp = NULL;
	if (!adp)
		return;

	if (adp->chd_dec_major > 0) {
		/* unregister crystalhd class */
		device_destroy(crystalhd_class, MKDEV(adp->chd_dec_major, 0));
		unregister_chrdev(adp->chd_dec_major, CRYSTALHD_API_NAME);
		BCMLOG(BCMLOG_INFO, "released api device - %d\n",
		       adp->chd_dec_major);
		class_destroy(crystalhd_class);
	}
	adp->chd_dec_major = 0;

	/* Clear iodata pool.. */
	do {
		temp = chd_dec_alloc_iodata(adp, 0);
		if (temp)
			kfree(temp);
	} while (temp);

	crystalhd_delete_elem_pool(adp);
}

static int __devinit chd_pci_reserve_mem(struct crystalhd_adp *pinfo)
{
	int rc;
	unsigned long bar2 = pci_resource_start(pinfo->pdev, 2);
	uint32_t mem_len   = pci_resource_len(pinfo->pdev, 2);
	unsigned long bar0 = pci_resource_start(pinfo->pdev, 0);
	uint32_t i2o_len   = pci_resource_len(pinfo->pdev, 0);

	BCMLOG(BCMLOG_SSTEP, "bar2:0x%lx-0x%08x  bar0:0x%lx-0x%08x\n",
	       bar2, mem_len, bar0, i2o_len);

	rc = check_mem_region(bar2, mem_len);
	if (rc) {
		BCMLOG_ERR("No valid mem region...\n");
		return -ENOMEM;
	}

	pinfo->addr = ioremap_nocache(bar2, mem_len);
	if (!pinfo->addr) {
		BCMLOG_ERR("Failed to remap mem region...\n");
		return -ENOMEM;
	}

	pinfo->pci_mem_start = bar2;
	pinfo->pci_mem_len   = mem_len;

	rc = check_mem_region(bar0, i2o_len);
	if (rc) {
		BCMLOG_ERR("No valid mem region...\n");
		return -ENOMEM;
	}

	pinfo->i2o_addr = ioremap_nocache(bar0, i2o_len);
	if (!pinfo->i2o_addr) {
		BCMLOG_ERR("Failed to remap mem region...\n");
		return -ENOMEM;
	}

	pinfo->pci_i2o_start = bar0;
	pinfo->pci_i2o_len   = i2o_len;

	rc = pci_request_regions(pinfo->pdev, pinfo->name);
	if (rc < 0) {
		BCMLOG_ERR("Region request failed: %d\n", rc);
		return rc;
	}

	BCMLOG(BCMLOG_SSTEP, "Mapped addr:0x%08lx  i2o_addr:0x%08lx\n",
	       (unsigned long)pinfo->addr, (unsigned long)pinfo->i2o_addr);

	return 0;
}

static void __devexit chd_pci_release_mem(struct crystalhd_adp *pinfo)
{
	if (!pinfo)
		return;

	if (pinfo->addr)
		iounmap(pinfo->addr);

	if (pinfo->i2o_addr)
		iounmap(pinfo->i2o_addr);

	pci_release_regions(pinfo->pdev);
}


static void __devexit chd_dec_pci_remove(struct pci_dev *pdev)
{
	struct crystalhd_adp *pinfo;
	BC_STATUS sts = BC_STS_SUCCESS;

	BCMLOG_ENTER;

	pinfo = (struct crystalhd_adp *) pci_get_drvdata(pdev);
	if (!pinfo) {
		BCMLOG_ERR("could not get adp\n");
		return;
	}

	sts = crystalhd_delete_cmd_context(&pinfo->cmds);
	if (sts != BC_STS_SUCCESS)
		BCMLOG_ERR("cmd delete :%d\n", sts);

	chd_dec_release_chdev(pinfo);

	chd_dec_disable_int(pinfo);

	chd_pci_release_mem(pinfo);
	pci_disable_device(pinfo->pdev);

	kfree(pinfo);
	g_adp_info = NULL;
}

static int __devinit chd_dec_pci_probe(struct pci_dev *pdev,
			     const struct pci_device_id *entry)
{
	struct crystalhd_adp *pinfo;
	int rc;
	BC_STATUS sts = BC_STS_SUCCESS;

	BCMLOG(BCMLOG_DBG, "PCI_INFO: Vendor:0x%04x Device:0x%04x "
	       "s_vendor:0x%04x s_device: 0x%04x\n",
	       pdev->vendor, pdev->device, pdev->subsystem_vendor,
	       pdev->subsystem_device);

	/* FIXME: jarod: why atomic? */
	pinfo = kzalloc(sizeof(struct crystalhd_adp), GFP_ATOMIC);
	if (!pinfo) {
		BCMLOG_ERR("Failed to allocate memory\n");
		return -ENOMEM;
	}

	pinfo->pdev = pdev;

	rc = pci_enable_device(pdev);
	if (rc) {
		BCMLOG_ERR("Failed to enable PCI device\n");
		return rc;
	}

	snprintf(pinfo->name, 31, "crystalhd_pci_e:%d:%d:%d",
		 pdev->bus->number, PCI_SLOT(pdev->devfn),
		 PCI_FUNC(pdev->devfn));

	rc = chd_pci_reserve_mem(pinfo);
	if (rc) {
		BCMLOG_ERR("Failed to setup memory regions.\n");
		return -ENOMEM;
	}

	pinfo->present	= 1;
	pinfo->drv_data = entry->driver_data;

	/* Setup adapter level lock.. */
	spin_lock_init(&pinfo->lock);

	/* setup api stuff.. */
	chd_dec_init_chdev(pinfo);
	rc = chd_dec_enable_int(pinfo);
	if (rc) {
		BCMLOG_ERR("_enable_int err:%d\n", rc);
		pci_disable_device(pdev);
		return -ENODEV;
	}

	/* Set dma mask... */
	if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
		pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
		pinfo->dmabits = 64;
	} else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
		pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
		pinfo->dmabits = 32;
	} else {
		BCMLOG_ERR("Unabled to setup DMA %d\n", rc);
		pci_disable_device(pdev);
		return -ENODEV;
	}

	sts = crystalhd_setup_cmd_context(&pinfo->cmds, pinfo);
	if (sts != BC_STS_SUCCESS) {
		BCMLOG_ERR("cmd setup :%d\n", sts);
		pci_disable_device(pdev);
		return -ENODEV;
	}

	pci_set_master(pdev);

	pci_set_drvdata(pdev, pinfo);

	g_adp_info = pinfo;

	return 0;
}

#ifdef CONFIG_PM
int chd_dec_pci_suspend(struct pci_dev *pdev, pm_message_t state)
{
	struct crystalhd_adp *adp;
	crystalhd_ioctl_data *temp;
	BC_STATUS sts = BC_STS_SUCCESS;

	adp = (struct crystalhd_adp *)pci_get_drvdata(pdev);
	if (!adp) {
		BCMLOG_ERR("could not get adp\n");
		return -ENODEV;
	}

	temp = chd_dec_alloc_iodata(adp, false);
	if (!temp) {
		BCMLOG_ERR("could not get ioctl data\n");
		return -ENODEV;
	}

	sts = crystalhd_suspend(&adp->cmds, temp);
	if (sts != BC_STS_SUCCESS) {
		BCMLOG_ERR("BCM70012 Suspend %d\n", sts);
		return -ENODEV;
	}

	chd_dec_free_iodata(adp, temp, false);
	chd_dec_disable_int(adp);
	pci_save_state(pdev);

	/* Disable IO/bus master/irq router */
	pci_disable_device(pdev);
	pci_set_power_state(pdev, pci_choose_state(pdev, state));
	return 0;
}

int chd_dec_pci_resume(struct pci_dev *pdev)
{
	struct crystalhd_adp *adp;
	BC_STATUS sts = BC_STS_SUCCESS;
	int rc;

	adp = (struct crystalhd_adp *)pci_get_drvdata(pdev);
	if (!adp) {
		BCMLOG_ERR("could not get adp\n");
		return -ENODEV;
	}

	pci_set_power_state(pdev, PCI_D0);
	pci_restore_state(pdev);

	/* device's irq possibly is changed, driver should take care */
	if (pci_enable_device(pdev)) {
		BCMLOG_ERR("Failed to enable PCI device\n");
		return 1;
	}

	pci_set_master(pdev);

	rc = chd_dec_enable_int(adp);
	if (rc) {
		BCMLOG_ERR("_enable_int err:%d\n", rc);
		pci_disable_device(pdev);
		return -ENODEV;
	}

	sts = crystalhd_resume(&adp->cmds);
	if (sts != BC_STS_SUCCESS) {
		BCMLOG_ERR("BCM70012 Resume %d\n", sts);
		pci_disable_device(pdev);
		return -ENODEV;
	}

	return 0;
}
#endif

static DEFINE_PCI_DEVICE_TABLE(chd_dec_pci_id_table) = {
	{ PCI_VDEVICE(BROADCOM, 0x1612), 8 },
	{ 0, },
};
MODULE_DEVICE_TABLE(pci, chd_dec_pci_id_table);

static struct pci_driver bc_chd_70012_driver = {
	.name     = "Broadcom 70012 Decoder",
	.probe    = chd_dec_pci_probe,
	.remove   = __devexit_p(chd_dec_pci_remove),
	.id_table = chd_dec_pci_id_table,
#ifdef CONFIG_PM
	.suspend  = chd_dec_pci_suspend,
	.resume   = chd_dec_pci_resume
#endif
};

void chd_set_log_level(struct crystalhd_adp *adp, char *arg)
{
	if ((!arg) || (strlen(arg) < 3))
		g_linklog_level = BCMLOG_ERROR | BCMLOG_DATA;
	else if (!strncmp(arg, "sstep", 5))
		g_linklog_level = BCMLOG_INFO | BCMLOG_DATA | BCMLOG_DBG |
				  BCMLOG_SSTEP | BCMLOG_ERROR;
	else if (!strncmp(arg, "info", 4))
		g_linklog_level = BCMLOG_ERROR | BCMLOG_DATA | BCMLOG_INFO;
	else if (!strncmp(arg, "debug", 5))
		g_linklog_level = BCMLOG_ERROR | BCMLOG_DATA | BCMLOG_INFO |
				  BCMLOG_DBG;
	else if (!strncmp(arg, "pball", 5))
		g_linklog_level = 0xFFFFFFFF & ~(BCMLOG_SPINLOCK);
	else if (!strncmp(arg, "silent", 6))
		g_linklog_level = 0;
	else
		g_linklog_level = 0;
}

struct crystalhd_adp *chd_get_adp(void)
{
	return g_adp_info;
}

static int __init chd_dec_module_init(void)
{
	int rc;

	chd_set_log_level(NULL, "debug");
	BCMLOG(BCMLOG_DATA, "Loading crystalhd %d.%d.%d\n",
	       crystalhd_kmod_major, crystalhd_kmod_minor, crystalhd_kmod_rev);

	rc = pci_register_driver(&bc_chd_70012_driver);

	if (rc < 0)
		BCMLOG_ERR("Could not find any devices. err:%d\n", rc);

	return rc;
}
module_init(chd_dec_module_init);

static void __exit chd_dec_module_cleanup(void)
{
	BCMLOG(BCMLOG_DATA, "unloading crystalhd %d.%d.%d\n",
	       crystalhd_kmod_major, crystalhd_kmod_minor, crystalhd_kmod_rev);

	pci_unregister_driver(&bc_chd_70012_driver);
}
module_exit(chd_dec_module_cleanup);

MODULE_AUTHOR("Naren Sankar <nsankar@broadcom.com>");
MODULE_AUTHOR("Prasad Bolisetty <prasadb@broadcom.com>");
MODULE_DESCRIPTION(CRYSTAL_HD_NAME);
MODULE_LICENSE("GPL");
MODULE_ALIAS("bcm70012");
Commit	Line	Data
7963eb43	1	/***************************************************************************
21b0838c AP	2	BCM70010 Linux driver
	3	Copyright (c) 2005-2009, Broadcom Corporation.
	4
	5	This driver is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation, version 2 of the License.
	8
	9	This driver is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	GNU General Public License for more details.
	13
	14	You should have received a copy of the GNU General Public License
	15	along with this driver. If not, see <http://www.gnu.org/licenses/>.
	16	***************************************************************************/
7963eb43	17
b1f2ac07	18	#include <linux/smp_lock.h>
5a0e3ad6	19	#include <linux/slab.h>
7963eb43 JW	20
	21	#include "crystalhd_lnx.h"
	22
	23	static struct class *crystalhd_class;
	24
	25	static struct crystalhd_adp *g_adp_info;
	26
	27	static irqreturn_t chd_dec_isr(int irq, void *arg)
	28	{
	29	struct crystalhd_adp adp = (struct crystalhd_adp ) arg;
	30	int rc = 0;
	31	if (adp)
	32	rc = crystalhd_cmd_interrupt(&adp->cmds);
	33
	34	return IRQ_RETVAL(rc);
	35	}
	36
	37	static int chd_dec_enable_int(struct crystalhd_adp *adp)
	38	{
	39	int rc = 0;
	40
	41	if (!adp \|\| !adp->pdev) {
	42	BCMLOG_ERR("Invalid arg!!\n");
	43	return -EINVAL;
	44	}
	45
	46	if (adp->pdev->msi_enabled)
	47	adp->msi = 1;
	48	else
	49	adp->msi = pci_enable_msi(adp->pdev);
	50
	51	rc = request_irq(adp->pdev->irq, chd_dec_isr, IRQF_SHARED,
	52	adp->name, (void *)adp);
	53	if (rc) {
641b63f9	54	BCMLOG_ERR("Interrupt request failed..\n");
7963eb43 JW	55	pci_disable_msi(adp->pdev);
	56	}
	57
	58	return rc;
	59	}
	60
	61	static int chd_dec_disable_int(struct crystalhd_adp *adp)
	62	{
	63	if (!adp \|\| !adp->pdev) {
	64	BCMLOG_ERR("Invalid arg!!\n");
	65	return -EINVAL;
	66	}
	67
	68	free_irq(adp->pdev->irq, adp);
	69
	70	if (adp->msi)
	71	pci_disable_msi(adp->pdev);
	72
	73	return 0;
	74	}
	75
	76	crystalhd_ioctl_data chd_dec_alloc_iodata(struct crystalhd_adp adp, bool isr)
	77	{
	78	unsigned long flags = 0;
	79	crystalhd_ioctl_data *temp;
	80
	81	if (!adp)
	82	return NULL;
	83
	84	spin_lock_irqsave(&adp->lock, flags);
	85
	86	temp = adp->idata_free_head;
	87	if (temp) {
	88	adp->idata_free_head = adp->idata_free_head->next;
	89	memset(temp, 0, sizeof(*temp));
	90	}
	91
	92	spin_unlock_irqrestore(&adp->lock, flags);
	93	return temp;
	94	}
	95
	96	void chd_dec_free_iodata(struct crystalhd_adp adp, crystalhd_ioctl_data iodata,
	97	bool isr)
	98	{
	99	unsigned long flags = 0;
	100
	101	if (!adp \|\| !iodata)
	102	return;
	103
	104	spin_lock_irqsave(&adp->lock, flags);
	105	iodata->next = adp->idata_free_head;
	106	adp->idata_free_head = iodata;
	107	spin_unlock_irqrestore(&adp->lock, flags);
	108	}
	109
	110	static inline int crystalhd_user_data(unsigned long ud, void *dr, int size, int set)
	111	{
	112	int rc;
	113
	114	if (!ud \|\| !dr) {
641b63f9	115	BCMLOG_ERR("Invalid arg\n");
7963eb43 JW	116	return -EINVAL;
	117	}
	118
	119	if (set)
	120	rc = copy_to_user((void *)ud, dr, size);
	121	else
	122	rc = copy_from_user(dr, (void *)ud, size);
	123
	124	if (rc) {
641b63f9	125	BCMLOG_ERR("Invalid args for command\n");
7963eb43 JW	126	rc = -EFAULT;
	127	}
	128
	129	return rc;
	130	}
	131
	132	static int chd_dec_fetch_cdata(struct crystalhd_adp adp, crystalhd_ioctl_data io,
	133	uint32_t m_sz, unsigned long ua)
	134	{
	135	unsigned long ua_off;
	136	int rc = 0;
	137
	138	if (!adp \|\| !io \|\| !ua \|\| !m_sz) {
	139	BCMLOG_ERR("Invalid Arg!!\n");
	140	return -EINVAL;
	141	}
	142
	143	io->add_cdata = vmalloc(m_sz);
	144	if (!io->add_cdata) {
	145	BCMLOG_ERR("kalloc fail for sz:%x\n", m_sz);
	146	return -ENOMEM;
	147	}
	148
	149	io->add_cdata_sz = m_sz;
	150	ua_off = ua + sizeof(io->udata);
	151	rc = crystalhd_user_data(ua_off, io->add_cdata, io->add_cdata_sz, 0);
	152	if (rc) {
	153	BCMLOG_ERR("failed to pull add_cdata sz:%x ua_off:%x\n",
	154	io->add_cdata_sz, (unsigned int)ua_off);
	155	if (io->add_cdata) {
	156	kfree(io->add_cdata);
	157	io->add_cdata = NULL;
	158	}
	159	return -ENODATA;
	160	}
	161
	162	return rc;
	163	}
	164
	165	static int chd_dec_release_cdata(struct crystalhd_adp *adp,
	166	crystalhd_ioctl_data *io, unsigned long ua)
	167	{
	168	unsigned long ua_off;
	169	int rc;
	170
	171	if (!adp \|\| !io \|\| !ua) {
	172	BCMLOG_ERR("Invalid Arg!!\n");
	173	return -EINVAL;
	174	}
	175
	176	if (io->cmd != BCM_IOC_FW_DOWNLOAD) {
	177	ua_off = ua + sizeof(io->udata);
	178	rc = crystalhd_user_data(ua_off, io->add_cdata,
	179	io->add_cdata_sz, 1);
	180	if (rc) {
	181	BCMLOG_ERR("failed to push add_cdata sz:%x ua_off:%x\n",
	182	io->add_cdata_sz, (unsigned int)ua_off);
	183	return -ENODATA;
	184	}
	185	}
	186
	187	if (io->add_cdata) {
	188	vfree(io->add_cdata);
	189	io->add_cdata = NULL;
190	}
191
192	return 0;
193	}
194
195	static int chd_dec_proc_user_data(struct crystalhd_adp *adp,
196	crystalhd_ioctl_data *io,
197	unsigned long ua, int set)
198	{
199	int rc;
200	uint32_t m_sz = 0;
201
202	if (!adp \|\| !io \|\| !ua) {
203	BCMLOG_ERR("Invalid Arg!!\n");
204	return -EINVAL;
205	}
206
207	rc = crystalhd_user_data(ua, &io->udata, sizeof(io->udata), set);
208	if (rc) {
641b63f9	209	BCMLOG_ERR("failed to %s iodata\n", (set ? "set" : "get"));
7963eb43 JW	210	return rc;
	211	}
	212
	213	switch (io->cmd) {
	214	case BCM_IOC_MEM_RD:
	215	case BCM_IOC_MEM_WR:
	216	case BCM_IOC_FW_DOWNLOAD:
	217	m_sz = io->udata.u.devMem.NumDwords * 4;
	218	if (set)
	219	rc = chd_dec_release_cdata(adp, io, ua);
	220	else
	221	rc = chd_dec_fetch_cdata(adp, io, m_sz, ua);
	222	break;
	223	default:
	224	break;
	225	}
	226
	227	return rc;
	228	}
	229
	230	static int chd_dec_api_cmd(struct crystalhd_adp *adp, unsigned long ua,
	231	uint32_t uid, uint32_t cmd, crystalhd_cmd_proc func)
	232	{
	233	int rc;
	234	crystalhd_ioctl_data *temp;
	235	BC_STATUS sts = BC_STS_SUCCESS;
	236
	237	temp = chd_dec_alloc_iodata(adp, 0);
	238	if (!temp) {
	239	BCMLOG_ERR("Failed to get iodata..\n");
	240	return -EINVAL;
	241	}
	242
	243	temp->u_id = uid;
	244	temp->cmd = cmd;
	245
	246	rc = chd_dec_proc_user_data(adp, temp, ua, 0);
	247	if (!rc) {
	248	sts = func(&adp->cmds, temp);
	249	if (sts == BC_STS_PENDING)
	250	sts = BC_STS_NOT_IMPL;
	251	temp->udata.RetSts = sts;
	252	rc = chd_dec_proc_user_data(adp, temp, ua, 1);
	253	}
	254
	255	if (temp) {
	256	chd_dec_free_iodata(adp, temp, 0);
	257	temp = NULL;
	258	}
	259
	260	return rc;
	261	}
	262
21b0838c	263	/* API interfaces */
b1f2ac07	264	static long chd_dec_ioctl(struct file *fd, unsigned int cmd, unsigned long ua)
7963eb43 JW	265	{
	266	struct crystalhd_adp *adp = chd_get_adp();
	267	crystalhd_cmd_proc cproc;
	268	struct crystalhd_user *uc;
b1f2ac07	269	int ret;
7963eb43 JW	270
	271	if (!adp \|\| !fd) {
	272	BCMLOG_ERR("Invalid adp\n");
	273	return -EINVAL;
	274	}
	275
	276	uc = (struct crystalhd_user *)fd->private_data;
	277	if (!uc) {
	278	BCMLOG_ERR("Failed to get uc\n");
	279	return -ENODATA;
	280	}
	281
b1f2ac07	282	lock_kernel();
7963eb43 JW	283	cproc = crystalhd_get_cmd_proc(&adp->cmds, cmd, uc);
	284	if (!cproc) {
	285	BCMLOG_ERR("Unhandled command: %d\n", cmd);
b1f2ac07	286	unlock_kernel();
7963eb43 JW	287	return -EINVAL;
	288	}
	289
b1f2ac07 AB	290	ret = chd_dec_api_cmd(adp, ua, uc->uid, cmd, cproc);
	291	unlock_kernel();
	292	return ret;
7963eb43 JW	293	}
	294
	295	static int chd_dec_open(struct inode in, struct file fd)
	296	{
	297	struct crystalhd_adp *adp = chd_get_adp();
	298	int rc = 0;
	299	BC_STATUS sts = BC_STS_SUCCESS;
	300	struct crystalhd_user *uc = NULL;
	301
	302	BCMLOG_ENTER;
	303	if (!adp) {
	304	BCMLOG_ERR("Invalid adp\n");
	305	return -EINVAL;
	306	}
	307
	308	if (adp->cfg_users >= BC_LINK_MAX_OPENS) {
	309	BCMLOG(BCMLOG_INFO, "Already in use.%d\n", adp->cfg_users);
	310	return -EBUSY;
	311	}
	312
	313	sts = crystalhd_user_open(&adp->cmds, &uc);
	314	if (sts != BC_STS_SUCCESS) {
641b63f9	315	BCMLOG_ERR("cmd_user_open - %d\n", sts);
7963eb43 JW	316	rc = -EBUSY;
	317	}
	318
	319	adp->cfg_users++;
	320
	321	fd->private_data = uc;
	322
	323	return rc;
	324	}
	325
	326	static int chd_dec_close(struct inode in, struct file fd)
	327	{
	328	struct crystalhd_adp *adp = chd_get_adp();
	329	struct crystalhd_user *uc;
	330
	331	BCMLOG_ENTER;
	332	if (!adp) {
641b63f9	333	BCMLOG_ERR("Invalid adp\n");
7963eb43 JW	334	return -EINVAL;
	335	}
	336
	337	uc = (struct crystalhd_user *)fd->private_data;
	338	if (!uc) {
	339	BCMLOG_ERR("Failed to get uc\n");
	340	return -ENODATA;
	341	}
	342
	343	crystalhd_user_close(&adp->cmds, uc);
	344
	345	adp->cfg_users--;
	346
	347	return 0;
	348	}
	349
	350	static const struct file_operations chd_dec_fops = {
	351	.owner = THIS_MODULE,
b1f2ac07	352	.unlocked_ioctl = chd_dec_ioctl,
7963eb43 JW	353	.open = chd_dec_open,
	354	.release = chd_dec_close,
	355	};
	356
21b0838c	357	static int __devinit chd_dec_init_chdev(struct crystalhd_adp *adp)
7963eb43 JW	358	{
	359	crystalhd_ioctl_data *temp;
	360	struct device *dev;
	361	int rc = -ENODEV, i = 0;
	362
	363	if (!adp)
	364	goto fail;
	365
	366	adp->chd_dec_major = register_chrdev(0, CRYSTALHD_API_NAME,
	367	&chd_dec_fops);
	368	if (adp->chd_dec_major < 0) {
	369	BCMLOG_ERR("Failed to create config dev\n");
	370	rc = adp->chd_dec_major;
	371	goto fail;
	372	}
	373
	374	/* register crystalhd class */
	375	crystalhd_class = class_create(THIS_MODULE, "crystalhd");
	376	if (IS_ERR(crystalhd_class)) {
	377	BCMLOG_ERR("failed to create class\n");
	378	goto fail;
	379	}
	380
	381	dev = device_create(crystalhd_class, NULL, MKDEV(adp->chd_dec_major, 0),
	382	NULL, "crystalhd");
15df6385	383	if (IS_ERR(dev)) {
7963eb43 JW	384	BCMLOG_ERR("failed to create device\n");
	385	goto device_create_fail;
	386	}
	387
	388	rc = crystalhd_create_elem_pool(adp, BC_LINK_ELEM_POOL_SZ);
	389	if (rc) {
	390	BCMLOG_ERR("failed to create device\n");
	391	goto elem_pool_fail;
	392	}
	393
	394	/* Allocate general purpose ioctl pool. */
	395	for (i = 0; i < CHD_IODATA_POOL_SZ; i++) {
	396	/* FIXME: jarod: why atomic? */
	397	temp = kzalloc(sizeof(crystalhd_ioctl_data), GFP_ATOMIC);
	398	if (!temp) {
	399	BCMLOG_ERR("ioctl data pool kzalloc failed\n");
	400	rc = -ENOMEM;
	401	goto kzalloc_fail;
	402	}
	403	/* Add to global pool.. */
	404	chd_dec_free_iodata(adp, temp, 0);
	405	}
	406
	407	return 0;
	408
	409	kzalloc_fail:
	410	crystalhd_delete_elem_pool(adp);
	411	elem_pool_fail:
	412	device_destroy(crystalhd_class, MKDEV(adp->chd_dec_major, 0));
	413	device_create_fail:
	414	class_destroy(crystalhd_class);
	415	fail:
	416	return rc;
	417	}
	418
21b0838c	419	static void __devexit chd_dec_release_chdev(struct crystalhd_adp *adp)
7963eb43 JW	420	{
	421	crystalhd_ioctl_data *temp = NULL;
	422	if (!adp)
	423	return;
	424
	425	if (adp->chd_dec_major > 0) {
	426	/* unregister crystalhd class */
	427	device_destroy(crystalhd_class, MKDEV(adp->chd_dec_major, 0));
	428	unregister_chrdev(adp->chd_dec_major, CRYSTALHD_API_NAME);
	429	BCMLOG(BCMLOG_INFO, "released api device - %d\n",
	430	adp->chd_dec_major);
	431	class_destroy(crystalhd_class);
	432	}
	433	adp->chd_dec_major = 0;
	434
	435	/* Clear iodata pool.. */
	436	do {
	437	temp = chd_dec_alloc_iodata(adp, 0);
	438	if (temp)
	439	kfree(temp);
	440	} while (temp);
	441
	442	crystalhd_delete_elem_pool(adp);
	443	}
	444
21b0838c	445	static int __devinit chd_pci_reserve_mem(struct crystalhd_adp *pinfo)
7963eb43 JW	446	{
	447	int rc;
	448	unsigned long bar2 = pci_resource_start(pinfo->pdev, 2);
	449	uint32_t mem_len = pci_resource_len(pinfo->pdev, 2);
	450	unsigned long bar0 = pci_resource_start(pinfo->pdev, 0);
	451	uint32_t i2o_len = pci_resource_len(pinfo->pdev, 0);
	452
	453	BCMLOG(BCMLOG_SSTEP, "bar2:0x%lx-0x%08x bar0:0x%lx-0x%08x\n",
	454	bar2, mem_len, bar0, i2o_len);
	455
	456	rc = check_mem_region(bar2, mem_len);
	457	if (rc) {
	458	BCMLOG_ERR("No valid mem region...\n");
	459	return -ENOMEM;
	460	}
	461
	462	pinfo->addr = ioremap_nocache(bar2, mem_len);
	463	if (!pinfo->addr) {
	464	BCMLOG_ERR("Failed to remap mem region...\n");
	465	return -ENOMEM;
	466	}
	467
	468	pinfo->pci_mem_start = bar2;
	469	pinfo->pci_mem_len = mem_len;
	470
	471	rc = check_mem_region(bar0, i2o_len);
	472	if (rc) {
	473	BCMLOG_ERR("No valid mem region...\n");
	474	return -ENOMEM;
	475	}
	476
	477	pinfo->i2o_addr = ioremap_nocache(bar0, i2o_len);
	478	if (!pinfo->i2o_addr) {
	479	BCMLOG_ERR("Failed to remap mem region...\n");
	480	return -ENOMEM;
	481	}
	482
	483	pinfo->pci_i2o_start = bar0;
	484	pinfo->pci_i2o_len = i2o_len;
	485
	486	rc = pci_request_regions(pinfo->pdev, pinfo->name);
	487	if (rc < 0) {
	488	BCMLOG_ERR("Region request failed: %d\n", rc);
	489	return rc;
	490	}
	491
	492	BCMLOG(BCMLOG_SSTEP, "Mapped addr:0x%08lx i2o_addr:0x%08lx\n",
	493	(unsigned long)pinfo->addr, (unsigned long)pinfo->i2o_addr);
	494
	495	return 0;
	496	}
	497
21b0838c	498	static void __devexit chd_pci_release_mem(struct crystalhd_adp *pinfo)
7963eb43 JW	499	{
	500	if (!pinfo)
	501	return;
	502
	503	if (pinfo->addr)
	504	iounmap(pinfo->addr);
	505
	506	if (pinfo->i2o_addr)
	507	iounmap(pinfo->i2o_addr);
	508
	509	pci_release_regions(pinfo->pdev);
	510	}
	511
	512
21b0838c	513	static void __devexit chd_dec_pci_remove(struct pci_dev *pdev)
7963eb43 JW	514	{
	515	struct crystalhd_adp *pinfo;
	516	BC_STATUS sts = BC_STS_SUCCESS;
	517
	518	BCMLOG_ENTER;
	519
	520	pinfo = (struct crystalhd_adp *) pci_get_drvdata(pdev);
	521	if (!pinfo) {
	522	BCMLOG_ERR("could not get adp\n");
	523	return;
	524	}
	525
	526	sts = crystalhd_delete_cmd_context(&pinfo->cmds);
	527	if (sts != BC_STS_SUCCESS)
641b63f9	528	BCMLOG_ERR("cmd delete :%d\n", sts);
7963eb43 JW	529
	530	chd_dec_release_chdev(pinfo);
	531
	532	chd_dec_disable_int(pinfo);
	533
	534	chd_pci_release_mem(pinfo);
	535	pci_disable_device(pinfo->pdev);
	536
	537	kfree(pinfo);
	538	g_adp_info = NULL;
	539	}
	540
21b0838c	541	static int __devinit chd_dec_pci_probe(struct pci_dev *pdev,
7963eb43 JW	542	const struct pci_device_id *entry)
	543	{
	544	struct crystalhd_adp *pinfo;
	545	int rc;
	546	BC_STATUS sts = BC_STS_SUCCESS;
	547
	548	BCMLOG(BCMLOG_DBG, "PCI_INFO: Vendor:0x%04x Device:0x%04x "
	549	"s_vendor:0x%04x s_device: 0x%04x\n",
	550	pdev->vendor, pdev->device, pdev->subsystem_vendor,
	551	pdev->subsystem_device);
	552
	553	/* FIXME: jarod: why atomic? */
	554	pinfo = kzalloc(sizeof(struct crystalhd_adp), GFP_ATOMIC);
	555	if (!pinfo) {
	556	BCMLOG_ERR("Failed to allocate memory\n");
	557	return -ENOMEM;
	558	}
	559
	560	pinfo->pdev = pdev;
	561
	562	rc = pci_enable_device(pdev);
	563	if (rc) {
	564	BCMLOG_ERR("Failed to enable PCI device\n");
	565	return rc;
	566	}
	567
	568	snprintf(pinfo->name, 31, "crystalhd_pci_e:%d:%d:%d",
	569	pdev->bus->number, PCI_SLOT(pdev->devfn),
	570	PCI_FUNC(pdev->devfn));
	571
	572	rc = chd_pci_reserve_mem(pinfo);
	573	if (rc) {
	574	BCMLOG_ERR("Failed to setup memory regions.\n");
	575	return -ENOMEM;
	576	}
	577
	578	pinfo->present = 1;
	579	pinfo->drv_data = entry->driver_data;
	580
	581	/* Setup adapter level lock.. */
	582	spin_lock_init(&pinfo->lock);
	583
	584	/* setup api stuff.. */
	585	chd_dec_init_chdev(pinfo);
	586	rc = chd_dec_enable_int(pinfo);
	587	if (rc) {
641b63f9	588	BCMLOG_ERR("_enable_int err:%d\n", rc);
7963eb43 JW	589	pci_disable_device(pdev);
	590	return -ENODEV;
	591	}
	592
	593	/* Set dma mask... */
	594	if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
	595	pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
	596	pinfo->dmabits = 64;
	597	} else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
	598	pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
	599	pinfo->dmabits = 32;
	600	} else {
	601	BCMLOG_ERR("Unabled to setup DMA %d\n", rc);
	602	pci_disable_device(pdev);
	603	return -ENODEV;
	604	}
	605
	606	sts = crystalhd_setup_cmd_context(&pinfo->cmds, pinfo);
	607	if (sts != BC_STS_SUCCESS) {
641b63f9	608	BCMLOG_ERR("cmd setup :%d\n", sts);
7963eb43 JW	609	pci_disable_device(pdev);
	610	return -ENODEV;
	611	}
	612
	613	pci_set_master(pdev);
	614
	615	pci_set_drvdata(pdev, pinfo);
	616
	617	g_adp_info = pinfo;
	618
	619	return 0;
7963eb43 JW	620	}
	621
	622	#ifdef CONFIG_PM
	623	int chd_dec_pci_suspend(struct pci_dev *pdev, pm_message_t state)
	624	{
	625	struct crystalhd_adp *adp;
	626	crystalhd_ioctl_data *temp;
	627	BC_STATUS sts = BC_STS_SUCCESS;
	628
	629	adp = (struct crystalhd_adp *)pci_get_drvdata(pdev);
	630	if (!adp) {
	631	BCMLOG_ERR("could not get adp\n");
	632	return -ENODEV;
	633	}
	634
	635	temp = chd_dec_alloc_iodata(adp, false);
	636	if (!temp) {
	637	BCMLOG_ERR("could not get ioctl data\n");
	638	return -ENODEV;
	639	}
	640
	641	sts = crystalhd_suspend(&adp->cmds, temp);
	642	if (sts != BC_STS_SUCCESS) {
	643	BCMLOG_ERR("BCM70012 Suspend %d\n", sts);
	644	return -ENODEV;
	645	}
	646
	647	chd_dec_free_iodata(adp, temp, false);
	648	chd_dec_disable_int(adp);
	649	pci_save_state(pdev);
	650
	651	/* Disable IO/bus master/irq router */
	652	pci_disable_device(pdev);
	653	pci_set_power_state(pdev, pci_choose_state(pdev, state));
	654	return 0;
	655	}
	656
	657	int chd_dec_pci_resume(struct pci_dev *pdev)
	658	{
	659	struct crystalhd_adp *adp;
	660	BC_STATUS sts = BC_STS_SUCCESS;
	661	int rc;
	662
	663	adp = (struct crystalhd_adp *)pci_get_drvdata(pdev);
	664	if (!adp) {
	665	BCMLOG_ERR("could not get adp\n");
	666	return -ENODEV;
	667	}
	668
	669	pci_set_power_state(pdev, PCI_D0);
	670	pci_restore_state(pdev);
	671
	672	/* device's irq possibly is changed, driver should take care */
	673	if (pci_enable_device(pdev)) {
	674	BCMLOG_ERR("Failed to enable PCI device\n");
	675	return 1;
	676	}
	677
	678	pci_set_master(pdev);
	679
	680	rc = chd_dec_enable_int(adp);
	681	if (rc) {
641b63f9	682	BCMLOG_ERR("_enable_int err:%d\n", rc);
7963eb43 JW	683	pci_disable_device(pdev);
	684	return -ENODEV;
	685	}
	686
	687	sts = crystalhd_resume(&adp->cmds);
	688	if (sts != BC_STS_SUCCESS) {
	689	BCMLOG_ERR("BCM70012 Resume %d\n", sts);
	690	pci_disable_device(pdev);
	691	return -ENODEV;
	692	}
	693
	694	return 0;
	695	}
	696	#endif
	697
21b0838c AP	698	static DEFINE_PCI_DEVICE_TABLE(chd_dec_pci_id_table) = {
21b0838c AP	699	{ PCI_VDEVICE(BROADCOM, 0x1612), 8 },
7963eb43 JW	700	{ 0, },
7963eb43 JW	701	};
21b0838c	702	MODULE_DEVICE_TABLE(pci, chd_dec_pci_id_table);
7963eb43	703
21b0838c	704	static struct pci_driver bc_chd_70012_driver = {
7963eb43 JW	705	.name = "Broadcom 70012 Decoder",
7963eb43 JW	706	.probe = chd_dec_pci_probe,
21b0838c	707	.remove = __devexit_p(chd_dec_pci_remove),
7963eb43 JW	708	.id_table = chd_dec_pci_id_table,
	709	#ifdef CONFIG_PM
	710	.suspend = chd_dec_pci_suspend,
	711	.resume = chd_dec_pci_resume
	712	#endif
	713	};
7963eb43 JW	714
	715	void chd_set_log_level(struct crystalhd_adp adp, char arg)
	716	{
	717	if ((!arg) \|\| (strlen(arg) < 3))
	718	g_linklog_level = BCMLOG_ERROR \| BCMLOG_DATA;
	719	else if (!strncmp(arg, "sstep", 5))
	720	g_linklog_level = BCMLOG_INFO \| BCMLOG_DATA \| BCMLOG_DBG \|
	721	BCMLOG_SSTEP \| BCMLOG_ERROR;
	722	else if (!strncmp(arg, "info", 4))
	723	g_linklog_level = BCMLOG_ERROR \| BCMLOG_DATA \| BCMLOG_INFO;
	724	else if (!strncmp(arg, "debug", 5))
	725	g_linklog_level = BCMLOG_ERROR \| BCMLOG_DATA \| BCMLOG_INFO \|
	726	BCMLOG_DBG;
	727	else if (!strncmp(arg, "pball", 5))
	728	g_linklog_level = 0xFFFFFFFF & ~(BCMLOG_SPINLOCK);
	729	else if (!strncmp(arg, "silent", 6))
	730	g_linklog_level = 0;
	731	else
	732	g_linklog_level = 0;
	733	}
	734
	735	struct crystalhd_adp *chd_get_adp(void)
	736	{
	737	return g_adp_info;
	738	}
	739
21b0838c	740	static int __init chd_dec_module_init(void)
7963eb43 JW	741	{
	742	int rc;
	743
	744	chd_set_log_level(NULL, "debug");
641b63f9	745	BCMLOG(BCMLOG_DATA, "Loading crystalhd %d.%d.%d\n",
7963eb43 JW	746	crystalhd_kmod_major, crystalhd_kmod_minor, crystalhd_kmod_rev);
	747
	748	rc = pci_register_driver(&bc_chd_70012_driver);
	749
	750	if (rc < 0)
641b63f9	751	BCMLOG_ERR("Could not find any devices. err:%d\n", rc);
7963eb43 JW	752
	753	return rc;
	754	}
21b0838c	755	module_init(chd_dec_module_init);
7963eb43	756
21b0838c	757	static void __exit chd_dec_module_cleanup(void)
7963eb43	758	{
641b63f9	759	BCMLOG(BCMLOG_DATA, "unloading crystalhd %d.%d.%d\n",
7963eb43 JW	760	crystalhd_kmod_major, crystalhd_kmod_minor, crystalhd_kmod_rev);
	761
	762	pci_unregister_driver(&bc_chd_70012_driver);
	763	}
21b0838c	764	module_exit(chd_dec_module_cleanup);
7963eb43 JW	765
	766	MODULE_AUTHOR("Naren Sankar <nsankar@broadcom.com>");
	767	MODULE_AUTHOR("Prasad Bolisetty <prasadb@broadcom.com>");
	768	MODULE_DESCRIPTION(CRYSTAL_HD_NAME);
	769	MODULE_LICENSE("GPL");
	770	MODULE_ALIAS("bcm70012");