brintos / linux-shallow public Read only

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