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 }