1	/*
2	* Management Module Support for MPT (Message Passing Technology) based
3	* controllers
4	*
5	* This code is based on drivers/scsi/mpt3sas/mpt3sas_ctl.c
6	* Copyright (C) 2012-2014 LSI Corporation
7	* Copyright (C) 2013-2014 Avago Technologies
8	* (mailto: MPT-FusionLinux.pdl@avagotech.com)
9	*
10	* This program is free software; you can redistribute it and/or
11	* modify it under the terms of the GNU General Public License
12	* as published by the Free Software Foundation; either version 2
13	* of the License, or (at your option) any later version.
14	*
15	* This program is distributed in the hope that it will be useful,
16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18	* GNU General Public License for more details.
19	*
20	* NO WARRANTY
21	* THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
22	* CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
23	* LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
24	* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
25	* solely responsible for determining the appropriateness of using and
26	* distributing the Program and assumes all risks associated with its
27	* exercise of rights under this Agreement, including but not limited to
28	* the risks and costs of program errors, damage to or loss of data,
29	* programs or equipment, and unavailability or interruption of operations.
30
31	* DISCLAIMER OF LIABILITY
32	* NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
33	* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
34	* DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
35	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
36	* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
37	* USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
38	* HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
39
40	* You should have received a copy of the GNU General Public License
41	* along with this program; if not, write to the Free Software
42	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
43	* USA.
44	*/
45
46	#include <linux/kernel.h>
47	#include <linux/module.h>
48	#include <linux/errno.h>
49	#include <linux/init.h>
50	#include <linux/slab.h>
51	#include <linux/types.h>
52	#include <linux/pci.h>
53	#include <linux/delay.h>
54	#include <linux/compat.h>
55	#include <linux/poll.h>
56
57	#include <linux/io.h>
58	#include <linux/uaccess.h>
59
60	#include "mpt3sas_base.h"
61	#include "mpt3sas_ctl.h"
62
63
64	static struct fasync_struct *async_queue;
65	static DECLARE_WAIT_QUEUE_HEAD(ctl_poll_wait);
66
67
68	/**
69	* enum block_state - blocking state
70	* @NON_BLOCKING: non blocking
71	* @BLOCKING: blocking
72	*
73	* These states are for ioctls that need to wait for a response
74	* from firmware, so they probably require sleep.
75	*/
76	enum block_state {
77	NON_BLOCKING,
78	BLOCKING,
79	};
80
81	/**
82	* _ctl_display_some_debug - debug routine
83	* @ioc: per adapter object
84	* @smid: system request message index
85	* @calling_function_name: string pass from calling function
86	* @mpi_reply: reply message frame
87	* Context: none.
88	*
89	* Function for displaying debug info helpful when debugging issues
90	* in this module.
91	*/
92	static void
93	_ctl_display_some_debug(struct MPT3SAS_ADAPTER *ioc, u16 smid,
94	char *calling_function_name, MPI2DefaultReply_t *mpi_reply)
95	{
96	Mpi2ConfigRequest_t *mpi_request;
97	char *desc = NULL;
98
99	if (!(ioc->logging_level & MPT_DEBUG_IOCTL))
100	return;
101
102	mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
103	switch (mpi_request->Function) {
104	case MPI2_FUNCTION_SCSI_IO_REQUEST:
105	{
106	Mpi2SCSIIORequest_t *scsi_request =
107	(Mpi2SCSIIORequest_t *)mpi_request;
108
109	snprintf(buf: ioc->tmp_string, MPT_STRING_LENGTH,
110	fmt: "scsi_io, cmd(0x%02x), cdb_len(%d)",
111	scsi_request->CDB.CDB32[0],
112	le16_to_cpu(scsi_request->IoFlags) & 0xF);
113	desc = ioc->tmp_string;
114	break;
115	}
116	case MPI2_FUNCTION_SCSI_TASK_MGMT:
117	desc = "task_mgmt";
118	break;
119	case MPI2_FUNCTION_IOC_INIT:
120	desc = "ioc_init";
121	break;
122	case MPI2_FUNCTION_IOC_FACTS:
123	desc = "ioc_facts";
124	break;
125	case MPI2_FUNCTION_CONFIG:
126	{
127	Mpi2ConfigRequest_t *config_request =
128	(Mpi2ConfigRequest_t *)mpi_request;
129
130	snprintf(buf: ioc->tmp_string, MPT_STRING_LENGTH,
131	fmt: "config, type(0x%02x), ext_type(0x%02x), number(%d)",
132	(config_request->Header.PageType &
133	MPI2_CONFIG_PAGETYPE_MASK), config_request->ExtPageType,
134	config_request->Header.PageNumber);
135	desc = ioc->tmp_string;
136	break;
137	}
138	case MPI2_FUNCTION_PORT_FACTS:
139	desc = "port_facts";
140	break;
141	case MPI2_FUNCTION_PORT_ENABLE:
142	desc = "port_enable";
143	break;
144	case MPI2_FUNCTION_EVENT_NOTIFICATION:
145	desc = "event_notification";
146	break;
147	case MPI2_FUNCTION_FW_DOWNLOAD:
148	desc = "fw_download";
149	break;
150	case MPI2_FUNCTION_FW_UPLOAD:
151	desc = "fw_upload";
152	break;
153	case MPI2_FUNCTION_RAID_ACTION:
154	desc = "raid_action";
155	break;
156	case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
157	{
158	Mpi2SCSIIORequest_t *scsi_request =
159	(Mpi2SCSIIORequest_t *)mpi_request;
160
161	snprintf(buf: ioc->tmp_string, MPT_STRING_LENGTH,
162	fmt: "raid_pass, cmd(0x%02x), cdb_len(%d)",
163	scsi_request->CDB.CDB32[0],
164	le16_to_cpu(scsi_request->IoFlags) & 0xF);
165	desc = ioc->tmp_string;
166	break;
167	}
168	case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL:
169	desc = "sas_iounit_cntl";
170	break;
171	case MPI2_FUNCTION_SATA_PASSTHROUGH:
172	desc = "sata_pass";
173	break;
174	case MPI2_FUNCTION_DIAG_BUFFER_POST:
175	desc = "diag_buffer_post";
176	break;
177	case MPI2_FUNCTION_DIAG_RELEASE:
178	desc = "diag_release";
179	break;
180	case MPI2_FUNCTION_SMP_PASSTHROUGH:
181	desc = "smp_passthrough";
182	break;
183	case MPI2_FUNCTION_TOOLBOX:
184	desc = "toolbox";
185	break;
186	case MPI2_FUNCTION_NVME_ENCAPSULATED:
187	desc = "nvme_encapsulated";
188	break;
189	}
190
191	if (!desc)
192	return;
193
194	ioc_info(ioc, "%s: %s, smid(%d)\n", calling_function_name, desc, smid);
195
196	if (!mpi_reply)
197	return;
198
199	if (mpi_reply->IOCStatus || mpi_reply->IOCLogInfo)
200	ioc_info(ioc, "\tiocstatus(0x%04x), loginfo(0x%08x)\n",
201	le16_to_cpu(mpi_reply->IOCStatus),
202	le32_to_cpu(mpi_reply->IOCLogInfo));
203
204	if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
205	mpi_request->Function ==
206	MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) {
207	Mpi2SCSIIOReply_t *scsi_reply =
208	(Mpi2SCSIIOReply_t *)mpi_reply;
209	struct _sas_device *sas_device = NULL;
210	struct _pcie_device *pcie_device = NULL;
211
212	sas_device = mpt3sas_get_sdev_by_handle(ioc,
213	le16_to_cpu(scsi_reply->DevHandle));
214	if (sas_device) {
215	ioc_warn(ioc, "\tsas_address(0x%016llx), phy(%d)\n",
216	(u64)sas_device->sas_address,
217	sas_device->phy);
218	ioc_warn(ioc, "\tenclosure_logical_id(0x%016llx), slot(%d)\n",
219	(u64)sas_device->enclosure_logical_id,
220	sas_device->slot);
221	sas_device_put(s: sas_device);
222	}
223	if (!sas_device) {
224	pcie_device = mpt3sas_get_pdev_by_handle(ioc,
225	le16_to_cpu(scsi_reply->DevHandle));
226	if (pcie_device) {
227	ioc_warn(ioc, "\tWWID(0x%016llx), port(%d)\n",
228	(unsigned long long)pcie_device->wwid,
229	pcie_device->port_num);
230	if (pcie_device->enclosure_handle != 0)
231	ioc_warn(ioc, "\tenclosure_logical_id(0x%016llx), slot(%d)\n",
232	(u64)pcie_device->enclosure_logical_id,
233	pcie_device->slot);
234	pcie_device_put(p: pcie_device);
235	}
236	}
237	if (scsi_reply->SCSIState || scsi_reply->SCSIStatus)
238	ioc_info(ioc, "\tscsi_state(0x%02x), scsi_status(0x%02x)\n",
239	scsi_reply->SCSIState,
240	scsi_reply->SCSIStatus);
241	}
242	}
243
244	/**
245	* mpt3sas_ctl_done - ctl module completion routine
246	* @ioc: per adapter object
247	* @smid: system request message index
248	* @msix_index: MSIX table index supplied by the OS
249	* @reply: reply message frame(lower 32bit addr)
250	* Context: none.
251	*
252	* The callback handler when using ioc->ctl_cb_idx.
253	*
254	* Return: 1 meaning mf should be freed from _base_interrupt
255	* 0 means the mf is freed from this function.
256	*/
257	u8
258	mpt3sas_ctl_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
259	u32 reply)
260	{
261	MPI2DefaultReply_t *mpi_reply;
262	Mpi2SCSIIOReply_t *scsiio_reply;
263	Mpi26NVMeEncapsulatedErrorReply_t *nvme_error_reply;
264	const void *sense_data;
265	u32 sz;
266
267	if (ioc->ctl_cmds.status == MPT3_CMD_NOT_USED)
268	return 1;
269	if (ioc->ctl_cmds.smid != smid)
270	return 1;
271	ioc->ctl_cmds.status |= MPT3_CMD_COMPLETE;
272	mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, phys_addr: reply);
273	if (mpi_reply) {
274	memcpy(ioc->ctl_cmds.reply, mpi_reply, mpi_reply->MsgLength*4);
275	ioc->ctl_cmds.status |= MPT3_CMD_REPLY_VALID;
276	/* get sense data */
277	if (mpi_reply->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
278	mpi_reply->Function ==
279	MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) {
280	scsiio_reply = (Mpi2SCSIIOReply_t *)mpi_reply;
281	if (scsiio_reply->SCSIState &
282	MPI2_SCSI_STATE_AUTOSENSE_VALID) {
283	sz = min_t(u32, SCSI_SENSE_BUFFERSIZE,
284	le32_to_cpu(scsiio_reply->SenseCount));
285	sense_data = mpt3sas_base_get_sense_buffer(ioc,
286	smid);
287	memcpy(ioc->ctl_cmds.sense, sense_data, sz);
288	}
289	}
290	/*
291	* Get Error Response data for NVMe device. The ctl_cmds.sense
292	* buffer is used to store the Error Response data.
293	*/
294	if (mpi_reply->Function == MPI2_FUNCTION_NVME_ENCAPSULATED) {
295	nvme_error_reply =
296	(Mpi26NVMeEncapsulatedErrorReply_t *)mpi_reply;
297	sz = min_t(u32, NVME_ERROR_RESPONSE_SIZE,
298	le16_to_cpu(nvme_error_reply->ErrorResponseCount));
299	sense_data = mpt3sas_base_get_sense_buffer(ioc, smid);
300	memcpy(ioc->ctl_cmds.sense, sense_data, sz);
301	}
302	}
303
304	_ctl_display_some_debug(ioc, smid, calling_function_name: "ctl_done", mpi_reply);
305	ioc->ctl_cmds.status &= ~MPT3_CMD_PENDING;
306	complete(&ioc->ctl_cmds.done);
307	return 1;
308	}
309
310	/**
311	* _ctl_check_event_type - determines when an event needs logging
312	* @ioc: per adapter object
313	* @event: firmware event
314	*
315	* The bitmask in ioc->event_type[] indicates which events should be
316	* be saved in the driver event_log. This bitmask is set by application.
317	*
318	* Return: 1 when event should be captured, or zero means no match.
319	*/
320	static int
321	_ctl_check_event_type(struct MPT3SAS_ADAPTER *ioc, u16 event)
322	{
323	u16 i;
324	u32 desired_event;
325
326	if (event >= 128 || !event || !ioc->event_log)
327	return 0;
328
329	desired_event = (1 << (event % 32));
330	if (!desired_event)
331	desired_event = 1;
332	i = event / 32;
333	return desired_event & ioc->event_type[i];
334	}
335
336	/**
337	* mpt3sas_ctl_add_to_event_log - add event
338	* @ioc: per adapter object
339	* @mpi_reply: reply message frame
340	*/
341	void
342	mpt3sas_ctl_add_to_event_log(struct MPT3SAS_ADAPTER *ioc,
343	Mpi2EventNotificationReply_t *mpi_reply)
344	{
345	struct MPT3_IOCTL_EVENTS *event_log;
346	u16 event;
347	int i;
348	u32 sz, event_data_sz;
349	u8 send_aen = 0;
350
351	if (!ioc->event_log)
352	return;
353
354	event = le16_to_cpu(mpi_reply->Event);
355
356	if (_ctl_check_event_type(ioc, event)) {
357
358	/* insert entry into circular event_log */
359	i = ioc->event_context % MPT3SAS_CTL_EVENT_LOG_SIZE;
360	event_log = ioc->event_log;
361	event_log[i].event = event;
362	event_log[i].context = ioc->event_context++;
363
364	event_data_sz = le16_to_cpu(mpi_reply->EventDataLength)*4;
365	sz = min_t(u32, event_data_sz, MPT3_EVENT_DATA_SIZE);
366	memset(event_log[i].data, 0, MPT3_EVENT_DATA_SIZE);
367	memcpy(event_log[i].data, mpi_reply->EventData, sz);
368	send_aen = 1;
369	}
370
371	/* This aen_event_read_flag flag is set until the
372	* application has read the event log.
373	* For MPI2_EVENT_LOG_ENTRY_ADDED, we always notify.
374	*/
375	if (event == MPI2_EVENT_LOG_ENTRY_ADDED ||
376	(send_aen && !ioc->aen_event_read_flag)) {
377	ioc->aen_event_read_flag = 1;
378	wake_up_interruptible(&ctl_poll_wait);
379	if (async_queue)
380	kill_fasync(&async_queue, SIGIO, POLL_IN);
381	}
382	}
383
384	/**
385	* mpt3sas_ctl_event_callback - firmware event handler (called at ISR time)
386	* @ioc: per adapter object
387	* @msix_index: MSIX table index supplied by the OS
388	* @reply: reply message frame(lower 32bit addr)
389	* Context: interrupt.
390	*
391	* This function merely adds a new work task into ioc->firmware_event_thread.
392	* The tasks are worked from _firmware_event_work in user context.
393	*
394	* Return: 1 meaning mf should be freed from _base_interrupt
395	* 0 means the mf is freed from this function.
396	*/
397	u8
398	mpt3sas_ctl_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index,
399	u32 reply)
400	{
401	Mpi2EventNotificationReply_t *mpi_reply;
402
403	mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, phys_addr: reply);
404	if (mpi_reply)
405	mpt3sas_ctl_add_to_event_log(ioc, mpi_reply);
406	return 1;
407	}
408
409	/**
410	* _ctl_verify_adapter - validates ioc_number passed from application
411	* @ioc_number: ?
412	* @iocpp: The ioc pointer is returned in this.
413	* @mpi_version: will be MPI2_VERSION for mpt2ctl ioctl device &
414	* MPI25_VERSION | MPI26_VERSION for mpt3ctl ioctl device.
415	*
416	* Return: (-1) means error, else ioc_number.
417	*/
418	static int
419	_ctl_verify_adapter(int ioc_number, struct MPT3SAS_ADAPTER **iocpp,
420	int mpi_version)
421	{
422	struct MPT3SAS_ADAPTER *ioc;
423	int version = 0;
424	/* global ioc lock to protect controller on list operations */
425	spin_lock(lock: &gioc_lock);
426	list_for_each_entry(ioc, &mpt3sas_ioc_list, list) {
427	if (ioc->id != ioc_number)
428	continue;
429	/* Check whether this ioctl command is from right
430	* ioctl device or not, if not continue the search.
431	*/
432	version = ioc->hba_mpi_version_belonged;
433	/* MPI25_VERSION and MPI26_VERSION uses same ioctl
434	* device.
435	*/
436	if (mpi_version == (MPI25_VERSION | MPI26_VERSION)) {
437	if ((version == MPI25_VERSION) ||
438	(version == MPI26_VERSION))
439	goto out;
440	else
441	continue;
442	} else {
443	if (version != mpi_version)
444	continue;
445	}
446	out:
447	spin_unlock(lock: &gioc_lock);
448	*iocpp = ioc;
449	return ioc_number;
450	}
451	spin_unlock(lock: &gioc_lock);
452	*iocpp = NULL;
453	return -1;
454	}
455
456	/**
457	* mpt3sas_ctl_pre_reset_handler - reset callback handler (for ctl)
458	* @ioc: per adapter object
459	*
460	* The handler for doing any required cleanup or initialization.
461	*/
462	void mpt3sas_ctl_pre_reset_handler(struct MPT3SAS_ADAPTER *ioc)
463	{
464	int i;
465	u8 issue_reset;
466
467	dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_PRE_RESET\n", __func__));
468	for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
469	if (!(ioc->diag_buffer_status[i] &
470	MPT3_DIAG_BUFFER_IS_REGISTERED))
471	continue;
472	if ((ioc->diag_buffer_status[i] &
473	MPT3_DIAG_BUFFER_IS_RELEASED))
474	continue;
475
476	/*
477	* add a log message to indicate the release
478	*/
479	ioc_info(ioc,
480	"%s: Releasing the trace buffer due to adapter reset.",
481	__func__);
482	ioc->htb_rel.buffer_rel_condition =
483	MPT3_DIAG_BUFFER_REL_TRIGGER;
484	mpt3sas_send_diag_release(ioc, buffer_type: i, issue_reset: &issue_reset);
485	}
486	}
487
488	/**
489	* mpt3sas_ctl_clear_outstanding_ioctls - clears outstanding ioctl cmd.
490	* @ioc: per adapter object
491	*
492	* The handler for doing any required cleanup or initialization.
493	*/
494	void mpt3sas_ctl_clear_outstanding_ioctls(struct MPT3SAS_ADAPTER *ioc)
495	{
496	dtmprintk(ioc,
497	ioc_info(ioc, "%s: clear outstanding ioctl cmd\n", __func__));
498	if (ioc->ctl_cmds.status & MPT3_CMD_PENDING) {
499	ioc->ctl_cmds.status |= MPT3_CMD_RESET;
500	mpt3sas_base_free_smid(ioc, smid: ioc->ctl_cmds.smid);
501	complete(&ioc->ctl_cmds.done);
502	}
503	}
504
505	/**
506	* mpt3sas_ctl_reset_done_handler - reset callback handler (for ctl)
507	* @ioc: per adapter object
508	*
509	* The handler for doing any required cleanup or initialization.
510	*/
511	void mpt3sas_ctl_reset_done_handler(struct MPT3SAS_ADAPTER *ioc)
512	{
513	int i;
514
515	dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_DONE_RESET\n", __func__));
516
517	for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
518	if (!(ioc->diag_buffer_status[i] &
519	MPT3_DIAG_BUFFER_IS_REGISTERED))
520	continue;
521	if ((ioc->diag_buffer_status[i] &
522	MPT3_DIAG_BUFFER_IS_RELEASED))
523	continue;
524	ioc->diag_buffer_status[i] |=
525	MPT3_DIAG_BUFFER_IS_DIAG_RESET;
526	}
527	}
528
529	/**
530	* _ctl_fasync -
531	* @fd: ?
532	* @filep: ?
533	* @mode: ?
534	*
535	* Called when application request fasyn callback handler.
536	*/
537	static int
538	_ctl_fasync(int fd, struct file *filep, int mode)
539	{
540	return fasync_helper(fd, filep, mode, &async_queue);
541	}
542
543	/**
544	* _ctl_poll -
545	* @filep: ?
546	* @wait: ?
547	*
548	*/
549	static __poll_t
550	_ctl_poll(struct file *filep, poll_table *wait)
551	{
552	struct MPT3SAS_ADAPTER *ioc;
553
554	poll_wait(filp: filep, wait_address: &ctl_poll_wait, p: wait);
555
556	/* global ioc lock to protect controller on list operations */
557	spin_lock(lock: &gioc_lock);
558	list_for_each_entry(ioc, &mpt3sas_ioc_list, list) {
559	if (ioc->aen_event_read_flag) {
560	spin_unlock(lock: &gioc_lock);
561	return EPOLLIN | EPOLLRDNORM;
562	}
563	}
564	spin_unlock(lock: &gioc_lock);
565	return 0;
566	}
567
568	/**
569	* _ctl_set_task_mid - assign an active smid to tm request
570	* @ioc: per adapter object
571	* @karg: (struct mpt3_ioctl_command)
572	* @tm_request: pointer to mf from user space
573	*
574	* Return: 0 when an smid if found, else fail.
575	* during failure, the reply frame is filled.
576	*/
577	static int
578	_ctl_set_task_mid(struct MPT3SAS_ADAPTER *ioc, struct mpt3_ioctl_command *karg,
579	Mpi2SCSITaskManagementRequest_t *tm_request)
580	{
581	bool found = false;
582	u16 smid;
583	u16 handle;
584	struct scsi_cmnd *scmd;
585	struct MPT3SAS_DEVICE *priv_data;
586	Mpi2SCSITaskManagementReply_t *tm_reply;
587	u32 sz;
588	u32 lun;
589	char *desc = NULL;
590
591	if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK)
592	desc = "abort_task";
593	else if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK)
594	desc = "query_task";
595	else
596	return 0;
597
598	lun = scsilun_to_int((struct scsi_lun *)tm_request->LUN);
599
600	handle = le16_to_cpu(tm_request->DevHandle);
601	for (smid = ioc->scsiio_depth; smid && !found; smid--) {
602	struct scsiio_tracker *st;
603	__le16 task_mid;
604
605	scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);
606	if (!scmd)
607	continue;
608	if (lun != scmd->device->lun)
609	continue;
610	priv_data = scmd->device->hostdata;
611	if (priv_data->sas_target == NULL)
612	continue;
613	if (priv_data->sas_target->handle != handle)
614	continue;
615	st = scsi_cmd_priv(cmd: scmd);
616
617	/*
618	* If the given TaskMID from the user space is zero, then the
619	* first outstanding smid will be picked up. Otherwise,
620	* targeted smid will be the one.
621	*/
622	task_mid = cpu_to_le16(st->smid);
623	if (!tm_request->TaskMID)
624	tm_request->TaskMID = task_mid;
625	found = tm_request->TaskMID == task_mid;
626	}
627
628	if (!found) {
629	dctlprintk(ioc,
630	ioc_info(ioc, "%s: handle(0x%04x), lun(%d), no active mid!!\n",
631	desc, le16_to_cpu(tm_request->DevHandle),
632	lun));
633	tm_reply = ioc->ctl_cmds.reply;
634	tm_reply->DevHandle = tm_request->DevHandle;
635	tm_reply->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
636	tm_reply->TaskType = tm_request->TaskType;
637	tm_reply->MsgLength = sizeof(Mpi2SCSITaskManagementReply_t)/4;
638	tm_reply->VP_ID = tm_request->VP_ID;
639	tm_reply->VF_ID = tm_request->VF_ID;
640	sz = min_t(u32, karg->max_reply_bytes, ioc->reply_sz);
641	if (copy_to_user(to: karg->reply_frame_buf_ptr, from: ioc->ctl_cmds.reply,
642	n: sz))
643	pr_err("failure at %s:%d/%s()!\n", __FILE__,
644	__LINE__, __func__);
645	return 1;
646	}
647
648	dctlprintk(ioc,
649	ioc_info(ioc, "%s: handle(0x%04x), lun(%d), task_mid(%d)\n",
650	desc, le16_to_cpu(tm_request->DevHandle), lun,
651	le16_to_cpu(tm_request->TaskMID)));
652	return 0;
653	}
654
655	/**
656	* _ctl_do_mpt_command - main handler for MPT3COMMAND opcode
657	* @ioc: per adapter object
658	* @karg: (struct mpt3_ioctl_command)
659	* @mf: pointer to mf in user space
660	*/
661	static long
662	_ctl_do_mpt_command(struct MPT3SAS_ADAPTER *ioc, struct mpt3_ioctl_command karg,
663	void __user *mf)
664	{
665	MPI2RequestHeader_t *mpi_request = NULL, *request;
666	MPI2DefaultReply_t *mpi_reply;
667	Mpi26NVMeEncapsulatedRequest_t *nvme_encap_request = NULL;
668	struct _pcie_device *pcie_device = NULL;
669	u16 smid;
670	unsigned long timeout;
671	u8 issue_reset;
672	u32 sz, sz_arg;
673	void *psge;
674	void *data_out = NULL;
675	dma_addr_t data_out_dma = 0;
676	size_t data_out_sz = 0;
677	void *data_in = NULL;
678	dma_addr_t data_in_dma = 0;
679	size_t data_in_sz = 0;
680	long ret;
681	u16 device_handle = MPT3SAS_INVALID_DEVICE_HANDLE;
682
683	issue_reset = 0;
684
685	if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) {
686	ioc_err(ioc, "%s: ctl_cmd in use\n", __func__);
687	ret = -EAGAIN;
688	goto out;
689	}
690
691	ret = mpt3sas_wait_for_ioc(ioc, IOC_OPERATIONAL_WAIT_COUNT);
692	if (ret)
693	goto out;
694
695	mpi_request = kzalloc(size: ioc->request_sz, GFP_KERNEL);
696	if (!mpi_request) {
697	ioc_err(ioc, "%s: failed obtaining a memory for mpi_request\n",
698	__func__);
699	ret = -ENOMEM;
700	goto out;
701	}
702
703	/* Check for overflow and wraparound */
704	if (karg.data_sge_offset * 4 > ioc->request_sz ||
705	karg.data_sge_offset > (UINT_MAX / 4)) {
706	ret = -EINVAL;
707	goto out;
708	}
709
710	/* copy in request message frame from user */
711	if (copy_from_user(to: mpi_request, from: mf, n: karg.data_sge_offset*4)) {
712	pr_err("failure at %s:%d/%s()!\n", __FILE__, __LINE__,
713	__func__);
714	ret = -EFAULT;
715	goto out;
716	}
717
718	if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) {
719	smid = mpt3sas_base_get_smid_hpr(ioc, cb_idx: ioc->ctl_cb_idx);
720	if (!smid) {
721	ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
722	ret = -EAGAIN;
723	goto out;
724	}
725	} else {
726	/* Use first reserved smid for passthrough ioctls */
727	smid = ioc->scsiio_depth - INTERNAL_SCSIIO_CMDS_COUNT + 1;
728	}
729
730	ret = 0;
731	ioc->ctl_cmds.status = MPT3_CMD_PENDING;
732	memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
733	request = mpt3sas_base_get_msg_frame(ioc, smid);
734	memset(request, 0, ioc->request_sz);
735	memcpy(request, mpi_request, karg.data_sge_offset*4);
736	ioc->ctl_cmds.smid = smid;
737	data_out_sz = karg.data_out_size;
738	data_in_sz = karg.data_in_size;
739
740	if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
741	mpi_request->Function == MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH ||
742	mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT ||
743	mpi_request->Function == MPI2_FUNCTION_SATA_PASSTHROUGH ||
744	mpi_request->Function == MPI2_FUNCTION_NVME_ENCAPSULATED) {
745
746	device_handle = le16_to_cpu(mpi_request->FunctionDependent1);
747	if (!device_handle || (device_handle >
748	ioc->facts.MaxDevHandle)) {
749	ret = -EINVAL;
750	mpt3sas_base_free_smid(ioc, smid);
751	goto out;
752	}
753	}
754
755	/* obtain dma-able memory for data transfer */
756	if (data_out_sz) /* WRITE */ {
757	data_out = dma_alloc_coherent(dev: &ioc->pdev->dev, size: data_out_sz,
758	dma_handle: &data_out_dma, GFP_KERNEL);
759	if (!data_out) {
760	pr_err("failure at %s:%d/%s()!\n", __FILE__,
761	__LINE__, __func__);
762	ret = -ENOMEM;
763	mpt3sas_base_free_smid(ioc, smid);
764	goto out;
765	}
766	if (copy_from_user(to: data_out, from: karg.data_out_buf_ptr,
767	n: data_out_sz)) {
768	pr_err("failure at %s:%d/%s()!\n", __FILE__,
769	__LINE__, __func__);
770	ret = -EFAULT;
771	mpt3sas_base_free_smid(ioc, smid);
772	goto out;
773	}
774	}
775
776	if (data_in_sz) /* READ */ {
777	data_in = dma_alloc_coherent(dev: &ioc->pdev->dev, size: data_in_sz,
778	dma_handle: &data_in_dma, GFP_KERNEL);
779	if (!data_in) {
780	pr_err("failure at %s:%d/%s()!\n", __FILE__,
781	__LINE__, __func__);
782	ret = -ENOMEM;
783	mpt3sas_base_free_smid(ioc, smid);
784	goto out;
785	}
786	}
787
788	psge = (void *)request + (karg.data_sge_offset*4);
789
790	/* send command to firmware */
791	_ctl_display_some_debug(ioc, smid, calling_function_name: "ctl_request", NULL);
792
793	init_completion(x: &ioc->ctl_cmds.done);
794	switch (mpi_request->Function) {
795	case MPI2_FUNCTION_NVME_ENCAPSULATED:
796	{
797	nvme_encap_request = (Mpi26NVMeEncapsulatedRequest_t *)request;
798	if (!ioc->pcie_sg_lookup) {
799	dtmprintk(ioc, ioc_info(ioc,
800	"HBA doesn't support NVMe. Rejecting NVMe Encapsulated request.\n"
801	));
802
803	if (ioc->logging_level & MPT_DEBUG_TM)
804	_debug_dump_mf(mpi_request: nvme_encap_request,
805	sz: ioc->request_sz/4);
806	mpt3sas_base_free_smid(ioc, smid);
807	ret = -EINVAL;
808	goto out;
809	}
810	/*
811	* Get the Physical Address of the sense buffer.
812	* Use Error Response buffer address field to hold the sense
813	* buffer address.
814	* Clear the internal sense buffer, which will potentially hold
815	* the Completion Queue Entry on return, or 0 if no Entry.
816	* Build the PRPs and set direction bits.
817	* Send the request.
818	*/
819	nvme_encap_request->ErrorResponseBaseAddress =
820	cpu_to_le64(ioc->sense_dma & 0xFFFFFFFF00000000UL);
821	nvme_encap_request->ErrorResponseBaseAddress |=
822	cpu_to_le64(le32_to_cpu(
823	mpt3sas_base_get_sense_buffer_dma(ioc, smid)));
824	nvme_encap_request->ErrorResponseAllocationLength =
825	cpu_to_le16(NVME_ERROR_RESPONSE_SIZE);
826	memset(ioc->ctl_cmds.sense, 0, NVME_ERROR_RESPONSE_SIZE);
827	ioc->build_nvme_prp(ioc, smid, nvme_encap_request,
828	data_out_dma, data_out_sz, data_in_dma, data_in_sz);
829	if (test_bit(device_handle, ioc->device_remove_in_progress)) {
830	dtmprintk(ioc,
831	ioc_info(ioc, "handle(0x%04x): ioctl failed due to device removal in progress\n",
832	device_handle));
833	mpt3sas_base_free_smid(ioc, smid);
834	ret = -EINVAL;
835	goto out;
836	}
837	mpt3sas_base_put_smid_nvme_encap(ioc, smid);
838	break;
839	}
840	case MPI2_FUNCTION_SCSI_IO_REQUEST:
841	case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
842	{
843	Mpi2SCSIIORequest_t *scsiio_request =
844	(Mpi2SCSIIORequest_t *)request;
845	scsiio_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
846	scsiio_request->SenseBufferLowAddress =
847	mpt3sas_base_get_sense_buffer_dma(ioc, smid);
848	memset(ioc->ctl_cmds.sense, 0, SCSI_SENSE_BUFFERSIZE);
849	if (test_bit(device_handle, ioc->device_remove_in_progress)) {
850	dtmprintk(ioc,
851	ioc_info(ioc, "handle(0x%04x) :ioctl failed due to device removal in progress\n",
852	device_handle));
853	mpt3sas_base_free_smid(ioc, smid);
854	ret = -EINVAL;
855	goto out;
856	}
857	ioc->build_sg(ioc, psge, data_out_dma, data_out_sz,
858	data_in_dma, data_in_sz);
859	if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST)
860	ioc->put_smid_scsi_io(ioc, smid, device_handle);
861	else
862	ioc->put_smid_default(ioc, smid);
863	break;
864	}
865	case MPI2_FUNCTION_SCSI_TASK_MGMT:
866	{
867	Mpi2SCSITaskManagementRequest_t *tm_request =
868	(Mpi2SCSITaskManagementRequest_t *)request;
869
870	dtmprintk(ioc,
871	ioc_info(ioc, "TASK_MGMT: handle(0x%04x), task_type(0x%02x)\n",
872	le16_to_cpu(tm_request->DevHandle),
873	tm_request->TaskType));
874	ioc->got_task_abort_from_ioctl = 1;
875	if (tm_request->TaskType ==
876	MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK ||
877	tm_request->TaskType ==
878	MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK) {
879	if (_ctl_set_task_mid(ioc, karg: &karg, tm_request)) {
880	mpt3sas_base_free_smid(ioc, smid);
881	ioc->got_task_abort_from_ioctl = 0;
882	goto out;
883	}
884	}
885	ioc->got_task_abort_from_ioctl = 0;
886
887	if (test_bit(device_handle, ioc->device_remove_in_progress)) {
888	dtmprintk(ioc,
889	ioc_info(ioc, "handle(0x%04x) :ioctl failed due to device removal in progress\n",
890	device_handle));
891	mpt3sas_base_free_smid(ioc, smid);
892	ret = -EINVAL;
893	goto out;
894	}
895	mpt3sas_scsih_set_tm_flag(ioc, le16_to_cpu(
896	tm_request->DevHandle));
897	ioc->build_sg_mpi(ioc, psge, data_out_dma, data_out_sz,
898	data_in_dma, data_in_sz);
899	ioc->put_smid_hi_priority(ioc, smid, 0);
900	break;
901	}
902	case MPI2_FUNCTION_SMP_PASSTHROUGH:
903	{
904	Mpi2SmpPassthroughRequest_t *smp_request =
905	(Mpi2SmpPassthroughRequest_t *)mpi_request;
906	u8 *data;
907
908	if (!ioc->multipath_on_hba) {
909	/* ioc determines which port to use */
910	smp_request->PhysicalPort = 0xFF;
911	}
912	if (smp_request->PassthroughFlags &
913	MPI2_SMP_PT_REQ_PT_FLAGS_IMMEDIATE)
914	data = (u8 *)&smp_request->SGL;
915	else {
916	if (unlikely(data_out == NULL)) {
917	pr_err("failure at %s:%d/%s()!\n",
918	__FILE__, __LINE__, __func__);
919	mpt3sas_base_free_smid(ioc, smid);
920	ret = -EINVAL;
921	goto out;
922	}
923	data = data_out;
924	}
925
926	if (data[1] == 0x91 && (data[10] == 1 || data[10] == 2)) {
927	ioc->ioc_link_reset_in_progress = 1;
928	ioc->ignore_loginfos = 1;
929	}
930	ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma,
931	data_in_sz);
932	ioc->put_smid_default(ioc, smid);
933	break;
934	}
935	case MPI2_FUNCTION_SATA_PASSTHROUGH:
936	{
937	if (test_bit(device_handle, ioc->device_remove_in_progress)) {
938	dtmprintk(ioc,
939	ioc_info(ioc, "handle(0x%04x) :ioctl failed due to device removal in progress\n",
940	device_handle));
941	mpt3sas_base_free_smid(ioc, smid);
942	ret = -EINVAL;
943	goto out;
944	}
945	ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma,
946	data_in_sz);
947	ioc->put_smid_default(ioc, smid);
948	break;
949	}
950	case MPI2_FUNCTION_FW_DOWNLOAD:
951	{
952	if (ioc->pdev->vendor == MPI2_MFGPAGE_VENDORID_ATTO) {
953	ioc_info(ioc, "Firmware download not supported for ATTO HBA.\n");
954	ret = -EPERM;
955	break;
956	}
957	fallthrough;
958	}
959	case MPI2_FUNCTION_FW_UPLOAD:
960	{
961	ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma,
962	data_in_sz);
963	ioc->put_smid_default(ioc, smid);
964	break;
965	}
966	case MPI2_FUNCTION_TOOLBOX:
967	{
968	Mpi2ToolboxCleanRequest_t *toolbox_request =
969	(Mpi2ToolboxCleanRequest_t *)mpi_request;
970
971	if ((toolbox_request->Tool == MPI2_TOOLBOX_DIAGNOSTIC_CLI_TOOL)
972	|| (toolbox_request->Tool ==
973	MPI26_TOOLBOX_BACKEND_PCIE_LANE_MARGIN))
974	ioc->build_sg(ioc, psge, data_out_dma, data_out_sz,
975	data_in_dma, data_in_sz);
976	else if (toolbox_request->Tool ==
977	MPI2_TOOLBOX_MEMORY_MOVE_TOOL) {
978	Mpi2ToolboxMemMoveRequest_t *mem_move_request =
979	(Mpi2ToolboxMemMoveRequest_t *)request;
980	Mpi2SGESimple64_t tmp, *src = NULL, *dst = NULL;
981
982	ioc->build_sg_mpi(ioc, psge, data_out_dma,
983	data_out_sz, data_in_dma, data_in_sz);
984	if (data_out_sz && !data_in_sz) {
985	dst =
986	(Mpi2SGESimple64_t *)&mem_move_request->SGL;
987	src = (void *)dst + ioc->sge_size;
988
989	memcpy(&tmp, src, ioc->sge_size);
990	memcpy(src, dst, ioc->sge_size);
991	memcpy(dst, &tmp, ioc->sge_size);
992	}
993	if (ioc->logging_level & MPT_DEBUG_TM) {
994	ioc_info(ioc,
995	"Mpi2ToolboxMemMoveRequest_t request msg\n");
996	_debug_dump_mf(mpi_request: mem_move_request,
997	sz: ioc->request_sz/4);
998	}
999	} else
1000	ioc->build_sg_mpi(ioc, psge, data_out_dma, data_out_sz,
1001	data_in_dma, data_in_sz);
1002	ioc->put_smid_default(ioc, smid);
1003	break;
1004	}
1005	case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL:
1006	{
1007	Mpi2SasIoUnitControlRequest_t *sasiounit_request =
1008	(Mpi2SasIoUnitControlRequest_t *)mpi_request;
1009
1010	if (sasiounit_request->Operation == MPI2_SAS_OP_PHY_HARD_RESET
1011	|| sasiounit_request->Operation ==
1012	MPI2_SAS_OP_PHY_LINK_RESET) {
1013	ioc->ioc_link_reset_in_progress = 1;
1014	ioc->ignore_loginfos = 1;
1015	}
1016	/* drop to default case for posting the request */
1017	}
1018	fallthrough;
1019	default:
1020	ioc->build_sg_mpi(ioc, psge, data_out_dma, data_out_sz,
1021	data_in_dma, data_in_sz);
1022	ioc->put_smid_default(ioc, smid);
1023	break;
1024	}
1025
1026	if (karg.timeout < MPT3_IOCTL_DEFAULT_TIMEOUT)
1027	timeout = MPT3_IOCTL_DEFAULT_TIMEOUT;
1028	else
1029	timeout = karg.timeout;
1030	wait_for_completion_timeout(x: &ioc->ctl_cmds.done, timeout: timeout*HZ);
1031	if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) {
1032	Mpi2SCSITaskManagementRequest_t *tm_request =
1033	(Mpi2SCSITaskManagementRequest_t *)mpi_request;
1034	mpt3sas_scsih_clear_tm_flag(ioc, le16_to_cpu(
1035	tm_request->DevHandle));
1036	mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
1037	} else if ((mpi_request->Function == MPI2_FUNCTION_SMP_PASSTHROUGH ||
1038	mpi_request->Function == MPI2_FUNCTION_SAS_IO_UNIT_CONTROL) &&
1039	ioc->ioc_link_reset_in_progress) {
1040	ioc->ioc_link_reset_in_progress = 0;
1041	ioc->ignore_loginfos = 0;
1042	}
1043	if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) {
1044	mpt3sas_check_cmd_timeout(ioc,
1045	ioc->ctl_cmds.status, mpi_request,
1046	karg.data_sge_offset, issue_reset);
1047	goto issue_host_reset;
1048	}
1049
1050	mpi_reply = ioc->ctl_cmds.reply;
1051
1052	if (mpi_reply->Function == MPI2_FUNCTION_SCSI_TASK_MGMT &&
1053	(ioc->logging_level & MPT_DEBUG_TM)) {
1054	Mpi2SCSITaskManagementReply_t *tm_reply =
1055	(Mpi2SCSITaskManagementReply_t *)mpi_reply;
1056
1057	ioc_info(ioc, "TASK_MGMT: IOCStatus(0x%04x), IOCLogInfo(0x%08x), TerminationCount(0x%08x)\n",
1058	le16_to_cpu(tm_reply->IOCStatus),
1059	le32_to_cpu(tm_reply->IOCLogInfo),
1060	le32_to_cpu(tm_reply->TerminationCount));
1061	}
1062
1063	/* copy out xdata to user */
1064	if (data_in_sz) {
1065	if (copy_to_user(to: karg.data_in_buf_ptr, from: data_in,
1066	n: data_in_sz)) {
1067	pr_err("failure at %s:%d/%s()!\n", __FILE__,
1068	__LINE__, __func__);
1069	ret = -ENODATA;
1070	goto out;
1071	}
1072	}
1073
1074	/* copy out reply message frame to user */
1075	if (karg.max_reply_bytes) {
1076	sz = min_t(u32, karg.max_reply_bytes, ioc->reply_sz);
1077	if (copy_to_user(to: karg.reply_frame_buf_ptr, from: ioc->ctl_cmds.reply,
1078	n: sz)) {
1079	pr_err("failure at %s:%d/%s()!\n", __FILE__,
1080	__LINE__, __func__);
1081	ret = -ENODATA;
1082	goto out;
1083	}
1084	}
1085
1086	/* copy out sense/NVMe Error Response to user */
1087	if (karg.max_sense_bytes && (mpi_request->Function ==
1088	MPI2_FUNCTION_SCSI_IO_REQUEST || mpi_request->Function ==
1089	MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH || mpi_request->Function ==
1090	MPI2_FUNCTION_NVME_ENCAPSULATED)) {
1091	if (karg.sense_data_ptr == NULL) {
1092	ioc_info(ioc, "Response buffer provided by application is NULL; Response data will not be returned\n");
1093	goto out;
1094	}
1095	sz_arg = (mpi_request->Function ==
1096	MPI2_FUNCTION_NVME_ENCAPSULATED) ? NVME_ERROR_RESPONSE_SIZE :
1097	SCSI_SENSE_BUFFERSIZE;
1098	sz = min_t(u32, karg.max_sense_bytes, sz_arg);
1099	if (copy_to_user(to: karg.sense_data_ptr, from: ioc->ctl_cmds.sense,
1100	n: sz)) {
1101	pr_err("failure at %s:%d/%s()!\n", __FILE__,
1102	__LINE__, __func__);
1103	ret = -ENODATA;
1104	goto out;
1105	}
1106	}
1107
1108	issue_host_reset:
1109	if (issue_reset) {
1110	ret = -ENODATA;
1111	if ((mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
1112	mpi_request->Function ==
1113	MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH ||
1114	mpi_request->Function == MPI2_FUNCTION_SATA_PASSTHROUGH)) {
1115	ioc_info(ioc, "issue target reset: handle = (0x%04x)\n",
1116	le16_to_cpu(mpi_request->FunctionDependent1));
1117	mpt3sas_halt_firmware(ioc);
1118	pcie_device = mpt3sas_get_pdev_by_handle(ioc,
1119	le16_to_cpu(mpi_request->FunctionDependent1));
1120	if (pcie_device && (!ioc->tm_custom_handling) &&
1121	(!(mpt3sas_scsih_is_pcie_scsi_device(
1122	device_info: pcie_device->device_info))))
1123	mpt3sas_scsih_issue_locked_tm(ioc,
1124	le16_to_cpu(mpi_request->FunctionDependent1),
1125	channel: 0, id: 0, lun: 0,
1126	MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, smid_task: 0,
1127	msix_task: 0, timeout: pcie_device->reset_timeout,
1128	MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE);
1129	else
1130	mpt3sas_scsih_issue_locked_tm(ioc,
1131	le16_to_cpu(mpi_request->FunctionDependent1),
1132	channel: 0, id: 0, lun: 0,
1133	MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, smid_task: 0,
1134	msix_task: 0, timeout: 30, MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET);
1135	} else
1136	mpt3sas_base_hard_reset_handler(ioc, type: FORCE_BIG_HAMMER);
1137	}
1138
1139	out:
1140	if (pcie_device)
1141	pcie_device_put(p: pcie_device);
1142
1143	/* free memory associated with sg buffers */
1144	if (data_in)
1145	dma_free_coherent(dev: &ioc->pdev->dev, size: data_in_sz, cpu_addr: data_in,
1146	dma_handle: data_in_dma);
1147
1148	if (data_out)
1149	dma_free_coherent(dev: &ioc->pdev->dev, size: data_out_sz, cpu_addr: data_out,
1150	dma_handle: data_out_dma);
1151
1152	kfree(objp: mpi_request);
1153	ioc->ctl_cmds.status = MPT3_CMD_NOT_USED;
1154	return ret;
1155	}
1156
1157	/**
1158	* _ctl_getiocinfo - main handler for MPT3IOCINFO opcode
1159	* @ioc: per adapter object
1160	* @arg: user space buffer containing ioctl content
1161	*/
1162	static long
1163	_ctl_getiocinfo(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1164	{
1165	struct mpt3_ioctl_iocinfo karg;
1166
1167	dctlprintk(ioc, ioc_info(ioc, "%s: enter\n",
1168	__func__));
1169
1170	memset(&karg, 0 , sizeof(karg));
1171	if (ioc->pfacts)
1172	karg.port_number = ioc->pfacts[0].PortNumber;
1173	karg.hw_rev = ioc->pdev->revision;
1174	karg.pci_id = ioc->pdev->device;
1175	karg.subsystem_device = ioc->pdev->subsystem_device;
1176	karg.subsystem_vendor = ioc->pdev->subsystem_vendor;
1177	karg.pci_information.u.bits.bus = ioc->pdev->bus->number;
1178	karg.pci_information.u.bits.device = PCI_SLOT(ioc->pdev->devfn);
1179	karg.pci_information.u.bits.function = PCI_FUNC(ioc->pdev->devfn);
1180	karg.pci_information.segment_id = pci_domain_nr(bus: ioc->pdev->bus);
1181	karg.firmware_version = ioc->facts.FWVersion.Word;
1182	strcpy(p: karg.driver_version, q: ioc->driver_name);
1183	strcat(p: karg.driver_version, q: "-");
1184	switch (ioc->hba_mpi_version_belonged) {
1185	case MPI2_VERSION:
1186	if (ioc->is_warpdrive)
1187	karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2_SSS6200;
1188	else
1189	karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2;
1190	strcat(p: karg.driver_version, MPT2SAS_DRIVER_VERSION);
1191	break;
1192	case MPI25_VERSION:
1193	case MPI26_VERSION:
1194	if (ioc->is_gen35_ioc)
1195	karg.adapter_type = MPT3_IOCTL_INTERFACE_SAS35;
1196	else
1197	karg.adapter_type = MPT3_IOCTL_INTERFACE_SAS3;
1198	strcat(p: karg.driver_version, MPT3SAS_DRIVER_VERSION);
1199	break;
1200	}
1201	karg.bios_version = le32_to_cpu(ioc->bios_pg3.BiosVersion);
1202
1203	if (copy_to_user(to: arg, from: &karg, n: sizeof(karg))) {
1204	pr_err("failure at %s:%d/%s()!\n",
1205	__FILE__, __LINE__, __func__);
1206	return -EFAULT;
1207	}
1208	return 0;
1209	}
1210
1211	/**
1212	* _ctl_eventquery - main handler for MPT3EVENTQUERY opcode
1213	* @ioc: per adapter object
1214	* @arg: user space buffer containing ioctl content
1215	*/
1216	static long
1217	_ctl_eventquery(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1218	{
1219	struct mpt3_ioctl_eventquery karg;
1220
1221	if (copy_from_user(to: &karg, from: arg, n: sizeof(karg))) {
1222	pr_err("failure at %s:%d/%s()!\n",
1223	__FILE__, __LINE__, __func__);
1224	return -EFAULT;
1225	}
1226
1227	dctlprintk(ioc, ioc_info(ioc, "%s: enter\n",
1228	__func__));
1229
1230	karg.event_entries = MPT3SAS_CTL_EVENT_LOG_SIZE;
1231	memcpy(karg.event_types, ioc->event_type,
1232	MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32));
1233
1234	if (copy_to_user(to: arg, from: &karg, n: sizeof(karg))) {
1235	pr_err("failure at %s:%d/%s()!\n",
1236	__FILE__, __LINE__, __func__);
1237	return -EFAULT;
1238	}
1239	return 0;
1240	}
1241
1242	/**
1243	* _ctl_eventenable - main handler for MPT3EVENTENABLE opcode
1244	* @ioc: per adapter object
1245	* @arg: user space buffer containing ioctl content
1246	*/
1247	static long
1248	_ctl_eventenable(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1249	{
1250	struct mpt3_ioctl_eventenable karg;
1251
1252	if (copy_from_user(to: &karg, from: arg, n: sizeof(karg))) {
1253	pr_err("failure at %s:%d/%s()!\n",
1254	__FILE__, __LINE__, __func__);
1255	return -EFAULT;
1256	}
1257
1258	dctlprintk(ioc, ioc_info(ioc, "%s: enter\n",
1259	__func__));
1260
1261	memcpy(ioc->event_type, karg.event_types,
1262	MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32));
1263	mpt3sas_base_validate_event_type(ioc, event_type: ioc->event_type);
1264
1265	if (ioc->event_log)
1266	return 0;
1267	/* initialize event_log */
1268	ioc->event_context = 0;
1269	ioc->aen_event_read_flag = 0;
1270	ioc->event_log = kcalloc(MPT3SAS_CTL_EVENT_LOG_SIZE,
1271	size: sizeof(struct MPT3_IOCTL_EVENTS), GFP_KERNEL);
1272	if (!ioc->event_log) {
1273	pr_err("failure at %s:%d/%s()!\n",
1274	__FILE__, __LINE__, __func__);
1275	return -ENOMEM;
1276	}
1277	return 0;
1278	}
1279
1280	/**
1281	* _ctl_eventreport - main handler for MPT3EVENTREPORT opcode
1282	* @ioc: per adapter object
1283	* @arg: user space buffer containing ioctl content
1284	*/
1285	static long
1286	_ctl_eventreport(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1287	{
1288	struct mpt3_ioctl_eventreport karg;
1289	u32 number_bytes, max_events, max;
1290	struct mpt3_ioctl_eventreport __user *uarg = arg;
1291
1292	if (copy_from_user(to: &karg, from: arg, n: sizeof(karg))) {
1293	pr_err("failure at %s:%d/%s()!\n",
1294	__FILE__, __LINE__, __func__);
1295	return -EFAULT;
1296	}
1297
1298	dctlprintk(ioc, ioc_info(ioc, "%s: enter\n",
1299	__func__));
1300
1301	number_bytes = karg.hdr.max_data_size -
1302	sizeof(struct mpt3_ioctl_header);
1303	max_events = number_bytes/sizeof(struct MPT3_IOCTL_EVENTS);
1304	max = min_t(u32, MPT3SAS_CTL_EVENT_LOG_SIZE, max_events);
1305
1306	/* If fewer than 1 event is requested, there must have
1307	* been some type of error.
1308	*/
1309	if (!max || !ioc->event_log)
1310	return -ENODATA;
1311
1312	number_bytes = max * sizeof(struct MPT3_IOCTL_EVENTS);
1313	if (copy_to_user(to: uarg->event_data, from: ioc->event_log, n: number_bytes)) {
1314	pr_err("failure at %s:%d/%s()!\n",
1315	__FILE__, __LINE__, __func__);
1316	return -EFAULT;
1317	}
1318
1319	/* reset flag so SIGIO can restart */
1320	ioc->aen_event_read_flag = 0;
1321	return 0;
1322	}
1323
1324	/**
1325	* _ctl_do_reset - main handler for MPT3HARDRESET opcode
1326	* @ioc: per adapter object
1327	* @arg: user space buffer containing ioctl content
1328	*/
1329	static long
1330	_ctl_do_reset(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1331	{
1332	struct mpt3_ioctl_diag_reset karg;
1333	int retval;
1334
1335	if (copy_from_user(to: &karg, from: arg, n: sizeof(karg))) {
1336	pr_err("failure at %s:%d/%s()!\n",
1337	__FILE__, __LINE__, __func__);
1338	return -EFAULT;
1339	}
1340
1341	if (ioc->shost_recovery || ioc->pci_error_recovery ||
1342	ioc->is_driver_loading)
1343	return -EAGAIN;
1344
1345	dctlprintk(ioc, ioc_info(ioc, "%s: enter\n",
1346	__func__));
1347
1348	ioc->reset_from_user = 1;
1349	retval = mpt3sas_base_hard_reset_handler(ioc, type: FORCE_BIG_HAMMER);
1350	ioc_info(ioc,
1351	"Ioctl: host reset: %s\n", ((!retval) ? "SUCCESS" : "FAILED"));
1352	return 0;
1353	}
1354
1355	/**
1356	* _ctl_btdh_search_sas_device - searching for sas device
1357	* @ioc: per adapter object
1358	* @btdh: btdh ioctl payload
1359	*/
1360	static int
1361	_ctl_btdh_search_sas_device(struct MPT3SAS_ADAPTER *ioc,
1362	struct mpt3_ioctl_btdh_mapping *btdh)
1363	{
1364	struct _sas_device *sas_device;
1365	unsigned long flags;
1366	int rc = 0;
1367
1368	if (list_empty(head: &ioc->sas_device_list))
1369	return rc;
1370
1371	spin_lock_irqsave(&ioc->sas_device_lock, flags);
1372	list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
1373	if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF &&
1374	btdh->handle == sas_device->handle) {
1375	btdh->bus = sas_device->channel;
1376	btdh->id = sas_device->id;
1377	rc = 1;
1378	goto out;
1379	} else if (btdh->bus == sas_device->channel && btdh->id ==
1380	sas_device->id && btdh->handle == 0xFFFF) {
1381	btdh->handle = sas_device->handle;
1382	rc = 1;
1383	goto out;
1384	}
1385	}
1386	out:
1387	spin_unlock_irqrestore(lock: &ioc->sas_device_lock, flags);
1388	return rc;
1389	}
1390
1391	/**
1392	* _ctl_btdh_search_pcie_device - searching for pcie device
1393	* @ioc: per adapter object
1394	* @btdh: btdh ioctl payload
1395	*/
1396	static int
1397	_ctl_btdh_search_pcie_device(struct MPT3SAS_ADAPTER *ioc,
1398	struct mpt3_ioctl_btdh_mapping *btdh)
1399	{
1400	struct _pcie_device *pcie_device;
1401	unsigned long flags;
1402	int rc = 0;
1403
1404	if (list_empty(head: &ioc->pcie_device_list))
1405	return rc;
1406
1407	spin_lock_irqsave(&ioc->pcie_device_lock, flags);
1408	list_for_each_entry(pcie_device, &ioc->pcie_device_list, list) {
1409	if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF &&
1410	btdh->handle == pcie_device->handle) {
1411	btdh->bus = pcie_device->channel;
1412	btdh->id = pcie_device->id;
1413	rc = 1;
1414	goto out;
1415	} else if (btdh->bus == pcie_device->channel && btdh->id ==
1416	pcie_device->id && btdh->handle == 0xFFFF) {
1417	btdh->handle = pcie_device->handle;
1418	rc = 1;
1419	goto out;
1420	}
1421	}
1422	out:
1423	spin_unlock_irqrestore(lock: &ioc->pcie_device_lock, flags);
1424	return rc;
1425	}
1426
1427	/**
1428	* _ctl_btdh_search_raid_device - searching for raid device
1429	* @ioc: per adapter object
1430	* @btdh: btdh ioctl payload
1431	*/
1432	static int
1433	_ctl_btdh_search_raid_device(struct MPT3SAS_ADAPTER *ioc,
1434	struct mpt3_ioctl_btdh_mapping *btdh)
1435	{
1436	struct _raid_device *raid_device;
1437	unsigned long flags;
1438	int rc = 0;
1439
1440	if (list_empty(head: &ioc->raid_device_list))
1441	return rc;
1442
1443	spin_lock_irqsave(&ioc->raid_device_lock, flags);
1444	list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
1445	if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF &&
1446	btdh->handle == raid_device->handle) {
1447	btdh->bus = raid_device->channel;
1448	btdh->id = raid_device->id;
1449	rc = 1;
1450	goto out;
1451	} else if (btdh->bus == raid_device->channel && btdh->id ==
1452	raid_device->id && btdh->handle == 0xFFFF) {
1453	btdh->handle = raid_device->handle;
1454	rc = 1;
1455	goto out;
1456	}
1457	}
1458	out:
1459	spin_unlock_irqrestore(lock: &ioc->raid_device_lock, flags);
1460	return rc;
1461	}
1462
1463	/**
1464	* _ctl_btdh_mapping - main handler for MPT3BTDHMAPPING opcode
1465	* @ioc: per adapter object
1466	* @arg: user space buffer containing ioctl content
1467	*/
1468	static long
1469	_ctl_btdh_mapping(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1470	{
1471	struct mpt3_ioctl_btdh_mapping karg;
1472	int rc;
1473
1474	if (copy_from_user(to: &karg, from: arg, n: sizeof(karg))) {
1475	pr_err("failure at %s:%d/%s()!\n",
1476	__FILE__, __LINE__, __func__);
1477	return -EFAULT;
1478	}
1479
1480	dctlprintk(ioc, ioc_info(ioc, "%s\n",
1481	__func__));
1482
1483	rc = _ctl_btdh_search_sas_device(ioc, btdh: &karg);
1484	if (!rc)
1485	rc = _ctl_btdh_search_pcie_device(ioc, btdh: &karg);
1486	if (!rc)
1487	_ctl_btdh_search_raid_device(ioc, btdh: &karg);
1488
1489	if (copy_to_user(to: arg, from: &karg, n: sizeof(karg))) {
1490	pr_err("failure at %s:%d/%s()!\n",
1491	__FILE__, __LINE__, __func__);
1492	return -EFAULT;
1493	}
1494	return 0;
1495	}
1496
1497	/**
1498	* _ctl_diag_capability - return diag buffer capability
1499	* @ioc: per adapter object
1500	* @buffer_type: specifies either TRACE, SNAPSHOT, or EXTENDED
1501	*
1502	* returns 1 when diag buffer support is enabled in firmware
1503	*/
1504	static u8
1505	_ctl_diag_capability(struct MPT3SAS_ADAPTER *ioc, u8 buffer_type)
1506	{
1507	u8 rc = 0;
1508
1509	switch (buffer_type) {
1510	case MPI2_DIAG_BUF_TYPE_TRACE:
1511	if (ioc->facts.IOCCapabilities &
1512	MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER)
1513	rc = 1;
1514	break;
1515	case MPI2_DIAG_BUF_TYPE_SNAPSHOT:
1516	if (ioc->facts.IOCCapabilities &
1517	MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER)
1518	rc = 1;
1519	break;
1520	case MPI2_DIAG_BUF_TYPE_EXTENDED:
1521	if (ioc->facts.IOCCapabilities &
1522	MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER)
1523	rc = 1;
1524	}
1525
1526	return rc;
1527	}
1528
1529	/**
1530	* _ctl_diag_get_bufftype - return diag buffer type
1531	* either TRACE, SNAPSHOT, or EXTENDED
1532	* @ioc: per adapter object
1533	* @unique_id: specifies the unique_id for the buffer
1534	*
1535	* returns MPT3_DIAG_UID_NOT_FOUND if the id not found
1536	*/
1537	static u8
1538	_ctl_diag_get_bufftype(struct MPT3SAS_ADAPTER *ioc, u32 unique_id)
1539	{
1540	u8 index;
1541
1542	for (index = 0; index < MPI2_DIAG_BUF_TYPE_COUNT; index++) {
1543	if (ioc->unique_id[index] == unique_id)
1544	return index;
1545	}
1546
1547	return MPT3_DIAG_UID_NOT_FOUND;
1548	}
1549
1550	/**
1551	* _ctl_diag_register_2 - wrapper for registering diag buffer support
1552	* @ioc: per adapter object
1553	* @diag_register: the diag_register struct passed in from user space
1554	*
1555	*/
1556	static long
1557	_ctl_diag_register_2(struct MPT3SAS_ADAPTER *ioc,
1558	struct mpt3_diag_register *diag_register)
1559	{
1560	int rc, i;
1561	void *request_data = NULL;
1562	dma_addr_t request_data_dma;
1563	u32 request_data_sz = 0;
1564	Mpi2DiagBufferPostRequest_t *mpi_request;
1565	Mpi2DiagBufferPostReply_t *mpi_reply;
1566	u8 buffer_type;
1567	u16 smid;
1568	u16 ioc_status;
1569	u32 ioc_state;
1570	u8 issue_reset = 0;
1571
1572	dctlprintk(ioc, ioc_info(ioc, "%s\n",
1573	__func__));
1574
1575	ioc_state = mpt3sas_base_get_iocstate(ioc, cooked: 1);
1576	if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
1577	ioc_err(ioc, "%s: failed due to ioc not operational\n",
1578	__func__);
1579	rc = -EAGAIN;
1580	goto out;
1581	}
1582
1583	if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) {
1584	ioc_err(ioc, "%s: ctl_cmd in use\n", __func__);
1585	rc = -EAGAIN;
1586	goto out;
1587	}
1588
1589	buffer_type = diag_register->buffer_type;
1590	if (!_ctl_diag_capability(ioc, buffer_type)) {
1591	ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n",
1592	__func__, buffer_type);
1593	return -EPERM;
1594	}
1595
1596	if (diag_register->unique_id == 0) {
1597	ioc_err(ioc,
1598	"%s: Invalid UID(0x%08x), buffer_type(0x%02x)\n", __func__,
1599	diag_register->unique_id, buffer_type);
1600	return -EINVAL;
1601	}
1602
1603	if ((ioc->diag_buffer_status[buffer_type] &
1604	MPT3_DIAG_BUFFER_IS_APP_OWNED) &&
1605	!(ioc->diag_buffer_status[buffer_type] &
1606	MPT3_DIAG_BUFFER_IS_RELEASED)) {
1607	ioc_err(ioc,
1608	"%s: buffer_type(0x%02x) is already registered by application with UID(0x%08x)\n",
1609	__func__, buffer_type, ioc->unique_id[buffer_type]);
1610	return -EINVAL;
1611	}
1612
1613	if (ioc->diag_buffer_status[buffer_type] &
1614	MPT3_DIAG_BUFFER_IS_REGISTERED) {
1615	/*
1616	* If driver posts buffer initially, then an application wants
1617	* to Register that buffer (own it) without Releasing first,
1618	* the application Register command MUST have the same buffer
1619	* type and size in the Register command (obtained from the
1620	* Query command). Otherwise that Register command will be
1621	* failed. If the application has released the buffer but wants
1622	* to re-register it, it should be allowed as long as the
1623	* Unique-Id/Size match.
1624	*/
1625
1626	if (ioc->unique_id[buffer_type] == MPT3DIAGBUFFUNIQUEID &&
1627	ioc->diag_buffer_sz[buffer_type] ==
1628	diag_register->requested_buffer_size) {
1629
1630	if (!(ioc->diag_buffer_status[buffer_type] &
1631	MPT3_DIAG_BUFFER_IS_RELEASED)) {
1632	dctlprintk(ioc, ioc_info(ioc,
1633	"%s: diag_buffer (%d) ownership changed. old-ID(0x%08x), new-ID(0x%08x)\n",
1634	__func__, buffer_type,
1635	ioc->unique_id[buffer_type],
1636	diag_register->unique_id));
1637
1638	/*
1639	* Application wants to own the buffer with
1640	* the same size.
1641	*/
1642	ioc->unique_id[buffer_type] =
1643	diag_register->unique_id;
1644	rc = 0; /* success */
1645	goto out;
1646	}
1647	} else if (ioc->unique_id[buffer_type] !=
1648	MPT3DIAGBUFFUNIQUEID) {
1649	if (ioc->unique_id[buffer_type] !=
1650	diag_register->unique_id ||
1651	ioc->diag_buffer_sz[buffer_type] !=
1652	diag_register->requested_buffer_size ||
1653	!(ioc->diag_buffer_status[buffer_type] &
1654	MPT3_DIAG_BUFFER_IS_RELEASED)) {
1655	ioc_err(ioc,
1656	"%s: already has a registered buffer for buffer_type(0x%02x)\n",
1657	__func__, buffer_type);
1658	return -EINVAL;
1659	}
1660	} else {
1661	ioc_err(ioc, "%s: already has a registered buffer for buffer_type(0x%02x)\n",
1662	__func__, buffer_type);
1663	return -EINVAL;
1664	}
1665	} else if (ioc->diag_buffer_status[buffer_type] &
1666	MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED) {
1667
1668	if (ioc->unique_id[buffer_type] != MPT3DIAGBUFFUNIQUEID ||
1669	ioc->diag_buffer_sz[buffer_type] !=
1670	diag_register->requested_buffer_size) {
1671
1672	ioc_err(ioc,
1673	"%s: already a buffer is allocated for buffer_type(0x%02x) of size %d bytes, so please try registering again with same size\n",
1674	__func__, buffer_type,
1675	ioc->diag_buffer_sz[buffer_type]);
1676	return -EINVAL;
1677	}
1678	}
1679
1680	if (diag_register->requested_buffer_size % 4) {
1681	ioc_err(ioc, "%s: the requested_buffer_size is not 4 byte aligned\n",
1682	__func__);
1683	return -EINVAL;
1684	}
1685
1686	smid = mpt3sas_base_get_smid(ioc, cb_idx: ioc->ctl_cb_idx);
1687	if (!smid) {
1688	ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
1689	rc = -EAGAIN;
1690	goto out;
1691	}
1692
1693	rc = 0;
1694	ioc->ctl_cmds.status = MPT3_CMD_PENDING;
1695	memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
1696	mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
1697	memset(mpi_request, 0, ioc->request_sz);
1698	ioc->ctl_cmds.smid = smid;
1699
1700	request_data = ioc->diag_buffer[buffer_type];
1701	request_data_sz = diag_register->requested_buffer_size;
1702	ioc->unique_id[buffer_type] = diag_register->unique_id;
1703	/* Reset ioc variables used for additional query commands */
1704	ioc->reset_from_user = 0;
1705	memset(&ioc->htb_rel, 0, sizeof(struct htb_rel_query));
1706	ioc->diag_buffer_status[buffer_type] &=
1707	MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED;
1708	memcpy(ioc->product_specific[buffer_type],
1709	diag_register->product_specific, MPT3_PRODUCT_SPECIFIC_DWORDS);
1710	ioc->diagnostic_flags[buffer_type] = diag_register->diagnostic_flags;
1711
1712	if (request_data) {
1713	request_data_dma = ioc->diag_buffer_dma[buffer_type];
1714	if (request_data_sz != ioc->diag_buffer_sz[buffer_type]) {
1715	dma_free_coherent(dev: &ioc->pdev->dev,
1716	size: ioc->diag_buffer_sz[buffer_type],
1717	cpu_addr: request_data, dma_handle: request_data_dma);
1718	request_data = NULL;
1719	}
1720	}
1721
1722	if (request_data == NULL) {
1723	ioc->diag_buffer_sz[buffer_type] = 0;
1724	ioc->diag_buffer_dma[buffer_type] = 0;
1725	request_data = dma_alloc_coherent(dev: &ioc->pdev->dev,
1726	size: request_data_sz, dma_handle: &request_data_dma, GFP_KERNEL);
1727	if (request_data == NULL) {
1728	ioc_err(ioc, "%s: failed allocating memory for diag buffers, requested size(%d)\n",
1729	__func__, request_data_sz);
1730	mpt3sas_base_free_smid(ioc, smid);
1731	rc = -ENOMEM;
1732	goto out;
1733	}
1734	ioc->diag_buffer[buffer_type] = request_data;
1735	ioc->diag_buffer_sz[buffer_type] = request_data_sz;
1736	ioc->diag_buffer_dma[buffer_type] = request_data_dma;
1737	}
1738
1739	mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST;
1740	mpi_request->BufferType = diag_register->buffer_type;
1741	mpi_request->Flags = cpu_to_le32(diag_register->diagnostic_flags);
1742	mpi_request->BufferAddress = cpu_to_le64(request_data_dma);
1743	mpi_request->BufferLength = cpu_to_le32(request_data_sz);
1744	mpi_request->VF_ID = 0; /* TODO */
1745	mpi_request->VP_ID = 0;
1746
1747	dctlprintk(ioc,
1748	ioc_info(ioc, "%s: diag_buffer(0x%p), dma(0x%llx), sz(%d)\n",
1749	__func__, request_data,
1750	(unsigned long long)request_data_dma,
1751	le32_to_cpu(mpi_request->BufferLength)));
1752
1753	for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++)
1754	mpi_request->ProductSpecific[i] =
1755	cpu_to_le32(ioc->product_specific[buffer_type][i]);
1756
1757	init_completion(x: &ioc->ctl_cmds.done);
1758	ioc->put_smid_default(ioc, smid);
1759	wait_for_completion_timeout(x: &ioc->ctl_cmds.done,
1760	MPT3_IOCTL_DEFAULT_TIMEOUT*HZ);
1761
1762	if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) {
1763	mpt3sas_check_cmd_timeout(ioc,
1764	ioc->ctl_cmds.status, mpi_request,
1765	sizeof(Mpi2DiagBufferPostRequest_t)/4, issue_reset);
1766	goto issue_host_reset;
1767	}
1768
1769	/* process the completed Reply Message Frame */
1770	if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) {
1771	ioc_err(ioc, "%s: no reply message\n", __func__);
1772	rc = -EFAULT;
1773	goto out;
1774	}
1775
1776	mpi_reply = ioc->ctl_cmds.reply;
1777	ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1778
1779	if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
1780	ioc->diag_buffer_status[buffer_type] |=
1781	MPT3_DIAG_BUFFER_IS_REGISTERED;
1782	dctlprintk(ioc, ioc_info(ioc, "%s: success\n", __func__));
1783	} else {
1784	ioc_info(ioc, "%s: ioc_status(0x%04x) log_info(0x%08x)\n",
1785	__func__,
1786	ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
1787	rc = -EFAULT;
1788	}
1789
1790	issue_host_reset:
1791	if (issue_reset)
1792	mpt3sas_base_hard_reset_handler(ioc, type: FORCE_BIG_HAMMER);
1793
1794	out:
1795
1796	if (rc && request_data) {
1797	dma_free_coherent(dev: &ioc->pdev->dev, size: request_data_sz,
1798	cpu_addr: request_data, dma_handle: request_data_dma);
1799	ioc->diag_buffer[buffer_type] = NULL;
1800	ioc->diag_buffer_status[buffer_type] &=
1801	~MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED;
1802	}
1803
1804	ioc->ctl_cmds.status = MPT3_CMD_NOT_USED;
1805	return rc;
1806	}
1807
1808	/**
1809	* mpt3sas_enable_diag_buffer - enabling diag_buffers support driver load time
1810	* @ioc: per adapter object
1811	* @bits_to_register: bitwise field where trace is bit 0, and snapshot is bit 1
1812	*
1813	* This is called when command line option diag_buffer_enable is enabled
1814	* at driver load time.
1815	*/
1816	void
1817	mpt3sas_enable_diag_buffer(struct MPT3SAS_ADAPTER *ioc, u8 bits_to_register)
1818	{
1819	struct mpt3_diag_register diag_register;
1820	u32 ret_val;
1821	u32 trace_buff_size = ioc->manu_pg11.HostTraceBufferMaxSizeKB<<10;
1822	u32 min_trace_buff_size = 0;
1823	u32 decr_trace_buff_size = 0;
1824
1825	memset(&diag_register, 0, sizeof(struct mpt3_diag_register));
1826
1827	if (bits_to_register & 1) {
1828	ioc_info(ioc, "registering trace buffer support\n");
1829	ioc->diag_trigger_master.MasterData =
1830	(MASTER_TRIGGER_FW_FAULT + MASTER_TRIGGER_ADAPTER_RESET);
1831	diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE;
1832	diag_register.unique_id =
1833	(ioc->hba_mpi_version_belonged == MPI2_VERSION) ?
1834	(MPT2DIAGBUFFUNIQUEID):(MPT3DIAGBUFFUNIQUEID);
1835
1836	if (trace_buff_size != 0) {
1837	diag_register.requested_buffer_size = trace_buff_size;
1838	min_trace_buff_size =
1839	ioc->manu_pg11.HostTraceBufferMinSizeKB<<10;
1840	decr_trace_buff_size =
1841	ioc->manu_pg11.HostTraceBufferDecrementSizeKB<<10;
1842
1843	if (min_trace_buff_size > trace_buff_size) {
1844	/* The buff size is not set correctly */
1845	ioc_err(ioc,
1846	"Min Trace Buff size (%d KB) greater than Max Trace Buff size (%d KB)\n",
1847	min_trace_buff_size>>10,
1848	trace_buff_size>>10);
1849	ioc_err(ioc,
1850	"Using zero Min Trace Buff Size\n");
1851	min_trace_buff_size = 0;
1852	}
1853
1854	if (decr_trace_buff_size == 0) {
1855	/*
1856	* retry the min size if decrement
1857	* is not available.
1858	*/
1859	decr_trace_buff_size =
1860	trace_buff_size - min_trace_buff_size;
1861	}
1862	} else {
1863	/* register for 2MB buffers */
1864	diag_register.requested_buffer_size = 2 * (1024 * 1024);
1865	}
1866
1867	do {
1868	ret_val = _ctl_diag_register_2(ioc, diag_register: &diag_register);
1869
1870	if (ret_val == -ENOMEM && min_trace_buff_size &&
1871	(trace_buff_size - decr_trace_buff_size) >=
1872	min_trace_buff_size) {
1873	/* adjust the buffer size */
1874	trace_buff_size -= decr_trace_buff_size;
1875	diag_register.requested_buffer_size =
1876	trace_buff_size;
1877	} else
1878	break;
1879	} while (true);
1880
1881	if (ret_val == -ENOMEM)
1882	ioc_err(ioc,
1883	"Cannot allocate trace buffer memory. Last memory tried = %d KB\n",
1884	diag_register.requested_buffer_size>>10);
1885	else if (ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE]
1886	& MPT3_DIAG_BUFFER_IS_REGISTERED) {
1887	ioc_info(ioc, "Trace buffer memory %d KB allocated\n",
1888	diag_register.requested_buffer_size>>10);
1889	if (ioc->hba_mpi_version_belonged != MPI2_VERSION)
1890	ioc->diag_buffer_status[
1891	MPI2_DIAG_BUF_TYPE_TRACE] |=
1892	MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED;
1893	}
1894	}
1895
1896	if (bits_to_register & 2) {
1897	ioc_info(ioc, "registering snapshot buffer support\n");
1898	diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_SNAPSHOT;
1899	/* register for 2MB buffers */
1900	diag_register.requested_buffer_size = 2 * (1024 * 1024);
1901	diag_register.unique_id = 0x7075901;
1902	_ctl_diag_register_2(ioc, diag_register: &diag_register);
1903	}
1904
1905	if (bits_to_register & 4) {
1906	ioc_info(ioc, "registering extended buffer support\n");
1907	diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_EXTENDED;
1908	/* register for 2MB buffers */
1909	diag_register.requested_buffer_size = 2 * (1024 * 1024);
1910	diag_register.unique_id = 0x7075901;
1911	_ctl_diag_register_2(ioc, diag_register: &diag_register);
1912	}
1913	}
1914
1915	/**
1916	* _ctl_diag_register - application register with driver
1917	* @ioc: per adapter object
1918	* @arg: user space buffer containing ioctl content
1919	*
1920	* This will allow the driver to setup any required buffers that will be
1921	* needed by firmware to communicate with the driver.
1922	*/
1923	static long
1924	_ctl_diag_register(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1925	{
1926	struct mpt3_diag_register karg;
1927	long rc;
1928
1929	if (copy_from_user(to: &karg, from: arg, n: sizeof(karg))) {
1930	pr_err("failure at %s:%d/%s()!\n",
1931	__FILE__, __LINE__, __func__);
1932	return -EFAULT;
1933	}
1934
1935	rc = _ctl_diag_register_2(ioc, diag_register: &karg);
1936
1937	if (!rc && (ioc->diag_buffer_status[karg.buffer_type] &
1938	MPT3_DIAG_BUFFER_IS_REGISTERED))
1939	ioc->diag_buffer_status[karg.buffer_type] |=
1940	MPT3_DIAG_BUFFER_IS_APP_OWNED;
1941
1942	return rc;
1943	}
1944
1945	/**
1946	* _ctl_diag_unregister - application unregister with driver
1947	* @ioc: per adapter object
1948	* @arg: user space buffer containing ioctl content
1949	*
1950	* This will allow the driver to cleanup any memory allocated for diag
1951	* messages and to free up any resources.
1952	*/
1953	static long
1954	_ctl_diag_unregister(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1955	{
1956	struct mpt3_diag_unregister karg;
1957	void *request_data;
1958	dma_addr_t request_data_dma;
1959	u32 request_data_sz;
1960	u8 buffer_type;
1961
1962	if (copy_from_user(to: &karg, from: arg, n: sizeof(karg))) {
1963	pr_err("failure at %s:%d/%s()!\n",
1964	__FILE__, __LINE__, __func__);
1965	return -EFAULT;
1966	}
1967
1968	dctlprintk(ioc, ioc_info(ioc, "%s\n",
1969	__func__));
1970
1971	buffer_type = _ctl_diag_get_bufftype(ioc, unique_id: karg.unique_id);
1972	if (buffer_type == MPT3_DIAG_UID_NOT_FOUND) {
1973	ioc_err(ioc, "%s: buffer with unique_id(0x%08x) not found\n",
1974	__func__, karg.unique_id);
1975	return -EINVAL;
1976	}
1977
1978	if (!_ctl_diag_capability(ioc, buffer_type)) {
1979	ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n",
1980	__func__, buffer_type);
1981	return -EPERM;
1982	}
1983
1984	if ((ioc->diag_buffer_status[buffer_type] &
1985	MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
1986	ioc_err(ioc, "%s: buffer_type(0x%02x) is not registered\n",
1987	__func__, buffer_type);
1988	return -EINVAL;
1989	}
1990	if ((ioc->diag_buffer_status[buffer_type] &
1991	MPT3_DIAG_BUFFER_IS_RELEASED) == 0) {
1992	ioc_err(ioc, "%s: buffer_type(0x%02x) has not been released\n",
1993	__func__, buffer_type);
1994	return -EINVAL;
1995	}
1996
1997	if (karg.unique_id != ioc->unique_id[buffer_type]) {
1998	ioc_err(ioc, "%s: unique_id(0x%08x) is not registered\n",
1999	__func__, karg.unique_id);
2000	return -EINVAL;
2001	}
2002
2003	request_data = ioc->diag_buffer[buffer_type];
2004	if (!request_data) {
2005	ioc_err(ioc, "%s: doesn't have memory allocated for buffer_type(0x%02x)\n",
2006	__func__, buffer_type);
2007	return -ENOMEM;
2008	}
2009
2010	if (ioc->diag_buffer_status[buffer_type] &
2011	MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED) {
2012	ioc->unique_id[buffer_type] = MPT3DIAGBUFFUNIQUEID;
2013	ioc->diag_buffer_status[buffer_type] &=
2014	~MPT3_DIAG_BUFFER_IS_APP_OWNED;
2015	ioc->diag_buffer_status[buffer_type] &=
2016	~MPT3_DIAG_BUFFER_IS_REGISTERED;
2017	} else {
2018	request_data_sz = ioc->diag_buffer_sz[buffer_type];
2019	request_data_dma = ioc->diag_buffer_dma[buffer_type];
2020	dma_free_coherent(dev: &ioc->pdev->dev, size: request_data_sz,
2021	cpu_addr: request_data, dma_handle: request_data_dma);
2022	ioc->diag_buffer[buffer_type] = NULL;
2023	ioc->diag_buffer_status[buffer_type] = 0;
2024	}
2025	return 0;
2026	}
2027
2028	/**
2029	* _ctl_diag_query - query relevant info associated with diag buffers
2030	* @ioc: per adapter object
2031	* @arg: user space buffer containing ioctl content
2032	*
2033	* The application will send only buffer_type and unique_id. Driver will
2034	* inspect unique_id first, if valid, fill in all the info. If unique_id is
2035	* 0x00, the driver will return info specified by Buffer Type.
2036	*/
2037	static long
2038	_ctl_diag_query(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
2039	{
2040	struct mpt3_diag_query karg;
2041	void *request_data;
2042	int i;
2043	u8 buffer_type;
2044
2045	if (copy_from_user(to: &karg, from: arg, n: sizeof(karg))) {
2046	pr_err("failure at %s:%d/%s()!\n",
2047	__FILE__, __LINE__, __func__);
2048	return -EFAULT;
2049	}
2050
2051	dctlprintk(ioc, ioc_info(ioc, "%s\n",
2052	__func__));
2053
2054	karg.application_flags = 0;
2055	buffer_type = karg.buffer_type;
2056
2057	if (!_ctl_diag_capability(ioc, buffer_type)) {
2058	ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n",
2059	__func__, buffer_type);
2060	return -EPERM;
2061	}
2062
2063	if (!(ioc->diag_buffer_status[buffer_type] &
2064	MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED)) {
2065	if ((ioc->diag_buffer_status[buffer_type] &
2066	MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
2067	ioc_err(ioc, "%s: buffer_type(0x%02x) is not registered\n",
2068	__func__, buffer_type);
2069	return -EINVAL;
2070	}
2071	}
2072
2073	if (karg.unique_id) {
2074	if (karg.unique_id != ioc->unique_id[buffer_type]) {
2075	ioc_err(ioc, "%s: unique_id(0x%08x) is not registered\n",
2076	__func__, karg.unique_id);
2077	return -EINVAL;
2078	}
2079	}
2080
2081	request_data = ioc->diag_buffer[buffer_type];
2082	if (!request_data) {
2083	ioc_err(ioc, "%s: doesn't have buffer for buffer_type(0x%02x)\n",
2084	__func__, buffer_type);
2085	return -ENOMEM;
2086	}
2087
2088	if ((ioc->diag_buffer_status[buffer_type] &
2089	MPT3_DIAG_BUFFER_IS_REGISTERED))
2090	karg.application_flags |= MPT3_APP_FLAGS_BUFFER_VALID;
2091
2092	if (!(ioc->diag_buffer_status[buffer_type] &
2093	MPT3_DIAG_BUFFER_IS_RELEASED))
2094	karg.application_flags |= MPT3_APP_FLAGS_FW_BUFFER_ACCESS;
2095
2096	if (!(ioc->diag_buffer_status[buffer_type] &
2097	MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED))
2098	karg.application_flags |= MPT3_APP_FLAGS_DYNAMIC_BUFFER_ALLOC;
2099
2100	if ((ioc->diag_buffer_status[buffer_type] &
2101	MPT3_DIAG_BUFFER_IS_APP_OWNED))
2102	karg.application_flags |= MPT3_APP_FLAGS_APP_OWNED;
2103
2104	for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++)
2105	karg.product_specific[i] =
2106	ioc->product_specific[buffer_type][i];
2107
2108	karg.total_buffer_size = ioc->diag_buffer_sz[buffer_type];
2109	karg.driver_added_buffer_size = 0;
2110	karg.unique_id = ioc->unique_id[buffer_type];
2111	karg.diagnostic_flags = ioc->diagnostic_flags[buffer_type];
2112
2113	if (copy_to_user(to: arg, from: &karg, n: sizeof(struct mpt3_diag_query))) {
2114	ioc_err(ioc, "%s: unable to write mpt3_diag_query data @ %p\n",
2115	__func__, arg);
2116	return -EFAULT;
2117	}
2118	return 0;
2119	}
2120
2121	/**
2122	* mpt3sas_send_diag_release - Diag Release Message
2123	* @ioc: per adapter object
2124	* @buffer_type: specifies either TRACE, SNAPSHOT, or EXTENDED
2125	* @issue_reset: specifies whether host reset is required.
2126	*
2127	*/
2128	int
2129	mpt3sas_send_diag_release(struct MPT3SAS_ADAPTER *ioc, u8 buffer_type,
2130	u8 *issue_reset)
2131	{
2132	Mpi2DiagReleaseRequest_t *mpi_request;
2133	Mpi2DiagReleaseReply_t *mpi_reply;
2134	u16 smid;
2135	u16 ioc_status;
2136	u32 ioc_state;
2137	int rc;
2138	u8 reset_needed = 0;
2139
2140	dctlprintk(ioc, ioc_info(ioc, "%s\n",
2141	__func__));
2142
2143	rc = 0;
2144	*issue_reset = 0;
2145
2146
2147	ioc_state = mpt3sas_base_get_iocstate(ioc, cooked: 1);
2148	if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
2149	if (ioc->diag_buffer_status[buffer_type] &
2150	MPT3_DIAG_BUFFER_IS_REGISTERED)
2151	ioc->diag_buffer_status[buffer_type] |=
2152	MPT3_DIAG_BUFFER_IS_RELEASED;
2153	dctlprintk(ioc,
2154	ioc_info(ioc, "%s: skipping due to FAULT state\n",
2155	__func__));
2156	rc = -EAGAIN;
2157	goto out;
2158	}
2159
2160	if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) {
2161	ioc_err(ioc, "%s: ctl_cmd in use\n", __func__);
2162	rc = -EAGAIN;
2163	goto out;
2164	}
2165
2166	smid = mpt3sas_base_get_smid(ioc, cb_idx: ioc->ctl_cb_idx);
2167	if (!smid) {
2168	ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
2169	rc = -EAGAIN;
2170	goto out;
2171	}
2172
2173	ioc->ctl_cmds.status = MPT3_CMD_PENDING;
2174	memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
2175	mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
2176	memset(mpi_request, 0, ioc->request_sz);
2177	ioc->ctl_cmds.smid = smid;
2178
2179	mpi_request->Function = MPI2_FUNCTION_DIAG_RELEASE;
2180	mpi_request->BufferType = buffer_type;
2181	mpi_request->VF_ID = 0; /* TODO */
2182	mpi_request->VP_ID = 0;
2183
2184	init_completion(x: &ioc->ctl_cmds.done);
2185	ioc->put_smid_default(ioc, smid);
2186	wait_for_completion_timeout(x: &ioc->ctl_cmds.done,
2187	MPT3_IOCTL_DEFAULT_TIMEOUT*HZ);
2188
2189	if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) {
2190	mpt3sas_check_cmd_timeout(ioc,
2191	ioc->ctl_cmds.status, mpi_request,
2192	sizeof(Mpi2DiagReleaseRequest_t)/4, reset_needed);
2193	*issue_reset = reset_needed;
2194	rc = -EFAULT;
2195	goto out;
2196	}
2197
2198	/* process the completed Reply Message Frame */
2199	if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) {
2200	ioc_err(ioc, "%s: no reply message\n", __func__);
2201	rc = -EFAULT;
2202	goto out;
2203	}
2204
2205	mpi_reply = ioc->ctl_cmds.reply;
2206	ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
2207
2208	if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
2209	ioc->diag_buffer_status[buffer_type] |=
2210	MPT3_DIAG_BUFFER_IS_RELEASED;
2211	dctlprintk(ioc, ioc_info(ioc, "%s: success\n", __func__));
2212	} else {
2213	ioc_info(ioc, "%s: ioc_status(0x%04x) log_info(0x%08x)\n",
2214	__func__,
2215	ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
2216	rc = -EFAULT;
2217	}
2218
2219	out:
2220	ioc->ctl_cmds.status = MPT3_CMD_NOT_USED;
2221	return rc;
2222	}
2223
2224	/**
2225	* _ctl_diag_release - request to send Diag Release Message to firmware
2226	* @ioc: ?
2227	* @arg: user space buffer containing ioctl content
2228	*
2229	* This allows ownership of the specified buffer to returned to the driver,
2230	* allowing an application to read the buffer without fear that firmware is
2231	* overwriting information in the buffer.
2232	*/
2233	static long
2234	_ctl_diag_release(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
2235	{
2236	struct mpt3_diag_release karg;
2237	void *request_data;
2238	int rc;
2239	u8 buffer_type;
2240	u8 issue_reset = 0;
2241
2242	if (copy_from_user(to: &karg, from: arg, n: sizeof(karg))) {
2243	pr_err("failure at %s:%d/%s()!\n",
2244	__FILE__, __LINE__, __func__);
2245	return -EFAULT;
2246	}
2247
2248	dctlprintk(ioc, ioc_info(ioc, "%s\n",
2249	__func__));
2250
2251	buffer_type = _ctl_diag_get_bufftype(ioc, unique_id: karg.unique_id);
2252	if (buffer_type == MPT3_DIAG_UID_NOT_FOUND) {
2253	ioc_err(ioc, "%s: buffer with unique_id(0x%08x) not found\n",
2254	__func__, karg.unique_id);
2255	return -EINVAL;
2256	}
2257
2258	if (!_ctl_diag_capability(ioc, buffer_type)) {
2259	ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n",
2260	__func__, buffer_type);
2261	return -EPERM;
2262	}
2263
2264	if ((ioc->diag_buffer_status[buffer_type] &
2265	MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
2266	ioc_err(ioc, "%s: buffer_type(0x%02x) is not registered\n",
2267	__func__, buffer_type);
2268	return -EINVAL;
2269	}
2270
2271	if (karg.unique_id != ioc->unique_id[buffer_type]) {
2272	ioc_err(ioc, "%s: unique_id(0x%08x) is not registered\n",
2273	__func__, karg.unique_id);
2274	return -EINVAL;
2275	}
2276
2277	if (ioc->diag_buffer_status[buffer_type] &
2278	MPT3_DIAG_BUFFER_IS_RELEASED) {
2279	ioc_err(ioc, "%s: buffer_type(0x%02x) is already released\n",
2280	__func__, buffer_type);
2281	return -EINVAL;
2282	}
2283
2284	request_data = ioc->diag_buffer[buffer_type];
2285
2286	if (!request_data) {
2287	ioc_err(ioc, "%s: doesn't have memory allocated for buffer_type(0x%02x)\n",
2288	__func__, buffer_type);
2289	return -ENOMEM;
2290	}
2291
2292	/* buffers were released by due to host reset */
2293	if ((ioc->diag_buffer_status[buffer_type] &
2294	MPT3_DIAG_BUFFER_IS_DIAG_RESET)) {
2295	ioc->diag_buffer_status[buffer_type] |=
2296	MPT3_DIAG_BUFFER_IS_RELEASED;
2297	ioc->diag_buffer_status[buffer_type] &=
2298	~MPT3_DIAG_BUFFER_IS_DIAG_RESET;
2299	ioc_err(ioc, "%s: buffer_type(0x%02x) was released due to host reset\n",
2300	__func__, buffer_type);
2301	return 0;
2302	}
2303
2304	rc = mpt3sas_send_diag_release(ioc, buffer_type, issue_reset: &issue_reset);
2305
2306	if (issue_reset)
2307	mpt3sas_base_hard_reset_handler(ioc, type: FORCE_BIG_HAMMER);
2308
2309	return rc;
2310	}
2311
2312	/**
2313	* _ctl_diag_read_buffer - request for copy of the diag buffer
2314	* @ioc: per adapter object
2315	* @arg: user space buffer containing ioctl content
2316	*/
2317	static long
2318	_ctl_diag_read_buffer(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
2319	{
2320	struct mpt3_diag_read_buffer karg;
2321	struct mpt3_diag_read_buffer __user *uarg = arg;
2322	void *request_data, *diag_data;
2323	Mpi2DiagBufferPostRequest_t *mpi_request;
2324	Mpi2DiagBufferPostReply_t *mpi_reply;
2325	int rc, i;
2326	u8 buffer_type;
2327	unsigned long request_size, copy_size;
2328	u16 smid;
2329	u16 ioc_status;
2330	u8 issue_reset = 0;
2331
2332	if (copy_from_user(to: &karg, from: arg, n: sizeof(karg))) {
2333	pr_err("failure at %s:%d/%s()!\n",
2334	__FILE__, __LINE__, __func__);
2335	return -EFAULT;
2336	}
2337
2338	dctlprintk(ioc, ioc_info(ioc, "%s\n",
2339	__func__));
2340
2341	buffer_type = _ctl_diag_get_bufftype(ioc, unique_id: karg.unique_id);
2342	if (buffer_type == MPT3_DIAG_UID_NOT_FOUND) {
2343	ioc_err(ioc, "%s: buffer with unique_id(0x%08x) not found\n",
2344	__func__, karg.unique_id);
2345	return -EINVAL;
2346	}
2347
2348	if (!_ctl_diag_capability(ioc, buffer_type)) {
2349	ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n",
2350	__func__, buffer_type);
2351	return -EPERM;
2352	}
2353
2354	if (karg.unique_id != ioc->unique_id[buffer_type]) {
2355	ioc_err(ioc, "%s: unique_id(0x%08x) is not registered\n",
2356	__func__, karg.unique_id);
2357	return -EINVAL;
2358	}
2359
2360	request_data = ioc->diag_buffer[buffer_type];
2361	if (!request_data) {
2362	ioc_err(ioc, "%s: doesn't have buffer for buffer_type(0x%02x)\n",
2363	__func__, buffer_type);
2364	return -ENOMEM;
2365	}
2366
2367	request_size = ioc->diag_buffer_sz[buffer_type];
2368
2369	if ((karg.starting_offset % 4) || (karg.bytes_to_read % 4)) {
2370	ioc_err(ioc, "%s: either the starting_offset or bytes_to_read are not 4 byte aligned\n",
2371	__func__);
2372	return -EINVAL;
2373	}
2374
2375	if (karg.starting_offset > request_size)
2376	return -EINVAL;
2377
2378	diag_data = (void *)(request_data + karg.starting_offset);
2379	dctlprintk(ioc,
2380	ioc_info(ioc, "%s: diag_buffer(%p), offset(%d), sz(%d)\n",
2381	__func__, diag_data, karg.starting_offset,
2382	karg.bytes_to_read));
2383
2384	/* Truncate data on requests that are too large */
2385	if ((diag_data + karg.bytes_to_read < diag_data) ||
2386	(diag_data + karg.bytes_to_read > request_data + request_size))
2387	copy_size = request_size - karg.starting_offset;
2388	else
2389	copy_size = karg.bytes_to_read;
2390
2391	if (copy_to_user(to: (void __user *)uarg->diagnostic_data,
2392	from: diag_data, n: copy_size)) {
2393	ioc_err(ioc, "%s: Unable to write mpt_diag_read_buffer_t data @ %p\n",
2394	__func__, diag_data);
2395	return -EFAULT;
2396	}
2397
2398	if ((karg.flags & MPT3_FLAGS_REREGISTER) == 0)
2399	return 0;
2400
2401	dctlprintk(ioc,
2402	ioc_info(ioc, "%s: Reregister buffer_type(0x%02x)\n",
2403	__func__, buffer_type));
2404	if ((ioc->diag_buffer_status[buffer_type] &
2405	MPT3_DIAG_BUFFER_IS_RELEASED) == 0) {
2406	dctlprintk(ioc,
2407	ioc_info(ioc, "%s: buffer_type(0x%02x) is still registered\n",
2408	__func__, buffer_type));
2409	return 0;
2410	}
2411	/* Get a free request frame and save the message context.
2412	*/
2413
2414	if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) {
2415	ioc_err(ioc, "%s: ctl_cmd in use\n", __func__);
2416	rc = -EAGAIN;
2417	goto out;
2418	}
2419
2420	smid = mpt3sas_base_get_smid(ioc, cb_idx: ioc->ctl_cb_idx);
2421	if (!smid) {
2422	ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
2423	rc = -EAGAIN;
2424	goto out;
2425	}
2426
2427	rc = 0;
2428	ioc->ctl_cmds.status = MPT3_CMD_PENDING;
2429	memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
2430	mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
2431	memset(mpi_request, 0, ioc->request_sz);
2432	ioc->ctl_cmds.smid = smid;
2433
2434	mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST;
2435	mpi_request->BufferType = buffer_type;
2436	mpi_request->BufferLength =
2437	cpu_to_le32(ioc->diag_buffer_sz[buffer_type]);
2438	mpi_request->BufferAddress =
2439	cpu_to_le64(ioc->diag_buffer_dma[buffer_type]);
2440	for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++)
2441	mpi_request->ProductSpecific[i] =
2442	cpu_to_le32(ioc->product_specific[buffer_type][i]);
2443	mpi_request->VF_ID = 0; /* TODO */
2444	mpi_request->VP_ID = 0;
2445
2446	init_completion(x: &ioc->ctl_cmds.done);
2447	ioc->put_smid_default(ioc, smid);
2448	wait_for_completion_timeout(x: &ioc->ctl_cmds.done,
2449	MPT3_IOCTL_DEFAULT_TIMEOUT*HZ);
2450
2451	if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) {
2452	mpt3sas_check_cmd_timeout(ioc,
2453	ioc->ctl_cmds.status, mpi_request,
2454	sizeof(Mpi2DiagBufferPostRequest_t)/4, issue_reset);
2455	goto issue_host_reset;
2456	}
2457
2458	/* process the completed Reply Message Frame */
2459	if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) {
2460	ioc_err(ioc, "%s: no reply message\n", __func__);
2461	rc = -EFAULT;
2462	goto out;
2463	}
2464
2465	mpi_reply = ioc->ctl_cmds.reply;
2466	ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
2467
2468	if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
2469	ioc->diag_buffer_status[buffer_type] |=
2470	MPT3_DIAG_BUFFER_IS_REGISTERED;
2471	ioc->diag_buffer_status[buffer_type] &=
2472	~MPT3_DIAG_BUFFER_IS_RELEASED;
2473	dctlprintk(ioc, ioc_info(ioc, "%s: success\n", __func__));
2474	} else {
2475	ioc_info(ioc, "%s: ioc_status(0x%04x) log_info(0x%08x)\n",
2476	__func__, ioc_status,
2477	le32_to_cpu(mpi_reply->IOCLogInfo));
2478	rc = -EFAULT;
2479	}
2480
2481	issue_host_reset:
2482	if (issue_reset)
2483	mpt3sas_base_hard_reset_handler(ioc, type: FORCE_BIG_HAMMER);
2484
2485	out:
2486
2487	ioc->ctl_cmds.status = MPT3_CMD_NOT_USED;
2488	return rc;
2489	}
2490
2491	/**
2492	* _ctl_addnl_diag_query - query relevant info associated with diag buffers
2493	* @ioc: per adapter object
2494	* @arg: user space buffer containing ioctl content
2495	*
2496	* The application will send only unique_id. Driver will
2497	* inspect unique_id first, if valid, fill the details related to cause
2498	* for diag buffer release.
2499	*/
2500	static long
2501	_ctl_addnl_diag_query(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
2502	{
2503	struct mpt3_addnl_diag_query karg;
2504	u32 buffer_type = 0;
2505
2506	if (copy_from_user(to: &karg, from: arg, n: sizeof(karg))) {
2507	pr_err("%s: failure at %s:%d/%s()!\n",
2508	ioc->name, __FILE__, __LINE__, __func__);
2509	return -EFAULT;
2510	}
2511	dctlprintk(ioc, ioc_info(ioc, "%s\n", __func__));
2512	if (karg.unique_id == 0) {
2513	ioc_err(ioc, "%s: unique_id is(0x%08x)\n",
2514	__func__, karg.unique_id);
2515	return -EPERM;
2516	}
2517	buffer_type = _ctl_diag_get_bufftype(ioc, unique_id: karg.unique_id);
2518	if (buffer_type == MPT3_DIAG_UID_NOT_FOUND) {
2519	ioc_err(ioc, "%s: buffer with unique_id(0x%08x) not found\n",
2520	__func__, karg.unique_id);
2521	return -EPERM;
2522	}
2523	memset(&karg.rel_query, 0, sizeof(karg.rel_query));
2524	if ((ioc->diag_buffer_status[buffer_type] &
2525	MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
2526	ioc_info(ioc, "%s: buffer_type(0x%02x) is not registered\n",
2527	__func__, buffer_type);
2528	goto out;
2529	}
2530	if ((ioc->diag_buffer_status[buffer_type] &
2531	MPT3_DIAG_BUFFER_IS_RELEASED) == 0) {
2532	ioc_err(ioc, "%s: buffer_type(0x%02x) is not released\n",
2533	__func__, buffer_type);
2534	return -EPERM;
2535	}
2536	memcpy(&karg.rel_query, &ioc->htb_rel, sizeof(karg.rel_query));
2537	out:
2538	if (copy_to_user(to: arg, from: &karg, n: sizeof(struct mpt3_addnl_diag_query))) {
2539	ioc_err(ioc, "%s: unable to write mpt3_addnl_diag_query data @ %p\n",
2540	__func__, arg);
2541	return -EFAULT;
2542	}
2543	return 0;
2544	}
2545
2546	#ifdef CONFIG_COMPAT
2547	/**
2548	* _ctl_compat_mpt_command - convert 32bit pointers to 64bit.
2549	* @ioc: per adapter object
2550	* @cmd: ioctl opcode
2551	* @arg: (struct mpt3_ioctl_command32)
2552	*
2553	* MPT3COMMAND32 - Handle 32bit applications running on 64bit os.
2554	*/
2555	static long
2556	_ctl_compat_mpt_command(struct MPT3SAS_ADAPTER *ioc, unsigned cmd,
2557	void __user *arg)
2558	{
2559	struct mpt3_ioctl_command32 karg32;
2560	struct mpt3_ioctl_command32 __user *uarg;
2561	struct mpt3_ioctl_command karg;
2562
2563	if (_IOC_SIZE(cmd) != sizeof(struct mpt3_ioctl_command32))
2564	return -EINVAL;
2565
2566	uarg = (struct mpt3_ioctl_command32 __user *) arg;
2567
2568	if (copy_from_user(to: &karg32, from: (char __user *)arg, n: sizeof(karg32))) {
2569	pr_err("failure at %s:%d/%s()!\n",
2570	__FILE__, __LINE__, __func__);
2571	return -EFAULT;
2572	}
2573
2574	memset(&karg, 0, sizeof(struct mpt3_ioctl_command));
2575	karg.hdr.ioc_number = karg32.hdr.ioc_number;
2576	karg.hdr.port_number = karg32.hdr.port_number;
2577	karg.hdr.max_data_size = karg32.hdr.max_data_size;
2578	karg.timeout = karg32.timeout;
2579	karg.max_reply_bytes = karg32.max_reply_bytes;
2580	karg.data_in_size = karg32.data_in_size;
2581	karg.data_out_size = karg32.data_out_size;
2582	karg.max_sense_bytes = karg32.max_sense_bytes;
2583	karg.data_sge_offset = karg32.data_sge_offset;
2584	karg.reply_frame_buf_ptr = compat_ptr(uptr: karg32.reply_frame_buf_ptr);
2585	karg.data_in_buf_ptr = compat_ptr(uptr: karg32.data_in_buf_ptr);
2586	karg.data_out_buf_ptr = compat_ptr(uptr: karg32.data_out_buf_ptr);
2587	karg.sense_data_ptr = compat_ptr(uptr: karg32.sense_data_ptr);
2588	return _ctl_do_mpt_command(ioc, karg, mf: &uarg->mf);
2589	}
2590	#endif
2591
2592	/**
2593	* _ctl_ioctl_main - main ioctl entry point
2594	* @file: (struct file)
2595	* @cmd: ioctl opcode
2596	* @arg: user space data buffer
2597	* @compat: handles 32 bit applications in 64bit os
2598	* @mpi_version: will be MPI2_VERSION for mpt2ctl ioctl device &
2599	* MPI25_VERSION | MPI26_VERSION for mpt3ctl ioctl device.
2600	*/
2601	static long
2602	_ctl_ioctl_main(struct file *file, unsigned int cmd, void __user *arg,
2603	u8 compat, u16 mpi_version)
2604	{
2605	struct MPT3SAS_ADAPTER *ioc;
2606	struct mpt3_ioctl_header ioctl_header;
2607	enum block_state state;
2608	long ret = -ENOIOCTLCMD;
2609
2610	/* get IOCTL header */
2611	if (copy_from_user(to: &ioctl_header, from: (char __user *)arg,
2612	n: sizeof(struct mpt3_ioctl_header))) {
2613	pr_err("failure at %s:%d/%s()!\n",
2614	__FILE__, __LINE__, __func__);
2615	return -EFAULT;
2616	}
2617
2618	if (_ctl_verify_adapter(ioc_number: ioctl_header.ioc_number,
2619	iocpp: &ioc, mpi_version) == -1 || !ioc)
2620	return -ENODEV;
2621
2622	/* pci_access_mutex lock acquired by ioctl path */
2623	mutex_lock(&ioc->pci_access_mutex);
2624
2625	if (ioc->shost_recovery || ioc->pci_error_recovery ||
2626	ioc->is_driver_loading || ioc->remove_host) {
2627	ret = -EAGAIN;
2628	goto out_unlock_pciaccess;
2629	}
2630
2631	state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : BLOCKING;
2632	if (state == NON_BLOCKING) {
2633	if (!mutex_trylock(lock: &ioc->ctl_cmds.mutex)) {
2634	ret = -EAGAIN;
2635	goto out_unlock_pciaccess;
2636	}
2637	} else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex)) {
2638	ret = -ERESTARTSYS;
2639	goto out_unlock_pciaccess;
2640	}
2641
2642
2643	switch (cmd) {
2644	case MPT3IOCINFO:
2645	if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_iocinfo))
2646	ret = _ctl_getiocinfo(ioc, arg);
2647	break;
2648	#ifdef CONFIG_COMPAT
2649	case MPT3COMMAND32:
2650	#endif
2651	case MPT3COMMAND:
2652	{
2653	struct mpt3_ioctl_command __user *uarg;
2654	struct mpt3_ioctl_command karg;
2655
2656	#ifdef CONFIG_COMPAT
2657	if (compat) {
2658	ret = _ctl_compat_mpt_command(ioc, cmd, arg);
2659	break;
2660	}
2661	#endif
2662	if (copy_from_user(to: &karg, from: arg, n: sizeof(karg))) {
2663	pr_err("failure at %s:%d/%s()!\n",
2664	__FILE__, __LINE__, __func__);
2665	ret = -EFAULT;
2666	break;
2667	}
2668
2669	if (karg.hdr.ioc_number != ioctl_header.ioc_number) {
2670	ret = -EINVAL;
2671	break;
2672	}
2673	if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_command)) {
2674	uarg = arg;
2675	ret = _ctl_do_mpt_command(ioc, karg, mf: &uarg->mf);
2676	}
2677	break;
2678	}
2679	case MPT3EVENTQUERY:
2680	if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_eventquery))
2681	ret = _ctl_eventquery(ioc, arg);
2682	break;
2683	case MPT3EVENTENABLE:
2684	if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_eventenable))
2685	ret = _ctl_eventenable(ioc, arg);
2686	break;
2687	case MPT3EVENTREPORT:
2688	ret = _ctl_eventreport(ioc, arg);
2689	break;
2690	case MPT3HARDRESET:
2691	if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_diag_reset))
2692	ret = _ctl_do_reset(ioc, arg);
2693	break;
2694	case MPT3BTDHMAPPING:
2695	if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_btdh_mapping))
2696	ret = _ctl_btdh_mapping(ioc, arg);
2697	break;
2698	case MPT3DIAGREGISTER:
2699	if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_register))
2700	ret = _ctl_diag_register(ioc, arg);
2701	break;
2702	case MPT3DIAGUNREGISTER:
2703	if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_unregister))
2704	ret = _ctl_diag_unregister(ioc, arg);
2705	break;
2706	case MPT3DIAGQUERY:
2707	if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_query))
2708	ret = _ctl_diag_query(ioc, arg);
2709	break;
2710	case MPT3DIAGRELEASE:
2711	if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_release))
2712	ret = _ctl_diag_release(ioc, arg);
2713	break;
2714	case MPT3DIAGREADBUFFER:
2715	if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_read_buffer))
2716	ret = _ctl_diag_read_buffer(ioc, arg);
2717	break;
2718	case MPT3ADDNLDIAGQUERY:
2719	if (_IOC_SIZE(cmd) == sizeof(struct mpt3_addnl_diag_query))
2720	ret = _ctl_addnl_diag_query(ioc, arg);
2721	break;
2722	default:
2723	dctlprintk(ioc,
2724	ioc_info(ioc, "unsupported ioctl opcode(0x%08x)\n",
2725	cmd));
2726	break;
2727	}
2728
2729	mutex_unlock(lock: &ioc->ctl_cmds.mutex);
2730	out_unlock_pciaccess:
2731	mutex_unlock(lock: &ioc->pci_access_mutex);
2732	return ret;
2733	}
2734
2735	/**
2736	* _ctl_ioctl - mpt3ctl main ioctl entry point (unlocked)
2737	* @file: (struct file)
2738	* @cmd: ioctl opcode
2739	* @arg: ?
2740	*/
2741	static long
2742	_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2743	{
2744	long ret;
2745
2746	/* pass MPI25_VERSION | MPI26_VERSION value,
2747	* to indicate that this ioctl cmd
2748	* came from mpt3ctl ioctl device.
2749	*/
2750	ret = _ctl_ioctl_main(file, cmd, arg: (void __user *)arg, compat: 0,
2751	MPI25_VERSION | MPI26_VERSION);
2752	return ret;
2753	}
2754
2755	/**
2756	* _ctl_mpt2_ioctl - mpt2ctl main ioctl entry point (unlocked)
2757	* @file: (struct file)
2758	* @cmd: ioctl opcode
2759	* @arg: ?
2760	*/
2761	static long
2762	_ctl_mpt2_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2763	{
2764	long ret;
2765
2766	/* pass MPI2_VERSION value, to indicate that this ioctl cmd
2767	* came from mpt2ctl ioctl device.
2768	*/
2769	ret = _ctl_ioctl_main(file, cmd, arg: (void __user *)arg, compat: 0, MPI2_VERSION);
2770	return ret;
2771	}
2772	#ifdef CONFIG_COMPAT
2773	/**
2774	* _ctl_ioctl_compat - main ioctl entry point (compat)
2775	* @file: ?
2776	* @cmd: ?
2777	* @arg: ?
2778	*
2779	* This routine handles 32 bit applications in 64bit os.
2780	*/
2781	static long
2782	_ctl_ioctl_compat(struct file *file, unsigned cmd, unsigned long arg)
2783	{
2784	long ret;
2785
2786	ret = _ctl_ioctl_main(file, cmd, arg: (void __user *)arg, compat: 1,
2787	MPI25_VERSION | MPI26_VERSION);
2788	return ret;
2789	}
2790
2791	/**
2792	* _ctl_mpt2_ioctl_compat - main ioctl entry point (compat)
2793	* @file: ?
2794	* @cmd: ?
2795	* @arg: ?
2796	*
2797	* This routine handles 32 bit applications in 64bit os.
2798	*/
2799	static long
2800	_ctl_mpt2_ioctl_compat(struct file *file, unsigned cmd, unsigned long arg)
2801	{
2802	long ret;
2803
2804	ret = _ctl_ioctl_main(file, cmd, arg: (void __user *)arg, compat: 1, MPI2_VERSION);
2805	return ret;
2806	}
2807	#endif
2808
2809	/* scsi host attributes */
2810	/**
2811	* version_fw_show - firmware version
2812	* @cdev: pointer to embedded class device
2813	* @attr: ?
2814	* @buf: the buffer returned
2815	*
2816	* A sysfs 'read-only' shost attribute.
2817	*/
2818	static ssize_t
2819	version_fw_show(struct device *cdev, struct device_attribute *attr,
2820	char *buf)
2821	{
2822	struct Scsi_Host *shost = class_to_shost(cdev);
2823	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2824
2825	return snprintf(buf, PAGE_SIZE, fmt: "%02d.%02d.%02d.%02d\n",
2826	(ioc->facts.FWVersion.Word & 0xFF000000) >> 24,
2827	(ioc->facts.FWVersion.Word & 0x00FF0000) >> 16,
2828	(ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
2829	ioc->facts.FWVersion.Word & 0x000000FF);
2830	}
2831	static DEVICE_ATTR_RO(version_fw);
2832
2833	/**
2834	* version_bios_show - bios version
2835	* @cdev: pointer to embedded class device
2836	* @attr: ?
2837	* @buf: the buffer returned
2838	*
2839	* A sysfs 'read-only' shost attribute.
2840	*/
2841	static ssize_t
2842	version_bios_show(struct device *cdev, struct device_attribute *attr,
2843	char *buf)
2844	{
2845	struct Scsi_Host *shost = class_to_shost(cdev);
2846	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2847
2848	u32 version = le32_to_cpu(ioc->bios_pg3.BiosVersion);
2849
2850	return snprintf(buf, PAGE_SIZE, fmt: "%02d.%02d.%02d.%02d\n",
2851	(version & 0xFF000000) >> 24,
2852	(version & 0x00FF0000) >> 16,
2853	(version & 0x0000FF00) >> 8,
2854	version & 0x000000FF);
2855	}
2856	static DEVICE_ATTR_RO(version_bios);
2857
2858	/**
2859	* version_mpi_show - MPI (message passing interface) version
2860	* @cdev: pointer to embedded class device
2861	* @attr: ?
2862	* @buf: the buffer returned
2863	*
2864	* A sysfs 'read-only' shost attribute.
2865	*/
2866	static ssize_t
2867	version_mpi_show(struct device *cdev, struct device_attribute *attr,
2868	char *buf)
2869	{
2870	struct Scsi_Host *shost = class_to_shost(cdev);
2871	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2872
2873	return snprintf(buf, PAGE_SIZE, fmt: "%03x.%02x\n",
2874	ioc->facts.MsgVersion, ioc->facts.HeaderVersion >> 8);
2875	}
2876	static DEVICE_ATTR_RO(version_mpi);
2877
2878	/**
2879	* version_product_show - product name
2880	* @cdev: pointer to embedded class device
2881	* @attr: ?
2882	* @buf: the buffer returned
2883	*
2884	* A sysfs 'read-only' shost attribute.
2885	*/
2886	static ssize_t
2887	version_product_show(struct device *cdev, struct device_attribute *attr,
2888	char *buf)
2889	{
2890	struct Scsi_Host *shost = class_to_shost(cdev);
2891	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2892
2893	return snprintf(buf, size: 16, fmt: "%s\n", ioc->manu_pg0.ChipName);
2894	}
2895	static DEVICE_ATTR_RO(version_product);
2896
2897	/**
2898	* version_nvdata_persistent_show - ndvata persistent version
2899	* @cdev: pointer to embedded class device
2900	* @attr: ?
2901	* @buf: the buffer returned
2902	*
2903	* A sysfs 'read-only' shost attribute.
2904	*/
2905	static ssize_t
2906	version_nvdata_persistent_show(struct device *cdev,
2907	struct device_attribute *attr, char *buf)
2908	{
2909	struct Scsi_Host *shost = class_to_shost(cdev);
2910	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2911
2912	return snprintf(buf, PAGE_SIZE, fmt: "%08xh\n",
2913	le32_to_cpu(ioc->iounit_pg0.NvdataVersionPersistent.Word));
2914	}
2915	static DEVICE_ATTR_RO(version_nvdata_persistent);
2916
2917	/**
2918	* version_nvdata_default_show - nvdata default version
2919	* @cdev: pointer to embedded class device
2920	* @attr: ?
2921	* @buf: the buffer returned
2922	*
2923	* A sysfs 'read-only' shost attribute.
2924	*/
2925	static ssize_t
2926	version_nvdata_default_show(struct device *cdev, struct device_attribute
2927	*attr, char *buf)
2928	{
2929	struct Scsi_Host *shost = class_to_shost(cdev);
2930	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2931
2932	return snprintf(buf, PAGE_SIZE, fmt: "%08xh\n",
2933	le32_to_cpu(ioc->iounit_pg0.NvdataVersionDefault.Word));
2934	}
2935	static DEVICE_ATTR_RO(version_nvdata_default);
2936
2937	/**
2938	* board_name_show - board name
2939	* @cdev: pointer to embedded class device
2940	* @attr: ?
2941	* @buf: the buffer returned
2942	*
2943	* A sysfs 'read-only' shost attribute.
2944	*/
2945	static ssize_t
2946	board_name_show(struct device *cdev, struct device_attribute *attr,
2947	char *buf)
2948	{
2949	struct Scsi_Host *shost = class_to_shost(cdev);
2950	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2951
2952	return snprintf(buf, size: 16, fmt: "%s\n", ioc->manu_pg0.BoardName);
2953	}
2954	static DEVICE_ATTR_RO(board_name);
2955
2956	/**
2957	* board_assembly_show - board assembly name
2958	* @cdev: pointer to embedded class device
2959	* @attr: ?
2960	* @buf: the buffer returned
2961	*
2962	* A sysfs 'read-only' shost attribute.
2963	*/
2964	static ssize_t
2965	board_assembly_show(struct device *cdev, struct device_attribute *attr,
2966	char *buf)
2967	{
2968	struct Scsi_Host *shost = class_to_shost(cdev);
2969	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2970
2971	return snprintf(buf, size: 16, fmt: "%s\n", ioc->manu_pg0.BoardAssembly);
2972	}
2973	static DEVICE_ATTR_RO(board_assembly);
2974
2975	/**
2976	* board_tracer_show - board tracer number
2977	* @cdev: pointer to embedded class device
2978	* @attr: ?
2979	* @buf: the buffer returned
2980	*
2981	* A sysfs 'read-only' shost attribute.
2982	*/
2983	static ssize_t
2984	board_tracer_show(struct device *cdev, struct device_attribute *attr,
2985	char *buf)
2986	{
2987	struct Scsi_Host *shost = class_to_shost(cdev);
2988	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2989
2990	return snprintf(buf, size: 16, fmt: "%s\n", ioc->manu_pg0.BoardTracerNumber);
2991	}
2992	static DEVICE_ATTR_RO(board_tracer);
2993
2994	/**
2995	* io_delay_show - io missing delay
2996	* @cdev: pointer to embedded class device
2997	* @attr: ?
2998	* @buf: the buffer returned
2999	*
3000	* This is for firmware implemention for deboucing device
3001	* removal events.
3002	*
3003	* A sysfs 'read-only' shost attribute.
3004	*/
3005	static ssize_t
3006	io_delay_show(struct device *cdev, struct device_attribute *attr,
3007	char *buf)
3008	{
3009	struct Scsi_Host *shost = class_to_shost(cdev);
3010	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3011
3012	return snprintf(buf, PAGE_SIZE, fmt: "%02d\n", ioc->io_missing_delay);
3013	}
3014	static DEVICE_ATTR_RO(io_delay);
3015
3016	/**
3017	* device_delay_show - device missing delay
3018	* @cdev: pointer to embedded class device
3019	* @attr: ?
3020	* @buf: the buffer returned
3021	*
3022	* This is for firmware implemention for deboucing device
3023	* removal events.
3024	*
3025	* A sysfs 'read-only' shost attribute.
3026	*/
3027	static ssize_t
3028	device_delay_show(struct device *cdev, struct device_attribute *attr,
3029	char *buf)
3030	{
3031	struct Scsi_Host *shost = class_to_shost(cdev);
3032	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3033
3034	return snprintf(buf, PAGE_SIZE, fmt: "%02d\n", ioc->device_missing_delay);
3035	}
3036	static DEVICE_ATTR_RO(device_delay);
3037
3038	/**
3039	* fw_queue_depth_show - global credits
3040	* @cdev: pointer to embedded class device
3041	* @attr: ?
3042	* @buf: the buffer returned
3043	*
3044	* This is firmware queue depth limit
3045	*
3046	* A sysfs 'read-only' shost attribute.
3047	*/
3048	static ssize_t
3049	fw_queue_depth_show(struct device *cdev, struct device_attribute *attr,
3050	char *buf)
3051	{
3052	struct Scsi_Host *shost = class_to_shost(cdev);
3053	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3054
3055	return snprintf(buf, PAGE_SIZE, fmt: "%02d\n", ioc->facts.RequestCredit);
3056	}
3057	static DEVICE_ATTR_RO(fw_queue_depth);
3058
3059	/**
3060	* host_sas_address_show - sas address
3061	* @cdev: pointer to embedded class device
3062	* @attr: ?
3063	* @buf: the buffer returned
3064	*
3065	* This is the controller sas address
3066	*
3067	* A sysfs 'read-only' shost attribute.
3068	*/
3069	static ssize_t
3070	host_sas_address_show(struct device *cdev, struct device_attribute *attr,
3071	char *buf)
3072
3073	{
3074	struct Scsi_Host *shost = class_to_shost(cdev);
3075	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3076
3077	return snprintf(buf, PAGE_SIZE, fmt: "0x%016llx\n",
3078	(unsigned long long)ioc->sas_hba.sas_address);
3079	}
3080	static DEVICE_ATTR_RO(host_sas_address);
3081
3082	/**
3083	* logging_level_show - logging level
3084	* @cdev: pointer to embedded class device
3085	* @attr: ?
3086	* @buf: the buffer returned
3087	*
3088	* A sysfs 'read/write' shost attribute.
3089	*/
3090	static ssize_t
3091	logging_level_show(struct device *cdev, struct device_attribute *attr,
3092	char *buf)
3093	{
3094	struct Scsi_Host *shost = class_to_shost(cdev);
3095	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3096
3097	return snprintf(buf, PAGE_SIZE, fmt: "%08xh\n", ioc->logging_level);
3098	}
3099	static ssize_t
3100	logging_level_store(struct device *cdev, struct device_attribute *attr,
3101	const char *buf, size_t count)
3102	{
3103	struct Scsi_Host *shost = class_to_shost(cdev);
3104	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3105	int val = 0;
3106
3107	if (sscanf(buf, "%x", &val) != 1)
3108	return -EINVAL;
3109
3110	ioc->logging_level = val;
3111	ioc_info(ioc, "logging_level=%08xh\n",
3112	ioc->logging_level);
3113	return strlen(buf);
3114	}
3115	static DEVICE_ATTR_RW(logging_level);
3116
3117	/**
3118	* fwfault_debug_show - show/store fwfault_debug
3119	* @cdev: pointer to embedded class device
3120	* @attr: ?
3121	* @buf: the buffer returned
3122	*
3123	* mpt3sas_fwfault_debug is command line option
3124	* A sysfs 'read/write' shost attribute.
3125	*/
3126	static ssize_t
3127	fwfault_debug_show(struct device *cdev, struct device_attribute *attr,
3128	char *buf)
3129	{
3130	struct Scsi_Host *shost = class_to_shost(cdev);
3131	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3132
3133	return snprintf(buf, PAGE_SIZE, fmt: "%d\n", ioc->fwfault_debug);
3134	}
3135	static ssize_t
3136	fwfault_debug_store(struct device *cdev, struct device_attribute *attr,
3137	const char *buf, size_t count)
3138	{
3139	struct Scsi_Host *shost = class_to_shost(cdev);
3140	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3141	int val = 0;
3142
3143	if (sscanf(buf, "%d", &val) != 1)
3144	return -EINVAL;
3145
3146	ioc->fwfault_debug = val;
3147	ioc_info(ioc, "fwfault_debug=%d\n",
3148	ioc->fwfault_debug);
3149	return strlen(buf);
3150	}
3151	static DEVICE_ATTR_RW(fwfault_debug);
3152
3153	/**
3154	* ioc_reset_count_show - ioc reset count
3155	* @cdev: pointer to embedded class device
3156	* @attr: ?
3157	* @buf: the buffer returned
3158	*
3159	* This is firmware queue depth limit
3160	*
3161	* A sysfs 'read-only' shost attribute.
3162	*/
3163	static ssize_t
3164	ioc_reset_count_show(struct device *cdev, struct device_attribute *attr,
3165	char *buf)
3166	{
3167	struct Scsi_Host *shost = class_to_shost(cdev);
3168	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3169
3170	return snprintf(buf, PAGE_SIZE, fmt: "%d\n", ioc->ioc_reset_count);
3171	}
3172	static DEVICE_ATTR_RO(ioc_reset_count);
3173
3174	/**
3175	* reply_queue_count_show - number of reply queues
3176	* @cdev: pointer to embedded class device
3177	* @attr: ?
3178	* @buf: the buffer returned
3179	*
3180	* This is number of reply queues
3181	*
3182	* A sysfs 'read-only' shost attribute.
3183	*/
3184	static ssize_t
3185	reply_queue_count_show(struct device *cdev,
3186	struct device_attribute *attr, char *buf)
3187	{
3188	u8 reply_queue_count;
3189	struct Scsi_Host *shost = class_to_shost(cdev);
3190	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3191
3192	if ((ioc->facts.IOCCapabilities &
3193	MPI2_IOCFACTS_CAPABILITY_MSI_X_INDEX) && ioc->msix_enable)
3194	reply_queue_count = ioc->reply_queue_count;
3195	else
3196	reply_queue_count = 1;
3197
3198	return snprintf(buf, PAGE_SIZE, fmt: "%d\n", reply_queue_count);
3199	}
3200	static DEVICE_ATTR_RO(reply_queue_count);
3201
3202	/**
3203	* BRM_status_show - Backup Rail Monitor Status
3204	* @cdev: pointer to embedded class device
3205	* @attr: ?
3206	* @buf: the buffer returned
3207	*
3208	* This is number of reply queues
3209	*
3210	* A sysfs 'read-only' shost attribute.
3211	*/
3212	static ssize_t
3213	BRM_status_show(struct device *cdev, struct device_attribute *attr,
3214	char *buf)
3215	{
3216	struct Scsi_Host *shost = class_to_shost(cdev);
3217	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3218	Mpi2IOUnitPage3_t io_unit_pg3;
3219	Mpi2ConfigReply_t mpi_reply;
3220	u16 backup_rail_monitor_status = 0;
3221	u16 ioc_status;
3222	int sz;
3223	ssize_t rc = 0;
3224
3225	if (!ioc->is_warpdrive) {
3226	ioc_err(ioc, "%s: BRM attribute is only for warpdrive\n",
3227	__func__);
3228	return 0;
3229	}
3230	/* pci_access_mutex lock acquired by sysfs show path */
3231	mutex_lock(&ioc->pci_access_mutex);
3232	if (ioc->pci_error_recovery || ioc->remove_host)
3233	goto out;
3234
3235	sz = sizeof(io_unit_pg3);
3236	memset(&io_unit_pg3, 0, sz);
3237
3238	if (mpt3sas_config_get_iounit_pg3(ioc, mpi_reply: &mpi_reply, config_page: &io_unit_pg3, sz) !=
3239	0) {
3240	ioc_err(ioc, "%s: failed reading iounit_pg3\n",
3241	__func__);
3242	rc = -EINVAL;
3243	goto out;
3244	}
3245
3246	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
3247	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
3248	ioc_err(ioc, "%s: iounit_pg3 failed with ioc_status(0x%04x)\n",
3249	__func__, ioc_status);
3250	rc = -EINVAL;
3251	goto out;
3252	}
3253
3254	if (io_unit_pg3.GPIOCount < 25) {
3255	ioc_err(ioc, "%s: iounit_pg3.GPIOCount less than 25 entries, detected (%d) entries\n",
3256	__func__, io_unit_pg3.GPIOCount);
3257	rc = -EINVAL;
3258	goto out;
3259	}
3260
3261	/* BRM status is in bit zero of GPIOVal[24] */
3262	backup_rail_monitor_status = le16_to_cpu(io_unit_pg3.GPIOVal[24]);
3263	rc = snprintf(buf, PAGE_SIZE, fmt: "%d\n", (backup_rail_monitor_status & 1));
3264
3265	out:
3266	mutex_unlock(lock: &ioc->pci_access_mutex);
3267	return rc;
3268	}
3269	static DEVICE_ATTR_RO(BRM_status);
3270
3271	struct DIAG_BUFFER_START {
3272	__le32 Size;
3273	__le32 DiagVersion;
3274	u8 BufferType;
3275	u8 Reserved[3];
3276	__le32 Reserved1;
3277	__le32 Reserved2;
3278	__le32 Reserved3;
3279	};
3280
3281	/**
3282	* host_trace_buffer_size_show - host buffer size (trace only)
3283	* @cdev: pointer to embedded class device
3284	* @attr: ?
3285	* @buf: the buffer returned
3286	*
3287	* A sysfs 'read-only' shost attribute.
3288	*/
3289	static ssize_t
3290	host_trace_buffer_size_show(struct device *cdev,
3291	struct device_attribute *attr, char *buf)
3292	{
3293	struct Scsi_Host *shost = class_to_shost(cdev);
3294	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3295	u32 size = 0;
3296	struct DIAG_BUFFER_START *request_data;
3297
3298	if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) {
3299	ioc_err(ioc, "%s: host_trace_buffer is not registered\n",
3300	__func__);
3301	return 0;
3302	}
3303
3304	if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
3305	MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
3306	ioc_err(ioc, "%s: host_trace_buffer is not registered\n",
3307	__func__);
3308	return 0;
3309	}
3310
3311	request_data = (struct DIAG_BUFFER_START *)
3312	ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE];
3313	if ((le32_to_cpu(request_data->DiagVersion) == 0x00000000 ||
3314	le32_to_cpu(request_data->DiagVersion) == 0x01000000 ||
3315	le32_to_cpu(request_data->DiagVersion) == 0x01010000) &&
3316	le32_to_cpu(request_data->Reserved3) == 0x4742444c)
3317	size = le32_to_cpu(request_data->Size);
3318
3319	ioc->ring_buffer_sz = size;
3320	return snprintf(buf, PAGE_SIZE, fmt: "%d\n", size);
3321	}
3322	static DEVICE_ATTR_RO(host_trace_buffer_size);
3323
3324	/**
3325	* host_trace_buffer_show - firmware ring buffer (trace only)
3326	* @cdev: pointer to embedded class device
3327	* @attr: ?
3328	* @buf: the buffer returned
3329	*
3330	* A sysfs 'read/write' shost attribute.
3331	*
3332	* You will only be able to read 4k bytes of ring buffer at a time.
3333	* In order to read beyond 4k bytes, you will have to write out the
3334	* offset to the same attribute, it will move the pointer.
3335	*/
3336	static ssize_t
3337	host_trace_buffer_show(struct device *cdev, struct device_attribute *attr,
3338	char *buf)
3339	{
3340	struct Scsi_Host *shost = class_to_shost(cdev);
3341	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3342	void *request_data;
3343	u32 size;
3344
3345	if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) {
3346	ioc_err(ioc, "%s: host_trace_buffer is not registered\n",
3347	__func__);
3348	return 0;
3349	}
3350
3351	if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
3352	MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
3353	ioc_err(ioc, "%s: host_trace_buffer is not registered\n",
3354	__func__);
3355	return 0;
3356	}
3357
3358	if (ioc->ring_buffer_offset > ioc->ring_buffer_sz)
3359	return 0;
3360
3361	size = ioc->ring_buffer_sz - ioc->ring_buffer_offset;
3362	size = (size >= PAGE_SIZE) ? (PAGE_SIZE - 1) : size;
3363	request_data = ioc->diag_buffer[0] + ioc->ring_buffer_offset;
3364	memcpy(buf, request_data, size);
3365	return size;
3366	}
3367
3368	static ssize_t
3369	host_trace_buffer_store(struct device *cdev, struct device_attribute *attr,
3370	const char *buf, size_t count)
3371	{
3372	struct Scsi_Host *shost = class_to_shost(cdev);
3373	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3374	int val = 0;
3375
3376	if (sscanf(buf, "%d", &val) != 1)
3377	return -EINVAL;
3378
3379	ioc->ring_buffer_offset = val;
3380	return strlen(buf);
3381	}
3382	static DEVICE_ATTR_RW(host_trace_buffer);
3383
3384
3385	/*****************************************/
3386
3387	/**
3388	* host_trace_buffer_enable_show - firmware ring buffer (trace only)
3389	* @cdev: pointer to embedded class device
3390	* @attr: ?
3391	* @buf: the buffer returned
3392	*
3393	* A sysfs 'read/write' shost attribute.
3394	*
3395	* This is a mechnism to post/release host_trace_buffers
3396	*/
3397	static ssize_t
3398	host_trace_buffer_enable_show(struct device *cdev,
3399	struct device_attribute *attr, char *buf)
3400	{
3401	struct Scsi_Host *shost = class_to_shost(cdev);
3402	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3403
3404	if ((!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) ||
3405	((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
3406	MPT3_DIAG_BUFFER_IS_REGISTERED) == 0))
3407	return snprintf(buf, PAGE_SIZE, fmt: "off\n");
3408	else if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
3409	MPT3_DIAG_BUFFER_IS_RELEASED))
3410	return snprintf(buf, PAGE_SIZE, fmt: "release\n");
3411	else
3412	return snprintf(buf, PAGE_SIZE, fmt: "post\n");
3413	}
3414
3415	static ssize_t
3416	host_trace_buffer_enable_store(struct device *cdev,
3417	struct device_attribute *attr, const char *buf, size_t count)
3418	{
3419	struct Scsi_Host *shost = class_to_shost(cdev);
3420	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3421	char str[10] = "";
3422	struct mpt3_diag_register diag_register;
3423	u8 issue_reset = 0;
3424
3425	/* don't allow post/release occurr while recovery is active */
3426	if (ioc->shost_recovery || ioc->remove_host ||
3427	ioc->pci_error_recovery || ioc->is_driver_loading)
3428	return -EBUSY;
3429
3430	if (sscanf(buf, "%9s", str) != 1)
3431	return -EINVAL;
3432
3433	if (!strcmp(str, "post")) {
3434	/* exit out if host buffers are already posted */
3435	if ((ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) &&
3436	(ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
3437	MPT3_DIAG_BUFFER_IS_REGISTERED) &&
3438	((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
3439	MPT3_DIAG_BUFFER_IS_RELEASED) == 0))
3440	goto out;
3441	memset(&diag_register, 0, sizeof(struct mpt3_diag_register));
3442	ioc_info(ioc, "posting host trace buffers\n");
3443	diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE;
3444
3445	if (ioc->manu_pg11.HostTraceBufferMaxSizeKB != 0 &&
3446	ioc->diag_buffer_sz[MPI2_DIAG_BUF_TYPE_TRACE] != 0) {
3447	/* post the same buffer allocated previously */
3448	diag_register.requested_buffer_size =
3449	ioc->diag_buffer_sz[MPI2_DIAG_BUF_TYPE_TRACE];
3450	} else {
3451	/*
3452	* Free the diag buffer memory which was previously
3453	* allocated by an application.
3454	*/
3455	if ((ioc->diag_buffer_sz[MPI2_DIAG_BUF_TYPE_TRACE] != 0)
3456	&&
3457	(ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
3458	MPT3_DIAG_BUFFER_IS_APP_OWNED)) {
3459	dma_free_coherent(dev: &ioc->pdev->dev,
3460	size: ioc->diag_buffer_sz[MPI2_DIAG_BUF_TYPE_TRACE],
3461	cpu_addr: ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE],
3462	dma_handle: ioc->diag_buffer_dma[MPI2_DIAG_BUF_TYPE_TRACE]);
3463	ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE] =
3464	NULL;
3465	}
3466
3467	diag_register.requested_buffer_size = (1024 * 1024);
3468	}
3469
3470	diag_register.unique_id =
3471	(ioc->hba_mpi_version_belonged == MPI2_VERSION) ?
3472	(MPT2DIAGBUFFUNIQUEID):(MPT3DIAGBUFFUNIQUEID);
3473	ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] = 0;
3474	_ctl_diag_register_2(ioc, diag_register: &diag_register);
3475	if (ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
3476	MPT3_DIAG_BUFFER_IS_REGISTERED) {
3477	ioc_info(ioc,
3478	"Trace buffer %d KB allocated through sysfs\n",
3479	diag_register.requested_buffer_size>>10);
3480	if (ioc->hba_mpi_version_belonged != MPI2_VERSION)
3481	ioc->diag_buffer_status[
3482	MPI2_DIAG_BUF_TYPE_TRACE] |=
3483	MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED;
3484	}
3485	} else if (!strcmp(str, "release")) {
3486	/* exit out if host buffers are already released */
3487	if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE])
3488	goto out;
3489	if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
3490	MPT3_DIAG_BUFFER_IS_REGISTERED) == 0)
3491	goto out;
3492	if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
3493	MPT3_DIAG_BUFFER_IS_RELEASED))
3494	goto out;
3495	ioc_info(ioc, "releasing host trace buffer\n");
3496	ioc->htb_rel.buffer_rel_condition = MPT3_DIAG_BUFFER_REL_SYSFS;
3497	mpt3sas_send_diag_release(ioc, MPI2_DIAG_BUF_TYPE_TRACE,
3498	issue_reset: &issue_reset);
3499	}
3500
3501	out:
3502	return strlen(buf);
3503	}
3504	static DEVICE_ATTR_RW(host_trace_buffer_enable);
3505
3506	/*********** diagnostic trigger suppport *********************************/
3507
3508	/**
3509	* diag_trigger_master_show - show the diag_trigger_master attribute
3510	* @cdev: pointer to embedded class device
3511	* @attr: ?
3512	* @buf: the buffer returned
3513	*
3514	* A sysfs 'read/write' shost attribute.
3515	*/
3516	static ssize_t
3517	diag_trigger_master_show(struct device *cdev,
3518	struct device_attribute *attr, char *buf)
3519
3520	{
3521	struct Scsi_Host *shost = class_to_shost(cdev);
3522	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3523	unsigned long flags;
3524	ssize_t rc;
3525
3526	spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
3527	rc = sizeof(struct SL_WH_MASTER_TRIGGER_T);
3528	memcpy(buf, &ioc->diag_trigger_master, rc);
3529	spin_unlock_irqrestore(lock: &ioc->diag_trigger_lock, flags);
3530	return rc;
3531	}
3532
3533	/**
3534	* diag_trigger_master_store - store the diag_trigger_master attribute
3535	* @cdev: pointer to embedded class device
3536	* @attr: ?
3537	* @buf: the buffer returned
3538	* @count: ?
3539	*
3540	* A sysfs 'read/write' shost attribute.
3541	*/
3542	static ssize_t
3543	diag_trigger_master_store(struct device *cdev,
3544	struct device_attribute *attr, const char *buf, size_t count)
3545
3546	{
3547	struct Scsi_Host *shost = class_to_shost(cdev);
3548	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3549	struct SL_WH_MASTER_TRIGGER_T *master_tg;
3550	unsigned long flags;
3551	ssize_t rc;
3552	bool set = 1;
3553
3554	rc = min(sizeof(struct SL_WH_MASTER_TRIGGER_T), count);
3555
3556	if (ioc->supports_trigger_pages) {
3557	master_tg = kzalloc(size: sizeof(struct SL_WH_MASTER_TRIGGER_T),
3558	GFP_KERNEL);
3559	if (!master_tg)
3560	return -ENOMEM;
3561
3562	memcpy(master_tg, buf, rc);
3563	if (!master_tg->MasterData)
3564	set = 0;
3565	if (mpt3sas_config_update_driver_trigger_pg1(ioc, master_tg,
3566	set)) {
3567	kfree(objp: master_tg);
3568	return -EFAULT;
3569	}
3570	kfree(objp: master_tg);
3571	}
3572
3573	spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
3574	memset(&ioc->diag_trigger_master, 0,
3575	sizeof(struct SL_WH_MASTER_TRIGGER_T));
3576	memcpy(&ioc->diag_trigger_master, buf, rc);
3577	ioc->diag_trigger_master.MasterData |=
3578	(MASTER_TRIGGER_FW_FAULT + MASTER_TRIGGER_ADAPTER_RESET);
3579	spin_unlock_irqrestore(lock: &ioc->diag_trigger_lock, flags);
3580	return rc;
3581	}
3582	static DEVICE_ATTR_RW(diag_trigger_master);
3583
3584
3585	/**
3586	* diag_trigger_event_show - show the diag_trigger_event attribute
3587	* @cdev: pointer to embedded class device
3588	* @attr: ?
3589	* @buf: the buffer returned
3590	*
3591	* A sysfs 'read/write' shost attribute.
3592	*/
3593	static ssize_t
3594	diag_trigger_event_show(struct device *cdev,
3595	struct device_attribute *attr, char *buf)
3596	{
3597	struct Scsi_Host *shost = class_to_shost(cdev);
3598	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3599	unsigned long flags;
3600	ssize_t rc;
3601
3602	spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
3603	rc = sizeof(struct SL_WH_EVENT_TRIGGERS_T);
3604	memcpy(buf, &ioc->diag_trigger_event, rc);
3605	spin_unlock_irqrestore(lock: &ioc->diag_trigger_lock, flags);
3606	return rc;
3607	}
3608
3609	/**
3610	* diag_trigger_event_store - store the diag_trigger_event attribute
3611	* @cdev: pointer to embedded class device
3612	* @attr: ?
3613	* @buf: the buffer returned
3614	* @count: ?
3615	*
3616	* A sysfs 'read/write' shost attribute.
3617	*/
3618	static ssize_t
3619	diag_trigger_event_store(struct device *cdev,
3620	struct device_attribute *attr, const char *buf, size_t count)
3621
3622	{
3623	struct Scsi_Host *shost = class_to_shost(cdev);
3624	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3625	struct SL_WH_EVENT_TRIGGERS_T *event_tg;
3626	unsigned long flags;
3627	ssize_t sz;
3628	bool set = 1;
3629
3630	sz = min(sizeof(struct SL_WH_EVENT_TRIGGERS_T), count);
3631	if (ioc->supports_trigger_pages) {
3632	event_tg = kzalloc(size: sizeof(struct SL_WH_EVENT_TRIGGERS_T),
3633	GFP_KERNEL);
3634	if (!event_tg)
3635	return -ENOMEM;
3636
3637	memcpy(event_tg, buf, sz);
3638	if (!event_tg->ValidEntries)
3639	set = 0;
3640	if (mpt3sas_config_update_driver_trigger_pg2(ioc, event_tg,
3641	set)) {
3642	kfree(objp: event_tg);
3643	return -EFAULT;
3644	}
3645	kfree(objp: event_tg);
3646	}
3647
3648	spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
3649
3650	memset(&ioc->diag_trigger_event, 0,
3651	sizeof(struct SL_WH_EVENT_TRIGGERS_T));
3652	memcpy(&ioc->diag_trigger_event, buf, sz);
3653	if (ioc->diag_trigger_event.ValidEntries > NUM_VALID_ENTRIES)
3654	ioc->diag_trigger_event.ValidEntries = NUM_VALID_ENTRIES;
3655	spin_unlock_irqrestore(lock: &ioc->diag_trigger_lock, flags);
3656	return sz;
3657	}
3658	static DEVICE_ATTR_RW(diag_trigger_event);
3659
3660
3661	/**
3662	* diag_trigger_scsi_show - show the diag_trigger_scsi attribute
3663	* @cdev: pointer to embedded class device
3664	* @attr: ?
3665	* @buf: the buffer returned
3666	*
3667	* A sysfs 'read/write' shost attribute.
3668	*/
3669	static ssize_t
3670	diag_trigger_scsi_show(struct device *cdev,
3671	struct device_attribute *attr, char *buf)
3672	{
3673	struct Scsi_Host *shost = class_to_shost(cdev);
3674	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3675	unsigned long flags;
3676	ssize_t rc;
3677
3678	spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
3679	rc = sizeof(struct SL_WH_SCSI_TRIGGERS_T);
3680	memcpy(buf, &ioc->diag_trigger_scsi, rc);
3681	spin_unlock_irqrestore(lock: &ioc->diag_trigger_lock, flags);
3682	return rc;
3683	}
3684
3685	/**
3686	* diag_trigger_scsi_store - store the diag_trigger_scsi attribute
3687	* @cdev: pointer to embedded class device
3688	* @attr: ?
3689	* @buf: the buffer returned
3690	* @count: ?
3691	*
3692	* A sysfs 'read/write' shost attribute.
3693	*/
3694	static ssize_t
3695	diag_trigger_scsi_store(struct device *cdev,
3696	struct device_attribute *attr, const char *buf, size_t count)
3697	{
3698	struct Scsi_Host *shost = class_to_shost(cdev);
3699	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3700	struct SL_WH_SCSI_TRIGGERS_T *scsi_tg;
3701	unsigned long flags;
3702	ssize_t sz;
3703	bool set = 1;
3704
3705	sz = min(sizeof(struct SL_WH_SCSI_TRIGGERS_T), count);
3706	if (ioc->supports_trigger_pages) {
3707	scsi_tg = kzalloc(size: sizeof(struct SL_WH_SCSI_TRIGGERS_T),
3708	GFP_KERNEL);
3709	if (!scsi_tg)
3710	return -ENOMEM;
3711
3712	memcpy(scsi_tg, buf, sz);
3713	if (!scsi_tg->ValidEntries)
3714	set = 0;
3715	if (mpt3sas_config_update_driver_trigger_pg3(ioc, scsi_tg,
3716	set)) {
3717	kfree(objp: scsi_tg);
3718	return -EFAULT;
3719	}
3720	kfree(objp: scsi_tg);
3721	}
3722
3723	spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
3724
3725	memset(&ioc->diag_trigger_scsi, 0, sizeof(ioc->diag_trigger_scsi));
3726	memcpy(&ioc->diag_trigger_scsi, buf, sz);
3727	if (ioc->diag_trigger_scsi.ValidEntries > NUM_VALID_ENTRIES)
3728	ioc->diag_trigger_scsi.ValidEntries = NUM_VALID_ENTRIES;
3729	spin_unlock_irqrestore(lock: &ioc->diag_trigger_lock, flags);
3730	return sz;
3731	}
3732	static DEVICE_ATTR_RW(diag_trigger_scsi);
3733
3734
3735	/**
3736	* diag_trigger_mpi_show - show the diag_trigger_mpi attribute
3737	* @cdev: pointer to embedded class device
3738	* @attr: ?
3739	* @buf: the buffer returned
3740	*
3741	* A sysfs 'read/write' shost attribute.
3742	*/
3743	static ssize_t
3744	diag_trigger_mpi_show(struct device *cdev,
3745	struct device_attribute *attr, char *buf)
3746	{
3747	struct Scsi_Host *shost = class_to_shost(cdev);
3748	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3749	unsigned long flags;
3750	ssize_t rc;
3751
3752	spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
3753	rc = sizeof(struct SL_WH_MPI_TRIGGERS_T);
3754	memcpy(buf, &ioc->diag_trigger_mpi, rc);
3755	spin_unlock_irqrestore(lock: &ioc->diag_trigger_lock, flags);
3756	return rc;
3757	}
3758
3759	/**
3760	* diag_trigger_mpi_store - store the diag_trigger_mpi attribute
3761	* @cdev: pointer to embedded class device
3762	* @attr: ?
3763	* @buf: the buffer returned
3764	* @count: ?
3765	*
3766	* A sysfs 'read/write' shost attribute.
3767	*/
3768	static ssize_t
3769	diag_trigger_mpi_store(struct device *cdev,
3770	struct device_attribute *attr, const char *buf, size_t count)
3771	{
3772	struct Scsi_Host *shost = class_to_shost(cdev);
3773	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3774	struct SL_WH_MPI_TRIGGERS_T *mpi_tg;
3775	unsigned long flags;
3776	ssize_t sz;
3777	bool set = 1;
3778
3779	sz = min(sizeof(struct SL_WH_MPI_TRIGGERS_T), count);
3780	if (ioc->supports_trigger_pages) {
3781	mpi_tg = kzalloc(size: sizeof(struct SL_WH_MPI_TRIGGERS_T),
3782	GFP_KERNEL);
3783	if (!mpi_tg)
3784	return -ENOMEM;
3785
3786	memcpy(mpi_tg, buf, sz);
3787	if (!mpi_tg->ValidEntries)
3788	set = 0;
3789	if (mpt3sas_config_update_driver_trigger_pg4(ioc, mpi_tg,
3790	set)) {
3791	kfree(objp: mpi_tg);
3792	return -EFAULT;
3793	}
3794	kfree(objp: mpi_tg);
3795	}
3796
3797	spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
3798	memset(&ioc->diag_trigger_mpi, 0,
3799	sizeof(ioc->diag_trigger_mpi));
3800	memcpy(&ioc->diag_trigger_mpi, buf, sz);
3801	if (ioc->diag_trigger_mpi.ValidEntries > NUM_VALID_ENTRIES)
3802	ioc->diag_trigger_mpi.ValidEntries = NUM_VALID_ENTRIES;
3803	spin_unlock_irqrestore(lock: &ioc->diag_trigger_lock, flags);
3804	return sz;
3805	}
3806
3807	static DEVICE_ATTR_RW(diag_trigger_mpi);
3808
3809	/*********** diagnostic trigger suppport *** END ****************************/
3810
3811	/*****************************************/
3812
3813	/**
3814	* drv_support_bitmap_show - driver supported feature bitmap
3815	* @cdev: pointer to embedded class device
3816	* @attr: unused
3817	* @buf: the buffer returned
3818	*
3819	* A sysfs 'read-only' shost attribute.
3820	*/
3821	static ssize_t
3822	drv_support_bitmap_show(struct device *cdev,
3823	struct device_attribute *attr, char *buf)
3824	{
3825	struct Scsi_Host *shost = class_to_shost(cdev);
3826	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3827
3828	return snprintf(buf, PAGE_SIZE, fmt: "0x%08x\n", ioc->drv_support_bitmap);
3829	}
3830	static DEVICE_ATTR_RO(drv_support_bitmap);
3831
3832	/**
3833	* enable_sdev_max_qd_show - display whether sdev max qd is enabled/disabled
3834	* @cdev: pointer to embedded class device
3835	* @attr: unused
3836	* @buf: the buffer returned
3837	*
3838	* A sysfs read/write shost attribute. This attribute is used to set the
3839	* targets queue depth to HBA IO queue depth if this attribute is enabled.
3840	*/
3841	static ssize_t
3842	enable_sdev_max_qd_show(struct device *cdev,
3843	struct device_attribute *attr, char *buf)
3844	{
3845	struct Scsi_Host *shost = class_to_shost(cdev);
3846	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3847
3848	return snprintf(buf, PAGE_SIZE, fmt: "%d\n", ioc->enable_sdev_max_qd);
3849	}
3850
3851	/**
3852	* enable_sdev_max_qd_store - Enable/disable sdev max qd
3853	* @cdev: pointer to embedded class device
3854	* @attr: unused
3855	* @buf: the buffer returned
3856	* @count: unused
3857	*
3858	* A sysfs read/write shost attribute. This attribute is used to set the
3859	* targets queue depth to HBA IO queue depth if this attribute is enabled.
3860	* If this attribute is disabled then targets will have corresponding default
3861	* queue depth.
3862	*/
3863	static ssize_t
3864	enable_sdev_max_qd_store(struct device *cdev,
3865	struct device_attribute *attr, const char *buf, size_t count)
3866	{
3867	struct Scsi_Host *shost = class_to_shost(cdev);
3868	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3869	struct MPT3SAS_DEVICE *sas_device_priv_data;
3870	struct MPT3SAS_TARGET *sas_target_priv_data;
3871	int val = 0;
3872	struct scsi_device *sdev;
3873	struct _raid_device *raid_device;
3874	int qdepth;
3875
3876	if (kstrtoint(s: buf, base: 0, res: &val) != 0)
3877	return -EINVAL;
3878
3879	switch (val) {
3880	case 0:
3881	ioc->enable_sdev_max_qd = 0;
3882	shost_for_each_device(sdev, ioc->shost) {
3883	sas_device_priv_data = sdev->hostdata;
3884	if (!sas_device_priv_data)
3885	continue;
3886	sas_target_priv_data = sas_device_priv_data->sas_target;
3887	if (!sas_target_priv_data)
3888	continue;
3889
3890	if (sas_target_priv_data->flags &
3891	MPT_TARGET_FLAGS_VOLUME) {
3892	raid_device =
3893	mpt3sas_raid_device_find_by_handle(ioc,
3894	handle: sas_target_priv_data->handle);
3895
3896	switch (raid_device->volume_type) {
3897	case MPI2_RAID_VOL_TYPE_RAID0:
3898	if (raid_device->device_info &
3899	MPI2_SAS_DEVICE_INFO_SSP_TARGET)
3900	qdepth =
3901	MPT3SAS_SAS_QUEUE_DEPTH;
3902	else
3903	qdepth =
3904	MPT3SAS_SATA_QUEUE_DEPTH;
3905	break;
3906	case MPI2_RAID_VOL_TYPE_RAID1E:
3907	case MPI2_RAID_VOL_TYPE_RAID1:
3908	case MPI2_RAID_VOL_TYPE_RAID10:
3909	case MPI2_RAID_VOL_TYPE_UNKNOWN:
3910	default:
3911	qdepth = MPT3SAS_RAID_QUEUE_DEPTH;
3912	}
3913	} else if (sas_target_priv_data->flags &
3914	MPT_TARGET_FLAGS_PCIE_DEVICE)
3915	qdepth = ioc->max_nvme_qd;
3916	else
3917	qdepth = (sas_target_priv_data->sas_dev->port_type > 1) ?
3918	ioc->max_wideport_qd : ioc->max_narrowport_qd;
3919
3920	mpt3sas_scsih_change_queue_depth(sdev, qdepth);
3921	}
3922	break;
3923	case 1:
3924	ioc->enable_sdev_max_qd = 1;
3925	shost_for_each_device(sdev, ioc->shost)
3926	mpt3sas_scsih_change_queue_depth(sdev,
3927	qdepth: shost->can_queue);
3928	break;
3929	default:
3930	return -EINVAL;
3931	}
3932
3933	return strlen(buf);
3934	}
3935	static DEVICE_ATTR_RW(enable_sdev_max_qd);
3936
3937	static struct attribute *mpt3sas_host_attrs[] = {
3938	&dev_attr_version_fw.attr,
3939	&dev_attr_version_bios.attr,
3940	&dev_attr_version_mpi.attr,
3941	&dev_attr_version_product.attr,
3942	&dev_attr_version_nvdata_persistent.attr,
3943	&dev_attr_version_nvdata_default.attr,
3944	&dev_attr_board_name.attr,
3945	&dev_attr_board_assembly.attr,
3946	&dev_attr_board_tracer.attr,
3947	&dev_attr_io_delay.attr,
3948	&dev_attr_device_delay.attr,
3949	&dev_attr_logging_level.attr,
3950	&dev_attr_fwfault_debug.attr,
3951	&dev_attr_fw_queue_depth.attr,
3952	&dev_attr_host_sas_address.attr,
3953	&dev_attr_ioc_reset_count.attr,
3954	&dev_attr_host_trace_buffer_size.attr,
3955	&dev_attr_host_trace_buffer.attr,
3956	&dev_attr_host_trace_buffer_enable.attr,
3957	&dev_attr_reply_queue_count.attr,
3958	&dev_attr_diag_trigger_master.attr,
3959	&dev_attr_diag_trigger_event.attr,
3960	&dev_attr_diag_trigger_scsi.attr,
3961	&dev_attr_diag_trigger_mpi.attr,
3962	&dev_attr_drv_support_bitmap.attr,
3963	&dev_attr_BRM_status.attr,
3964	&dev_attr_enable_sdev_max_qd.attr,
3965	NULL,
3966	};
3967
3968	static const struct attribute_group mpt3sas_host_attr_group = {
3969	.attrs = mpt3sas_host_attrs
3970	};
3971
3972	const struct attribute_group *mpt3sas_host_groups[] = {
3973	&mpt3sas_host_attr_group,
3974	NULL
3975	};
3976
3977	/* device attributes */
3978
3979	/**
3980	* sas_address_show - sas address
3981	* @dev: pointer to embedded class device
3982	* @attr: ?
3983	* @buf: the buffer returned
3984	*
3985	* This is the sas address for the target
3986	*
3987	* A sysfs 'read-only' shost attribute.
3988	*/
3989	static ssize_t
3990	sas_address_show(struct device *dev, struct device_attribute *attr,
3991	char *buf)
3992	{
3993	struct scsi_device *sdev = to_scsi_device(dev);
3994	struct MPT3SAS_DEVICE *sas_device_priv_data = sdev->hostdata;
3995
3996	return snprintf(buf, PAGE_SIZE, fmt: "0x%016llx\n",
3997	(unsigned long long)sas_device_priv_data->sas_target->sas_address);
3998	}
3999	static DEVICE_ATTR_RO(sas_address);
4000
4001	/**
4002	* sas_device_handle_show - device handle
4003	* @dev: pointer to embedded class device
4004	* @attr: ?
4005	* @buf: the buffer returned
4006	*
4007	* This is the firmware assigned device handle
4008	*
4009	* A sysfs 'read-only' shost attribute.
4010	*/
4011	static ssize_t
4012	sas_device_handle_show(struct device *dev, struct device_attribute *attr,
4013	char *buf)
4014	{
4015	struct scsi_device *sdev = to_scsi_device(dev);
4016	struct MPT3SAS_DEVICE *sas_device_priv_data = sdev->hostdata;
4017
4018	return snprintf(buf, PAGE_SIZE, fmt: "0x%04x\n",
4019	sas_device_priv_data->sas_target->handle);
4020	}
4021	static DEVICE_ATTR_RO(sas_device_handle);
4022
4023	/**
4024	* sas_ncq_prio_supported_show - Indicate if device supports NCQ priority
4025	* @dev: pointer to embedded device
4026	* @attr: sas_ncq_prio_supported attribute descriptor
4027	* @buf: the buffer returned
4028	*
4029	* A sysfs 'read-only' sdev attribute, only works with SATA
4030	*/
4031	static ssize_t
4032	sas_ncq_prio_supported_show(struct device *dev,
4033	struct device_attribute *attr, char *buf)
4034	{
4035	struct scsi_device *sdev = to_scsi_device(dev);
4036
4037	return sysfs_emit(buf, fmt: "%d\n", scsih_ncq_prio_supp(sdev));
4038	}
4039	static DEVICE_ATTR_RO(sas_ncq_prio_supported);
4040
4041	/**
4042	* sas_ncq_prio_enable_show - send prioritized io commands to device
4043	* @dev: pointer to embedded device
4044	* @attr: ?
4045	* @buf: the buffer returned
4046	*
4047	* A sysfs 'read/write' sdev attribute, only works with SATA
4048	*/
4049	static ssize_t
4050	sas_ncq_prio_enable_show(struct device *dev,
4051	struct device_attribute *attr, char *buf)
4052	{
4053	struct scsi_device *sdev = to_scsi_device(dev);
4054	struct MPT3SAS_DEVICE *sas_device_priv_data = sdev->hostdata;
4055
4056	return snprintf(buf, PAGE_SIZE, fmt: "%d\n",
4057	sas_device_priv_data->ncq_prio_enable);
4058	}
4059
4060	static ssize_t
4061	sas_ncq_prio_enable_store(struct device *dev,
4062	struct device_attribute *attr,
4063	const char *buf, size_t count)
4064	{
4065	struct scsi_device *sdev = to_scsi_device(dev);
4066	struct MPT3SAS_DEVICE *sas_device_priv_data = sdev->hostdata;
4067	bool ncq_prio_enable = 0;
4068
4069	if (kstrtobool(s: buf, res: &ncq_prio_enable))
4070	return -EINVAL;
4071
4072	if (!scsih_ncq_prio_supp(sdev))
4073	return -EINVAL;
4074
4075	sas_device_priv_data->ncq_prio_enable = ncq_prio_enable;
4076	return strlen(buf);
4077	}
4078	static DEVICE_ATTR_RW(sas_ncq_prio_enable);
4079
4080	static struct attribute *mpt3sas_dev_attrs[] = {
4081	&dev_attr_sas_address.attr,
4082	&dev_attr_sas_device_handle.attr,
4083	&dev_attr_sas_ncq_prio_supported.attr,
4084	&dev_attr_sas_ncq_prio_enable.attr,
4085	NULL,
4086	};
4087
4088	static const struct attribute_group mpt3sas_dev_attr_group = {
4089	.attrs = mpt3sas_dev_attrs
4090	};
4091
4092	const struct attribute_group *mpt3sas_dev_groups[] = {
4093	&mpt3sas_dev_attr_group,
4094	NULL
4095	};
4096
4097	/* file operations table for mpt3ctl device */
4098	static const struct file_operations ctl_fops = {
4099	.owner = THIS_MODULE,
4100	.unlocked_ioctl = _ctl_ioctl,
4101	.poll = _ctl_poll,
4102	.fasync = _ctl_fasync,
4103	#ifdef CONFIG_COMPAT
4104	.compat_ioctl = _ctl_ioctl_compat,
4105	#endif
4106	};
4107
4108	/* file operations table for mpt2ctl device */
4109	static const struct file_operations ctl_gen2_fops = {
4110	.owner = THIS_MODULE,
4111	.unlocked_ioctl = _ctl_mpt2_ioctl,
4112	.poll = _ctl_poll,
4113	.fasync = _ctl_fasync,
4114	#ifdef CONFIG_COMPAT
4115	.compat_ioctl = _ctl_mpt2_ioctl_compat,
4116	#endif
4117	};
4118
4119	static struct miscdevice ctl_dev = {
4120	.minor = MPT3SAS_MINOR,
4121	.name = MPT3SAS_DEV_NAME,
4122	.fops = &ctl_fops,
4123	};
4124
4125	static struct miscdevice gen2_ctl_dev = {
4126	.minor = MPT2SAS_MINOR,
4127	.name = MPT2SAS_DEV_NAME,
4128	.fops = &ctl_gen2_fops,
4129	};
4130
4131	/**
4132	* mpt3sas_ctl_init - main entry point for ctl.
4133	* @hbas_to_enumerate: ?
4134	*/
4135	void
4136	mpt3sas_ctl_init(ushort hbas_to_enumerate)
4137	{
4138	async_queue = NULL;
4139
4140	/* Don't register mpt3ctl ioctl device if
4141	* hbas_to_enumarate is one.
4142	*/
4143	if (hbas_to_enumerate != 1)
4144	if (misc_register(misc: &ctl_dev) < 0)
4145	pr_err("%s can't register misc device [minor=%d]\n",
4146	MPT3SAS_DRIVER_NAME, MPT3SAS_MINOR);
4147
4148	/* Don't register mpt3ctl ioctl device if
4149	* hbas_to_enumarate is two.
4150	*/
4151	if (hbas_to_enumerate != 2)
4152	if (misc_register(misc: &gen2_ctl_dev) < 0)
4153	pr_err("%s can't register misc device [minor=%d]\n",
4154	MPT2SAS_DRIVER_NAME, MPT2SAS_MINOR);
4155
4156	init_waitqueue_head(&ctl_poll_wait);
4157	}
4158
4159	/**
4160	* mpt3sas_ctl_exit - exit point for ctl
4161	* @hbas_to_enumerate: ?
4162	*/
4163	void
4164	mpt3sas_ctl_exit(ushort hbas_to_enumerate)
4165	{
4166	struct MPT3SAS_ADAPTER *ioc;
4167	int i;
4168
4169	list_for_each_entry(ioc, &mpt3sas_ioc_list, list) {
4170
4171	/* free memory associated to diag buffers */
4172	for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
4173	if (!ioc->diag_buffer[i])
4174	continue;
4175	dma_free_coherent(dev: &ioc->pdev->dev,
4176	size: ioc->diag_buffer_sz[i],
4177	cpu_addr: ioc->diag_buffer[i],
4178	dma_handle: ioc->diag_buffer_dma[i]);
4179	ioc->diag_buffer[i] = NULL;
4180	ioc->diag_buffer_status[i] = 0;
4181	}
4182
4183	kfree(objp: ioc->event_log);
4184	}
4185	if (hbas_to_enumerate != 1)
4186	misc_deregister(misc: &ctl_dev);
4187	if (hbas_to_enumerate != 2)
4188	misc_deregister(misc: &gen2_ctl_dev);
4189	}
4190