drivers/staging/crystalhd/crystalhd_lnx.c

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