[mirror_ubuntu-artful-kernel.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/version.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 int chd_dec_ioctl(struct inode *in, struct file *fd,
			 unsigned int cmd, unsigned long ua)
{
	struct crystalhd_adp *adp = chd_get_adp();
	crystalhd_cmd_proc cproc;
	struct crystalhd_user *uc;

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

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

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

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,
	.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 (!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 JW	17
7963eb43 JW	18	#include <linux/version.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) {
	54	BCMLOG_ERR("Interrupt request failed.. \n");
	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) {
115	BCMLOG_ERR("Invalid arg \n");
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) {
125	BCMLOG_ERR("Invalid args for command \n");
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) {
209	BCMLOG_ERR("failed to %s iodata \n", (set ? "set" : "get"));
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 */
7963eb43 JW	264	static int chd_dec_ioctl(struct inode in, struct file fd,
	265	unsigned int cmd, unsigned long ua)
	266	{
	267	struct crystalhd_adp *adp = chd_get_adp();
	268	crystalhd_cmd_proc cproc;
	269	struct crystalhd_user *uc;
	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
	282	cproc = crystalhd_get_cmd_proc(&adp->cmds, cmd, uc);
	283	if (!cproc) {
	284	BCMLOG_ERR("Unhandled command: %d\n", cmd);
	285	return -EINVAL;
	286	}
	287
	288	return chd_dec_api_cmd(adp, ua, uc->uid, cmd, cproc);
	289	}
	290
	291	static int chd_dec_open(struct inode in, struct file fd)
	292	{
	293	struct crystalhd_adp *adp = chd_get_adp();
	294	int rc = 0;
	295	BC_STATUS sts = BC_STS_SUCCESS;
	296	struct crystalhd_user *uc = NULL;
	297
	298	BCMLOG_ENTER;
	299	if (!adp) {
	300	BCMLOG_ERR("Invalid adp\n");
	301	return -EINVAL;
	302	}
	303
	304	if (adp->cfg_users >= BC_LINK_MAX_OPENS) {
	305	BCMLOG(BCMLOG_INFO, "Already in use.%d\n", adp->cfg_users);
	306	return -EBUSY;
	307	}
	308
	309	sts = crystalhd_user_open(&adp->cmds, &uc);
	310	if (sts != BC_STS_SUCCESS) {
	311	BCMLOG_ERR("cmd_user_open - %d \n", sts);
	312	rc = -EBUSY;
	313	}
	314
	315	adp->cfg_users++;
	316
	317	fd->private_data = uc;
	318
	319	return rc;
	320	}
	321
	322	static int chd_dec_close(struct inode in, struct file fd)
	323	{
	324	struct crystalhd_adp *adp = chd_get_adp();
	325	struct crystalhd_user *uc;
	326
	327	BCMLOG_ENTER;
328	if (!adp) {
329	BCMLOG_ERR("Invalid adp \n");
330	return -EINVAL;
331	}
332
333	uc = (struct crystalhd_user *)fd->private_data;
334	if (!uc) {
335	BCMLOG_ERR("Failed to get uc\n");
336	return -ENODATA;
337	}
338
339	crystalhd_user_close(&adp->cmds, uc);
340
341	adp->cfg_users--;
342
343	return 0;
344	}
345
346	static const struct file_operations chd_dec_fops = {
347	.owner = THIS_MODULE,
348	.ioctl = chd_dec_ioctl,
349	.open = chd_dec_open,
350	.release = chd_dec_close,
351	};
352
21b0838c	353	static int __devinit chd_dec_init_chdev(struct crystalhd_adp *adp)
7963eb43 JW	354	{
	355	crystalhd_ioctl_data *temp;
	356	struct device *dev;
	357	int rc = -ENODEV, i = 0;
	358
	359	if (!adp)
	360	goto fail;
	361
	362	adp->chd_dec_major = register_chrdev(0, CRYSTALHD_API_NAME,
	363	&chd_dec_fops);
	364	if (adp->chd_dec_major < 0) {
	365	BCMLOG_ERR("Failed to create config dev\n");
	366	rc = adp->chd_dec_major;
	367	goto fail;
	368	}
	369
	370	/* register crystalhd class */
	371	crystalhd_class = class_create(THIS_MODULE, "crystalhd");
	372	if (IS_ERR(crystalhd_class)) {
	373	BCMLOG_ERR("failed to create class\n");
	374	goto fail;
	375	}
	376
	377	dev = device_create(crystalhd_class, NULL, MKDEV(adp->chd_dec_major, 0),
	378	NULL, "crystalhd");
	379	if (!dev) {
	380	BCMLOG_ERR("failed to create device\n");
	381	goto device_create_fail;
	382	}
	383
	384	rc = crystalhd_create_elem_pool(adp, BC_LINK_ELEM_POOL_SZ);
	385	if (rc) {
	386	BCMLOG_ERR("failed to create device\n");
	387	goto elem_pool_fail;
	388	}
	389
	390	/* Allocate general purpose ioctl pool. */
	391	for (i = 0; i < CHD_IODATA_POOL_SZ; i++) {
	392	/* FIXME: jarod: why atomic? */
	393	temp = kzalloc(sizeof(crystalhd_ioctl_data), GFP_ATOMIC);
	394	if (!temp) {
	395	BCMLOG_ERR("ioctl data pool kzalloc failed\n");
	396	rc = -ENOMEM;
	397	goto kzalloc_fail;
	398	}
	399	/* Add to global pool.. */
	400	chd_dec_free_iodata(adp, temp, 0);
	401	}
	402
	403	return 0;
	404
	405	kzalloc_fail:
	406	crystalhd_delete_elem_pool(adp);
	407	elem_pool_fail:
	408	device_destroy(crystalhd_class, MKDEV(adp->chd_dec_major, 0));
	409	device_create_fail:
	410	class_destroy(crystalhd_class);
	411	fail:
	412	return rc;
	413	}
	414
21b0838c	415	static void __devexit chd_dec_release_chdev(struct crystalhd_adp *adp)
7963eb43 JW	416	{
	417	crystalhd_ioctl_data *temp = NULL;
	418	if (!adp)
	419	return;
	420
	421	if (adp->chd_dec_major > 0) {
	422	/* unregister crystalhd class */
	423	device_destroy(crystalhd_class, MKDEV(adp->chd_dec_major, 0));
	424	unregister_chrdev(adp->chd_dec_major, CRYSTALHD_API_NAME);
	425	BCMLOG(BCMLOG_INFO, "released api device - %d\n",
	426	adp->chd_dec_major);
	427	class_destroy(crystalhd_class);
	428	}
	429	adp->chd_dec_major = 0;
	430
	431	/* Clear iodata pool.. */
	432	do {
	433	temp = chd_dec_alloc_iodata(adp, 0);
	434	if (temp)
	435	kfree(temp);
	436	} while (temp);
	437
	438	crystalhd_delete_elem_pool(adp);
	439	}
	440
21b0838c	441	static int __devinit chd_pci_reserve_mem(struct crystalhd_adp *pinfo)
7963eb43 JW	442	{
	443	int rc;
	444	unsigned long bar2 = pci_resource_start(pinfo->pdev, 2);
	445	uint32_t mem_len = pci_resource_len(pinfo->pdev, 2);
	446	unsigned long bar0 = pci_resource_start(pinfo->pdev, 0);
	447	uint32_t i2o_len = pci_resource_len(pinfo->pdev, 0);
	448
	449	BCMLOG(BCMLOG_SSTEP, "bar2:0x%lx-0x%08x bar0:0x%lx-0x%08x\n",
	450	bar2, mem_len, bar0, i2o_len);
	451
	452	rc = check_mem_region(bar2, mem_len);
	453	if (rc) {
	454	BCMLOG_ERR("No valid mem region...\n");
	455	return -ENOMEM;
	456	}
	457
	458	pinfo->addr = ioremap_nocache(bar2, mem_len);
	459	if (!pinfo->addr) {
	460	BCMLOG_ERR("Failed to remap mem region...\n");
	461	return -ENOMEM;
	462	}
	463
	464	pinfo->pci_mem_start = bar2;
	465	pinfo->pci_mem_len = mem_len;
	466
	467	rc = check_mem_region(bar0, i2o_len);
	468	if (rc) {
	469	BCMLOG_ERR("No valid mem region...\n");
	470	return -ENOMEM;
	471	}
	472
	473	pinfo->i2o_addr = ioremap_nocache(bar0, i2o_len);
	474	if (!pinfo->i2o_addr) {
	475	BCMLOG_ERR("Failed to remap mem region...\n");
	476	return -ENOMEM;
	477	}
	478
	479	pinfo->pci_i2o_start = bar0;
	480	pinfo->pci_i2o_len = i2o_len;
	481
	482	rc = pci_request_regions(pinfo->pdev, pinfo->name);
	483	if (rc < 0) {
	484	BCMLOG_ERR("Region request failed: %d\n", rc);
	485	return rc;
	486	}
	487
	488	BCMLOG(BCMLOG_SSTEP, "Mapped addr:0x%08lx i2o_addr:0x%08lx\n",
	489	(unsigned long)pinfo->addr, (unsigned long)pinfo->i2o_addr);
	490
	491	return 0;
	492	}
	493
21b0838c	494	static void __devexit chd_pci_release_mem(struct crystalhd_adp *pinfo)
7963eb43 JW	495	{
	496	if (!pinfo)
	497	return;
	498
	499	if (pinfo->addr)
	500	iounmap(pinfo->addr);
	501
	502	if (pinfo->i2o_addr)
	503	iounmap(pinfo->i2o_addr);
	504
	505	pci_release_regions(pinfo->pdev);
	506	}
	507
	508
21b0838c	509	static void __devexit chd_dec_pci_remove(struct pci_dev *pdev)
7963eb43 JW	510	{
	511	struct crystalhd_adp *pinfo;
	512	BC_STATUS sts = BC_STS_SUCCESS;
	513
	514	BCMLOG_ENTER;
	515
	516	pinfo = (struct crystalhd_adp *) pci_get_drvdata(pdev);
	517	if (!pinfo) {
	518	BCMLOG_ERR("could not get adp\n");
	519	return;
	520	}
	521
	522	sts = crystalhd_delete_cmd_context(&pinfo->cmds);
	523	if (sts != BC_STS_SUCCESS)
	524	BCMLOG_ERR("cmd delete :%d \n", sts);
	525
	526	chd_dec_release_chdev(pinfo);
	527
	528	chd_dec_disable_int(pinfo);
	529
	530	chd_pci_release_mem(pinfo);
	531	pci_disable_device(pinfo->pdev);
	532
	533	kfree(pinfo);
	534	g_adp_info = NULL;
	535	}
	536
21b0838c	537	static int __devinit chd_dec_pci_probe(struct pci_dev *pdev,
7963eb43 JW	538	const struct pci_device_id *entry)
	539	{
	540	struct crystalhd_adp *pinfo;
	541	int rc;
	542	BC_STATUS sts = BC_STS_SUCCESS;
	543
	544	BCMLOG(BCMLOG_DBG, "PCI_INFO: Vendor:0x%04x Device:0x%04x "
	545	"s_vendor:0x%04x s_device: 0x%04x\n",
	546	pdev->vendor, pdev->device, pdev->subsystem_vendor,
	547	pdev->subsystem_device);
	548
	549	/* FIXME: jarod: why atomic? */
	550	pinfo = kzalloc(sizeof(struct crystalhd_adp), GFP_ATOMIC);
	551	if (!pinfo) {
	552	BCMLOG_ERR("Failed to allocate memory\n");
	553	return -ENOMEM;
	554	}
	555
	556	pinfo->pdev = pdev;
	557
	558	rc = pci_enable_device(pdev);
	559	if (rc) {
	560	BCMLOG_ERR("Failed to enable PCI device\n");
	561	return rc;
	562	}
	563
	564	snprintf(pinfo->name, 31, "crystalhd_pci_e:%d:%d:%d",
	565	pdev->bus->number, PCI_SLOT(pdev->devfn),
	566	PCI_FUNC(pdev->devfn));
	567
	568	rc = chd_pci_reserve_mem(pinfo);
	569	if (rc) {
	570	BCMLOG_ERR("Failed to setup memory regions.\n");
	571	return -ENOMEM;
	572	}
	573
	574	pinfo->present = 1;
	575	pinfo->drv_data = entry->driver_data;
	576
	577	/* Setup adapter level lock.. */
	578	spin_lock_init(&pinfo->lock);
	579
	580	/* setup api stuff.. */
	581	chd_dec_init_chdev(pinfo);
	582	rc = chd_dec_enable_int(pinfo);
	583	if (rc) {
	584	BCMLOG_ERR("_enable_int err:%d \n", rc);
	585	pci_disable_device(pdev);
	586	return -ENODEV;
	587	}
	588
	589	/* Set dma mask... */
	590	if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
	591	pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
	592	pinfo->dmabits = 64;
	593	} else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
	594	pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
	595	pinfo->dmabits = 32;
	596	} else {
	597	BCMLOG_ERR("Unabled to setup DMA %d\n", rc);
	598	pci_disable_device(pdev);
	599	return -ENODEV;
	600	}
	601
602	sts = crystalhd_setup_cmd_context(&pinfo->cmds, pinfo);
603	if (sts != BC_STS_SUCCESS) {
604	BCMLOG_ERR("cmd setup :%d \n", sts);
605	pci_disable_device(pdev);
606	return -ENODEV;
607	}
608
609	pci_set_master(pdev);
610
611	pci_set_drvdata(pdev, pinfo);
612
613	g_adp_info = pinfo;
614
615	return 0;
7963eb43 JW	616	}
	617
	618	#ifdef CONFIG_PM
	619	int chd_dec_pci_suspend(struct pci_dev *pdev, pm_message_t state)
	620	{
	621	struct crystalhd_adp *adp;
	622	crystalhd_ioctl_data *temp;
	623	BC_STATUS sts = BC_STS_SUCCESS;
	624
	625	adp = (struct crystalhd_adp *)pci_get_drvdata(pdev);
	626	if (!adp) {
	627	BCMLOG_ERR("could not get adp\n");
	628	return -ENODEV;
	629	}
	630
	631	temp = chd_dec_alloc_iodata(adp, false);
	632	if (!temp) {
	633	BCMLOG_ERR("could not get ioctl data\n");
	634	return -ENODEV;
	635	}
	636
	637	sts = crystalhd_suspend(&adp->cmds, temp);
	638	if (sts != BC_STS_SUCCESS) {
	639	BCMLOG_ERR("BCM70012 Suspend %d\n", sts);
	640	return -ENODEV;
	641	}
	642
	643	chd_dec_free_iodata(adp, temp, false);
	644	chd_dec_disable_int(adp);
	645	pci_save_state(pdev);
	646
	647	/* Disable IO/bus master/irq router */
	648	pci_disable_device(pdev);
	649	pci_set_power_state(pdev, pci_choose_state(pdev, state));
	650	return 0;
	651	}
	652
	653	int chd_dec_pci_resume(struct pci_dev *pdev)
	654	{
	655	struct crystalhd_adp *adp;
	656	BC_STATUS sts = BC_STS_SUCCESS;
	657	int rc;
	658
	659	adp = (struct crystalhd_adp *)pci_get_drvdata(pdev);
	660	if (!adp) {
	661	BCMLOG_ERR("could not get adp\n");
	662	return -ENODEV;
	663	}
	664
	665	pci_set_power_state(pdev, PCI_D0);
	666	pci_restore_state(pdev);
	667
	668	/* device's irq possibly is changed, driver should take care */
	669	if (pci_enable_device(pdev)) {
	670	BCMLOG_ERR("Failed to enable PCI device\n");
	671	return 1;
	672	}
	673
	674	pci_set_master(pdev);
	675
	676	rc = chd_dec_enable_int(adp);
	677	if (rc) {
	678	BCMLOG_ERR("_enable_int err:%d \n", rc);
	679	pci_disable_device(pdev);
680	return -ENODEV;
681	}
682
683	sts = crystalhd_resume(&adp->cmds);
684	if (sts != BC_STS_SUCCESS) {
685	BCMLOG_ERR("BCM70012 Resume %d\n", sts);
686	pci_disable_device(pdev);
687	return -ENODEV;
688	}
689
690	return 0;
691	}
692	#endif
693
21b0838c AP	694	static DEFINE_PCI_DEVICE_TABLE(chd_dec_pci_id_table) = {
21b0838c AP	695	{ PCI_VDEVICE(BROADCOM, 0x1612), 8 },
7963eb43 JW	696	{ 0, },
7963eb43 JW	697	};
21b0838c	698	MODULE_DEVICE_TABLE(pci, chd_dec_pci_id_table);
7963eb43	699
21b0838c	700	static struct pci_driver bc_chd_70012_driver = {
7963eb43 JW	701	.name = "Broadcom 70012 Decoder",
7963eb43 JW	702	.probe = chd_dec_pci_probe,
21b0838c	703	.remove = __devexit_p(chd_dec_pci_remove),
7963eb43 JW	704	.id_table = chd_dec_pci_id_table,
	705	#ifdef CONFIG_PM
	706	.suspend = chd_dec_pci_suspend,
	707	.resume = chd_dec_pci_resume
	708	#endif
	709	};
7963eb43 JW	710
	711	void chd_set_log_level(struct crystalhd_adp adp, char arg)
	712	{
	713	if ((!arg) \|\| (strlen(arg) < 3))
	714	g_linklog_level = BCMLOG_ERROR \| BCMLOG_DATA;
	715	else if (!strncmp(arg, "sstep", 5))
	716	g_linklog_level = BCMLOG_INFO \| BCMLOG_DATA \| BCMLOG_DBG \|
	717	BCMLOG_SSTEP \| BCMLOG_ERROR;
	718	else if (!strncmp(arg, "info", 4))
	719	g_linklog_level = BCMLOG_ERROR \| BCMLOG_DATA \| BCMLOG_INFO;
	720	else if (!strncmp(arg, "debug", 5))
	721	g_linklog_level = BCMLOG_ERROR \| BCMLOG_DATA \| BCMLOG_INFO \|
	722	BCMLOG_DBG;
	723	else if (!strncmp(arg, "pball", 5))
	724	g_linklog_level = 0xFFFFFFFF & ~(BCMLOG_SPINLOCK);
	725	else if (!strncmp(arg, "silent", 6))
	726	g_linklog_level = 0;
	727	else
	728	g_linklog_level = 0;
	729	}
	730
	731	struct crystalhd_adp *chd_get_adp(void)
	732	{
	733	return g_adp_info;
	734	}
	735
21b0838c	736	static int __init chd_dec_module_init(void)
7963eb43 JW	737	{
	738	int rc;
	739
	740	chd_set_log_level(NULL, "debug");
	741	BCMLOG(BCMLOG_DATA, "Loading crystalhd %d.%d.%d \n",
	742	crystalhd_kmod_major, crystalhd_kmod_minor, crystalhd_kmod_rev);
	743
	744	rc = pci_register_driver(&bc_chd_70012_driver);
	745
	746	if (rc < 0)
	747	BCMLOG_ERR("Could not find any devices. err:%d \n", rc);
	748
	749	return rc;
	750	}
21b0838c	751	module_init(chd_dec_module_init);
7963eb43	752
21b0838c	753	static void __exit chd_dec_module_cleanup(void)
7963eb43 JW	754	{
	755	BCMLOG(BCMLOG_DATA, "unloading crystalhd %d.%d.%d \n",
	756	crystalhd_kmod_major, crystalhd_kmod_minor, crystalhd_kmod_rev);
	757
	758	pci_unregister_driver(&bc_chd_70012_driver);
	759	}
21b0838c	760	module_exit(chd_dec_module_cleanup);
7963eb43 JW	761
	762	MODULE_AUTHOR("Naren Sankar <nsankar@broadcom.com>");
	763	MODULE_AUTHOR("Prasad Bolisetty <prasadb@broadcom.com>");
	764	MODULE_DESCRIPTION(CRYSTAL_HD_NAME);
	765	MODULE_LICENSE("GPL");
	766	MODULE_ALIAS("bcm70012");