drivers/crypto/cavium/cpt/cptpf_main.c

   1 /*
   2  * Copyright (C) 2016 Cavium, Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of version 2 of the GNU General Public License
   6  * as published by the Free Software Foundation.
   7  */
   8
   9 #include <linux/device.h>
  10 #include <linux/firmware.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/module.h>
  13 #include <linux/moduleparam.h>
  14 #include <linux/pci.h>
  15 #include <linux/printk.h>
  16 #include <linux/version.h>
  17
  18 #include "cptpf.h"
  19
  20 #define DRV_NAME        "thunder-cpt"
  21 #define DRV_VERSION     "1.0"
  22
  23 static u32 num_vfs = 4; /* Default 4 VF enabled */
  24 module_param(num_vfs, uint, 0444);
  25 MODULE_PARM_DESC(num_vfs, "Number of VFs to enable(1-16)");
  26
  27 /*
  28  * Disable cores specified by coremask
  29  */
  30 static void cpt_disable_cores(struct cpt_device *cpt, u64 coremask,
  31                               u8 type, u8 grp)
  32 {
  33         u64 pf_exe_ctl;
  34         u32 timeout = 100;
  35         u64 grpmask = 0;
  36         struct device *dev = &cpt->pdev->dev;
  37
  38         if (type == AE_TYPES)
  39                 coremask = (coremask << cpt->max_se_cores);
  40
  41         /* Disengage the cores from groups */
  42         grpmask = cpt_read_csr64(cpt->reg_base, CPTX_PF_GX_EN(0, grp));
  43         cpt_write_csr64(cpt->reg_base, CPTX_PF_GX_EN(0, grp),
  44                         (grpmask & ~coremask));
  45         udelay(CSR_DELAY);
  46         grp = cpt_read_csr64(cpt->reg_base, CPTX_PF_EXEC_BUSY(0));
  47         while (grp & coremask) {
  48                 dev_err(dev, "Cores still busy %llx", coremask);
  49                 grp = cpt_read_csr64(cpt->reg_base,
  50                                      CPTX_PF_EXEC_BUSY(0));
  51                 if (timeout--)
  52                         break;
  53
  54                 udelay(CSR_DELAY);
  55         }
  56
  57         /* Disable the cores */
  58         pf_exe_ctl = cpt_read_csr64(cpt->reg_base, CPTX_PF_EXE_CTL(0));
  59         cpt_write_csr64(cpt->reg_base, CPTX_PF_EXE_CTL(0),
  60                         (pf_exe_ctl & ~coremask));
  61         udelay(CSR_DELAY);
  62 }
  63
  64 /*
  65  * Enable cores specified by coremask
  66  */
  67 static void cpt_enable_cores(struct cpt_device *cpt, u64 coremask,
  68                              u8 type)
  69 {
  70         u64 pf_exe_ctl;
  71
  72         if (type == AE_TYPES)
  73                 coremask = (coremask << cpt->max_se_cores);
  74
  75         pf_exe_ctl = cpt_read_csr64(cpt->reg_base, CPTX_PF_EXE_CTL(0));
  76         cpt_write_csr64(cpt->reg_base, CPTX_PF_EXE_CTL(0),
  77                         (pf_exe_ctl | coremask));
  78         udelay(CSR_DELAY);
  79 }
  80
  81 static void cpt_configure_group(struct cpt_device *cpt, u8 grp,
  82                                 u64 coremask, u8 type)
  83 {
  84         u64 pf_gx_en = 0;
  85
  86         if (type == AE_TYPES)
  87                 coremask = (coremask << cpt->max_se_cores);
  88
  89         pf_gx_en = cpt_read_csr64(cpt->reg_base, CPTX_PF_GX_EN(0, grp));
  90         cpt_write_csr64(cpt->reg_base, CPTX_PF_GX_EN(0, grp),
  91                         (pf_gx_en | coremask));
  92         udelay(CSR_DELAY);
  93 }
  94
  95 static void cpt_disable_mbox_interrupts(struct cpt_device *cpt)
  96 {
  97         /* Clear mbox(0) interupts for all vfs */
  98         cpt_write_csr64(cpt->reg_base, CPTX_PF_MBOX_ENA_W1CX(0, 0), ~0ull);
  99 }
 100
 101 static void cpt_disable_ecc_interrupts(struct cpt_device *cpt)
 102 {
 103         /* Clear ecc(0) interupts for all vfs */
 104         cpt_write_csr64(cpt->reg_base, CPTX_PF_ECC0_ENA_W1C(0), ~0ull);
 105 }
 106
 107 static void cpt_disable_exec_interrupts(struct cpt_device *cpt)
 108 {
 109         /* Clear exec interupts for all vfs */
 110         cpt_write_csr64(cpt->reg_base, CPTX_PF_EXEC_ENA_W1C(0), ~0ull);
 111 }
 112
 113 static void cpt_disable_all_interrupts(struct cpt_device *cpt)
 114 {
 115         cpt_disable_mbox_interrupts(cpt);
 116         cpt_disable_ecc_interrupts(cpt);
 117         cpt_disable_exec_interrupts(cpt);
 118 }
 119
 120 static void cpt_enable_mbox_interrupts(struct cpt_device *cpt)
 121 {
 122         /* Set mbox(0) interupts for all vfs */
 123         cpt_write_csr64(cpt->reg_base, CPTX_PF_MBOX_ENA_W1SX(0, 0), ~0ull);
 124 }
 125
 126 static int cpt_load_microcode(struct cpt_device *cpt, struct microcode *mcode)
 127 {
 128         int ret = 0, core = 0, shift = 0;
 129         u32 total_cores = 0;
 130         struct device *dev = &cpt->pdev->dev;
 131
 132         if (!mcode || !mcode->code) {
 133                 dev_err(dev, "Either the mcode is null or data is NULL\n");
 134                 return -EINVAL;
 135         }
 136
 137         if (mcode->code_size == 0) {
 138                 dev_err(dev, "microcode size is 0\n");
 139                 return -EINVAL;
 140         }
 141
 142         /* Assumes 0-9 are SE cores for UCODE_BASE registers and
 143          * AE core bases follow
 144          */
 145         if (mcode->is_ae) {
 146                 core = CPT_MAX_SE_CORES; /* start couting from 10 */
 147                 total_cores = CPT_MAX_TOTAL_CORES; /* upto 15 */
 148         } else {
 149                 core = 0; /* start couting from 0 */
 150                 total_cores = CPT_MAX_SE_CORES; /* upto 9 */
 151         }
 152
 153         /* Point to microcode for each core of the group */
 154         for (; core < total_cores ; core++, shift++) {
 155                 if (mcode->core_mask & (1 << shift)) {
 156                         cpt_write_csr64(cpt->reg_base,
 157                                         CPTX_PF_ENGX_UCODE_BASE(0, core),
 158                                         (u64)mcode->phys_base);
 159                 }
 160         }
 161         return ret;
 162 }
 163
 164 static int do_cpt_init(struct cpt_device *cpt, struct microcode *mcode)
 165 {
 166         int ret = 0;
 167         struct device *dev = &cpt->pdev->dev;
 168
 169         /* Make device not ready */
 170         cpt->flags &= ~CPT_FLAG_DEVICE_READY;
 171         /* Disable All PF interrupts */
 172         cpt_disable_all_interrupts(cpt);
 173         /* Calculate mcode group and coremasks */
 174         if (mcode->is_ae) {
 175                 if (mcode->num_cores > cpt->max_ae_cores) {
 176                         dev_err(dev, "Requested for more cores than available AE cores\n");
 177                         ret = -EINVAL;
 178                         goto cpt_init_fail;
 179                 }
 180
 181                 if (cpt->next_group >= CPT_MAX_CORE_GROUPS) {
 182                         dev_err(dev, "Can't load, all eight microcode groups in use");
 183                         return -ENFILE;
 184                 }
 185
 186                 mcode->group = cpt->next_group;
 187                 /* Convert requested cores to mask */
 188                 mcode->core_mask = GENMASK(mcode->num_cores, 0);
 189                 cpt_disable_cores(cpt, mcode->core_mask, AE_TYPES,
 190                                   mcode->group);
 191                 /* Load microcode for AE engines */
 192                 ret = cpt_load_microcode(cpt, mcode);
 193                 if (ret) {
 194                         dev_err(dev, "Microcode load Failed for %s\n",
 195                                 mcode->version);
 196                         goto cpt_init_fail;
 197                 }
 198                 cpt->next_group++;
 199                 /* Configure group mask for the mcode */
 200                 cpt_configure_group(cpt, mcode->group, mcode->core_mask,
 201                                     AE_TYPES);
 202                 /* Enable AE cores for the group mask */
 203                 cpt_enable_cores(cpt, mcode->core_mask, AE_TYPES);
 204         } else {
 205                 if (mcode->num_cores > cpt->max_se_cores) {
 206                         dev_err(dev, "Requested for more cores than available SE cores\n");
 207                         ret = -EINVAL;
 208                         goto cpt_init_fail;
 209                 }
 210                 if (cpt->next_group >= CPT_MAX_CORE_GROUPS) {
 211                         dev_err(dev, "Can't load, all eight microcode groups in use");
 212                         return -ENFILE;
 213                 }
 214
 215                 mcode->group = cpt->next_group;
 216                 /* Covert requested cores to mask */
 217                 mcode->core_mask = GENMASK(mcode->num_cores, 0);
 218                 cpt_disable_cores(cpt, mcode->core_mask, SE_TYPES,
 219                                   mcode->group);
 220                 /* Load microcode for SE engines */
 221                 ret = cpt_load_microcode(cpt, mcode);
 222                 if (ret) {
 223                         dev_err(dev, "Microcode load Failed for %s\n",
 224                                 mcode->version);
 225                         goto cpt_init_fail;
 226                 }
 227                 cpt->next_group++;
 228                 /* Configure group mask for the mcode */
 229                 cpt_configure_group(cpt, mcode->group, mcode->core_mask,
 230                                     SE_TYPES);
 231                 /* Enable SE cores for the group mask */
 232                 cpt_enable_cores(cpt, mcode->core_mask, SE_TYPES);
 233         }
 234
 235         /* Enabled PF mailbox interrupts */
 236         cpt_enable_mbox_interrupts(cpt);
 237         cpt->flags |= CPT_FLAG_DEVICE_READY;
 238
 239         return ret;
 240
 241 cpt_init_fail:
 242         /* Enabled PF mailbox interrupts */
 243         cpt_enable_mbox_interrupts(cpt);
 244
 245         return ret;
 246 }
 247
 248 struct ucode_header {
 249         u8 version[CPT_UCODE_VERSION_SZ];
 250         u32 code_length;
 251         u32 data_length;
 252         u64 sram_address;
 253 };
 254
 255 static int cpt_ucode_load_fw(struct cpt_device *cpt, const u8 *fw, bool is_ae)
 256 {
 257         const struct firmware *fw_entry;
 258         struct device *dev = &cpt->pdev->dev;
 259         struct ucode_header *ucode;
 260         unsigned int code_length;
 261         struct microcode *mcode;
 262         int j, ret = 0;
 263
 264         ret = reject_firmware(&fw_entry, fw, dev);
 265         if (ret)
 266                 return ret;
 267
 268         ucode = (struct ucode_header *)fw_entry->data;
 269         mcode = &cpt->mcode[cpt->next_mc_idx];
 270         memcpy(mcode->version, (u8 *)fw_entry->data, CPT_UCODE_VERSION_SZ);
 271         code_length = ntohl(ucode->code_length);
 272         if (code_length == 0 || code_length >= INT_MAX / 2) {
 273                 ret = -EINVAL;
 274                 goto fw_release;
 275         }
 276         mcode->code_size = code_length * 2;
 277
 278         mcode->is_ae = is_ae;
 279         mcode->core_mask = 0ULL;
 280         mcode->num_cores = is_ae ? 6 : 10;
 281
 282         /*  Allocate DMAable space */
 283         mcode->code = dma_zalloc_coherent(&cpt->pdev->dev, mcode->code_size,
 284                                           &mcode->phys_base, GFP_KERNEL);
 285         if (!mcode->code) {
 286                 dev_err(dev, "Unable to allocate space for microcode");
 287                 ret = -ENOMEM;
 288                 goto fw_release;
 289         }
 290
 291         memcpy((void *)mcode->code, (void *)(fw_entry->data + sizeof(*ucode)),
 292                mcode->code_size);
 293
 294         /* Byte swap 64-bit */
 295         for (j = 0; j < (mcode->code_size / 8); j++)
 296                 ((u64 *)mcode->code)[j] = cpu_to_be64(((u64 *)mcode->code)[j]);
 297         /*  MC needs 16-bit swap */
 298         for (j = 0; j < (mcode->code_size / 2); j++)
 299                 ((u16 *)mcode->code)[j] = cpu_to_be16(((u16 *)mcode->code)[j]);
 300
 301         dev_dbg(dev, "mcode->code_size = %u\n", mcode->code_size);
 302         dev_dbg(dev, "mcode->is_ae = %u\n", mcode->is_ae);
 303         dev_dbg(dev, "mcode->num_cores = %u\n", mcode->num_cores);
 304         dev_dbg(dev, "mcode->code = %llx\n", (u64)mcode->code);
 305         dev_dbg(dev, "mcode->phys_base = %llx\n", mcode->phys_base);
 306
 307         ret = do_cpt_init(cpt, mcode);
 308         if (ret) {
 309                 dev_err(dev, "do_cpt_init failed with ret: %d\n", ret);
 310                 goto fw_release;
 311         }
 312
 313         dev_info(dev, "Microcode Loaded %s\n", mcode->version);
 314         mcode->is_mc_valid = 1;
 315         cpt->next_mc_idx++;
 316
 317 fw_release:
 318         release_firmware(fw_entry);
 319
 320         return ret;
 321 }
 322
 323 static int cpt_ucode_load(struct cpt_device *cpt)
 324 {
 325         int ret = 0;
 326         struct device *dev = &cpt->pdev->dev;
 327
 328         ret = cpt_ucode_load_fw(cpt, "/*(DEBLOBBED)*/", true);
 329         if (ret) {
 330                 dev_err(dev, "ae:cpt_ucode_load failed with ret: %d\n", ret);
 331                 return ret;
 332         }
 333         ret = cpt_ucode_load_fw(cpt, "/*(DEBLOBBED)*/", false);
 334         if (ret) {
 335                 dev_err(dev, "se:cpt_ucode_load failed with ret: %d\n", ret);
 336                 return ret;
 337         }
 338
 339         return ret;
 340 }
 341
 342 static irqreturn_t cpt_mbx0_intr_handler(int irq, void *cpt_irq)
 343 {
 344         struct cpt_device *cpt = (struct cpt_device *)cpt_irq;
 345
 346         cpt_mbox_intr_handler(cpt, 0);
 347
 348         return IRQ_HANDLED;
 349 }
 350
 351 static void cpt_reset(struct cpt_device *cpt)
 352 {
 353         cpt_write_csr64(cpt->reg_base, CPTX_PF_RESET(0), 1);
 354 }
 355
 356 static void cpt_find_max_enabled_cores(struct cpt_device *cpt)
 357 {
 358         union cptx_pf_constants pf_cnsts = {0};
 359
 360         pf_cnsts.u = cpt_read_csr64(cpt->reg_base, CPTX_PF_CONSTANTS(0));
 361         cpt->max_se_cores = pf_cnsts.s.se;
 362         cpt->max_ae_cores = pf_cnsts.s.ae;
 363 }
 364
 365 static u32 cpt_check_bist_status(struct cpt_device *cpt)
 366 {
 367         union cptx_pf_bist_status bist_sts = {0};
 368
 369         bist_sts.u = cpt_read_csr64(cpt->reg_base,
 370                                     CPTX_PF_BIST_STATUS(0));
 371
 372         return bist_sts.u;
 373 }
 374
 375 static u64 cpt_check_exe_bist_status(struct cpt_device *cpt)
 376 {
 377         union cptx_pf_exe_bist_status bist_sts = {0};
 378
 379         bist_sts.u = cpt_read_csr64(cpt->reg_base,
 380                                     CPTX_PF_EXE_BIST_STATUS(0));
 381
 382         return bist_sts.u;
 383 }
 384
 385 static void cpt_disable_all_cores(struct cpt_device *cpt)
 386 {
 387         u32 grp, timeout = 100;
 388         struct device *dev = &cpt->pdev->dev;
 389
 390         /* Disengage the cores from groups */
 391         for (grp = 0; grp < CPT_MAX_CORE_GROUPS; grp++) {
 392                 cpt_write_csr64(cpt->reg_base, CPTX_PF_GX_EN(0, grp), 0);
 393                 udelay(CSR_DELAY);
 394         }
 395
 396         grp = cpt_read_csr64(cpt->reg_base, CPTX_PF_EXEC_BUSY(0));
 397         while (grp) {
 398                 dev_err(dev, "Cores still busy");
 399                 grp = cpt_read_csr64(cpt->reg_base,
 400                                      CPTX_PF_EXEC_BUSY(0));
 401                 if (timeout--)
 402                         break;
 403
 404                 udelay(CSR_DELAY);
 405         }
 406         /* Disable the cores */
 407         cpt_write_csr64(cpt->reg_base, CPTX_PF_EXE_CTL(0), 0);
 408 }
 409
 410 /**
 411  * Ensure all cores are disengaged from all groups by
 412  * calling cpt_disable_all_cores() before calling this
 413  * function.
 414  */
 415 static void cpt_unload_microcode(struct cpt_device *cpt)
 416 {
 417         u32 grp = 0, core;
 418
 419         /* Free microcode bases and reset group masks */
 420         for (grp = 0; grp < CPT_MAX_CORE_GROUPS; grp++) {
 421                 struct microcode *mcode = &cpt->mcode[grp];
 422
 423                 if (cpt->mcode[grp].code)
 424                         dma_free_coherent(&cpt->pdev->dev, mcode->code_size,
 425                                           mcode->code, mcode->phys_base);
 426                 mcode->code = NULL;
 427         }
 428         /* Clear UCODE_BASE registers for all engines */
 429         for (core = 0; core < CPT_MAX_TOTAL_CORES; core++)
 430                 cpt_write_csr64(cpt->reg_base,
 431                                 CPTX_PF_ENGX_UCODE_BASE(0, core), 0ull);
 432 }
 433
 434 static int cpt_device_init(struct cpt_device *cpt)
 435 {
 436         u64 bist;
 437         struct device *dev = &cpt->pdev->dev;
 438
 439         /* Reset the PF when probed first */
 440         cpt_reset(cpt);
 441         msleep(100);
 442
 443         /*Check BIST status*/
 444         bist = (u64)cpt_check_bist_status(cpt);
 445         if (bist) {
 446                 dev_err(dev, "RAM BIST failed with code 0x%llx", bist);
 447                 return -ENODEV;
 448         }
 449
 450         bist = cpt_check_exe_bist_status(cpt);
 451         if (bist) {
 452                 dev_err(dev, "Engine BIST failed with code 0x%llx", bist);
 453                 return -ENODEV;
 454         }
 455
 456         /*Get CLK frequency*/
 457         /*Get max enabled cores */
 458         cpt_find_max_enabled_cores(cpt);
 459         /*Disable all cores*/
 460         cpt_disable_all_cores(cpt);
 461         /*Reset device parameters*/
 462         cpt->next_mc_idx   = 0;
 463         cpt->next_group = 0;
 464         /* PF is ready */
 465         cpt->flags |= CPT_FLAG_DEVICE_READY;
 466
 467         return 0;
 468 }
 469
 470 static int cpt_register_interrupts(struct cpt_device *cpt)
 471 {
 472         int ret;
 473         struct device *dev = &cpt->pdev->dev;
 474
 475         /* Enable MSI-X */
 476         ret = pci_alloc_irq_vectors(cpt->pdev, CPT_PF_MSIX_VECTORS,
 477                         CPT_PF_MSIX_VECTORS, PCI_IRQ_MSIX);
 478         if (ret < 0) {
 479                 dev_err(&cpt->pdev->dev, "Request for #%d msix vectors failed\n",
 480                         CPT_PF_MSIX_VECTORS);
 481                 return ret;
 482         }
 483
 484         /* Register mailbox interrupt handlers */
 485         ret = request_irq(pci_irq_vector(cpt->pdev, CPT_PF_INT_VEC_E_MBOXX(0)),
 486                           cpt_mbx0_intr_handler, 0, "CPT Mbox0", cpt);
 487         if (ret)
 488                 goto fail;
 489
 490         /* Enable mailbox interrupt */
 491         cpt_enable_mbox_interrupts(cpt);
 492         return 0;
 493
 494 fail:
 495         dev_err(dev, "Request irq failed\n");
 496         pci_disable_msix(cpt->pdev);
 497         return ret;
 498 }
 499
 500 static void cpt_unregister_interrupts(struct cpt_device *cpt)
 501 {
 502         free_irq(pci_irq_vector(cpt->pdev, CPT_PF_INT_VEC_E_MBOXX(0)), cpt);
 503         pci_disable_msix(cpt->pdev);
 504 }
 505
 506 static int cpt_sriov_init(struct cpt_device *cpt, int num_vfs)
 507 {
 508         int pos = 0;
 509         int err;
 510         u16 total_vf_cnt;
 511         struct pci_dev *pdev = cpt->pdev;
 512
 513         pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_SRIOV);
 514         if (!pos) {
 515                 dev_err(&pdev->dev, "SRIOV capability is not found in PCIe config space\n");
 516                 return -ENODEV;
 517         }
 518
 519         cpt->num_vf_en = num_vfs; /* User requested VFs */
 520         pci_read_config_word(pdev, (pos + PCI_SRIOV_TOTAL_VF), &total_vf_cnt);
 521         if (total_vf_cnt < cpt->num_vf_en)
 522                 cpt->num_vf_en = total_vf_cnt;
 523
 524         if (!total_vf_cnt)
 525                 return 0;
 526
 527         /*Enabled the available VFs */
 528         err = pci_enable_sriov(pdev, cpt->num_vf_en);
 529         if (err) {
 530                 dev_err(&pdev->dev, "SRIOV enable failed, num VF is %d\n",
 531                         cpt->num_vf_en);
 532                 cpt->num_vf_en = 0;
 533                 return err;
 534         }
 535
 536         /* TODO: Optionally enable static VQ priorities feature */
 537
 538         dev_info(&pdev->dev, "SRIOV enabled, number of VF available %d\n",
 539                  cpt->num_vf_en);
 540
 541         cpt->flags |= CPT_FLAG_SRIOV_ENABLED;
 542
 543         return 0;
 544 }
 545
 546 static int cpt_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 547 {
 548         struct device *dev = &pdev->dev;
 549         struct cpt_device *cpt;
 550         int err;
 551
 552         if (num_vfs > 16 || num_vfs < 4) {
 553                 dev_warn(dev, "Invalid vf count %d, Resetting it to 4(default)\n",
 554                          num_vfs);
 555                 num_vfs = 4;
 556         }
 557
 558         cpt = devm_kzalloc(dev, sizeof(*cpt), GFP_KERNEL);
 559         if (!cpt)
 560                 return -ENOMEM;
 561
 562         pci_set_drvdata(pdev, cpt);
 563         cpt->pdev = pdev;
 564         err = pci_enable_device(pdev);
 565         if (err) {
 566                 dev_err(dev, "Failed to enable PCI device\n");
 567                 pci_set_drvdata(pdev, NULL);
 568                 return err;
 569         }
 570
 571         err = pci_request_regions(pdev, DRV_NAME);
 572         if (err) {
 573                 dev_err(dev, "PCI request regions failed 0x%x\n", err);
 574                 goto cpt_err_disable_device;
 575         }
 576
 577         err = pci_set_dma_mask(pdev, DMA_BIT_MASK(48));
 578         if (err) {
 579                 dev_err(dev, "Unable to get usable DMA configuration\n");
 580                 goto cpt_err_release_regions;
 581         }
 582
 583         err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(48));
 584         if (err) {
 585                 dev_err(dev, "Unable to get 48-bit DMA for consistent allocations\n");
 586                 goto cpt_err_release_regions;
 587         }
 588
 589         /* MAP PF's configuration registers */
 590         cpt->reg_base = pcim_iomap(pdev, 0, 0);
 591         if (!cpt->reg_base) {
 592                 dev_err(dev, "Cannot map config register space, aborting\n");
 593                 err = -ENOMEM;
 594                 goto cpt_err_release_regions;
 595         }
 596
 597         /* CPT device HW initialization */
 598         cpt_device_init(cpt);
 599
 600         /* Register interrupts */
 601         err = cpt_register_interrupts(cpt);
 602         if (err)
 603                 goto cpt_err_release_regions;
 604
 605         err = cpt_ucode_load(cpt);
 606         if (err)
 607                 goto cpt_err_unregister_interrupts;
 608
 609         /* Configure SRIOV */
 610         err = cpt_sriov_init(cpt, num_vfs);
 611         if (err)
 612                 goto cpt_err_unregister_interrupts;
 613
 614         return 0;
 615
 616 cpt_err_unregister_interrupts:
 617         cpt_unregister_interrupts(cpt);
 618 cpt_err_release_regions:
 619         pci_release_regions(pdev);
 620 cpt_err_disable_device:
 621         pci_disable_device(pdev);
 622         pci_set_drvdata(pdev, NULL);
 623         return err;
 624 }
 625
 626 static void cpt_remove(struct pci_dev *pdev)
 627 {
 628         struct cpt_device *cpt = pci_get_drvdata(pdev);
 629
 630         /* Disengage SE and AE cores from all groups*/
 631         cpt_disable_all_cores(cpt);
 632         /* Unload microcodes */
 633         cpt_unload_microcode(cpt);
 634         cpt_unregister_interrupts(cpt);
 635         pci_disable_sriov(pdev);
 636         pci_release_regions(pdev);
 637         pci_disable_device(pdev);
 638         pci_set_drvdata(pdev, NULL);
 639 }
 640
 641 static void cpt_shutdown(struct pci_dev *pdev)
 642 {
 643         struct cpt_device *cpt = pci_get_drvdata(pdev);
 644
 645         if (!cpt)
 646                 return;
 647
 648         dev_info(&pdev->dev, "Shutdown device %x:%x.\n",
 649                  (u32)pdev->vendor, (u32)pdev->device);
 650
 651         cpt_unregister_interrupts(cpt);
 652         pci_release_regions(pdev);
 653         pci_disable_device(pdev);
 654         pci_set_drvdata(pdev, NULL);
 655 }
 656
 657 /* Supported devices */
 658 static const struct pci_device_id cpt_id_table[] = {
 659         { PCI_DEVICE(PCI_VENDOR_ID_CAVIUM, CPT_81XX_PCI_PF_DEVICE_ID) },
 660         { 0, }  /* end of table */
 661 };
 662
 663 static struct pci_driver cpt_pci_driver = {
 664         .name = DRV_NAME,
 665         .id_table = cpt_id_table,
 666         .probe = cpt_probe,
 667         .remove = cpt_remove,
 668         .shutdown = cpt_shutdown,
 669 };
 670
 671 module_pci_driver(cpt_pci_driver);
 672
 673 MODULE_AUTHOR("George Cherian <george.cherian@cavium.com>");
 674 MODULE_DESCRIPTION("Cavium Thunder CPT Physical Function Driver");
 675 MODULE_LICENSE("GPL v2");
 676 MODULE_VERSION(DRV_VERSION);
 677 MODULE_DEVICE_TABLE(pci, cpt_id_table);