Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright (C) 2021 Broadcom. All Rights Reserved. The term
0004  * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
0005  */
0006 
0007 #include "efct_driver.h"
0008 
0009 #include "efct_hw.h"
0010 #include "efct_unsol.h"
0011 #include "efct_scsi.h"
0012 
0013 LIST_HEAD(efct_devices);
0014 
0015 static int logmask;
0016 module_param(logmask, int, 0444);
0017 MODULE_PARM_DESC(logmask, "logging bitmask (default 0)");
0018 
0019 static struct libefc_function_template efct_libefc_templ = {
0020     .issue_mbox_rqst = efct_issue_mbox_rqst,
0021     .send_els = efct_els_hw_srrs_send,
0022     .send_bls = efct_efc_bls_send,
0023 
0024     .new_nport = efct_scsi_tgt_new_nport,
0025     .del_nport = efct_scsi_tgt_del_nport,
0026     .scsi_new_node = efct_scsi_new_initiator,
0027     .scsi_del_node = efct_scsi_del_initiator,
0028     .hw_seq_free = efct_efc_hw_sequence_free,
0029 };
0030 
0031 static int
0032 efct_device_init(void)
0033 {
0034     int rc;
0035 
0036     /* driver-wide init for target-server */
0037     rc = efct_scsi_tgt_driver_init();
0038     if (rc) {
0039         pr_err("efct_scsi_tgt_init failed rc=%d\n", rc);
0040         return rc;
0041     }
0042 
0043     rc = efct_scsi_reg_fc_transport();
0044     if (rc) {
0045         pr_err("failed to register to FC host\n");
0046         return rc;
0047     }
0048 
0049     return 0;
0050 }
0051 
0052 static void
0053 efct_device_shutdown(void)
0054 {
0055     efct_scsi_release_fc_transport();
0056 
0057     efct_scsi_tgt_driver_exit();
0058 }
0059 
0060 static void *
0061 efct_device_alloc(u32 nid)
0062 {
0063     struct efct *efct = NULL;
0064 
0065     efct = kzalloc_node(sizeof(*efct), GFP_KERNEL, nid);
0066     if (!efct)
0067         return efct;
0068 
0069     INIT_LIST_HEAD(&efct->list_entry);
0070     list_add_tail(&efct->list_entry, &efct_devices);
0071 
0072     return efct;
0073 }
0074 
0075 static void
0076 efct_teardown_msix(struct efct *efct)
0077 {
0078     u32 i;
0079 
0080     for (i = 0; i < efct->n_msix_vec; i++) {
0081         free_irq(pci_irq_vector(efct->pci, i),
0082              &efct->intr_context[i]);
0083     }
0084 
0085     pci_free_irq_vectors(efct->pci);
0086 }
0087 
0088 static int
0089 efct_efclib_config(struct efct *efct, struct libefc_function_template *tt)
0090 {
0091     struct efc *efc;
0092     struct sli4 *sli;
0093     int rc = 0;
0094 
0095     efc = kzalloc(sizeof(*efc), GFP_KERNEL);
0096     if (!efc)
0097         return -ENOMEM;
0098 
0099     efct->efcport = efc;
0100 
0101     memcpy(&efc->tt, tt, sizeof(*tt));
0102     efc->base = efct;
0103     efc->pci = efct->pci;
0104 
0105     efc->def_wwnn = efct_get_wwnn(&efct->hw);
0106     efc->def_wwpn = efct_get_wwpn(&efct->hw);
0107     efc->enable_tgt = 1;
0108     efc->log_level = EFC_LOG_LIB;
0109 
0110     sli = &efct->hw.sli;
0111     efc->max_xfer_size = sli->sge_supported_length *
0112                  sli_get_max_sgl(&efct->hw.sli);
0113     efc->sli = sli;
0114     efc->fcfi = efct->hw.fcf_indicator;
0115 
0116     rc = efcport_init(efc);
0117     if (rc)
0118         efc_log_err(efc, "efcport_init failed\n");
0119 
0120     return rc;
0121 }
0122 
0123 static int efct_request_firmware_update(struct efct *efct);
0124 
0125 static const char*
0126 efct_pci_model(u16 device)
0127 {
0128     switch (device) {
0129     case EFCT_DEVICE_LANCER_G6: return "LPE31004";
0130     case EFCT_DEVICE_LANCER_G7: return "LPE36000";
0131     default:            return "unknown";
0132     }
0133 }
0134 
0135 static int
0136 efct_device_attach(struct efct *efct)
0137 {
0138     u32 rc = 0, i = 0;
0139 
0140     if (efct->attached) {
0141         efc_log_err(efct, "Device is already attached\n");
0142         return -EIO;
0143     }
0144 
0145     snprintf(efct->name, sizeof(efct->name), "[%s%d] ", "fc",
0146          efct->instance_index);
0147 
0148     efct->logmask = logmask;
0149     efct->filter_def = EFCT_DEFAULT_FILTER;
0150     efct->max_isr_time_msec = EFCT_OS_MAX_ISR_TIME_MSEC;
0151 
0152     efct->model = efct_pci_model(efct->pci->device);
0153 
0154     efct->efct_req_fw_upgrade = true;
0155 
0156     /* Allocate transport object and bring online */
0157     efct->xport = efct_xport_alloc(efct);
0158     if (!efct->xport) {
0159         efc_log_err(efct, "failed to allocate transport object\n");
0160         rc = -ENOMEM;
0161         goto out;
0162     }
0163 
0164     rc = efct_xport_attach(efct->xport);
0165     if (rc) {
0166         efc_log_err(efct, "failed to attach transport object\n");
0167         goto xport_out;
0168     }
0169 
0170     rc = efct_xport_initialize(efct->xport);
0171     if (rc) {
0172         efc_log_err(efct, "failed to initialize transport object\n");
0173         goto xport_out;
0174     }
0175 
0176     rc = efct_efclib_config(efct, &efct_libefc_templ);
0177     if (rc) {
0178         efc_log_err(efct, "failed to init efclib\n");
0179         goto efclib_out;
0180     }
0181 
0182     for (i = 0; i < efct->n_msix_vec; i++) {
0183         efc_log_debug(efct, "irq %d enabled\n", i);
0184         enable_irq(pci_irq_vector(efct->pci, i));
0185     }
0186 
0187     efct->attached = true;
0188 
0189     if (efct->efct_req_fw_upgrade)
0190         efct_request_firmware_update(efct);
0191 
0192     return rc;
0193 
0194 efclib_out:
0195     efct_xport_detach(efct->xport);
0196 xport_out:
0197     efct_xport_free(efct->xport);
0198     efct->xport = NULL;
0199 out:
0200     return rc;
0201 }
0202 
0203 static int
0204 efct_device_detach(struct efct *efct)
0205 {
0206     int i;
0207 
0208     if (!efct || !efct->attached) {
0209         pr_err("Device is not attached\n");
0210         return -EIO;
0211     }
0212 
0213     if (efct_xport_control(efct->xport, EFCT_XPORT_SHUTDOWN))
0214         efc_log_err(efct, "Transport Shutdown timed out\n");
0215 
0216     for (i = 0; i < efct->n_msix_vec; i++)
0217         disable_irq(pci_irq_vector(efct->pci, i));
0218 
0219     efct_xport_detach(efct->xport);
0220 
0221     efct_xport_free(efct->xport);
0222     efct->xport = NULL;
0223 
0224     efcport_destroy(efct->efcport);
0225     kfree(efct->efcport);
0226 
0227     efct->attached = false;
0228 
0229     return 0;
0230 }
0231 
0232 static void
0233 efct_fw_write_cb(int status, u32 actual_write_length,
0234          u32 change_status, void *arg)
0235 {
0236     struct efct_fw_write_result *result = arg;
0237 
0238     result->status = status;
0239     result->actual_xfer = actual_write_length;
0240     result->change_status = change_status;
0241 
0242     complete(&result->done);
0243 }
0244 
0245 static int
0246 efct_firmware_write(struct efct *efct, const u8 *buf, size_t buf_len,
0247             u8 *change_status)
0248 {
0249     int rc = 0;
0250     u32 bytes_left;
0251     u32 xfer_size;
0252     u32 offset;
0253     struct efc_dma dma;
0254     int last = 0;
0255     struct efct_fw_write_result result;
0256 
0257     init_completion(&result.done);
0258 
0259     bytes_left = buf_len;
0260     offset = 0;
0261 
0262     dma.size = FW_WRITE_BUFSIZE;
0263     dma.virt = dma_alloc_coherent(&efct->pci->dev,
0264                       dma.size, &dma.phys, GFP_KERNEL);
0265     if (!dma.virt)
0266         return -ENOMEM;
0267 
0268     while (bytes_left > 0) {
0269         if (bytes_left > FW_WRITE_BUFSIZE)
0270             xfer_size = FW_WRITE_BUFSIZE;
0271         else
0272             xfer_size = bytes_left;
0273 
0274         memcpy(dma.virt, buf + offset, xfer_size);
0275 
0276         if (bytes_left == xfer_size)
0277             last = 1;
0278 
0279         efct_hw_firmware_write(&efct->hw, &dma, xfer_size, offset,
0280                        last, efct_fw_write_cb, &result);
0281 
0282         if (wait_for_completion_interruptible(&result.done) != 0) {
0283             rc = -ENXIO;
0284             break;
0285         }
0286 
0287         if (result.actual_xfer == 0 || result.status != 0) {
0288             rc = -EFAULT;
0289             break;
0290         }
0291 
0292         if (last)
0293             *change_status = result.change_status;
0294 
0295         bytes_left -= result.actual_xfer;
0296         offset += result.actual_xfer;
0297     }
0298 
0299     dma_free_coherent(&efct->pci->dev, dma.size, dma.virt, dma.phys);
0300     return rc;
0301 }
0302 
0303 static int
0304 efct_fw_reset(struct efct *efct)
0305 {
0306     /*
0307      * Firmware reset to activate the new firmware.
0308      * Function 0 will update and load the new firmware
0309      * during attach.
0310      */
0311     if (timer_pending(&efct->xport->stats_timer))
0312         del_timer(&efct->xport->stats_timer);
0313 
0314     if (efct_hw_reset(&efct->hw, EFCT_HW_RESET_FIRMWARE)) {
0315         efc_log_info(efct, "failed to reset firmware\n");
0316         return -EIO;
0317     }
0318 
0319     efc_log_info(efct, "successfully reset firmware.Now resetting port\n");
0320 
0321     efct_device_detach(efct);
0322     return efct_device_attach(efct);
0323 }
0324 
0325 static int
0326 efct_request_firmware_update(struct efct *efct)
0327 {
0328     int rc = 0;
0329     u8 file_name[256], fw_change_status = 0;
0330     const struct firmware *fw;
0331     struct efct_hw_grp_hdr *fw_image;
0332 
0333     snprintf(file_name, 256, "%s.grp", efct->model);
0334 
0335     rc = request_firmware(&fw, file_name, &efct->pci->dev);
0336     if (rc) {
0337         efc_log_debug(efct, "Firmware file(%s) not found.\n", file_name);
0338         return rc;
0339     }
0340 
0341     fw_image = (struct efct_hw_grp_hdr *)fw->data;
0342 
0343     if (!strncmp(efct->hw.sli.fw_name[0], fw_image->revision,
0344              strnlen(fw_image->revision, 16))) {
0345         efc_log_debug(efct,
0346                   "Skip update. Firmware is already up to date.\n");
0347         goto exit;
0348     }
0349 
0350     efc_log_info(efct, "Firmware update is initiated. %s -> %s\n",
0351              efct->hw.sli.fw_name[0], fw_image->revision);
0352 
0353     rc = efct_firmware_write(efct, fw->data, fw->size, &fw_change_status);
0354     if (rc) {
0355         efc_log_err(efct, "Firmware update failed. rc = %d\n", rc);
0356         goto exit;
0357     }
0358 
0359     efc_log_info(efct, "Firmware updated successfully\n");
0360     switch (fw_change_status) {
0361     case 0x00:
0362         efc_log_info(efct, "New firmware is active.\n");
0363         break;
0364     case 0x01:
0365         efc_log_info(efct,
0366             "System reboot needed to activate the new firmware\n");
0367         break;
0368     case 0x02:
0369     case 0x03:
0370         efc_log_info(efct,
0371                  "firmware reset to activate the new firmware\n");
0372         efct_fw_reset(efct);
0373         break;
0374     default:
0375         efc_log_info(efct, "Unexpected value change_status:%d\n",
0376                  fw_change_status);
0377         break;
0378     }
0379 
0380 exit:
0381     release_firmware(fw);
0382 
0383     return rc;
0384 }
0385 
0386 static void
0387 efct_device_free(struct efct *efct)
0388 {
0389     if (efct) {
0390         list_del(&efct->list_entry);
0391         kfree(efct);
0392     }
0393 }
0394 
0395 static int
0396 efct_device_interrupts_required(struct efct *efct)
0397 {
0398     int rc;
0399 
0400     rc = efct_hw_setup(&efct->hw, efct, efct->pci);
0401     if (rc < 0)
0402         return rc;
0403 
0404     return efct->hw.config.n_eq;
0405 }
0406 
0407 static irqreturn_t
0408 efct_intr_thread(int irq, void *handle)
0409 {
0410     struct efct_intr_context *intr_ctx = handle;
0411     struct efct *efct = intr_ctx->efct;
0412 
0413     efct_hw_process(&efct->hw, intr_ctx->index, efct->max_isr_time_msec);
0414     return IRQ_HANDLED;
0415 }
0416 
0417 static irqreturn_t
0418 efct_intr_msix(int irq, void *handle)
0419 {
0420     return IRQ_WAKE_THREAD;
0421 }
0422 
0423 static int
0424 efct_setup_msix(struct efct *efct, u32 num_intrs)
0425 {
0426     int rc = 0, i;
0427 
0428     if (!pci_find_capability(efct->pci, PCI_CAP_ID_MSIX)) {
0429         dev_err(&efct->pci->dev,
0430             "%s : MSI-X not available\n", __func__);
0431         return -EIO;
0432     }
0433 
0434     efct->n_msix_vec = num_intrs;
0435 
0436     rc = pci_alloc_irq_vectors(efct->pci, num_intrs, num_intrs,
0437                    PCI_IRQ_MSIX | PCI_IRQ_AFFINITY);
0438 
0439     if (rc < 0) {
0440         dev_err(&efct->pci->dev, "Failed to alloc irq : %d\n", rc);
0441         return rc;
0442     }
0443 
0444     for (i = 0; i < num_intrs; i++) {
0445         struct efct_intr_context *intr_ctx = NULL;
0446 
0447         intr_ctx = &efct->intr_context[i];
0448         intr_ctx->efct = efct;
0449         intr_ctx->index = i;
0450 
0451         rc = request_threaded_irq(pci_irq_vector(efct->pci, i),
0452                       efct_intr_msix, efct_intr_thread, 0,
0453                       EFCT_DRIVER_NAME, intr_ctx);
0454         if (rc) {
0455             dev_err(&efct->pci->dev,
0456                 "Failed to register %d vector: %d\n", i, rc);
0457             goto out;
0458         }
0459     }
0460 
0461     return rc;
0462 
0463 out:
0464     while (--i >= 0)
0465         free_irq(pci_irq_vector(efct->pci, i),
0466              &efct->intr_context[i]);
0467 
0468     pci_free_irq_vectors(efct->pci);
0469     return rc;
0470 }
0471 
0472 static struct pci_device_id efct_pci_table[] = {
0473     {PCI_DEVICE(EFCT_VENDOR_ID, EFCT_DEVICE_LANCER_G6), 0},
0474     {PCI_DEVICE(EFCT_VENDOR_ID, EFCT_DEVICE_LANCER_G7), 0},
0475     {}  /* terminate list */
0476 };
0477 
0478 static int
0479 efct_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
0480 {
0481     struct efct *efct = NULL;
0482     int rc;
0483     u32 i, r;
0484     int num_interrupts = 0;
0485     int nid;
0486 
0487     dev_info(&pdev->dev, "%s\n", EFCT_DRIVER_NAME);
0488 
0489     rc = pci_enable_device_mem(pdev);
0490     if (rc)
0491         return rc;
0492 
0493     pci_set_master(pdev);
0494 
0495     rc = pci_set_mwi(pdev);
0496     if (rc) {
0497         dev_info(&pdev->dev, "pci_set_mwi returned %d\n", rc);
0498         goto mwi_out;
0499     }
0500 
0501     rc = pci_request_regions(pdev, EFCT_DRIVER_NAME);
0502     if (rc) {
0503         dev_err(&pdev->dev, "pci_request_regions failed %d\n", rc);
0504         goto req_regions_out;
0505     }
0506 
0507     /* Fetch the Numa node id for this device */
0508     nid = dev_to_node(&pdev->dev);
0509     if (nid < 0) {
0510         dev_err(&pdev->dev, "Warning Numa node ID is %d\n", nid);
0511         nid = 0;
0512     }
0513 
0514     /* Allocate efct */
0515     efct = efct_device_alloc(nid);
0516     if (!efct) {
0517         dev_err(&pdev->dev, "Failed to allocate efct\n");
0518         rc = -ENOMEM;
0519         goto alloc_out;
0520     }
0521 
0522     efct->pci = pdev;
0523     efct->numa_node = nid;
0524 
0525     /* Map all memory BARs */
0526     for (i = 0, r = 0; i < EFCT_PCI_MAX_REGS; i++) {
0527         if (pci_resource_flags(pdev, i) & IORESOURCE_MEM) {
0528             efct->reg[r] = ioremap(pci_resource_start(pdev, i),
0529                            pci_resource_len(pdev, i));
0530             r++;
0531         }
0532 
0533         /*
0534          * If the 64-bit attribute is set, both this BAR and the
0535          * next form the complete address. Skip processing the
0536          * next BAR.
0537          */
0538         if (pci_resource_flags(pdev, i) & IORESOURCE_MEM_64)
0539             i++;
0540     }
0541 
0542     pci_set_drvdata(pdev, efct);
0543 
0544     rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
0545     if (rc) {
0546         dev_err(&pdev->dev, "setting DMA_BIT_MASK failed\n");
0547         goto dma_mask_out;
0548     }
0549 
0550     num_interrupts = efct_device_interrupts_required(efct);
0551     if (num_interrupts < 0) {
0552         efc_log_err(efct, "efct_device_interrupts_required failed\n");
0553         rc = -1;
0554         goto dma_mask_out;
0555     }
0556 
0557     /*
0558      * Initialize MSIX interrupts, note,
0559      * efct_setup_msix() enables the interrupt
0560      */
0561     rc = efct_setup_msix(efct, num_interrupts);
0562     if (rc) {
0563         dev_err(&pdev->dev, "Can't setup msix\n");
0564         goto dma_mask_out;
0565     }
0566     /* Disable interrupt for now */
0567     for (i = 0; i < efct->n_msix_vec; i++) {
0568         efc_log_debug(efct, "irq %d disabled\n", i);
0569         disable_irq(pci_irq_vector(efct->pci, i));
0570     }
0571 
0572     rc = efct_device_attach(efct);
0573     if (rc)
0574         goto attach_out;
0575 
0576     return 0;
0577 
0578 attach_out:
0579     efct_teardown_msix(efct);
0580 dma_mask_out:
0581     pci_set_drvdata(pdev, NULL);
0582 
0583     for (i = 0; i < EFCT_PCI_MAX_REGS; i++) {
0584         if (efct->reg[i])
0585             iounmap(efct->reg[i]);
0586     }
0587     efct_device_free(efct);
0588 alloc_out:
0589     pci_release_regions(pdev);
0590 req_regions_out:
0591     pci_clear_mwi(pdev);
0592 mwi_out:
0593     pci_disable_device(pdev);
0594     return rc;
0595 }
0596 
0597 static void
0598 efct_pci_remove(struct pci_dev *pdev)
0599 {
0600     struct efct *efct = pci_get_drvdata(pdev);
0601     u32 i;
0602 
0603     if (!efct)
0604         return;
0605 
0606     efct_device_detach(efct);
0607 
0608     efct_teardown_msix(efct);
0609 
0610     for (i = 0; i < EFCT_PCI_MAX_REGS; i++) {
0611         if (efct->reg[i])
0612             iounmap(efct->reg[i]);
0613     }
0614 
0615     pci_set_drvdata(pdev, NULL);
0616 
0617     efct_device_free(efct);
0618 
0619     pci_release_regions(pdev);
0620 
0621     pci_disable_device(pdev);
0622 }
0623 
0624 static void
0625 efct_device_prep_for_reset(struct efct *efct, struct pci_dev *pdev)
0626 {
0627     if (efct) {
0628         efc_log_debug(efct,
0629                   "PCI channel disable preparing for reset\n");
0630         efct_device_detach(efct);
0631         /* Disable interrupt and pci device */
0632         efct_teardown_msix(efct);
0633     }
0634     pci_disable_device(pdev);
0635 }
0636 
0637 static void
0638 efct_device_prep_for_recover(struct efct *efct)
0639 {
0640     if (efct) {
0641         efc_log_debug(efct, "PCI channel preparing for recovery\n");
0642         efct_hw_io_abort_all(&efct->hw);
0643     }
0644 }
0645 
0646 /**
0647  * efct_pci_io_error_detected - method for handling PCI I/O error
0648  * @pdev: pointer to PCI device.
0649  * @state: the current PCI connection state.
0650  *
0651  * This routine is registered to the PCI subsystem for error handling. This
0652  * function is called by the PCI subsystem after a PCI bus error affecting
0653  * this device has been detected. When this routine is invoked, it dispatches
0654  * device error detected handling routine, which will perform the proper
0655  * error detected operation.
0656  *
0657  * Return codes
0658  * PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
0659  * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
0660  */
0661 static pci_ers_result_t
0662 efct_pci_io_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
0663 {
0664     struct efct *efct = pci_get_drvdata(pdev);
0665     pci_ers_result_t rc;
0666 
0667     switch (state) {
0668     case pci_channel_io_normal:
0669         efct_device_prep_for_recover(efct);
0670         rc = PCI_ERS_RESULT_CAN_RECOVER;
0671         break;
0672     case pci_channel_io_frozen:
0673         efct_device_prep_for_reset(efct, pdev);
0674         rc = PCI_ERS_RESULT_NEED_RESET;
0675         break;
0676     case pci_channel_io_perm_failure:
0677         efct_device_detach(efct);
0678         rc = PCI_ERS_RESULT_DISCONNECT;
0679         break;
0680     default:
0681         efc_log_debug(efct, "Unknown PCI error state:0x%x\n", state);
0682         efct_device_prep_for_reset(efct, pdev);
0683         rc = PCI_ERS_RESULT_NEED_RESET;
0684         break;
0685     }
0686 
0687     return rc;
0688 }
0689 
0690 static pci_ers_result_t
0691 efct_pci_io_slot_reset(struct pci_dev *pdev)
0692 {
0693     int rc;
0694     struct efct *efct = pci_get_drvdata(pdev);
0695 
0696     rc = pci_enable_device_mem(pdev);
0697     if (rc) {
0698         efc_log_err(efct, "failed to enable PCI device after reset\n");
0699         return PCI_ERS_RESULT_DISCONNECT;
0700     }
0701 
0702     /*
0703      * As the new kernel behavior of pci_restore_state() API call clears
0704      * device saved_state flag, need to save the restored state again.
0705      */
0706 
0707     pci_save_state(pdev);
0708 
0709     pci_set_master(pdev);
0710 
0711     rc = efct_setup_msix(efct, efct->n_msix_vec);
0712     if (rc)
0713         efc_log_err(efct, "rc %d returned, IRQ allocation failed\n",
0714                 rc);
0715 
0716     /* Perform device reset */
0717     efct_device_detach(efct);
0718     /* Bring device to online*/
0719     efct_device_attach(efct);
0720 
0721     return PCI_ERS_RESULT_RECOVERED;
0722 }
0723 
0724 static void
0725 efct_pci_io_resume(struct pci_dev *pdev)
0726 {
0727     struct efct *efct = pci_get_drvdata(pdev);
0728 
0729     /* Perform device reset */
0730     efct_device_detach(efct);
0731     /* Bring device to online*/
0732     efct_device_attach(efct);
0733 }
0734 
0735 MODULE_DEVICE_TABLE(pci, efct_pci_table);
0736 
0737 static struct pci_error_handlers efct_pci_err_handler = {
0738     .error_detected = efct_pci_io_error_detected,
0739     .slot_reset = efct_pci_io_slot_reset,
0740     .resume = efct_pci_io_resume,
0741 };
0742 
0743 static struct pci_driver efct_pci_driver = {
0744     .name       = EFCT_DRIVER_NAME,
0745     .id_table   = efct_pci_table,
0746     .probe      = efct_pci_probe,
0747     .remove     = efct_pci_remove,
0748     .err_handler    = &efct_pci_err_handler,
0749 };
0750 
0751 static
0752 int __init efct_init(void)
0753 {
0754     int rc;
0755 
0756     rc = efct_device_init();
0757     if (rc) {
0758         pr_err("efct_device_init failed rc=%d\n", rc);
0759         return rc;
0760     }
0761 
0762     rc = pci_register_driver(&efct_pci_driver);
0763     if (rc) {
0764         pr_err("pci_register_driver failed rc=%d\n", rc);
0765         efct_device_shutdown();
0766     }
0767 
0768     return rc;
0769 }
0770 
0771 static void __exit efct_exit(void)
0772 {
0773     pci_unregister_driver(&efct_pci_driver);
0774     efct_device_shutdown();
0775 }
0776 
0777 module_init(efct_init);
0778 module_exit(efct_exit);
0779 MODULE_VERSION(EFCT_DRIVER_VERSION);
0780 MODULE_LICENSE("GPL");
0781 MODULE_AUTHOR("Broadcom");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!