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