1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * Driver for Broadcom MPI3 Storage Controllers 4 * 5 * Copyright (C) 2017-2023 Broadcom Inc. 6 * (mailto: mpi3mr-linuxdrv.pdl@broadcom.com) 7 * 8 */ 9 10#include "mpi3mr.h" 11#include <linux/bsg-lib.h> 12#include <uapi/scsi/scsi_bsg_mpi3mr.h> 13 14/** 15 * mpi3mr_bsg_pel_abort - sends PEL abort request 16 * @mrioc: Adapter instance reference 17 * 18 * This function sends PEL abort request to the firmware through 19 * admin request queue. 20 * 21 * Return: 0 on success, -1 on failure 22 */ 23static int mpi3mr_bsg_pel_abort(struct mpi3mr_ioc *mrioc) 24{ 25 struct mpi3_pel_req_action_abort pel_abort_req; 26 struct mpi3_pel_reply *pel_reply; 27 int retval = 0; 28 u16 pe_log_status; 29 30 if (mrioc->reset_in_progress) { 31 dprint_bsg_err(mrioc, "%s: reset in progress\n", __func__); 32 return -1; 33 } 34 if (mrioc->stop_bsgs) { 35 dprint_bsg_err(mrioc, "%s: bsgs are blocked\n", __func__); 36 return -1; 37 } 38 39 memset(&pel_abort_req, 0, sizeof(pel_abort_req)); 40 mutex_lock(&mrioc->pel_abort_cmd.mutex); 41 if (mrioc->pel_abort_cmd.state & MPI3MR_CMD_PENDING) { 42 dprint_bsg_err(mrioc, "%s: command is in use\n", __func__); 43 mutex_unlock(&mrioc->pel_abort_cmd.mutex); 44 return -1; 45 } 46 mrioc->pel_abort_cmd.state = MPI3MR_CMD_PENDING; 47 mrioc->pel_abort_cmd.is_waiting = 1; 48 mrioc->pel_abort_cmd.callback = NULL; 49 pel_abort_req.host_tag = cpu_to_le16(MPI3MR_HOSTTAG_PEL_ABORT); 50 pel_abort_req.function = MPI3_FUNCTION_PERSISTENT_EVENT_LOG; 51 pel_abort_req.action = MPI3_PEL_ACTION_ABORT; 52 pel_abort_req.abort_host_tag = cpu_to_le16(MPI3MR_HOSTTAG_PEL_WAIT); 53 54 mrioc->pel_abort_requested = 1; 55 init_completion(&mrioc->pel_abort_cmd.done); 56 retval = mpi3mr_admin_request_post(mrioc, &pel_abort_req, 57 sizeof(pel_abort_req), 0); 58 if (retval) { 59 retval = -1; 60 dprint_bsg_err(mrioc, "%s: admin request post failed\n", 61 __func__); 62 mrioc->pel_abort_requested = 0; 63 goto out_unlock; 64 } 65 66 wait_for_completion_timeout(&mrioc->pel_abort_cmd.done, 67 (MPI3MR_INTADMCMD_TIMEOUT * HZ)); 68 if (!(mrioc->pel_abort_cmd.state & MPI3MR_CMD_COMPLETE)) { 69 mrioc->pel_abort_cmd.is_waiting = 0; 70 dprint_bsg_err(mrioc, "%s: command timedout\n", __func__); 71 if (!(mrioc->pel_abort_cmd.state & MPI3MR_CMD_RESET)) 72 mpi3mr_soft_reset_handler(mrioc, 73 MPI3MR_RESET_FROM_PELABORT_TIMEOUT, 1); 74 retval = -1; 75 goto out_unlock; 76 } 77 if ((mrioc->pel_abort_cmd.ioc_status & MPI3_IOCSTATUS_STATUS_MASK) 78 != MPI3_IOCSTATUS_SUCCESS) { 79 dprint_bsg_err(mrioc, 80 "%s: command failed, ioc_status(0x%04x) log_info(0x%08x)\n", 81 __func__, (mrioc->pel_abort_cmd.ioc_status & 82 MPI3_IOCSTATUS_STATUS_MASK), 83 mrioc->pel_abort_cmd.ioc_loginfo); 84 retval = -1; 85 goto out_unlock; 86 } 87 if (mrioc->pel_abort_cmd.state & MPI3MR_CMD_REPLY_VALID) { 88 pel_reply = (struct mpi3_pel_reply *)mrioc->pel_abort_cmd.reply; 89 pe_log_status = le16_to_cpu(pel_reply->pe_log_status); 90 if (pe_log_status != MPI3_PEL_STATUS_SUCCESS) { 91 dprint_bsg_err(mrioc, 92 "%s: command failed, pel_status(0x%04x)\n", 93 __func__, pe_log_status); 94 retval = -1; 95 } 96 } 97 98out_unlock: 99 mrioc->pel_abort_cmd.state = MPI3MR_CMD_NOTUSED; 100 mutex_unlock(&mrioc->pel_abort_cmd.mutex); 101 return retval; 102} 103/** 104 * mpi3mr_bsg_verify_adapter - verify adapter number is valid 105 * @ioc_number: Adapter number 106 * 107 * This function returns the adapter instance pointer of given 108 * adapter number. If adapter number does not match with the 109 * driver's adapter list, driver returns NULL. 110 * 111 * Return: adapter instance reference 112 */ 113static struct mpi3mr_ioc *mpi3mr_bsg_verify_adapter(int ioc_number) 114{ 115 struct mpi3mr_ioc *mrioc = NULL; 116 117 spin_lock(&mrioc_list_lock); 118 list_for_each_entry(mrioc, &mrioc_list, list) { 119 if (mrioc->id == ioc_number) { 120 spin_unlock(&mrioc_list_lock); 121 return mrioc; 122 } 123 } 124 spin_unlock(&mrioc_list_lock); 125 return NULL; 126} 127 128/** 129 * mpi3mr_enable_logdata - Handler for log data enable 130 * @mrioc: Adapter instance reference 131 * @job: BSG job reference 132 * 133 * This function enables log data caching in the driver if not 134 * already enabled and return the maximum number of log data 135 * entries that can be cached in the driver. 136 * 137 * Return: 0 on success and proper error codes on failure 138 */ 139static long mpi3mr_enable_logdata(struct mpi3mr_ioc *mrioc, 140 struct bsg_job *job) 141{ 142 struct mpi3mr_logdata_enable logdata_enable; 143 144 if (!mrioc->logdata_buf) { 145 mrioc->logdata_entry_sz = 146 (mrioc->reply_sz - (sizeof(struct mpi3_event_notification_reply) - 4)) 147 + MPI3MR_BSG_LOGDATA_ENTRY_HEADER_SZ; 148 mrioc->logdata_buf_idx = 0; 149 mrioc->logdata_buf = kcalloc(MPI3MR_BSG_LOGDATA_MAX_ENTRIES, 150 mrioc->logdata_entry_sz, GFP_KERNEL); 151 152 if (!mrioc->logdata_buf) 153 return -ENOMEM; 154 } 155 156 memset(&logdata_enable, 0, sizeof(logdata_enable)); 157 logdata_enable.max_entries = 158 MPI3MR_BSG_LOGDATA_MAX_ENTRIES; 159 if (job->request_payload.payload_len >= sizeof(logdata_enable)) { 160 sg_copy_from_buffer(job->request_payload.sg_list, 161 job->request_payload.sg_cnt, 162 &logdata_enable, sizeof(logdata_enable)); 163 return 0; 164 } 165 166 return -EINVAL; 167} 168/** 169 * mpi3mr_get_logdata - Handler for get log data 170 * @mrioc: Adapter instance reference 171 * @job: BSG job pointer 172 * This function copies the log data entries to the user buffer 173 * when log caching is enabled in the driver. 174 * 175 * Return: 0 on success and proper error codes on failure 176 */ 177static long mpi3mr_get_logdata(struct mpi3mr_ioc *mrioc, 178 struct bsg_job *job) 179{ 180 u16 num_entries, sz, entry_sz = mrioc->logdata_entry_sz; 181 182 if ((!mrioc->logdata_buf) || (job->request_payload.payload_len < entry_sz)) 183 return -EINVAL; 184 185 num_entries = job->request_payload.payload_len / entry_sz; 186 if (num_entries > MPI3MR_BSG_LOGDATA_MAX_ENTRIES) 187 num_entries = MPI3MR_BSG_LOGDATA_MAX_ENTRIES; 188 sz = num_entries * entry_sz; 189 190 if (job->request_payload.payload_len >= sz) { 191 sg_copy_from_buffer(job->request_payload.sg_list, 192 job->request_payload.sg_cnt, 193 mrioc->logdata_buf, sz); 194 return 0; 195 } 196 return -EINVAL; 197} 198 199/** 200 * mpi3mr_bsg_pel_enable - Handler for PEL enable driver 201 * @mrioc: Adapter instance reference 202 * @job: BSG job pointer 203 * 204 * This function is the handler for PEL enable driver. 205 * Validates the application given class and locale and if 206 * requires aborts the existing PEL wait request and/or issues 207 * new PEL wait request to the firmware and returns. 208 * 209 * Return: 0 on success and proper error codes on failure. 210 */ 211static long mpi3mr_bsg_pel_enable(struct mpi3mr_ioc *mrioc, 212 struct bsg_job *job) 213{ 214 long rval = -EINVAL; 215 struct mpi3mr_bsg_out_pel_enable pel_enable; 216 u8 issue_pel_wait; 217 u8 tmp_class; 218 u16 tmp_locale; 219 220 if (job->request_payload.payload_len != sizeof(pel_enable)) { 221 dprint_bsg_err(mrioc, "%s: invalid size argument\n", 222 __func__); 223 return rval; 224 } 225 226 if (mrioc->unrecoverable) { 227 dprint_bsg_err(mrioc, "%s: unrecoverable controller\n", 228 __func__); 229 return -EFAULT; 230 } 231 232 if (mrioc->reset_in_progress) { 233 dprint_bsg_err(mrioc, "%s: reset in progress\n", __func__); 234 return -EAGAIN; 235 } 236 237 if (mrioc->stop_bsgs) { 238 dprint_bsg_err(mrioc, "%s: bsgs are blocked\n", __func__); 239 return -EAGAIN; 240 } 241 242 sg_copy_to_buffer(job->request_payload.sg_list, 243 job->request_payload.sg_cnt, 244 &pel_enable, sizeof(pel_enable)); 245 246 if (pel_enable.pel_class > MPI3_PEL_CLASS_FAULT) { 247 dprint_bsg_err(mrioc, "%s: out of range class %d sent\n", 248 __func__, pel_enable.pel_class); 249 rval = 0; 250 goto out; 251 } 252 if (!mrioc->pel_enabled) 253 issue_pel_wait = 1; 254 else { 255 if ((mrioc->pel_class <= pel_enable.pel_class) && 256 !((mrioc->pel_locale & pel_enable.pel_locale) ^ 257 pel_enable.pel_locale)) { 258 issue_pel_wait = 0; 259 rval = 0; 260 } else { 261 pel_enable.pel_locale |= mrioc->pel_locale; 262 263 if (mrioc->pel_class < pel_enable.pel_class) 264 pel_enable.pel_class = mrioc->pel_class; 265 266 rval = mpi3mr_bsg_pel_abort(mrioc); 267 if (rval) { 268 dprint_bsg_err(mrioc, 269 "%s: pel_abort failed, status(%ld)\n", 270 __func__, rval); 271 goto out; 272 } 273 issue_pel_wait = 1; 274 } 275 } 276 if (issue_pel_wait) { 277 tmp_class = mrioc->pel_class; 278 tmp_locale = mrioc->pel_locale; 279 mrioc->pel_class = pel_enable.pel_class; 280 mrioc->pel_locale = pel_enable.pel_locale; 281 mrioc->pel_enabled = 1; 282 rval = mpi3mr_pel_get_seqnum_post(mrioc, NULL); 283 if (rval) { 284 mrioc->pel_class = tmp_class; 285 mrioc->pel_locale = tmp_locale; 286 mrioc->pel_enabled = 0; 287 dprint_bsg_err(mrioc, 288 "%s: pel get sequence number failed, status(%ld)\n", 289 __func__, rval); 290 } 291 } 292 293out: 294 return rval; 295} 296/** 297 * mpi3mr_get_all_tgt_info - Get all target information 298 * @mrioc: Adapter instance reference 299 * @job: BSG job reference 300 * 301 * This function copies the driver managed target devices device 302 * handle, persistent ID, bus ID and taret ID to the user 303 * provided buffer for the specific controller. This function 304 * also provides the number of devices managed by the driver for 305 * the specific controller. 306 * 307 * Return: 0 on success and proper error codes on failure 308 */ 309static long mpi3mr_get_all_tgt_info(struct mpi3mr_ioc *mrioc, 310 struct bsg_job *job) 311{ 312 u16 num_devices = 0, i = 0, size; 313 unsigned long flags; 314 struct mpi3mr_tgt_dev *tgtdev; 315 struct mpi3mr_device_map_info *devmap_info = NULL; 316 struct mpi3mr_all_tgt_info *alltgt_info = NULL; 317 uint32_t min_entrylen = 0, kern_entrylen = 0, usr_entrylen = 0; 318 319 if (job->request_payload.payload_len < sizeof(u32)) { 320 dprint_bsg_err(mrioc, "%s: invalid size argument\n", 321 __func__); 322 return -EINVAL; 323 } 324 325 spin_lock_irqsave(&mrioc->tgtdev_lock, flags); 326 list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list) 327 num_devices++; 328 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags); 329 330 if ((job->request_payload.payload_len <= sizeof(u64)) || 331 list_empty(&mrioc->tgtdev_list)) { 332 sg_copy_from_buffer(job->request_payload.sg_list, 333 job->request_payload.sg_cnt, 334 &num_devices, sizeof(num_devices)); 335 return 0; 336 } 337 338 kern_entrylen = num_devices * sizeof(*devmap_info); 339 size = sizeof(u64) + kern_entrylen; 340 alltgt_info = kzalloc(size, GFP_KERNEL); 341 if (!alltgt_info) 342 return -ENOMEM; 343 344 devmap_info = alltgt_info->dmi; 345 memset((u8 *)devmap_info, 0xFF, kern_entrylen); 346 spin_lock_irqsave(&mrioc->tgtdev_lock, flags); 347 list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list) { 348 if (i < num_devices) { 349 devmap_info[i].handle = tgtdev->dev_handle; 350 devmap_info[i].perst_id = tgtdev->perst_id; 351 if (tgtdev->host_exposed && tgtdev->starget) { 352 devmap_info[i].target_id = tgtdev->starget->id; 353 devmap_info[i].bus_id = 354 tgtdev->starget->channel; 355 } 356 i++; 357 } 358 } 359 num_devices = i; 360 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags); 361 362 alltgt_info->num_devices = num_devices; 363 364 usr_entrylen = (job->request_payload.payload_len - sizeof(u64)) / 365 sizeof(*devmap_info); 366 usr_entrylen *= sizeof(*devmap_info); 367 min_entrylen = min(usr_entrylen, kern_entrylen); 368 369 sg_copy_from_buffer(job->request_payload.sg_list, 370 job->request_payload.sg_cnt, 371 alltgt_info, (min_entrylen + sizeof(u64))); 372 kfree(alltgt_info); 373 return 0; 374} 375/** 376 * mpi3mr_get_change_count - Get topology change count 377 * @mrioc: Adapter instance reference 378 * @job: BSG job reference 379 * 380 * This function copies the toplogy change count provided by the 381 * driver in events and cached in the driver to the user 382 * provided buffer for the specific controller. 383 * 384 * Return: 0 on success and proper error codes on failure 385 */ 386static long mpi3mr_get_change_count(struct mpi3mr_ioc *mrioc, 387 struct bsg_job *job) 388{ 389 struct mpi3mr_change_count chgcnt; 390 391 memset(&chgcnt, 0, sizeof(chgcnt)); 392 chgcnt.change_count = mrioc->change_count; 393 if (job->request_payload.payload_len >= sizeof(chgcnt)) { 394 sg_copy_from_buffer(job->request_payload.sg_list, 395 job->request_payload.sg_cnt, 396 &chgcnt, sizeof(chgcnt)); 397 return 0; 398 } 399 return -EINVAL; 400} 401 402/** 403 * mpi3mr_bsg_adp_reset - Issue controller reset 404 * @mrioc: Adapter instance reference 405 * @job: BSG job reference 406 * 407 * This function identifies the user provided reset type and 408 * issues approporiate reset to the controller and wait for that 409 * to complete and reinitialize the controller and then returns 410 * 411 * Return: 0 on success and proper error codes on failure 412 */ 413static long mpi3mr_bsg_adp_reset(struct mpi3mr_ioc *mrioc, 414 struct bsg_job *job) 415{ 416 long rval = -EINVAL; 417 u8 save_snapdump; 418 struct mpi3mr_bsg_adp_reset adpreset; 419 420 if (job->request_payload.payload_len != 421 sizeof(adpreset)) { 422 dprint_bsg_err(mrioc, "%s: invalid size argument\n", 423 __func__); 424 goto out; 425 } 426 427 sg_copy_to_buffer(job->request_payload.sg_list, 428 job->request_payload.sg_cnt, 429 &adpreset, sizeof(adpreset)); 430 431 switch (adpreset.reset_type) { 432 case MPI3MR_BSG_ADPRESET_SOFT: 433 save_snapdump = 0; 434 break; 435 case MPI3MR_BSG_ADPRESET_DIAG_FAULT: 436 save_snapdump = 1; 437 break; 438 default: 439 dprint_bsg_err(mrioc, "%s: unknown reset_type(%d)\n", 440 __func__, adpreset.reset_type); 441 goto out; 442 } 443 444 rval = mpi3mr_soft_reset_handler(mrioc, MPI3MR_RESET_FROM_APP, 445 save_snapdump); 446 447 if (rval) 448 dprint_bsg_err(mrioc, 449 "%s: reset handler returned error(%ld) for reset type %d\n", 450 __func__, rval, adpreset.reset_type); 451out: 452 return rval; 453} 454 455/** 456 * mpi3mr_bsg_populate_adpinfo - Get adapter info command handler 457 * @mrioc: Adapter instance reference 458 * @job: BSG job reference 459 * 460 * This function provides adapter information for the given 461 * controller 462 * 463 * Return: 0 on success and proper error codes on failure 464 */ 465static long mpi3mr_bsg_populate_adpinfo(struct mpi3mr_ioc *mrioc, 466 struct bsg_job *job) 467{ 468 enum mpi3mr_iocstate ioc_state; 469 struct mpi3mr_bsg_in_adpinfo adpinfo; 470 471 memset(&adpinfo, 0, sizeof(adpinfo)); 472 adpinfo.adp_type = MPI3MR_BSG_ADPTYPE_AVGFAMILY; 473 adpinfo.pci_dev_id = mrioc->pdev->device; 474 adpinfo.pci_dev_hw_rev = mrioc->pdev->revision; 475 adpinfo.pci_subsys_dev_id = mrioc->pdev->subsystem_device; 476 adpinfo.pci_subsys_ven_id = mrioc->pdev->subsystem_vendor; 477 adpinfo.pci_bus = mrioc->pdev->bus->number; 478 adpinfo.pci_dev = PCI_SLOT(mrioc->pdev->devfn); 479 adpinfo.pci_func = PCI_FUNC(mrioc->pdev->devfn); 480 adpinfo.pci_seg_id = pci_domain_nr(mrioc->pdev->bus); 481 adpinfo.app_intfc_ver = MPI3MR_IOCTL_VERSION; 482 483 ioc_state = mpi3mr_get_iocstate(mrioc); 484 if (ioc_state == MRIOC_STATE_UNRECOVERABLE) 485 adpinfo.adp_state = MPI3MR_BSG_ADPSTATE_UNRECOVERABLE; 486 else if ((mrioc->reset_in_progress) || (mrioc->stop_bsgs)) 487 adpinfo.adp_state = MPI3MR_BSG_ADPSTATE_IN_RESET; 488 else if (ioc_state == MRIOC_STATE_FAULT) 489 adpinfo.adp_state = MPI3MR_BSG_ADPSTATE_FAULT; 490 else 491 adpinfo.adp_state = MPI3MR_BSG_ADPSTATE_OPERATIONAL; 492 493 memcpy((u8 *)&adpinfo.driver_info, (u8 *)&mrioc->driver_info, 494 sizeof(adpinfo.driver_info)); 495 496 if (job->request_payload.payload_len >= sizeof(adpinfo)) { 497 sg_copy_from_buffer(job->request_payload.sg_list, 498 job->request_payload.sg_cnt, 499 &adpinfo, sizeof(adpinfo)); 500 return 0; 501 } 502 return -EINVAL; 503} 504 505/** 506 * mpi3mr_bsg_process_drv_cmds - Driver Command handler 507 * @job: BSG job reference 508 * 509 * This function is the top level handler for driver commands, 510 * this does basic validation of the buffer and identifies the 511 * opcode and switches to correct sub handler. 512 * 513 * Return: 0 on success and proper error codes on failure 514 */ 515static long mpi3mr_bsg_process_drv_cmds(struct bsg_job *job) 516{ 517 long rval = -EINVAL; 518 struct mpi3mr_ioc *mrioc = NULL; 519 struct mpi3mr_bsg_packet *bsg_req = NULL; 520 struct mpi3mr_bsg_drv_cmd *drvrcmd = NULL; 521 522 bsg_req = job->request; 523 drvrcmd = &bsg_req->cmd.drvrcmd; 524 525 mrioc = mpi3mr_bsg_verify_adapter(drvrcmd->mrioc_id); 526 if (!mrioc) 527 return -ENODEV; 528 529 if (drvrcmd->opcode == MPI3MR_DRVBSG_OPCODE_ADPINFO) { 530 rval = mpi3mr_bsg_populate_adpinfo(mrioc, job); 531 return rval; 532 } 533 534 if (mutex_lock_interruptible(&mrioc->bsg_cmds.mutex)) 535 return -ERESTARTSYS; 536 537 switch (drvrcmd->opcode) { 538 case MPI3MR_DRVBSG_OPCODE_ADPRESET: 539 rval = mpi3mr_bsg_adp_reset(mrioc, job); 540 break; 541 case MPI3MR_DRVBSG_OPCODE_ALLTGTDEVINFO: 542 rval = mpi3mr_get_all_tgt_info(mrioc, job); 543 break; 544 case MPI3MR_DRVBSG_OPCODE_GETCHGCNT: 545 rval = mpi3mr_get_change_count(mrioc, job); 546 break; 547 case MPI3MR_DRVBSG_OPCODE_LOGDATAENABLE: 548 rval = mpi3mr_enable_logdata(mrioc, job); 549 break; 550 case MPI3MR_DRVBSG_OPCODE_GETLOGDATA: 551 rval = mpi3mr_get_logdata(mrioc, job); 552 break; 553 case MPI3MR_DRVBSG_OPCODE_PELENABLE: 554 rval = mpi3mr_bsg_pel_enable(mrioc, job); 555 break; 556 case MPI3MR_DRVBSG_OPCODE_UNKNOWN: 557 default: 558 pr_err("%s: unsupported driver command opcode %d\n", 559 MPI3MR_DRIVER_NAME, drvrcmd->opcode); 560 break; 561 } 562 mutex_unlock(&mrioc->bsg_cmds.mutex); 563 return rval; 564} 565 566/** 567 * mpi3mr_bsg_build_sgl - SGL construction for MPI commands 568 * @mpi_req: MPI request 569 * @sgl_offset: offset to start sgl in the MPI request 570 * @drv_bufs: DMA address of the buffers to be placed in sgl 571 * @bufcnt: Number of DMA buffers 572 * @is_rmc: Does the buffer list has management command buffer 573 * @is_rmr: Does the buffer list has management response buffer 574 * @num_datasges: Number of data buffers in the list 575 * 576 * This function places the DMA address of the given buffers in 577 * proper format as SGEs in the given MPI request. 578 * 579 * Return: Nothing 580 */ 581static void mpi3mr_bsg_build_sgl(u8 *mpi_req, uint32_t sgl_offset, 582 struct mpi3mr_buf_map *drv_bufs, u8 bufcnt, u8 is_rmc, 583 u8 is_rmr, u8 num_datasges) 584{ 585 u8 *sgl = (mpi_req + sgl_offset), count = 0; 586 struct mpi3_mgmt_passthrough_request *rmgmt_req = 587 (struct mpi3_mgmt_passthrough_request *)mpi_req; 588 struct mpi3mr_buf_map *drv_buf_iter = drv_bufs; 589 u8 sgl_flags, sgl_flags_last; 590 591 sgl_flags = MPI3_SGE_FLAGS_ELEMENT_TYPE_SIMPLE | 592 MPI3_SGE_FLAGS_DLAS_SYSTEM | MPI3_SGE_FLAGS_END_OF_BUFFER; 593 sgl_flags_last = sgl_flags | MPI3_SGE_FLAGS_END_OF_LIST; 594 595 if (is_rmc) { 596 mpi3mr_add_sg_single(&rmgmt_req->command_sgl, 597 sgl_flags_last, drv_buf_iter->kern_buf_len, 598 drv_buf_iter->kern_buf_dma); 599 sgl = (u8 *)drv_buf_iter->kern_buf + drv_buf_iter->bsg_buf_len; 600 drv_buf_iter++; 601 count++; 602 if (is_rmr) { 603 mpi3mr_add_sg_single(&rmgmt_req->response_sgl, 604 sgl_flags_last, drv_buf_iter->kern_buf_len, 605 drv_buf_iter->kern_buf_dma); 606 drv_buf_iter++; 607 count++; 608 } else 609 mpi3mr_build_zero_len_sge( 610 &rmgmt_req->response_sgl); 611 } 612 if (!num_datasges) { 613 mpi3mr_build_zero_len_sge(sgl); 614 return; 615 } 616 for (; count < bufcnt; count++, drv_buf_iter++) { 617 if (drv_buf_iter->data_dir == DMA_NONE) 618 continue; 619 if (num_datasges == 1 || !is_rmc) 620 mpi3mr_add_sg_single(sgl, sgl_flags_last, 621 drv_buf_iter->kern_buf_len, drv_buf_iter->kern_buf_dma); 622 else 623 mpi3mr_add_sg_single(sgl, sgl_flags, 624 drv_buf_iter->kern_buf_len, drv_buf_iter->kern_buf_dma); 625 sgl += sizeof(struct mpi3_sge_common); 626 num_datasges--; 627 } 628} 629 630/** 631 * mpi3mr_get_nvme_data_fmt - returns the NVMe data format 632 * @nvme_encap_request: NVMe encapsulated MPI request 633 * 634 * This function returns the type of the data format specified 635 * in user provided NVMe command in NVMe encapsulated request. 636 * 637 * Return: Data format of the NVMe command (PRP/SGL etc) 638 */ 639static unsigned int mpi3mr_get_nvme_data_fmt( 640 struct mpi3_nvme_encapsulated_request *nvme_encap_request) 641{ 642 u8 format = 0; 643 644 format = ((nvme_encap_request->command[0] & 0xc000) >> 14); 645 return format; 646 647} 648 649/** 650 * mpi3mr_build_nvme_sgl - SGL constructor for NVME 651 * encapsulated request 652 * @mrioc: Adapter instance reference 653 * @nvme_encap_request: NVMe encapsulated MPI request 654 * @drv_bufs: DMA address of the buffers to be placed in sgl 655 * @bufcnt: Number of DMA buffers 656 * 657 * This function places the DMA address of the given buffers in 658 * proper format as SGEs in the given NVMe encapsulated request. 659 * 660 * Return: 0 on success, -1 on failure 661 */ 662static int mpi3mr_build_nvme_sgl(struct mpi3mr_ioc *mrioc, 663 struct mpi3_nvme_encapsulated_request *nvme_encap_request, 664 struct mpi3mr_buf_map *drv_bufs, u8 bufcnt) 665{ 666 struct mpi3mr_nvme_pt_sge *nvme_sgl; 667 u64 sgl_ptr; 668 u8 count; 669 size_t length = 0; 670 struct mpi3mr_buf_map *drv_buf_iter = drv_bufs; 671 u64 sgemod_mask = ((u64)((mrioc->facts.sge_mod_mask) << 672 mrioc->facts.sge_mod_shift) << 32); 673 u64 sgemod_val = ((u64)(mrioc->facts.sge_mod_value) << 674 mrioc->facts.sge_mod_shift) << 32; 675 676 /* 677 * Not all commands require a data transfer. If no data, just return 678 * without constructing any sgl. 679 */ 680 for (count = 0; count < bufcnt; count++, drv_buf_iter++) { 681 if (drv_buf_iter->data_dir == DMA_NONE) 682 continue; 683 sgl_ptr = (u64)drv_buf_iter->kern_buf_dma; 684 length = drv_buf_iter->kern_buf_len; 685 break; 686 } 687 if (!length) 688 return 0; 689 690 if (sgl_ptr & sgemod_mask) { 691 dprint_bsg_err(mrioc, 692 "%s: SGL address collides with SGE modifier\n", 693 __func__); 694 return -1; 695 } 696 697 sgl_ptr &= ~sgemod_mask; 698 sgl_ptr |= sgemod_val; 699 nvme_sgl = (struct mpi3mr_nvme_pt_sge *) 700 ((u8 *)(nvme_encap_request->command) + MPI3MR_NVME_CMD_SGL_OFFSET); 701 memset(nvme_sgl, 0, sizeof(struct mpi3mr_nvme_pt_sge)); 702 nvme_sgl->base_addr = sgl_ptr; 703 nvme_sgl->length = length; 704 return 0; 705} 706 707/** 708 * mpi3mr_build_nvme_prp - PRP constructor for NVME 709 * encapsulated request 710 * @mrioc: Adapter instance reference 711 * @nvme_encap_request: NVMe encapsulated MPI request 712 * @drv_bufs: DMA address of the buffers to be placed in SGL 713 * @bufcnt: Number of DMA buffers 714 * 715 * This function places the DMA address of the given buffers in 716 * proper format as PRP entries in the given NVMe encapsulated 717 * request. 718 * 719 * Return: 0 on success, -1 on failure 720 */ 721static int mpi3mr_build_nvme_prp(struct mpi3mr_ioc *mrioc, 722 struct mpi3_nvme_encapsulated_request *nvme_encap_request, 723 struct mpi3mr_buf_map *drv_bufs, u8 bufcnt) 724{ 725 int prp_size = MPI3MR_NVME_PRP_SIZE; 726 __le64 *prp_entry, *prp1_entry, *prp2_entry; 727 __le64 *prp_page; 728 dma_addr_t prp_entry_dma, prp_page_dma, dma_addr; 729 u32 offset, entry_len, dev_pgsz; 730 u32 page_mask_result, page_mask; 731 size_t length = 0; 732 u8 count; 733 struct mpi3mr_buf_map *drv_buf_iter = drv_bufs; 734 u64 sgemod_mask = ((u64)((mrioc->facts.sge_mod_mask) << 735 mrioc->facts.sge_mod_shift) << 32); 736 u64 sgemod_val = ((u64)(mrioc->facts.sge_mod_value) << 737 mrioc->facts.sge_mod_shift) << 32; 738 u16 dev_handle = nvme_encap_request->dev_handle; 739 struct mpi3mr_tgt_dev *tgtdev; 740 741 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, dev_handle); 742 if (!tgtdev) { 743 dprint_bsg_err(mrioc, "%s: invalid device handle 0x%04x\n", 744 __func__, dev_handle); 745 return -1; 746 } 747 748 if (tgtdev->dev_spec.pcie_inf.pgsz == 0) { 749 dprint_bsg_err(mrioc, 750 "%s: NVMe device page size is zero for handle 0x%04x\n", 751 __func__, dev_handle); 752 mpi3mr_tgtdev_put(tgtdev); 753 return -1; 754 } 755 756 dev_pgsz = 1 << (tgtdev->dev_spec.pcie_inf.pgsz); 757 mpi3mr_tgtdev_put(tgtdev); 758 759 /* 760 * Not all commands require a data transfer. If no data, just return 761 * without constructing any PRP. 762 */ 763 for (count = 0; count < bufcnt; count++, drv_buf_iter++) { 764 if (drv_buf_iter->data_dir == DMA_NONE) 765 continue; 766 dma_addr = drv_buf_iter->kern_buf_dma; 767 length = drv_buf_iter->kern_buf_len; 768 break; 769 } 770 771 if (!length) 772 return 0; 773 774 mrioc->prp_sz = 0; 775 mrioc->prp_list_virt = dma_alloc_coherent(&mrioc->pdev->dev, 776 dev_pgsz, &mrioc->prp_list_dma, GFP_KERNEL); 777 778 if (!mrioc->prp_list_virt) 779 return -1; 780 mrioc->prp_sz = dev_pgsz; 781 782 /* 783 * Set pointers to PRP1 and PRP2, which are in the NVMe command. 784 * PRP1 is located at a 24 byte offset from the start of the NVMe 785 * command. Then set the current PRP entry pointer to PRP1. 786 */ 787 prp1_entry = (__le64 *)((u8 *)(nvme_encap_request->command) + 788 MPI3MR_NVME_CMD_PRP1_OFFSET); 789 prp2_entry = (__le64 *)((u8 *)(nvme_encap_request->command) + 790 MPI3MR_NVME_CMD_PRP2_OFFSET); 791 prp_entry = prp1_entry; 792 /* 793 * For the PRP entries, use the specially allocated buffer of 794 * contiguous memory. 795 */ 796 prp_page = (__le64 *)mrioc->prp_list_virt; 797 prp_page_dma = mrioc->prp_list_dma; 798 799 /* 800 * Check if we are within 1 entry of a page boundary we don't 801 * want our first entry to be a PRP List entry. 802 */ 803 page_mask = dev_pgsz - 1; 804 page_mask_result = (uintptr_t)((u8 *)prp_page + prp_size) & page_mask; 805 if (!page_mask_result) { 806 dprint_bsg_err(mrioc, "%s: PRP page is not page aligned\n", 807 __func__); 808 goto err_out; 809 } 810 811 /* 812 * Set PRP physical pointer, which initially points to the current PRP 813 * DMA memory page. 814 */ 815 prp_entry_dma = prp_page_dma; 816 817 818 /* Loop while the length is not zero. */ 819 while (length) { 820 page_mask_result = (prp_entry_dma + prp_size) & page_mask; 821 if (!page_mask_result && (length > dev_pgsz)) { 822 dprint_bsg_err(mrioc, 823 "%s: single PRP page is not sufficient\n", 824 __func__); 825 goto err_out; 826 } 827 828 /* Need to handle if entry will be part of a page. */ 829 offset = dma_addr & page_mask; 830 entry_len = dev_pgsz - offset; 831 832 if (prp_entry == prp1_entry) { 833 /* 834 * Must fill in the first PRP pointer (PRP1) before 835 * moving on. 836 */ 837 *prp1_entry = cpu_to_le64(dma_addr); 838 if (*prp1_entry & sgemod_mask) { 839 dprint_bsg_err(mrioc, 840 "%s: PRP1 address collides with SGE modifier\n", 841 __func__); 842 goto err_out; 843 } 844 *prp1_entry &= ~sgemod_mask; 845 *prp1_entry |= sgemod_val; 846 847 /* 848 * Now point to the second PRP entry within the 849 * command (PRP2). 850 */ 851 prp_entry = prp2_entry; 852 } else if (prp_entry == prp2_entry) { 853 /* 854 * Should the PRP2 entry be a PRP List pointer or just 855 * a regular PRP pointer? If there is more than one 856 * more page of data, must use a PRP List pointer. 857 */ 858 if (length > dev_pgsz) { 859 /* 860 * PRP2 will contain a PRP List pointer because 861 * more PRP's are needed with this command. The 862 * list will start at the beginning of the 863 * contiguous buffer. 864 */ 865 *prp2_entry = cpu_to_le64(prp_entry_dma); 866 if (*prp2_entry & sgemod_mask) { 867 dprint_bsg_err(mrioc, 868 "%s: PRP list address collides with SGE modifier\n", 869 __func__); 870 goto err_out; 871 } 872 *prp2_entry &= ~sgemod_mask; 873 *prp2_entry |= sgemod_val; 874 875 /* 876 * The next PRP Entry will be the start of the 877 * first PRP List. 878 */ 879 prp_entry = prp_page; 880 continue; 881 } else { 882 /* 883 * After this, the PRP Entries are complete. 884 * This command uses 2 PRP's and no PRP list. 885 */ 886 *prp2_entry = cpu_to_le64(dma_addr); 887 if (*prp2_entry & sgemod_mask) { 888 dprint_bsg_err(mrioc, 889 "%s: PRP2 collides with SGE modifier\n", 890 __func__); 891 goto err_out; 892 } 893 *prp2_entry &= ~sgemod_mask; 894 *prp2_entry |= sgemod_val; 895 } 896 } else { 897 /* 898 * Put entry in list and bump the addresses. 899 * 900 * After PRP1 and PRP2 are filled in, this will fill in 901 * all remaining PRP entries in a PRP List, one per 902 * each time through the loop. 903 */ 904 *prp_entry = cpu_to_le64(dma_addr); 905 if (*prp_entry & sgemod_mask) { 906 dprint_bsg_err(mrioc, 907 "%s: PRP address collides with SGE modifier\n", 908 __func__); 909 goto err_out; 910 } 911 *prp_entry &= ~sgemod_mask; 912 *prp_entry |= sgemod_val; 913 prp_entry++; 914 prp_entry_dma += prp_size; 915 } 916 917 /* 918 * Bump the phys address of the command's data buffer by the 919 * entry_len. 920 */ 921 dma_addr += entry_len; 922 923 /* decrement length accounting for last partial page. */ 924 if (entry_len > length) 925 length = 0; 926 else 927 length -= entry_len; 928 } 929 return 0; 930err_out: 931 if (mrioc->prp_list_virt) { 932 dma_free_coherent(&mrioc->pdev->dev, mrioc->prp_sz, 933 mrioc->prp_list_virt, mrioc->prp_list_dma); 934 mrioc->prp_list_virt = NULL; 935 } 936 return -1; 937} 938/** 939 * mpi3mr_bsg_process_mpt_cmds - MPI Pass through BSG handler 940 * @job: BSG job reference 941 * @reply_payload_rcv_len: length of payload recvd 942 * 943 * This function is the top level handler for MPI Pass through 944 * command, this does basic validation of the input data buffers, 945 * identifies the given buffer types and MPI command, allocates 946 * DMAable memory for user given buffers, construstcs SGL 947 * properly and passes the command to the firmware. 948 * 949 * Once the MPI command is completed the driver copies the data 950 * if any and reply, sense information to user provided buffers. 951 * If the command is timed out then issues controller reset 952 * prior to returning. 953 * 954 * Return: 0 on success and proper error codes on failure 955 */ 956 957static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job, unsigned int *reply_payload_rcv_len) 958{ 959 long rval = -EINVAL; 960 961 struct mpi3mr_ioc *mrioc = NULL; 962 u8 *mpi_req = NULL, *sense_buff_k = NULL; 963 u8 mpi_msg_size = 0; 964 struct mpi3mr_bsg_packet *bsg_req = NULL; 965 struct mpi3mr_bsg_mptcmd *karg; 966 struct mpi3mr_buf_entry *buf_entries = NULL; 967 struct mpi3mr_buf_map *drv_bufs = NULL, *drv_buf_iter = NULL; 968 u8 count, bufcnt = 0, is_rmcb = 0, is_rmrb = 0, din_cnt = 0, dout_cnt = 0; 969 u8 invalid_be = 0, erb_offset = 0xFF, mpirep_offset = 0xFF, sg_entries = 0; 970 u8 block_io = 0, resp_code = 0, nvme_fmt = 0; 971 struct mpi3_request_header *mpi_header = NULL; 972 struct mpi3_status_reply_descriptor *status_desc; 973 struct mpi3_scsi_task_mgmt_request *tm_req; 974 u32 erbsz = MPI3MR_SENSE_BUF_SZ, tmplen; 975 u16 dev_handle; 976 struct mpi3mr_tgt_dev *tgtdev; 977 struct mpi3mr_stgt_priv_data *stgt_priv = NULL; 978 struct mpi3mr_bsg_in_reply_buf *bsg_reply_buf = NULL; 979 u32 din_size = 0, dout_size = 0; 980 u8 *din_buf = NULL, *dout_buf = NULL; 981 u8 *sgl_iter = NULL, *sgl_din_iter = NULL, *sgl_dout_iter = NULL; 982 983 bsg_req = job->request; 984 karg = (struct mpi3mr_bsg_mptcmd *)&bsg_req->cmd.mptcmd; 985 986 mrioc = mpi3mr_bsg_verify_adapter(karg->mrioc_id); 987 if (!mrioc) 988 return -ENODEV; 989 990 if (karg->timeout < MPI3MR_APP_DEFAULT_TIMEOUT) 991 karg->timeout = MPI3MR_APP_DEFAULT_TIMEOUT; 992 993 mpi_req = kzalloc(MPI3MR_ADMIN_REQ_FRAME_SZ, GFP_KERNEL); 994 if (!mpi_req) 995 return -ENOMEM; 996 mpi_header = (struct mpi3_request_header *)mpi_req; 997 998 bufcnt = karg->buf_entry_list.num_of_entries; 999 drv_bufs = kzalloc((sizeof(*drv_bufs) * bufcnt), GFP_KERNEL); 1000 if (!drv_bufs) { 1001 rval = -ENOMEM; 1002 goto out; 1003 } 1004 1005 dout_buf = kzalloc(job->request_payload.payload_len, 1006 GFP_KERNEL); 1007 if (!dout_buf) { 1008 rval = -ENOMEM; 1009 goto out; 1010 } 1011 1012 din_buf = kzalloc(job->reply_payload.payload_len, 1013 GFP_KERNEL); 1014 if (!din_buf) { 1015 rval = -ENOMEM; 1016 goto out; 1017 } 1018 1019 sg_copy_to_buffer(job->request_payload.sg_list, 1020 job->request_payload.sg_cnt, 1021 dout_buf, job->request_payload.payload_len); 1022 1023 buf_entries = karg->buf_entry_list.buf_entry; 1024 sgl_din_iter = din_buf; 1025 sgl_dout_iter = dout_buf; 1026 drv_buf_iter = drv_bufs; 1027 1028 for (count = 0; count < bufcnt; count++, buf_entries++, drv_buf_iter++) { 1029 1030 if (sgl_dout_iter > (dout_buf + job->request_payload.payload_len)) { 1031 dprint_bsg_err(mrioc, "%s: data_out buffer length mismatch\n", 1032 __func__); 1033 rval = -EINVAL; 1034 goto out; 1035 } 1036 if (sgl_din_iter > (din_buf + job->reply_payload.payload_len)) { 1037 dprint_bsg_err(mrioc, "%s: data_in buffer length mismatch\n", 1038 __func__); 1039 rval = -EINVAL; 1040 goto out; 1041 } 1042 1043 switch (buf_entries->buf_type) { 1044 case MPI3MR_BSG_BUFTYPE_RAIDMGMT_CMD: 1045 sgl_iter = sgl_dout_iter; 1046 sgl_dout_iter += buf_entries->buf_len; 1047 drv_buf_iter->data_dir = DMA_TO_DEVICE; 1048 is_rmcb = 1; 1049 if (count != 0) 1050 invalid_be = 1; 1051 break; 1052 case MPI3MR_BSG_BUFTYPE_RAIDMGMT_RESP: 1053 sgl_iter = sgl_din_iter; 1054 sgl_din_iter += buf_entries->buf_len; 1055 drv_buf_iter->data_dir = DMA_FROM_DEVICE; 1056 is_rmrb = 1; 1057 if (count != 1 || !is_rmcb) 1058 invalid_be = 1; 1059 break; 1060 case MPI3MR_BSG_BUFTYPE_DATA_IN: 1061 sgl_iter = sgl_din_iter; 1062 sgl_din_iter += buf_entries->buf_len; 1063 drv_buf_iter->data_dir = DMA_FROM_DEVICE; 1064 din_cnt++; 1065 din_size += drv_buf_iter->bsg_buf_len; 1066 if ((din_cnt > 1) && !is_rmcb) 1067 invalid_be = 1; 1068 break; 1069 case MPI3MR_BSG_BUFTYPE_DATA_OUT: 1070 sgl_iter = sgl_dout_iter; 1071 sgl_dout_iter += buf_entries->buf_len; 1072 drv_buf_iter->data_dir = DMA_TO_DEVICE; 1073 dout_cnt++; 1074 dout_size += drv_buf_iter->bsg_buf_len; 1075 if ((dout_cnt > 1) && !is_rmcb) 1076 invalid_be = 1; 1077 break; 1078 case MPI3MR_BSG_BUFTYPE_MPI_REPLY: 1079 sgl_iter = sgl_din_iter; 1080 sgl_din_iter += buf_entries->buf_len; 1081 drv_buf_iter->data_dir = DMA_NONE; 1082 mpirep_offset = count; 1083 break; 1084 case MPI3MR_BSG_BUFTYPE_ERR_RESPONSE: 1085 sgl_iter = sgl_din_iter; 1086 sgl_din_iter += buf_entries->buf_len; 1087 drv_buf_iter->data_dir = DMA_NONE; 1088 erb_offset = count; 1089 break; 1090 case MPI3MR_BSG_BUFTYPE_MPI_REQUEST: 1091 sgl_iter = sgl_dout_iter; 1092 sgl_dout_iter += buf_entries->buf_len; 1093 drv_buf_iter->data_dir = DMA_NONE; 1094 mpi_msg_size = buf_entries->buf_len; 1095 if ((!mpi_msg_size || (mpi_msg_size % 4)) || 1096 (mpi_msg_size > MPI3MR_ADMIN_REQ_FRAME_SZ)) { 1097 dprint_bsg_err(mrioc, "%s: invalid MPI message size\n", 1098 __func__); 1099 rval = -EINVAL; 1100 goto out; 1101 } 1102 memcpy(mpi_req, sgl_iter, buf_entries->buf_len); 1103 break; 1104 default: 1105 invalid_be = 1; 1106 break; 1107 } 1108 if (invalid_be) { 1109 dprint_bsg_err(mrioc, "%s: invalid buffer entries passed\n", 1110 __func__); 1111 rval = -EINVAL; 1112 goto out; 1113 } 1114 1115 drv_buf_iter->bsg_buf = sgl_iter; 1116 drv_buf_iter->bsg_buf_len = buf_entries->buf_len; 1117 1118 } 1119 if (!is_rmcb && (dout_cnt || din_cnt)) { 1120 sg_entries = dout_cnt + din_cnt; 1121 if (((mpi_msg_size) + (sg_entries * 1122 sizeof(struct mpi3_sge_common))) > MPI3MR_ADMIN_REQ_FRAME_SZ) { 1123 dprint_bsg_err(mrioc, 1124 "%s:%d: invalid message size passed\n", 1125 __func__, __LINE__); 1126 rval = -EINVAL; 1127 goto out; 1128 } 1129 } 1130 if (din_size > MPI3MR_MAX_APP_XFER_SIZE) { 1131 dprint_bsg_err(mrioc, 1132 "%s:%d: invalid data transfer size passed for function 0x%x din_size=%d\n", 1133 __func__, __LINE__, mpi_header->function, din_size); 1134 rval = -EINVAL; 1135 goto out; 1136 } 1137 if (dout_size > MPI3MR_MAX_APP_XFER_SIZE) { 1138 dprint_bsg_err(mrioc, 1139 "%s:%d: invalid data transfer size passed for function 0x%x dout_size = %d\n", 1140 __func__, __LINE__, mpi_header->function, dout_size); 1141 rval = -EINVAL; 1142 goto out; 1143 } 1144 1145 drv_buf_iter = drv_bufs; 1146 for (count = 0; count < bufcnt; count++, drv_buf_iter++) { 1147 if (drv_buf_iter->data_dir == DMA_NONE) 1148 continue; 1149 1150 drv_buf_iter->kern_buf_len = drv_buf_iter->bsg_buf_len; 1151 if (is_rmcb && !count) 1152 drv_buf_iter->kern_buf_len += ((dout_cnt + din_cnt) * 1153 sizeof(struct mpi3_sge_common)); 1154 1155 if (!drv_buf_iter->kern_buf_len) 1156 continue; 1157 1158 drv_buf_iter->kern_buf = dma_alloc_coherent(&mrioc->pdev->dev, 1159 drv_buf_iter->kern_buf_len, &drv_buf_iter->kern_buf_dma, 1160 GFP_KERNEL); 1161 if (!drv_buf_iter->kern_buf) { 1162 rval = -ENOMEM; 1163 goto out; 1164 } 1165 if (drv_buf_iter->data_dir == DMA_TO_DEVICE) { 1166 tmplen = min(drv_buf_iter->kern_buf_len, 1167 drv_buf_iter->bsg_buf_len); 1168 memcpy(drv_buf_iter->kern_buf, drv_buf_iter->bsg_buf, tmplen); 1169 } 1170 } 1171 1172 if (erb_offset != 0xFF) { 1173 sense_buff_k = kzalloc(erbsz, GFP_KERNEL); 1174 if (!sense_buff_k) { 1175 rval = -ENOMEM; 1176 goto out; 1177 } 1178 } 1179 1180 if (mutex_lock_interruptible(&mrioc->bsg_cmds.mutex)) { 1181 rval = -ERESTARTSYS; 1182 goto out; 1183 } 1184 if (mrioc->bsg_cmds.state & MPI3MR_CMD_PENDING) { 1185 rval = -EAGAIN; 1186 dprint_bsg_err(mrioc, "%s: command is in use\n", __func__); 1187 mutex_unlock(&mrioc->bsg_cmds.mutex); 1188 goto out; 1189 } 1190 if (mrioc->unrecoverable) { 1191 dprint_bsg_err(mrioc, "%s: unrecoverable controller\n", 1192 __func__); 1193 rval = -EFAULT; 1194 mutex_unlock(&mrioc->bsg_cmds.mutex); 1195 goto out; 1196 } 1197 if (mrioc->reset_in_progress) { 1198 dprint_bsg_err(mrioc, "%s: reset in progress\n", __func__); 1199 rval = -EAGAIN; 1200 mutex_unlock(&mrioc->bsg_cmds.mutex); 1201 goto out; 1202 } 1203 if (mrioc->stop_bsgs) { 1204 dprint_bsg_err(mrioc, "%s: bsgs are blocked\n", __func__); 1205 rval = -EAGAIN; 1206 mutex_unlock(&mrioc->bsg_cmds.mutex); 1207 goto out; 1208 } 1209 1210 if (mpi_header->function == MPI3_BSG_FUNCTION_NVME_ENCAPSULATED) { 1211 nvme_fmt = mpi3mr_get_nvme_data_fmt( 1212 (struct mpi3_nvme_encapsulated_request *)mpi_req); 1213 if (nvme_fmt == MPI3MR_NVME_DATA_FORMAT_PRP) { 1214 if (mpi3mr_build_nvme_prp(mrioc, 1215 (struct mpi3_nvme_encapsulated_request *)mpi_req, 1216 drv_bufs, bufcnt)) { 1217 rval = -ENOMEM; 1218 mutex_unlock(&mrioc->bsg_cmds.mutex); 1219 goto out; 1220 } 1221 } else if (nvme_fmt == MPI3MR_NVME_DATA_FORMAT_SGL1 || 1222 nvme_fmt == MPI3MR_NVME_DATA_FORMAT_SGL2) { 1223 if (mpi3mr_build_nvme_sgl(mrioc, 1224 (struct mpi3_nvme_encapsulated_request *)mpi_req, 1225 drv_bufs, bufcnt)) { 1226 rval = -EINVAL; 1227 mutex_unlock(&mrioc->bsg_cmds.mutex); 1228 goto out; 1229 } 1230 } else { 1231 dprint_bsg_err(mrioc, 1232 "%s:invalid NVMe command format\n", __func__); 1233 rval = -EINVAL; 1234 mutex_unlock(&mrioc->bsg_cmds.mutex); 1235 goto out; 1236 } 1237 } else { 1238 mpi3mr_bsg_build_sgl(mpi_req, (mpi_msg_size), 1239 drv_bufs, bufcnt, is_rmcb, is_rmrb, 1240 (dout_cnt + din_cnt)); 1241 } 1242 1243 if (mpi_header->function == MPI3_BSG_FUNCTION_SCSI_TASK_MGMT) { 1244 tm_req = (struct mpi3_scsi_task_mgmt_request *)mpi_req; 1245 if (tm_req->task_type != 1246 MPI3_SCSITASKMGMT_TASKTYPE_ABORT_TASK) { 1247 dev_handle = tm_req->dev_handle; 1248 block_io = 1; 1249 } 1250 } 1251 if (block_io) { 1252 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, dev_handle); 1253 if (tgtdev && tgtdev->starget && tgtdev->starget->hostdata) { 1254 stgt_priv = (struct mpi3mr_stgt_priv_data *) 1255 tgtdev->starget->hostdata; 1256 atomic_inc(&stgt_priv->block_io); 1257 mpi3mr_tgtdev_put(tgtdev); 1258 } 1259 } 1260 1261 mrioc->bsg_cmds.state = MPI3MR_CMD_PENDING; 1262 mrioc->bsg_cmds.is_waiting = 1; 1263 mrioc->bsg_cmds.callback = NULL; 1264 mrioc->bsg_cmds.is_sense = 0; 1265 mrioc->bsg_cmds.sensebuf = sense_buff_k; 1266 memset(mrioc->bsg_cmds.reply, 0, mrioc->reply_sz); 1267 mpi_header->host_tag = cpu_to_le16(MPI3MR_HOSTTAG_BSG_CMDS); 1268 if (mrioc->logging_level & MPI3_DEBUG_BSG_INFO) { 1269 dprint_bsg_info(mrioc, 1270 "%s: posting bsg request to the controller\n", __func__); 1271 dprint_dump(mpi_req, MPI3MR_ADMIN_REQ_FRAME_SZ, 1272 "bsg_mpi3_req"); 1273 if (mpi_header->function == MPI3_BSG_FUNCTION_MGMT_PASSTHROUGH) { 1274 drv_buf_iter = &drv_bufs[0]; 1275 dprint_dump(drv_buf_iter->kern_buf, 1276 drv_buf_iter->kern_buf_len, "mpi3_mgmt_req"); 1277 } 1278 } 1279 1280 init_completion(&mrioc->bsg_cmds.done); 1281 rval = mpi3mr_admin_request_post(mrioc, mpi_req, 1282 MPI3MR_ADMIN_REQ_FRAME_SZ, 0); 1283 1284 1285 if (rval) { 1286 mrioc->bsg_cmds.is_waiting = 0; 1287 dprint_bsg_err(mrioc, 1288 "%s: posting bsg request is failed\n", __func__); 1289 rval = -EAGAIN; 1290 goto out_unlock; 1291 } 1292 wait_for_completion_timeout(&mrioc->bsg_cmds.done, 1293 (karg->timeout * HZ)); 1294 if (block_io && stgt_priv) 1295 atomic_dec(&stgt_priv->block_io); 1296 if (!(mrioc->bsg_cmds.state & MPI3MR_CMD_COMPLETE)) { 1297 mrioc->bsg_cmds.is_waiting = 0; 1298 rval = -EAGAIN; 1299 if (mrioc->bsg_cmds.state & MPI3MR_CMD_RESET) 1300 goto out_unlock; 1301 dprint_bsg_err(mrioc, 1302 "%s: bsg request timedout after %d seconds\n", __func__, 1303 karg->timeout); 1304 if (mrioc->logging_level & MPI3_DEBUG_BSG_ERROR) { 1305 dprint_dump(mpi_req, MPI3MR_ADMIN_REQ_FRAME_SZ, 1306 "bsg_mpi3_req"); 1307 if (mpi_header->function == 1308 MPI3_BSG_FUNCTION_MGMT_PASSTHROUGH) { 1309 drv_buf_iter = &drv_bufs[0]; 1310 dprint_dump(drv_buf_iter->kern_buf, 1311 drv_buf_iter->kern_buf_len, "mpi3_mgmt_req"); 1312 } 1313 } 1314 1315 if ((mpi_header->function == MPI3_BSG_FUNCTION_NVME_ENCAPSULATED) || 1316 (mpi_header->function == MPI3_BSG_FUNCTION_SCSI_IO)) 1317 mpi3mr_issue_tm(mrioc, 1318 MPI3_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 1319 mpi_header->function_dependent, 0, 1320 MPI3MR_HOSTTAG_BLK_TMS, MPI3MR_RESETTM_TIMEOUT, 1321 &mrioc->host_tm_cmds, &resp_code, NULL); 1322 if (!(mrioc->bsg_cmds.state & MPI3MR_CMD_COMPLETE) && 1323 !(mrioc->bsg_cmds.state & MPI3MR_CMD_RESET)) 1324 mpi3mr_soft_reset_handler(mrioc, 1325 MPI3MR_RESET_FROM_APP_TIMEOUT, 1); 1326 goto out_unlock; 1327 } 1328 dprint_bsg_info(mrioc, "%s: bsg request is completed\n", __func__); 1329 1330 if (mrioc->prp_list_virt) { 1331 dma_free_coherent(&mrioc->pdev->dev, mrioc->prp_sz, 1332 mrioc->prp_list_virt, mrioc->prp_list_dma); 1333 mrioc->prp_list_virt = NULL; 1334 } 1335 1336 if ((mrioc->bsg_cmds.ioc_status & MPI3_IOCSTATUS_STATUS_MASK) 1337 != MPI3_IOCSTATUS_SUCCESS) { 1338 dprint_bsg_info(mrioc, 1339 "%s: command failed, ioc_status(0x%04x) log_info(0x%08x)\n", 1340 __func__, 1341 (mrioc->bsg_cmds.ioc_status & MPI3_IOCSTATUS_STATUS_MASK), 1342 mrioc->bsg_cmds.ioc_loginfo); 1343 } 1344 1345 if ((mpirep_offset != 0xFF) && 1346 drv_bufs[mpirep_offset].bsg_buf_len) { 1347 drv_buf_iter = &drv_bufs[mpirep_offset]; 1348 drv_buf_iter->kern_buf_len = (sizeof(*bsg_reply_buf) - 1 + 1349 mrioc->reply_sz); 1350 bsg_reply_buf = kzalloc(drv_buf_iter->kern_buf_len, GFP_KERNEL); 1351 1352 if (!bsg_reply_buf) { 1353 rval = -ENOMEM; 1354 goto out_unlock; 1355 } 1356 if (mrioc->bsg_cmds.state & MPI3MR_CMD_REPLY_VALID) { 1357 bsg_reply_buf->mpi_reply_type = 1358 MPI3MR_BSG_MPI_REPLY_BUFTYPE_ADDRESS; 1359 memcpy(bsg_reply_buf->reply_buf, 1360 mrioc->bsg_cmds.reply, mrioc->reply_sz); 1361 } else { 1362 bsg_reply_buf->mpi_reply_type = 1363 MPI3MR_BSG_MPI_REPLY_BUFTYPE_STATUS; 1364 status_desc = (struct mpi3_status_reply_descriptor *) 1365 bsg_reply_buf->reply_buf; 1366 status_desc->ioc_status = mrioc->bsg_cmds.ioc_status; 1367 status_desc->ioc_log_info = mrioc->bsg_cmds.ioc_loginfo; 1368 } 1369 tmplen = min(drv_buf_iter->kern_buf_len, 1370 drv_buf_iter->bsg_buf_len); 1371 memcpy(drv_buf_iter->bsg_buf, bsg_reply_buf, tmplen); 1372 } 1373 1374 if (erb_offset != 0xFF && mrioc->bsg_cmds.sensebuf && 1375 mrioc->bsg_cmds.is_sense) { 1376 drv_buf_iter = &drv_bufs[erb_offset]; 1377 tmplen = min(erbsz, drv_buf_iter->bsg_buf_len); 1378 memcpy(drv_buf_iter->bsg_buf, sense_buff_k, tmplen); 1379 } 1380 1381 drv_buf_iter = drv_bufs; 1382 for (count = 0; count < bufcnt; count++, drv_buf_iter++) { 1383 if (drv_buf_iter->data_dir == DMA_NONE) 1384 continue; 1385 if (drv_buf_iter->data_dir == DMA_FROM_DEVICE) { 1386 tmplen = min(drv_buf_iter->kern_buf_len, 1387 drv_buf_iter->bsg_buf_len); 1388 memcpy(drv_buf_iter->bsg_buf, 1389 drv_buf_iter->kern_buf, tmplen); 1390 } 1391 } 1392 1393out_unlock: 1394 if (din_buf) { 1395 *reply_payload_rcv_len = 1396 sg_copy_from_buffer(job->reply_payload.sg_list, 1397 job->reply_payload.sg_cnt, 1398 din_buf, job->reply_payload.payload_len); 1399 } 1400 mrioc->bsg_cmds.is_sense = 0; 1401 mrioc->bsg_cmds.sensebuf = NULL; 1402 mrioc->bsg_cmds.state = MPI3MR_CMD_NOTUSED; 1403 mutex_unlock(&mrioc->bsg_cmds.mutex); 1404out: 1405 kfree(sense_buff_k); 1406 kfree(dout_buf); 1407 kfree(din_buf); 1408 kfree(mpi_req); 1409 if (drv_bufs) { 1410 drv_buf_iter = drv_bufs; 1411 for (count = 0; count < bufcnt; count++, drv_buf_iter++) { 1412 if (drv_buf_iter->kern_buf && drv_buf_iter->kern_buf_dma) 1413 dma_free_coherent(&mrioc->pdev->dev, 1414 drv_buf_iter->kern_buf_len, 1415 drv_buf_iter->kern_buf, 1416 drv_buf_iter->kern_buf_dma); 1417 } 1418 kfree(drv_bufs); 1419 } 1420 kfree(bsg_reply_buf); 1421 return rval; 1422} 1423 1424/** 1425 * mpi3mr_app_save_logdata - Save Log Data events 1426 * @mrioc: Adapter instance reference 1427 * @event_data: event data associated with log data event 1428 * @event_data_size: event data size to copy 1429 * 1430 * If log data event caching is enabled by the applicatiobns, 1431 * then this function saves the log data in the circular queue 1432 * and Sends async signal SIGIO to indicate there is an async 1433 * event from the firmware to the event monitoring applications. 1434 * 1435 * Return:Nothing 1436 */ 1437void mpi3mr_app_save_logdata(struct mpi3mr_ioc *mrioc, char *event_data, 1438 u16 event_data_size) 1439{ 1440 u32 index = mrioc->logdata_buf_idx, sz; 1441 struct mpi3mr_logdata_entry *entry; 1442 1443 if (!(mrioc->logdata_buf)) 1444 return; 1445 1446 entry = (struct mpi3mr_logdata_entry *) 1447 (mrioc->logdata_buf + (index * mrioc->logdata_entry_sz)); 1448 entry->valid_entry = 1; 1449 sz = min(mrioc->logdata_entry_sz, event_data_size); 1450 memcpy(entry->data, event_data, sz); 1451 mrioc->logdata_buf_idx = 1452 ((++index) % MPI3MR_BSG_LOGDATA_MAX_ENTRIES); 1453 atomic64_inc(&event_counter); 1454} 1455 1456/** 1457 * mpi3mr_bsg_request - bsg request entry point 1458 * @job: BSG job reference 1459 * 1460 * This is driver's entry point for bsg requests 1461 * 1462 * Return: 0 on success and proper error codes on failure 1463 */ 1464static int mpi3mr_bsg_request(struct bsg_job *job) 1465{ 1466 long rval = -EINVAL; 1467 unsigned int reply_payload_rcv_len = 0; 1468 1469 struct mpi3mr_bsg_packet *bsg_req = job->request; 1470 1471 switch (bsg_req->cmd_type) { 1472 case MPI3MR_DRV_CMD: 1473 rval = mpi3mr_bsg_process_drv_cmds(job); 1474 break; 1475 case MPI3MR_MPT_CMD: 1476 rval = mpi3mr_bsg_process_mpt_cmds(job, &reply_payload_rcv_len); 1477 break; 1478 default: 1479 pr_err("%s: unsupported BSG command(0x%08x)\n", 1480 MPI3MR_DRIVER_NAME, bsg_req->cmd_type); 1481 break; 1482 } 1483 1484 bsg_job_done(job, rval, reply_payload_rcv_len); 1485 1486 return 0; 1487} 1488 1489/** 1490 * mpi3mr_bsg_exit - de-registration from bsg layer 1491 * @mrioc: Adapter instance reference 1492 * 1493 * This will be called during driver unload and all 1494 * bsg resources allocated during load will be freed. 1495 * 1496 * Return:Nothing 1497 */ 1498void mpi3mr_bsg_exit(struct mpi3mr_ioc *mrioc) 1499{ 1500 struct device *bsg_dev = &mrioc->bsg_dev; 1501 if (!mrioc->bsg_queue) 1502 return; 1503 1504 bsg_remove_queue(mrioc->bsg_queue); 1505 mrioc->bsg_queue = NULL; 1506 1507 device_del(bsg_dev); 1508 put_device(bsg_dev); 1509} 1510 1511/** 1512 * mpi3mr_bsg_node_release -release bsg device node 1513 * @dev: bsg device node 1514 * 1515 * decrements bsg dev parent reference count 1516 * 1517 * Return:Nothing 1518 */ 1519static void mpi3mr_bsg_node_release(struct device *dev) 1520{ 1521 put_device(dev->parent); 1522} 1523 1524/** 1525 * mpi3mr_bsg_init - registration with bsg layer 1526 * @mrioc: Adapter instance reference 1527 * 1528 * This will be called during driver load and it will 1529 * register driver with bsg layer 1530 * 1531 * Return:Nothing 1532 */ 1533void mpi3mr_bsg_init(struct mpi3mr_ioc *mrioc) 1534{ 1535 struct device *bsg_dev = &mrioc->bsg_dev; 1536 struct device *parent = &mrioc->shost->shost_gendev; 1537 1538 device_initialize(bsg_dev); 1539 1540 bsg_dev->parent = get_device(parent); 1541 bsg_dev->release = mpi3mr_bsg_node_release; 1542 1543 dev_set_name(bsg_dev, "mpi3mrctl%u", mrioc->id); 1544 1545 if (device_add(bsg_dev)) { 1546 ioc_err(mrioc, "%s: bsg device add failed\n", 1547 dev_name(bsg_dev)); 1548 put_device(bsg_dev); 1549 return; 1550 } 1551 1552 mrioc->bsg_queue = bsg_setup_queue(bsg_dev, dev_name(bsg_dev), 1553 mpi3mr_bsg_request, NULL, 0); 1554 if (IS_ERR(mrioc->bsg_queue)) { 1555 ioc_err(mrioc, "%s: bsg registration failed\n", 1556 dev_name(bsg_dev)); 1557 device_del(bsg_dev); 1558 put_device(bsg_dev); 1559 return; 1560 } 1561 1562 blk_queue_max_segments(mrioc->bsg_queue, MPI3MR_MAX_APP_XFER_SEGMENTS); 1563 blk_queue_max_hw_sectors(mrioc->bsg_queue, MPI3MR_MAX_APP_XFER_SECTORS); 1564 1565 return; 1566} 1567 1568/** 1569 * version_fw_show - SysFS callback for firmware version read 1570 * @dev: class device 1571 * @attr: Device attributes 1572 * @buf: Buffer to copy 1573 * 1574 * Return: sysfs_emit() return after copying firmware version 1575 */ 1576static ssize_t 1577version_fw_show(struct device *dev, struct device_attribute *attr, 1578 char *buf) 1579{ 1580 struct Scsi_Host *shost = class_to_shost(dev); 1581 struct mpi3mr_ioc *mrioc = shost_priv(shost); 1582 struct mpi3mr_compimg_ver *fwver = &mrioc->facts.fw_ver; 1583 1584 return sysfs_emit(buf, "%d.%d.%d.%d.%05d-%05d\n", 1585 fwver->gen_major, fwver->gen_minor, fwver->ph_major, 1586 fwver->ph_minor, fwver->cust_id, fwver->build_num); 1587} 1588static DEVICE_ATTR_RO(version_fw); 1589 1590/** 1591 * fw_queue_depth_show - SysFS callback for firmware max cmds 1592 * @dev: class device 1593 * @attr: Device attributes 1594 * @buf: Buffer to copy 1595 * 1596 * Return: sysfs_emit() return after copying firmware max commands 1597 */ 1598static ssize_t 1599fw_queue_depth_show(struct device *dev, struct device_attribute *attr, 1600 char *buf) 1601{ 1602 struct Scsi_Host *shost = class_to_shost(dev); 1603 struct mpi3mr_ioc *mrioc = shost_priv(shost); 1604 1605 return sysfs_emit(buf, "%d\n", mrioc->facts.max_reqs); 1606} 1607static DEVICE_ATTR_RO(fw_queue_depth); 1608 1609/** 1610 * op_req_q_count_show - SysFS callback for request queue count 1611 * @dev: class device 1612 * @attr: Device attributes 1613 * @buf: Buffer to copy 1614 * 1615 * Return: sysfs_emit() return after copying request queue count 1616 */ 1617static ssize_t 1618op_req_q_count_show(struct device *dev, struct device_attribute *attr, 1619 char *buf) 1620{ 1621 struct Scsi_Host *shost = class_to_shost(dev); 1622 struct mpi3mr_ioc *mrioc = shost_priv(shost); 1623 1624 return sysfs_emit(buf, "%d\n", mrioc->num_op_req_q); 1625} 1626static DEVICE_ATTR_RO(op_req_q_count); 1627 1628/** 1629 * reply_queue_count_show - SysFS callback for reply queue count 1630 * @dev: class device 1631 * @attr: Device attributes 1632 * @buf: Buffer to copy 1633 * 1634 * Return: sysfs_emit() return after copying reply queue count 1635 */ 1636static ssize_t 1637reply_queue_count_show(struct device *dev, struct device_attribute *attr, 1638 char *buf) 1639{ 1640 struct Scsi_Host *shost = class_to_shost(dev); 1641 struct mpi3mr_ioc *mrioc = shost_priv(shost); 1642 1643 return sysfs_emit(buf, "%d\n", mrioc->num_op_reply_q); 1644} 1645 1646static DEVICE_ATTR_RO(reply_queue_count); 1647 1648/** 1649 * logging_level_show - Show controller debug level 1650 * @dev: class device 1651 * @attr: Device attributes 1652 * @buf: Buffer to copy 1653 * 1654 * A sysfs 'read/write' shost attribute, to show the current 1655 * debug log level used by the driver for the specific 1656 * controller. 1657 * 1658 * Return: sysfs_emit() return 1659 */ 1660static ssize_t 1661logging_level_show(struct device *dev, 1662 struct device_attribute *attr, char *buf) 1663 1664{ 1665 struct Scsi_Host *shost = class_to_shost(dev); 1666 struct mpi3mr_ioc *mrioc = shost_priv(shost); 1667 1668 return sysfs_emit(buf, "%08xh\n", mrioc->logging_level); 1669} 1670 1671/** 1672 * logging_level_store- Change controller debug level 1673 * @dev: class device 1674 * @attr: Device attributes 1675 * @buf: Buffer to copy 1676 * @count: size of the buffer 1677 * 1678 * A sysfs 'read/write' shost attribute, to change the current 1679 * debug log level used by the driver for the specific 1680 * controller. 1681 * 1682 * Return: strlen() return 1683 */ 1684static ssize_t 1685logging_level_store(struct device *dev, 1686 struct device_attribute *attr, 1687 const char *buf, size_t count) 1688{ 1689 struct Scsi_Host *shost = class_to_shost(dev); 1690 struct mpi3mr_ioc *mrioc = shost_priv(shost); 1691 int val = 0; 1692 1693 if (kstrtoint(buf, 0, &val) != 0) 1694 return -EINVAL; 1695 1696 mrioc->logging_level = val; 1697 ioc_info(mrioc, "logging_level=%08xh\n", mrioc->logging_level); 1698 return strlen(buf); 1699} 1700static DEVICE_ATTR_RW(logging_level); 1701 1702/** 1703 * adp_state_show() - SysFS callback for adapter state show 1704 * @dev: class device 1705 * @attr: Device attributes 1706 * @buf: Buffer to copy 1707 * 1708 * Return: sysfs_emit() return after copying adapter state 1709 */ 1710static ssize_t 1711adp_state_show(struct device *dev, struct device_attribute *attr, 1712 char *buf) 1713{ 1714 struct Scsi_Host *shost = class_to_shost(dev); 1715 struct mpi3mr_ioc *mrioc = shost_priv(shost); 1716 enum mpi3mr_iocstate ioc_state; 1717 uint8_t adp_state; 1718 1719 ioc_state = mpi3mr_get_iocstate(mrioc); 1720 if (ioc_state == MRIOC_STATE_UNRECOVERABLE) 1721 adp_state = MPI3MR_BSG_ADPSTATE_UNRECOVERABLE; 1722 else if ((mrioc->reset_in_progress) || (mrioc->stop_bsgs)) 1723 adp_state = MPI3MR_BSG_ADPSTATE_IN_RESET; 1724 else if (ioc_state == MRIOC_STATE_FAULT) 1725 adp_state = MPI3MR_BSG_ADPSTATE_FAULT; 1726 else 1727 adp_state = MPI3MR_BSG_ADPSTATE_OPERATIONAL; 1728 1729 return sysfs_emit(buf, "%u\n", adp_state); 1730} 1731 1732static DEVICE_ATTR_RO(adp_state); 1733 1734static struct attribute *mpi3mr_host_attrs[] = { 1735 &dev_attr_version_fw.attr, 1736 &dev_attr_fw_queue_depth.attr, 1737 &dev_attr_op_req_q_count.attr, 1738 &dev_attr_reply_queue_count.attr, 1739 &dev_attr_logging_level.attr, 1740 &dev_attr_adp_state.attr, 1741 NULL, 1742}; 1743 1744static const struct attribute_group mpi3mr_host_attr_group = { 1745 .attrs = mpi3mr_host_attrs 1746}; 1747 1748const struct attribute_group *mpi3mr_host_groups[] = { 1749 &mpi3mr_host_attr_group, 1750 NULL, 1751}; 1752 1753 1754/* 1755 * SCSI Device attributes under sysfs 1756 */ 1757 1758/** 1759 * sas_address_show - SysFS callback for dev SASaddress display 1760 * @dev: class device 1761 * @attr: Device attributes 1762 * @buf: Buffer to copy 1763 * 1764 * Return: sysfs_emit() return after copying SAS address of the 1765 * specific SAS/SATA end device. 1766 */ 1767static ssize_t 1768sas_address_show(struct device *dev, struct device_attribute *attr, 1769 char *buf) 1770{ 1771 struct scsi_device *sdev = to_scsi_device(dev); 1772 struct mpi3mr_sdev_priv_data *sdev_priv_data; 1773 struct mpi3mr_stgt_priv_data *tgt_priv_data; 1774 struct mpi3mr_tgt_dev *tgtdev; 1775 1776 sdev_priv_data = sdev->hostdata; 1777 if (!sdev_priv_data) 1778 return 0; 1779 1780 tgt_priv_data = sdev_priv_data->tgt_priv_data; 1781 if (!tgt_priv_data) 1782 return 0; 1783 tgtdev = tgt_priv_data->tgt_dev; 1784 if (!tgtdev || tgtdev->dev_type != MPI3_DEVICE_DEVFORM_SAS_SATA) 1785 return 0; 1786 return sysfs_emit(buf, "0x%016llx\n", 1787 (unsigned long long)tgtdev->dev_spec.sas_sata_inf.sas_address); 1788} 1789 1790static DEVICE_ATTR_RO(sas_address); 1791 1792/** 1793 * device_handle_show - SysFS callback for device handle display 1794 * @dev: class device 1795 * @attr: Device attributes 1796 * @buf: Buffer to copy 1797 * 1798 * Return: sysfs_emit() return after copying firmware internal 1799 * device handle of the specific device. 1800 */ 1801static ssize_t 1802device_handle_show(struct device *dev, struct device_attribute *attr, 1803 char *buf) 1804{ 1805 struct scsi_device *sdev = to_scsi_device(dev); 1806 struct mpi3mr_sdev_priv_data *sdev_priv_data; 1807 struct mpi3mr_stgt_priv_data *tgt_priv_data; 1808 struct mpi3mr_tgt_dev *tgtdev; 1809 1810 sdev_priv_data = sdev->hostdata; 1811 if (!sdev_priv_data) 1812 return 0; 1813 1814 tgt_priv_data = sdev_priv_data->tgt_priv_data; 1815 if (!tgt_priv_data) 1816 return 0; 1817 tgtdev = tgt_priv_data->tgt_dev; 1818 if (!tgtdev) 1819 return 0; 1820 return sysfs_emit(buf, "0x%04x\n", tgtdev->dev_handle); 1821} 1822 1823static DEVICE_ATTR_RO(device_handle); 1824 1825/** 1826 * persistent_id_show - SysFS callback for persisten ID display 1827 * @dev: class device 1828 * @attr: Device attributes 1829 * @buf: Buffer to copy 1830 * 1831 * Return: sysfs_emit() return after copying persistent ID of the 1832 * of the specific device. 1833 */ 1834static ssize_t 1835persistent_id_show(struct device *dev, struct device_attribute *attr, 1836 char *buf) 1837{ 1838 struct scsi_device *sdev = to_scsi_device(dev); 1839 struct mpi3mr_sdev_priv_data *sdev_priv_data; 1840 struct mpi3mr_stgt_priv_data *tgt_priv_data; 1841 struct mpi3mr_tgt_dev *tgtdev; 1842 1843 sdev_priv_data = sdev->hostdata; 1844 if (!sdev_priv_data) 1845 return 0; 1846 1847 tgt_priv_data = sdev_priv_data->tgt_priv_data; 1848 if (!tgt_priv_data) 1849 return 0; 1850 tgtdev = tgt_priv_data->tgt_dev; 1851 if (!tgtdev) 1852 return 0; 1853 return sysfs_emit(buf, "%d\n", tgtdev->perst_id); 1854} 1855static DEVICE_ATTR_RO(persistent_id); 1856 1857static struct attribute *mpi3mr_dev_attrs[] = { 1858 &dev_attr_sas_address.attr, 1859 &dev_attr_device_handle.attr, 1860 &dev_attr_persistent_id.attr, 1861 NULL, 1862}; 1863 1864static const struct attribute_group mpi3mr_dev_attr_group = { 1865 .attrs = mpi3mr_dev_attrs 1866}; 1867 1868const struct attribute_group *mpi3mr_dev_groups[] = { 1869 &mpi3mr_dev_attr_group, 1870 NULL, 1871}; 1872