Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Driver for Broadcom MPI3 Storage Controllers
0004  *
0005  * Copyright (C) 2017-2022 Broadcom Inc.
0006  *  (mailto: mpi3mr-linuxdrv.pdl@broadcom.com)
0007  *
0008  */
0009 
0010 #include "mpi3mr.h"
0011 #include <linux/bsg-lib.h>
0012 #include <uapi/scsi/scsi_bsg_mpi3mr.h>
0013 
0014 /**
0015  * mpi3mr_bsg_pel_abort - sends PEL abort request
0016  * @mrioc: Adapter instance reference
0017  *
0018  * This function sends PEL abort request to the firmware through
0019  * admin request queue.
0020  *
0021  * Return: 0 on success, -1 on failure
0022  */
0023 static int mpi3mr_bsg_pel_abort(struct mpi3mr_ioc *mrioc)
0024 {
0025     struct mpi3_pel_req_action_abort pel_abort_req;
0026     struct mpi3_pel_reply *pel_reply;
0027     int retval = 0;
0028     u16 pe_log_status;
0029 
0030     if (mrioc->reset_in_progress) {
0031         dprint_bsg_err(mrioc, "%s: reset in progress\n", __func__);
0032         return -1;
0033     }
0034     if (mrioc->stop_bsgs) {
0035         dprint_bsg_err(mrioc, "%s: bsgs are blocked\n", __func__);
0036         return -1;
0037     }
0038 
0039     memset(&pel_abort_req, 0, sizeof(pel_abort_req));
0040     mutex_lock(&mrioc->pel_abort_cmd.mutex);
0041     if (mrioc->pel_abort_cmd.state & MPI3MR_CMD_PENDING) {
0042         dprint_bsg_err(mrioc, "%s: command is in use\n", __func__);
0043         mutex_unlock(&mrioc->pel_abort_cmd.mutex);
0044         return -1;
0045     }
0046     mrioc->pel_abort_cmd.state = MPI3MR_CMD_PENDING;
0047     mrioc->pel_abort_cmd.is_waiting = 1;
0048     mrioc->pel_abort_cmd.callback = NULL;
0049     pel_abort_req.host_tag = cpu_to_le16(MPI3MR_HOSTTAG_PEL_ABORT);
0050     pel_abort_req.function = MPI3_FUNCTION_PERSISTENT_EVENT_LOG;
0051     pel_abort_req.action = MPI3_PEL_ACTION_ABORT;
0052     pel_abort_req.abort_host_tag = cpu_to_le16(MPI3MR_HOSTTAG_PEL_WAIT);
0053 
0054     mrioc->pel_abort_requested = 1;
0055     init_completion(&mrioc->pel_abort_cmd.done);
0056     retval = mpi3mr_admin_request_post(mrioc, &pel_abort_req,
0057         sizeof(pel_abort_req), 0);
0058     if (retval) {
0059         retval = -1;
0060         dprint_bsg_err(mrioc, "%s: admin request post failed\n",
0061             __func__);
0062         mrioc->pel_abort_requested = 0;
0063         goto out_unlock;
0064     }
0065 
0066     wait_for_completion_timeout(&mrioc->pel_abort_cmd.done,
0067         (MPI3MR_INTADMCMD_TIMEOUT * HZ));
0068     if (!(mrioc->pel_abort_cmd.state & MPI3MR_CMD_COMPLETE)) {
0069         mrioc->pel_abort_cmd.is_waiting = 0;
0070         dprint_bsg_err(mrioc, "%s: command timedout\n", __func__);
0071         if (!(mrioc->pel_abort_cmd.state & MPI3MR_CMD_RESET))
0072             mpi3mr_soft_reset_handler(mrioc,
0073                 MPI3MR_RESET_FROM_PELABORT_TIMEOUT, 1);
0074         retval = -1;
0075         goto out_unlock;
0076     }
0077     if ((mrioc->pel_abort_cmd.ioc_status & MPI3_IOCSTATUS_STATUS_MASK)
0078          != MPI3_IOCSTATUS_SUCCESS) {
0079         dprint_bsg_err(mrioc,
0080             "%s: command failed, ioc_status(0x%04x) log_info(0x%08x)\n",
0081             __func__, (mrioc->pel_abort_cmd.ioc_status &
0082             MPI3_IOCSTATUS_STATUS_MASK),
0083             mrioc->pel_abort_cmd.ioc_loginfo);
0084         retval = -1;
0085         goto out_unlock;
0086     }
0087     if (mrioc->pel_abort_cmd.state & MPI3MR_CMD_REPLY_VALID) {
0088         pel_reply = (struct mpi3_pel_reply *)mrioc->pel_abort_cmd.reply;
0089         pe_log_status = le16_to_cpu(pel_reply->pe_log_status);
0090         if (pe_log_status != MPI3_PEL_STATUS_SUCCESS) {
0091             dprint_bsg_err(mrioc,
0092                 "%s: command failed, pel_status(0x%04x)\n",
0093                 __func__, pe_log_status);
0094             retval = -1;
0095         }
0096     }
0097 
0098 out_unlock:
0099     mrioc->pel_abort_cmd.state = MPI3MR_CMD_NOTUSED;
0100     mutex_unlock(&mrioc->pel_abort_cmd.mutex);
0101     return retval;
0102 }
0103 /**
0104  * mpi3mr_bsg_verify_adapter - verify adapter number is valid
0105  * @ioc_number: Adapter number
0106  *
0107  * This function returns the adapter instance pointer of given
0108  * adapter number. If adapter number does not match with the
0109  * driver's adapter list, driver returns NULL.
0110  *
0111  * Return: adapter instance reference
0112  */
0113 static struct mpi3mr_ioc *mpi3mr_bsg_verify_adapter(int ioc_number)
0114 {
0115     struct mpi3mr_ioc *mrioc = NULL;
0116 
0117     spin_lock(&mrioc_list_lock);
0118     list_for_each_entry(mrioc, &mrioc_list, list) {
0119         if (mrioc->id == ioc_number) {
0120             spin_unlock(&mrioc_list_lock);
0121             return mrioc;
0122         }
0123     }
0124     spin_unlock(&mrioc_list_lock);
0125     return NULL;
0126 }
0127 
0128 /**
0129  * mpi3mr_enable_logdata - Handler for log data enable
0130  * @mrioc: Adapter instance reference
0131  * @job: BSG job reference
0132  *
0133  * This function enables log data caching in the driver if not
0134  * already enabled and return the maximum number of log data
0135  * entries that can be cached in the driver.
0136  *
0137  * Return: 0 on success and proper error codes on failure
0138  */
0139 static long mpi3mr_enable_logdata(struct mpi3mr_ioc *mrioc,
0140     struct bsg_job *job)
0141 {
0142     struct mpi3mr_logdata_enable logdata_enable;
0143 
0144     if (!mrioc->logdata_buf) {
0145         mrioc->logdata_entry_sz =
0146             (mrioc->reply_sz - (sizeof(struct mpi3_event_notification_reply) - 4))
0147             + MPI3MR_BSG_LOGDATA_ENTRY_HEADER_SZ;
0148         mrioc->logdata_buf_idx = 0;
0149         mrioc->logdata_buf = kcalloc(MPI3MR_BSG_LOGDATA_MAX_ENTRIES,
0150             mrioc->logdata_entry_sz, GFP_KERNEL);
0151 
0152         if (!mrioc->logdata_buf)
0153             return -ENOMEM;
0154     }
0155 
0156     memset(&logdata_enable, 0, sizeof(logdata_enable));
0157     logdata_enable.max_entries =
0158         MPI3MR_BSG_LOGDATA_MAX_ENTRIES;
0159     if (job->request_payload.payload_len >= sizeof(logdata_enable)) {
0160         sg_copy_from_buffer(job->request_payload.sg_list,
0161                     job->request_payload.sg_cnt,
0162                     &logdata_enable, sizeof(logdata_enable));
0163         return 0;
0164     }
0165 
0166     return -EINVAL;
0167 }
0168 /**
0169  * mpi3mr_get_logdata - Handler for get log data
0170  * @mrioc: Adapter instance reference
0171  * @job: BSG job pointer
0172  * This function copies the log data entries to the user buffer
0173  * when log caching is enabled in the driver.
0174  *
0175  * Return: 0 on success and proper error codes on failure
0176  */
0177 static long mpi3mr_get_logdata(struct mpi3mr_ioc *mrioc,
0178     struct bsg_job *job)
0179 {
0180     u16 num_entries, sz, entry_sz = mrioc->logdata_entry_sz;
0181 
0182     if ((!mrioc->logdata_buf) || (job->request_payload.payload_len < entry_sz))
0183         return -EINVAL;
0184 
0185     num_entries = job->request_payload.payload_len / entry_sz;
0186     if (num_entries > MPI3MR_BSG_LOGDATA_MAX_ENTRIES)
0187         num_entries = MPI3MR_BSG_LOGDATA_MAX_ENTRIES;
0188     sz = num_entries * entry_sz;
0189 
0190     if (job->request_payload.payload_len >= sz) {
0191         sg_copy_from_buffer(job->request_payload.sg_list,
0192                     job->request_payload.sg_cnt,
0193                     mrioc->logdata_buf, sz);
0194         return 0;
0195     }
0196     return -EINVAL;
0197 }
0198 
0199 /**
0200  * mpi3mr_bsg_pel_enable - Handler for PEL enable driver
0201  * @mrioc: Adapter instance reference
0202  * @job: BSG job pointer
0203  *
0204  * This function is the handler for PEL enable driver.
0205  * Validates the application given class and locale and if
0206  * requires aborts the existing PEL wait request and/or issues
0207  * new PEL wait request to the firmware and returns.
0208  *
0209  * Return: 0 on success and proper error codes on failure.
0210  */
0211 static long mpi3mr_bsg_pel_enable(struct mpi3mr_ioc *mrioc,
0212                   struct bsg_job *job)
0213 {
0214     long rval = -EINVAL;
0215     struct mpi3mr_bsg_out_pel_enable pel_enable;
0216     u8 issue_pel_wait;
0217     u8 tmp_class;
0218     u16 tmp_locale;
0219 
0220     if (job->request_payload.payload_len != sizeof(pel_enable)) {
0221         dprint_bsg_err(mrioc, "%s: invalid size argument\n",
0222             __func__);
0223         return rval;
0224     }
0225 
0226     sg_copy_to_buffer(job->request_payload.sg_list,
0227               job->request_payload.sg_cnt,
0228               &pel_enable, sizeof(pel_enable));
0229 
0230     if (pel_enable.pel_class > MPI3_PEL_CLASS_FAULT) {
0231         dprint_bsg_err(mrioc, "%s: out of range class %d sent\n",
0232             __func__, pel_enable.pel_class);
0233         rval = 0;
0234         goto out;
0235     }
0236     if (!mrioc->pel_enabled)
0237         issue_pel_wait = 1;
0238     else {
0239         if ((mrioc->pel_class <= pel_enable.pel_class) &&
0240             !((mrioc->pel_locale & pel_enable.pel_locale) ^
0241               pel_enable.pel_locale)) {
0242             issue_pel_wait = 0;
0243             rval = 0;
0244         } else {
0245             pel_enable.pel_locale |= mrioc->pel_locale;
0246 
0247             if (mrioc->pel_class < pel_enable.pel_class)
0248                 pel_enable.pel_class = mrioc->pel_class;
0249 
0250             rval = mpi3mr_bsg_pel_abort(mrioc);
0251             if (rval) {
0252                 dprint_bsg_err(mrioc,
0253                     "%s: pel_abort failed, status(%ld)\n",
0254                     __func__, rval);
0255                 goto out;
0256             }
0257             issue_pel_wait = 1;
0258         }
0259     }
0260     if (issue_pel_wait) {
0261         tmp_class = mrioc->pel_class;
0262         tmp_locale = mrioc->pel_locale;
0263         mrioc->pel_class = pel_enable.pel_class;
0264         mrioc->pel_locale = pel_enable.pel_locale;
0265         mrioc->pel_enabled = 1;
0266         rval = mpi3mr_pel_get_seqnum_post(mrioc, NULL);
0267         if (rval) {
0268             mrioc->pel_class = tmp_class;
0269             mrioc->pel_locale = tmp_locale;
0270             mrioc->pel_enabled = 0;
0271             dprint_bsg_err(mrioc,
0272                 "%s: pel get sequence number failed, status(%ld)\n",
0273                 __func__, rval);
0274         }
0275     }
0276 
0277 out:
0278     return rval;
0279 }
0280 /**
0281  * mpi3mr_get_all_tgt_info - Get all target information
0282  * @mrioc: Adapter instance reference
0283  * @job: BSG job reference
0284  *
0285  * This function copies the driver managed target devices device
0286  * handle, persistent ID, bus ID and taret ID to the user
0287  * provided buffer for the specific controller. This function
0288  * also provides the number of devices managed by the driver for
0289  * the specific controller.
0290  *
0291  * Return: 0 on success and proper error codes on failure
0292  */
0293 static long mpi3mr_get_all_tgt_info(struct mpi3mr_ioc *mrioc,
0294     struct bsg_job *job)
0295 {
0296     long rval = -EINVAL;
0297     u16 num_devices = 0, i = 0, size;
0298     unsigned long flags;
0299     struct mpi3mr_tgt_dev *tgtdev;
0300     struct mpi3mr_device_map_info *devmap_info = NULL;
0301     struct mpi3mr_all_tgt_info *alltgt_info = NULL;
0302     uint32_t min_entrylen = 0, kern_entrylen = 0, usr_entrylen = 0;
0303 
0304     if (job->request_payload.payload_len < sizeof(u32)) {
0305         dprint_bsg_err(mrioc, "%s: invalid size argument\n",
0306             __func__);
0307         return rval;
0308     }
0309 
0310     spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
0311     list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list)
0312         num_devices++;
0313     spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
0314 
0315     if ((job->request_payload.payload_len == sizeof(u32)) ||
0316         list_empty(&mrioc->tgtdev_list)) {
0317         sg_copy_from_buffer(job->request_payload.sg_list,
0318                     job->request_payload.sg_cnt,
0319                     &num_devices, sizeof(num_devices));
0320         return 0;
0321     }
0322 
0323     kern_entrylen = (num_devices - 1) * sizeof(*devmap_info);
0324     size = sizeof(*alltgt_info) + kern_entrylen;
0325     alltgt_info = kzalloc(size, GFP_KERNEL);
0326     if (!alltgt_info)
0327         return -ENOMEM;
0328 
0329     devmap_info = alltgt_info->dmi;
0330     memset((u8 *)devmap_info, 0xFF, (kern_entrylen + sizeof(*devmap_info)));
0331     spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
0332     list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list) {
0333         if (i < num_devices) {
0334             devmap_info[i].handle = tgtdev->dev_handle;
0335             devmap_info[i].perst_id = tgtdev->perst_id;
0336             if (tgtdev->host_exposed && tgtdev->starget) {
0337                 devmap_info[i].target_id = tgtdev->starget->id;
0338                 devmap_info[i].bus_id =
0339                     tgtdev->starget->channel;
0340             }
0341             i++;
0342         }
0343     }
0344     num_devices = i;
0345     spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
0346 
0347     memcpy(&alltgt_info->num_devices, &num_devices, sizeof(num_devices));
0348 
0349     usr_entrylen = (job->request_payload.payload_len - sizeof(u32)) / sizeof(*devmap_info);
0350     usr_entrylen *= sizeof(*devmap_info);
0351     min_entrylen = min(usr_entrylen, kern_entrylen);
0352     if (min_entrylen && (!memcpy(&alltgt_info->dmi, devmap_info, min_entrylen))) {
0353         dprint_bsg_err(mrioc, "%s:%d: device map info copy failed\n",
0354             __func__, __LINE__);
0355         rval = -EFAULT;
0356         goto out;
0357     }
0358 
0359     sg_copy_from_buffer(job->request_payload.sg_list,
0360                 job->request_payload.sg_cnt,
0361                 alltgt_info, job->request_payload.payload_len);
0362     rval = 0;
0363 out:
0364     kfree(alltgt_info);
0365     return rval;
0366 }
0367 /**
0368  * mpi3mr_get_change_count - Get topology change count
0369  * @mrioc: Adapter instance reference
0370  * @job: BSG job reference
0371  *
0372  * This function copies the toplogy change count provided by the
0373  * driver in events and cached in the driver to the user
0374  * provided buffer for the specific controller.
0375  *
0376  * Return: 0 on success and proper error codes on failure
0377  */
0378 static long mpi3mr_get_change_count(struct mpi3mr_ioc *mrioc,
0379     struct bsg_job *job)
0380 {
0381     struct mpi3mr_change_count chgcnt;
0382 
0383     memset(&chgcnt, 0, sizeof(chgcnt));
0384     chgcnt.change_count = mrioc->change_count;
0385     if (job->request_payload.payload_len >= sizeof(chgcnt)) {
0386         sg_copy_from_buffer(job->request_payload.sg_list,
0387                     job->request_payload.sg_cnt,
0388                     &chgcnt, sizeof(chgcnt));
0389         return 0;
0390     }
0391     return -EINVAL;
0392 }
0393 
0394 /**
0395  * mpi3mr_bsg_adp_reset - Issue controller reset
0396  * @mrioc: Adapter instance reference
0397  * @job: BSG job reference
0398  *
0399  * This function identifies the user provided reset type and
0400  * issues approporiate reset to the controller and wait for that
0401  * to complete and reinitialize the controller and then returns
0402  *
0403  * Return: 0 on success and proper error codes on failure
0404  */
0405 static long mpi3mr_bsg_adp_reset(struct mpi3mr_ioc *mrioc,
0406     struct bsg_job *job)
0407 {
0408     long rval = -EINVAL;
0409     u8 save_snapdump;
0410     struct mpi3mr_bsg_adp_reset adpreset;
0411 
0412     if (job->request_payload.payload_len !=
0413             sizeof(adpreset)) {
0414         dprint_bsg_err(mrioc, "%s: invalid size argument\n",
0415             __func__);
0416         goto out;
0417     }
0418 
0419     sg_copy_to_buffer(job->request_payload.sg_list,
0420               job->request_payload.sg_cnt,
0421               &adpreset, sizeof(adpreset));
0422 
0423     switch (adpreset.reset_type) {
0424     case MPI3MR_BSG_ADPRESET_SOFT:
0425         save_snapdump = 0;
0426         break;
0427     case MPI3MR_BSG_ADPRESET_DIAG_FAULT:
0428         save_snapdump = 1;
0429         break;
0430     default:
0431         dprint_bsg_err(mrioc, "%s: unknown reset_type(%d)\n",
0432             __func__, adpreset.reset_type);
0433         goto out;
0434     }
0435 
0436     rval = mpi3mr_soft_reset_handler(mrioc, MPI3MR_RESET_FROM_APP,
0437         save_snapdump);
0438 
0439     if (rval)
0440         dprint_bsg_err(mrioc,
0441             "%s: reset handler returned error(%ld) for reset type %d\n",
0442             __func__, rval, adpreset.reset_type);
0443 out:
0444     return rval;
0445 }
0446 
0447 /**
0448  * mpi3mr_bsg_populate_adpinfo - Get adapter info command handler
0449  * @mrioc: Adapter instance reference
0450  * @job: BSG job reference
0451  *
0452  * This function provides adapter information for the given
0453  * controller
0454  *
0455  * Return: 0 on success and proper error codes on failure
0456  */
0457 static long mpi3mr_bsg_populate_adpinfo(struct mpi3mr_ioc *mrioc,
0458     struct bsg_job *job)
0459 {
0460     enum mpi3mr_iocstate ioc_state;
0461     struct mpi3mr_bsg_in_adpinfo adpinfo;
0462 
0463     memset(&adpinfo, 0, sizeof(adpinfo));
0464     adpinfo.adp_type = MPI3MR_BSG_ADPTYPE_AVGFAMILY;
0465     adpinfo.pci_dev_id = mrioc->pdev->device;
0466     adpinfo.pci_dev_hw_rev = mrioc->pdev->revision;
0467     adpinfo.pci_subsys_dev_id = mrioc->pdev->subsystem_device;
0468     adpinfo.pci_subsys_ven_id = mrioc->pdev->subsystem_vendor;
0469     adpinfo.pci_bus = mrioc->pdev->bus->number;
0470     adpinfo.pci_dev = PCI_SLOT(mrioc->pdev->devfn);
0471     adpinfo.pci_func = PCI_FUNC(mrioc->pdev->devfn);
0472     adpinfo.pci_seg_id = pci_domain_nr(mrioc->pdev->bus);
0473     adpinfo.app_intfc_ver = MPI3MR_IOCTL_VERSION;
0474 
0475     ioc_state = mpi3mr_get_iocstate(mrioc);
0476     if (ioc_state == MRIOC_STATE_UNRECOVERABLE)
0477         adpinfo.adp_state = MPI3MR_BSG_ADPSTATE_UNRECOVERABLE;
0478     else if ((mrioc->reset_in_progress) || (mrioc->stop_bsgs))
0479         adpinfo.adp_state = MPI3MR_BSG_ADPSTATE_IN_RESET;
0480     else if (ioc_state == MRIOC_STATE_FAULT)
0481         adpinfo.adp_state = MPI3MR_BSG_ADPSTATE_FAULT;
0482     else
0483         adpinfo.adp_state = MPI3MR_BSG_ADPSTATE_OPERATIONAL;
0484 
0485     memcpy((u8 *)&adpinfo.driver_info, (u8 *)&mrioc->driver_info,
0486         sizeof(adpinfo.driver_info));
0487 
0488     if (job->request_payload.payload_len >= sizeof(adpinfo)) {
0489         sg_copy_from_buffer(job->request_payload.sg_list,
0490                     job->request_payload.sg_cnt,
0491                     &adpinfo, sizeof(adpinfo));
0492         return 0;
0493     }
0494     return -EINVAL;
0495 }
0496 
0497 /**
0498  * mpi3mr_bsg_process_drv_cmds - Driver Command handler
0499  * @job: BSG job reference
0500  *
0501  * This function is the top level handler for driver commands,
0502  * this does basic validation of the buffer and identifies the
0503  * opcode and switches to correct sub handler.
0504  *
0505  * Return: 0 on success and proper error codes on failure
0506  */
0507 static long mpi3mr_bsg_process_drv_cmds(struct bsg_job *job)
0508 {
0509     long rval = -EINVAL;
0510     struct mpi3mr_ioc *mrioc = NULL;
0511     struct mpi3mr_bsg_packet *bsg_req = NULL;
0512     struct mpi3mr_bsg_drv_cmd *drvrcmd = NULL;
0513 
0514     bsg_req = job->request;
0515     drvrcmd = &bsg_req->cmd.drvrcmd;
0516 
0517     mrioc = mpi3mr_bsg_verify_adapter(drvrcmd->mrioc_id);
0518     if (!mrioc)
0519         return -ENODEV;
0520 
0521     if (drvrcmd->opcode == MPI3MR_DRVBSG_OPCODE_ADPINFO) {
0522         rval = mpi3mr_bsg_populate_adpinfo(mrioc, job);
0523         return rval;
0524     }
0525 
0526     if (mutex_lock_interruptible(&mrioc->bsg_cmds.mutex))
0527         return -ERESTARTSYS;
0528 
0529     switch (drvrcmd->opcode) {
0530     case MPI3MR_DRVBSG_OPCODE_ADPRESET:
0531         rval = mpi3mr_bsg_adp_reset(mrioc, job);
0532         break;
0533     case MPI3MR_DRVBSG_OPCODE_ALLTGTDEVINFO:
0534         rval = mpi3mr_get_all_tgt_info(mrioc, job);
0535         break;
0536     case MPI3MR_DRVBSG_OPCODE_GETCHGCNT:
0537         rval = mpi3mr_get_change_count(mrioc, job);
0538         break;
0539     case MPI3MR_DRVBSG_OPCODE_LOGDATAENABLE:
0540         rval = mpi3mr_enable_logdata(mrioc, job);
0541         break;
0542     case MPI3MR_DRVBSG_OPCODE_GETLOGDATA:
0543         rval = mpi3mr_get_logdata(mrioc, job);
0544         break;
0545     case MPI3MR_DRVBSG_OPCODE_PELENABLE:
0546         rval = mpi3mr_bsg_pel_enable(mrioc, job);
0547         break;
0548     case MPI3MR_DRVBSG_OPCODE_UNKNOWN:
0549     default:
0550         pr_err("%s: unsupported driver command opcode %d\n",
0551             MPI3MR_DRIVER_NAME, drvrcmd->opcode);
0552         break;
0553     }
0554     mutex_unlock(&mrioc->bsg_cmds.mutex);
0555     return rval;
0556 }
0557 
0558 /**
0559  * mpi3mr_bsg_build_sgl - SGL construction for MPI commands
0560  * @mpi_req: MPI request
0561  * @sgl_offset: offset to start sgl in the MPI request
0562  * @drv_bufs: DMA address of the buffers to be placed in sgl
0563  * @bufcnt: Number of DMA buffers
0564  * @is_rmc: Does the buffer list has management command buffer
0565  * @is_rmr: Does the buffer list has management response buffer
0566  * @num_datasges: Number of data buffers in the list
0567  *
0568  * This function places the DMA address of the given buffers in
0569  * proper format as SGEs in the given MPI request.
0570  *
0571  * Return: Nothing
0572  */
0573 static void mpi3mr_bsg_build_sgl(u8 *mpi_req, uint32_t sgl_offset,
0574     struct mpi3mr_buf_map *drv_bufs, u8 bufcnt, u8 is_rmc,
0575     u8 is_rmr, u8 num_datasges)
0576 {
0577     u8 *sgl = (mpi_req + sgl_offset), count = 0;
0578     struct mpi3_mgmt_passthrough_request *rmgmt_req =
0579         (struct mpi3_mgmt_passthrough_request *)mpi_req;
0580     struct mpi3mr_buf_map *drv_buf_iter = drv_bufs;
0581     u8 sgl_flags, sgl_flags_last;
0582 
0583     sgl_flags = MPI3_SGE_FLAGS_ELEMENT_TYPE_SIMPLE |
0584         MPI3_SGE_FLAGS_DLAS_SYSTEM | MPI3_SGE_FLAGS_END_OF_BUFFER;
0585     sgl_flags_last = sgl_flags | MPI3_SGE_FLAGS_END_OF_LIST;
0586 
0587     if (is_rmc) {
0588         mpi3mr_add_sg_single(&rmgmt_req->command_sgl,
0589             sgl_flags_last, drv_buf_iter->kern_buf_len,
0590             drv_buf_iter->kern_buf_dma);
0591         sgl = (u8 *)drv_buf_iter->kern_buf + drv_buf_iter->bsg_buf_len;
0592         drv_buf_iter++;
0593         count++;
0594         if (is_rmr) {
0595             mpi3mr_add_sg_single(&rmgmt_req->response_sgl,
0596                 sgl_flags_last, drv_buf_iter->kern_buf_len,
0597                 drv_buf_iter->kern_buf_dma);
0598             drv_buf_iter++;
0599             count++;
0600         } else
0601             mpi3mr_build_zero_len_sge(
0602                 &rmgmt_req->response_sgl);
0603     }
0604     if (!num_datasges) {
0605         mpi3mr_build_zero_len_sge(sgl);
0606         return;
0607     }
0608     for (; count < bufcnt; count++, drv_buf_iter++) {
0609         if (drv_buf_iter->data_dir == DMA_NONE)
0610             continue;
0611         if (num_datasges == 1 || !is_rmc)
0612             mpi3mr_add_sg_single(sgl, sgl_flags_last,
0613                 drv_buf_iter->kern_buf_len, drv_buf_iter->kern_buf_dma);
0614         else
0615             mpi3mr_add_sg_single(sgl, sgl_flags,
0616                 drv_buf_iter->kern_buf_len, drv_buf_iter->kern_buf_dma);
0617         sgl += sizeof(struct mpi3_sge_common);
0618         num_datasges--;
0619     }
0620 }
0621 
0622 /**
0623  * mpi3mr_get_nvme_data_fmt - returns the NVMe data format
0624  * @nvme_encap_request: NVMe encapsulated MPI request
0625  *
0626  * This function returns the type of the data format specified
0627  * in user provided NVMe command in NVMe encapsulated request.
0628  *
0629  * Return: Data format of the NVMe command (PRP/SGL etc)
0630  */
0631 static unsigned int mpi3mr_get_nvme_data_fmt(
0632     struct mpi3_nvme_encapsulated_request *nvme_encap_request)
0633 {
0634     u8 format = 0;
0635 
0636     format = ((nvme_encap_request->command[0] & 0xc000) >> 14);
0637     return format;
0638 
0639 }
0640 
0641 /**
0642  * mpi3mr_build_nvme_sgl - SGL constructor for NVME
0643  *                 encapsulated request
0644  * @mrioc: Adapter instance reference
0645  * @nvme_encap_request: NVMe encapsulated MPI request
0646  * @drv_bufs: DMA address of the buffers to be placed in sgl
0647  * @bufcnt: Number of DMA buffers
0648  *
0649  * This function places the DMA address of the given buffers in
0650  * proper format as SGEs in the given NVMe encapsulated request.
0651  *
0652  * Return: 0 on success, -1 on failure
0653  */
0654 static int mpi3mr_build_nvme_sgl(struct mpi3mr_ioc *mrioc,
0655     struct mpi3_nvme_encapsulated_request *nvme_encap_request,
0656     struct mpi3mr_buf_map *drv_bufs, u8 bufcnt)
0657 {
0658     struct mpi3mr_nvme_pt_sge *nvme_sgl;
0659     u64 sgl_ptr;
0660     u8 count;
0661     size_t length = 0;
0662     struct mpi3mr_buf_map *drv_buf_iter = drv_bufs;
0663     u64 sgemod_mask = ((u64)((mrioc->facts.sge_mod_mask) <<
0664                 mrioc->facts.sge_mod_shift) << 32);
0665     u64 sgemod_val = ((u64)(mrioc->facts.sge_mod_value) <<
0666               mrioc->facts.sge_mod_shift) << 32;
0667 
0668     /*
0669      * Not all commands require a data transfer. If no data, just return
0670      * without constructing any sgl.
0671      */
0672     for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
0673         if (drv_buf_iter->data_dir == DMA_NONE)
0674             continue;
0675         sgl_ptr = (u64)drv_buf_iter->kern_buf_dma;
0676         length = drv_buf_iter->kern_buf_len;
0677         break;
0678     }
0679     if (!length)
0680         return 0;
0681 
0682     if (sgl_ptr & sgemod_mask) {
0683         dprint_bsg_err(mrioc,
0684             "%s: SGL address collides with SGE modifier\n",
0685             __func__);
0686         return -1;
0687     }
0688 
0689     sgl_ptr &= ~sgemod_mask;
0690     sgl_ptr |= sgemod_val;
0691     nvme_sgl = (struct mpi3mr_nvme_pt_sge *)
0692         ((u8 *)(nvme_encap_request->command) + MPI3MR_NVME_CMD_SGL_OFFSET);
0693     memset(nvme_sgl, 0, sizeof(struct mpi3mr_nvme_pt_sge));
0694     nvme_sgl->base_addr = sgl_ptr;
0695     nvme_sgl->length = length;
0696     return 0;
0697 }
0698 
0699 /**
0700  * mpi3mr_build_nvme_prp - PRP constructor for NVME
0701  *                 encapsulated request
0702  * @mrioc: Adapter instance reference
0703  * @nvme_encap_request: NVMe encapsulated MPI request
0704  * @drv_bufs: DMA address of the buffers to be placed in SGL
0705  * @bufcnt: Number of DMA buffers
0706  *
0707  * This function places the DMA address of the given buffers in
0708  * proper format as PRP entries in the given NVMe encapsulated
0709  * request.
0710  *
0711  * Return: 0 on success, -1 on failure
0712  */
0713 static int mpi3mr_build_nvme_prp(struct mpi3mr_ioc *mrioc,
0714     struct mpi3_nvme_encapsulated_request *nvme_encap_request,
0715     struct mpi3mr_buf_map *drv_bufs, u8 bufcnt)
0716 {
0717     int prp_size = MPI3MR_NVME_PRP_SIZE;
0718     __le64 *prp_entry, *prp1_entry, *prp2_entry;
0719     __le64 *prp_page;
0720     dma_addr_t prp_entry_dma, prp_page_dma, dma_addr;
0721     u32 offset, entry_len, dev_pgsz;
0722     u32 page_mask_result, page_mask;
0723     size_t length = 0;
0724     u8 count;
0725     struct mpi3mr_buf_map *drv_buf_iter = drv_bufs;
0726     u64 sgemod_mask = ((u64)((mrioc->facts.sge_mod_mask) <<
0727                 mrioc->facts.sge_mod_shift) << 32);
0728     u64 sgemod_val = ((u64)(mrioc->facts.sge_mod_value) <<
0729               mrioc->facts.sge_mod_shift) << 32;
0730     u16 dev_handle = nvme_encap_request->dev_handle;
0731     struct mpi3mr_tgt_dev *tgtdev;
0732 
0733     tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, dev_handle);
0734     if (!tgtdev) {
0735         dprint_bsg_err(mrioc, "%s: invalid device handle 0x%04x\n",
0736             __func__, dev_handle);
0737         return -1;
0738     }
0739 
0740     if (tgtdev->dev_spec.pcie_inf.pgsz == 0) {
0741         dprint_bsg_err(mrioc,
0742             "%s: NVMe device page size is zero for handle 0x%04x\n",
0743             __func__, dev_handle);
0744         mpi3mr_tgtdev_put(tgtdev);
0745         return -1;
0746     }
0747 
0748     dev_pgsz = 1 << (tgtdev->dev_spec.pcie_inf.pgsz);
0749     mpi3mr_tgtdev_put(tgtdev);
0750 
0751     /*
0752      * Not all commands require a data transfer. If no data, just return
0753      * without constructing any PRP.
0754      */
0755     for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
0756         if (drv_buf_iter->data_dir == DMA_NONE)
0757             continue;
0758         dma_addr = drv_buf_iter->kern_buf_dma;
0759         length = drv_buf_iter->kern_buf_len;
0760         break;
0761     }
0762 
0763     if (!length)
0764         return 0;
0765 
0766     mrioc->prp_sz = 0;
0767     mrioc->prp_list_virt = dma_alloc_coherent(&mrioc->pdev->dev,
0768         dev_pgsz, &mrioc->prp_list_dma, GFP_KERNEL);
0769 
0770     if (!mrioc->prp_list_virt)
0771         return -1;
0772     mrioc->prp_sz = dev_pgsz;
0773 
0774     /*
0775      * Set pointers to PRP1 and PRP2, which are in the NVMe command.
0776      * PRP1 is located at a 24 byte offset from the start of the NVMe
0777      * command.  Then set the current PRP entry pointer to PRP1.
0778      */
0779     prp1_entry = (__le64 *)((u8 *)(nvme_encap_request->command) +
0780         MPI3MR_NVME_CMD_PRP1_OFFSET);
0781     prp2_entry = (__le64 *)((u8 *)(nvme_encap_request->command) +
0782         MPI3MR_NVME_CMD_PRP2_OFFSET);
0783     prp_entry = prp1_entry;
0784     /*
0785      * For the PRP entries, use the specially allocated buffer of
0786      * contiguous memory.
0787      */
0788     prp_page = (__le64 *)mrioc->prp_list_virt;
0789     prp_page_dma = mrioc->prp_list_dma;
0790 
0791     /*
0792      * Check if we are within 1 entry of a page boundary we don't
0793      * want our first entry to be a PRP List entry.
0794      */
0795     page_mask = dev_pgsz - 1;
0796     page_mask_result = (uintptr_t)((u8 *)prp_page + prp_size) & page_mask;
0797     if (!page_mask_result) {
0798         dprint_bsg_err(mrioc, "%s: PRP page is not page aligned\n",
0799             __func__);
0800         goto err_out;
0801     }
0802 
0803     /*
0804      * Set PRP physical pointer, which initially points to the current PRP
0805      * DMA memory page.
0806      */
0807     prp_entry_dma = prp_page_dma;
0808 
0809 
0810     /* Loop while the length is not zero. */
0811     while (length) {
0812         page_mask_result = (prp_entry_dma + prp_size) & page_mask;
0813         if (!page_mask_result && (length >  dev_pgsz)) {
0814             dprint_bsg_err(mrioc,
0815                 "%s: single PRP page is not sufficient\n",
0816                 __func__);
0817             goto err_out;
0818         }
0819 
0820         /* Need to handle if entry will be part of a page. */
0821         offset = dma_addr & page_mask;
0822         entry_len = dev_pgsz - offset;
0823 
0824         if (prp_entry == prp1_entry) {
0825             /*
0826              * Must fill in the first PRP pointer (PRP1) before
0827              * moving on.
0828              */
0829             *prp1_entry = cpu_to_le64(dma_addr);
0830             if (*prp1_entry & sgemod_mask) {
0831                 dprint_bsg_err(mrioc,
0832                     "%s: PRP1 address collides with SGE modifier\n",
0833                     __func__);
0834                 goto err_out;
0835             }
0836             *prp1_entry &= ~sgemod_mask;
0837             *prp1_entry |= sgemod_val;
0838 
0839             /*
0840              * Now point to the second PRP entry within the
0841              * command (PRP2).
0842              */
0843             prp_entry = prp2_entry;
0844         } else if (prp_entry == prp2_entry) {
0845             /*
0846              * Should the PRP2 entry be a PRP List pointer or just
0847              * a regular PRP pointer?  If there is more than one
0848              * more page of data, must use a PRP List pointer.
0849              */
0850             if (length > dev_pgsz) {
0851                 /*
0852                  * PRP2 will contain a PRP List pointer because
0853                  * more PRP's are needed with this command. The
0854                  * list will start at the beginning of the
0855                  * contiguous buffer.
0856                  */
0857                 *prp2_entry = cpu_to_le64(prp_entry_dma);
0858                 if (*prp2_entry & sgemod_mask) {
0859                     dprint_bsg_err(mrioc,
0860                         "%s: PRP list address collides with SGE modifier\n",
0861                         __func__);
0862                     goto err_out;
0863                 }
0864                 *prp2_entry &= ~sgemod_mask;
0865                 *prp2_entry |= sgemod_val;
0866 
0867                 /*
0868                  * The next PRP Entry will be the start of the
0869                  * first PRP List.
0870                  */
0871                 prp_entry = prp_page;
0872                 continue;
0873             } else {
0874                 /*
0875                  * After this, the PRP Entries are complete.
0876                  * This command uses 2 PRP's and no PRP list.
0877                  */
0878                 *prp2_entry = cpu_to_le64(dma_addr);
0879                 if (*prp2_entry & sgemod_mask) {
0880                     dprint_bsg_err(mrioc,
0881                         "%s: PRP2 collides with SGE modifier\n",
0882                         __func__);
0883                     goto err_out;
0884                 }
0885                 *prp2_entry &= ~sgemod_mask;
0886                 *prp2_entry |= sgemod_val;
0887             }
0888         } else {
0889             /*
0890              * Put entry in list and bump the addresses.
0891              *
0892              * After PRP1 and PRP2 are filled in, this will fill in
0893              * all remaining PRP entries in a PRP List, one per
0894              * each time through the loop.
0895              */
0896             *prp_entry = cpu_to_le64(dma_addr);
0897             if (*prp1_entry & sgemod_mask) {
0898                 dprint_bsg_err(mrioc,
0899                     "%s: PRP address collides with SGE modifier\n",
0900                     __func__);
0901                 goto err_out;
0902             }
0903             *prp_entry &= ~sgemod_mask;
0904             *prp_entry |= sgemod_val;
0905             prp_entry++;
0906             prp_entry_dma++;
0907         }
0908 
0909         /*
0910          * Bump the phys address of the command's data buffer by the
0911          * entry_len.
0912          */
0913         dma_addr += entry_len;
0914 
0915         /* decrement length accounting for last partial page. */
0916         if (entry_len > length)
0917             length = 0;
0918         else
0919             length -= entry_len;
0920     }
0921     return 0;
0922 err_out:
0923     if (mrioc->prp_list_virt) {
0924         dma_free_coherent(&mrioc->pdev->dev, mrioc->prp_sz,
0925             mrioc->prp_list_virt, mrioc->prp_list_dma);
0926         mrioc->prp_list_virt = NULL;
0927     }
0928     return -1;
0929 }
0930 /**
0931  * mpi3mr_bsg_process_mpt_cmds - MPI Pass through BSG handler
0932  * @job: BSG job reference
0933  *
0934  * This function is the top level handler for MPI Pass through
0935  * command, this does basic validation of the input data buffers,
0936  * identifies the given buffer types and MPI command, allocates
0937  * DMAable memory for user given buffers, construstcs SGL
0938  * properly and passes the command to the firmware.
0939  *
0940  * Once the MPI command is completed the driver copies the data
0941  * if any and reply, sense information to user provided buffers.
0942  * If the command is timed out then issues controller reset
0943  * prior to returning.
0944  *
0945  * Return: 0 on success and proper error codes on failure
0946  */
0947 
0948 static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply_payload_rcv_len)
0949 {
0950     long rval = -EINVAL;
0951 
0952     struct mpi3mr_ioc *mrioc = NULL;
0953     u8 *mpi_req = NULL, *sense_buff_k = NULL;
0954     u8 mpi_msg_size = 0;
0955     struct mpi3mr_bsg_packet *bsg_req = NULL;
0956     struct mpi3mr_bsg_mptcmd *karg;
0957     struct mpi3mr_buf_entry *buf_entries = NULL;
0958     struct mpi3mr_buf_map *drv_bufs = NULL, *drv_buf_iter = NULL;
0959     u8 count, bufcnt = 0, is_rmcb = 0, is_rmrb = 0, din_cnt = 0, dout_cnt = 0;
0960     u8 invalid_be = 0, erb_offset = 0xFF, mpirep_offset = 0xFF, sg_entries = 0;
0961     u8 block_io = 0, resp_code = 0, nvme_fmt = 0;
0962     struct mpi3_request_header *mpi_header = NULL;
0963     struct mpi3_status_reply_descriptor *status_desc;
0964     struct mpi3_scsi_task_mgmt_request *tm_req;
0965     u32 erbsz = MPI3MR_SENSE_BUF_SZ, tmplen;
0966     u16 dev_handle;
0967     struct mpi3mr_tgt_dev *tgtdev;
0968     struct mpi3mr_stgt_priv_data *stgt_priv = NULL;
0969     struct mpi3mr_bsg_in_reply_buf *bsg_reply_buf = NULL;
0970     u32 din_size = 0, dout_size = 0;
0971     u8 *din_buf = NULL, *dout_buf = NULL;
0972     u8 *sgl_iter = NULL, *sgl_din_iter = NULL, *sgl_dout_iter = NULL;
0973 
0974     bsg_req = job->request;
0975     karg = (struct mpi3mr_bsg_mptcmd *)&bsg_req->cmd.mptcmd;
0976 
0977     mrioc = mpi3mr_bsg_verify_adapter(karg->mrioc_id);
0978     if (!mrioc)
0979         return -ENODEV;
0980 
0981     if (karg->timeout < MPI3MR_APP_DEFAULT_TIMEOUT)
0982         karg->timeout = MPI3MR_APP_DEFAULT_TIMEOUT;
0983 
0984     mpi_req = kzalloc(MPI3MR_ADMIN_REQ_FRAME_SZ, GFP_KERNEL);
0985     if (!mpi_req)
0986         return -ENOMEM;
0987     mpi_header = (struct mpi3_request_header *)mpi_req;
0988 
0989     bufcnt = karg->buf_entry_list.num_of_entries;
0990     drv_bufs = kzalloc((sizeof(*drv_bufs) * bufcnt), GFP_KERNEL);
0991     if (!drv_bufs) {
0992         rval = -ENOMEM;
0993         goto out;
0994     }
0995 
0996     dout_buf = kzalloc(job->request_payload.payload_len,
0997                       GFP_KERNEL);
0998     if (!dout_buf) {
0999         rval = -ENOMEM;
1000         goto out;
1001     }
1002 
1003     din_buf = kzalloc(job->reply_payload.payload_len,
1004                      GFP_KERNEL);
1005     if (!din_buf) {
1006         rval = -ENOMEM;
1007         goto out;
1008     }
1009 
1010     sg_copy_to_buffer(job->request_payload.sg_list,
1011               job->request_payload.sg_cnt,
1012               dout_buf, job->request_payload.payload_len);
1013 
1014     buf_entries = karg->buf_entry_list.buf_entry;
1015     sgl_din_iter = din_buf;
1016     sgl_dout_iter = dout_buf;
1017     drv_buf_iter = drv_bufs;
1018 
1019     for (count = 0; count < bufcnt; count++, buf_entries++, drv_buf_iter++) {
1020 
1021         if (sgl_dout_iter > (dout_buf + job->request_payload.payload_len)) {
1022             dprint_bsg_err(mrioc, "%s: data_out buffer length mismatch\n",
1023                 __func__);
1024             rval = -EINVAL;
1025             goto out;
1026         }
1027         if (sgl_din_iter > (din_buf + job->reply_payload.payload_len)) {
1028             dprint_bsg_err(mrioc, "%s: data_in buffer length mismatch\n",
1029                 __func__);
1030             rval = -EINVAL;
1031             goto out;
1032         }
1033 
1034         switch (buf_entries->buf_type) {
1035         case MPI3MR_BSG_BUFTYPE_RAIDMGMT_CMD:
1036             sgl_iter = sgl_dout_iter;
1037             sgl_dout_iter += buf_entries->buf_len;
1038             drv_buf_iter->data_dir = DMA_TO_DEVICE;
1039             is_rmcb = 1;
1040             if (count != 0)
1041                 invalid_be = 1;
1042             break;
1043         case MPI3MR_BSG_BUFTYPE_RAIDMGMT_RESP:
1044             sgl_iter = sgl_din_iter;
1045             sgl_din_iter += buf_entries->buf_len;
1046             drv_buf_iter->data_dir = DMA_FROM_DEVICE;
1047             is_rmrb = 1;
1048             if (count != 1 || !is_rmcb)
1049                 invalid_be = 1;
1050             break;
1051         case MPI3MR_BSG_BUFTYPE_DATA_IN:
1052             sgl_iter = sgl_din_iter;
1053             sgl_din_iter += buf_entries->buf_len;
1054             drv_buf_iter->data_dir = DMA_FROM_DEVICE;
1055             din_cnt++;
1056             din_size += drv_buf_iter->bsg_buf_len;
1057             if ((din_cnt > 1) && !is_rmcb)
1058                 invalid_be = 1;
1059             break;
1060         case MPI3MR_BSG_BUFTYPE_DATA_OUT:
1061             sgl_iter = sgl_dout_iter;
1062             sgl_dout_iter += buf_entries->buf_len;
1063             drv_buf_iter->data_dir = DMA_TO_DEVICE;
1064             dout_cnt++;
1065             dout_size += drv_buf_iter->bsg_buf_len;
1066             if ((dout_cnt > 1) && !is_rmcb)
1067                 invalid_be = 1;
1068             break;
1069         case MPI3MR_BSG_BUFTYPE_MPI_REPLY:
1070             sgl_iter = sgl_din_iter;
1071             sgl_din_iter += buf_entries->buf_len;
1072             drv_buf_iter->data_dir = DMA_NONE;
1073             mpirep_offset = count;
1074             break;
1075         case MPI3MR_BSG_BUFTYPE_ERR_RESPONSE:
1076             sgl_iter = sgl_din_iter;
1077             sgl_din_iter += buf_entries->buf_len;
1078             drv_buf_iter->data_dir = DMA_NONE;
1079             erb_offset = count;
1080             break;
1081         case MPI3MR_BSG_BUFTYPE_MPI_REQUEST:
1082             sgl_iter = sgl_dout_iter;
1083             sgl_dout_iter += buf_entries->buf_len;
1084             drv_buf_iter->data_dir = DMA_NONE;
1085             mpi_msg_size = buf_entries->buf_len;
1086             if ((!mpi_msg_size || (mpi_msg_size % 4)) ||
1087                     (mpi_msg_size > MPI3MR_ADMIN_REQ_FRAME_SZ)) {
1088                 dprint_bsg_err(mrioc, "%s: invalid MPI message size\n",
1089                     __func__);
1090                 rval = -EINVAL;
1091                 goto out;
1092             }
1093             memcpy(mpi_req, sgl_iter, buf_entries->buf_len);
1094             break;
1095         default:
1096             invalid_be = 1;
1097             break;
1098         }
1099         if (invalid_be) {
1100             dprint_bsg_err(mrioc, "%s: invalid buffer entries passed\n",
1101                 __func__);
1102             rval = -EINVAL;
1103             goto out;
1104         }
1105 
1106         drv_buf_iter->bsg_buf = sgl_iter;
1107         drv_buf_iter->bsg_buf_len = buf_entries->buf_len;
1108 
1109     }
1110     if (!is_rmcb && (dout_cnt || din_cnt)) {
1111         sg_entries = dout_cnt + din_cnt;
1112         if (((mpi_msg_size) + (sg_entries *
1113               sizeof(struct mpi3_sge_common))) > MPI3MR_ADMIN_REQ_FRAME_SZ) {
1114             dprint_bsg_err(mrioc,
1115                 "%s:%d: invalid message size passed\n",
1116                 __func__, __LINE__);
1117             rval = -EINVAL;
1118             goto out;
1119         }
1120     }
1121     if (din_size > MPI3MR_MAX_APP_XFER_SIZE) {
1122         dprint_bsg_err(mrioc,
1123             "%s:%d: invalid data transfer size passed for function 0x%x din_size=%d\n",
1124             __func__, __LINE__, mpi_header->function, din_size);
1125         rval = -EINVAL;
1126         goto out;
1127     }
1128     if (dout_size > MPI3MR_MAX_APP_XFER_SIZE) {
1129         dprint_bsg_err(mrioc,
1130             "%s:%d: invalid data transfer size passed for function 0x%x dout_size = %d\n",
1131             __func__, __LINE__, mpi_header->function, dout_size);
1132         rval = -EINVAL;
1133         goto out;
1134     }
1135 
1136     drv_buf_iter = drv_bufs;
1137     for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
1138         if (drv_buf_iter->data_dir == DMA_NONE)
1139             continue;
1140 
1141         drv_buf_iter->kern_buf_len = drv_buf_iter->bsg_buf_len;
1142         if (is_rmcb && !count)
1143             drv_buf_iter->kern_buf_len += ((dout_cnt + din_cnt) *
1144                 sizeof(struct mpi3_sge_common));
1145 
1146         if (!drv_buf_iter->kern_buf_len)
1147             continue;
1148 
1149         drv_buf_iter->kern_buf = dma_alloc_coherent(&mrioc->pdev->dev,
1150             drv_buf_iter->kern_buf_len, &drv_buf_iter->kern_buf_dma,
1151             GFP_KERNEL);
1152         if (!drv_buf_iter->kern_buf) {
1153             rval = -ENOMEM;
1154             goto out;
1155         }
1156         if (drv_buf_iter->data_dir == DMA_TO_DEVICE) {
1157             tmplen = min(drv_buf_iter->kern_buf_len,
1158                 drv_buf_iter->bsg_buf_len);
1159             memcpy(drv_buf_iter->kern_buf, drv_buf_iter->bsg_buf, tmplen);
1160         }
1161     }
1162 
1163     if (erb_offset != 0xFF) {
1164         sense_buff_k = kzalloc(erbsz, GFP_KERNEL);
1165         if (!sense_buff_k) {
1166             rval = -ENOMEM;
1167             goto out;
1168         }
1169     }
1170 
1171     if (mutex_lock_interruptible(&mrioc->bsg_cmds.mutex)) {
1172         rval = -ERESTARTSYS;
1173         goto out;
1174     }
1175     if (mrioc->bsg_cmds.state & MPI3MR_CMD_PENDING) {
1176         rval = -EAGAIN;
1177         dprint_bsg_err(mrioc, "%s: command is in use\n", __func__);
1178         mutex_unlock(&mrioc->bsg_cmds.mutex);
1179         goto out;
1180     }
1181     if (mrioc->unrecoverable) {
1182         dprint_bsg_err(mrioc, "%s: unrecoverable controller\n",
1183             __func__);
1184         rval = -EFAULT;
1185         mutex_unlock(&mrioc->bsg_cmds.mutex);
1186         goto out;
1187     }
1188     if (mrioc->reset_in_progress) {
1189         dprint_bsg_err(mrioc, "%s: reset in progress\n", __func__);
1190         rval = -EAGAIN;
1191         mutex_unlock(&mrioc->bsg_cmds.mutex);
1192         goto out;
1193     }
1194     if (mrioc->stop_bsgs) {
1195         dprint_bsg_err(mrioc, "%s: bsgs are blocked\n", __func__);
1196         rval = -EAGAIN;
1197         mutex_unlock(&mrioc->bsg_cmds.mutex);
1198         goto out;
1199     }
1200 
1201     if (mpi_header->function == MPI3_BSG_FUNCTION_NVME_ENCAPSULATED) {
1202         nvme_fmt = mpi3mr_get_nvme_data_fmt(
1203             (struct mpi3_nvme_encapsulated_request *)mpi_req);
1204         if (nvme_fmt == MPI3MR_NVME_DATA_FORMAT_PRP) {
1205             if (mpi3mr_build_nvme_prp(mrioc,
1206                 (struct mpi3_nvme_encapsulated_request *)mpi_req,
1207                 drv_bufs, bufcnt)) {
1208                 rval = -ENOMEM;
1209                 mutex_unlock(&mrioc->bsg_cmds.mutex);
1210                 goto out;
1211             }
1212         } else if (nvme_fmt == MPI3MR_NVME_DATA_FORMAT_SGL1 ||
1213             nvme_fmt == MPI3MR_NVME_DATA_FORMAT_SGL2) {
1214             if (mpi3mr_build_nvme_sgl(mrioc,
1215                 (struct mpi3_nvme_encapsulated_request *)mpi_req,
1216                 drv_bufs, bufcnt)) {
1217                 rval = -EINVAL;
1218                 mutex_unlock(&mrioc->bsg_cmds.mutex);
1219                 goto out;
1220             }
1221         } else {
1222             dprint_bsg_err(mrioc,
1223                 "%s:invalid NVMe command format\n", __func__);
1224             rval = -EINVAL;
1225             mutex_unlock(&mrioc->bsg_cmds.mutex);
1226             goto out;
1227         }
1228     } else {
1229         mpi3mr_bsg_build_sgl(mpi_req, (mpi_msg_size),
1230             drv_bufs, bufcnt, is_rmcb, is_rmrb,
1231             (dout_cnt + din_cnt));
1232     }
1233 
1234     if (mpi_header->function == MPI3_BSG_FUNCTION_SCSI_TASK_MGMT) {
1235         tm_req = (struct mpi3_scsi_task_mgmt_request *)mpi_req;
1236         if (tm_req->task_type !=
1237             MPI3_SCSITASKMGMT_TASKTYPE_ABORT_TASK) {
1238             dev_handle = tm_req->dev_handle;
1239             block_io = 1;
1240         }
1241     }
1242     if (block_io) {
1243         tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, dev_handle);
1244         if (tgtdev && tgtdev->starget && tgtdev->starget->hostdata) {
1245             stgt_priv = (struct mpi3mr_stgt_priv_data *)
1246                 tgtdev->starget->hostdata;
1247             atomic_inc(&stgt_priv->block_io);
1248             mpi3mr_tgtdev_put(tgtdev);
1249         }
1250     }
1251 
1252     mrioc->bsg_cmds.state = MPI3MR_CMD_PENDING;
1253     mrioc->bsg_cmds.is_waiting = 1;
1254     mrioc->bsg_cmds.callback = NULL;
1255     mrioc->bsg_cmds.is_sense = 0;
1256     mrioc->bsg_cmds.sensebuf = sense_buff_k;
1257     memset(mrioc->bsg_cmds.reply, 0, mrioc->reply_sz);
1258     mpi_header->host_tag = cpu_to_le16(MPI3MR_HOSTTAG_BSG_CMDS);
1259     if (mrioc->logging_level & MPI3_DEBUG_BSG_INFO) {
1260         dprint_bsg_info(mrioc,
1261             "%s: posting bsg request to the controller\n", __func__);
1262         dprint_dump(mpi_req, MPI3MR_ADMIN_REQ_FRAME_SZ,
1263             "bsg_mpi3_req");
1264         if (mpi_header->function == MPI3_BSG_FUNCTION_MGMT_PASSTHROUGH) {
1265             drv_buf_iter = &drv_bufs[0];
1266             dprint_dump(drv_buf_iter->kern_buf,
1267                 drv_buf_iter->kern_buf_len, "mpi3_mgmt_req");
1268         }
1269     }
1270 
1271     init_completion(&mrioc->bsg_cmds.done);
1272     rval = mpi3mr_admin_request_post(mrioc, mpi_req,
1273         MPI3MR_ADMIN_REQ_FRAME_SZ, 0);
1274 
1275 
1276     if (rval) {
1277         mrioc->bsg_cmds.is_waiting = 0;
1278         dprint_bsg_err(mrioc,
1279             "%s: posting bsg request is failed\n", __func__);
1280         rval = -EAGAIN;
1281         goto out_unlock;
1282     }
1283     wait_for_completion_timeout(&mrioc->bsg_cmds.done,
1284         (karg->timeout * HZ));
1285     if (block_io && stgt_priv)
1286         atomic_dec(&stgt_priv->block_io);
1287     if (!(mrioc->bsg_cmds.state & MPI3MR_CMD_COMPLETE)) {
1288         mrioc->bsg_cmds.is_waiting = 0;
1289         rval = -EAGAIN;
1290         if (mrioc->bsg_cmds.state & MPI3MR_CMD_RESET)
1291             goto out_unlock;
1292         dprint_bsg_err(mrioc,
1293             "%s: bsg request timedout after %d seconds\n", __func__,
1294             karg->timeout);
1295         if (mrioc->logging_level & MPI3_DEBUG_BSG_ERROR) {
1296             dprint_dump(mpi_req, MPI3MR_ADMIN_REQ_FRAME_SZ,
1297                 "bsg_mpi3_req");
1298             if (mpi_header->function ==
1299                 MPI3_BSG_FUNCTION_MGMT_PASSTHROUGH) {
1300                 drv_buf_iter = &drv_bufs[0];
1301                 dprint_dump(drv_buf_iter->kern_buf,
1302                     drv_buf_iter->kern_buf_len, "mpi3_mgmt_req");
1303             }
1304         }
1305 
1306         if ((mpi_header->function == MPI3_BSG_FUNCTION_NVME_ENCAPSULATED) ||
1307             (mpi_header->function == MPI3_BSG_FUNCTION_SCSI_IO))
1308             mpi3mr_issue_tm(mrioc,
1309                 MPI3_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
1310                 mpi_header->function_dependent, 0,
1311                 MPI3MR_HOSTTAG_BLK_TMS, MPI3MR_RESETTM_TIMEOUT,
1312                 &mrioc->host_tm_cmds, &resp_code, NULL);
1313         if (!(mrioc->bsg_cmds.state & MPI3MR_CMD_COMPLETE) &&
1314             !(mrioc->bsg_cmds.state & MPI3MR_CMD_RESET))
1315             mpi3mr_soft_reset_handler(mrioc,
1316                 MPI3MR_RESET_FROM_APP_TIMEOUT, 1);
1317         goto out_unlock;
1318     }
1319     dprint_bsg_info(mrioc, "%s: bsg request is completed\n", __func__);
1320 
1321     if (mrioc->prp_list_virt) {
1322         dma_free_coherent(&mrioc->pdev->dev, mrioc->prp_sz,
1323             mrioc->prp_list_virt, mrioc->prp_list_dma);
1324         mrioc->prp_list_virt = NULL;
1325     }
1326 
1327     if ((mrioc->bsg_cmds.ioc_status & MPI3_IOCSTATUS_STATUS_MASK)
1328          != MPI3_IOCSTATUS_SUCCESS) {
1329         dprint_bsg_info(mrioc,
1330             "%s: command failed, ioc_status(0x%04x) log_info(0x%08x)\n",
1331             __func__,
1332             (mrioc->bsg_cmds.ioc_status & MPI3_IOCSTATUS_STATUS_MASK),
1333             mrioc->bsg_cmds.ioc_loginfo);
1334     }
1335 
1336     if ((mpirep_offset != 0xFF) &&
1337         drv_bufs[mpirep_offset].bsg_buf_len) {
1338         drv_buf_iter = &drv_bufs[mpirep_offset];
1339         drv_buf_iter->kern_buf_len = (sizeof(*bsg_reply_buf) - 1 +
1340                        mrioc->reply_sz);
1341         bsg_reply_buf = kzalloc(drv_buf_iter->kern_buf_len, GFP_KERNEL);
1342 
1343         if (!bsg_reply_buf) {
1344             rval = -ENOMEM;
1345             goto out_unlock;
1346         }
1347         if (mrioc->bsg_cmds.state & MPI3MR_CMD_REPLY_VALID) {
1348             bsg_reply_buf->mpi_reply_type =
1349                 MPI3MR_BSG_MPI_REPLY_BUFTYPE_ADDRESS;
1350             memcpy(bsg_reply_buf->reply_buf,
1351                 mrioc->bsg_cmds.reply, mrioc->reply_sz);
1352         } else {
1353             bsg_reply_buf->mpi_reply_type =
1354                 MPI3MR_BSG_MPI_REPLY_BUFTYPE_STATUS;
1355             status_desc = (struct mpi3_status_reply_descriptor *)
1356                 bsg_reply_buf->reply_buf;
1357             status_desc->ioc_status = mrioc->bsg_cmds.ioc_status;
1358             status_desc->ioc_log_info = mrioc->bsg_cmds.ioc_loginfo;
1359         }
1360         tmplen = min(drv_buf_iter->kern_buf_len,
1361             drv_buf_iter->bsg_buf_len);
1362         memcpy(drv_buf_iter->bsg_buf, bsg_reply_buf, tmplen);
1363     }
1364 
1365     if (erb_offset != 0xFF && mrioc->bsg_cmds.sensebuf &&
1366         mrioc->bsg_cmds.is_sense) {
1367         drv_buf_iter = &drv_bufs[erb_offset];
1368         tmplen = min(erbsz, drv_buf_iter->bsg_buf_len);
1369         memcpy(drv_buf_iter->bsg_buf, sense_buff_k, tmplen);
1370     }
1371 
1372     drv_buf_iter = drv_bufs;
1373     for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
1374         if (drv_buf_iter->data_dir == DMA_NONE)
1375             continue;
1376         if (drv_buf_iter->data_dir == DMA_FROM_DEVICE) {
1377             tmplen = min(drv_buf_iter->kern_buf_len,
1378                      drv_buf_iter->bsg_buf_len);
1379             memcpy(drv_buf_iter->bsg_buf,
1380                    drv_buf_iter->kern_buf, tmplen);
1381         }
1382     }
1383 
1384 out_unlock:
1385     if (din_buf) {
1386         *reply_payload_rcv_len =
1387             sg_copy_from_buffer(job->reply_payload.sg_list,
1388                         job->reply_payload.sg_cnt,
1389                         din_buf, job->reply_payload.payload_len);
1390     }
1391     mrioc->bsg_cmds.is_sense = 0;
1392     mrioc->bsg_cmds.sensebuf = NULL;
1393     mrioc->bsg_cmds.state = MPI3MR_CMD_NOTUSED;
1394     mutex_unlock(&mrioc->bsg_cmds.mutex);
1395 out:
1396     kfree(sense_buff_k);
1397     kfree(dout_buf);
1398     kfree(din_buf);
1399     kfree(mpi_req);
1400     if (drv_bufs) {
1401         drv_buf_iter = drv_bufs;
1402         for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
1403             if (drv_buf_iter->kern_buf && drv_buf_iter->kern_buf_dma)
1404                 dma_free_coherent(&mrioc->pdev->dev,
1405                     drv_buf_iter->kern_buf_len,
1406                     drv_buf_iter->kern_buf,
1407                     drv_buf_iter->kern_buf_dma);
1408         }
1409         kfree(drv_bufs);
1410     }
1411     kfree(bsg_reply_buf);
1412     return rval;
1413 }
1414 
1415 /**
1416  * mpi3mr_app_save_logdata - Save Log Data events
1417  * @mrioc: Adapter instance reference
1418  * @event_data: event data associated with log data event
1419  * @event_data_size: event data size to copy
1420  *
1421  * If log data event caching is enabled by the applicatiobns,
1422  * then this function saves the log data in the circular queue
1423  * and Sends async signal SIGIO to indicate there is an async
1424  * event from the firmware to the event monitoring applications.
1425  *
1426  * Return:Nothing
1427  */
1428 void mpi3mr_app_save_logdata(struct mpi3mr_ioc *mrioc, char *event_data,
1429     u16 event_data_size)
1430 {
1431     u32 index = mrioc->logdata_buf_idx, sz;
1432     struct mpi3mr_logdata_entry *entry;
1433 
1434     if (!(mrioc->logdata_buf))
1435         return;
1436 
1437     entry = (struct mpi3mr_logdata_entry *)
1438         (mrioc->logdata_buf + (index * mrioc->logdata_entry_sz));
1439     entry->valid_entry = 1;
1440     sz = min(mrioc->logdata_entry_sz, event_data_size);
1441     memcpy(entry->data, event_data, sz);
1442     mrioc->logdata_buf_idx =
1443         ((++index) % MPI3MR_BSG_LOGDATA_MAX_ENTRIES);
1444     atomic64_inc(&event_counter);
1445 }
1446 
1447 /**
1448  * mpi3mr_bsg_request - bsg request entry point
1449  * @job: BSG job reference
1450  *
1451  * This is driver's entry point for bsg requests
1452  *
1453  * Return: 0 on success and proper error codes on failure
1454  */
1455 static int mpi3mr_bsg_request(struct bsg_job *job)
1456 {
1457     long rval = -EINVAL;
1458     unsigned int reply_payload_rcv_len = 0;
1459 
1460     struct mpi3mr_bsg_packet *bsg_req = job->request;
1461 
1462     switch (bsg_req->cmd_type) {
1463     case MPI3MR_DRV_CMD:
1464         rval = mpi3mr_bsg_process_drv_cmds(job);
1465         break;
1466     case MPI3MR_MPT_CMD:
1467         rval = mpi3mr_bsg_process_mpt_cmds(job, &reply_payload_rcv_len);
1468         break;
1469     default:
1470         pr_err("%s: unsupported BSG command(0x%08x)\n",
1471             MPI3MR_DRIVER_NAME, bsg_req->cmd_type);
1472         break;
1473     }
1474 
1475     bsg_job_done(job, rval, reply_payload_rcv_len);
1476 
1477     return 0;
1478 }
1479 
1480 /**
1481  * mpi3mr_bsg_exit - de-registration from bsg layer
1482  *
1483  * This will be called during driver unload and all
1484  * bsg resources allocated during load will be freed.
1485  *
1486  * Return:Nothing
1487  */
1488 void mpi3mr_bsg_exit(struct mpi3mr_ioc *mrioc)
1489 {
1490     struct device *bsg_dev = &mrioc->bsg_dev;
1491     if (!mrioc->bsg_queue)
1492         return;
1493 
1494     bsg_remove_queue(mrioc->bsg_queue);
1495     mrioc->bsg_queue = NULL;
1496 
1497     device_del(bsg_dev);
1498     put_device(bsg_dev);
1499 }
1500 
1501 /**
1502  * mpi3mr_bsg_node_release -release bsg device node
1503  * @dev: bsg device node
1504  *
1505  * decrements bsg dev parent reference count
1506  *
1507  * Return:Nothing
1508  */
1509 static void mpi3mr_bsg_node_release(struct device *dev)
1510 {
1511     put_device(dev->parent);
1512 }
1513 
1514 /**
1515  * mpi3mr_bsg_init -  registration with bsg layer
1516  *
1517  * This will be called during driver load and it will
1518  * register driver with bsg layer
1519  *
1520  * Return:Nothing
1521  */
1522 void mpi3mr_bsg_init(struct mpi3mr_ioc *mrioc)
1523 {
1524     struct device *bsg_dev = &mrioc->bsg_dev;
1525     struct device *parent = &mrioc->shost->shost_gendev;
1526 
1527     device_initialize(bsg_dev);
1528 
1529     bsg_dev->parent = get_device(parent);
1530     bsg_dev->release = mpi3mr_bsg_node_release;
1531 
1532     dev_set_name(bsg_dev, "mpi3mrctl%u", mrioc->id);
1533 
1534     if (device_add(bsg_dev)) {
1535         ioc_err(mrioc, "%s: bsg device add failed\n",
1536             dev_name(bsg_dev));
1537         put_device(bsg_dev);
1538         return;
1539     }
1540 
1541     mrioc->bsg_queue = bsg_setup_queue(bsg_dev, dev_name(bsg_dev),
1542             mpi3mr_bsg_request, NULL, 0);
1543     if (IS_ERR(mrioc->bsg_queue)) {
1544         ioc_err(mrioc, "%s: bsg registration failed\n",
1545             dev_name(bsg_dev));
1546         device_del(bsg_dev);
1547         put_device(bsg_dev);
1548         return;
1549     }
1550 
1551     blk_queue_max_segments(mrioc->bsg_queue, MPI3MR_MAX_APP_XFER_SEGMENTS);
1552     blk_queue_max_hw_sectors(mrioc->bsg_queue, MPI3MR_MAX_APP_XFER_SECTORS);
1553 
1554     return;
1555 }
1556 
1557 /**
1558  * version_fw_show - SysFS callback for firmware version read
1559  * @dev: class device
1560  * @attr: Device attributes
1561  * @buf: Buffer to copy
1562  *
1563  * Return: sysfs_emit() return after copying firmware version
1564  */
1565 static ssize_t
1566 version_fw_show(struct device *dev, struct device_attribute *attr,
1567     char *buf)
1568 {
1569     struct Scsi_Host *shost = class_to_shost(dev);
1570     struct mpi3mr_ioc *mrioc = shost_priv(shost);
1571     struct mpi3mr_compimg_ver *fwver = &mrioc->facts.fw_ver;
1572 
1573     return sysfs_emit(buf, "%d.%d.%d.%d.%05d-%05d\n",
1574         fwver->gen_major, fwver->gen_minor, fwver->ph_major,
1575         fwver->ph_minor, fwver->cust_id, fwver->build_num);
1576 }
1577 static DEVICE_ATTR_RO(version_fw);
1578 
1579 /**
1580  * fw_queue_depth_show - SysFS callback for firmware max cmds
1581  * @dev: class device
1582  * @attr: Device attributes
1583  * @buf: Buffer to copy
1584  *
1585  * Return: sysfs_emit() return after copying firmware max commands
1586  */
1587 static ssize_t
1588 fw_queue_depth_show(struct device *dev, struct device_attribute *attr,
1589             char *buf)
1590 {
1591     struct Scsi_Host *shost = class_to_shost(dev);
1592     struct mpi3mr_ioc *mrioc = shost_priv(shost);
1593 
1594     return sysfs_emit(buf, "%d\n", mrioc->facts.max_reqs);
1595 }
1596 static DEVICE_ATTR_RO(fw_queue_depth);
1597 
1598 /**
1599  * op_req_q_count_show - SysFS callback for request queue count
1600  * @dev: class device
1601  * @attr: Device attributes
1602  * @buf: Buffer to copy
1603  *
1604  * Return: sysfs_emit() return after copying request queue count
1605  */
1606 static ssize_t
1607 op_req_q_count_show(struct device *dev, struct device_attribute *attr,
1608             char *buf)
1609 {
1610     struct Scsi_Host *shost = class_to_shost(dev);
1611     struct mpi3mr_ioc *mrioc = shost_priv(shost);
1612 
1613     return sysfs_emit(buf, "%d\n", mrioc->num_op_req_q);
1614 }
1615 static DEVICE_ATTR_RO(op_req_q_count);
1616 
1617 /**
1618  * reply_queue_count_show - SysFS callback for reply queue count
1619  * @dev: class device
1620  * @attr: Device attributes
1621  * @buf: Buffer to copy
1622  *
1623  * Return: sysfs_emit() return after copying reply queue count
1624  */
1625 static ssize_t
1626 reply_queue_count_show(struct device *dev, struct device_attribute *attr,
1627             char *buf)
1628 {
1629     struct Scsi_Host *shost = class_to_shost(dev);
1630     struct mpi3mr_ioc *mrioc = shost_priv(shost);
1631 
1632     return sysfs_emit(buf, "%d\n", mrioc->num_op_reply_q);
1633 }
1634 
1635 static DEVICE_ATTR_RO(reply_queue_count);
1636 
1637 /**
1638  * logging_level_show - Show controller debug level
1639  * @dev: class device
1640  * @attr: Device attributes
1641  * @buf: Buffer to copy
1642  *
1643  * A sysfs 'read/write' shost attribute, to show the current
1644  * debug log level used by the driver for the specific
1645  * controller.
1646  *
1647  * Return: sysfs_emit() return
1648  */
1649 static ssize_t
1650 logging_level_show(struct device *dev,
1651     struct device_attribute *attr, char *buf)
1652 
1653 {
1654     struct Scsi_Host *shost = class_to_shost(dev);
1655     struct mpi3mr_ioc *mrioc = shost_priv(shost);
1656 
1657     return sysfs_emit(buf, "%08xh\n", mrioc->logging_level);
1658 }
1659 
1660 /**
1661  * logging_level_store- Change controller debug level
1662  * @dev: class device
1663  * @attr: Device attributes
1664  * @buf: Buffer to copy
1665  * @count: size of the buffer
1666  *
1667  * A sysfs 'read/write' shost attribute, to change the current
1668  * debug log level used by the driver for the specific
1669  * controller.
1670  *
1671  * Return: strlen() return
1672  */
1673 static ssize_t
1674 logging_level_store(struct device *dev,
1675     struct device_attribute *attr,
1676     const char *buf, size_t count)
1677 {
1678     struct Scsi_Host *shost = class_to_shost(dev);
1679     struct mpi3mr_ioc *mrioc = shost_priv(shost);
1680     int val = 0;
1681 
1682     if (kstrtoint(buf, 0, &val) != 0)
1683         return -EINVAL;
1684 
1685     mrioc->logging_level = val;
1686     ioc_info(mrioc, "logging_level=%08xh\n", mrioc->logging_level);
1687     return strlen(buf);
1688 }
1689 static DEVICE_ATTR_RW(logging_level);
1690 
1691 /**
1692  * adp_state_show() - SysFS callback for adapter state show
1693  * @dev: class device
1694  * @attr: Device attributes
1695  * @buf: Buffer to copy
1696  *
1697  * Return: sysfs_emit() return after copying adapter state
1698  */
1699 static ssize_t
1700 adp_state_show(struct device *dev, struct device_attribute *attr,
1701     char *buf)
1702 {
1703     struct Scsi_Host *shost = class_to_shost(dev);
1704     struct mpi3mr_ioc *mrioc = shost_priv(shost);
1705     enum mpi3mr_iocstate ioc_state;
1706     uint8_t adp_state;
1707 
1708     ioc_state = mpi3mr_get_iocstate(mrioc);
1709     if (ioc_state == MRIOC_STATE_UNRECOVERABLE)
1710         adp_state = MPI3MR_BSG_ADPSTATE_UNRECOVERABLE;
1711     else if ((mrioc->reset_in_progress) || (mrioc->stop_bsgs))
1712         adp_state = MPI3MR_BSG_ADPSTATE_IN_RESET;
1713     else if (ioc_state == MRIOC_STATE_FAULT)
1714         adp_state = MPI3MR_BSG_ADPSTATE_FAULT;
1715     else
1716         adp_state = MPI3MR_BSG_ADPSTATE_OPERATIONAL;
1717 
1718     return sysfs_emit(buf, "%u\n", adp_state);
1719 }
1720 
1721 static DEVICE_ATTR_RO(adp_state);
1722 
1723 static struct attribute *mpi3mr_host_attrs[] = {
1724     &dev_attr_version_fw.attr,
1725     &dev_attr_fw_queue_depth.attr,
1726     &dev_attr_op_req_q_count.attr,
1727     &dev_attr_reply_queue_count.attr,
1728     &dev_attr_logging_level.attr,
1729     &dev_attr_adp_state.attr,
1730     NULL,
1731 };
1732 
1733 static const struct attribute_group mpi3mr_host_attr_group = {
1734     .attrs = mpi3mr_host_attrs
1735 };
1736 
1737 const struct attribute_group *mpi3mr_host_groups[] = {
1738     &mpi3mr_host_attr_group,
1739     NULL,
1740 };
1741 
1742 
1743 /*
1744  * SCSI Device attributes under sysfs
1745  */
1746 
1747 /**
1748  * sas_address_show - SysFS callback for dev SASaddress display
1749  * @dev: class device
1750  * @attr: Device attributes
1751  * @buf: Buffer to copy
1752  *
1753  * Return: sysfs_emit() return after copying SAS address of the
1754  * specific SAS/SATA end device.
1755  */
1756 static ssize_t
1757 sas_address_show(struct device *dev, struct device_attribute *attr,
1758             char *buf)
1759 {
1760     struct scsi_device *sdev = to_scsi_device(dev);
1761     struct mpi3mr_sdev_priv_data *sdev_priv_data;
1762     struct mpi3mr_stgt_priv_data *tgt_priv_data;
1763     struct mpi3mr_tgt_dev *tgtdev;
1764 
1765     sdev_priv_data = sdev->hostdata;
1766     if (!sdev_priv_data)
1767         return 0;
1768 
1769     tgt_priv_data = sdev_priv_data->tgt_priv_data;
1770     if (!tgt_priv_data)
1771         return 0;
1772     tgtdev = tgt_priv_data->tgt_dev;
1773     if (!tgtdev || tgtdev->dev_type != MPI3_DEVICE_DEVFORM_SAS_SATA)
1774         return 0;
1775     return sysfs_emit(buf, "0x%016llx\n",
1776         (unsigned long long)tgtdev->dev_spec.sas_sata_inf.sas_address);
1777 }
1778 
1779 static DEVICE_ATTR_RO(sas_address);
1780 
1781 /**
1782  * device_handle_show - SysFS callback for device handle display
1783  * @dev: class device
1784  * @attr: Device attributes
1785  * @buf: Buffer to copy
1786  *
1787  * Return: sysfs_emit() return after copying firmware internal
1788  * device handle of the specific device.
1789  */
1790 static ssize_t
1791 device_handle_show(struct device *dev, struct device_attribute *attr,
1792             char *buf)
1793 {
1794     struct scsi_device *sdev = to_scsi_device(dev);
1795     struct mpi3mr_sdev_priv_data *sdev_priv_data;
1796     struct mpi3mr_stgt_priv_data *tgt_priv_data;
1797     struct mpi3mr_tgt_dev *tgtdev;
1798 
1799     sdev_priv_data = sdev->hostdata;
1800     if (!sdev_priv_data)
1801         return 0;
1802 
1803     tgt_priv_data = sdev_priv_data->tgt_priv_data;
1804     if (!tgt_priv_data)
1805         return 0;
1806     tgtdev = tgt_priv_data->tgt_dev;
1807     if (!tgtdev)
1808         return 0;
1809     return sysfs_emit(buf, "0x%04x\n", tgtdev->dev_handle);
1810 }
1811 
1812 static DEVICE_ATTR_RO(device_handle);
1813 
1814 /**
1815  * persistent_id_show - SysFS callback for persisten ID display
1816  * @dev: class device
1817  * @attr: Device attributes
1818  * @buf: Buffer to copy
1819  *
1820  * Return: sysfs_emit() return after copying persistent ID of the
1821  * of the specific device.
1822  */
1823 static ssize_t
1824 persistent_id_show(struct device *dev, struct device_attribute *attr,
1825             char *buf)
1826 {
1827     struct scsi_device *sdev = to_scsi_device(dev);
1828     struct mpi3mr_sdev_priv_data *sdev_priv_data;
1829     struct mpi3mr_stgt_priv_data *tgt_priv_data;
1830     struct mpi3mr_tgt_dev *tgtdev;
1831 
1832     sdev_priv_data = sdev->hostdata;
1833     if (!sdev_priv_data)
1834         return 0;
1835 
1836     tgt_priv_data = sdev_priv_data->tgt_priv_data;
1837     if (!tgt_priv_data)
1838         return 0;
1839     tgtdev = tgt_priv_data->tgt_dev;
1840     if (!tgtdev)
1841         return 0;
1842     return sysfs_emit(buf, "%d\n", tgtdev->perst_id);
1843 }
1844 static DEVICE_ATTR_RO(persistent_id);
1845 
1846 static struct attribute *mpi3mr_dev_attrs[] = {
1847     &dev_attr_sas_address.attr,
1848     &dev_attr_device_handle.attr,
1849     &dev_attr_persistent_id.attr,
1850     NULL,
1851 };
1852 
1853 static const struct attribute_group mpi3mr_dev_attr_group = {
1854     .attrs = mpi3mr_dev_attrs
1855 };
1856 
1857 const struct attribute_group *mpi3mr_dev_groups[] = {
1858     &mpi3mr_dev_attr_group,
1859     NULL,
1860 };
[ 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!