mpt2sas_ctl.c revision eabb08ad2d3b0257cd2c9aed4f106fb39d14604a
1/*
2 * Management Module Support for MPT (Message Passing Technology) based
3 * controllers
4 *
5 * This code is based on drivers/scsi/mpt2sas/mpt2_ctl.c
6 * Copyright (C) 2007-2010  LSI Corporation
7 *  (mailto:DL-MPTFusionLinux@lsi.com)
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 2
12 * of the License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 * GNU General Public License for more details.
18 *
19 * NO WARRANTY
20 * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
21 * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
22 * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
23 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
24 * solely responsible for determining the appropriateness of using and
25 * distributing the Program and assumes all risks associated with its
26 * exercise of rights under this Agreement, including but not limited to
27 * the risks and costs of program errors, damage to or loss of data,
28 * programs or equipment, and unavailability or interruption of operations.
29
30 * DISCLAIMER OF LIABILITY
31 * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
32 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
34 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
35 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
36 * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
37 * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
38
39 * You should have received a copy of the GNU General Public License
40 * along with this program; if not, write to the Free Software
41 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
42 * USA.
43 */
44
45#include <linux/version.h>
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/smp_lock.h>
55#include <linux/compat.h>
56#include <linux/poll.h>
57
58#include <linux/io.h>
59#include <linux/uaccess.h>
60
61#include "mpt2sas_base.h"
62#include "mpt2sas_ctl.h"
63
64static struct fasync_struct *async_queue;
65static DECLARE_WAIT_QUEUE_HEAD(ctl_poll_wait);
66
67static int _ctl_send_release(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type,
68    u8 *issue_reset);
69
70/**
71 * enum block_state - blocking state
72 * @NON_BLOCKING: non blocking
73 * @BLOCKING: blocking
74 *
75 * These states are for ioctls that need to wait for a response
76 * from firmware, so they probably require sleep.
77 */
78enum block_state {
79	NON_BLOCKING,
80	BLOCKING,
81};
82
83#ifdef CONFIG_SCSI_MPT2SAS_LOGGING
84/**
85 * _ctl_display_some_debug - debug routine
86 * @ioc: per adapter object
87 * @smid: system request message index
88 * @calling_function_name: string pass from calling function
89 * @mpi_reply: reply message frame
90 * Context: none.
91 *
92 * Function for displaying debug info helpfull when debugging issues
93 * in this module.
94 */
95static void
96_ctl_display_some_debug(struct MPT2SAS_ADAPTER *ioc, u16 smid,
97    char *calling_function_name, MPI2DefaultReply_t *mpi_reply)
98{
99	Mpi2ConfigRequest_t *mpi_request;
100	char *desc = NULL;
101
102	if (!(ioc->logging_level & MPT_DEBUG_IOCTL))
103		return;
104
105	mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
106	switch (mpi_request->Function) {
107	case MPI2_FUNCTION_SCSI_IO_REQUEST:
108	{
109		Mpi2SCSIIORequest_t *scsi_request =
110		    (Mpi2SCSIIORequest_t *)mpi_request;
111
112		snprintf(ioc->tmp_string, MPT_STRING_LENGTH,
113		    "scsi_io, cmd(0x%02x), cdb_len(%d)",
114		    scsi_request->CDB.CDB32[0],
115		    le16_to_cpu(scsi_request->IoFlags) & 0xF);
116		desc = ioc->tmp_string;
117		break;
118	}
119	case MPI2_FUNCTION_SCSI_TASK_MGMT:
120		desc = "task_mgmt";
121		break;
122	case MPI2_FUNCTION_IOC_INIT:
123		desc = "ioc_init";
124		break;
125	case MPI2_FUNCTION_IOC_FACTS:
126		desc = "ioc_facts";
127		break;
128	case MPI2_FUNCTION_CONFIG:
129	{
130		Mpi2ConfigRequest_t *config_request =
131		    (Mpi2ConfigRequest_t *)mpi_request;
132
133		snprintf(ioc->tmp_string, MPT_STRING_LENGTH,
134		    "config, type(0x%02x), ext_type(0x%02x), number(%d)",
135		    (config_request->Header.PageType &
136		     MPI2_CONFIG_PAGETYPE_MASK), config_request->ExtPageType,
137		    config_request->Header.PageNumber);
138		desc = ioc->tmp_string;
139		break;
140	}
141	case MPI2_FUNCTION_PORT_FACTS:
142		desc = "port_facts";
143		break;
144	case MPI2_FUNCTION_PORT_ENABLE:
145		desc = "port_enable";
146		break;
147	case MPI2_FUNCTION_EVENT_NOTIFICATION:
148		desc = "event_notification";
149		break;
150	case MPI2_FUNCTION_FW_DOWNLOAD:
151		desc = "fw_download";
152		break;
153	case MPI2_FUNCTION_FW_UPLOAD:
154		desc = "fw_upload";
155		break;
156	case MPI2_FUNCTION_RAID_ACTION:
157		desc = "raid_action";
158		break;
159	case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
160	{
161		Mpi2SCSIIORequest_t *scsi_request =
162		    (Mpi2SCSIIORequest_t *)mpi_request;
163
164		snprintf(ioc->tmp_string, MPT_STRING_LENGTH,
165		    "raid_pass, cmd(0x%02x), cdb_len(%d)",
166		    scsi_request->CDB.CDB32[0],
167		    le16_to_cpu(scsi_request->IoFlags) & 0xF);
168		desc = ioc->tmp_string;
169		break;
170	}
171	case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL:
172		desc = "sas_iounit_cntl";
173		break;
174	case MPI2_FUNCTION_SATA_PASSTHROUGH:
175		desc = "sata_pass";
176		break;
177	case MPI2_FUNCTION_DIAG_BUFFER_POST:
178		desc = "diag_buffer_post";
179		break;
180	case MPI2_FUNCTION_DIAG_RELEASE:
181		desc = "diag_release";
182		break;
183	case MPI2_FUNCTION_SMP_PASSTHROUGH:
184		desc = "smp_passthrough";
185		break;
186	}
187
188	if (!desc)
189		return;
190
191	printk(MPT2SAS_INFO_FMT "%s: %s, smid(%d)\n",
192	    ioc->name, calling_function_name, desc, smid);
193
194	if (!mpi_reply)
195		return;
196
197	if (mpi_reply->IOCStatus || mpi_reply->IOCLogInfo)
198		printk(MPT2SAS_INFO_FMT
199		    "\tiocstatus(0x%04x), loginfo(0x%08x)\n",
200		    ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
201		    le32_to_cpu(mpi_reply->IOCLogInfo));
202
203	if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
204	    mpi_request->Function ==
205	    MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) {
206		Mpi2SCSIIOReply_t *scsi_reply =
207		    (Mpi2SCSIIOReply_t *)mpi_reply;
208		if (scsi_reply->SCSIState || scsi_reply->SCSIStatus)
209			printk(MPT2SAS_INFO_FMT
210			    "\tscsi_state(0x%02x), scsi_status"
211			    "(0x%02x)\n", ioc->name,
212			    scsi_reply->SCSIState,
213			    scsi_reply->SCSIStatus);
214	}
215}
216#endif
217
218/**
219 * mpt2sas_ctl_done - ctl module completion routine
220 * @ioc: per adapter object
221 * @smid: system request message index
222 * @msix_index: MSIX table index supplied by the OS
223 * @reply: reply message frame(lower 32bit addr)
224 * Context: none.
225 *
226 * The callback handler when using ioc->ctl_cb_idx.
227 *
228 * Return 1 meaning mf should be freed from _base_interrupt
229 *        0 means the mf is freed from this function.
230 */
231u8
232mpt2sas_ctl_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
233	u32 reply)
234{
235	MPI2DefaultReply_t *mpi_reply;
236
237	if (ioc->ctl_cmds.status == MPT2_CMD_NOT_USED)
238		return 1;
239	if (ioc->ctl_cmds.smid != smid)
240		return 1;
241	ioc->ctl_cmds.status |= MPT2_CMD_COMPLETE;
242	mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
243	if (mpi_reply) {
244		memcpy(ioc->ctl_cmds.reply, mpi_reply, mpi_reply->MsgLength*4);
245		ioc->ctl_cmds.status |= MPT2_CMD_REPLY_VALID;
246	}
247#ifdef CONFIG_SCSI_MPT2SAS_LOGGING
248	_ctl_display_some_debug(ioc, smid, "ctl_done", mpi_reply);
249#endif
250	ioc->ctl_cmds.status &= ~MPT2_CMD_PENDING;
251	complete(&ioc->ctl_cmds.done);
252	return 1;
253}
254
255/**
256 * _ctl_check_event_type - determines when an event needs logging
257 * @ioc: per adapter object
258 * @event: firmware event
259 *
260 * The bitmask in ioc->event_type[] indicates which events should be
261 * be saved in the driver event_log.  This bitmask is set by application.
262 *
263 * Returns 1 when event should be captured, or zero means no match.
264 */
265static int
266_ctl_check_event_type(struct MPT2SAS_ADAPTER *ioc, u16 event)
267{
268	u16 i;
269	u32 desired_event;
270
271	if (event >= 128 || !event || !ioc->event_log)
272		return 0;
273
274	desired_event = (1 << (event % 32));
275	if (!desired_event)
276		desired_event = 1;
277	i = event / 32;
278	return desired_event & ioc->event_type[i];
279}
280
281/**
282 * mpt2sas_ctl_add_to_event_log - add event
283 * @ioc: per adapter object
284 * @mpi_reply: reply message frame
285 *
286 * Return nothing.
287 */
288void
289mpt2sas_ctl_add_to_event_log(struct MPT2SAS_ADAPTER *ioc,
290    Mpi2EventNotificationReply_t *mpi_reply)
291{
292	struct MPT2_IOCTL_EVENTS *event_log;
293	u16 event;
294	int i;
295	u32 sz, event_data_sz;
296	u8 send_aen = 0;
297
298	if (!ioc->event_log)
299		return;
300
301	event = le16_to_cpu(mpi_reply->Event);
302
303	if (_ctl_check_event_type(ioc, event)) {
304
305		/* insert entry into circular event_log */
306		i = ioc->event_context % MPT2SAS_CTL_EVENT_LOG_SIZE;
307		event_log = ioc->event_log;
308		event_log[i].event = event;
309		event_log[i].context = ioc->event_context++;
310
311		event_data_sz = le16_to_cpu(mpi_reply->EventDataLength)*4;
312		sz = min_t(u32, event_data_sz, MPT2_EVENT_DATA_SIZE);
313		memset(event_log[i].data, 0, MPT2_EVENT_DATA_SIZE);
314		memcpy(event_log[i].data, mpi_reply->EventData, sz);
315		send_aen = 1;
316	}
317
318	/* This aen_event_read_flag flag is set until the
319	 * application has read the event log.
320	 * For MPI2_EVENT_LOG_ENTRY_ADDED, we always notify.
321	 */
322	if (event == MPI2_EVENT_LOG_ENTRY_ADDED ||
323	    (send_aen && !ioc->aen_event_read_flag)) {
324		ioc->aen_event_read_flag = 1;
325		wake_up_interruptible(&ctl_poll_wait);
326		if (async_queue)
327			kill_fasync(&async_queue, SIGIO, POLL_IN);
328	}
329}
330
331/**
332 * mpt2sas_ctl_event_callback - firmware event handler (called at ISR time)
333 * @ioc: per adapter object
334 * @msix_index: MSIX table index supplied by the OS
335 * @reply: reply message frame(lower 32bit addr)
336 * Context: interrupt.
337 *
338 * This function merely adds a new work task into ioc->firmware_event_thread.
339 * The tasks are worked from _firmware_event_work in user context.
340 *
341 * Return 1 meaning mf should be freed from _base_interrupt
342 *        0 means the mf is freed from this function.
343 */
344u8
345mpt2sas_ctl_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 msix_index,
346	u32 reply)
347{
348	Mpi2EventNotificationReply_t *mpi_reply;
349
350	mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
351	mpt2sas_ctl_add_to_event_log(ioc, mpi_reply);
352	return 1;
353}
354
355/**
356 * _ctl_verify_adapter - validates ioc_number passed from application
357 * @ioc: per adapter object
358 * @iocpp: The ioc pointer is returned in this.
359 *
360 * Return (-1) means error, else ioc_number.
361 */
362static int
363_ctl_verify_adapter(int ioc_number, struct MPT2SAS_ADAPTER **iocpp)
364{
365	struct MPT2SAS_ADAPTER *ioc;
366
367	list_for_each_entry(ioc, &mpt2sas_ioc_list, list) {
368		if (ioc->id != ioc_number)
369			continue;
370		*iocpp = ioc;
371		return ioc_number;
372	}
373	*iocpp = NULL;
374	return -1;
375}
376
377/**
378 * mpt2sas_ctl_reset_handler - reset callback handler (for ctl)
379 * @ioc: per adapter object
380 * @reset_phase: phase
381 *
382 * The handler for doing any required cleanup or initialization.
383 *
384 * The reset phase can be MPT2_IOC_PRE_RESET, MPT2_IOC_AFTER_RESET,
385 * MPT2_IOC_DONE_RESET
386 */
387void
388mpt2sas_ctl_reset_handler(struct MPT2SAS_ADAPTER *ioc, int reset_phase)
389{
390	int i;
391	u8 issue_reset;
392
393	switch (reset_phase) {
394	case MPT2_IOC_PRE_RESET:
395		dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
396		    "MPT2_IOC_PRE_RESET\n", ioc->name, __func__));
397		for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
398			if (!(ioc->diag_buffer_status[i] &
399			    MPT2_DIAG_BUFFER_IS_REGISTERED))
400				continue;
401			if ((ioc->diag_buffer_status[i] &
402			    MPT2_DIAG_BUFFER_IS_RELEASED))
403				continue;
404			_ctl_send_release(ioc, i, &issue_reset);
405		}
406		break;
407	case MPT2_IOC_AFTER_RESET:
408		dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
409		    "MPT2_IOC_AFTER_RESET\n", ioc->name, __func__));
410		if (ioc->ctl_cmds.status & MPT2_CMD_PENDING) {
411			ioc->ctl_cmds.status |= MPT2_CMD_RESET;
412			mpt2sas_base_free_smid(ioc, ioc->ctl_cmds.smid);
413			complete(&ioc->ctl_cmds.done);
414		}
415		break;
416	case MPT2_IOC_DONE_RESET:
417		dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
418		    "MPT2_IOC_DONE_RESET\n", ioc->name, __func__));
419
420		for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
421			if (!(ioc->diag_buffer_status[i] &
422			    MPT2_DIAG_BUFFER_IS_REGISTERED))
423				continue;
424			if ((ioc->diag_buffer_status[i] &
425			    MPT2_DIAG_BUFFER_IS_RELEASED))
426				continue;
427			ioc->diag_buffer_status[i] |=
428			    MPT2_DIAG_BUFFER_IS_DIAG_RESET;
429		}
430		break;
431	}
432}
433
434/**
435 * _ctl_fasync -
436 * @fd -
437 * @filep -
438 * @mode -
439 *
440 * Called when application request fasyn callback handler.
441 */
442static int
443_ctl_fasync(int fd, struct file *filep, int mode)
444{
445	return fasync_helper(fd, filep, mode, &async_queue);
446}
447
448/**
449 * _ctl_release -
450 * @inode -
451 * @filep -
452 *
453 * Called when application releases the fasyn callback handler.
454 */
455static int
456_ctl_release(struct inode *inode, struct file *filep)
457{
458	return fasync_helper(-1, filep, 0, &async_queue);
459}
460
461/**
462 * _ctl_poll -
463 * @file -
464 * @wait -
465 *
466 */
467static unsigned int
468_ctl_poll(struct file *filep, poll_table *wait)
469{
470	struct MPT2SAS_ADAPTER *ioc;
471
472	poll_wait(filep, &ctl_poll_wait, wait);
473
474	list_for_each_entry(ioc, &mpt2sas_ioc_list, list) {
475		if (ioc->aen_event_read_flag)
476			return POLLIN | POLLRDNORM;
477	}
478	return 0;
479}
480
481/**
482 * _ctl_set_task_mid - assign an active smid to tm request
483 * @ioc: per adapter object
484 * @karg - (struct mpt2_ioctl_command)
485 * @tm_request - pointer to mf from user space
486 *
487 * Returns 0 when an smid if found, else fail.
488 * during failure, the reply frame is filled.
489 */
490static int
491_ctl_set_task_mid(struct MPT2SAS_ADAPTER *ioc, struct mpt2_ioctl_command *karg,
492    Mpi2SCSITaskManagementRequest_t *tm_request)
493{
494	u8 found = 0;
495	u16 i;
496	u16 handle;
497	struct scsi_cmnd *scmd;
498	struct MPT2SAS_DEVICE *priv_data;
499	unsigned long flags;
500	Mpi2SCSITaskManagementReply_t *tm_reply;
501	u32 sz;
502	u32 lun;
503	char *desc = NULL;
504
505	if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK)
506		desc = "abort_task";
507	else if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK)
508		desc = "query_task";
509	else
510		return 0;
511
512	lun = scsilun_to_int((struct scsi_lun *)tm_request->LUN);
513
514	handle = le16_to_cpu(tm_request->DevHandle);
515	spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
516	for (i = ioc->scsiio_depth; i && !found; i--) {
517		scmd = ioc->scsi_lookup[i - 1].scmd;
518		if (scmd == NULL || scmd->device == NULL ||
519		    scmd->device->hostdata == NULL)
520			continue;
521		if (lun != scmd->device->lun)
522			continue;
523		priv_data = scmd->device->hostdata;
524		if (priv_data->sas_target == NULL)
525			continue;
526		if (priv_data->sas_target->handle != handle)
527			continue;
528		tm_request->TaskMID = cpu_to_le16(ioc->scsi_lookup[i - 1].smid);
529		found = 1;
530	}
531	spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
532
533	if (!found) {
534		dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
535		    "handle(0x%04x), lun(%d), no active mid!!\n", ioc->name,
536		    desc, le16_to_cpu(tm_request->DevHandle), lun));
537		tm_reply = ioc->ctl_cmds.reply;
538		tm_reply->DevHandle = tm_request->DevHandle;
539		tm_reply->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
540		tm_reply->TaskType = tm_request->TaskType;
541		tm_reply->MsgLength = sizeof(Mpi2SCSITaskManagementReply_t)/4;
542		tm_reply->VP_ID = tm_request->VP_ID;
543		tm_reply->VF_ID = tm_request->VF_ID;
544		sz = min_t(u32, karg->max_reply_bytes, ioc->reply_sz);
545		if (copy_to_user(karg->reply_frame_buf_ptr, ioc->ctl_cmds.reply,
546		    sz))
547			printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
548			    __LINE__, __func__);
549		return 1;
550	}
551
552	dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
553	    "handle(0x%04x), lun(%d), task_mid(%d)\n", ioc->name,
554	    desc, le16_to_cpu(tm_request->DevHandle), lun,
555	     le16_to_cpu(tm_request->TaskMID)));
556	return 0;
557}
558
559/**
560 * _ctl_do_mpt_command - main handler for MPT2COMMAND opcode
561 * @ioc: per adapter object
562 * @karg - (struct mpt2_ioctl_command)
563 * @mf - pointer to mf in user space
564 * @state - NON_BLOCKING or BLOCKING
565 */
566static long
567_ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc,
568    struct mpt2_ioctl_command karg, void __user *mf, enum block_state state)
569{
570	MPI2RequestHeader_t *mpi_request;
571	MPI2DefaultReply_t *mpi_reply;
572	u32 ioc_state;
573	u16 ioc_status;
574	u16 smid;
575	unsigned long timeout, timeleft;
576	u8 issue_reset;
577	u32 sz;
578	void *psge;
579	void *priv_sense = NULL;
580	void *data_out = NULL;
581	dma_addr_t data_out_dma;
582	size_t data_out_sz = 0;
583	void *data_in = NULL;
584	dma_addr_t data_in_dma;
585	size_t data_in_sz = 0;
586	u32 sgl_flags;
587	long ret;
588	u16 wait_state_count;
589
590	issue_reset = 0;
591
592	if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
593		return -EAGAIN;
594	else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
595		return -ERESTARTSYS;
596
597	if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
598		printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
599		    ioc->name, __func__);
600		ret = -EAGAIN;
601		goto out;
602	}
603
604	wait_state_count = 0;
605	ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
606	while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
607		if (wait_state_count++ == 10) {
608			printk(MPT2SAS_ERR_FMT
609			    "%s: failed due to ioc not operational\n",
610			    ioc->name, __func__);
611			ret = -EFAULT;
612			goto out;
613		}
614		ssleep(1);
615		ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
616		printk(MPT2SAS_INFO_FMT "%s: waiting for "
617		    "operational state(count=%d)\n", ioc->name,
618		    __func__, wait_state_count);
619	}
620	if (wait_state_count)
621		printk(MPT2SAS_INFO_FMT "%s: ioc is operational\n",
622		    ioc->name, __func__);
623
624	smid = mpt2sas_base_get_smid_scsiio(ioc, ioc->ctl_cb_idx, NULL);
625	if (!smid) {
626		printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
627		    ioc->name, __func__);
628		ret = -EAGAIN;
629		goto out;
630	}
631
632	ret = 0;
633	ioc->ctl_cmds.status = MPT2_CMD_PENDING;
634	memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
635	mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
636	ioc->ctl_cmds.smid = smid;
637	data_out_sz = karg.data_out_size;
638	data_in_sz = karg.data_in_size;
639
640	/* copy in request message frame from user */
641	if (copy_from_user(mpi_request, mf, karg.data_sge_offset*4)) {
642		printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__, __LINE__,
643		    __func__);
644		ret = -EFAULT;
645		mpt2sas_base_free_smid(ioc, smid);
646		goto out;
647	}
648
649	if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
650	    mpi_request->Function == MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) {
651		if (!le16_to_cpu(mpi_request->FunctionDependent1) ||
652		    le16_to_cpu(mpi_request->FunctionDependent1) >
653		    ioc->facts.MaxDevHandle) {
654			ret = -EINVAL;
655			mpt2sas_base_free_smid(ioc, smid);
656			goto out;
657		}
658	}
659
660	/* obtain dma-able memory for data transfer */
661	if (data_out_sz) /* WRITE */ {
662		data_out = pci_alloc_consistent(ioc->pdev, data_out_sz,
663		    &data_out_dma);
664		if (!data_out) {
665			printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
666			    __LINE__, __func__);
667			ret = -ENOMEM;
668			mpt2sas_base_free_smid(ioc, smid);
669			goto out;
670		}
671		if (copy_from_user(data_out, karg.data_out_buf_ptr,
672			data_out_sz)) {
673			printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
674			    __LINE__, __func__);
675			ret =  -EFAULT;
676			mpt2sas_base_free_smid(ioc, smid);
677			goto out;
678		}
679	}
680
681	if (data_in_sz) /* READ */ {
682		data_in = pci_alloc_consistent(ioc->pdev, data_in_sz,
683		    &data_in_dma);
684		if (!data_in) {
685			printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
686			    __LINE__, __func__);
687			ret = -ENOMEM;
688			mpt2sas_base_free_smid(ioc, smid);
689			goto out;
690		}
691	}
692
693	/* add scatter gather elements */
694	psge = (void *)mpi_request + (karg.data_sge_offset*4);
695
696	if (!data_out_sz && !data_in_sz) {
697		mpt2sas_base_build_zero_len_sge(ioc, psge);
698	} else if (data_out_sz && data_in_sz) {
699		/* WRITE sgel first */
700		sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT |
701		    MPI2_SGE_FLAGS_END_OF_BUFFER | MPI2_SGE_FLAGS_HOST_TO_IOC);
702		sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
703		ioc->base_add_sg_single(psge, sgl_flags |
704		    data_out_sz, data_out_dma);
705
706		/* incr sgel */
707		psge += ioc->sge_size;
708
709		/* READ sgel last */
710		sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT |
711		    MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER |
712		    MPI2_SGE_FLAGS_END_OF_LIST);
713		sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
714		ioc->base_add_sg_single(psge, sgl_flags |
715		    data_in_sz, data_in_dma);
716	} else if (data_out_sz) /* WRITE */ {
717		sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT |
718		    MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER |
719		    MPI2_SGE_FLAGS_END_OF_LIST | MPI2_SGE_FLAGS_HOST_TO_IOC);
720		sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
721		ioc->base_add_sg_single(psge, sgl_flags |
722		    data_out_sz, data_out_dma);
723	} else if (data_in_sz) /* READ */ {
724		sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT |
725		    MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER |
726		    MPI2_SGE_FLAGS_END_OF_LIST);
727		sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
728		ioc->base_add_sg_single(psge, sgl_flags |
729		    data_in_sz, data_in_dma);
730	}
731
732	/* send command to firmware */
733#ifdef CONFIG_SCSI_MPT2SAS_LOGGING
734	_ctl_display_some_debug(ioc, smid, "ctl_request", NULL);
735#endif
736
737	switch (mpi_request->Function) {
738	case MPI2_FUNCTION_SCSI_IO_REQUEST:
739	case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
740	{
741		Mpi2SCSIIORequest_t *scsiio_request =
742		    (Mpi2SCSIIORequest_t *)mpi_request;
743		scsiio_request->SenseBufferLowAddress =
744		    mpt2sas_base_get_sense_buffer_dma(ioc, smid);
745		priv_sense = mpt2sas_base_get_sense_buffer(ioc, smid);
746		memset(priv_sense, 0, SCSI_SENSE_BUFFERSIZE);
747		if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST)
748			mpt2sas_base_put_smid_scsi_io(ioc, smid,
749			    le16_to_cpu(mpi_request->FunctionDependent1));
750		else
751			mpt2sas_base_put_smid_default(ioc, smid);
752		break;
753	}
754	case MPI2_FUNCTION_SCSI_TASK_MGMT:
755	{
756		Mpi2SCSITaskManagementRequest_t *tm_request =
757		    (Mpi2SCSITaskManagementRequest_t *)mpi_request;
758
759		dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "TASK_MGMT: "
760		    "handle(0x%04x), task_type(0x%02x)\n", ioc->name,
761		    le16_to_cpu(tm_request->DevHandle), tm_request->TaskType));
762
763		if (tm_request->TaskType ==
764		    MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK ||
765		    tm_request->TaskType ==
766		    MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK) {
767			if (_ctl_set_task_mid(ioc, &karg, tm_request)) {
768				mpt2sas_base_free_smid(ioc, smid);
769				goto out;
770			}
771		}
772
773		mpt2sas_scsih_set_tm_flag(ioc, le16_to_cpu(
774		    tm_request->DevHandle));
775		mpt2sas_base_put_smid_hi_priority(ioc, smid);
776		break;
777	}
778	case MPI2_FUNCTION_SMP_PASSTHROUGH:
779	{
780		Mpi2SmpPassthroughRequest_t *smp_request =
781		    (Mpi2SmpPassthroughRequest_t *)mpi_request;
782		u8 *data;
783
784		/* ioc determines which port to use */
785		smp_request->PhysicalPort = 0xFF;
786		if (smp_request->PassthroughFlags &
787		    MPI2_SMP_PT_REQ_PT_FLAGS_IMMEDIATE)
788			data = (u8 *)&smp_request->SGL;
789		else
790			data = data_out;
791
792		if (data[1] == 0x91 && (data[10] == 1 || data[10] == 2)) {
793			ioc->ioc_link_reset_in_progress = 1;
794			ioc->ignore_loginfos = 1;
795		}
796		mpt2sas_base_put_smid_default(ioc, smid);
797		break;
798	}
799	case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL:
800	{
801		Mpi2SasIoUnitControlRequest_t *sasiounit_request =
802		    (Mpi2SasIoUnitControlRequest_t *)mpi_request;
803
804		if (sasiounit_request->Operation == MPI2_SAS_OP_PHY_HARD_RESET
805		    || sasiounit_request->Operation ==
806		    MPI2_SAS_OP_PHY_LINK_RESET) {
807			ioc->ioc_link_reset_in_progress = 1;
808			ioc->ignore_loginfos = 1;
809		}
810		mpt2sas_base_put_smid_default(ioc, smid);
811		break;
812	}
813	default:
814		mpt2sas_base_put_smid_default(ioc, smid);
815		break;
816	}
817
818	if (karg.timeout < MPT2_IOCTL_DEFAULT_TIMEOUT)
819		timeout = MPT2_IOCTL_DEFAULT_TIMEOUT;
820	else
821		timeout = karg.timeout;
822	init_completion(&ioc->ctl_cmds.done);
823	timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
824	    timeout*HZ);
825	if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) {
826		Mpi2SCSITaskManagementRequest_t *tm_request =
827		    (Mpi2SCSITaskManagementRequest_t *)mpi_request;
828		mpt2sas_scsih_clear_tm_flag(ioc, le16_to_cpu(
829		    tm_request->DevHandle));
830	} else if ((mpi_request->Function == MPI2_FUNCTION_SMP_PASSTHROUGH ||
831	    mpi_request->Function == MPI2_FUNCTION_SAS_IO_UNIT_CONTROL) &&
832		ioc->ioc_link_reset_in_progress) {
833		ioc->ioc_link_reset_in_progress = 0;
834		ioc->ignore_loginfos = 0;
835	}
836	if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
837		printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
838		    __func__);
839		_debug_dump_mf(mpi_request, karg.data_sge_offset);
840		if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
841			issue_reset = 1;
842		goto issue_host_reset;
843	}
844
845	mpi_reply = ioc->ctl_cmds.reply;
846	ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
847
848#ifdef CONFIG_SCSI_MPT2SAS_LOGGING
849	if (mpi_reply->Function == MPI2_FUNCTION_SCSI_TASK_MGMT &&
850	    (ioc->logging_level & MPT_DEBUG_TM)) {
851		Mpi2SCSITaskManagementReply_t *tm_reply =
852		    (Mpi2SCSITaskManagementReply_t *)mpi_reply;
853
854		printk(MPT2SAS_INFO_FMT "TASK_MGMT: "
855		    "IOCStatus(0x%04x), IOCLogInfo(0x%08x), "
856		    "TerminationCount(0x%08x)\n", ioc->name,
857		    le16_to_cpu(tm_reply->IOCStatus),
858		    le32_to_cpu(tm_reply->IOCLogInfo),
859		    le32_to_cpu(tm_reply->TerminationCount));
860	}
861#endif
862	/* copy out xdata to user */
863	if (data_in_sz) {
864		if (copy_to_user(karg.data_in_buf_ptr, data_in,
865		    data_in_sz)) {
866			printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
867			    __LINE__, __func__);
868			ret = -ENODATA;
869			goto out;
870		}
871	}
872
873	/* copy out reply message frame to user */
874	if (karg.max_reply_bytes) {
875		sz = min_t(u32, karg.max_reply_bytes, ioc->reply_sz);
876		if (copy_to_user(karg.reply_frame_buf_ptr, ioc->ctl_cmds.reply,
877		    sz)) {
878			printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
879			    __LINE__, __func__);
880			ret = -ENODATA;
881			goto out;
882		}
883	}
884
885	/* copy out sense to user */
886	if (karg.max_sense_bytes && (mpi_request->Function ==
887	    MPI2_FUNCTION_SCSI_IO_REQUEST || mpi_request->Function ==
888	    MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
889		sz = min_t(u32, karg.max_sense_bytes, SCSI_SENSE_BUFFERSIZE);
890		if (copy_to_user(karg.sense_data_ptr, priv_sense, sz)) {
891			printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
892			    __LINE__, __func__);
893			ret = -ENODATA;
894			goto out;
895		}
896	}
897
898 issue_host_reset:
899	if (issue_reset) {
900		ret = -ENODATA;
901		if ((mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
902		    mpi_request->Function ==
903		    MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
904			printk(MPT2SAS_INFO_FMT "issue target reset: handle "
905			    "= (0x%04x)\n", ioc->name,
906			    le16_to_cpu(mpi_request->FunctionDependent1));
907			mpt2sas_halt_firmware(ioc);
908			mpt2sas_scsih_issue_tm(ioc,
909			    le16_to_cpu(mpi_request->FunctionDependent1), 0, 0,
910			    0, MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0, 10,
911			    NULL);
912			ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
913		} else
914			mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
915			    FORCE_BIG_HAMMER);
916	}
917
918 out:
919
920	/* free memory associated with sg buffers */
921	if (data_in)
922		pci_free_consistent(ioc->pdev, data_in_sz, data_in,
923		    data_in_dma);
924
925	if (data_out)
926		pci_free_consistent(ioc->pdev, data_out_sz, data_out,
927		    data_out_dma);
928
929	ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
930	mutex_unlock(&ioc->ctl_cmds.mutex);
931	return ret;
932}
933
934/**
935 * _ctl_getiocinfo - main handler for MPT2IOCINFO opcode
936 * @arg - user space buffer containing ioctl content
937 */
938static long
939_ctl_getiocinfo(void __user *arg)
940{
941	struct mpt2_ioctl_iocinfo karg;
942	struct MPT2SAS_ADAPTER *ioc;
943	u8 revision;
944
945	if (copy_from_user(&karg, arg, sizeof(karg))) {
946		printk(KERN_ERR "failure at %s:%d/%s()!\n",
947		    __FILE__, __LINE__, __func__);
948		return -EFAULT;
949	}
950	if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
951		return -ENODEV;
952
953	dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
954	    __func__));
955
956	memset(&karg, 0 , sizeof(karg));
957	karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2;
958	if (ioc->pfacts)
959		karg.port_number = ioc->pfacts[0].PortNumber;
960	pci_read_config_byte(ioc->pdev, PCI_CLASS_REVISION, &revision);
961	karg.hw_rev = revision;
962	karg.pci_id = ioc->pdev->device;
963	karg.subsystem_device = ioc->pdev->subsystem_device;
964	karg.subsystem_vendor = ioc->pdev->subsystem_vendor;
965	karg.pci_information.u.bits.bus = ioc->pdev->bus->number;
966	karg.pci_information.u.bits.device = PCI_SLOT(ioc->pdev->devfn);
967	karg.pci_information.u.bits.function = PCI_FUNC(ioc->pdev->devfn);
968	karg.pci_information.segment_id = pci_domain_nr(ioc->pdev->bus);
969	karg.firmware_version = ioc->facts.FWVersion.Word;
970	strcpy(karg.driver_version, MPT2SAS_DRIVER_NAME);
971	strcat(karg.driver_version, "-");
972	strcat(karg.driver_version, MPT2SAS_DRIVER_VERSION);
973	karg.bios_version = le32_to_cpu(ioc->bios_pg3.BiosVersion);
974
975	if (copy_to_user(arg, &karg, sizeof(karg))) {
976		printk(KERN_ERR "failure at %s:%d/%s()!\n",
977		    __FILE__, __LINE__, __func__);
978		return -EFAULT;
979	}
980	return 0;
981}
982
983/**
984 * _ctl_eventquery - main handler for MPT2EVENTQUERY opcode
985 * @arg - user space buffer containing ioctl content
986 */
987static long
988_ctl_eventquery(void __user *arg)
989{
990	struct mpt2_ioctl_eventquery karg;
991	struct MPT2SAS_ADAPTER *ioc;
992
993	if (copy_from_user(&karg, arg, sizeof(karg))) {
994		printk(KERN_ERR "failure at %s:%d/%s()!\n",
995		    __FILE__, __LINE__, __func__);
996		return -EFAULT;
997	}
998	if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
999		return -ENODEV;
1000
1001	dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
1002	    __func__));
1003
1004	karg.event_entries = MPT2SAS_CTL_EVENT_LOG_SIZE;
1005	memcpy(karg.event_types, ioc->event_type,
1006	    MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32));
1007
1008	if (copy_to_user(arg, &karg, sizeof(karg))) {
1009		printk(KERN_ERR "failure at %s:%d/%s()!\n",
1010		    __FILE__, __LINE__, __func__);
1011		return -EFAULT;
1012	}
1013	return 0;
1014}
1015
1016/**
1017 * _ctl_eventenable - main handler for MPT2EVENTENABLE opcode
1018 * @arg - user space buffer containing ioctl content
1019 */
1020static long
1021_ctl_eventenable(void __user *arg)
1022{
1023	struct mpt2_ioctl_eventenable karg;
1024	struct MPT2SAS_ADAPTER *ioc;
1025
1026	if (copy_from_user(&karg, arg, sizeof(karg))) {
1027		printk(KERN_ERR "failure at %s:%d/%s()!\n",
1028		    __FILE__, __LINE__, __func__);
1029		return -EFAULT;
1030	}
1031	if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1032		return -ENODEV;
1033
1034	dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
1035	    __func__));
1036
1037	if (ioc->event_log)
1038		return 0;
1039	memcpy(ioc->event_type, karg.event_types,
1040	    MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32));
1041	mpt2sas_base_validate_event_type(ioc, ioc->event_type);
1042
1043	/* initialize event_log */
1044	ioc->event_context = 0;
1045	ioc->aen_event_read_flag = 0;
1046	ioc->event_log = kcalloc(MPT2SAS_CTL_EVENT_LOG_SIZE,
1047	    sizeof(struct MPT2_IOCTL_EVENTS), GFP_KERNEL);
1048	if (!ioc->event_log) {
1049		printk(KERN_ERR "failure at %s:%d/%s()!\n",
1050		    __FILE__, __LINE__, __func__);
1051		return -ENOMEM;
1052	}
1053	return 0;
1054}
1055
1056/**
1057 * _ctl_eventreport - main handler for MPT2EVENTREPORT opcode
1058 * @arg - user space buffer containing ioctl content
1059 */
1060static long
1061_ctl_eventreport(void __user *arg)
1062{
1063	struct mpt2_ioctl_eventreport karg;
1064	struct MPT2SAS_ADAPTER *ioc;
1065	u32 number_bytes, max_events, max;
1066	struct mpt2_ioctl_eventreport __user *uarg = arg;
1067
1068	if (copy_from_user(&karg, arg, sizeof(karg))) {
1069		printk(KERN_ERR "failure at %s:%d/%s()!\n",
1070		    __FILE__, __LINE__, __func__);
1071		return -EFAULT;
1072	}
1073	if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1074		return -ENODEV;
1075
1076	dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
1077	    __func__));
1078
1079	number_bytes = karg.hdr.max_data_size -
1080	    sizeof(struct mpt2_ioctl_header);
1081	max_events = number_bytes/sizeof(struct MPT2_IOCTL_EVENTS);
1082	max = min_t(u32, MPT2SAS_CTL_EVENT_LOG_SIZE, max_events);
1083
1084	/* If fewer than 1 event is requested, there must have
1085	 * been some type of error.
1086	 */
1087	if (!max || !ioc->event_log)
1088		return -ENODATA;
1089
1090	number_bytes = max * sizeof(struct MPT2_IOCTL_EVENTS);
1091	if (copy_to_user(uarg->event_data, ioc->event_log, number_bytes)) {
1092		printk(KERN_ERR "failure at %s:%d/%s()!\n",
1093		    __FILE__, __LINE__, __func__);
1094		return -EFAULT;
1095	}
1096
1097	/* reset flag so SIGIO can restart */
1098	ioc->aen_event_read_flag = 0;
1099	return 0;
1100}
1101
1102/**
1103 * _ctl_do_reset - main handler for MPT2HARDRESET opcode
1104 * @arg - user space buffer containing ioctl content
1105 */
1106static long
1107_ctl_do_reset(void __user *arg)
1108{
1109	struct mpt2_ioctl_diag_reset karg;
1110	struct MPT2SAS_ADAPTER *ioc;
1111	int retval;
1112
1113	if (copy_from_user(&karg, arg, sizeof(karg))) {
1114		printk(KERN_ERR "failure at %s:%d/%s()!\n",
1115		    __FILE__, __LINE__, __func__);
1116		return -EFAULT;
1117	}
1118	if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1119		return -ENODEV;
1120
1121	dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
1122	    __func__));
1123
1124	retval = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1125	    FORCE_BIG_HAMMER);
1126	printk(MPT2SAS_INFO_FMT "host reset: %s\n",
1127	    ioc->name, ((!retval) ? "SUCCESS" : "FAILED"));
1128	return 0;
1129}
1130
1131/**
1132 * _ctl_btdh_search_sas_device - searching for sas device
1133 * @ioc: per adapter object
1134 * @btdh: btdh ioctl payload
1135 */
1136static int
1137_ctl_btdh_search_sas_device(struct MPT2SAS_ADAPTER *ioc,
1138    struct mpt2_ioctl_btdh_mapping *btdh)
1139{
1140	struct _sas_device *sas_device;
1141	unsigned long flags;
1142	int rc = 0;
1143
1144	if (list_empty(&ioc->sas_device_list))
1145		return rc;
1146
1147	spin_lock_irqsave(&ioc->sas_device_lock, flags);
1148	list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
1149		if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF &&
1150		    btdh->handle == sas_device->handle) {
1151			btdh->bus = sas_device->channel;
1152			btdh->id = sas_device->id;
1153			rc = 1;
1154			goto out;
1155		} else if (btdh->bus == sas_device->channel && btdh->id ==
1156		    sas_device->id && btdh->handle == 0xFFFF) {
1157			btdh->handle = sas_device->handle;
1158			rc = 1;
1159			goto out;
1160		}
1161	}
1162 out:
1163	spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1164	return rc;
1165}
1166
1167/**
1168 * _ctl_btdh_search_raid_device - searching for raid device
1169 * @ioc: per adapter object
1170 * @btdh: btdh ioctl payload
1171 */
1172static int
1173_ctl_btdh_search_raid_device(struct MPT2SAS_ADAPTER *ioc,
1174    struct mpt2_ioctl_btdh_mapping *btdh)
1175{
1176	struct _raid_device *raid_device;
1177	unsigned long flags;
1178	int rc = 0;
1179
1180	if (list_empty(&ioc->raid_device_list))
1181		return rc;
1182
1183	spin_lock_irqsave(&ioc->raid_device_lock, flags);
1184	list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
1185		if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF &&
1186		    btdh->handle == raid_device->handle) {
1187			btdh->bus = raid_device->channel;
1188			btdh->id = raid_device->id;
1189			rc = 1;
1190			goto out;
1191		} else if (btdh->bus == raid_device->channel && btdh->id ==
1192		    raid_device->id && btdh->handle == 0xFFFF) {
1193			btdh->handle = raid_device->handle;
1194			rc = 1;
1195			goto out;
1196		}
1197	}
1198 out:
1199	spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1200	return rc;
1201}
1202
1203/**
1204 * _ctl_btdh_mapping - main handler for MPT2BTDHMAPPING opcode
1205 * @arg - user space buffer containing ioctl content
1206 */
1207static long
1208_ctl_btdh_mapping(void __user *arg)
1209{
1210	struct mpt2_ioctl_btdh_mapping karg;
1211	struct MPT2SAS_ADAPTER *ioc;
1212	int rc;
1213
1214	if (copy_from_user(&karg, arg, sizeof(karg))) {
1215		printk(KERN_ERR "failure at %s:%d/%s()!\n",
1216		    __FILE__, __LINE__, __func__);
1217		return -EFAULT;
1218	}
1219	if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1220		return -ENODEV;
1221
1222	dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1223	    __func__));
1224
1225	rc = _ctl_btdh_search_sas_device(ioc, &karg);
1226	if (!rc)
1227		_ctl_btdh_search_raid_device(ioc, &karg);
1228
1229	if (copy_to_user(arg, &karg, sizeof(karg))) {
1230		printk(KERN_ERR "failure at %s:%d/%s()!\n",
1231		    __FILE__, __LINE__, __func__);
1232		return -EFAULT;
1233	}
1234	return 0;
1235}
1236
1237/**
1238 * _ctl_diag_capability - return diag buffer capability
1239 * @ioc: per adapter object
1240 * @buffer_type: specifies either TRACE, SNAPSHOT, or EXTENDED
1241 *
1242 * returns 1 when diag buffer support is enabled in firmware
1243 */
1244static u8
1245_ctl_diag_capability(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type)
1246{
1247	u8 rc = 0;
1248
1249	switch (buffer_type) {
1250	case MPI2_DIAG_BUF_TYPE_TRACE:
1251		if (ioc->facts.IOCCapabilities &
1252		    MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER)
1253			rc = 1;
1254		break;
1255	case MPI2_DIAG_BUF_TYPE_SNAPSHOT:
1256		if (ioc->facts.IOCCapabilities &
1257		    MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER)
1258			rc = 1;
1259		break;
1260	case MPI2_DIAG_BUF_TYPE_EXTENDED:
1261		if (ioc->facts.IOCCapabilities &
1262		    MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER)
1263			rc = 1;
1264	}
1265
1266	return rc;
1267}
1268
1269/**
1270 * _ctl_diag_register_2 - wrapper for registering diag buffer support
1271 * @ioc: per adapter object
1272 * @diag_register: the diag_register struct passed in from user space
1273 *
1274 */
1275static long
1276_ctl_diag_register_2(struct MPT2SAS_ADAPTER *ioc,
1277    struct mpt2_diag_register *diag_register)
1278{
1279	int rc, i;
1280	void *request_data = NULL;
1281	dma_addr_t request_data_dma;
1282	u32 request_data_sz = 0;
1283	Mpi2DiagBufferPostRequest_t *mpi_request;
1284	Mpi2DiagBufferPostReply_t *mpi_reply;
1285	u8 buffer_type;
1286	unsigned long timeleft;
1287	u16 smid;
1288	u16 ioc_status;
1289	u8 issue_reset = 0;
1290
1291	dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1292	    __func__));
1293
1294	if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
1295		printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
1296		    ioc->name, __func__);
1297		rc = -EAGAIN;
1298		goto out;
1299	}
1300
1301	buffer_type = diag_register->buffer_type;
1302	if (!_ctl_diag_capability(ioc, buffer_type)) {
1303		printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
1304		    "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1305		return -EPERM;
1306	}
1307
1308	if (ioc->diag_buffer_status[buffer_type] &
1309	    MPT2_DIAG_BUFFER_IS_REGISTERED) {
1310		printk(MPT2SAS_ERR_FMT "%s: already has a registered "
1311		    "buffer for buffer_type(0x%02x)\n", ioc->name, __func__,
1312		    buffer_type);
1313		return -EINVAL;
1314	}
1315
1316	if (diag_register->requested_buffer_size % 4)  {
1317		printk(MPT2SAS_ERR_FMT "%s: the requested_buffer_size "
1318		    "is not 4 byte aligned\n", ioc->name, __func__);
1319		return -EINVAL;
1320	}
1321
1322	smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
1323	if (!smid) {
1324		printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
1325		    ioc->name, __func__);
1326		rc = -EAGAIN;
1327		goto out;
1328	}
1329
1330	rc = 0;
1331	ioc->ctl_cmds.status = MPT2_CMD_PENDING;
1332	memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
1333	mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
1334	ioc->ctl_cmds.smid = smid;
1335
1336	request_data = ioc->diag_buffer[buffer_type];
1337	request_data_sz = diag_register->requested_buffer_size;
1338	ioc->unique_id[buffer_type] = diag_register->unique_id;
1339	ioc->diag_buffer_status[buffer_type] = 0;
1340	memcpy(ioc->product_specific[buffer_type],
1341	    diag_register->product_specific, MPT2_PRODUCT_SPECIFIC_DWORDS);
1342	ioc->diagnostic_flags[buffer_type] = diag_register->diagnostic_flags;
1343
1344	if (request_data) {
1345		request_data_dma = ioc->diag_buffer_dma[buffer_type];
1346		if (request_data_sz != ioc->diag_buffer_sz[buffer_type]) {
1347			pci_free_consistent(ioc->pdev,
1348			    ioc->diag_buffer_sz[buffer_type],
1349			    request_data, request_data_dma);
1350			request_data = NULL;
1351		}
1352	}
1353
1354	if (request_data == NULL) {
1355		ioc->diag_buffer_sz[buffer_type] = 0;
1356		ioc->diag_buffer_dma[buffer_type] = 0;
1357		request_data = pci_alloc_consistent(
1358			ioc->pdev, request_data_sz, &request_data_dma);
1359		if (request_data == NULL) {
1360			printk(MPT2SAS_ERR_FMT "%s: failed allocating memory"
1361			    " for diag buffers, requested size(%d)\n",
1362			    ioc->name, __func__, request_data_sz);
1363			mpt2sas_base_free_smid(ioc, smid);
1364			return -ENOMEM;
1365		}
1366		ioc->diag_buffer[buffer_type] = request_data;
1367		ioc->diag_buffer_sz[buffer_type] = request_data_sz;
1368		ioc->diag_buffer_dma[buffer_type] = request_data_dma;
1369	}
1370
1371	mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST;
1372	mpi_request->BufferType = diag_register->buffer_type;
1373	mpi_request->Flags = cpu_to_le32(diag_register->diagnostic_flags);
1374	mpi_request->BufferAddress = cpu_to_le64(request_data_dma);
1375	mpi_request->BufferLength = cpu_to_le32(request_data_sz);
1376	mpi_request->VF_ID = 0; /* TODO */
1377	mpi_request->VP_ID = 0;
1378
1379	dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: diag_buffer(0x%p), "
1380	    "dma(0x%llx), sz(%d)\n", ioc->name, __func__, request_data,
1381	    (unsigned long long)request_data_dma,
1382	    le32_to_cpu(mpi_request->BufferLength)));
1383
1384	for (i = 0; i < MPT2_PRODUCT_SPECIFIC_DWORDS; i++)
1385		mpi_request->ProductSpecific[i] =
1386			cpu_to_le32(ioc->product_specific[buffer_type][i]);
1387
1388	mpt2sas_base_put_smid_default(ioc, smid);
1389	init_completion(&ioc->ctl_cmds.done);
1390	timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
1391	    MPT2_IOCTL_DEFAULT_TIMEOUT*HZ);
1392
1393	if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
1394		printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
1395		    __func__);
1396		_debug_dump_mf(mpi_request,
1397		    sizeof(Mpi2DiagBufferPostRequest_t)/4);
1398		if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
1399			issue_reset = 1;
1400		goto issue_host_reset;
1401	}
1402
1403	/* process the completed Reply Message Frame */
1404	if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) {
1405		printk(MPT2SAS_ERR_FMT "%s: no reply message\n",
1406		    ioc->name, __func__);
1407		rc = -EFAULT;
1408		goto out;
1409	}
1410
1411	mpi_reply = ioc->ctl_cmds.reply;
1412	ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1413
1414	if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
1415		ioc->diag_buffer_status[buffer_type] |=
1416			MPT2_DIAG_BUFFER_IS_REGISTERED;
1417		dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: success\n",
1418		    ioc->name, __func__));
1419	} else {
1420		printk(MPT2SAS_INFO_FMT "%s: ioc_status(0x%04x) "
1421		    "log_info(0x%08x)\n", ioc->name, __func__,
1422		    ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
1423		rc = -EFAULT;
1424	}
1425
1426 issue_host_reset:
1427	if (issue_reset)
1428		mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1429		    FORCE_BIG_HAMMER);
1430
1431 out:
1432
1433	if (rc && request_data)
1434		pci_free_consistent(ioc->pdev, request_data_sz,
1435		    request_data, request_data_dma);
1436
1437	ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
1438	return rc;
1439}
1440
1441/**
1442 * mpt2sas_enable_diag_buffer - enabling diag_buffers support driver load time
1443 * @ioc: per adapter object
1444 * @bits_to_register: bitwise field where trace is bit 0, and snapshot is bit 1
1445 *
1446 * This is called when command line option diag_buffer_enable is enabled
1447 * at driver load time.
1448 */
1449void
1450mpt2sas_enable_diag_buffer(struct MPT2SAS_ADAPTER *ioc, u8 bits_to_register)
1451{
1452	struct mpt2_diag_register diag_register;
1453
1454	memset(&diag_register, 0, sizeof(struct mpt2_diag_register));
1455
1456	if (bits_to_register & 1) {
1457		printk(MPT2SAS_INFO_FMT "registering trace buffer support\n",
1458		    ioc->name);
1459		diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE;
1460		/* register for 1MB buffers  */
1461		diag_register.requested_buffer_size = (1024 * 1024);
1462		diag_register.unique_id = 0x7075900;
1463		_ctl_diag_register_2(ioc,  &diag_register);
1464	}
1465
1466	if (bits_to_register & 2) {
1467		printk(MPT2SAS_INFO_FMT "registering snapshot buffer support\n",
1468		    ioc->name);
1469		diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_SNAPSHOT;
1470		/* register for 2MB buffers  */
1471		diag_register.requested_buffer_size = 2 * (1024 * 1024);
1472		diag_register.unique_id = 0x7075901;
1473		_ctl_diag_register_2(ioc,  &diag_register);
1474	}
1475
1476	if (bits_to_register & 4) {
1477		printk(MPT2SAS_INFO_FMT "registering extended buffer support\n",
1478		    ioc->name);
1479		diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_EXTENDED;
1480		/* register for 2MB buffers  */
1481		diag_register.requested_buffer_size = 2 * (1024 * 1024);
1482		diag_register.unique_id = 0x7075901;
1483		_ctl_diag_register_2(ioc,  &diag_register);
1484	}
1485}
1486
1487/**
1488 * _ctl_diag_register - application register with driver
1489 * @arg - user space buffer containing ioctl content
1490 * @state - NON_BLOCKING or BLOCKING
1491 *
1492 * This will allow the driver to setup any required buffers that will be
1493 * needed by firmware to communicate with the driver.
1494 */
1495static long
1496_ctl_diag_register(void __user *arg, enum block_state state)
1497{
1498	struct mpt2_diag_register karg;
1499	struct MPT2SAS_ADAPTER *ioc;
1500	long rc;
1501
1502	if (copy_from_user(&karg, arg, sizeof(karg))) {
1503		printk(KERN_ERR "failure at %s:%d/%s()!\n",
1504		    __FILE__, __LINE__, __func__);
1505		return -EFAULT;
1506	}
1507	if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1508		return -ENODEV;
1509
1510	if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
1511		return -EAGAIN;
1512	else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
1513		return -ERESTARTSYS;
1514	rc = _ctl_diag_register_2(ioc, &karg);
1515	mutex_unlock(&ioc->ctl_cmds.mutex);
1516	return rc;
1517}
1518
1519/**
1520 * _ctl_diag_unregister - application unregister with driver
1521 * @arg - user space buffer containing ioctl content
1522 *
1523 * This will allow the driver to cleanup any memory allocated for diag
1524 * messages and to free up any resources.
1525 */
1526static long
1527_ctl_diag_unregister(void __user *arg)
1528{
1529	struct mpt2_diag_unregister karg;
1530	struct MPT2SAS_ADAPTER *ioc;
1531	void *request_data;
1532	dma_addr_t request_data_dma;
1533	u32 request_data_sz;
1534	u8 buffer_type;
1535
1536	if (copy_from_user(&karg, arg, sizeof(karg))) {
1537		printk(KERN_ERR "failure at %s:%d/%s()!\n",
1538		    __FILE__, __LINE__, __func__);
1539		return -EFAULT;
1540	}
1541	if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1542		return -ENODEV;
1543
1544	dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1545	    __func__));
1546
1547	buffer_type = karg.unique_id & 0x000000ff;
1548	if (!_ctl_diag_capability(ioc, buffer_type)) {
1549		printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
1550		    "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1551		return -EPERM;
1552	}
1553
1554	if ((ioc->diag_buffer_status[buffer_type] &
1555	    MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) {
1556		printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) is not "
1557		    "registered\n", ioc->name, __func__, buffer_type);
1558		return -EINVAL;
1559	}
1560	if ((ioc->diag_buffer_status[buffer_type] &
1561	    MPT2_DIAG_BUFFER_IS_RELEASED) == 0) {
1562		printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) has not been "
1563		    "released\n", ioc->name, __func__, buffer_type);
1564		return -EINVAL;
1565	}
1566
1567	if (karg.unique_id != ioc->unique_id[buffer_type]) {
1568		printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not "
1569		    "registered\n", ioc->name, __func__, karg.unique_id);
1570		return -EINVAL;
1571	}
1572
1573	request_data = ioc->diag_buffer[buffer_type];
1574	if (!request_data) {
1575		printk(MPT2SAS_ERR_FMT "%s: doesn't have memory allocated for "
1576		    "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1577		return -ENOMEM;
1578	}
1579
1580	request_data_sz = ioc->diag_buffer_sz[buffer_type];
1581	request_data_dma = ioc->diag_buffer_dma[buffer_type];
1582	pci_free_consistent(ioc->pdev, request_data_sz,
1583	    request_data, request_data_dma);
1584	ioc->diag_buffer[buffer_type] = NULL;
1585	ioc->diag_buffer_status[buffer_type] = 0;
1586	return 0;
1587}
1588
1589/**
1590 * _ctl_diag_query - query relevant info associated with diag buffers
1591 * @arg - user space buffer containing ioctl content
1592 *
1593 * The application will send only buffer_type and unique_id.  Driver will
1594 * inspect unique_id first, if valid, fill in all the info.  If unique_id is
1595 * 0x00, the driver will return info specified by Buffer Type.
1596 */
1597static long
1598_ctl_diag_query(void __user *arg)
1599{
1600	struct mpt2_diag_query karg;
1601	struct MPT2SAS_ADAPTER *ioc;
1602	void *request_data;
1603	int i;
1604	u8 buffer_type;
1605
1606	if (copy_from_user(&karg, arg, sizeof(karg))) {
1607		printk(KERN_ERR "failure at %s:%d/%s()!\n",
1608		    __FILE__, __LINE__, __func__);
1609		return -EFAULT;
1610	}
1611	if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1612		return -ENODEV;
1613
1614	dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1615	    __func__));
1616
1617	karg.application_flags = 0;
1618	buffer_type = karg.buffer_type;
1619
1620	if (!_ctl_diag_capability(ioc, buffer_type)) {
1621		printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
1622		    "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1623		return -EPERM;
1624	}
1625
1626	if ((ioc->diag_buffer_status[buffer_type] &
1627	    MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) {
1628		printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) is not "
1629		    "registered\n", ioc->name, __func__, buffer_type);
1630		return -EINVAL;
1631	}
1632
1633	if (karg.unique_id & 0xffffff00) {
1634		if (karg.unique_id != ioc->unique_id[buffer_type]) {
1635			printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not "
1636			    "registered\n", ioc->name, __func__,
1637			    karg.unique_id);
1638			return -EINVAL;
1639		}
1640	}
1641
1642	request_data = ioc->diag_buffer[buffer_type];
1643	if (!request_data) {
1644		printk(MPT2SAS_ERR_FMT "%s: doesn't have buffer for "
1645		    "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1646		return -ENOMEM;
1647	}
1648
1649	if (ioc->diag_buffer_status[buffer_type] & MPT2_DIAG_BUFFER_IS_RELEASED)
1650		karg.application_flags = (MPT2_APP_FLAGS_APP_OWNED |
1651		    MPT2_APP_FLAGS_BUFFER_VALID);
1652	else
1653		karg.application_flags = (MPT2_APP_FLAGS_APP_OWNED |
1654		    MPT2_APP_FLAGS_BUFFER_VALID |
1655		    MPT2_APP_FLAGS_FW_BUFFER_ACCESS);
1656
1657	for (i = 0; i < MPT2_PRODUCT_SPECIFIC_DWORDS; i++)
1658		karg.product_specific[i] =
1659		    ioc->product_specific[buffer_type][i];
1660
1661	karg.total_buffer_size = ioc->diag_buffer_sz[buffer_type];
1662	karg.driver_added_buffer_size = 0;
1663	karg.unique_id = ioc->unique_id[buffer_type];
1664	karg.diagnostic_flags = ioc->diagnostic_flags[buffer_type];
1665
1666	if (copy_to_user(arg, &karg, sizeof(struct mpt2_diag_query))) {
1667		printk(MPT2SAS_ERR_FMT "%s: unable to write mpt2_diag_query "
1668		    "data @ %p\n", ioc->name, __func__, arg);
1669		return -EFAULT;
1670	}
1671	return 0;
1672}
1673
1674/**
1675 * _ctl_send_release - Diag Release Message
1676 * @ioc: per adapter object
1677 * @buffer_type - specifies either TRACE, SNAPSHOT, or EXTENDED
1678 * @issue_reset - specifies whether host reset is required.
1679 *
1680 */
1681static int
1682_ctl_send_release(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type, u8 *issue_reset)
1683{
1684	Mpi2DiagReleaseRequest_t *mpi_request;
1685	Mpi2DiagReleaseReply_t *mpi_reply;
1686	u16 smid;
1687	u16 ioc_status;
1688	u32 ioc_state;
1689	int rc;
1690	unsigned long timeleft;
1691
1692	dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1693	    __func__));
1694
1695	rc = 0;
1696	*issue_reset = 0;
1697
1698	ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
1699	if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
1700		dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
1701		    "skipping due to FAULT state\n", ioc->name,
1702		    __func__));
1703		rc = -EAGAIN;
1704		goto out;
1705	}
1706
1707	if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
1708		printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
1709		    ioc->name, __func__);
1710		rc = -EAGAIN;
1711		goto out;
1712	}
1713
1714	smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
1715	if (!smid) {
1716		printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
1717		    ioc->name, __func__);
1718		rc = -EAGAIN;
1719		goto out;
1720	}
1721
1722	ioc->ctl_cmds.status = MPT2_CMD_PENDING;
1723	memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
1724	mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
1725	ioc->ctl_cmds.smid = smid;
1726
1727	mpi_request->Function = MPI2_FUNCTION_DIAG_RELEASE;
1728	mpi_request->BufferType = buffer_type;
1729	mpi_request->VF_ID = 0; /* TODO */
1730	mpi_request->VP_ID = 0;
1731
1732	mpt2sas_base_put_smid_default(ioc, smid);
1733	init_completion(&ioc->ctl_cmds.done);
1734	timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
1735	    MPT2_IOCTL_DEFAULT_TIMEOUT*HZ);
1736
1737	if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
1738		printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
1739		    __func__);
1740		_debug_dump_mf(mpi_request,
1741		    sizeof(Mpi2DiagReleaseRequest_t)/4);
1742		if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
1743			*issue_reset = 1;
1744		rc = -EFAULT;
1745		goto out;
1746	}
1747
1748	/* process the completed Reply Message Frame */
1749	if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) {
1750		printk(MPT2SAS_ERR_FMT "%s: no reply message\n",
1751		    ioc->name, __func__);
1752		rc = -EFAULT;
1753		goto out;
1754	}
1755
1756	mpi_reply = ioc->ctl_cmds.reply;
1757	ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1758
1759	if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
1760		ioc->diag_buffer_status[buffer_type] |=
1761		    MPT2_DIAG_BUFFER_IS_RELEASED;
1762		dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: success\n",
1763		    ioc->name, __func__));
1764	} else {
1765		printk(MPT2SAS_INFO_FMT "%s: ioc_status(0x%04x) "
1766		    "log_info(0x%08x)\n", ioc->name, __func__,
1767		    ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
1768		rc = -EFAULT;
1769	}
1770
1771 out:
1772	ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
1773	return rc;
1774}
1775
1776/**
1777 * _ctl_diag_release - request to send Diag Release Message to firmware
1778 * @arg - user space buffer containing ioctl content
1779 * @state - NON_BLOCKING or BLOCKING
1780 *
1781 * This allows ownership of the specified buffer to returned to the driver,
1782 * allowing an application to read the buffer without fear that firmware is
1783 * overwritting information in the buffer.
1784 */
1785static long
1786_ctl_diag_release(void __user *arg, enum block_state state)
1787{
1788	struct mpt2_diag_release karg;
1789	struct MPT2SAS_ADAPTER *ioc;
1790	void *request_data;
1791	int rc;
1792	u8 buffer_type;
1793	u8 issue_reset = 0;
1794
1795	if (copy_from_user(&karg, arg, sizeof(karg))) {
1796		printk(KERN_ERR "failure at %s:%d/%s()!\n",
1797		    __FILE__, __LINE__, __func__);
1798		return -EFAULT;
1799	}
1800	if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1801		return -ENODEV;
1802
1803	dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1804	    __func__));
1805
1806	buffer_type = karg.unique_id & 0x000000ff;
1807	if (!_ctl_diag_capability(ioc, buffer_type)) {
1808		printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
1809		    "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1810		return -EPERM;
1811	}
1812
1813	if ((ioc->diag_buffer_status[buffer_type] &
1814	    MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) {
1815		printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) is not "
1816		    "registered\n", ioc->name, __func__, buffer_type);
1817		return -EINVAL;
1818	}
1819
1820	if (karg.unique_id != ioc->unique_id[buffer_type]) {
1821		printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not "
1822		    "registered\n", ioc->name, __func__, karg.unique_id);
1823		return -EINVAL;
1824	}
1825
1826	if (ioc->diag_buffer_status[buffer_type] &
1827	    MPT2_DIAG_BUFFER_IS_RELEASED) {
1828		printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) "
1829		    "is already released\n", ioc->name, __func__,
1830		    buffer_type);
1831		return 0;
1832	}
1833
1834	request_data = ioc->diag_buffer[buffer_type];
1835
1836	if (!request_data) {
1837		printk(MPT2SAS_ERR_FMT "%s: doesn't have memory allocated for "
1838		    "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1839		return -ENOMEM;
1840	}
1841
1842	/* buffers were released by due to host reset */
1843	if ((ioc->diag_buffer_status[buffer_type] &
1844	    MPT2_DIAG_BUFFER_IS_DIAG_RESET)) {
1845		ioc->diag_buffer_status[buffer_type] |=
1846		    MPT2_DIAG_BUFFER_IS_RELEASED;
1847		ioc->diag_buffer_status[buffer_type] &=
1848		    ~MPT2_DIAG_BUFFER_IS_DIAG_RESET;
1849		printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) "
1850		    "was released due to host reset\n", ioc->name, __func__,
1851		    buffer_type);
1852		return 0;
1853	}
1854
1855	if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
1856		return -EAGAIN;
1857	else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
1858		return -ERESTARTSYS;
1859
1860	rc = _ctl_send_release(ioc, buffer_type, &issue_reset);
1861
1862	if (issue_reset)
1863		mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1864		    FORCE_BIG_HAMMER);
1865
1866	mutex_unlock(&ioc->ctl_cmds.mutex);
1867	return rc;
1868}
1869
1870/**
1871 * _ctl_diag_read_buffer - request for copy of the diag buffer
1872 * @arg - user space buffer containing ioctl content
1873 * @state - NON_BLOCKING or BLOCKING
1874 */
1875static long
1876_ctl_diag_read_buffer(void __user *arg, enum block_state state)
1877{
1878	struct mpt2_diag_read_buffer karg;
1879	struct mpt2_diag_read_buffer __user *uarg = arg;
1880	struct MPT2SAS_ADAPTER *ioc;
1881	void *request_data, *diag_data;
1882	Mpi2DiagBufferPostRequest_t *mpi_request;
1883	Mpi2DiagBufferPostReply_t *mpi_reply;
1884	int rc, i;
1885	u8 buffer_type;
1886	unsigned long timeleft;
1887	u16 smid;
1888	u16 ioc_status;
1889	u8 issue_reset = 0;
1890
1891	if (copy_from_user(&karg, arg, sizeof(karg))) {
1892		printk(KERN_ERR "failure at %s:%d/%s()!\n",
1893		    __FILE__, __LINE__, __func__);
1894		return -EFAULT;
1895	}
1896	if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1897		return -ENODEV;
1898
1899	dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
1900	    __func__));
1901
1902	buffer_type = karg.unique_id & 0x000000ff;
1903	if (!_ctl_diag_capability(ioc, buffer_type)) {
1904		printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
1905		    "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1906		return -EPERM;
1907	}
1908
1909	if (karg.unique_id != ioc->unique_id[buffer_type]) {
1910		printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not "
1911		    "registered\n", ioc->name, __func__, karg.unique_id);
1912		return -EINVAL;
1913	}
1914
1915	request_data = ioc->diag_buffer[buffer_type];
1916	if (!request_data) {
1917		printk(MPT2SAS_ERR_FMT "%s: doesn't have buffer for "
1918		    "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1919		return -ENOMEM;
1920	}
1921
1922	if ((karg.starting_offset % 4) || (karg.bytes_to_read % 4)) {
1923		printk(MPT2SAS_ERR_FMT "%s: either the starting_offset "
1924		    "or bytes_to_read are not 4 byte aligned\n", ioc->name,
1925		    __func__);
1926		return -EINVAL;
1927	}
1928
1929	diag_data = (void *)(request_data + karg.starting_offset);
1930	dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: diag_buffer(%p), "
1931	    "offset(%d), sz(%d)\n", ioc->name, __func__,
1932	    diag_data, karg.starting_offset, karg.bytes_to_read));
1933
1934	if (copy_to_user((void __user *)uarg->diagnostic_data,
1935	    diag_data, karg.bytes_to_read)) {
1936		printk(MPT2SAS_ERR_FMT "%s: Unable to write "
1937		    "mpt_diag_read_buffer_t data @ %p\n", ioc->name,
1938		    __func__, diag_data);
1939		return -EFAULT;
1940	}
1941
1942	if ((karg.flags & MPT2_FLAGS_REREGISTER) == 0)
1943		return 0;
1944
1945	dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: Reregister "
1946		"buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type));
1947	if ((ioc->diag_buffer_status[buffer_type] &
1948	    MPT2_DIAG_BUFFER_IS_RELEASED) == 0) {
1949		dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
1950		    "buffer_type(0x%02x) is still registered\n", ioc->name,
1951		     __func__, buffer_type));
1952		return 0;
1953	}
1954	/* Get a free request frame and save the message context.
1955	*/
1956	if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
1957		return -EAGAIN;
1958	else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
1959		return -ERESTARTSYS;
1960
1961	if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
1962		printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
1963		    ioc->name, __func__);
1964		rc = -EAGAIN;
1965		goto out;
1966	}
1967
1968	smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
1969	if (!smid) {
1970		printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
1971		    ioc->name, __func__);
1972		rc = -EAGAIN;
1973		goto out;
1974	}
1975
1976	rc = 0;
1977	ioc->ctl_cmds.status = MPT2_CMD_PENDING;
1978	memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
1979	mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
1980	ioc->ctl_cmds.smid = smid;
1981
1982	mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST;
1983	mpi_request->BufferType = buffer_type;
1984	mpi_request->BufferLength =
1985	    cpu_to_le32(ioc->diag_buffer_sz[buffer_type]);
1986	mpi_request->BufferAddress =
1987	    cpu_to_le64(ioc->diag_buffer_dma[buffer_type]);
1988	for (i = 0; i < MPT2_PRODUCT_SPECIFIC_DWORDS; i++)
1989		mpi_request->ProductSpecific[i] =
1990			cpu_to_le32(ioc->product_specific[buffer_type][i]);
1991	mpi_request->VF_ID = 0; /* TODO */
1992	mpi_request->VP_ID = 0;
1993
1994	mpt2sas_base_put_smid_default(ioc, smid);
1995	init_completion(&ioc->ctl_cmds.done);
1996	timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
1997	    MPT2_IOCTL_DEFAULT_TIMEOUT*HZ);
1998
1999	if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
2000		printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
2001		    __func__);
2002		_debug_dump_mf(mpi_request,
2003		    sizeof(Mpi2DiagBufferPostRequest_t)/4);
2004		if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
2005			issue_reset = 1;
2006		goto issue_host_reset;
2007	}
2008
2009	/* process the completed Reply Message Frame */
2010	if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) {
2011		printk(MPT2SAS_ERR_FMT "%s: no reply message\n",
2012		    ioc->name, __func__);
2013		rc = -EFAULT;
2014		goto out;
2015	}
2016
2017	mpi_reply = ioc->ctl_cmds.reply;
2018	ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
2019
2020	if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
2021		ioc->diag_buffer_status[buffer_type] |=
2022		    MPT2_DIAG_BUFFER_IS_REGISTERED;
2023		dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: success\n",
2024		    ioc->name, __func__));
2025	} else {
2026		printk(MPT2SAS_INFO_FMT "%s: ioc_status(0x%04x) "
2027		    "log_info(0x%08x)\n", ioc->name, __func__,
2028		    ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
2029		rc = -EFAULT;
2030	}
2031
2032 issue_host_reset:
2033	if (issue_reset)
2034		mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2035		    FORCE_BIG_HAMMER);
2036
2037 out:
2038
2039	ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
2040	mutex_unlock(&ioc->ctl_cmds.mutex);
2041	return rc;
2042}
2043
2044/**
2045 * _ctl_ioctl_main - main ioctl entry point
2046 * @file - (struct file)
2047 * @cmd - ioctl opcode
2048 * @arg -
2049 */
2050static long
2051_ctl_ioctl_main(struct file *file, unsigned int cmd, void __user *arg)
2052{
2053	enum block_state state;
2054	long ret = -EINVAL;
2055
2056	state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING :
2057	    BLOCKING;
2058
2059	switch (cmd) {
2060	case MPT2IOCINFO:
2061		if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_iocinfo))
2062			ret = _ctl_getiocinfo(arg);
2063		break;
2064	case MPT2COMMAND:
2065	{
2066		struct mpt2_ioctl_command karg;
2067		struct mpt2_ioctl_command __user *uarg;
2068		struct MPT2SAS_ADAPTER *ioc;
2069
2070		if (copy_from_user(&karg, arg, sizeof(karg))) {
2071			printk(KERN_ERR "failure at %s:%d/%s()!\n",
2072			    __FILE__, __LINE__, __func__);
2073			return -EFAULT;
2074		}
2075
2076		if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 ||
2077		    !ioc)
2078			return -ENODEV;
2079
2080		if (ioc->shost_recovery)
2081			return -EAGAIN;
2082
2083		if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_command)) {
2084			uarg = arg;
2085			ret = _ctl_do_mpt_command(ioc, karg, &uarg->mf, state);
2086		}
2087		break;
2088	}
2089	case MPT2EVENTQUERY:
2090		if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_eventquery))
2091			ret = _ctl_eventquery(arg);
2092		break;
2093	case MPT2EVENTENABLE:
2094		if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_eventenable))
2095			ret = _ctl_eventenable(arg);
2096		break;
2097	case MPT2EVENTREPORT:
2098		ret = _ctl_eventreport(arg);
2099		break;
2100	case MPT2HARDRESET:
2101		if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_diag_reset))
2102			ret = _ctl_do_reset(arg);
2103		break;
2104	case MPT2BTDHMAPPING:
2105		if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_btdh_mapping))
2106			ret = _ctl_btdh_mapping(arg);
2107		break;
2108	case MPT2DIAGREGISTER:
2109		if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_register))
2110			ret = _ctl_diag_register(arg, state);
2111		break;
2112	case MPT2DIAGUNREGISTER:
2113		if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_unregister))
2114			ret = _ctl_diag_unregister(arg);
2115		break;
2116	case MPT2DIAGQUERY:
2117		if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_query))
2118			ret = _ctl_diag_query(arg);
2119		break;
2120	case MPT2DIAGRELEASE:
2121		if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_release))
2122			ret = _ctl_diag_release(arg, state);
2123		break;
2124	case MPT2DIAGREADBUFFER:
2125		if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_read_buffer))
2126			ret = _ctl_diag_read_buffer(arg, state);
2127		break;
2128	default:
2129	{
2130		struct mpt2_ioctl_command karg;
2131		struct MPT2SAS_ADAPTER *ioc;
2132
2133		if (copy_from_user(&karg, arg, sizeof(karg))) {
2134			printk(KERN_ERR "failure at %s:%d/%s()!\n",
2135			    __FILE__, __LINE__, __func__);
2136			return -EFAULT;
2137		}
2138
2139		if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 ||
2140		    !ioc)
2141			return -ENODEV;
2142
2143		dctlprintk(ioc, printk(MPT2SAS_INFO_FMT
2144		    "unsupported ioctl opcode(0x%08x)\n", ioc->name, cmd));
2145		break;
2146	}
2147	}
2148	return ret;
2149}
2150
2151/**
2152 * _ctl_ioctl - main ioctl entry point (unlocked)
2153 * @file - (struct file)
2154 * @cmd - ioctl opcode
2155 * @arg -
2156 */
2157static long
2158_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2159{
2160	long ret;
2161
2162	lock_kernel();
2163	ret = _ctl_ioctl_main(file, cmd, (void __user *)arg);
2164	unlock_kernel();
2165	return ret;
2166}
2167
2168#ifdef CONFIG_COMPAT
2169/**
2170 * _ctl_compat_mpt_command - convert 32bit pointers to 64bit.
2171 * @file - (struct file)
2172 * @cmd - ioctl opcode
2173 * @arg - (struct mpt2_ioctl_command32)
2174 *
2175 * MPT2COMMAND32 - Handle 32bit applications running on 64bit os.
2176 */
2177static long
2178_ctl_compat_mpt_command(struct file *file, unsigned cmd, unsigned long arg)
2179{
2180	struct mpt2_ioctl_command32 karg32;
2181	struct mpt2_ioctl_command32 __user *uarg;
2182	struct mpt2_ioctl_command karg;
2183	struct MPT2SAS_ADAPTER *ioc;
2184	enum block_state state;
2185
2186	if (_IOC_SIZE(cmd) != sizeof(struct mpt2_ioctl_command32))
2187		return -EINVAL;
2188
2189	uarg = (struct mpt2_ioctl_command32 __user *) arg;
2190
2191	if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32))) {
2192		printk(KERN_ERR "failure at %s:%d/%s()!\n",
2193		    __FILE__, __LINE__, __func__);
2194		return -EFAULT;
2195	}
2196	if (_ctl_verify_adapter(karg32.hdr.ioc_number, &ioc) == -1 || !ioc)
2197		return -ENODEV;
2198
2199	if (ioc->shost_recovery)
2200		return -EAGAIN;
2201
2202	memset(&karg, 0, sizeof(struct mpt2_ioctl_command));
2203	karg.hdr.ioc_number = karg32.hdr.ioc_number;
2204	karg.hdr.port_number = karg32.hdr.port_number;
2205	karg.hdr.max_data_size = karg32.hdr.max_data_size;
2206	karg.timeout = karg32.timeout;
2207	karg.max_reply_bytes = karg32.max_reply_bytes;
2208	karg.data_in_size = karg32.data_in_size;
2209	karg.data_out_size = karg32.data_out_size;
2210	karg.max_sense_bytes = karg32.max_sense_bytes;
2211	karg.data_sge_offset = karg32.data_sge_offset;
2212	karg.reply_frame_buf_ptr = compat_ptr(karg32.reply_frame_buf_ptr);
2213	karg.data_in_buf_ptr = compat_ptr(karg32.data_in_buf_ptr);
2214	karg.data_out_buf_ptr = compat_ptr(karg32.data_out_buf_ptr);
2215	karg.sense_data_ptr = compat_ptr(karg32.sense_data_ptr);
2216	state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : BLOCKING;
2217	return _ctl_do_mpt_command(ioc, karg, &uarg->mf, state);
2218}
2219
2220/**
2221 * _ctl_ioctl_compat - main ioctl entry point (compat)
2222 * @file -
2223 * @cmd -
2224 * @arg -
2225 *
2226 * This routine handles 32 bit applications in 64bit os.
2227 */
2228static long
2229_ctl_ioctl_compat(struct file *file, unsigned cmd, unsigned long arg)
2230{
2231	long ret;
2232
2233	lock_kernel();
2234	if (cmd == MPT2COMMAND32)
2235		ret = _ctl_compat_mpt_command(file, cmd, arg);
2236	else
2237		ret = _ctl_ioctl_main(file, cmd, (void __user *)arg);
2238	unlock_kernel();
2239	return ret;
2240}
2241#endif
2242
2243/* scsi host attributes */
2244
2245/**
2246 * _ctl_version_fw_show - firmware version
2247 * @cdev - pointer to embedded class device
2248 * @buf - the buffer returned
2249 *
2250 * A sysfs 'read-only' shost attribute.
2251 */
2252static ssize_t
2253_ctl_version_fw_show(struct device *cdev, struct device_attribute *attr,
2254    char *buf)
2255{
2256	struct Scsi_Host *shost = class_to_shost(cdev);
2257	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2258
2259	return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
2260	    (ioc->facts.FWVersion.Word & 0xFF000000) >> 24,
2261	    (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16,
2262	    (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
2263	    ioc->facts.FWVersion.Word & 0x000000FF);
2264}
2265static DEVICE_ATTR(version_fw, S_IRUGO, _ctl_version_fw_show, NULL);
2266
2267/**
2268 * _ctl_version_bios_show - bios version
2269 * @cdev - pointer to embedded class device
2270 * @buf - the buffer returned
2271 *
2272 * A sysfs 'read-only' shost attribute.
2273 */
2274static ssize_t
2275_ctl_version_bios_show(struct device *cdev, struct device_attribute *attr,
2276    char *buf)
2277{
2278	struct Scsi_Host *shost = class_to_shost(cdev);
2279	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2280
2281	u32 version = le32_to_cpu(ioc->bios_pg3.BiosVersion);
2282
2283	return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
2284	    (version & 0xFF000000) >> 24,
2285	    (version & 0x00FF0000) >> 16,
2286	    (version & 0x0000FF00) >> 8,
2287	    version & 0x000000FF);
2288}
2289static DEVICE_ATTR(version_bios, S_IRUGO, _ctl_version_bios_show, NULL);
2290
2291/**
2292 * _ctl_version_mpi_show - MPI (message passing interface) version
2293 * @cdev - pointer to embedded class device
2294 * @buf - the buffer returned
2295 *
2296 * A sysfs 'read-only' shost attribute.
2297 */
2298static ssize_t
2299_ctl_version_mpi_show(struct device *cdev, struct device_attribute *attr,
2300    char *buf)
2301{
2302	struct Scsi_Host *shost = class_to_shost(cdev);
2303	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2304
2305	return snprintf(buf, PAGE_SIZE, "%03x.%02x\n",
2306	    ioc->facts.MsgVersion, ioc->facts.HeaderVersion >> 8);
2307}
2308static DEVICE_ATTR(version_mpi, S_IRUGO, _ctl_version_mpi_show, NULL);
2309
2310/**
2311 * _ctl_version_product_show - product name
2312 * @cdev - pointer to embedded class device
2313 * @buf - the buffer returned
2314 *
2315 * A sysfs 'read-only' shost attribute.
2316 */
2317static ssize_t
2318_ctl_version_product_show(struct device *cdev, struct device_attribute *attr,
2319    char *buf)
2320{
2321	struct Scsi_Host *shost = class_to_shost(cdev);
2322	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2323
2324	return snprintf(buf, 16, "%s\n", ioc->manu_pg0.ChipName);
2325}
2326static DEVICE_ATTR(version_product, S_IRUGO,
2327   _ctl_version_product_show, NULL);
2328
2329/**
2330 * _ctl_version_nvdata_persistent_show - ndvata persistent version
2331 * @cdev - pointer to embedded class device
2332 * @buf - the buffer returned
2333 *
2334 * A sysfs 'read-only' shost attribute.
2335 */
2336static ssize_t
2337_ctl_version_nvdata_persistent_show(struct device *cdev,
2338    struct device_attribute *attr, char *buf)
2339{
2340	struct Scsi_Host *shost = class_to_shost(cdev);
2341	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2342
2343	return snprintf(buf, PAGE_SIZE, "%08xh\n",
2344	    le32_to_cpu(ioc->iounit_pg0.NvdataVersionPersistent.Word));
2345}
2346static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO,
2347    _ctl_version_nvdata_persistent_show, NULL);
2348
2349/**
2350 * _ctl_version_nvdata_default_show - nvdata default version
2351 * @cdev - pointer to embedded class device
2352 * @buf - the buffer returned
2353 *
2354 * A sysfs 'read-only' shost attribute.
2355 */
2356static ssize_t
2357_ctl_version_nvdata_default_show(struct device *cdev,
2358    struct device_attribute *attr, char *buf)
2359{
2360	struct Scsi_Host *shost = class_to_shost(cdev);
2361	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2362
2363	return snprintf(buf, PAGE_SIZE, "%08xh\n",
2364	    le32_to_cpu(ioc->iounit_pg0.NvdataVersionDefault.Word));
2365}
2366static DEVICE_ATTR(version_nvdata_default, S_IRUGO,
2367    _ctl_version_nvdata_default_show, NULL);
2368
2369/**
2370 * _ctl_board_name_show - board name
2371 * @cdev - pointer to embedded class device
2372 * @buf - the buffer returned
2373 *
2374 * A sysfs 'read-only' shost attribute.
2375 */
2376static ssize_t
2377_ctl_board_name_show(struct device *cdev, struct device_attribute *attr,
2378    char *buf)
2379{
2380	struct Scsi_Host *shost = class_to_shost(cdev);
2381	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2382
2383	return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardName);
2384}
2385static DEVICE_ATTR(board_name, S_IRUGO, _ctl_board_name_show, NULL);
2386
2387/**
2388 * _ctl_board_assembly_show - board assembly name
2389 * @cdev - pointer to embedded class device
2390 * @buf - the buffer returned
2391 *
2392 * A sysfs 'read-only' shost attribute.
2393 */
2394static ssize_t
2395_ctl_board_assembly_show(struct device *cdev, struct device_attribute *attr,
2396    char *buf)
2397{
2398	struct Scsi_Host *shost = class_to_shost(cdev);
2399	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2400
2401	return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardAssembly);
2402}
2403static DEVICE_ATTR(board_assembly, S_IRUGO,
2404    _ctl_board_assembly_show, NULL);
2405
2406/**
2407 * _ctl_board_tracer_show - board tracer number
2408 * @cdev - pointer to embedded class device
2409 * @buf - the buffer returned
2410 *
2411 * A sysfs 'read-only' shost attribute.
2412 */
2413static ssize_t
2414_ctl_board_tracer_show(struct device *cdev, struct device_attribute *attr,
2415    char *buf)
2416{
2417	struct Scsi_Host *shost = class_to_shost(cdev);
2418	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2419
2420	return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardTracerNumber);
2421}
2422static DEVICE_ATTR(board_tracer, S_IRUGO,
2423    _ctl_board_tracer_show, NULL);
2424
2425/**
2426 * _ctl_io_delay_show - io missing delay
2427 * @cdev - pointer to embedded class device
2428 * @buf - the buffer returned
2429 *
2430 * This is for firmware implemention for deboucing device
2431 * removal events.
2432 *
2433 * A sysfs 'read-only' shost attribute.
2434 */
2435static ssize_t
2436_ctl_io_delay_show(struct device *cdev, struct device_attribute *attr,
2437    char *buf)
2438{
2439	struct Scsi_Host *shost = class_to_shost(cdev);
2440	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2441
2442	return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay);
2443}
2444static DEVICE_ATTR(io_delay, S_IRUGO,
2445    _ctl_io_delay_show, NULL);
2446
2447/**
2448 * _ctl_device_delay_show - device missing delay
2449 * @cdev - pointer to embedded class device
2450 * @buf - the buffer returned
2451 *
2452 * This is for firmware implemention for deboucing device
2453 * removal events.
2454 *
2455 * A sysfs 'read-only' shost attribute.
2456 */
2457static ssize_t
2458_ctl_device_delay_show(struct device *cdev, struct device_attribute *attr,
2459    char *buf)
2460{
2461	struct Scsi_Host *shost = class_to_shost(cdev);
2462	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2463
2464	return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay);
2465}
2466static DEVICE_ATTR(device_delay, S_IRUGO,
2467    _ctl_device_delay_show, NULL);
2468
2469/**
2470 * _ctl_fw_queue_depth_show - global credits
2471 * @cdev - pointer to embedded class device
2472 * @buf - the buffer returned
2473 *
2474 * This is firmware queue depth limit
2475 *
2476 * A sysfs 'read-only' shost attribute.
2477 */
2478static ssize_t
2479_ctl_fw_queue_depth_show(struct device *cdev, struct device_attribute *attr,
2480    char *buf)
2481{
2482	struct Scsi_Host *shost = class_to_shost(cdev);
2483	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2484
2485	return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->facts.RequestCredit);
2486}
2487static DEVICE_ATTR(fw_queue_depth, S_IRUGO,
2488    _ctl_fw_queue_depth_show, NULL);
2489
2490/**
2491 * _ctl_sas_address_show - sas address
2492 * @cdev - pointer to embedded class device
2493 * @buf - the buffer returned
2494 *
2495 * This is the controller sas address
2496 *
2497 * A sysfs 'read-only' shost attribute.
2498 */
2499static ssize_t
2500_ctl_host_sas_address_show(struct device *cdev, struct device_attribute *attr,
2501    char *buf)
2502{
2503	struct Scsi_Host *shost = class_to_shost(cdev);
2504	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2505
2506	return snprintf(buf, PAGE_SIZE, "0x%016llx\n",
2507	    (unsigned long long)ioc->sas_hba.sas_address);
2508}
2509static DEVICE_ATTR(host_sas_address, S_IRUGO,
2510    _ctl_host_sas_address_show, NULL);
2511
2512/**
2513 * _ctl_logging_level_show - logging level
2514 * @cdev - pointer to embedded class device
2515 * @buf - the buffer returned
2516 *
2517 * A sysfs 'read/write' shost attribute.
2518 */
2519static ssize_t
2520_ctl_logging_level_show(struct device *cdev, struct device_attribute *attr,
2521    char *buf)
2522{
2523	struct Scsi_Host *shost = class_to_shost(cdev);
2524	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2525
2526	return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->logging_level);
2527}
2528static ssize_t
2529_ctl_logging_level_store(struct device *cdev, struct device_attribute *attr,
2530    const char *buf, size_t count)
2531{
2532	struct Scsi_Host *shost = class_to_shost(cdev);
2533	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2534	int val = 0;
2535
2536	if (sscanf(buf, "%x", &val) != 1)
2537		return -EINVAL;
2538
2539	ioc->logging_level = val;
2540	printk(MPT2SAS_INFO_FMT "logging_level=%08xh\n", ioc->name,
2541	    ioc->logging_level);
2542	return strlen(buf);
2543}
2544static DEVICE_ATTR(logging_level, S_IRUGO | S_IWUSR,
2545    _ctl_logging_level_show, _ctl_logging_level_store);
2546
2547/* device attributes */
2548/*
2549 * _ctl_fwfault_debug_show - show/store fwfault_debug
2550 * @cdev - pointer to embedded class device
2551 * @buf - the buffer returned
2552 *
2553 * mpt2sas_fwfault_debug is command line option
2554 * A sysfs 'read/write' shost attribute.
2555 */
2556static ssize_t
2557_ctl_fwfault_debug_show(struct device *cdev,
2558    struct device_attribute *attr, char *buf)
2559{
2560	struct Scsi_Host *shost = class_to_shost(cdev);
2561	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2562
2563	return snprintf(buf, PAGE_SIZE, "%d\n", ioc->fwfault_debug);
2564}
2565static ssize_t
2566_ctl_fwfault_debug_store(struct device *cdev,
2567    struct device_attribute *attr, const char *buf, size_t count)
2568{
2569	struct Scsi_Host *shost = class_to_shost(cdev);
2570	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2571	int val = 0;
2572
2573	if (sscanf(buf, "%d", &val) != 1)
2574		return -EINVAL;
2575
2576	ioc->fwfault_debug = val;
2577	printk(MPT2SAS_INFO_FMT "fwfault_debug=%d\n", ioc->name,
2578	    ioc->fwfault_debug);
2579	return strlen(buf);
2580}
2581static DEVICE_ATTR(fwfault_debug, S_IRUGO | S_IWUSR,
2582    _ctl_fwfault_debug_show, _ctl_fwfault_debug_store);
2583
2584
2585/**
2586 * _ctl_ioc_reset_count_show - ioc reset count
2587 * @cdev - pointer to embedded class device
2588 * @buf - the buffer returned
2589 *
2590 * This is firmware queue depth limit
2591 *
2592 * A sysfs 'read-only' shost attribute.
2593 */
2594static ssize_t
2595_ctl_ioc_reset_count_show(struct device *cdev, struct device_attribute *attr,
2596    char *buf)
2597{
2598	struct Scsi_Host *shost = class_to_shost(cdev);
2599	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2600
2601	return snprintf(buf, PAGE_SIZE, "%08d\n", ioc->ioc_reset_count);
2602}
2603static DEVICE_ATTR(ioc_reset_count, S_IRUGO,
2604    _ctl_ioc_reset_count_show, NULL);
2605
2606struct DIAG_BUFFER_START {
2607	u32 Size;
2608	u32 DiagVersion;
2609	u8 BufferType;
2610	u8 Reserved[3];
2611	u32 Reserved1;
2612	u32 Reserved2;
2613	u32 Reserved3;
2614};
2615/**
2616 * _ctl_host_trace_buffer_size_show - host buffer size (trace only)
2617 * @cdev - pointer to embedded class device
2618 * @buf - the buffer returned
2619 *
2620 * A sysfs 'read-only' shost attribute.
2621 */
2622static ssize_t
2623_ctl_host_trace_buffer_size_show(struct device *cdev,
2624    struct device_attribute *attr, char *buf)
2625{
2626	struct Scsi_Host *shost = class_to_shost(cdev);
2627	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2628	u32 size = 0;
2629	struct DIAG_BUFFER_START *request_data;
2630
2631	if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) {
2632		printk(MPT2SAS_ERR_FMT "%s: host_trace_buffer is not "
2633		    "registered\n", ioc->name, __func__);
2634		return 0;
2635	}
2636
2637	if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2638	    MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) {
2639		printk(MPT2SAS_ERR_FMT "%s: host_trace_buffer is not "
2640		    "registered\n", ioc->name, __func__);
2641		return 0;
2642	}
2643
2644	request_data = (struct DIAG_BUFFER_START *)
2645	    ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE];
2646	if ((le32_to_cpu(request_data->DiagVersion) == 0x00000000 ||
2647	    le32_to_cpu(request_data->DiagVersion) == 0x01000000) &&
2648	    le32_to_cpu(request_data->Reserved3) == 0x4742444c)
2649		size = le32_to_cpu(request_data->Size);
2650
2651	ioc->ring_buffer_sz = size;
2652	return snprintf(buf, PAGE_SIZE, "%d\n", size);
2653}
2654static DEVICE_ATTR(host_trace_buffer_size, S_IRUGO,
2655	 _ctl_host_trace_buffer_size_show, NULL);
2656
2657/**
2658 * _ctl_host_trace_buffer_show - firmware ring buffer (trace only)
2659 * @cdev - pointer to embedded class device
2660 * @buf - the buffer returned
2661 *
2662 * A sysfs 'read/write' shost attribute.
2663 *
2664 * You will only be able to read 4k bytes of ring buffer at a time.
2665 * In order to read beyond 4k bytes, you will have to write out the
2666 * offset to the same attribute, it will move the pointer.
2667 */
2668static ssize_t
2669_ctl_host_trace_buffer_show(struct device *cdev, struct device_attribute *attr,
2670     char *buf)
2671{
2672	struct Scsi_Host *shost = class_to_shost(cdev);
2673	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2674	void *request_data;
2675	u32 size;
2676
2677	if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) {
2678		printk(MPT2SAS_ERR_FMT "%s: host_trace_buffer is not "
2679		    "registered\n", ioc->name, __func__);
2680		return 0;
2681	}
2682
2683	if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2684	    MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) {
2685		printk(MPT2SAS_ERR_FMT "%s: host_trace_buffer is not "
2686		    "registered\n", ioc->name, __func__);
2687		return 0;
2688	}
2689
2690	if (ioc->ring_buffer_offset > ioc->ring_buffer_sz)
2691		return 0;
2692
2693	size = ioc->ring_buffer_sz - ioc->ring_buffer_offset;
2694	size = (size > PAGE_SIZE) ? PAGE_SIZE : size;
2695	request_data = ioc->diag_buffer[0] + ioc->ring_buffer_offset;
2696	memcpy(buf, request_data, size);
2697	return size;
2698}
2699
2700static ssize_t
2701_ctl_host_trace_buffer_store(struct device *cdev, struct device_attribute *attr,
2702    const char *buf, size_t count)
2703{
2704	struct Scsi_Host *shost = class_to_shost(cdev);
2705	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2706	int val = 0;
2707
2708	if (sscanf(buf, "%d", &val) != 1)
2709		return -EINVAL;
2710
2711	ioc->ring_buffer_offset = val;
2712	return strlen(buf);
2713}
2714static DEVICE_ATTR(host_trace_buffer, S_IRUGO | S_IWUSR,
2715    _ctl_host_trace_buffer_show, _ctl_host_trace_buffer_store);
2716
2717/*****************************************/
2718
2719/**
2720 * _ctl_host_trace_buffer_enable_show - firmware ring buffer (trace only)
2721 * @cdev - pointer to embedded class device
2722 * @buf - the buffer returned
2723 *
2724 * A sysfs 'read/write' shost attribute.
2725 *
2726 * This is a mechnism to post/release host_trace_buffers
2727 */
2728static ssize_t
2729_ctl_host_trace_buffer_enable_show(struct device *cdev,
2730    struct device_attribute *attr, char *buf)
2731{
2732	struct Scsi_Host *shost = class_to_shost(cdev);
2733	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2734
2735	if ((!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) ||
2736	   ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2737	    MPT2_DIAG_BUFFER_IS_REGISTERED) == 0))
2738		return snprintf(buf, PAGE_SIZE, "off\n");
2739	else if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2740	    MPT2_DIAG_BUFFER_IS_RELEASED))
2741		return snprintf(buf, PAGE_SIZE, "release\n");
2742	else
2743		return snprintf(buf, PAGE_SIZE, "post\n");
2744}
2745
2746static ssize_t
2747_ctl_host_trace_buffer_enable_store(struct device *cdev,
2748    struct device_attribute *attr, const char *buf, size_t count)
2749{
2750	struct Scsi_Host *shost = class_to_shost(cdev);
2751	struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2752	char str[10] = "";
2753	struct mpt2_diag_register diag_register;
2754	u8 issue_reset = 0;
2755
2756	if (sscanf(buf, "%s", str) != 1)
2757		return -EINVAL;
2758
2759	if (!strcmp(str, "post")) {
2760		/* exit out if host buffers are already posted */
2761		if ((ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) &&
2762		    (ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2763		    MPT2_DIAG_BUFFER_IS_REGISTERED) &&
2764		    ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2765		    MPT2_DIAG_BUFFER_IS_RELEASED) == 0))
2766			goto out;
2767		memset(&diag_register, 0, sizeof(struct mpt2_diag_register));
2768		printk(MPT2SAS_INFO_FMT "posting host trace buffers\n",
2769		    ioc->name);
2770		diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE;
2771		diag_register.requested_buffer_size = (1024 * 1024);
2772		diag_register.unique_id = 0x7075900;
2773		ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] = 0;
2774		_ctl_diag_register_2(ioc,  &diag_register);
2775	} else if (!strcmp(str, "release")) {
2776		/* exit out if host buffers are already released */
2777		if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE])
2778			goto out;
2779		if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2780		    MPT2_DIAG_BUFFER_IS_REGISTERED) == 0)
2781			goto out;
2782		if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2783		    MPT2_DIAG_BUFFER_IS_RELEASED))
2784			goto out;
2785		printk(MPT2SAS_INFO_FMT "releasing host trace buffer\n",
2786		    ioc->name);
2787		_ctl_send_release(ioc, MPI2_DIAG_BUF_TYPE_TRACE, &issue_reset);
2788	}
2789
2790 out:
2791	return strlen(buf);
2792}
2793static DEVICE_ATTR(host_trace_buffer_enable, S_IRUGO | S_IWUSR,
2794    _ctl_host_trace_buffer_enable_show, _ctl_host_trace_buffer_enable_store);
2795
2796struct device_attribute *mpt2sas_host_attrs[] = {
2797	&dev_attr_version_fw,
2798	&dev_attr_version_bios,
2799	&dev_attr_version_mpi,
2800	&dev_attr_version_product,
2801	&dev_attr_version_nvdata_persistent,
2802	&dev_attr_version_nvdata_default,
2803	&dev_attr_board_name,
2804	&dev_attr_board_assembly,
2805	&dev_attr_board_tracer,
2806	&dev_attr_io_delay,
2807	&dev_attr_device_delay,
2808	&dev_attr_logging_level,
2809	&dev_attr_fwfault_debug,
2810	&dev_attr_fw_queue_depth,
2811	&dev_attr_host_sas_address,
2812	&dev_attr_ioc_reset_count,
2813	&dev_attr_host_trace_buffer_size,
2814	&dev_attr_host_trace_buffer,
2815	&dev_attr_host_trace_buffer_enable,
2816	NULL,
2817};
2818
2819/**
2820 * _ctl_device_sas_address_show - sas address
2821 * @cdev - pointer to embedded class device
2822 * @buf - the buffer returned
2823 *
2824 * This is the sas address for the target
2825 *
2826 * A sysfs 'read-only' shost attribute.
2827 */
2828static ssize_t
2829_ctl_device_sas_address_show(struct device *dev, struct device_attribute *attr,
2830    char *buf)
2831{
2832	struct scsi_device *sdev = to_scsi_device(dev);
2833	struct MPT2SAS_DEVICE *sas_device_priv_data = sdev->hostdata;
2834
2835	return snprintf(buf, PAGE_SIZE, "0x%016llx\n",
2836	    (unsigned long long)sas_device_priv_data->sas_target->sas_address);
2837}
2838static DEVICE_ATTR(sas_address, S_IRUGO, _ctl_device_sas_address_show, NULL);
2839
2840/**
2841 * _ctl_device_handle_show - device handle
2842 * @cdev - pointer to embedded class device
2843 * @buf - the buffer returned
2844 *
2845 * This is the firmware assigned device handle
2846 *
2847 * A sysfs 'read-only' shost attribute.
2848 */
2849static ssize_t
2850_ctl_device_handle_show(struct device *dev, struct device_attribute *attr,
2851    char *buf)
2852{
2853	struct scsi_device *sdev = to_scsi_device(dev);
2854	struct MPT2SAS_DEVICE *sas_device_priv_data = sdev->hostdata;
2855
2856	return snprintf(buf, PAGE_SIZE, "0x%04x\n",
2857	    sas_device_priv_data->sas_target->handle);
2858}
2859static DEVICE_ATTR(sas_device_handle, S_IRUGO, _ctl_device_handle_show, NULL);
2860
2861struct device_attribute *mpt2sas_dev_attrs[] = {
2862	&dev_attr_sas_address,
2863	&dev_attr_sas_device_handle,
2864	NULL,
2865};
2866
2867static const struct file_operations ctl_fops = {
2868	.owner = THIS_MODULE,
2869	.unlocked_ioctl = _ctl_ioctl,
2870	.release = _ctl_release,
2871	.poll = _ctl_poll,
2872	.fasync = _ctl_fasync,
2873#ifdef CONFIG_COMPAT
2874	.compat_ioctl = _ctl_ioctl_compat,
2875#endif
2876};
2877
2878static struct miscdevice ctl_dev = {
2879	.minor  = MPT2SAS_MINOR,
2880	.name   = MPT2SAS_DEV_NAME,
2881	.fops   = &ctl_fops,
2882};
2883
2884/**
2885 * mpt2sas_ctl_init - main entry point for ctl.
2886 *
2887 */
2888void
2889mpt2sas_ctl_init(void)
2890{
2891	async_queue = NULL;
2892	if (misc_register(&ctl_dev) < 0)
2893		printk(KERN_ERR "%s can't register misc device [minor=%d]\n",
2894		    MPT2SAS_DRIVER_NAME, MPT2SAS_MINOR);
2895
2896	init_waitqueue_head(&ctl_poll_wait);
2897}
2898
2899/**
2900 * mpt2sas_ctl_exit - exit point for ctl
2901 *
2902 */
2903void
2904mpt2sas_ctl_exit(void)
2905{
2906	struct MPT2SAS_ADAPTER *ioc;
2907	int i;
2908
2909	list_for_each_entry(ioc, &mpt2sas_ioc_list, list) {
2910
2911		/* free memory associated to diag buffers */
2912		for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
2913			if (!ioc->diag_buffer[i])
2914				continue;
2915			pci_free_consistent(ioc->pdev, ioc->diag_buffer_sz[i],
2916			    ioc->diag_buffer[i], ioc->diag_buffer_dma[i]);
2917			ioc->diag_buffer[i] = NULL;
2918			ioc->diag_buffer_status[i] = 0;
2919		}
2920
2921		kfree(ioc->event_log);
2922	}
2923	misc_deregister(&ctl_dev);
2924}
2925
2926