1 /***************************************************************************
3 Copyright (c) 2005-2009, Broadcom Corporation.
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.
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.
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 ***************************************************************************/
18 #include <linux/version.h>
19 #include <linux/slab.h>
21 #include "crystalhd_lnx.h"
23 static struct class *crystalhd_class;
25 static struct crystalhd_adp *g_adp_info;
27 static irqreturn_t chd_dec_isr(int irq, void *arg)
29 struct crystalhd_adp *adp = (struct crystalhd_adp *) arg;
32 rc = crystalhd_cmd_interrupt(&adp->cmds);
34 return IRQ_RETVAL(rc);
37 static int chd_dec_enable_int(struct crystalhd_adp *adp)
41 if (!adp || !adp->pdev) {
42 BCMLOG_ERR("Invalid arg!!\n");
46 if (adp->pdev->msi_enabled)
49 adp->msi = pci_enable_msi(adp->pdev);
51 rc = request_irq(adp->pdev->irq, chd_dec_isr, IRQF_SHARED,
52 adp->name, (void *)adp);
54 BCMLOG_ERR("Interrupt request failed.. \n");
55 pci_disable_msi(adp->pdev);
61 static int chd_dec_disable_int(struct crystalhd_adp *adp)
63 if (!adp || !adp->pdev) {
64 BCMLOG_ERR("Invalid arg!!\n");
68 free_irq(adp->pdev->irq, adp);
71 pci_disable_msi(adp->pdev);
76 crystalhd_ioctl_data *chd_dec_alloc_iodata(struct crystalhd_adp *adp, bool isr)
78 unsigned long flags = 0;
79 crystalhd_ioctl_data *temp;
84 spin_lock_irqsave(&adp->lock, flags);
86 temp = adp->idata_free_head;
88 adp->idata_free_head = adp->idata_free_head->next;
89 memset(temp, 0, sizeof(*temp));
92 spin_unlock_irqrestore(&adp->lock, flags);
96 void chd_dec_free_iodata(struct crystalhd_adp *adp, crystalhd_ioctl_data *iodata,
99 unsigned long flags = 0;
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);
110 static inline int crystalhd_user_data(unsigned long ud, void *dr, int size, int set)
115 BCMLOG_ERR("Invalid arg \n");
120 rc = copy_to_user((void *)ud, dr, size);
122 rc = copy_from_user(dr, (void *)ud, size);
125 BCMLOG_ERR("Invalid args for command \n");
132 static int chd_dec_fetch_cdata(struct crystalhd_adp *adp, crystalhd_ioctl_data *io,
133 uint32_t m_sz, unsigned long ua)
135 unsigned long ua_off;
138 if (!adp || !io || !ua || !m_sz) {
139 BCMLOG_ERR("Invalid Arg!!\n");
143 io->add_cdata = vmalloc(m_sz);
144 if (!io->add_cdata) {
145 BCMLOG_ERR("kalloc fail for sz:%x\n", m_sz);
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);
153 BCMLOG_ERR("failed to pull add_cdata sz:%x ua_off:%x\n",
154 io->add_cdata_sz, (unsigned int)ua_off);
156 kfree(io->add_cdata);
157 io->add_cdata = NULL;
165 static int chd_dec_release_cdata(struct crystalhd_adp *adp,
166 crystalhd_ioctl_data *io, unsigned long ua)
168 unsigned long ua_off;
171 if (!adp || !io || !ua) {
172 BCMLOG_ERR("Invalid Arg!!\n");
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);
181 BCMLOG_ERR("failed to push add_cdata sz:%x ua_off:%x\n",
182 io->add_cdata_sz, (unsigned int)ua_off);
188 vfree(io->add_cdata);
189 io->add_cdata = NULL;
195 static int chd_dec_proc_user_data(struct crystalhd_adp *adp,
196 crystalhd_ioctl_data *io,
197 unsigned long ua, int set)
202 if (!adp || !io || !ua) {
203 BCMLOG_ERR("Invalid Arg!!\n");
207 rc = crystalhd_user_data(ua, &io->udata, sizeof(io->udata), set);
209 BCMLOG_ERR("failed to %s iodata \n", (set ? "set" : "get"));
216 case BCM_IOC_FW_DOWNLOAD:
217 m_sz = io->udata.u.devMem.NumDwords * 4;
219 rc = chd_dec_release_cdata(adp, io, ua);
221 rc = chd_dec_fetch_cdata(adp, io, m_sz, ua);
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)
234 crystalhd_ioctl_data *temp;
235 BC_STATUS sts = BC_STS_SUCCESS;
237 temp = chd_dec_alloc_iodata(adp, 0);
239 BCMLOG_ERR("Failed to get iodata..\n");
246 rc = chd_dec_proc_user_data(adp, temp, ua, 0);
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);
256 chd_dec_free_iodata(adp, temp, 0);
264 static int chd_dec_ioctl(struct inode *in, struct file *fd,
265 unsigned int cmd, unsigned long ua)
267 struct crystalhd_adp *adp = chd_get_adp();
268 crystalhd_cmd_proc cproc;
269 struct crystalhd_user *uc;
272 BCMLOG_ERR("Invalid adp\n");
276 uc = (struct crystalhd_user *)fd->private_data;
278 BCMLOG_ERR("Failed to get uc\n");
282 cproc = crystalhd_get_cmd_proc(&adp->cmds, cmd, uc);
284 BCMLOG_ERR("Unhandled command: %d\n", cmd);
288 return chd_dec_api_cmd(adp, ua, uc->uid, cmd, cproc);
291 static int chd_dec_open(struct inode *in, struct file *fd)
293 struct crystalhd_adp *adp = chd_get_adp();
295 BC_STATUS sts = BC_STS_SUCCESS;
296 struct crystalhd_user *uc = NULL;
300 BCMLOG_ERR("Invalid adp\n");
304 if (adp->cfg_users >= BC_LINK_MAX_OPENS) {
305 BCMLOG(BCMLOG_INFO, "Already in use.%d\n", adp->cfg_users);
309 sts = crystalhd_user_open(&adp->cmds, &uc);
310 if (sts != BC_STS_SUCCESS) {
311 BCMLOG_ERR("cmd_user_open - %d \n", sts);
317 fd->private_data = uc;
322 static int chd_dec_close(struct inode *in, struct file *fd)
324 struct crystalhd_adp *adp = chd_get_adp();
325 struct crystalhd_user *uc;
329 BCMLOG_ERR("Invalid adp \n");
333 uc = (struct crystalhd_user *)fd->private_data;
335 BCMLOG_ERR("Failed to get uc\n");
339 crystalhd_user_close(&adp->cmds, uc);
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,
353 static int __devinit chd_dec_init_chdev(struct crystalhd_adp *adp)
355 crystalhd_ioctl_data *temp;
357 int rc = -ENODEV, i = 0;
362 adp->chd_dec_major = register_chrdev(0, CRYSTALHD_API_NAME,
364 if (adp->chd_dec_major < 0) {
365 BCMLOG_ERR("Failed to create config dev\n");
366 rc = adp->chd_dec_major;
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");
377 dev = device_create(crystalhd_class, NULL, MKDEV(adp->chd_dec_major, 0),
380 BCMLOG_ERR("failed to create device\n");
381 goto device_create_fail;
384 rc = crystalhd_create_elem_pool(adp, BC_LINK_ELEM_POOL_SZ);
386 BCMLOG_ERR("failed to create device\n");
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);
395 BCMLOG_ERR("ioctl data pool kzalloc failed\n");
399 /* Add to global pool.. */
400 chd_dec_free_iodata(adp, temp, 0);
406 crystalhd_delete_elem_pool(adp);
408 device_destroy(crystalhd_class, MKDEV(adp->chd_dec_major, 0));
410 class_destroy(crystalhd_class);
415 static void __devexit chd_dec_release_chdev(struct crystalhd_adp *adp)
417 crystalhd_ioctl_data *temp = NULL;
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",
427 class_destroy(crystalhd_class);
429 adp->chd_dec_major = 0;
431 /* Clear iodata pool.. */
433 temp = chd_dec_alloc_iodata(adp, 0);
438 crystalhd_delete_elem_pool(adp);
441 static int __devinit chd_pci_reserve_mem(struct crystalhd_adp *pinfo)
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);
449 BCMLOG(BCMLOG_SSTEP, "bar2:0x%lx-0x%08x bar0:0x%lx-0x%08x\n",
450 bar2, mem_len, bar0, i2o_len);
452 rc = check_mem_region(bar2, mem_len);
454 BCMLOG_ERR("No valid mem region...\n");
458 pinfo->addr = ioremap_nocache(bar2, mem_len);
460 BCMLOG_ERR("Failed to remap mem region...\n");
464 pinfo->pci_mem_start = bar2;
465 pinfo->pci_mem_len = mem_len;
467 rc = check_mem_region(bar0, i2o_len);
469 BCMLOG_ERR("No valid mem region...\n");
473 pinfo->i2o_addr = ioremap_nocache(bar0, i2o_len);
474 if (!pinfo->i2o_addr) {
475 BCMLOG_ERR("Failed to remap mem region...\n");
479 pinfo->pci_i2o_start = bar0;
480 pinfo->pci_i2o_len = i2o_len;
482 rc = pci_request_regions(pinfo->pdev, pinfo->name);
484 BCMLOG_ERR("Region request failed: %d\n", rc);
488 BCMLOG(BCMLOG_SSTEP, "Mapped addr:0x%08lx i2o_addr:0x%08lx\n",
489 (unsigned long)pinfo->addr, (unsigned long)pinfo->i2o_addr);
494 static void __devexit chd_pci_release_mem(struct crystalhd_adp *pinfo)
500 iounmap(pinfo->addr);
503 iounmap(pinfo->i2o_addr);
505 pci_release_regions(pinfo->pdev);
509 static void __devexit chd_dec_pci_remove(struct pci_dev *pdev)
511 struct crystalhd_adp *pinfo;
512 BC_STATUS sts = BC_STS_SUCCESS;
516 pinfo = (struct crystalhd_adp *) pci_get_drvdata(pdev);
518 BCMLOG_ERR("could not get adp\n");
522 sts = crystalhd_delete_cmd_context(&pinfo->cmds);
523 if (sts != BC_STS_SUCCESS)
524 BCMLOG_ERR("cmd delete :%d \n", sts);
526 chd_dec_release_chdev(pinfo);
528 chd_dec_disable_int(pinfo);
530 chd_pci_release_mem(pinfo);
531 pci_disable_device(pinfo->pdev);
537 static int __devinit chd_dec_pci_probe(struct pci_dev *pdev,
538 const struct pci_device_id *entry)
540 struct crystalhd_adp *pinfo;
542 BC_STATUS sts = BC_STS_SUCCESS;
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);
549 /* FIXME: jarod: why atomic? */
550 pinfo = kzalloc(sizeof(struct crystalhd_adp), GFP_ATOMIC);
552 BCMLOG_ERR("Failed to allocate memory\n");
558 rc = pci_enable_device(pdev);
560 BCMLOG_ERR("Failed to enable PCI device\n");
564 snprintf(pinfo->name, 31, "crystalhd_pci_e:%d:%d:%d",
565 pdev->bus->number, PCI_SLOT(pdev->devfn),
566 PCI_FUNC(pdev->devfn));
568 rc = chd_pci_reserve_mem(pinfo);
570 BCMLOG_ERR("Failed to setup memory regions.\n");
575 pinfo->drv_data = entry->driver_data;
577 /* Setup adapter level lock.. */
578 spin_lock_init(&pinfo->lock);
580 /* setup api stuff.. */
581 chd_dec_init_chdev(pinfo);
582 rc = chd_dec_enable_int(pinfo);
584 BCMLOG_ERR("_enable_int err:%d \n", rc);
585 pci_disable_device(pdev);
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));
593 } else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
594 pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
597 BCMLOG_ERR("Unabled to setup DMA %d\n", rc);
598 pci_disable_device(pdev);
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);
609 pci_set_master(pdev);
611 pci_set_drvdata(pdev, pinfo);
619 int chd_dec_pci_suspend(struct pci_dev *pdev, pm_message_t state)
621 struct crystalhd_adp *adp;
622 crystalhd_ioctl_data *temp;
623 BC_STATUS sts = BC_STS_SUCCESS;
625 adp = (struct crystalhd_adp *)pci_get_drvdata(pdev);
627 BCMLOG_ERR("could not get adp\n");
631 temp = chd_dec_alloc_iodata(adp, false);
633 BCMLOG_ERR("could not get ioctl data\n");
637 sts = crystalhd_suspend(&adp->cmds, temp);
638 if (sts != BC_STS_SUCCESS) {
639 BCMLOG_ERR("BCM70012 Suspend %d\n", sts);
643 chd_dec_free_iodata(adp, temp, false);
644 chd_dec_disable_int(adp);
645 pci_save_state(pdev);
647 /* Disable IO/bus master/irq router */
648 pci_disable_device(pdev);
649 pci_set_power_state(pdev, pci_choose_state(pdev, state));
653 int chd_dec_pci_resume(struct pci_dev *pdev)
655 struct crystalhd_adp *adp;
656 BC_STATUS sts = BC_STS_SUCCESS;
659 adp = (struct crystalhd_adp *)pci_get_drvdata(pdev);
661 BCMLOG_ERR("could not get adp\n");
665 pci_set_power_state(pdev, PCI_D0);
666 pci_restore_state(pdev);
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");
674 pci_set_master(pdev);
676 rc = chd_dec_enable_int(adp);
678 BCMLOG_ERR("_enable_int err:%d \n", rc);
679 pci_disable_device(pdev);
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);
694 static DEFINE_PCI_DEVICE_TABLE(chd_dec_pci_id_table) = {
695 { PCI_VDEVICE(BROADCOM, 0x1612), 8 },
698 MODULE_DEVICE_TABLE(pci, chd_dec_pci_id_table);
700 static struct pci_driver bc_chd_70012_driver = {
701 .name = "Broadcom 70012 Decoder",
702 .probe = chd_dec_pci_probe,
703 .remove = __devexit_p(chd_dec_pci_remove),
704 .id_table = chd_dec_pci_id_table,
706 .suspend = chd_dec_pci_suspend,
707 .resume = chd_dec_pci_resume
711 void chd_set_log_level(struct crystalhd_adp *adp, char *arg)
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 |
723 else if (!strncmp(arg, "pball", 5))
724 g_linklog_level = 0xFFFFFFFF & ~(BCMLOG_SPINLOCK);
725 else if (!strncmp(arg, "silent", 6))
731 struct crystalhd_adp *chd_get_adp(void)
736 static int __init chd_dec_module_init(void)
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);
744 rc = pci_register_driver(&bc_chd_70012_driver);
747 BCMLOG_ERR("Could not find any devices. err:%d \n", rc);
751 module_init(chd_dec_module_init);
753 static void __exit chd_dec_module_cleanup(void)
755 BCMLOG(BCMLOG_DATA, "unloading crystalhd %d.%d.%d \n",
756 crystalhd_kmod_major, crystalhd_kmod_minor, crystalhd_kmod_rev);
758 pci_unregister_driver(&bc_chd_70012_driver);
760 module_exit(chd_dec_module_cleanup);
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");