mpi3mr_app.c

   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_alloc_trace_buffer: Allocate segmented trace buffer
  16 * @mrioc: Adapter instance reference
  17 * @trace_size: Trace buffer size
  18 *
  19 * Allocate either segmented memory pools or contiguous buffer
  20 * based on the controller capability for the host trace
  21 * buffer.
  22 *
  23 * Return: 0 on success, non-zero on failure.
  24 */
  25static int mpi3mr_alloc_trace_buffer(struct mpi3mr_ioc *mrioc, u32 trace_size)
  26{
  27	struct diag_buffer_desc *diag_buffer = &mrioc->diag_buffers[0];
  28	int i, sz;
  29	u64 *diag_buffer_list = NULL;
  30	dma_addr_t diag_buffer_list_dma;
  31	u32 seg_count;
  32
  33	if (mrioc->seg_tb_support) {
  34		seg_count = (trace_size) / MPI3MR_PAGE_SIZE_4K;
  35		trace_size = seg_count * MPI3MR_PAGE_SIZE_4K;
  36
  37		diag_buffer_list = dma_alloc_coherent(&mrioc->pdev->dev,
  38				sizeof(u64) * seg_count,
  39				&diag_buffer_list_dma, GFP_KERNEL);
  40		if (!diag_buffer_list)
  41			return -1;
  42
  43		mrioc->num_tb_segs = seg_count;
  44
  45		sz = sizeof(struct segments) * seg_count;
  46		mrioc->trace_buf = kzalloc(sz, GFP_KERNEL);
  47		if (!mrioc->trace_buf)
  48			goto trace_buf_failed;
  49
  50		mrioc->trace_buf_pool = dma_pool_create("trace_buf pool",
  51		    &mrioc->pdev->dev, MPI3MR_PAGE_SIZE_4K, MPI3MR_PAGE_SIZE_4K,
  52		    0);
  53		if (!mrioc->trace_buf_pool) {
  54			ioc_err(mrioc, "trace buf pool: dma_pool_create failed\n");
  55			goto trace_buf_pool_failed;
  56		}
  57
  58		for (i = 0; i < seg_count; i++) {
  59			mrioc->trace_buf[i].segment =
  60			    dma_pool_zalloc(mrioc->trace_buf_pool, GFP_KERNEL,
  61			    &mrioc->trace_buf[i].segment_dma);
  62			diag_buffer_list[i] =
  63			    (u64) mrioc->trace_buf[i].segment_dma;
  64			if (!diag_buffer_list[i])
  65				goto tb_seg_alloc_failed;
  66		}
  67
  68		diag_buffer->addr =  diag_buffer_list;
  69		diag_buffer->dma_addr = diag_buffer_list_dma;
  70		diag_buffer->is_segmented = true;
  71
  72		dprint_init(mrioc, "segmented trace diag buffer\n"
  73				"is allocated successfully seg_count:%d\n", seg_count);
  74		return 0;
  75	} else {
  76		diag_buffer->addr = dma_alloc_coherent(&mrioc->pdev->dev,
  77		    trace_size, &diag_buffer->dma_addr, GFP_KERNEL);
  78		if (diag_buffer->addr) {
  79			dprint_init(mrioc, "trace diag buffer is allocated successfully\n");
  80			return 0;
  81		}
  82		return -1;
  83	}
  84
  85tb_seg_alloc_failed:
  86	if (mrioc->trace_buf_pool) {
  87		for (i = 0; i < mrioc->num_tb_segs; i++) {
  88			if (mrioc->trace_buf[i].segment) {
  89				dma_pool_free(mrioc->trace_buf_pool,
  90				    mrioc->trace_buf[i].segment,
  91				    mrioc->trace_buf[i].segment_dma);
  92				mrioc->trace_buf[i].segment = NULL;
  93			}
  94			mrioc->trace_buf[i].segment = NULL;
  95		}
  96		dma_pool_destroy(mrioc->trace_buf_pool);
  97		mrioc->trace_buf_pool = NULL;
  98	}
  99trace_buf_pool_failed:
 100	kfree(mrioc->trace_buf);
 101	mrioc->trace_buf = NULL;
 102trace_buf_failed:
 103	if (diag_buffer_list)
 104		dma_free_coherent(&mrioc->pdev->dev,
 105		    sizeof(u64) * mrioc->num_tb_segs,
 106		    diag_buffer_list, diag_buffer_list_dma);
 107	return -1;
 108}
 109
 110/**
 111 * mpi3mr_alloc_diag_bufs - Allocate memory for diag buffers
 112 * @mrioc: Adapter instance reference
 113 *
 114 * This functions checks whether the driver defined buffer sizes
 115 * are greater than IOCFacts provided controller local buffer
 116 * sizes and if the driver defined sizes are more then the
 117 * driver allocates the specific buffer by reading driver page1
 118 *
 119 * Return: Nothing.
 120 */
 121void mpi3mr_alloc_diag_bufs(struct mpi3mr_ioc *mrioc)
 122{
 123	struct diag_buffer_desc *diag_buffer;
 124	struct mpi3_driver_page1 driver_pg1;
 125	u32 trace_dec_size, trace_min_size, fw_dec_size, fw_min_size,
 126		trace_size, fw_size;
 127	u16 pg_sz = sizeof(driver_pg1);
 128	int retval = 0;
 129	bool retry = false;
 130
 131	if (mrioc->diag_buffers[0].addr || mrioc->diag_buffers[1].addr)
 132		return;
 133
 134	retval = mpi3mr_cfg_get_driver_pg1(mrioc, &driver_pg1, pg_sz);
 135	if (retval) {
 136		ioc_warn(mrioc,
 137		    "%s: driver page 1 read failed, allocating trace\n"
 138		    "and firmware diag buffers of default size\n", __func__);
 139		trace_size = fw_size = MPI3MR_DEFAULT_HDB_MAX_SZ;
 140		trace_dec_size = fw_dec_size = MPI3MR_DEFAULT_HDB_DEC_SZ;
 141		trace_min_size = fw_min_size = MPI3MR_DEFAULT_HDB_MIN_SZ;
 142
 143	} else {
 144		trace_size = driver_pg1.host_diag_trace_max_size * 1024;
 145		trace_dec_size = driver_pg1.host_diag_trace_decrement_size
 146			 * 1024;
 147		trace_min_size = driver_pg1.host_diag_trace_min_size * 1024;
 148		fw_size = driver_pg1.host_diag_fw_max_size * 1024;
 149		fw_dec_size = driver_pg1.host_diag_fw_decrement_size * 1024;
 150		fw_min_size = driver_pg1.host_diag_fw_min_size * 1024;
 151		dprint_init(mrioc,
 152		    "%s:trace diag buffer sizes read from driver\n"
 153		    "page1: maximum size = %dKB, decrement size = %dKB\n"
 154		    ", minimum size = %dKB\n", __func__, driver_pg1.host_diag_trace_max_size,
 155		    driver_pg1.host_diag_trace_decrement_size,
 156		    driver_pg1.host_diag_trace_min_size);
 157		dprint_init(mrioc,
 158		    "%s:firmware diag buffer sizes read from driver\n"
 159		    "page1: maximum size = %dKB, decrement size = %dKB\n"
 160		    ", minimum size = %dKB\n", __func__, driver_pg1.host_diag_fw_max_size,
 161		    driver_pg1.host_diag_fw_decrement_size,
 162		    driver_pg1.host_diag_fw_min_size);
 163		if ((trace_size == 0) && (fw_size == 0))
 164			return;
 165	}
 166
 167
 168retry_trace:
 169	diag_buffer = &mrioc->diag_buffers[0];
 170	diag_buffer->type = MPI3_DIAG_BUFFER_TYPE_TRACE;
 171	diag_buffer->status = MPI3MR_HDB_BUFSTATUS_NOT_ALLOCATED;
 172	if ((mrioc->facts.diag_trace_sz < trace_size) && (trace_size >=
 173		trace_min_size)) {
 174		if (!retry)
 175			dprint_init(mrioc,
 176			    "trying to allocate trace diag buffer of size = %dKB\n",
 177			    trace_size / 1024);
 178		if ((!mrioc->seg_tb_support && (get_order(trace_size) > MAX_PAGE_ORDER)) ||
 179		    mpi3mr_alloc_trace_buffer(mrioc, trace_size)) {
 180
 181			retry = true;
 182			trace_size -= trace_dec_size;
 183			dprint_init(mrioc, "trace diag buffer allocation failed\n"
 184			"retrying smaller size %dKB\n", trace_size / 1024);
 185			goto retry_trace;
 186		} else
 187			diag_buffer->size = trace_size;
 188	}
 189
 190	retry = false;
 191retry_fw:
 192
 193	diag_buffer = &mrioc->diag_buffers[1];
 194
 195	diag_buffer->type = MPI3_DIAG_BUFFER_TYPE_FW;
 196	diag_buffer->status = MPI3MR_HDB_BUFSTATUS_NOT_ALLOCATED;
 197	if ((mrioc->facts.diag_fw_sz < fw_size) && (fw_size >= fw_min_size)) {
 198		if (get_order(fw_size) <= MAX_PAGE_ORDER) {
 199			diag_buffer->addr
 200				= dma_alloc_coherent(&mrioc->pdev->dev, fw_size,
 201						     &diag_buffer->dma_addr,
 202						     GFP_KERNEL);
 203		}
 204		if (!retry)
 205			dprint_init(mrioc,
 206			    "%s:trying to allocate firmware diag buffer of size = %dKB\n",
 207			    __func__, fw_size / 1024);
 208		if (diag_buffer->addr) {
 209			dprint_init(mrioc, "%s:firmware diag buffer allocated successfully\n",
 210			    __func__);
 211			diag_buffer->size = fw_size;
 212		} else {
 213			retry = true;
 214			fw_size -= fw_dec_size;
 215			dprint_init(mrioc, "%s:trace diag buffer allocation failed,\n"
 216					"retrying smaller size %dKB\n",
 217					__func__, fw_size / 1024);
 218			goto retry_fw;
 219		}
 220	}
 221}
 222
 223/**
 224 * mpi3mr_issue_diag_buf_post - Send diag buffer post req
 225 * @mrioc: Adapter instance reference
 226 * @diag_buffer: Diagnostic buffer descriptor
 227 *
 228 * Issue diagnostic buffer post MPI request through admin queue
 229 * and wait for the completion of it or time out.
 230 *
 231 * Return: 0 on success, non-zero on failures.
 232 */
 233int mpi3mr_issue_diag_buf_post(struct mpi3mr_ioc *mrioc,
 234	struct diag_buffer_desc *diag_buffer)
 235{
 236	struct mpi3_diag_buffer_post_request diag_buf_post_req;
 237	u8 prev_status;
 238	int retval = 0;
 239
 240	if (diag_buffer->disabled_after_reset) {
 241		dprint_bsg_err(mrioc, "%s: skipping diag buffer posting\n"
 242				"as it is disabled after reset\n", __func__);
 243		return -1;
 244	}
 245
 246	memset(&diag_buf_post_req, 0, sizeof(diag_buf_post_req));
 247	mutex_lock(&mrioc->init_cmds.mutex);
 248	if (mrioc->init_cmds.state & MPI3MR_CMD_PENDING) {
 249		dprint_bsg_err(mrioc, "%s: command is in use\n", __func__);
 250		mutex_unlock(&mrioc->init_cmds.mutex);
 251		return -1;
 252	}
 253	mrioc->init_cmds.state = MPI3MR_CMD_PENDING;
 254	mrioc->init_cmds.is_waiting = 1;
 255	mrioc->init_cmds.callback = NULL;
 256	diag_buf_post_req.host_tag = cpu_to_le16(MPI3MR_HOSTTAG_INITCMDS);
 257	diag_buf_post_req.function = MPI3_FUNCTION_DIAG_BUFFER_POST;
 258	diag_buf_post_req.type = diag_buffer->type;
 259	diag_buf_post_req.address = le64_to_cpu(diag_buffer->dma_addr);
 260	diag_buf_post_req.length = le32_to_cpu(diag_buffer->size);
 261
 262	if (diag_buffer->is_segmented)
 263		diag_buf_post_req.msg_flags |= MPI3_DIAG_BUFFER_POST_MSGFLAGS_SEGMENTED;
 264
 265	dprint_bsg_info(mrioc, "%s: posting diag buffer type %d segmented:%d\n", __func__,
 266	    diag_buffer->type, diag_buffer->is_segmented);
 267
 268	prev_status = diag_buffer->status;
 269	diag_buffer->status = MPI3MR_HDB_BUFSTATUS_POSTED_UNPAUSED;
 270	init_completion(&mrioc->init_cmds.done);
 271	retval = mpi3mr_admin_request_post(mrioc, &diag_buf_post_req,
 272	    sizeof(diag_buf_post_req), 1);
 273	if (retval) {
 274		dprint_bsg_err(mrioc, "%s: admin request post failed\n",
 275		    __func__);
 276		goto out_unlock;
 277	}
 278	wait_for_completion_timeout(&mrioc->init_cmds.done,
 279	    (MPI3MR_INTADMCMD_TIMEOUT * HZ));
 280	if (!(mrioc->init_cmds.state & MPI3MR_CMD_COMPLETE)) {
 281		mrioc->init_cmds.is_waiting = 0;
 282		dprint_bsg_err(mrioc, "%s: command timedout\n", __func__);
 283		mpi3mr_check_rh_fault_ioc(mrioc,
 284		    MPI3MR_RESET_FROM_DIAG_BUFFER_POST_TIMEOUT);
 285		retval = -1;
 286		goto out_unlock;
 287	}
 288	if ((mrioc->init_cmds.ioc_status & MPI3_IOCSTATUS_STATUS_MASK)
 289	    != MPI3_IOCSTATUS_SUCCESS) {
 290		dprint_bsg_err(mrioc,
 291		    "%s: command failed, buffer_type (%d) ioc_status(0x%04x) log_info(0x%08x)\n",
 292		    __func__, diag_buffer->type,
 293		    (mrioc->init_cmds.ioc_status & MPI3_IOCSTATUS_STATUS_MASK),
 294		    mrioc->init_cmds.ioc_loginfo);
 295		retval = -1;
 296		goto out_unlock;
 297	}
 298	dprint_bsg_info(mrioc, "%s: diag buffer type %d posted successfully\n",
 299	    __func__, diag_buffer->type);
 300
 301out_unlock:
 302	if (retval)
 303		diag_buffer->status = prev_status;
 304	mrioc->init_cmds.state = MPI3MR_CMD_NOTUSED;
 305	mutex_unlock(&mrioc->init_cmds.mutex);
 306	return retval;
 307}
 308
 309/**
 310 * mpi3mr_post_diag_bufs - Post diag buffers to the controller
 311 * @mrioc: Adapter instance reference
 312 *
 313 * This function calls helper function to post both trace and
 314 * firmware buffers to the controller.
 315 *
 316 * Return: None
 317 */
 318int mpi3mr_post_diag_bufs(struct mpi3mr_ioc *mrioc)
 319{
 320	u8 i;
 321	struct diag_buffer_desc *diag_buffer;
 322
 323	for (i = 0; i < MPI3MR_MAX_NUM_HDB; i++) {
 324		diag_buffer = &mrioc->diag_buffers[i];
 325		if (!(diag_buffer->addr))
 326			continue;
 327		if (mpi3mr_issue_diag_buf_post(mrioc, diag_buffer))
 328			return -1;
 329	}
 330	return 0;
 331}
 332
 333/**
 334 * mpi3mr_issue_diag_buf_release - Send diag buffer release req
 335 * @mrioc: Adapter instance reference
 336 * @diag_buffer: Diagnostic buffer descriptor
 337 *
 338 * Issue diagnostic buffer manage MPI request with release
 339 * action request through admin queue and wait for the
 340 * completion of it or time out.
 341 *
 342 * Return: 0 on success, non-zero on failures.
 343 */
 344int mpi3mr_issue_diag_buf_release(struct mpi3mr_ioc *mrioc,
 345	struct diag_buffer_desc *diag_buffer)
 346{
 347	struct mpi3_diag_buffer_manage_request diag_buf_manage_req;
 348	int retval = 0;
 349
 350	if ((diag_buffer->status != MPI3MR_HDB_BUFSTATUS_POSTED_UNPAUSED) &&
 351	    (diag_buffer->status != MPI3MR_HDB_BUFSTATUS_POSTED_PAUSED))
 352		return retval;
 353
 354	memset(&diag_buf_manage_req, 0, sizeof(diag_buf_manage_req));
 355	mutex_lock(&mrioc->init_cmds.mutex);
 356	if (mrioc->init_cmds.state & MPI3MR_CMD_PENDING) {
 357		dprint_reset(mrioc, "%s: command is in use\n", __func__);
 358		mutex_unlock(&mrioc->init_cmds.mutex);
 359		return -1;
 360	}
 361	mrioc->init_cmds.state = MPI3MR_CMD_PENDING;
 362	mrioc->init_cmds.is_waiting = 1;
 363	mrioc->init_cmds.callback = NULL;
 364	diag_buf_manage_req.host_tag = cpu_to_le16(MPI3MR_HOSTTAG_INITCMDS);
 365	diag_buf_manage_req.function = MPI3_FUNCTION_DIAG_BUFFER_MANAGE;
 366	diag_buf_manage_req.type = diag_buffer->type;
 367	diag_buf_manage_req.action = MPI3_DIAG_BUFFER_ACTION_RELEASE;
 368
 369
 370	dprint_reset(mrioc, "%s: releasing diag buffer type %d\n", __func__,
 371	    diag_buffer->type);
 372	init_completion(&mrioc->init_cmds.done);
 373	retval = mpi3mr_admin_request_post(mrioc, &diag_buf_manage_req,
 374	    sizeof(diag_buf_manage_req), 1);
 375	if (retval) {
 376		dprint_reset(mrioc, "%s: admin request post failed\n", __func__);
 377		mpi3mr_set_trigger_data_in_hdb(diag_buffer,
 378		    MPI3MR_HDB_TRIGGER_TYPE_UNKNOWN, NULL, 1);
 379		goto out_unlock;
 380	}
 381	wait_for_completion_timeout(&mrioc->init_cmds.done,
 382	    (MPI3MR_INTADMCMD_TIMEOUT * HZ));
 383	if (!(mrioc->init_cmds.state & MPI3MR_CMD_COMPLETE)) {
 384		mrioc->init_cmds.is_waiting = 0;
 385		dprint_reset(mrioc, "%s: command timedout\n", __func__);
 386		mpi3mr_check_rh_fault_ioc(mrioc,
 387		    MPI3MR_RESET_FROM_DIAG_BUFFER_RELEASE_TIMEOUT);
 388		retval = -1;
 389		goto out_unlock;
 390	}
 391	if ((mrioc->init_cmds.ioc_status & MPI3_IOCSTATUS_STATUS_MASK)
 392	    != MPI3_IOCSTATUS_SUCCESS) {
 393		dprint_reset(mrioc,
 394		    "%s: command failed, buffer_type (%d) ioc_status(0x%04x) log_info(0x%08x)\n",
 395		    __func__, diag_buffer->type,
 396		    (mrioc->init_cmds.ioc_status & MPI3_IOCSTATUS_STATUS_MASK),
 397		    mrioc->init_cmds.ioc_loginfo);
 398		retval = -1;
 399		goto out_unlock;
 400	}
 401	dprint_reset(mrioc, "%s: diag buffer type %d released successfully\n",
 402	    __func__, diag_buffer->type);
 403
 404out_unlock:
 405	mrioc->init_cmds.state = MPI3MR_CMD_NOTUSED;
 406	mutex_unlock(&mrioc->init_cmds.mutex);
 407	return retval;
 408}
 409
 410/**
 411 * mpi3mr_process_trigger - Generic HDB Trigger handler
 412 * @mrioc: Adapter instance reference
 413 * @trigger_type: Trigger type
 414 * @trigger_data: Trigger data
 415 * @trigger_flags: Trigger flags
 416 *
 417 * This function checks validity of HDB, triggers and based on
 418 * trigger information, creates an event to be processed in the
 419 * firmware event worker thread .
 420 *
 421 * This function should be called with trigger spinlock held
 422 *
 423 * Return: Nothing
 424 */
 425static void mpi3mr_process_trigger(struct mpi3mr_ioc *mrioc, u8 trigger_type,
 426	union mpi3mr_trigger_data *trigger_data, u8 trigger_flags)
 427{
 428	struct trigger_event_data event_data;
 429	struct diag_buffer_desc *trace_hdb = NULL;
 430	struct diag_buffer_desc *fw_hdb = NULL;
 431	u64 global_trigger;
 432
 433	trace_hdb = mpi3mr_diag_buffer_for_type(mrioc,
 434	    MPI3_DIAG_BUFFER_TYPE_TRACE);
 435	if (trace_hdb &&
 436	    (trace_hdb->status != MPI3MR_HDB_BUFSTATUS_POSTED_UNPAUSED) &&
 437	    (trace_hdb->status != MPI3MR_HDB_BUFSTATUS_POSTED_PAUSED))
 438		trace_hdb =  NULL;
 439
 440	fw_hdb = mpi3mr_diag_buffer_for_type(mrioc, MPI3_DIAG_BUFFER_TYPE_FW);
 441
 442	if (fw_hdb &&
 443	    (fw_hdb->status != MPI3MR_HDB_BUFSTATUS_POSTED_UNPAUSED) &&
 444	    (fw_hdb->status != MPI3MR_HDB_BUFSTATUS_POSTED_PAUSED))
 445		fw_hdb = NULL;
 446
 447	if (mrioc->snapdump_trigger_active || (mrioc->fw_release_trigger_active
 448	    && mrioc->trace_release_trigger_active) ||
 449	    (!trace_hdb && !fw_hdb) || (!mrioc->driver_pg2) ||
 450	    ((trigger_type == MPI3MR_HDB_TRIGGER_TYPE_ELEMENT)
 451	     && (!mrioc->driver_pg2->num_triggers)))
 452		return;
 453
 454	memset(&event_data, 0, sizeof(event_data));
 455	event_data.trigger_type = trigger_type;
 456	memcpy(&event_data.trigger_specific_data, trigger_data,
 457	    sizeof(*trigger_data));
 458	global_trigger = le64_to_cpu(mrioc->driver_pg2->global_trigger);
 459
 460	if (global_trigger & MPI3_DRIVER2_GLOBALTRIGGER_SNAPDUMP_ENABLED) {
 461		event_data.snapdump = true;
 462		event_data.trace_hdb = trace_hdb;
 463		event_data.fw_hdb = fw_hdb;
 464		mrioc->snapdump_trigger_active = true;
 465	} else if (trigger_type == MPI3MR_HDB_TRIGGER_TYPE_GLOBAL) {
 466		if ((trace_hdb) && (global_trigger &
 467		    MPI3_DRIVER2_GLOBALTRIGGER_DIAG_TRACE_RELEASE) &&
 468		    (!mrioc->trace_release_trigger_active)) {
 469			event_data.trace_hdb = trace_hdb;
 470			mrioc->trace_release_trigger_active = true;
 471		}
 472		if ((fw_hdb) && (global_trigger &
 473		    MPI3_DRIVER2_GLOBALTRIGGER_DIAG_FW_RELEASE) &&
 474		    (!mrioc->fw_release_trigger_active)) {
 475			event_data.fw_hdb = fw_hdb;
 476			mrioc->fw_release_trigger_active = true;
 477		}
 478	} else if (trigger_type == MPI3MR_HDB_TRIGGER_TYPE_ELEMENT) {
 479		if ((trace_hdb) && (trigger_flags &
 480		    MPI3_DRIVER2_TRIGGER_FLAGS_DIAG_TRACE_RELEASE) &&
 481		    (!mrioc->trace_release_trigger_active)) {
 482			event_data.trace_hdb = trace_hdb;
 483			mrioc->trace_release_trigger_active = true;
 484		}
 485		if ((fw_hdb) && (trigger_flags &
 486		    MPI3_DRIVER2_TRIGGER_FLAGS_DIAG_FW_RELEASE) &&
 487		    (!mrioc->fw_release_trigger_active)) {
 488			event_data.fw_hdb = fw_hdb;
 489			mrioc->fw_release_trigger_active = true;
 490		}
 491	}
 492
 493	if (event_data.trace_hdb || event_data.fw_hdb)
 494		mpi3mr_hdb_trigger_data_event(mrioc, &event_data);
 495}
 496
 497/**
 498 * mpi3mr_global_trigger - Global HDB trigger handler
 499 * @mrioc: Adapter instance reference
 500 * @trigger_data: Trigger data
 501 *
 502 * This function checks whether the given global trigger is
 503 * enabled in the driver page 2 and if so calls generic trigger
 504 * handler to queue event for HDB release.
 505 *
 506 * Return: Nothing
 507 */
 508void mpi3mr_global_trigger(struct mpi3mr_ioc *mrioc, u64 trigger_data)
 509{
 510	unsigned long flags;
 511	union mpi3mr_trigger_data trigger_specific_data;
 512
 513	spin_lock_irqsave(&mrioc->trigger_lock, flags);
 514	if (le64_to_cpu(mrioc->driver_pg2->global_trigger) & trigger_data) {
 515		memset(&trigger_specific_data, 0,
 516		    sizeof(trigger_specific_data));
 517		trigger_specific_data.global = trigger_data;
 518		mpi3mr_process_trigger(mrioc, MPI3MR_HDB_TRIGGER_TYPE_GLOBAL,
 519		    &trigger_specific_data, 0);
 520	}
 521	spin_unlock_irqrestore(&mrioc->trigger_lock, flags);
 522}
 523
 524/**
 525 * mpi3mr_scsisense_trigger - SCSI sense HDB trigger handler
 526 * @mrioc: Adapter instance reference
 527 * @sensekey: Sense Key
 528 * @asc: Additional Sense Code
 529 * @ascq: Additional Sense Code Qualifier
 530 *
 531 * This function compares SCSI sense trigger values with driver
 532 * page 2 values and calls generic trigger handler to release
 533 * HDBs if match found
 534 *
 535 * Return: Nothing
 536 */
 537void mpi3mr_scsisense_trigger(struct mpi3mr_ioc *mrioc, u8 sensekey, u8 asc,
 538	u8 ascq)
 539{
 540	struct mpi3_driver2_trigger_scsi_sense *scsi_sense_trigger = NULL;
 541	u64 i = 0;
 542	unsigned long flags;
 543	u8 num_triggers, trigger_flags;
 544
 545	if (mrioc->scsisense_trigger_present) {
 546		spin_lock_irqsave(&mrioc->trigger_lock, flags);
 547		scsi_sense_trigger = (struct mpi3_driver2_trigger_scsi_sense *)
 548			mrioc->driver_pg2->trigger;
 549		num_triggers = mrioc->driver_pg2->num_triggers;
 550		for (i = 0; i < num_triggers; i++, scsi_sense_trigger++) {
 551			if (scsi_sense_trigger->type !=
 552			    MPI3_DRIVER2_TRIGGER_TYPE_SCSI_SENSE)
 553				continue;
 554			if (!(scsi_sense_trigger->sense_key ==
 555			    MPI3_DRIVER2_TRIGGER_SCSI_SENSE_SENSE_KEY_MATCH_ALL
 556			      || scsi_sense_trigger->sense_key == sensekey))
 557				continue;
 558			if (!(scsi_sense_trigger->asc ==
 559			    MPI3_DRIVER2_TRIGGER_SCSI_SENSE_ASC_MATCH_ALL ||
 560			    scsi_sense_trigger->asc == asc))
 561				continue;
 562			if (!(scsi_sense_trigger->ascq ==
 563			    MPI3_DRIVER2_TRIGGER_SCSI_SENSE_ASCQ_MATCH_ALL ||
 564			    scsi_sense_trigger->ascq == ascq))
 565				continue;
 566			trigger_flags = scsi_sense_trigger->flags;
 567			mpi3mr_process_trigger(mrioc,
 568			    MPI3MR_HDB_TRIGGER_TYPE_ELEMENT,
 569			    (union mpi3mr_trigger_data *)scsi_sense_trigger,
 570			    trigger_flags);
 571			break;
 572		}
 573		spin_unlock_irqrestore(&mrioc->trigger_lock, flags);
 574	}
 575}
 576
 577/**
 578 * mpi3mr_event_trigger - MPI event HDB trigger handler
 579 * @mrioc: Adapter instance reference
 580 * @event: MPI Event
 581 *
 582 * This function compares event trigger values with driver page
 583 * 2 values and calls generic trigger handler to release
 584 * HDBs if match found.
 585 *
 586 * Return: Nothing
 587 */
 588void mpi3mr_event_trigger(struct mpi3mr_ioc *mrioc, u8 event)
 589{
 590	struct mpi3_driver2_trigger_event *event_trigger = NULL;
 591	u64 i = 0;
 592	unsigned long flags;
 593	u8 num_triggers, trigger_flags;
 594
 595	if (mrioc->event_trigger_present) {
 596		spin_lock_irqsave(&mrioc->trigger_lock, flags);
 597		event_trigger = (struct mpi3_driver2_trigger_event *)
 598			mrioc->driver_pg2->trigger;
 599		num_triggers = mrioc->driver_pg2->num_triggers;
 600
 601		for (i = 0; i < num_triggers; i++, event_trigger++) {
 602			if (event_trigger->type !=
 603			    MPI3_DRIVER2_TRIGGER_TYPE_EVENT)
 604				continue;
 605			if (event_trigger->event != event)
 606				continue;
 607			trigger_flags = event_trigger->flags;
 608			mpi3mr_process_trigger(mrioc,
 609			    MPI3MR_HDB_TRIGGER_TYPE_ELEMENT,
 610			    (union mpi3mr_trigger_data *)event_trigger,
 611			    trigger_flags);
 612			break;
 613		}
 614		spin_unlock_irqrestore(&mrioc->trigger_lock, flags);
 615	}
 616}
 617
 618/**
 619 * mpi3mr_reply_trigger - MPI Reply HDB trigger handler
 620 * @mrioc: Adapter instance reference
 621 * @ioc_status: Masked value of IOC Status from MPI Reply
 622 * @ioc_loginfo: IOC Log Info from MPI Reply
 623 *
 624 * This function compares IOC status and IOC log info trigger
 625 * values with driver page 2 values and calls generic trigger
 626 * handler to release HDBs if match found.
 627 *
 628 * Return: Nothing
 629 */
 630void mpi3mr_reply_trigger(struct mpi3mr_ioc *mrioc, u16 ioc_status,
 631	u32 ioc_loginfo)
 632{
 633	struct mpi3_driver2_trigger_reply *reply_trigger = NULL;
 634	u64 i = 0;
 635	unsigned long flags;
 636	u8 num_triggers, trigger_flags;
 637
 638	if (mrioc->reply_trigger_present) {
 639		spin_lock_irqsave(&mrioc->trigger_lock, flags);
 640		reply_trigger = (struct mpi3_driver2_trigger_reply *)
 641			mrioc->driver_pg2->trigger;
 642		num_triggers = mrioc->driver_pg2->num_triggers;
 643		for (i = 0; i < num_triggers; i++, reply_trigger++) {
 644			if (reply_trigger->type !=
 645			    MPI3_DRIVER2_TRIGGER_TYPE_REPLY)
 646				continue;
 647			if ((le16_to_cpu(reply_trigger->ioc_status) !=
 648			     ioc_status)
 649			    && (le16_to_cpu(reply_trigger->ioc_status) !=
 650			    MPI3_DRIVER2_TRIGGER_REPLY_IOCSTATUS_MATCH_ALL))
 651				continue;
 652			if ((le32_to_cpu(reply_trigger->ioc_log_info) !=
 653			    (le32_to_cpu(reply_trigger->ioc_log_info_mask) &
 654			     ioc_loginfo)))
 655				continue;
 656			trigger_flags = reply_trigger->flags;
 657			mpi3mr_process_trigger(mrioc,
 658			    MPI3MR_HDB_TRIGGER_TYPE_ELEMENT,
 659			    (union mpi3mr_trigger_data *)reply_trigger,
 660			    trigger_flags);
 661			break;
 662		}
 663		spin_unlock_irqrestore(&mrioc->trigger_lock, flags);
 664	}
 665}
 666
 667/**
 668 * mpi3mr_get_num_trigger - Gets number of HDB triggers
 669 * @mrioc: Adapter instance reference
 670 * @num_triggers: Number of triggers
 671 * @page_action: Page action
 672 *
 673 * This function reads number of triggers by reading driver page
 674 * 2
 675 *
 676 * Return: 0 on success and proper error codes on failure
 677 */
 678static int mpi3mr_get_num_trigger(struct mpi3mr_ioc *mrioc, u8 *num_triggers,
 679	u8 page_action)
 680{
 681	struct mpi3_driver_page2 drvr_page2;
 682	int retval = 0;
 683
 684	*num_triggers = 0;
 685
 686	retval = mpi3mr_cfg_get_driver_pg2(mrioc, &drvr_page2,
 687	    sizeof(struct mpi3_driver_page2), page_action);
 688
 689	if (retval) {
 690		dprint_init(mrioc, "%s: driver page 2 read failed\n", __func__);
 691		return retval;
 692	}
 693	*num_triggers = drvr_page2.num_triggers;
 694	return retval;
 695}
 696
 697/**
 698 * mpi3mr_refresh_trigger - Handler for Refresh trigger BSG
 699 * @mrioc: Adapter instance reference
 700 * @page_action: Page action
 701 *
 702 * This function caches the driver page 2 in the driver's memory
 703 * by reading driver page 2 from the controller for a given page
 704 * type and updates the HDB trigger values
 705 *
 706 * Return: 0 on success and proper error codes on failure
 707 */
 708int mpi3mr_refresh_trigger(struct mpi3mr_ioc *mrioc, u8 page_action)
 709{
 710	u16 pg_sz = sizeof(struct mpi3_driver_page2);
 711	struct mpi3_driver_page2 *drvr_page2 = NULL;
 712	u8 trigger_type, num_triggers;
 713	int retval;
 714	int i = 0;
 715	unsigned long flags;
 716
 717	retval = mpi3mr_get_num_trigger(mrioc, &num_triggers, page_action);
 718
 719	if (retval)
 720		goto out;
 721
 722	pg_sz = offsetof(struct mpi3_driver_page2, trigger) +
 723		(num_triggers * sizeof(union mpi3_driver2_trigger_element));
 724	drvr_page2 = kzalloc(pg_sz, GFP_KERNEL);
 725	if (!drvr_page2) {
 726		retval = -ENOMEM;
 727		goto out;
 728	}
 729
 730	retval = mpi3mr_cfg_get_driver_pg2(mrioc, drvr_page2, pg_sz, page_action);
 731	if (retval) {
 732		dprint_init(mrioc, "%s: driver page 2 read failed\n", __func__);
 733		kfree(drvr_page2);
 734		goto out;
 735	}
 736	spin_lock_irqsave(&mrioc->trigger_lock, flags);
 737	kfree(mrioc->driver_pg2);
 738	mrioc->driver_pg2 = drvr_page2;
 739	mrioc->reply_trigger_present = false;
 740	mrioc->event_trigger_present = false;
 741	mrioc->scsisense_trigger_present = false;
 742
 743	for (i = 0; (i < mrioc->driver_pg2->num_triggers); i++) {
 744		trigger_type = mrioc->driver_pg2->trigger[i].event.type;
 745		switch (trigger_type) {
 746		case MPI3_DRIVER2_TRIGGER_TYPE_REPLY:
 747			mrioc->reply_trigger_present = true;
 748			break;
 749		case MPI3_DRIVER2_TRIGGER_TYPE_EVENT:
 750			mrioc->event_trigger_present = true;
 751			break;
 752		case MPI3_DRIVER2_TRIGGER_TYPE_SCSI_SENSE:
 753			mrioc->scsisense_trigger_present = true;
 754			break;
 755		default:
 756			break;
 757		}
 758	}
 759	spin_unlock_irqrestore(&mrioc->trigger_lock, flags);
 760out:
 761	return retval;
 762}
 763
 764/**
 765 * mpi3mr_release_diag_bufs - Release diag buffers
 766 * @mrioc: Adapter instance reference
 767 * @skip_rel_action: Skip release action and set buffer state
 768 *
 769 * This function calls helper function to release both trace and
 770 * firmware buffers from the controller.
 771 *
 772 * Return: None
 773 */
 774void mpi3mr_release_diag_bufs(struct mpi3mr_ioc *mrioc, u8 skip_rel_action)
 775{
 776	u8 i;
 777	struct diag_buffer_desc *diag_buffer;
 778
 779	for (i = 0; i < MPI3MR_MAX_NUM_HDB; i++) {
 780		diag_buffer = &mrioc->diag_buffers[i];
 781		if (!(diag_buffer->addr))
 782			continue;
 783		if (diag_buffer->status == MPI3MR_HDB_BUFSTATUS_RELEASED)
 784			continue;
 785		if (!skip_rel_action)
 786			mpi3mr_issue_diag_buf_release(mrioc, diag_buffer);
 787		diag_buffer->status = MPI3MR_HDB_BUFSTATUS_RELEASED;
 788		atomic64_inc(&event_counter);
 789	}
 790}
 791
 792/**
 793 * mpi3mr_set_trigger_data_in_hdb - Updates HDB trigger type and
 794 * trigger data
 795 *
 796 * @hdb: HDB pointer
 797 * @type: Trigger type
 798 * @trigger_data: Pointer to trigger data information
 799 * @force: Trigger overwrite flag
 800 *
 801 * Updates trigger type and trigger data based on parameter
 802 * passed to this function
 803 *
 804 * Return: Nothing
 805 */
 806void mpi3mr_set_trigger_data_in_hdb(struct diag_buffer_desc *hdb,
 807	u8 type, union mpi3mr_trigger_data *trigger_data, bool force)
 808{
 809	if ((!force) && (hdb->trigger_type != MPI3MR_HDB_TRIGGER_TYPE_UNKNOWN))
 810		return;
 811	hdb->trigger_type = type;
 812	if (!trigger_data)
 813		memset(&hdb->trigger_data, 0, sizeof(*trigger_data));
 814	else
 815		memcpy(&hdb->trigger_data, trigger_data, sizeof(*trigger_data));
 816}
 817
 818/**
 819 * mpi3mr_set_trigger_data_in_all_hdb - Updates HDB trigger type
 820 * and trigger data for all HDB
 821 *
 822 * @mrioc: Adapter instance reference
 823 * @type: Trigger type
 824 * @trigger_data: Pointer to trigger data information
 825 * @force: Trigger overwrite flag
 826 *
 827 * Updates trigger type and trigger data based on parameter
 828 * passed to this function
 829 *
 830 * Return: Nothing
 831 */
 832void mpi3mr_set_trigger_data_in_all_hdb(struct mpi3mr_ioc *mrioc,
 833	u8 type, union mpi3mr_trigger_data *trigger_data, bool force)
 834{
 835	struct diag_buffer_desc *hdb = NULL;
 836
 837	hdb = mpi3mr_diag_buffer_for_type(mrioc, MPI3_DIAG_BUFFER_TYPE_TRACE);
 838	if (hdb)
 839		mpi3mr_set_trigger_data_in_hdb(hdb, type, trigger_data, force);
 840	hdb = mpi3mr_diag_buffer_for_type(mrioc, MPI3_DIAG_BUFFER_TYPE_FW);
 841	if (hdb)
 842		mpi3mr_set_trigger_data_in_hdb(hdb, type, trigger_data, force);
 843}
 844
 845/**
 846 * mpi3mr_hdbstatuschg_evt_th - HDB status change evt tophalf
 847 * @mrioc: Adapter instance reference
 848 * @event_reply: event data
 849 *
 850 * Modifies the status of the applicable diag buffer descriptors
 851 *
 852 * Return: Nothing
 853 */
 854void mpi3mr_hdbstatuschg_evt_th(struct mpi3mr_ioc *mrioc,
 855	struct mpi3_event_notification_reply *event_reply)
 856{
 857	struct mpi3_event_data_diag_buffer_status_change *evtdata;
 858	struct diag_buffer_desc *diag_buffer;
 859
 860	evtdata = (struct mpi3_event_data_diag_buffer_status_change *)
 861	    event_reply->event_data;
 862
 863	diag_buffer = mpi3mr_diag_buffer_for_type(mrioc, evtdata->type);
 864	if (!diag_buffer)
 865		return;
 866	if ((diag_buffer->status != MPI3MR_HDB_BUFSTATUS_POSTED_UNPAUSED) &&
 867	    (diag_buffer->status != MPI3MR_HDB_BUFSTATUS_POSTED_PAUSED))
 868		return;
 869	switch (evtdata->reason_code) {
 870	case MPI3_EVENT_DIAG_BUFFER_STATUS_CHANGE_RC_RELEASED:
 871	{
 872		diag_buffer->status = MPI3MR_HDB_BUFSTATUS_RELEASED;
 873		mpi3mr_set_trigger_data_in_hdb(diag_buffer,
 874		    MPI3MR_HDB_TRIGGER_TYPE_FW_RELEASED, NULL, 0);
 875		atomic64_inc(&event_counter);
 876		break;
 877	}
 878	case MPI3_EVENT_DIAG_BUFFER_STATUS_CHANGE_RC_RESUMED:
 879	{
 880		diag_buffer->status = MPI3MR_HDB_BUFSTATUS_POSTED_UNPAUSED;
 881		break;
 882	}
 883	case MPI3_EVENT_DIAG_BUFFER_STATUS_CHANGE_RC_PAUSED:
 884	{
 885		diag_buffer->status = MPI3MR_HDB_BUFSTATUS_POSTED_PAUSED;
 886		break;
 887	}
 888	default:
 889		dprint_event_th(mrioc, "%s: unknown reason_code(%d)\n",
 890		    __func__, evtdata->reason_code);
 891		break;
 892	}
 893}
 894
 895/**
 896 * mpi3mr_diag_buffer_for_type - returns buffer desc for type
 897 * @mrioc: Adapter instance reference
 898 * @buf_type: Diagnostic buffer type
 899 *
 900 * Identifies matching diag descriptor from mrioc for given diag
 901 * buffer type.
 902 *
 903 * Return: diag buffer descriptor on success, NULL on failures.
 904 */
 905
 906struct diag_buffer_desc *
 907mpi3mr_diag_buffer_for_type(struct mpi3mr_ioc *mrioc, u8 buf_type)
 908{
 909	u8 i;
 910
 911	for (i = 0; i < MPI3MR_MAX_NUM_HDB; i++) {
 912		if (mrioc->diag_buffers[i].type == buf_type)
 913			return &mrioc->diag_buffers[i];
 914	}
 915	return NULL;
 916}
 917
 918/**
 919 * mpi3mr_bsg_pel_abort - sends PEL abort request
 920 * @mrioc: Adapter instance reference
 921 *
 922 * This function sends PEL abort request to the firmware through
 923 * admin request queue.
 924 *
 925 * Return: 0 on success, -1 on failure
 926 */
 927static int mpi3mr_bsg_pel_abort(struct mpi3mr_ioc *mrioc)
 928{
 929	struct mpi3_pel_req_action_abort pel_abort_req;
 930	struct mpi3_pel_reply *pel_reply;
 931	int retval = 0;
 932	u16 pe_log_status;
 933
 934	if (mrioc->reset_in_progress) {
 935		dprint_bsg_err(mrioc, "%s: reset in progress\n", __func__);
 936		return -1;
 937	}
 938	if (mrioc->stop_bsgs || mrioc->block_on_pci_err) {
 939		dprint_bsg_err(mrioc, "%s: bsgs are blocked\n", __func__);
 940		return -1;
 941	}
 942
 943	memset(&pel_abort_req, 0, sizeof(pel_abort_req));
 944	mutex_lock(&mrioc->pel_abort_cmd.mutex);
 945	if (mrioc->pel_abort_cmd.state & MPI3MR_CMD_PENDING) {
 946		dprint_bsg_err(mrioc, "%s: command is in use\n", __func__);
 947		mutex_unlock(&mrioc->pel_abort_cmd.mutex);
 948		return -1;
 949	}
 950	mrioc->pel_abort_cmd.state = MPI3MR_CMD_PENDING;
 951	mrioc->pel_abort_cmd.is_waiting = 1;
 952	mrioc->pel_abort_cmd.callback = NULL;
 953	pel_abort_req.host_tag = cpu_to_le16(MPI3MR_HOSTTAG_PEL_ABORT);
 954	pel_abort_req.function = MPI3_FUNCTION_PERSISTENT_EVENT_LOG;
 955	pel_abort_req.action = MPI3_PEL_ACTION_ABORT;
 956	pel_abort_req.abort_host_tag = cpu_to_le16(MPI3MR_HOSTTAG_PEL_WAIT);
 957
 958	mrioc->pel_abort_requested = 1;
 959	init_completion(&mrioc->pel_abort_cmd.done);
 960	retval = mpi3mr_admin_request_post(mrioc, &pel_abort_req,
 961	    sizeof(pel_abort_req), 0);
 962	if (retval) {
 963		retval = -1;
 964		dprint_bsg_err(mrioc, "%s: admin request post failed\n",
 965		    __func__);
 966		mrioc->pel_abort_requested = 0;
 967		goto out_unlock;
 968	}
 969
 970	wait_for_completion_timeout(&mrioc->pel_abort_cmd.done,
 971	    (MPI3MR_INTADMCMD_TIMEOUT * HZ));
 972	if (!(mrioc->pel_abort_cmd.state & MPI3MR_CMD_COMPLETE)) {
 973		mrioc->pel_abort_cmd.is_waiting = 0;
 974		dprint_bsg_err(mrioc, "%s: command timedout\n", __func__);
 975		if (!(mrioc->pel_abort_cmd.state & MPI3MR_CMD_RESET))
 976			mpi3mr_soft_reset_handler(mrioc,
 977			    MPI3MR_RESET_FROM_PELABORT_TIMEOUT, 1);
 978		retval = -1;
 979		goto out_unlock;
 980	}
 981	if ((mrioc->pel_abort_cmd.ioc_status & MPI3_IOCSTATUS_STATUS_MASK)
 982	     != MPI3_IOCSTATUS_SUCCESS) {
 983		dprint_bsg_err(mrioc,
 984		    "%s: command failed, ioc_status(0x%04x) log_info(0x%08x)\n",
 985		    __func__, (mrioc->pel_abort_cmd.ioc_status &
 986		    MPI3_IOCSTATUS_STATUS_MASK),
 987		    mrioc->pel_abort_cmd.ioc_loginfo);
 988		retval = -1;
 989		goto out_unlock;
 990	}
 991	if (mrioc->pel_abort_cmd.state & MPI3MR_CMD_REPLY_VALID) {
 992		pel_reply = (struct mpi3_pel_reply *)mrioc->pel_abort_cmd.reply;
 993		pe_log_status = le16_to_cpu(pel_reply->pe_log_status);
 994		if (pe_log_status != MPI3_PEL_STATUS_SUCCESS) {
 995			dprint_bsg_err(mrioc,
 996			    "%s: command failed, pel_status(0x%04x)\n",
 997			    __func__, pe_log_status);
 998			retval = -1;
 999		}
1000	}
1001
1002out_unlock:
1003	mrioc->pel_abort_cmd.state = MPI3MR_CMD_NOTUSED;
1004	mutex_unlock(&mrioc->pel_abort_cmd.mutex);
1005	return retval;
1006}
1007/**
1008 * mpi3mr_bsg_verify_adapter - verify adapter number is valid
1009 * @ioc_number: Adapter number
1010 *
1011 * This function returns the adapter instance pointer of given
1012 * adapter number. If adapter number does not match with the
1013 * driver's adapter list, driver returns NULL.
1014 *
1015 * Return: adapter instance reference
1016 */
1017static struct mpi3mr_ioc *mpi3mr_bsg_verify_adapter(int ioc_number)
1018{
1019	struct mpi3mr_ioc *mrioc = NULL;
1020
1021	spin_lock(&mrioc_list_lock);
1022	list_for_each_entry(mrioc, &mrioc_list, list) {
1023		if (mrioc->id == ioc_number) {
1024			spin_unlock(&mrioc_list_lock);
1025			return mrioc;
1026		}
1027	}
1028	spin_unlock(&mrioc_list_lock);
1029	return NULL;
1030}
1031
1032/**
1033 * mpi3mr_bsg_refresh_hdb_triggers - Refresh HDB trigger data
1034 * @mrioc: Adapter instance reference
1035 * @job: BSG Job pointer
1036 *
1037 * This function reads the controller trigger config page as
1038 * defined by the input page type and refreshes the driver's
1039 * local trigger information structures with the controller's
1040 * config page data.
1041 *
1042 * Return: 0 on success and proper error codes on failure
1043 */
1044static long
1045mpi3mr_bsg_refresh_hdb_triggers(struct mpi3mr_ioc *mrioc,
1046				struct bsg_job *job)
1047{
1048	struct mpi3mr_bsg_out_refresh_hdb_triggers refresh_triggers;
1049	uint32_t data_out_sz;
1050	u8 page_action;
1051	long rval = -EINVAL;
1052
1053	data_out_sz = job->request_payload.payload_len;
1054
1055	if (data_out_sz != sizeof(refresh_triggers)) {
1056		dprint_bsg_err(mrioc, "%s: invalid size argument\n",
1057		    __func__);
1058		return rval;
1059	}
1060
1061	if (mrioc->unrecoverable) {
1062		dprint_bsg_err(mrioc, "%s: unrecoverable controller\n",
1063		    __func__);
1064		return -EFAULT;
1065	}
1066	if (mrioc->reset_in_progress) {
1067		dprint_bsg_err(mrioc, "%s: reset in progress\n", __func__);
1068		return -EAGAIN;
1069	}
1070
1071	sg_copy_to_buffer(job->request_payload.sg_list,
1072	    job->request_payload.sg_cnt,
1073	    &refresh_triggers, sizeof(refresh_triggers));
1074
1075	switch (refresh_triggers.page_type) {
1076	case MPI3MR_HDB_REFRESH_TYPE_CURRENT:
1077		page_action = MPI3_CONFIG_ACTION_READ_CURRENT;
1078		break;
1079	case MPI3MR_HDB_REFRESH_TYPE_DEFAULT:
1080		page_action = MPI3_CONFIG_ACTION_READ_DEFAULT;
1081		break;
1082	case MPI3MR_HDB_HDB_REFRESH_TYPE_PERSISTENT:
1083		page_action = MPI3_CONFIG_ACTION_READ_PERSISTENT;
1084		break;
1085	default:
1086		dprint_bsg_err(mrioc,
1087		    "%s: unsupported refresh trigger, page_type %d\n",
1088		    __func__, refresh_triggers.page_type);
1089		return rval;
1090	}
1091	rval = mpi3mr_refresh_trigger(mrioc, page_action);
1092
1093	return rval;
1094}
1095
1096/**
1097 * mpi3mr_bsg_upload_hdb - Upload a specific HDB to user space
1098 * @mrioc: Adapter instance reference
1099 * @job: BSG Job pointer
1100 *
1101 * Return: 0 on success and proper error codes on failure
1102 */
1103static long mpi3mr_bsg_upload_hdb(struct mpi3mr_ioc *mrioc,
1104				  struct bsg_job *job)
1105{
1106	struct mpi3mr_bsg_out_upload_hdb upload_hdb;
1107	struct diag_buffer_desc *diag_buffer;
1108	uint32_t data_out_size;
1109	uint32_t data_in_size;
1110
1111	data_out_size = job->request_payload.payload_len;
1112	data_in_size = job->reply_payload.payload_len;
1113
1114	if (data_out_size != sizeof(upload_hdb)) {
1115		dprint_bsg_err(mrioc, "%s: invalid size argument\n",
1116		    __func__);
1117		return -EINVAL;
1118	}
1119
1120	sg_copy_to_buffer(job->request_payload.sg_list,
1121			  job->request_payload.sg_cnt,
1122			  &upload_hdb, sizeof(upload_hdb));
1123
1124	if ((!upload_hdb.length) || (data_in_size != upload_hdb.length)) {
1125		dprint_bsg_err(mrioc, "%s: invalid length argument\n",
1126		    __func__);
1127		return -EINVAL;
1128	}
1129	diag_buffer = mpi3mr_diag_buffer_for_type(mrioc, upload_hdb.buf_type);
1130	if ((!diag_buffer) || (!diag_buffer->addr)) {
1131		dprint_bsg_err(mrioc, "%s: invalid buffer type %d\n",
1132		    __func__, upload_hdb.buf_type);
1133		return -EINVAL;
1134	}
1135
1136	if ((diag_buffer->status != MPI3MR_HDB_BUFSTATUS_RELEASED) &&
1137	    (diag_buffer->status != MPI3MR_HDB_BUFSTATUS_POSTED_PAUSED)) {
1138		dprint_bsg_err(mrioc,
1139		    "%s: invalid buffer status %d for type %d\n",
1140		    __func__, diag_buffer->status, upload_hdb.buf_type);
1141		return -EINVAL;
1142	}
1143
1144	if ((upload_hdb.start_offset + upload_hdb.length) > diag_buffer->size) {
1145		dprint_bsg_err(mrioc,
1146		    "%s: invalid start offset %d, length %d for type %d\n",
1147		    __func__, upload_hdb.start_offset, upload_hdb.length,
1148		    upload_hdb.buf_type);
1149		return -EINVAL;
1150	}
1151	sg_copy_from_buffer(job->reply_payload.sg_list,
1152			    job->reply_payload.sg_cnt,
1153	    (diag_buffer->addr + upload_hdb.start_offset),
1154	    data_in_size);
1155	return 0;
1156}
1157
1158/**
1159 * mpi3mr_bsg_repost_hdb - Re-post HDB
1160 * @mrioc: Adapter instance reference
1161 * @job: BSG job pointer
1162 *
1163 * This function retrieves the HDB descriptor corresponding to a
1164 * given buffer type and if the HDB is in released status then
1165 * posts the HDB with the firmware.
1166 *
1167 * Return: 0 on success and proper error codes on failure
1168 */
1169static long mpi3mr_bsg_repost_hdb(struct mpi3mr_ioc *mrioc,
1170				  struct bsg_job *job)
1171{
1172	struct mpi3mr_bsg_out_repost_hdb repost_hdb;
1173	struct diag_buffer_desc *diag_buffer;
1174	uint32_t data_out_sz;
1175
1176	data_out_sz = job->request_payload.payload_len;
1177
1178	if (data_out_sz != sizeof(repost_hdb)) {
1179		dprint_bsg_err(mrioc, "%s: invalid size argument\n",
1180		    __func__);
1181		return -EINVAL;
1182	}
1183	if (mrioc->unrecoverable) {
1184		dprint_bsg_err(mrioc, "%s: unrecoverable controller\n",
1185		    __func__);
1186		return -EFAULT;
1187	}
1188	if (mrioc->reset_in_progress) {
1189		dprint_bsg_err(mrioc, "%s: reset in progress\n", __func__);
1190		return -EAGAIN;
1191	}
1192
1193	sg_copy_to_buffer(job->request_payload.sg_list,
1194			  job->request_payload.sg_cnt,
1195			  &repost_hdb, sizeof(repost_hdb));
1196
1197	diag_buffer = mpi3mr_diag_buffer_for_type(mrioc, repost_hdb.buf_type);
1198	if ((!diag_buffer) || (!diag_buffer->addr)) {
1199		dprint_bsg_err(mrioc, "%s: invalid buffer type %d\n",
1200		    __func__, repost_hdb.buf_type);
1201		return -EINVAL;
1202	}
1203
1204	if (diag_buffer->status != MPI3MR_HDB_BUFSTATUS_RELEASED) {
1205		dprint_bsg_err(mrioc,
1206		    "%s: invalid buffer status %d for type %d\n",
1207		    __func__, diag_buffer->status, repost_hdb.buf_type);
1208		return -EINVAL;
1209	}
1210
1211	if (mpi3mr_issue_diag_buf_post(mrioc, diag_buffer)) {
1212		dprint_bsg_err(mrioc, "%s: post failed for type %d\n",
1213		    __func__, repost_hdb.buf_type);
1214		return -EFAULT;
1215	}
1216	mpi3mr_set_trigger_data_in_hdb(diag_buffer,
1217	    MPI3MR_HDB_TRIGGER_TYPE_UNKNOWN, NULL, 1);
1218
1219	return 0;
1220}
1221
1222/**
1223 * mpi3mr_bsg_query_hdb - Handler for query HDB command
1224 * @mrioc: Adapter instance reference
1225 * @job: BSG job pointer
1226 *
1227 * This function prepares and copies the host diagnostic buffer
1228 * entries to the user buffer.
1229 *
1230 * Return: 0 on success and proper error codes on failure
1231 */
1232static long mpi3mr_bsg_query_hdb(struct mpi3mr_ioc *mrioc,
1233				 struct bsg_job *job)
1234{
1235	long rval = 0;
1236	struct mpi3mr_bsg_in_hdb_status *hbd_status;
1237	struct mpi3mr_hdb_entry *hbd_status_entry;
1238	u32 length, min_length;
1239	u8 i;
1240	struct diag_buffer_desc *diag_buffer;
1241	uint32_t data_in_sz = 0;
1242
1243	data_in_sz = job->request_payload.payload_len;
1244
1245	length = (sizeof(*hbd_status) + ((MPI3MR_MAX_NUM_HDB - 1) *
1246		    sizeof(*hbd_status_entry)));
1247	hbd_status = kmalloc(length, GFP_KERNEL);
1248	if (!hbd_status)
1249		return -ENOMEM;
1250	hbd_status_entry = &hbd_status->entry[0];
1251
1252	hbd_status->num_hdb_types = MPI3MR_MAX_NUM_HDB;
1253	for (i = 0; i < MPI3MR_MAX_NUM_HDB; i++) {
1254		diag_buffer = &mrioc->diag_buffers[i];
1255		hbd_status_entry->buf_type = diag_buffer->type;
1256		hbd_status_entry->status = diag_buffer->status;
1257		hbd_status_entry->trigger_type = diag_buffer->trigger_type;
1258		memcpy(&hbd_status_entry->trigger_data,
1259		    &diag_buffer->trigger_data,
1260		    sizeof(hbd_status_entry->trigger_data));
1261		hbd_status_entry->size = (diag_buffer->size / 1024);
1262		hbd_status_entry++;
1263	}
1264	hbd_status->element_trigger_format =
1265		MPI3MR_HDB_QUERY_ELEMENT_TRIGGER_FORMAT_DATA;
1266
1267	if (data_in_sz < 4) {
1268		dprint_bsg_err(mrioc, "%s: invalid size passed\n", __func__);
1269		rval = -EINVAL;
1270		goto out;
1271	}
1272	min_length = min(data_in_sz, length);
1273	if (job->request_payload.payload_len >= min_length) {
1274		sg_copy_from_buffer(job->request_payload.sg_list,
1275				    job->request_payload.sg_cnt,
1276				    hbd_status, min_length);
1277		rval = 0;
1278	}
1279out:
1280	kfree(hbd_status);
1281	return rval;
1282}
1283
1284
1285/**
1286 * mpi3mr_enable_logdata - Handler for log data enable
1287 * @mrioc: Adapter instance reference
1288 * @job: BSG job reference
1289 *
1290 * This function enables log data caching in the driver if not
1291 * already enabled and return the maximum number of log data
1292 * entries that can be cached in the driver.
1293 *
1294 * Return: 0 on success and proper error codes on failure
1295 */
1296static long mpi3mr_enable_logdata(struct mpi3mr_ioc *mrioc,
1297	struct bsg_job *job)
1298{
1299	struct mpi3mr_logdata_enable logdata_enable;
1300
1301	if (!mrioc->logdata_buf) {
1302		mrioc->logdata_entry_sz =
1303		    (mrioc->reply_sz - (sizeof(struct mpi3_event_notification_reply) - 4))
1304		    + MPI3MR_BSG_LOGDATA_ENTRY_HEADER_SZ;
1305		mrioc->logdata_buf_idx = 0;
1306		mrioc->logdata_buf = kcalloc(MPI3MR_BSG_LOGDATA_MAX_ENTRIES,
1307		    mrioc->logdata_entry_sz, GFP_KERNEL);
1308
1309		if (!mrioc->logdata_buf)
1310			return -ENOMEM;
1311	}
1312
1313	memset(&logdata_enable, 0, sizeof(logdata_enable));
1314	logdata_enable.max_entries =
1315	    MPI3MR_BSG_LOGDATA_MAX_ENTRIES;
1316	if (job->request_payload.payload_len >= sizeof(logdata_enable)) {
1317		sg_copy_from_buffer(job->request_payload.sg_list,
1318				    job->request_payload.sg_cnt,
1319				    &logdata_enable, sizeof(logdata_enable));
1320		return 0;
1321	}
1322
1323	return -EINVAL;
1324}
1325/**
1326 * mpi3mr_get_logdata - Handler for get log data
1327 * @mrioc: Adapter instance reference
1328 * @job: BSG job pointer
1329 * This function copies the log data entries to the user buffer
1330 * when log caching is enabled in the driver.
1331 *
1332 * Return: 0 on success and proper error codes on failure
1333 */
1334static long mpi3mr_get_logdata(struct mpi3mr_ioc *mrioc,
1335	struct bsg_job *job)
1336{
1337	u16 num_entries, sz, entry_sz = mrioc->logdata_entry_sz;
1338
1339	if ((!mrioc->logdata_buf) || (job->request_payload.payload_len < entry_sz))
1340		return -EINVAL;
1341
1342	num_entries = job->request_payload.payload_len / entry_sz;
1343	if (num_entries > MPI3MR_BSG_LOGDATA_MAX_ENTRIES)
1344		num_entries = MPI3MR_BSG_LOGDATA_MAX_ENTRIES;
1345	sz = num_entries * entry_sz;
1346
1347	if (job->request_payload.payload_len >= sz) {
1348		sg_copy_from_buffer(job->request_payload.sg_list,
1349				    job->request_payload.sg_cnt,
1350				    mrioc->logdata_buf, sz);
1351		return 0;
1352	}
1353	return -EINVAL;
1354}
1355
1356/**
1357 * mpi3mr_bsg_pel_enable - Handler for PEL enable driver
1358 * @mrioc: Adapter instance reference
1359 * @job: BSG job pointer
1360 *
1361 * This function is the handler for PEL enable driver.
1362 * Validates the application given class and locale and if
1363 * requires aborts the existing PEL wait request and/or issues
1364 * new PEL wait request to the firmware and returns.
1365 *
1366 * Return: 0 on success and proper error codes on failure.
1367 */
1368static long mpi3mr_bsg_pel_enable(struct mpi3mr_ioc *mrioc,
1369				  struct bsg_job *job)
1370{
1371	long rval = -EINVAL;
1372	struct mpi3mr_bsg_out_pel_enable pel_enable;
1373	u8 issue_pel_wait;
1374	u8 tmp_class;
1375	u16 tmp_locale;
1376
1377	if (job->request_payload.payload_len != sizeof(pel_enable)) {
1378		dprint_bsg_err(mrioc, "%s: invalid size argument\n",
1379		    __func__);
1380		return rval;
1381	}
1382
1383	if (mrioc->unrecoverable) {
1384		dprint_bsg_err(mrioc, "%s: unrecoverable controller\n",
1385			       __func__);
1386		return -EFAULT;
1387	}
1388
1389	if (mrioc->reset_in_progress) {
1390		dprint_bsg_err(mrioc, "%s: reset in progress\n", __func__);
1391		return -EAGAIN;
1392	}
1393
1394	if (mrioc->stop_bsgs) {
1395		dprint_bsg_err(mrioc, "%s: bsgs are blocked\n", __func__);
1396		return -EAGAIN;
1397	}
1398
1399	sg_copy_to_buffer(job->request_payload.sg_list,
1400			  job->request_payload.sg_cnt,
1401			  &pel_enable, sizeof(pel_enable));
1402
1403	if (pel_enable.pel_class > MPI3_PEL_CLASS_FAULT) {
1404		dprint_bsg_err(mrioc, "%s: out of range class %d sent\n",
1405			__func__, pel_enable.pel_class);
1406		rval = 0;
1407		goto out;
1408	}
1409	if (!mrioc->pel_enabled)
1410		issue_pel_wait = 1;
1411	else {
1412		if ((mrioc->pel_class <= pel_enable.pel_class) &&
1413		    !((mrioc->pel_locale & pel_enable.pel_locale) ^
1414		      pel_enable.pel_locale)) {
1415			issue_pel_wait = 0;
1416			rval = 0;
1417		} else {
1418			pel_enable.pel_locale |= mrioc->pel_locale;
1419
1420			if (mrioc->pel_class < pel_enable.pel_class)
1421				pel_enable.pel_class = mrioc->pel_class;
1422
1423			rval = mpi3mr_bsg_pel_abort(mrioc);
1424			if (rval) {
1425				dprint_bsg_err(mrioc,
1426				    "%s: pel_abort failed, status(%ld)\n",
1427				    __func__, rval);
1428				goto out;
1429			}
1430			issue_pel_wait = 1;
1431		}
1432	}
1433	if (issue_pel_wait) {
1434		tmp_class = mrioc->pel_class;
1435		tmp_locale = mrioc->pel_locale;
1436		mrioc->pel_class = pel_enable.pel_class;
1437		mrioc->pel_locale = pel_enable.pel_locale;
1438		mrioc->pel_enabled = 1;
1439		rval = mpi3mr_pel_get_seqnum_post(mrioc, NULL);
1440		if (rval) {
1441			mrioc->pel_class = tmp_class;
1442			mrioc->pel_locale = tmp_locale;
1443			mrioc->pel_enabled = 0;
1444			dprint_bsg_err(mrioc,
1445			    "%s: pel get sequence number failed, status(%ld)\n",
1446			    __func__, rval);
1447		}
1448	}
1449
1450out:
1451	return rval;
1452}
1453/**
1454 * mpi3mr_get_all_tgt_info - Get all target information
1455 * @mrioc: Adapter instance reference
1456 * @job: BSG job reference
1457 *
1458 * This function copies the driver managed target devices device
1459 * handle, persistent ID, bus ID and taret ID to the user
1460 * provided buffer for the specific controller. This function
1461 * also provides the number of devices managed by the driver for
1462 * the specific controller.
1463 *
1464 * Return: 0 on success and proper error codes on failure
1465 */
1466static long mpi3mr_get_all_tgt_info(struct mpi3mr_ioc *mrioc,
1467	struct bsg_job *job)
1468{
1469	u16 num_devices = 0, i = 0, size;
1470	unsigned long flags;
1471	struct mpi3mr_tgt_dev *tgtdev;
1472	struct mpi3mr_device_map_info *devmap_info = NULL;
1473	struct mpi3mr_all_tgt_info *alltgt_info = NULL;
1474	uint32_t min_entrylen = 0, kern_entrylen = 0, usr_entrylen = 0;
1475
1476	if (job->request_payload.payload_len < sizeof(u32)) {
1477		dprint_bsg_err(mrioc, "%s: invalid size argument\n",
1478		    __func__);
1479		return -EINVAL;
1480	}
1481
1482	spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
1483	list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list)
1484		num_devices++;
1485	spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
1486
1487	if ((job->request_payload.payload_len <= sizeof(u64)) ||
1488		list_empty(&mrioc->tgtdev_list)) {
1489		sg_copy_from_buffer(job->request_payload.sg_list,
1490				    job->request_payload.sg_cnt,
1491				    &num_devices, sizeof(num_devices));
1492		return 0;
1493	}
1494
1495	kern_entrylen = num_devices * sizeof(*devmap_info);
1496	size = sizeof(u64) + kern_entrylen;
1497	alltgt_info = kzalloc(size, GFP_KERNEL);
1498	if (!alltgt_info)
1499		return -ENOMEM;
1500
1501	devmap_info = alltgt_info->dmi;
1502	memset((u8 *)devmap_info, 0xFF, kern_entrylen);
1503	spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
1504	list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list) {
1505		if (i < num_devices) {
1506			devmap_info[i].handle = tgtdev->dev_handle;
1507			devmap_info[i].perst_id = tgtdev->perst_id;
1508			if (tgtdev->host_exposed && tgtdev->starget) {
1509				devmap_info[i].target_id = tgtdev->starget->id;
1510				devmap_info[i].bus_id =
1511				    tgtdev->starget->channel;
1512			}
1513			i++;
1514		}
1515	}
1516	num_devices = i;
1517	spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
1518
1519	alltgt_info->num_devices = num_devices;
1520
1521	usr_entrylen = (job->request_payload.payload_len - sizeof(u64)) /
1522		sizeof(*devmap_info);
1523	usr_entrylen *= sizeof(*devmap_info);
1524	min_entrylen = min(usr_entrylen, kern_entrylen);
1525
1526	sg_copy_from_buffer(job->request_payload.sg_list,
1527			    job->request_payload.sg_cnt,
1528			    alltgt_info, (min_entrylen + sizeof(u64)));
1529	kfree(alltgt_info);
1530	return 0;
1531}
1532/**
1533 * mpi3mr_get_change_count - Get topology change count
1534 * @mrioc: Adapter instance reference
1535 * @job: BSG job reference
1536 *
1537 * This function copies the toplogy change count provided by the
1538 * driver in events and cached in the driver to the user
1539 * provided buffer for the specific controller.
1540 *
1541 * Return: 0 on success and proper error codes on failure
1542 */
1543static long mpi3mr_get_change_count(struct mpi3mr_ioc *mrioc,
1544	struct bsg_job *job)
1545{
1546	struct mpi3mr_change_count chgcnt;
1547
1548	memset(&chgcnt, 0, sizeof(chgcnt));
1549	chgcnt.change_count = mrioc->change_count;
1550	if (job->request_payload.payload_len >= sizeof(chgcnt)) {
1551		sg_copy_from_buffer(job->request_payload.sg_list,
1552				    job->request_payload.sg_cnt,
1553				    &chgcnt, sizeof(chgcnt));
1554		return 0;
1555	}
1556	return -EINVAL;
1557}
1558
1559/**
1560 * mpi3mr_bsg_adp_reset - Issue controller reset
1561 * @mrioc: Adapter instance reference
1562 * @job: BSG job reference
1563 *
1564 * This function identifies the user provided reset type and
1565 * issues approporiate reset to the controller and wait for that
1566 * to complete and reinitialize the controller and then returns
1567 *
1568 * Return: 0 on success and proper error codes on failure
1569 */
1570static long mpi3mr_bsg_adp_reset(struct mpi3mr_ioc *mrioc,
1571	struct bsg_job *job)
1572{
1573	long rval = -EINVAL;
1574	u8 save_snapdump;
1575	struct mpi3mr_bsg_adp_reset adpreset;
1576
1577	if (job->request_payload.payload_len !=
1578			sizeof(adpreset)) {
1579		dprint_bsg_err(mrioc, "%s: invalid size argument\n",
1580		    __func__);
1581		goto out;
1582	}
1583
1584	if (mrioc->unrecoverable || mrioc->block_on_pci_err)
1585		return -EINVAL;
1586
1587	sg_copy_to_buffer(job->request_payload.sg_list,
1588			  job->request_payload.sg_cnt,
1589			  &adpreset, sizeof(adpreset));
1590
1591	switch (adpreset.reset_type) {
1592	case MPI3MR_BSG_ADPRESET_SOFT:
1593		save_snapdump = 0;
1594		break;
1595	case MPI3MR_BSG_ADPRESET_DIAG_FAULT:
1596		save_snapdump = 1;
1597		break;
1598	default:
1599		dprint_bsg_err(mrioc, "%s: unknown reset_type(%d)\n",
1600		    __func__, adpreset.reset_type);
1601		goto out;
1602	}
1603
1604	rval = mpi3mr_soft_reset_handler(mrioc, MPI3MR_RESET_FROM_APP,
1605	    save_snapdump);
1606
1607	if (rval)
1608		dprint_bsg_err(mrioc,
1609		    "%s: reset handler returned error(%ld) for reset type %d\n",
1610		    __func__, rval, adpreset.reset_type);
1611out:
1612	return rval;
1613}
1614
1615/**
1616 * mpi3mr_bsg_populate_adpinfo - Get adapter info command handler
1617 * @mrioc: Adapter instance reference
1618 * @job: BSG job reference
1619 *
1620 * This function provides adapter information for the given
1621 * controller
1622 *
1623 * Return: 0 on success and proper error codes on failure
1624 */
1625static long mpi3mr_bsg_populate_adpinfo(struct mpi3mr_ioc *mrioc,
1626	struct bsg_job *job)
1627{
1628	enum mpi3mr_iocstate ioc_state;
1629	struct mpi3mr_bsg_in_adpinfo adpinfo;
1630
1631	memset(&adpinfo, 0, sizeof(adpinfo));
1632	adpinfo.adp_type = MPI3MR_BSG_ADPTYPE_AVGFAMILY;
1633	adpinfo.pci_dev_id = mrioc->pdev->device;
1634	adpinfo.pci_dev_hw_rev = mrioc->pdev->revision;
1635	adpinfo.pci_subsys_dev_id = mrioc->pdev->subsystem_device;
1636	adpinfo.pci_subsys_ven_id = mrioc->pdev->subsystem_vendor;
1637	adpinfo.pci_bus = mrioc->pdev->bus->number;
1638	adpinfo.pci_dev = PCI_SLOT(mrioc->pdev->devfn);
1639	adpinfo.pci_func = PCI_FUNC(mrioc->pdev->devfn);
1640	adpinfo.pci_seg_id = pci_domain_nr(mrioc->pdev->bus);
1641	adpinfo.app_intfc_ver = MPI3MR_IOCTL_VERSION;
1642
1643	ioc_state = mpi3mr_get_iocstate(mrioc);
1644	if (ioc_state == MRIOC_STATE_UNRECOVERABLE)
1645		adpinfo.adp_state = MPI3MR_BSG_ADPSTATE_UNRECOVERABLE;
1646	else if ((mrioc->reset_in_progress) || (mrioc->stop_bsgs))
1647		adpinfo.adp_state = MPI3MR_BSG_ADPSTATE_IN_RESET;
1648	else if (ioc_state == MRIOC_STATE_FAULT)
1649		adpinfo.adp_state = MPI3MR_BSG_ADPSTATE_FAULT;
1650	else
1651		adpinfo.adp_state = MPI3MR_BSG_ADPSTATE_OPERATIONAL;
1652
1653	memcpy((u8 *)&adpinfo.driver_info, (u8 *)&mrioc->driver_info,
1654	    sizeof(adpinfo.driver_info));
1655
1656	if (job->request_payload.payload_len >= sizeof(adpinfo)) {
1657		sg_copy_from_buffer(job->request_payload.sg_list,
1658				    job->request_payload.sg_cnt,
1659				    &adpinfo, sizeof(adpinfo));
1660		return 0;
1661	}
1662	return -EINVAL;
1663}
1664
1665/**
1666 * mpi3mr_bsg_process_drv_cmds - Driver Command handler
1667 * @job: BSG job reference
1668 *
1669 * This function is the top level handler for driver commands,
1670 * this does basic validation of the buffer and identifies the
1671 * opcode and switches to correct sub handler.
1672 *
1673 * Return: 0 on success and proper error codes on failure
1674 */
1675static long mpi3mr_bsg_process_drv_cmds(struct bsg_job *job)
1676{
1677	long rval = -EINVAL;
1678	struct mpi3mr_ioc *mrioc = NULL;
1679	struct mpi3mr_bsg_packet *bsg_req = NULL;
1680	struct mpi3mr_bsg_drv_cmd *drvrcmd = NULL;
1681
1682	bsg_req = job->request;
1683	drvrcmd = &bsg_req->cmd.drvrcmd;
1684
1685	mrioc = mpi3mr_bsg_verify_adapter(drvrcmd->mrioc_id);
1686	if (!mrioc)
1687		return -ENODEV;
1688
1689	if (drvrcmd->opcode == MPI3MR_DRVBSG_OPCODE_ADPINFO) {
1690		rval = mpi3mr_bsg_populate_adpinfo(mrioc, job);
1691		return rval;
1692	}
1693
1694	if (mutex_lock_interruptible(&mrioc->bsg_cmds.mutex))
1695		return -ERESTARTSYS;
1696
1697	switch (drvrcmd->opcode) {
1698	case MPI3MR_DRVBSG_OPCODE_ADPRESET:
1699		rval = mpi3mr_bsg_adp_reset(mrioc, job);
1700		break;
1701	case MPI3MR_DRVBSG_OPCODE_ALLTGTDEVINFO:
1702		rval = mpi3mr_get_all_tgt_info(mrioc, job);
1703		break;
1704	case MPI3MR_DRVBSG_OPCODE_GETCHGCNT:
1705		rval = mpi3mr_get_change_count(mrioc, job);
1706		break;
1707	case MPI3MR_DRVBSG_OPCODE_LOGDATAENABLE:
1708		rval = mpi3mr_enable_logdata(mrioc, job);
1709		break;
1710	case MPI3MR_DRVBSG_OPCODE_GETLOGDATA:
1711		rval = mpi3mr_get_logdata(mrioc, job);
1712		break;
1713	case MPI3MR_DRVBSG_OPCODE_PELENABLE:
1714		rval = mpi3mr_bsg_pel_enable(mrioc, job);
1715		break;
1716	case MPI3MR_DRVBSG_OPCODE_QUERY_HDB:
1717		rval = mpi3mr_bsg_query_hdb(mrioc, job);
1718		break;
1719	case MPI3MR_DRVBSG_OPCODE_REPOST_HDB:
1720		rval = mpi3mr_bsg_repost_hdb(mrioc, job);
1721		break;
1722	case MPI3MR_DRVBSG_OPCODE_UPLOAD_HDB:
1723		rval = mpi3mr_bsg_upload_hdb(mrioc, job);
1724		break;
1725	case MPI3MR_DRVBSG_OPCODE_REFRESH_HDB_TRIGGERS:
1726		rval = mpi3mr_bsg_refresh_hdb_triggers(mrioc, job);
1727		break;
1728	case MPI3MR_DRVBSG_OPCODE_UNKNOWN:
1729	default:
1730		pr_err("%s: unsupported driver command opcode %d\n",
1731		    MPI3MR_DRIVER_NAME, drvrcmd->opcode);
1732		break;
1733	}
1734	mutex_unlock(&mrioc->bsg_cmds.mutex);
1735	return rval;
1736}
1737
1738/**
1739 * mpi3mr_total_num_ioctl_sges - Count number of SGEs required
1740 * @drv_bufs: DMA address of the buffers to be placed in sgl
1741 * @bufcnt: Number of DMA buffers
1742 *
1743 * This function returns total number of data SGEs required
1744 * including zero length SGEs and excluding management request
1745 * and response buffer for the given list of data buffer
1746 * descriptors
1747 *
1748 * Return: Number of SGE elements needed
1749 */
1750static inline u16 mpi3mr_total_num_ioctl_sges(struct mpi3mr_buf_map *drv_bufs,
1751					      u8 bufcnt)
1752{
1753	u16 i, sge_count = 0;
1754
1755	for (i = 0; i < bufcnt; i++, drv_bufs++) {
1756		if (drv_bufs->data_dir == DMA_NONE ||
1757		    drv_bufs->kern_buf)
1758			continue;
1759		sge_count += drv_bufs->num_dma_desc;
1760		if (!drv_bufs->num_dma_desc)
1761			sge_count++;
1762	}
1763	return sge_count;
1764}
1765
1766/**
1767 * mpi3mr_bsg_build_sgl - SGL construction for MPI commands
1768 * @mrioc: Adapter instance reference
1769 * @mpi_req: MPI request
1770 * @sgl_offset: offset to start sgl in the MPI request
1771 * @drv_bufs: DMA address of the buffers to be placed in sgl
1772 * @bufcnt: Number of DMA buffers
1773 * @is_rmc: Does the buffer list has management command buffer
1774 * @is_rmr: Does the buffer list has management response buffer
1775 * @num_datasges: Number of data buffers in the list
1776 *
1777 * This function places the DMA address of the given buffers in
1778 * proper format as SGEs in the given MPI request.
1779 *
1780 * Return: 0 on success,-1 on failure
1781 */
1782static int mpi3mr_bsg_build_sgl(struct mpi3mr_ioc *mrioc, u8 *mpi_req,
1783				u32 sgl_offset, struct mpi3mr_buf_map *drv_bufs,
1784				u8 bufcnt, u8 is_rmc, u8 is_rmr, u8 num_datasges)
1785{
1786	struct mpi3_request_header *mpi_header =
1787		(struct mpi3_request_header *)mpi_req;
1788	u8 *sgl = (mpi_req + sgl_offset), count = 0;
1789	struct mpi3_mgmt_passthrough_request *rmgmt_req =
1790	    (struct mpi3_mgmt_passthrough_request *)mpi_req;
1791	struct mpi3mr_buf_map *drv_buf_iter = drv_bufs;
1792	u8 flag, sgl_flags, sgl_flag_eob, sgl_flags_last, last_chain_sgl_flag;
1793	u16 available_sges, i, sges_needed;
1794	u32 sge_element_size = sizeof(struct mpi3_sge_common);
1795	bool chain_used = false;
1796
1797	sgl_flags = MPI3_SGE_FLAGS_ELEMENT_TYPE_SIMPLE |
1798		MPI3_SGE_FLAGS_DLAS_SYSTEM;
1799	sgl_flag_eob = sgl_flags | MPI3_SGE_FLAGS_END_OF_BUFFER;
1800	sgl_flags_last = sgl_flag_eob | MPI3_SGE_FLAGS_END_OF_LIST;
1801	last_chain_sgl_flag = MPI3_SGE_FLAGS_ELEMENT_TYPE_LAST_CHAIN |
1802	    MPI3_SGE_FLAGS_DLAS_SYSTEM;
1803
1804	sges_needed = mpi3mr_total_num_ioctl_sges(drv_bufs, bufcnt);
1805
1806	if (is_rmc) {
1807		mpi3mr_add_sg_single(&rmgmt_req->command_sgl,
1808		    sgl_flags_last, drv_buf_iter->kern_buf_len,
1809		    drv_buf_iter->kern_buf_dma);
1810		sgl = (u8 *)drv_buf_iter->kern_buf +
1811			drv_buf_iter->bsg_buf_len;
1812		available_sges = (drv_buf_iter->kern_buf_len -
1813		    drv_buf_iter->bsg_buf_len) / sge_element_size;
1814
1815		if (sges_needed > available_sges)
1816			return -1;
1817
1818		chain_used = true;
1819		drv_buf_iter++;
1820		count++;
1821		if (is_rmr) {
1822			mpi3mr_add_sg_single(&rmgmt_req->response_sgl,
1823			    sgl_flags_last, drv_buf_iter->kern_buf_len,
1824			    drv_buf_iter->kern_buf_dma);
1825			drv_buf_iter++;
1826			count++;
1827		} else
1828			mpi3mr_build_zero_len_sge(
1829			    &rmgmt_req->response_sgl);
1830		if (num_datasges) {
1831			i = 0;
1832			goto build_sges;
1833		}
1834	} else {
1835		if (sgl_offset >= MPI3MR_ADMIN_REQ_FRAME_SZ)
1836			return -1;
1837		available_sges = (MPI3MR_ADMIN_REQ_FRAME_SZ - sgl_offset) /
1838		sge_element_size;
1839		if (!available_sges)
1840			return -1;
1841	}
1842	if (!num_datasges) {
1843		mpi3mr_build_zero_len_sge(sgl);
1844		return 0;
1845	}
1846	if (mpi_header->function == MPI3_BSG_FUNCTION_SMP_PASSTHROUGH) {
1847		if ((sges_needed > 2) || (sges_needed > available_sges))
1848			return -1;
1849		for (; count < bufcnt; count++, drv_buf_iter++) {
1850			if (drv_buf_iter->data_dir == DMA_NONE ||
1851			    !drv_buf_iter->num_dma_desc)
1852				continue;
1853			mpi3mr_add_sg_single(sgl, sgl_flags_last,
1854					     drv_buf_iter->dma_desc[0].size,
1855					     drv_buf_iter->dma_desc[0].dma_addr);
1856			sgl += sge_element_size;
1857		}
1858		return 0;
1859	}
1860	i = 0;
1861
1862build_sges:
1863	for (; count < bufcnt; count++, drv_buf_iter++) {
1864		if (drv_buf_iter->data_dir == DMA_NONE)
1865			continue;
1866		if (!drv_buf_iter->num_dma_desc) {
1867			if (chain_used && !available_sges)
1868				return -1;
1869			if (!chain_used && (available_sges == 1) &&
1870			    (sges_needed > 1))
1871				goto setup_chain;
1872			flag = sgl_flag_eob;
1873			if (num_datasges == 1)
1874				flag = sgl_flags_last;
1875			mpi3mr_add_sg_single(sgl, flag, 0, 0);
1876			sgl += sge_element_size;
1877			sges_needed--;
1878			available_sges--;
1879			num_datasges--;
1880			continue;
1881		}
1882		for (; i < drv_buf_iter->num_dma_desc; i++) {
1883			if (chain_used && !available_sges)
1884				return -1;
1885			if (!chain_used && (available_sges == 1) &&
1886			    (sges_needed > 1))
1887				goto setup_chain;
1888			flag = sgl_flags;
1889			if (i == (drv_buf_iter->num_dma_desc - 1)) {
1890				if (num_datasges == 1)
1891					flag = sgl_flags_last;
1892				else
1893					flag = sgl_flag_eob;
1894			}
1895
1896			mpi3mr_add_sg_single(sgl, flag,
1897					     drv_buf_iter->dma_desc[i].size,
1898					     drv_buf_iter->dma_desc[i].dma_addr);
1899			sgl += sge_element_size;
1900			available_sges--;
1901			sges_needed--;
1902		}
1903		num_datasges--;
1904		i = 0;
1905	}
1906	return 0;
1907
1908setup_chain:
1909	available_sges = mrioc->ioctl_chain_sge.size / sge_element_size;
1910	if (sges_needed > available_sges)
1911		return -1;
1912	mpi3mr_add_sg_single(sgl, last_chain_sgl_flag,
1913			     (sges_needed * sge_element_size),
1914			     mrioc->ioctl_chain_sge.dma_addr);
1915	memset(mrioc->ioctl_chain_sge.addr, 0, mrioc->ioctl_chain_sge.size);
1916	sgl = (u8 *)mrioc->ioctl_chain_sge.addr;
1917	chain_used = true;
1918	goto build_sges;
1919}
1920
1921/**
1922 * mpi3mr_get_nvme_data_fmt - returns the NVMe data format
1923 * @nvme_encap_request: NVMe encapsulated MPI request
1924 *
1925 * This function returns the type of the data format specified
1926 * in user provided NVMe command in NVMe encapsulated request.
1927 *
1928 * Return: Data format of the NVMe command (PRP/SGL etc)
1929 */
1930static unsigned int mpi3mr_get_nvme_data_fmt(
1931	struct mpi3_nvme_encapsulated_request *nvme_encap_request)
1932{
1933	u8 format = 0;
1934
1935	format = ((nvme_encap_request->command[0] & 0xc000) >> 14);
1936	return format;
1937
1938}
1939
1940/**
1941 * mpi3mr_build_nvme_sgl - SGL constructor for NVME
1942 *				   encapsulated request
1943 * @mrioc: Adapter instance reference
1944 * @nvme_encap_request: NVMe encapsulated MPI request
1945 * @drv_bufs: DMA address of the buffers to be placed in sgl
1946 * @bufcnt: Number of DMA buffers
1947 *
1948 * This function places the DMA address of the given buffers in
1949 * proper format as SGEs in the given NVMe encapsulated request.
1950 *
1951 * Return: 0 on success, -1 on failure
1952 */
1953static int mpi3mr_build_nvme_sgl(struct mpi3mr_ioc *mrioc,
1954	struct mpi3_nvme_encapsulated_request *nvme_encap_request,
1955	struct mpi3mr_buf_map *drv_bufs, u8 bufcnt)
1956{
1957	struct mpi3mr_nvme_pt_sge *nvme_sgl;
1958	__le64 sgl_dma;
1959	u8 count;
1960	size_t length = 0;
1961	u16 available_sges = 0, i;
1962	u32 sge_element_size = sizeof(struct mpi3mr_nvme_pt_sge);
1963	struct mpi3mr_buf_map *drv_buf_iter = drv_bufs;
1964	u64 sgemod_mask = ((u64)((mrioc->facts.sge_mod_mask) <<
1965			    mrioc->facts.sge_mod_shift) << 32);
1966	u64 sgemod_val = ((u64)(mrioc->facts.sge_mod_value) <<
1967			  mrioc->facts.sge_mod_shift) << 32;
1968	u32 size;
1969
1970	nvme_sgl = (struct mpi3mr_nvme_pt_sge *)
1971	    ((u8 *)(nvme_encap_request->command) + MPI3MR_NVME_CMD_SGL_OFFSET);
1972
1973	/*
1974	 * Not all commands require a data transfer. If no data, just return
1975	 * without constructing any sgl.
1976	 */
1977	for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
1978		if (drv_buf_iter->data_dir == DMA_NONE)
1979			continue;
1980		length = drv_buf_iter->kern_buf_len;
1981		break;
1982	}
1983	if (!length || !drv_buf_iter->num_dma_desc)
1984		return 0;
1985
1986	if (drv_buf_iter->num_dma_desc == 1) {
1987		available_sges = 1;
1988		goto build_sges;
1989	}
1990
1991	sgl_dma = cpu_to_le64(mrioc->ioctl_chain_sge.dma_addr);
1992	if (sgl_dma & sgemod_mask) {
1993		dprint_bsg_err(mrioc,
1994		    "%s: SGL chain address collides with SGE modifier\n",
1995		    __func__);
1996		return -1;
1997	}
1998
1999	sgl_dma &= ~sgemod_mask;
2000	sgl_dma |= sgemod_val;
2001
2002	memset(mrioc->ioctl_chain_sge.addr, 0, mrioc->ioctl_chain_sge.size);
2003	available_sges = mrioc->ioctl_chain_sge.size / sge_element_size;
2004	if (available_sges < drv_buf_iter->num_dma_desc)
2005		return -1;
2006	memset(nvme_sgl, 0, sizeof(struct mpi3mr_nvme_pt_sge));
2007	nvme_sgl->base_addr = sgl_dma;
2008	size = drv_buf_iter->num_dma_desc * sizeof(struct mpi3mr_nvme_pt_sge);
2009	nvme_sgl->length = cpu_to_le32(size);
2010	nvme_sgl->type = MPI3MR_NVMESGL_LAST_SEGMENT;
2011	nvme_sgl = (struct mpi3mr_nvme_pt_sge *)mrioc->ioctl_chain_sge.addr;
2012
2013build_sges:
2014	for (i = 0; i < drv_buf_iter->num_dma_desc; i++) {
2015		sgl_dma = cpu_to_le64(drv_buf_iter->dma_desc[i].dma_addr);
2016		if (sgl_dma & sgemod_mask) {
2017			dprint_bsg_err(mrioc,
2018				       "%s: SGL address collides with SGE modifier\n",
2019				       __func__);
2020		return -1;
2021		}
2022
2023		sgl_dma &= ~sgemod_mask;
2024		sgl_dma |= sgemod_val;
2025
2026		nvme_sgl->base_addr = sgl_dma;
2027		nvme_sgl->length = cpu_to_le32(drv_buf_iter->dma_desc[i].size);
2028		nvme_sgl->type = MPI3MR_NVMESGL_DATA_SEGMENT;
2029		nvme_sgl++;
2030		available_sges--;
2031	}
2032
2033	return 0;
2034}
2035
2036/**
2037 * mpi3mr_build_nvme_prp - PRP constructor for NVME
2038 *			       encapsulated request
2039 * @mrioc: Adapter instance reference
2040 * @nvme_encap_request: NVMe encapsulated MPI request
2041 * @drv_bufs: DMA address of the buffers to be placed in SGL
2042 * @bufcnt: Number of DMA buffers
2043 *
2044 * This function places the DMA address of the given buffers in
2045 * proper format as PRP entries in the given NVMe encapsulated
2046 * request.
2047 *
2048 * Return: 0 on success, -1 on failure
2049 */
2050static int mpi3mr_build_nvme_prp(struct mpi3mr_ioc *mrioc,
2051	struct mpi3_nvme_encapsulated_request *nvme_encap_request,
2052	struct mpi3mr_buf_map *drv_bufs, u8 bufcnt)
2053{
2054	int prp_size = MPI3MR_NVME_PRP_SIZE;
2055	__le64 *prp_entry, *prp1_entry, *prp2_entry;
2056	__le64 *prp_page;
2057	dma_addr_t prp_entry_dma, prp_page_dma, dma_addr;
2058	u32 offset, entry_len, dev_pgsz;
2059	u32 page_mask_result, page_mask;
2060	size_t length = 0, desc_len;
2061	u8 count;
2062	struct mpi3mr_buf_map *drv_buf_iter = drv_bufs;
2063	u64 sgemod_mask = ((u64)((mrioc->facts.sge_mod_mask) <<
2064			    mrioc->facts.sge_mod_shift) << 32);
2065	u64 sgemod_val = ((u64)(mrioc->facts.sge_mod_value) <<
2066			  mrioc->facts.sge_mod_shift) << 32;
2067	u16 dev_handle = nvme_encap_request->dev_handle;
2068	struct mpi3mr_tgt_dev *tgtdev;
2069	u16 desc_count = 0;
2070
2071	tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, dev_handle);
2072	if (!tgtdev) {
2073		dprint_bsg_err(mrioc, "%s: invalid device handle 0x%04x\n",
2074			__func__, dev_handle);
2075		return -1;
2076	}
2077
2078	if (tgtdev->dev_spec.pcie_inf.pgsz == 0) {
2079		dprint_bsg_err(mrioc,
2080		    "%s: NVMe device page size is zero for handle 0x%04x\n",
2081		    __func__, dev_handle);
2082		mpi3mr_tgtdev_put(tgtdev);
2083		return -1;
2084	}
2085
2086	dev_pgsz = 1 << (tgtdev->dev_spec.pcie_inf.pgsz);
2087	mpi3mr_tgtdev_put(tgtdev);
2088	page_mask = dev_pgsz - 1;
2089
2090	if (dev_pgsz > MPI3MR_IOCTL_SGE_SIZE) {
2091		dprint_bsg_err(mrioc,
2092			       "%s: NVMe device page size(%d) is greater than ioctl data sge size(%d) for handle 0x%04x\n",
2093			       __func__, dev_pgsz,  MPI3MR_IOCTL_SGE_SIZE, dev_handle);
2094		return -1;
2095	}
2096
2097	if (MPI3MR_IOCTL_SGE_SIZE % dev_pgsz) {
2098		dprint_bsg_err(mrioc,
2099			       "%s: ioctl data sge size(%d) is not a multiple of NVMe device page size(%d) for handle 0x%04x\n",
2100			       __func__, MPI3MR_IOCTL_SGE_SIZE, dev_pgsz, dev_handle);
2101		return -1;
2102	}
2103
2104	/*
2105	 * Not all commands require a data transfer. If no data, just return
2106	 * without constructing any PRP.
2107	 */
2108	for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
2109		if (drv_buf_iter->data_dir == DMA_NONE)
2110			continue;
2111		length = drv_buf_iter->kern_buf_len;
2112		break;
2113	}
2114
2115	if (!length || !drv_buf_iter->num_dma_desc)
2116		return 0;
2117
2118	for (count = 0; count < drv_buf_iter->num_dma_desc; count++) {
2119		dma_addr = drv_buf_iter->dma_desc[count].dma_addr;
2120		if (dma_addr & page_mask) {
2121			dprint_bsg_err(mrioc,
2122				       "%s:dma_addr %pad is not aligned with page size 0x%x\n",
2123				       __func__,  &dma_addr, dev_pgsz);
2124			return -1;
2125		}
2126	}
2127
2128	dma_addr = drv_buf_iter->dma_desc[0].dma_addr;
2129	desc_len = drv_buf_iter->dma_desc[0].size;
2130
2131	mrioc->prp_sz = 0;
2132	mrioc->prp_list_virt = dma_alloc_coherent(&mrioc->pdev->dev,
2133	    dev_pgsz, &mrioc->prp_list_dma, GFP_KERNEL);
2134
2135	if (!mrioc->prp_list_virt)
2136		return -1;
2137	mrioc->prp_sz = dev_pgsz;
2138
2139	/*
2140	 * Set pointers to PRP1 and PRP2, which are in the NVMe command.
2141	 * PRP1 is located at a 24 byte offset from the start of the NVMe
2142	 * command.  Then set the current PRP entry pointer to PRP1.
2143	 */
2144	prp1_entry = (__le64 *)((u8 *)(nvme_encap_request->command) +
2145	    MPI3MR_NVME_CMD_PRP1_OFFSET);
2146	prp2_entry = (__le64 *)((u8 *)(nvme_encap_request->command) +
2147	    MPI3MR_NVME_CMD_PRP2_OFFSET);
2148	prp_entry = prp1_entry;
2149	/*
2150	 * For the PRP entries, use the specially allocated buffer of
2151	 * contiguous memory.
2152	 */
2153	prp_page = (__le64 *)mrioc->prp_list_virt;
2154	prp_page_dma = mrioc->prp_list_dma;
2155
2156	/*
2157	 * Check if we are within 1 entry of a page boundary we don't
2158	 * want our first entry to be a PRP List entry.
2159	 */
2160	page_mask_result = (uintptr_t)((u8 *)prp_page + prp_size) & page_mask;
2161	if (!page_mask_result) {
2162		dprint_bsg_err(mrioc, "%s: PRP page is not page aligned\n",
2163		    __func__);
2164		goto err_out;
2165	}
2166
2167	/*
2168	 * Set PRP physical pointer, which initially points to the current PRP
2169	 * DMA memory page.
2170	 */
2171	prp_entry_dma = prp_page_dma;
2172
2173
2174	/* Loop while the length is not zero. */
2175	while (length) {
2176		page_mask_result = (prp_entry_dma + prp_size) & page_mask;
2177		if (!page_mask_result && (length >  dev_pgsz)) {
2178			dprint_bsg_err(mrioc,
2179			    "%s: single PRP page is not sufficient\n",
2180			    __func__);
2181			goto err_out;
2182		}
2183
2184		/* Need to handle if entry will be part of a page. */
2185		offset = dma_addr & page_mask;
2186		entry_len = dev_pgsz - offset;
2187
2188		if (prp_entry == prp1_entry) {
2189			/*
2190			 * Must fill in the first PRP pointer (PRP1) before
2191			 * moving on.
2192			 */
2193			*prp1_entry = cpu_to_le64(dma_addr);
2194			if (*prp1_entry & sgemod_mask) {
2195				dprint_bsg_err(mrioc,
2196				    "%s: PRP1 address collides with SGE modifier\n",
2197				    __func__);
2198				goto err_out;
2199			}
2200			*prp1_entry &= ~sgemod_mask;
2201			*prp1_entry |= sgemod_val;
2202
2203			/*
2204			 * Now point to the second PRP entry within the
2205			 * command (PRP2).
2206			 */
2207			prp_entry = prp2_entry;
2208		} else if (prp_entry == prp2_entry) {
2209			/*
2210			 * Should the PRP2 entry be a PRP List pointer or just
2211			 * a regular PRP pointer?  If there is more than one
2212			 * more page of data, must use a PRP List pointer.
2213			 */
2214			if (length > dev_pgsz) {
2215				/*
2216				 * PRP2 will contain a PRP List pointer because
2217				 * more PRP's are needed with this command. The
2218				 * list will start at the beginning of the
2219				 * contiguous buffer.
2220				 */
2221				*prp2_entry = cpu_to_le64(prp_entry_dma);
2222				if (*prp2_entry & sgemod_mask) {
2223					dprint_bsg_err(mrioc,
2224					    "%s: PRP list address collides with SGE modifier\n",
2225					    __func__);
2226					goto err_out;
2227				}
2228				*prp2_entry &= ~sgemod_mask;
2229				*prp2_entry |= sgemod_val;
2230
2231				/*
2232				 * The next PRP Entry will be the start of the
2233				 * first PRP List.
2234				 */
2235				prp_entry = prp_page;
2236				continue;
2237			} else {
2238				/*
2239				 * After this, the PRP Entries are complete.
2240				 * This command uses 2 PRP's and no PRP list.
2241				 */
2242				*prp2_entry = cpu_to_le64(dma_addr);
2243				if (*prp2_entry & sgemod_mask) {
2244					dprint_bsg_err(mrioc,
2245					    "%s: PRP2 collides with SGE modifier\n",
2246					    __func__);
2247					goto err_out;
2248				}
2249				*prp2_entry &= ~sgemod_mask;
2250				*prp2_entry |= sgemod_val;
2251			}
2252		} else {
2253			/*
2254			 * Put entry in list and bump the addresses.
2255			 *
2256			 * After PRP1 and PRP2 are filled in, this will fill in
2257			 * all remaining PRP entries in a PRP List, one per
2258			 * each time through the loop.
2259			 */
2260			*prp_entry = cpu_to_le64(dma_addr);
2261			if (*prp_entry & sgemod_mask) {
2262				dprint_bsg_err(mrioc,
2263				    "%s: PRP address collides with SGE modifier\n",
2264				    __func__);
2265				goto err_out;
2266			}
2267			*prp_entry &= ~sgemod_mask;
2268			*prp_entry |= sgemod_val;
2269			prp_entry++;
2270			prp_entry_dma += prp_size;
2271		}
2272
2273		/* decrement length accounting for last partial page. */
2274		if (entry_len >= length) {
2275			length = 0;
2276		} else {
2277			if (entry_len <= desc_len) {
2278				dma_addr += entry_len;
2279				desc_len -= entry_len;
2280			}
2281			if (!desc_len) {
2282				if ((++desc_count) >=
2283				   drv_buf_iter->num_dma_desc) {
2284					dprint_bsg_err(mrioc,
2285						       "%s: Invalid len %zd while building PRP\n",
2286						       __func__, length);
2287					goto err_out;
2288				}
2289				dma_addr =
2290				    drv_buf_iter->dma_desc[desc_count].dma_addr;
2291				desc_len =
2292				    drv_buf_iter->dma_desc[desc_count].size;
2293			}
2294			length -= entry_len;
2295		}
2296	}
2297
2298	return 0;
2299err_out:
2300	if (mrioc->prp_list_virt) {
2301		dma_free_coherent(&mrioc->pdev->dev, mrioc->prp_sz,
2302		    mrioc->prp_list_virt, mrioc->prp_list_dma);
2303		mrioc->prp_list_virt = NULL;
2304	}
2305	return -1;
2306}
2307
2308/**
2309 * mpi3mr_map_data_buffer_dma - build dma descriptors for data
2310 *                              buffers
2311 * @mrioc: Adapter instance reference
2312 * @drv_buf: buffer map descriptor
2313 * @desc_count: Number of already consumed dma descriptors
2314 *
2315 * This function computes how many pre-allocated DMA descriptors
2316 * are required for the given data buffer and if those number of
2317 * descriptors are free, then setup the mapping of the scattered
2318 * DMA address to the given data buffer, if the data direction
2319 * of the buffer is DMA_TO_DEVICE then the actual data is copied to
2320 * the DMA buffers
2321 *
2322 * Return: 0 on success, -1 on failure
2323 */
2324static int mpi3mr_map_data_buffer_dma(struct mpi3mr_ioc *mrioc,
2325				      struct mpi3mr_buf_map *drv_buf,
2326				      u16 desc_count)
2327{
2328	u16 i, needed_desc = drv_buf->kern_buf_len / MPI3MR_IOCTL_SGE_SIZE;
2329	u32 buf_len = drv_buf->kern_buf_len, copied_len = 0;
2330
2331	if (drv_buf->kern_buf_len % MPI3MR_IOCTL_SGE_SIZE)
2332		needed_desc++;
2333	if ((needed_desc + desc_count) > MPI3MR_NUM_IOCTL_SGE) {
2334		dprint_bsg_err(mrioc, "%s: DMA descriptor mapping error %d:%d:%d\n",
2335			       __func__, needed_desc, desc_count, MPI3MR_NUM_IOCTL_SGE);
2336		return -1;
2337	}
2338	drv_buf->dma_desc = kzalloc(sizeof(*drv_buf->dma_desc) * needed_desc,
2339				    GFP_KERNEL);
2340	if (!drv_buf->dma_desc)
2341		return -1;
2342	for (i = 0; i < needed_desc; i++, desc_count++) {
2343		drv_buf->dma_desc[i].addr = mrioc->ioctl_sge[desc_count].addr;
2344		drv_buf->dma_desc[i].dma_addr =
2345		    mrioc->ioctl_sge[desc_count].dma_addr;
2346		if (buf_len < mrioc->ioctl_sge[desc_count].size)
2347			drv_buf->dma_desc[i].size = buf_len;
2348		else
2349			drv_buf->dma_desc[i].size =
2350			    mrioc->ioctl_sge[desc_count].size;
2351		buf_len -= drv_buf->dma_desc[i].size;
2352		memset(drv_buf->dma_desc[i].addr, 0,
2353		       mrioc->ioctl_sge[desc_count].size);
2354		if (drv_buf->data_dir == DMA_TO_DEVICE) {
2355			memcpy(drv_buf->dma_desc[i].addr,
2356			       drv_buf->bsg_buf + copied_len,
2357			       drv_buf->dma_desc[i].size);
2358			copied_len += drv_buf->dma_desc[i].size;
2359		}
2360	}
2361	drv_buf->num_dma_desc = needed_desc;
2362	return 0;
2363}
2364/**
2365 * mpi3mr_bsg_process_mpt_cmds - MPI Pass through BSG handler
2366 * @job: BSG job reference
2367 *
2368 * This function is the top level handler for MPI Pass through
2369 * command, this does basic validation of the input data buffers,
2370 * identifies the given buffer types and MPI command, allocates
2371 * DMAable memory for user given buffers, construstcs SGL
2372 * properly and passes the command to the firmware.
2373 *
2374 * Once the MPI command is completed the driver copies the data
2375 * if any and reply, sense information to user provided buffers.
2376 * If the command is timed out then issues controller reset
2377 * prior to returning.
2378 *
2379 * Return: 0 on success and proper error codes on failure
2380 */
2381
2382static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job)
2383{
2384	long rval = -EINVAL;
2385	struct mpi3mr_ioc *mrioc = NULL;
2386	u8 *mpi_req = NULL, *sense_buff_k = NULL;
2387	u8 mpi_msg_size = 0;
2388	struct mpi3mr_bsg_packet *bsg_req = NULL;
2389	struct mpi3mr_bsg_mptcmd *karg;
2390	struct mpi3mr_buf_entry *buf_entries = NULL;
2391	struct mpi3mr_buf_map *drv_bufs = NULL, *drv_buf_iter = NULL;
2392	u8 count, bufcnt = 0, is_rmcb = 0, is_rmrb = 0;
2393	u8 din_cnt = 0, dout_cnt = 0;
2394	u8 invalid_be = 0, erb_offset = 0xFF, mpirep_offset = 0xFF;
2395	u8 block_io = 0, nvme_fmt = 0, resp_code = 0;
2396	struct mpi3_request_header *mpi_header = NULL;
2397	struct mpi3_status_reply_descriptor *status_desc;
2398	struct mpi3_scsi_task_mgmt_request *tm_req;
2399	u32 erbsz = MPI3MR_SENSE_BUF_SZ, tmplen;
2400	u16 dev_handle;
2401	struct mpi3mr_tgt_dev *tgtdev;
2402	struct mpi3mr_stgt_priv_data *stgt_priv = NULL;
2403	struct mpi3mr_bsg_in_reply_buf *bsg_reply_buf = NULL;
2404	u32 din_size = 0, dout_size = 0;
2405	u8 *din_buf = NULL, *dout_buf = NULL;
2406	u8 *sgl_iter = NULL, *sgl_din_iter = NULL, *sgl_dout_iter = NULL;
2407	u16 rmc_size  = 0, desc_count = 0;
2408
2409	bsg_req = job->request;
2410	karg = (struct mpi3mr_bsg_mptcmd *)&bsg_req->cmd.mptcmd;
2411
2412	mrioc = mpi3mr_bsg_verify_adapter(karg->mrioc_id);
2413	if (!mrioc)
2414		return -ENODEV;
2415
2416	if (mutex_lock_interruptible(&mrioc->bsg_cmds.mutex))
2417		return -ERESTARTSYS;
2418
2419	if (mrioc->bsg_cmds.state & MPI3MR_CMD_PENDING) {
2420		dprint_bsg_err(mrioc, "%s: command is in use\n", __func__);
2421		mutex_unlock(&mrioc->bsg_cmds.mutex);
2422		return -EAGAIN;
2423	}
2424
2425	if (!mrioc->ioctl_sges_allocated) {
2426		mutex_unlock(&mrioc->bsg_cmds.mutex);
2427		dprint_bsg_err(mrioc, "%s: DMA memory was not allocated\n",
2428			       __func__);
2429		return -ENOMEM;
2430	}
2431
2432	if (karg->timeout < MPI3MR_APP_DEFAULT_TIMEOUT)
2433		karg->timeout = MPI3MR_APP_DEFAULT_TIMEOUT;
2434
2435	mpi_req = kzalloc(MPI3MR_ADMIN_REQ_FRAME_SZ, GFP_KERNEL);
2436	if (!mpi_req) {
2437		mutex_unlock(&mrioc->bsg_cmds.mutex);
2438		return -ENOMEM;
2439	}
2440	mpi_header = (struct mpi3_request_header *)mpi_req;
2441
2442	bufcnt = karg->buf_entry_list.num_of_entries;
2443	drv_bufs = kzalloc((sizeof(*drv_bufs) * bufcnt), GFP_KERNEL);
2444	if (!drv_bufs) {
2445		mutex_unlock(&mrioc->bsg_cmds.mutex);
2446		rval = -ENOMEM;
2447		goto out;
2448	}
2449
2450	dout_buf = kzalloc(job->request_payload.payload_len,
2451				      GFP_KERNEL);
2452	if (!dout_buf) {
2453		mutex_unlock(&mrioc->bsg_cmds.mutex);
2454		rval = -ENOMEM;
2455		goto out;
2456	}
2457
2458	din_buf = kzalloc(job->reply_payload.payload_len,
2459				     GFP_KERNEL);
2460	if (!din_buf) {
2461		mutex_unlock(&mrioc->bsg_cmds.mutex);
2462		rval = -ENOMEM;
2463		goto out;
2464	}
2465
2466	sg_copy_to_buffer(job->request_payload.sg_list,
2467			  job->request_payload.sg_cnt,
2468			  dout_buf, job->request_payload.payload_len);
2469
2470	buf_entries = karg->buf_entry_list.buf_entry;
2471	sgl_din_iter = din_buf;
2472	sgl_dout_iter = dout_buf;
2473	drv_buf_iter = drv_bufs;
2474
2475	for (count = 0; count < bufcnt; count++, buf_entries++, drv_buf_iter++) {
2476
2477		switch (buf_entries->buf_type) {
2478		case MPI3MR_BSG_BUFTYPE_RAIDMGMT_CMD:
2479			sgl_iter = sgl_dout_iter;
2480			sgl_dout_iter += buf_entries->buf_len;
2481			drv_buf_iter->data_dir = DMA_TO_DEVICE;
2482			is_rmcb = 1;
2483			if ((count != 0) || !buf_entries->buf_len)
2484				invalid_be = 1;
2485			break;
2486		case MPI3MR_BSG_BUFTYPE_RAIDMGMT_RESP:
2487			sgl_iter = sgl_din_iter;
2488			sgl_din_iter += buf_entries->buf_len;
2489			drv_buf_iter->data_dir = DMA_FROM_DEVICE;
2490			is_rmrb = 1;
2491			if (count != 1 || !is_rmcb || !buf_entries->buf_len)
2492				invalid_be = 1;
2493			break;
2494		case MPI3MR_BSG_BUFTYPE_DATA_IN:
2495			sgl_iter = sgl_din_iter;
2496			sgl_din_iter += buf_entries->buf_len;
2497			drv_buf_iter->data_dir = DMA_FROM_DEVICE;
2498			din_cnt++;
2499			din_size += buf_entries->buf_len;
2500			if ((din_cnt > 1) && !is_rmcb)
2501				invalid_be = 1;
2502			break;
2503		case MPI3MR_BSG_BUFTYPE_DATA_OUT:
2504			sgl_iter = sgl_dout_iter;
2505			sgl_dout_iter += buf_entries->buf_len;
2506			drv_buf_iter->data_dir = DMA_TO_DEVICE;
2507			dout_cnt++;
2508			dout_size += buf_entries->buf_len;
2509			if ((dout_cnt > 1) && !is_rmcb)
2510				invalid_be = 1;
2511			break;
2512		case MPI3MR_BSG_BUFTYPE_MPI_REPLY:
2513			sgl_iter = sgl_din_iter;
2514			sgl_din_iter += buf_entries->buf_len;
2515			drv_buf_iter->data_dir = DMA_NONE;
2516			mpirep_offset = count;
2517			if (!buf_entries->buf_len)
2518				invalid_be = 1;
2519			break;
2520		case MPI3MR_BSG_BUFTYPE_ERR_RESPONSE:
2521			sgl_iter = sgl_din_iter;
2522			sgl_din_iter += buf_entries->buf_len;
2523			drv_buf_iter->data_dir = DMA_NONE;
2524			erb_offset = count;
2525			if (!buf_entries->buf_len)
2526				invalid_be = 1;
2527			break;
2528		case MPI3MR_BSG_BUFTYPE_MPI_REQUEST:
2529			sgl_iter = sgl_dout_iter;
2530			sgl_dout_iter += buf_entries->buf_len;
2531			drv_buf_iter->data_dir = DMA_NONE;
2532			mpi_msg_size = buf_entries->buf_len;
2533			if ((!mpi_msg_size || (mpi_msg_size % 4)) ||
2534					(mpi_msg_size > MPI3MR_ADMIN_REQ_FRAME_SZ)) {
2535				dprint_bsg_err(mrioc, "%s: invalid MPI message size\n",
2536					__func__);
2537				mutex_unlock(&mrioc->bsg_cmds.mutex);
2538				rval = -EINVAL;
2539				goto out;
2540			}
2541			memcpy(mpi_req, sgl_iter, buf_entries->buf_len);
2542			break;
2543		default:
2544			invalid_be = 1;
2545			break;
2546		}
2547		if (invalid_be) {
2548			dprint_bsg_err(mrioc, "%s: invalid buffer entries passed\n",
2549				__func__);
2550			mutex_unlock(&mrioc->bsg_cmds.mutex);
2551			rval = -EINVAL;
2552			goto out;
2553		}
2554
2555		if (sgl_dout_iter > (dout_buf + job->request_payload.payload_len)) {
2556			dprint_bsg_err(mrioc, "%s: data_out buffer length mismatch\n",
2557				       __func__);
2558			mutex_unlock(&mrioc->bsg_cmds.mutex);
2559			rval = -EINVAL;
2560			goto out;
2561		}
2562		if (sgl_din_iter > (din_buf + job->reply_payload.payload_len)) {
2563			dprint_bsg_err(mrioc, "%s: data_in buffer length mismatch\n",
2564				       __func__);
2565			mutex_unlock(&mrioc->bsg_cmds.mutex);
2566			rval = -EINVAL;
2567			goto out;
2568		}
2569
2570		drv_buf_iter->bsg_buf = sgl_iter;
2571		drv_buf_iter->bsg_buf_len = buf_entries->buf_len;
2572	}
2573
2574	if (is_rmcb && ((din_size + dout_size) > MPI3MR_MAX_APP_XFER_SIZE)) {
2575		dprint_bsg_err(mrioc, "%s:%d: invalid data transfer size passed for function 0x%x din_size = %d, dout_size = %d\n",
2576			       __func__, __LINE__, mpi_header->function, din_size,
2577			       dout_size);
2578		mutex_unlock(&mrioc->bsg_cmds.mutex);
2579		rval = -EINVAL;
2580		goto out;
2581	}
2582
2583	if (din_size > MPI3MR_MAX_APP_XFER_SIZE) {
2584		dprint_bsg_err(mrioc,
2585		    "%s:%d: invalid data transfer size passed for function 0x%x din_size=%d\n",
2586		    __func__, __LINE__, mpi_header->function, din_size);
2587		mutex_unlock(&mrioc->bsg_cmds.mutex);
2588		rval = -EINVAL;
2589		goto out;
2590	}
2591	if (dout_size > MPI3MR_MAX_APP_XFER_SIZE) {
2592		dprint_bsg_err(mrioc,
2593		    "%s:%d: invalid data transfer size passed for function 0x%x dout_size = %d\n",
2594		    __func__, __LINE__, mpi_header->function, dout_size);
2595		mutex_unlock(&mrioc->bsg_cmds.mutex);
2596		rval = -EINVAL;
2597		goto out;
2598	}
2599
2600	if (mpi_header->function == MPI3_BSG_FUNCTION_SMP_PASSTHROUGH) {
2601		if (din_size > MPI3MR_IOCTL_SGE_SIZE ||
2602		    dout_size > MPI3MR_IOCTL_SGE_SIZE) {
2603			dprint_bsg_err(mrioc, "%s:%d: invalid message size passed:%d:%d:%d:%d\n",
2604				       __func__, __LINE__, din_cnt, dout_cnt, din_size,
2605			    dout_size);
2606			mutex_unlock(&mrioc->bsg_cmds.mutex);
2607			rval = -EINVAL;
2608			goto out;
2609		}
2610	}
2611
2612	drv_buf_iter = drv_bufs;
2613	for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
2614		if (drv_buf_iter->data_dir == DMA_NONE)
2615			continue;
2616
2617		drv_buf_iter->kern_buf_len = drv_buf_iter->bsg_buf_len;
2618		if (is_rmcb && !count) {
2619			drv_buf_iter->kern_buf_len =
2620			    mrioc->ioctl_chain_sge.size;
2621			drv_buf_iter->kern_buf =
2622			    mrioc->ioctl_chain_sge.addr;
2623			drv_buf_iter->kern_buf_dma =
2624			    mrioc->ioctl_chain_sge.dma_addr;
2625			drv_buf_iter->dma_desc = NULL;
2626			drv_buf_iter->num_dma_desc = 0;
2627			memset(drv_buf_iter->kern_buf, 0,
2628			       drv_buf_iter->kern_buf_len);
2629			tmplen = min(drv_buf_iter->kern_buf_len,
2630				     drv_buf_iter->bsg_buf_len);
2631			rmc_size = tmplen;
2632			memcpy(drv_buf_iter->kern_buf, drv_buf_iter->bsg_buf, tmplen);
2633		} else if (is_rmrb && (count == 1)) {
2634			drv_buf_iter->kern_buf_len =
2635			    mrioc->ioctl_resp_sge.size;
2636			drv_buf_iter->kern_buf =
2637			    mrioc->ioctl_resp_sge.addr;
2638			drv_buf_iter->kern_buf_dma =
2639			    mrioc->ioctl_resp_sge.dma_addr;
2640			drv_buf_iter->dma_desc = NULL;
2641			drv_buf_iter->num_dma_desc = 0;
2642			memset(drv_buf_iter->kern_buf, 0,
2643			       drv_buf_iter->kern_buf_len);
2644			tmplen = min(drv_buf_iter->kern_buf_len,
2645				     drv_buf_iter->bsg_buf_len);
2646			drv_buf_iter->kern_buf_len = tmplen;
2647			memset(drv_buf_iter->bsg_buf, 0,
2648			       drv_buf_iter->bsg_buf_len);
2649		} else {
2650			if (!drv_buf_iter->kern_buf_len)
2651				continue;
2652			if (mpi3mr_map_data_buffer_dma(mrioc, drv_buf_iter, desc_count)) {
2653				rval = -ENOMEM;
2654				mutex_unlock(&mrioc->bsg_cmds.mutex);
2655				dprint_bsg_err(mrioc, "%s:%d: mapping data buffers failed\n",
2656					       __func__, __LINE__);
2657			goto out;
2658		}
2659			desc_count += drv_buf_iter->num_dma_desc;
2660		}
2661	}
2662
2663	if (erb_offset != 0xFF) {
2664		sense_buff_k = kzalloc(erbsz, GFP_KERNEL);
2665		if (!sense_buff_k) {
2666			rval = -ENOMEM;
2667			mutex_unlock(&mrioc->bsg_cmds.mutex);
2668			goto out;
2669		}
2670	}
2671
2672	if (mrioc->unrecoverable) {
2673		dprint_bsg_err(mrioc, "%s: unrecoverable controller\n",
2674		    __func__);
2675		rval = -EFAULT;
2676		mutex_unlock(&mrioc->bsg_cmds.mutex);
2677		goto out;
2678	}
2679	if (mrioc->reset_in_progress) {
2680		dprint_bsg_err(mrioc, "%s: reset in progress\n", __func__);
2681		rval = -EAGAIN;
2682		mutex_unlock(&mrioc->bsg_cmds.mutex);
2683		goto out;
2684	}
2685	if (mrioc->stop_bsgs || mrioc->block_on_pci_err) {
2686		dprint_bsg_err(mrioc, "%s: bsgs are blocked\n", __func__);
2687		rval = -EAGAIN;
2688		mutex_unlock(&mrioc->bsg_cmds.mutex);
2689		goto out;
2690	}
2691
2692	if (mpi_header->function == MPI3_BSG_FUNCTION_NVME_ENCAPSULATED) {
2693		nvme_fmt = mpi3mr_get_nvme_data_fmt(
2694			(struct mpi3_nvme_encapsulated_request *)mpi_req);
2695		if (nvme_fmt == MPI3MR_NVME_DATA_FORMAT_PRP) {
2696			if (mpi3mr_build_nvme_prp(mrioc,
2697			    (struct mpi3_nvme_encapsulated_request *)mpi_req,
2698			    drv_bufs, bufcnt)) {
2699				rval = -ENOMEM;
2700				mutex_unlock(&mrioc->bsg_cmds.mutex);
2701				goto out;
2702			}
2703		} else if (nvme_fmt == MPI3MR_NVME_DATA_FORMAT_SGL1 ||
2704			nvme_fmt == MPI3MR_NVME_DATA_FORMAT_SGL2) {
2705			if (mpi3mr_build_nvme_sgl(mrioc,
2706			    (struct mpi3_nvme_encapsulated_request *)mpi_req,
2707			    drv_bufs, bufcnt)) {
2708				rval = -EINVAL;
2709				mutex_unlock(&mrioc->bsg_cmds.mutex);
2710				goto out;
2711			}
2712		} else {
2713			dprint_bsg_err(mrioc,
2714			    "%s:invalid NVMe command format\n", __func__);
2715			rval = -EINVAL;
2716			mutex_unlock(&mrioc->bsg_cmds.mutex);
2717			goto out;
2718		}
2719	} else {
2720		if (mpi3mr_bsg_build_sgl(mrioc, mpi_req, mpi_msg_size,
2721					 drv_bufs, bufcnt, is_rmcb, is_rmrb,
2722					 (dout_cnt + din_cnt))) {
2723			dprint_bsg_err(mrioc, "%s: sgl build failed\n", __func__);
2724			rval = -EAGAIN;
2725			mutex_unlock(&mrioc->bsg_cmds.mutex);
2726			goto out;
2727		}
2728	}
2729
2730	if (mpi_header->function == MPI3_BSG_FUNCTION_SCSI_TASK_MGMT) {
2731		tm_req = (struct mpi3_scsi_task_mgmt_request *)mpi_req;
2732		if (tm_req->task_type !=
2733		    MPI3_SCSITASKMGMT_TASKTYPE_ABORT_TASK) {
2734			dev_handle = tm_req->dev_handle;
2735			block_io = 1;
2736		}
2737	}
2738	if (block_io) {
2739		tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, dev_handle);
2740		if (tgtdev && tgtdev->starget && tgtdev->starget->hostdata) {
2741			stgt_priv = (struct mpi3mr_stgt_priv_data *)
2742			    tgtdev->starget->hostdata;
2743			atomic_inc(&stgt_priv->block_io);
2744			mpi3mr_tgtdev_put(tgtdev);
2745		}
2746	}
2747
2748	mrioc->bsg_cmds.state = MPI3MR_CMD_PENDING;
2749	mrioc->bsg_cmds.is_waiting = 1;
2750	mrioc->bsg_cmds.callback = NULL;
2751	mrioc->bsg_cmds.is_sense = 0;
2752	mrioc->bsg_cmds.sensebuf = sense_buff_k;
2753	memset(mrioc->bsg_cmds.reply, 0, mrioc->reply_sz);
2754	mpi_header->host_tag = cpu_to_le16(MPI3MR_HOSTTAG_BSG_CMDS);
2755	if (mrioc->logging_level & MPI3_DEBUG_BSG_INFO) {
2756		dprint_bsg_info(mrioc,
2757		    "%s: posting bsg request to the controller\n", __func__);
2758		dprint_dump(mpi_req, MPI3MR_ADMIN_REQ_FRAME_SZ,
2759		    "bsg_mpi3_req");
2760		if (mpi_header->function == MPI3_BSG_FUNCTION_MGMT_PASSTHROUGH) {
2761			drv_buf_iter = &drv_bufs[0];
2762			dprint_dump(drv_buf_iter->kern_buf,
2763			    rmc_size, "mpi3_mgmt_req");
2764		}
2765	}
2766
2767	init_completion(&mrioc->bsg_cmds.done);
2768	rval = mpi3mr_admin_request_post(mrioc, mpi_req,
2769	    MPI3MR_ADMIN_REQ_FRAME_SZ, 0);
2770
2771
2772	if (rval) {
2773		mrioc->bsg_cmds.is_waiting = 0;
2774		dprint_bsg_err(mrioc,
2775		    "%s: posting bsg request is failed\n", __func__);
2776		rval = -EAGAIN;
2777		goto out_unlock;
2778	}
2779	wait_for_completion_timeout(&mrioc->bsg_cmds.done,
2780	    (karg->timeout * HZ));
2781	if (block_io && stgt_priv)
2782		atomic_dec(&stgt_priv->block_io);
2783	if (!(mrioc->bsg_cmds.state & MPI3MR_CMD_COMPLETE)) {
2784		mrioc->bsg_cmds.is_waiting = 0;
2785		rval = -EAGAIN;
2786		if (mrioc->bsg_cmds.state & MPI3MR_CMD_RESET)
2787			goto out_unlock;
2788		if (((mpi_header->function != MPI3_FUNCTION_SCSI_IO) &&
2789		    (mpi_header->function != MPI3_FUNCTION_NVME_ENCAPSULATED))
2790		    || (mrioc->logging_level & MPI3_DEBUG_BSG_ERROR)) {
2791			ioc_info(mrioc, "%s: bsg request timedout after %d seconds\n",
2792			    __func__, karg->timeout);
2793			if (!(mrioc->logging_level & MPI3_DEBUG_BSG_INFO)) {
2794				dprint_dump(mpi_req, MPI3MR_ADMIN_REQ_FRAME_SZ,
2795			    "bsg_mpi3_req");
2796			if (mpi_header->function ==
2797			    MPI3_FUNCTION_MGMT_PASSTHROUGH) {
2798				drv_buf_iter = &drv_bufs[0];
2799				dprint_dump(drv_buf_iter->kern_buf,
2800				    rmc_size, "mpi3_mgmt_req");
2801				}
2802			}
2803		}
2804		if ((mpi_header->function == MPI3_BSG_FUNCTION_NVME_ENCAPSULATED) ||
2805			(mpi_header->function == MPI3_BSG_FUNCTION_SCSI_IO)) {
2806			dprint_bsg_err(mrioc, "%s: bsg request timedout after %d seconds,\n"
2807				"issuing target reset to (0x%04x)\n", __func__,
2808				karg->timeout, mpi_header->function_dependent);
2809			mpi3mr_issue_tm(mrioc,
2810			    MPI3_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
2811			    mpi_header->function_dependent, 0,
2812			    MPI3MR_HOSTTAG_BLK_TMS, MPI3MR_RESETTM_TIMEOUT,
2813			    &mrioc->host_tm_cmds, &resp_code, NULL);
2814		}
2815		if (!(mrioc->bsg_cmds.state & MPI3MR_CMD_COMPLETE) &&
2816		    !(mrioc->bsg_cmds.state & MPI3MR_CMD_RESET))
2817			mpi3mr_soft_reset_handler(mrioc,
2818			    MPI3MR_RESET_FROM_APP_TIMEOUT, 1);
2819		goto out_unlock;
2820	}
2821	dprint_bsg_info(mrioc, "%s: bsg request is completed\n", __func__);
2822
2823	if (mrioc->prp_list_virt) {
2824		dma_free_coherent(&mrioc->pdev->dev, mrioc->prp_sz,
2825		    mrioc->prp_list_virt, mrioc->prp_list_dma);
2826		mrioc->prp_list_virt = NULL;
2827	}
2828
2829	if ((mrioc->bsg_cmds.ioc_status & MPI3_IOCSTATUS_STATUS_MASK)
2830	     != MPI3_IOCSTATUS_SUCCESS) {
2831		dprint_bsg_info(mrioc,
2832		    "%s: command failed, ioc_status(0x%04x) log_info(0x%08x)\n",
2833		    __func__,
2834		    (mrioc->bsg_cmds.ioc_status & MPI3_IOCSTATUS_STATUS_MASK),
2835		    mrioc->bsg_cmds.ioc_loginfo);
2836	}
2837
2838	if ((mpirep_offset != 0xFF) &&
2839	    drv_bufs[mpirep_offset].bsg_buf_len) {
2840		drv_buf_iter = &drv_bufs[mpirep_offset];
2841		drv_buf_iter->kern_buf_len = (sizeof(*bsg_reply_buf) +
2842					   mrioc->reply_sz);
2843		bsg_reply_buf = kzalloc(drv_buf_iter->kern_buf_len, GFP_KERNEL);
2844
2845		if (!bsg_reply_buf) {
2846			rval = -ENOMEM;
2847			goto out_unlock;
2848		}
2849		if (mrioc->bsg_cmds.state & MPI3MR_CMD_REPLY_VALID) {
2850			bsg_reply_buf->mpi_reply_type =
2851				MPI3MR_BSG_MPI_REPLY_BUFTYPE_ADDRESS;
2852			memcpy(bsg_reply_buf->reply_buf,
2853			    mrioc->bsg_cmds.reply, mrioc->reply_sz);
2854		} else {
2855			bsg_reply_buf->mpi_reply_type =
2856				MPI3MR_BSG_MPI_REPLY_BUFTYPE_STATUS;
2857			status_desc = (struct mpi3_status_reply_descriptor *)
2858			    bsg_reply_buf->reply_buf;
2859			status_desc->ioc_status = mrioc->bsg_cmds.ioc_status;
2860			status_desc->ioc_log_info = mrioc->bsg_cmds.ioc_loginfo;
2861		}
2862		tmplen = min(drv_buf_iter->kern_buf_len,
2863			drv_buf_iter->bsg_buf_len);
2864		memcpy(drv_buf_iter->bsg_buf, bsg_reply_buf, tmplen);
2865	}
2866
2867	if (erb_offset != 0xFF && mrioc->bsg_cmds.sensebuf &&
2868	    mrioc->bsg_cmds.is_sense) {
2869		drv_buf_iter = &drv_bufs[erb_offset];
2870		tmplen = min(erbsz, drv_buf_iter->bsg_buf_len);
2871		memcpy(drv_buf_iter->bsg_buf, sense_buff_k, tmplen);
2872	}
2873
2874	drv_buf_iter = drv_bufs;
2875	for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
2876		if (drv_buf_iter->data_dir == DMA_NONE)
2877			continue;
2878		if ((count == 1) && is_rmrb) {
2879			memcpy(drv_buf_iter->bsg_buf,
2880			    drv_buf_iter->kern_buf,
2881			    drv_buf_iter->kern_buf_len);
2882		} else if (drv_buf_iter->data_dir == DMA_FROM_DEVICE) {
2883			tmplen = 0;
2884			for (desc_count = 0;
2885			    desc_count < drv_buf_iter->num_dma_desc;
2886			    desc_count++) {
2887				memcpy(((u8 *)drv_buf_iter->bsg_buf + tmplen),
2888				       drv_buf_iter->dma_desc[desc_count].addr,
2889				       drv_buf_iter->dma_desc[desc_count].size);
2890				tmplen +=
2891				    drv_buf_iter->dma_desc[desc_count].size;
2892		}
2893	}
2894	}
2895
2896out_unlock:
2897	if (din_buf) {
2898		job->reply_payload_rcv_len =
2899			sg_copy_from_buffer(job->reply_payload.sg_list,
2900					    job->reply_payload.sg_cnt,
2901					    din_buf, job->reply_payload.payload_len);
2902	}
2903	mrioc->bsg_cmds.is_sense = 0;
2904	mrioc->bsg_cmds.sensebuf = NULL;
2905	mrioc->bsg_cmds.state = MPI3MR_CMD_NOTUSED;
2906	mutex_unlock(&mrioc->bsg_cmds.mutex);
2907out:
2908	kfree(sense_buff_k);
2909	kfree(dout_buf);
2910	kfree(din_buf);
2911	kfree(mpi_req);
2912	if (drv_bufs) {
2913		drv_buf_iter = drv_bufs;
2914		for (count = 0; count < bufcnt; count++, drv_buf_iter++)
2915			kfree(drv_buf_iter->dma_desc);
2916		kfree(drv_bufs);
2917	}
2918	kfree(bsg_reply_buf);
2919	return rval;
2920}
2921
2922/**
2923 * mpi3mr_app_save_logdata - Save Log Data events
2924 * @mrioc: Adapter instance reference
2925 * @event_data: event data associated with log data event
2926 * @event_data_size: event data size to copy
2927 *
2928 * If log data event caching is enabled by the applicatiobns,
2929 * then this function saves the log data in the circular queue
2930 * and Sends async signal SIGIO to indicate there is an async
2931 * event from the firmware to the event monitoring applications.
2932 *
2933 * Return:Nothing
2934 */
2935void mpi3mr_app_save_logdata(struct mpi3mr_ioc *mrioc, char *event_data,
2936	u16 event_data_size)
2937{
2938	u32 index = mrioc->logdata_buf_idx, sz;
2939	struct mpi3mr_logdata_entry *entry;
2940
2941	if (!(mrioc->logdata_buf))
2942		return;
2943
2944	entry = (struct mpi3mr_logdata_entry *)
2945		(mrioc->logdata_buf + (index * mrioc->logdata_entry_sz));
2946	entry->valid_entry = 1;
2947	sz = min(mrioc->logdata_entry_sz, event_data_size);
2948	memcpy(entry->data, event_data, sz);
2949	mrioc->logdata_buf_idx =
2950		((++index) % MPI3MR_BSG_LOGDATA_MAX_ENTRIES);
2951	atomic64_inc(&event_counter);
2952}
2953
2954/**
2955 * mpi3mr_bsg_request - bsg request entry point
2956 * @job: BSG job reference
2957 *
2958 * This is driver's entry point for bsg requests
2959 *
2960 * Return: 0 on success and proper error codes on failure
2961 */
2962static int mpi3mr_bsg_request(struct bsg_job *job)
2963{
2964	long rval = -EINVAL;
2965	unsigned int reply_payload_rcv_len = 0;
2966
2967	struct mpi3mr_bsg_packet *bsg_req = job->request;
2968
2969	switch (bsg_req->cmd_type) {
2970	case MPI3MR_DRV_CMD:
2971		rval = mpi3mr_bsg_process_drv_cmds(job);
2972		break;
2973	case MPI3MR_MPT_CMD:
2974		rval = mpi3mr_bsg_process_mpt_cmds(job);
2975		break;
2976	default:
2977		pr_err("%s: unsupported BSG command(0x%08x)\n",
2978		    MPI3MR_DRIVER_NAME, bsg_req->cmd_type);
2979		break;
2980	}
2981
2982	bsg_job_done(job, rval, reply_payload_rcv_len);
2983
2984	return 0;
2985}
2986
2987/**
2988 * mpi3mr_bsg_exit - de-registration from bsg layer
2989 * @mrioc: Adapter instance reference
2990 *
2991 * This will be called during driver unload and all
2992 * bsg resources allocated during load will be freed.
2993 *
2994 * Return:Nothing
2995 */
2996void mpi3mr_bsg_exit(struct mpi3mr_ioc *mrioc)
2997{
2998	struct device *bsg_dev = &mrioc->bsg_dev;
2999	if (!mrioc->bsg_queue)
3000		return;
3001
3002	bsg_remove_queue(mrioc->bsg_queue);
3003	mrioc->bsg_queue = NULL;
3004
3005	device_del(bsg_dev);
3006	put_device(bsg_dev);
3007}
3008
3009/**
3010 * mpi3mr_bsg_node_release -release bsg device node
3011 * @dev: bsg device node
3012 *
3013 * decrements bsg dev parent reference count
3014 *
3015 * Return:Nothing
3016 */
3017static void mpi3mr_bsg_node_release(struct device *dev)
3018{
3019	put_device(dev->parent);
3020}
3021
3022/**
3023 * mpi3mr_bsg_init -  registration with bsg layer
3024 * @mrioc: Adapter instance reference
3025 *
3026 * This will be called during driver load and it will
3027 * register driver with bsg layer
3028 *
3029 * Return:Nothing
3030 */
3031void mpi3mr_bsg_init(struct mpi3mr_ioc *mrioc)
3032{
3033	struct device *bsg_dev = &mrioc->bsg_dev;
3034	struct device *parent = &mrioc->shost->shost_gendev;
3035	struct queue_limits lim = {
3036		.max_hw_sectors		= MPI3MR_MAX_APP_XFER_SECTORS,
3037		.max_segments		= MPI3MR_MAX_APP_XFER_SEGMENTS,
3038	};
3039	struct request_queue *q;
3040
3041	device_initialize(bsg_dev);
3042
3043	bsg_dev->parent = get_device(parent);
3044	bsg_dev->release = mpi3mr_bsg_node_release;
3045
3046	dev_set_name(bsg_dev, "mpi3mrctl%u", mrioc->id);
3047
3048	if (device_add(bsg_dev)) {
3049		ioc_err(mrioc, "%s: bsg device add failed\n",
3050		    dev_name(bsg_dev));
3051		put_device(bsg_dev);
3052		return;
3053	}
3054
3055	q = bsg_setup_queue(bsg_dev, dev_name(bsg_dev), &lim,
3056			mpi3mr_bsg_request, NULL, 0);
3057	if (IS_ERR(q)) {
3058		ioc_err(mrioc, "%s: bsg registration failed\n",
3059		    dev_name(bsg_dev));
3060		device_del(bsg_dev);
3061		put_device(bsg_dev);
3062		return;
3063	}
3064
3065	mrioc->bsg_queue = q;
3066}
3067
3068/**
3069 * version_fw_show - SysFS callback for firmware version read
3070 * @dev: class device
3071 * @attr: Device attributes
3072 * @buf: Buffer to copy
3073 *
3074 * Return: sysfs_emit() return after copying firmware version
3075 */
3076static ssize_t
3077version_fw_show(struct device *dev, struct device_attribute *attr,
3078	char *buf)
3079{
3080	struct Scsi_Host *shost = class_to_shost(dev);
3081	struct mpi3mr_ioc *mrioc = shost_priv(shost);
3082	struct mpi3mr_compimg_ver *fwver = &mrioc->facts.fw_ver;
3083
3084	return sysfs_emit(buf, "%d.%d.%d.%d.%05d-%05d\n",
3085	    fwver->gen_major, fwver->gen_minor, fwver->ph_major,
3086	    fwver->ph_minor, fwver->cust_id, fwver->build_num);
3087}
3088static DEVICE_ATTR_RO(version_fw);
3089
3090/**
3091 * fw_queue_depth_show - SysFS callback for firmware max cmds
3092 * @dev: class device
3093 * @attr: Device attributes
3094 * @buf: Buffer to copy
3095 *
3096 * Return: sysfs_emit() return after copying firmware max commands
3097 */
3098static ssize_t
3099fw_queue_depth_show(struct device *dev, struct device_attribute *attr,
3100			char *buf)
3101{
3102	struct Scsi_Host *shost = class_to_shost(dev);
3103	struct mpi3mr_ioc *mrioc = shost_priv(shost);
3104
3105	return sysfs_emit(buf, "%d\n", mrioc->facts.max_reqs);
3106}
3107static DEVICE_ATTR_RO(fw_queue_depth);
3108
3109/**
3110 * op_req_q_count_show - SysFS callback for request queue count
3111 * @dev: class device
3112 * @attr: Device attributes
3113 * @buf: Buffer to copy
3114 *
3115 * Return: sysfs_emit() return after copying request queue count
3116 */
3117static ssize_t
3118op_req_q_count_show(struct device *dev, struct device_attribute *attr,
3119			char *buf)
3120{
3121	struct Scsi_Host *shost = class_to_shost(dev);
3122	struct mpi3mr_ioc *mrioc = shost_priv(shost);
3123
3124	return sysfs_emit(buf, "%d\n", mrioc->num_op_req_q);
3125}
3126static DEVICE_ATTR_RO(op_req_q_count);
3127
3128/**
3129 * reply_queue_count_show - SysFS callback for reply queue count
3130 * @dev: class device
3131 * @attr: Device attributes
3132 * @buf: Buffer to copy
3133 *
3134 * Return: sysfs_emit() return after copying reply queue count
3135 */
3136static ssize_t
3137reply_queue_count_show(struct device *dev, struct device_attribute *attr,
3138			char *buf)
3139{
3140	struct Scsi_Host *shost = class_to_shost(dev);
3141	struct mpi3mr_ioc *mrioc = shost_priv(shost);
3142
3143	return sysfs_emit(buf, "%d\n", mrioc->num_op_reply_q);
3144}
3145
3146static DEVICE_ATTR_RO(reply_queue_count);
3147
3148/**
3149 * reply_qfull_count_show - Show reply qfull count
3150 * @dev: class device
3151 * @attr: Device attributes
3152 * @buf: Buffer to copy
3153 *
3154 * Retrieves the current value of the reply_qfull_count from the mrioc structure and
3155 * formats it as a string for display.
3156 *
3157 * Return: sysfs_emit() return
3158 */
3159static ssize_t
3160reply_qfull_count_show(struct device *dev, struct device_attribute *attr,
3161			char *buf)
3162{
3163	struct Scsi_Host *shost = class_to_shost(dev);
3164	struct mpi3mr_ioc *mrioc = shost_priv(shost);
3165
3166	return sysfs_emit(buf, "%u\n", atomic_read(&mrioc->reply_qfull_count));
3167}
3168
3169static DEVICE_ATTR_RO(reply_qfull_count);
3170
3171/**
3172 * logging_level_show - Show controller debug level
3173 * @dev: class device
3174 * @attr: Device attributes
3175 * @buf: Buffer to copy
3176 *
3177 * A sysfs 'read/write' shost attribute, to show the current
3178 * debug log level used by the driver for the specific
3179 * controller.
3180 *
3181 * Return: sysfs_emit() return
3182 */
3183static ssize_t
3184logging_level_show(struct device *dev,
3185	struct device_attribute *attr, char *buf)
3186
3187{
3188	struct Scsi_Host *shost = class_to_shost(dev);
3189	struct mpi3mr_ioc *mrioc = shost_priv(shost);
3190
3191	return sysfs_emit(buf, "%08xh\n", mrioc->logging_level);
3192}
3193
3194/**
3195 * logging_level_store- Change controller debug level
3196 * @dev: class device
3197 * @attr: Device attributes
3198 * @buf: Buffer to copy
3199 * @count: size of the buffer
3200 *
3201 * A sysfs 'read/write' shost attribute, to change the current
3202 * debug log level used by the driver for the specific
3203 * controller.
3204 *
3205 * Return: strlen() return
3206 */
3207static ssize_t
3208logging_level_store(struct device *dev,
3209	struct device_attribute *attr,
3210	const char *buf, size_t count)
3211{
3212	struct Scsi_Host *shost = class_to_shost(dev);
3213	struct mpi3mr_ioc *mrioc = shost_priv(shost);
3214	int val = 0;
3215
3216	if (kstrtoint(buf, 0, &val) != 0)
3217		return -EINVAL;
3218
3219	mrioc->logging_level = val;
3220	ioc_info(mrioc, "logging_level=%08xh\n", mrioc->logging_level);
3221	return strlen(buf);
3222}
3223static DEVICE_ATTR_RW(logging_level);
3224
3225/**
3226 * adp_state_show() - SysFS callback for adapter state show
3227 * @dev: class device
3228 * @attr: Device attributes
3229 * @buf: Buffer to copy
3230 *
3231 * Return: sysfs_emit() return after copying adapter state
3232 */
3233static ssize_t
3234adp_state_show(struct device *dev, struct device_attribute *attr,
3235	char *buf)
3236{
3237	struct Scsi_Host *shost = class_to_shost(dev);
3238	struct mpi3mr_ioc *mrioc = shost_priv(shost);
3239	enum mpi3mr_iocstate ioc_state;
3240	uint8_t adp_state;
3241
3242	ioc_state = mpi3mr_get_iocstate(mrioc);
3243	if (ioc_state == MRIOC_STATE_UNRECOVERABLE)
3244		adp_state = MPI3MR_BSG_ADPSTATE_UNRECOVERABLE;
3245	else if (mrioc->reset_in_progress || mrioc->stop_bsgs ||
3246		 mrioc->block_on_pci_err)
3247		adp_state = MPI3MR_BSG_ADPSTATE_IN_RESET;
3248	else if (ioc_state == MRIOC_STATE_FAULT)
3249		adp_state = MPI3MR_BSG_ADPSTATE_FAULT;
3250	else
3251		adp_state = MPI3MR_BSG_ADPSTATE_OPERATIONAL;
3252
3253	return sysfs_emit(buf, "%u\n", adp_state);
3254}
3255
3256static DEVICE_ATTR_RO(adp_state);
3257
3258static struct attribute *mpi3mr_host_attrs[] = {
3259	&dev_attr_version_fw.attr,
3260	&dev_attr_fw_queue_depth.attr,
3261	&dev_attr_op_req_q_count.attr,
3262	&dev_attr_reply_queue_count.attr,
3263	&dev_attr_reply_qfull_count.attr,
3264	&dev_attr_logging_level.attr,
3265	&dev_attr_adp_state.attr,
3266	NULL,
3267};
3268
3269static const struct attribute_group mpi3mr_host_attr_group = {
3270	.attrs = mpi3mr_host_attrs
3271};
3272
3273const struct attribute_group *mpi3mr_host_groups[] = {
3274	&mpi3mr_host_attr_group,
3275	NULL,
3276};
3277
3278
3279/*
3280 * SCSI Device attributes under sysfs
3281 */
3282
3283/**
3284 * sas_address_show - SysFS callback for dev SASaddress display
3285 * @dev: class device
3286 * @attr: Device attributes
3287 * @buf: Buffer to copy
3288 *
3289 * Return: sysfs_emit() return after copying SAS address of the
3290 * specific SAS/SATA end device.
3291 */
3292static ssize_t
3293sas_address_show(struct device *dev, struct device_attribute *attr,
3294			char *buf)
3295{
3296	struct scsi_device *sdev = to_scsi_device(dev);
3297	struct mpi3mr_sdev_priv_data *sdev_priv_data;
3298	struct mpi3mr_stgt_priv_data *tgt_priv_data;
3299	struct mpi3mr_tgt_dev *tgtdev;
3300
3301	sdev_priv_data = sdev->hostdata;
3302	if (!sdev_priv_data)
3303		return 0;
3304
3305	tgt_priv_data = sdev_priv_data->tgt_priv_data;
3306	if (!tgt_priv_data)
3307		return 0;
3308	tgtdev = tgt_priv_data->tgt_dev;
3309	if (!tgtdev || tgtdev->dev_type != MPI3_DEVICE_DEVFORM_SAS_SATA)
3310		return 0;
3311	return sysfs_emit(buf, "0x%016llx\n",
3312	    (unsigned long long)tgtdev->dev_spec.sas_sata_inf.sas_address);
3313}
3314
3315static DEVICE_ATTR_RO(sas_address);
3316
3317/**
3318 * device_handle_show - SysFS callback for device handle display
3319 * @dev: class device
3320 * @attr: Device attributes
3321 * @buf: Buffer to copy
3322 *
3323 * Return: sysfs_emit() return after copying firmware internal
3324 * device handle of the specific device.
3325 */
3326static ssize_t
3327device_handle_show(struct device *dev, struct device_attribute *attr,
3328			char *buf)
3329{
3330	struct scsi_device *sdev = to_scsi_device(dev);
3331	struct mpi3mr_sdev_priv_data *sdev_priv_data;
3332	struct mpi3mr_stgt_priv_data *tgt_priv_data;
3333	struct mpi3mr_tgt_dev *tgtdev;
3334
3335	sdev_priv_data = sdev->hostdata;
3336	if (!sdev_priv_data)
3337		return 0;
3338
3339	tgt_priv_data = sdev_priv_data->tgt_priv_data;
3340	if (!tgt_priv_data)
3341		return 0;
3342	tgtdev = tgt_priv_data->tgt_dev;
3343	if (!tgtdev)
3344		return 0;
3345	return sysfs_emit(buf, "0x%04x\n", tgtdev->dev_handle);
3346}
3347
3348static DEVICE_ATTR_RO(device_handle);
3349
3350/**
3351 * persistent_id_show - SysFS callback for persisten ID display
3352 * @dev: class device
3353 * @attr: Device attributes
3354 * @buf: Buffer to copy
3355 *
3356 * Return: sysfs_emit() return after copying persistent ID of the
3357 * of the specific device.
3358 */
3359static ssize_t
3360persistent_id_show(struct device *dev, struct device_attribute *attr,
3361			char *buf)
3362{
3363	struct scsi_device *sdev = to_scsi_device(dev);
3364	struct mpi3mr_sdev_priv_data *sdev_priv_data;
3365	struct mpi3mr_stgt_priv_data *tgt_priv_data;
3366	struct mpi3mr_tgt_dev *tgtdev;
3367
3368	sdev_priv_data = sdev->hostdata;
3369	if (!sdev_priv_data)
3370		return 0;
3371
3372	tgt_priv_data = sdev_priv_data->tgt_priv_data;
3373	if (!tgt_priv_data)
3374		return 0;
3375	tgtdev = tgt_priv_data->tgt_dev;
3376	if (!tgtdev)
3377		return 0;
3378	return sysfs_emit(buf, "%d\n", tgtdev->perst_id);
3379}
3380static DEVICE_ATTR_RO(persistent_id);
3381
3382/**
3383 * sas_ncq_prio_supported_show - Indicate if device supports NCQ priority
3384 * @dev: pointer to embedded device
3385 * @attr: sas_ncq_prio_supported attribute descriptor
3386 * @buf: the buffer returned
3387 *
3388 * A sysfs 'read-only' sdev attribute, only works with SATA devices
3389 *
3390 * Returns: the number of characters written to @buf
3391 */
3392static ssize_t
3393sas_ncq_prio_supported_show(struct device *dev,
3394			    struct device_attribute *attr, char *buf)
3395{
3396	struct scsi_device *sdev = to_scsi_device(dev);
3397
3398	return sysfs_emit(buf, "%d\n", sas_ata_ncq_prio_supported(sdev));
3399}
3400static DEVICE_ATTR_RO(sas_ncq_prio_supported);
3401
3402/**
3403 * sas_ncq_prio_enable_show - send prioritized io commands to device
3404 * @dev: pointer to embedded device
3405 * @attr: sas_ncq_prio_enable attribute descriptor
3406 * @buf: the buffer returned
3407 *
3408 * A sysfs 'read/write' sdev attribute, only works with SATA devices
3409 *
3410 * Returns: the number of characters written to @buf
3411 */
3412static ssize_t
3413sas_ncq_prio_enable_show(struct device *dev,
3414				 struct device_attribute *attr, char *buf)
3415{
3416	struct scsi_device *sdev = to_scsi_device(dev);
3417	struct mpi3mr_sdev_priv_data *sdev_priv_data =  sdev->hostdata;
3418
3419	if (!sdev_priv_data)
3420		return 0;
3421
3422	return sysfs_emit(buf, "%d\n", sdev_priv_data->ncq_prio_enable);
3423}
3424
3425static ssize_t
3426sas_ncq_prio_enable_store(struct device *dev,
3427				  struct device_attribute *attr,
3428				  const char *buf, size_t count)
3429{
3430	struct scsi_device *sdev = to_scsi_device(dev);
3431	struct mpi3mr_sdev_priv_data *sdev_priv_data =  sdev->hostdata;
3432	bool ncq_prio_enable = 0;
3433
3434	if (kstrtobool(buf, &ncq_prio_enable))
3435		return -EINVAL;
3436
3437	if (!sas_ata_ncq_prio_supported(sdev))
3438		return -EINVAL;
3439
3440	sdev_priv_data->ncq_prio_enable = ncq_prio_enable;
3441
3442	return strlen(buf);
3443}
3444static DEVICE_ATTR_RW(sas_ncq_prio_enable);
3445
3446static struct attribute *mpi3mr_dev_attrs[] = {
3447	&dev_attr_sas_address.attr,
3448	&dev_attr_device_handle.attr,
3449	&dev_attr_persistent_id.attr,
3450	&dev_attr_sas_ncq_prio_supported.attr,
3451	&dev_attr_sas_ncq_prio_enable.attr,
3452	NULL,
3453};
3454
3455static const struct attribute_group mpi3mr_dev_attr_group = {
3456	.attrs = mpi3mr_dev_attrs
3457};
3458
3459const struct attribute_group *mpi3mr_dev_groups[] = {
3460	&mpi3mr_dev_attr_group,
3461	NULL,
3462};