drivers/message/fusion/mptctl.c

   1 /*
   2  *  linux/drivers/message/fusion/mptctl.c
   3  *      mpt Ioctl driver.
   4  *      For use with LSI PCI chip/adapters
   5  *      running LSI Fusion MPT (Message Passing Technology) firmware.
   6  *
   7  *  Copyright (c) 1999-2008 LSI Corporation
   8  *  (mailto:DL-MPTFusionLinux@lsi.com)
   9  *
  10  */
  11 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  12 /*
  13     This program is free software; you can redistribute it and/or modify
  14     it under the terms of the GNU General Public License as published by
  15     the Free Software Foundation; version 2 of the License.
  16
  17     This program is distributed in the hope that it will be useful,
  18     but WITHOUT ANY WARRANTY; without even the implied warranty of
  19     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20     GNU General Public License for more details.
  21
  22     NO WARRANTY
  23     THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  24     CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  25     LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  26     MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  27     solely responsible for determining the appropriateness of using and
  28     distributing the Program and assumes all risks associated with its
  29     exercise of rights under this Agreement, including but not limited to
  30     the risks and costs of program errors, damage to or loss of data,
  31     programs or equipment, and unavailability or interruption of operations.
  32
  33     DISCLAIMER OF LIABILITY
  34     NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  35     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36     DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  37     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  38     TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  39     USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  40     HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  41
  42     You should have received a copy of the GNU General Public License
  43     along with this program; if not, write to the Free Software
  44     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  45 */
  46 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  47
  48 #include <linux/kernel.h>
  49 #include <linux/module.h>
  50 #include <linux/errno.h>
  51 #include <linux/init.h>
  52 #include <linux/slab.h>
  53 #include <linux/types.h>
  54 #include <linux/pci.h>
  55 #include <linux/delay.h>        /* for mdelay */
  56 #include <linux/miscdevice.h>
  57 #include <linux/smp_lock.h>
  58 #include <linux/compat.h>
  59
  60 #include <asm/io.h>
  61 #include <asm/uaccess.h>
  62
  63 #include <scsi/scsi.h>
  64 #include <scsi/scsi_cmnd.h>
  65 #include <scsi/scsi_device.h>
  66 #include <scsi/scsi_host.h>
  67 #include <scsi/scsi_tcq.h>
  68
  69 #define COPYRIGHT       "Copyright (c) 1999-2008 LSI Corporation"
  70 #define MODULEAUTHOR    "LSI Corporation"
  71 #include "mptbase.h"
  72 #include "mptctl.h"
  73
  74 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  75 #define my_NAME         "Fusion MPT misc device (ioctl) driver"
  76 #define my_VERSION      MPT_LINUX_VERSION_COMMON
  77 #define MYNAM           "mptctl"
  78
  79 MODULE_AUTHOR(MODULEAUTHOR);
  80 MODULE_DESCRIPTION(my_NAME);
  81 MODULE_LICENSE("GPL");
  82 MODULE_VERSION(my_VERSION);
  83
  84 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  85
  86 static u8 mptctl_id = MPT_MAX_PROTOCOL_DRIVERS;
  87 static u8 mptctl_taskmgmt_id = MPT_MAX_PROTOCOL_DRIVERS;
  88
  89 static DECLARE_WAIT_QUEUE_HEAD ( mptctl_wait );
  90
  91 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  92
  93 struct buflist {
  94         u8      *kptr;
  95         int      len;
  96 };
  97
  98 /*
  99  * Function prototypes. Called from OS entry point mptctl_ioctl.
 100  * arg contents specific to function.
 101  */
 102 static int mptctl_fw_download(unsigned long arg);
 103 static int mptctl_getiocinfo(unsigned long arg, unsigned int cmd);
 104 static int mptctl_gettargetinfo(unsigned long arg);
 105 static int mptctl_readtest(unsigned long arg);
 106 static int mptctl_mpt_command(unsigned long arg);
 107 static int mptctl_eventquery(unsigned long arg);
 108 static int mptctl_eventenable(unsigned long arg);
 109 static int mptctl_eventreport(unsigned long arg);
 110 static int mptctl_replace_fw(unsigned long arg);
 111
 112 static int mptctl_do_reset(unsigned long arg);
 113 static int mptctl_hp_hostinfo(unsigned long arg, unsigned int cmd);
 114 static int mptctl_hp_targetinfo(unsigned long arg);
 115
 116 static int  mptctl_probe(struct pci_dev *, const struct pci_device_id *);
 117 static void mptctl_remove(struct pci_dev *);
 118
 119 #ifdef CONFIG_COMPAT
 120 static long compat_mpctl_ioctl(struct file *f, unsigned cmd, unsigned long arg);
 121 #endif
 122 /*
 123  * Private function calls.
 124  */
 125 static int mptctl_do_mpt_command(struct mpt_ioctl_command karg, void __user *mfPtr);
 126 static int mptctl_do_fw_download(int ioc, char __user *ufwbuf, size_t fwlen);
 127 static MptSge_t *kbuf_alloc_2_sgl(int bytes, u32 dir, int sge_offset, int *frags,
 128                 struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc);
 129 static void kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma,
 130                 struct buflist *buflist, MPT_ADAPTER *ioc);
 131
 132 /*
 133  * Reset Handler cleanup function
 134  */
 135 static int  mptctl_ioc_reset(MPT_ADAPTER *ioc, int reset_phase);
 136
 137 /*
 138  * Event Handler function
 139  */
 140 static int mptctl_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
 141 static struct fasync_struct *async_queue=NULL;
 142
 143 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 144 /*
 145  * Scatter gather list (SGL) sizes and limits...
 146  */
 147 //#define MAX_SCSI_FRAGS        9
 148 #define MAX_FRAGS_SPILL1        9
 149 #define MAX_FRAGS_SPILL2        15
 150 #define FRAGS_PER_BUCKET        (MAX_FRAGS_SPILL2 + 1)
 151
 152 //#define MAX_CHAIN_FRAGS       64
 153 //#define MAX_CHAIN_FRAGS       (15+15+15+16)
 154 #define MAX_CHAIN_FRAGS         (4 * MAX_FRAGS_SPILL2 + 1)
 155
 156 //  Define max sg LIST bytes ( == (#frags + #chains) * 8 bytes each)
 157 //  Works out to: 592d bytes!     (9+1)*8 + 4*(15+1)*8
 158 //                  ^----------------- 80 + 512
 159 #define MAX_SGL_BYTES           ((MAX_FRAGS_SPILL1 + 1 + (4 * FRAGS_PER_BUCKET)) * 8)
 160
 161 /* linux only seems to ever give 128kB MAX contiguous (GFP_USER) mem bytes */
 162 #define MAX_KMALLOC_SZ          (128*1024)
 163
 164 #define MPT_IOCTL_DEFAULT_TIMEOUT 10    /* Default timeout value (seconds) */
 165
 166 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 167 /**
 168  *      mptctl_syscall_down - Down the MPT adapter syscall semaphore.
 169  *      @ioc: Pointer to MPT adapter
 170  *      @nonblock: boolean, non-zero if O_NONBLOCK is set
 171  *
 172  *      All of the ioctl commands can potentially sleep, which is illegal
 173  *      with a spinlock held, thus we perform mutual exclusion here.
 174  *
 175  *      Returns negative errno on error, or zero for success.
 176  */
 177 static inline int
 178 mptctl_syscall_down(MPT_ADAPTER *ioc, int nonblock)
 179 {
 180         int rc = 0;
 181
 182         if (nonblock) {
 183                 if (!mutex_trylock(&ioc->ioctl_cmds.mutex))
 184                         rc = -EAGAIN;
 185         } else {
 186                 if (mutex_lock_interruptible(&ioc->ioctl_cmds.mutex))
 187                         rc = -ERESTARTSYS;
 188         }
 189         return rc;
 190 }
 191
 192 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 193 /*
 194  *  This is the callback for any message we have posted. The message itself
 195  *  will be returned to the message pool when we return from the IRQ
 196  *
 197  *  This runs in irq context so be short and sweet.
 198  */
 199 static int
 200 mptctl_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply)
 201 {
 202         char    *sense_data;
 203         int     req_index;
 204         int     sz;
 205
 206         if (!req)
 207                 return 0;
 208
 209         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "completing mpi function "
 210             "(0x%02X), req=%p, reply=%p\n", ioc->name,  req->u.hdr.Function,
 211             req, reply));
 212
 213         /*
 214          * Handling continuation of the same reply. Processing the first
 215          * reply, and eating the other replys that come later.
 216          */
 217         if (ioc->ioctl_cmds.msg_context != req->u.hdr.MsgContext)
 218                 goto out_continuation;
 219
 220         ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
 221
 222         if (!reply)
 223                 goto out;
 224
 225         ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
 226         sz = min(ioc->reply_sz, 4*reply->u.reply.MsgLength);
 227         memcpy(ioc->ioctl_cmds.reply, reply, sz);
 228
 229         if (reply->u.reply.IOCStatus || reply->u.reply.IOCLogInfo)
 230                 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 231                     "iocstatus (0x%04X), loginfo (0x%08X)\n", ioc->name,
 232                     le16_to_cpu(reply->u.reply.IOCStatus),
 233                     le32_to_cpu(reply->u.reply.IOCLogInfo)));
 234
 235         if ((req->u.hdr.Function == MPI_FUNCTION_SCSI_IO_REQUEST) ||
 236                 (req->u.hdr.Function ==
 237                  MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
 238
 239                 if (reply->u.sreply.SCSIStatus || reply->u.sreply.SCSIState)
 240                         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 241                         "scsi_status (0x%02x), scsi_state (0x%02x), "
 242                         "tag = (0x%04x), transfer_count (0x%08x)\n", ioc->name,
 243                         reply->u.sreply.SCSIStatus,
 244                         reply->u.sreply.SCSIState,
 245                         le16_to_cpu(reply->u.sreply.TaskTag),
 246                         le32_to_cpu(reply->u.sreply.TransferCount)));
 247
 248                 if (reply->u.sreply.SCSIState &
 249                         MPI_SCSI_STATE_AUTOSENSE_VALID) {
 250                         sz = req->u.scsireq.SenseBufferLength;
 251                         req_index =
 252                             le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx);
 253                         sense_data = ((u8 *)ioc->sense_buf_pool +
 254                              (req_index * MPT_SENSE_BUFFER_ALLOC));
 255                         memcpy(ioc->ioctl_cmds.sense, sense_data, sz);
 256                         ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_SENSE_VALID;
 257                 }
 258         }
 259
 260  out:
 261         /* We are done, issue wake up
 262          */
 263         if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_PENDING) {
 264                 if (req->u.hdr.Function == MPI_FUNCTION_SCSI_TASK_MGMT) {
 265                         mpt_clear_taskmgmt_in_progress_flag(ioc);
 266                         ioc->ioctl_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
 267                         complete(&ioc->ioctl_cmds.done);
 268                         if (ioc->bus_type == SAS)
 269                                 ioc->schedule_target_reset(ioc);
 270                 } else {
 271                         ioc->ioctl_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
 272                         complete(&ioc->ioctl_cmds.done);
 273                 }
 274         }
 275
 276  out_continuation:
 277         if (reply && (reply->u.reply.MsgFlags &
 278             MPI_MSGFLAGS_CONTINUATION_REPLY))
 279                 return 0;
 280         return 1;
 281 }
 282
 283
 284 static int
 285 mptctl_taskmgmt_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
 286 {
 287         if (!mf)
 288                 return 0;
 289
 290         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 291                 "TaskMgmt completed (mf=%p, mr=%p)\n",
 292                 ioc->name, mf, mr));
 293
 294         ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
 295
 296         if (!mr)
 297                 goto out;
 298
 299         ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
 300         memcpy(ioc->taskmgmt_cmds.reply, mr,
 301             min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
 302  out:
 303         if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
 304                 mpt_clear_taskmgmt_in_progress_flag(ioc);
 305                 ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
 306                 complete(&ioc->taskmgmt_cmds.done);
 307                 if (ioc->bus_type == SAS)
 308                         ioc->schedule_target_reset(ioc);
 309                 return 1;
 310         }
 311         return 0;
 312 }
 313
 314 static int
 315 mptctl_do_taskmgmt(MPT_ADAPTER *ioc, u8 tm_type, u8 bus_id, u8 target_id)
 316 {
 317         MPT_FRAME_HDR   *mf;
 318         SCSITaskMgmt_t  *pScsiTm;
 319         SCSITaskMgmtReply_t *pScsiTmReply;
 320         int              ii;
 321         int              retval;
 322         unsigned long    timeout;
 323         unsigned long    time_count;
 324         u16              iocstatus;
 325
 326
 327         mutex_lock(&ioc->taskmgmt_cmds.mutex);
 328         if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
 329                 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
 330                 return -EPERM;
 331         }
 332
 333         retval = 0;
 334
 335         mf = mpt_get_msg_frame(mptctl_taskmgmt_id, ioc);
 336         if (mf == NULL) {
 337                 dtmprintk(ioc,
 338                         printk(MYIOC_s_WARN_FMT "TaskMgmt, no msg frames!!\n",
 339                         ioc->name));
 340                 mpt_clear_taskmgmt_in_progress_flag(ioc);
 341                 retval = -ENOMEM;
 342                 goto tm_done;
 343         }
 344
 345         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
 346                 ioc->name, mf));
 347
 348         pScsiTm = (SCSITaskMgmt_t *) mf;
 349         memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t));
 350         pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
 351         pScsiTm->TaskType = tm_type;
 352         if ((tm_type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS) &&
 353                 (ioc->bus_type == FC))
 354                 pScsiTm->MsgFlags =
 355                                 MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
 356         pScsiTm->TargetID = target_id;
 357         pScsiTm->Bus = bus_id;
 358         pScsiTm->ChainOffset = 0;
 359         pScsiTm->Reserved = 0;
 360         pScsiTm->Reserved1 = 0;
 361         pScsiTm->TaskMsgContext = 0;
 362         for (ii= 0; ii < 8; ii++)
 363                 pScsiTm->LUN[ii] = 0;
 364         for (ii=0; ii < 7; ii++)
 365                 pScsiTm->Reserved2[ii] = 0;
 366
 367         switch (ioc->bus_type) {
 368         case FC:
 369                 timeout = 40;
 370                 break;
 371         case SAS:
 372                 timeout = 30;
 373                 break;
 374         case SPI:
 375                 default:
 376                 timeout = 10;
 377                 break;
 378         }
 379
 380         dtmprintk(ioc,
 381                 printk(MYIOC_s_DEBUG_FMT "TaskMgmt type=%d timeout=%ld\n",
 382                 ioc->name, tm_type, timeout));
 383
 384         INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
 385         time_count = jiffies;
 386         if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
 387             (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
 388                 mpt_put_msg_frame_hi_pri(mptctl_taskmgmt_id, ioc, mf);
 389         else {
 390                 retval = mpt_send_handshake_request(mptctl_taskmgmt_id, ioc,
 391                     sizeof(SCSITaskMgmt_t), (u32 *)pScsiTm, CAN_SLEEP);
 392                 if (retval != 0) {
 393                         dfailprintk(ioc,
 394                                 printk(MYIOC_s_ERR_FMT
 395                                 "TaskMgmt send_handshake FAILED!"
 396                                 " (ioc %p, mf %p, rc=%d) \n", ioc->name,
 397                                 ioc, mf, retval));
 398                         mpt_free_msg_frame(ioc, mf);
 399                         mpt_clear_taskmgmt_in_progress_flag(ioc);
 400                         goto tm_done;
 401                 }
 402         }
 403
 404         /* Now wait for the command to complete */
 405         ii = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done, timeout*HZ);
 406
 407         if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
 408                 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 409                     "TaskMgmt failed\n", ioc->name));
 410                 mpt_free_msg_frame(ioc, mf);
 411                 mpt_clear_taskmgmt_in_progress_flag(ioc);
 412                 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
 413                         retval = 0;
 414                 else
 415                         retval = -1; /* return failure */
 416                 goto tm_done;
 417         }
 418
 419         if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
 420                 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 421                     "TaskMgmt failed\n", ioc->name));
 422                 retval = -1; /* return failure */
 423                 goto tm_done;
 424         }
 425
 426         pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply;
 427         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 428             "TaskMgmt fw_channel = %d, fw_id = %d, task_type=0x%02X, "
 429             "iocstatus=0x%04X\n\tloginfo=0x%08X, response_code=0x%02X, "
 430             "term_cmnds=%d\n", ioc->name, pScsiTmReply->Bus,
 431             pScsiTmReply->TargetID, tm_type,
 432             le16_to_cpu(pScsiTmReply->IOCStatus),
 433             le32_to_cpu(pScsiTmReply->IOCLogInfo),
 434             pScsiTmReply->ResponseCode,
 435             le32_to_cpu(pScsiTmReply->TerminationCount)));
 436
 437         iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
 438
 439         if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
 440            iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED ||
 441            iocstatus == MPI_IOCSTATUS_SUCCESS)
 442                 retval = 0;
 443         else {
 444                 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 445                     "TaskMgmt failed\n", ioc->name));
 446                 retval = -1; /* return failure */
 447         }
 448
 449  tm_done:
 450         mutex_unlock(&ioc->taskmgmt_cmds.mutex);
 451         CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
 452         return retval;
 453 }
 454
 455 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 456 /* mptctl_timeout_expired
 457  *
 458  * Expecting an interrupt, however timed out.
 459  *
 460  */
 461 static void
 462 mptctl_timeout_expired(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
 463 {
 464         unsigned long flags;
 465         int ret_val = -1;
 466         SCSIIORequest_t *scsi_req = (SCSIIORequest_t *) mf;
 467         u8 function = mf->u.hdr.Function;
 468
 469         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": %s\n",
 470                 ioc->name, __func__));
 471
 472         if (mpt_fwfault_debug)
 473                 mpt_halt_firmware(ioc);
 474
 475         spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
 476         if (ioc->ioc_reset_in_progress) {
 477                 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
 478                 CLEAR_MGMT_PENDING_STATUS(ioc->ioctl_cmds.status)
 479                 mpt_free_msg_frame(ioc, mf);
 480                 return;
 481         }
 482         spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
 483
 484
 485         CLEAR_MGMT_PENDING_STATUS(ioc->ioctl_cmds.status)
 486
 487         if (ioc->bus_type == SAS) {
 488                 if (function == MPI_FUNCTION_SCSI_IO_REQUEST)
 489                         ret_val = mptctl_do_taskmgmt(ioc,
 490                                 MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
 491                                 scsi_req->Bus, scsi_req->TargetID);
 492                 else if (function == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)
 493                         ret_val = mptctl_do_taskmgmt(ioc,
 494                                 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
 495                                 scsi_req->Bus, 0);
 496                 if (!ret_val)
 497                         return;
 498         } else {
 499                 if ((function == MPI_FUNCTION_SCSI_IO_REQUEST) ||
 500                         (function == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH))
 501                         ret_val = mptctl_do_taskmgmt(ioc,
 502                                 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
 503                                 scsi_req->Bus, 0);
 504                 if (!ret_val)
 505                         return;
 506         }
 507
 508         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling Reset! \n",
 509                  ioc->name));
 510         mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
 511         mpt_free_msg_frame(ioc, mf);
 512 }
 513
 514
 515 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 516 /* mptctl_ioc_reset
 517  *
 518  * Clean-up functionality. Used only if there has been a
 519  * reload of the FW due.
 520  *
 521  */
 522 static int
 523 mptctl_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
 524 {
 525         switch(reset_phase) {
 526         case MPT_IOC_SETUP_RESET:
 527                 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 528                     "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__));
 529                 break;
 530         case MPT_IOC_PRE_RESET:
 531                 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 532                     "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__));
 533                 break;
 534         case MPT_IOC_POST_RESET:
 535                 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 536                     "%s: MPT_IOC_POST_RESET\n", ioc->name, __func__));
 537                 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_PENDING) {
 538                         ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_DID_IOCRESET;
 539                         complete(&ioc->ioctl_cmds.done);
 540                 }
 541                 break;
 542         default:
 543                 break;
 544         }
 545
 546         return 1;
 547 }
 548
 549 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 550 /* ASYNC Event Notification Support */
 551 static int
 552 mptctl_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
 553 {
 554         u8 event;
 555
 556         event = le32_to_cpu(pEvReply->Event) & 0xFF;
 557
 558         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s() called\n",
 559             ioc->name, __func__));
 560         if(async_queue == NULL)
 561                 return 1;
 562
 563         /* Raise SIGIO for persistent events.
 564          * TODO - this define is not in MPI spec yet,
 565          * but they plan to set it to 0x21
 566          */
 567          if (event == 0x21 ) {
 568                 ioc->aen_event_read_flag=1;
 569                 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Raised SIGIO to application\n",
 570                     ioc->name));
 571                 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 572                     "Raised SIGIO to application\n", ioc->name));
 573                 kill_fasync(&async_queue, SIGIO, POLL_IN);
 574                 return 1;
 575          }
 576
 577         /* This flag is set after SIGIO was raised, and
 578          * remains set until the application has read
 579          * the event log via ioctl=MPTEVENTREPORT
 580          */
 581         if(ioc->aen_event_read_flag)
 582                 return 1;
 583
 584         /* Signal only for the events that are
 585          * requested for by the application
 586          */
 587         if (ioc->events && (ioc->eventTypes & ( 1 << event))) {
 588                 ioc->aen_event_read_flag=1;
 589                 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 590                     "Raised SIGIO to application\n", ioc->name));
 591                 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 592                     "Raised SIGIO to application\n", ioc->name));
 593                 kill_fasync(&async_queue, SIGIO, POLL_IN);
 594         }
 595         return 1;
 596 }
 597
 598 static int
 599 mptctl_fasync(int fd, struct file *filep, int mode)
 600 {
 601         MPT_ADAPTER     *ioc;
 602         int ret;
 603
 604         lock_kernel();
 605         list_for_each_entry(ioc, &ioc_list, list)
 606                 ioc->aen_event_read_flag=0;
 607
 608         ret = fasync_helper(fd, filep, mode, &async_queue);
 609         unlock_kernel();
 610         return ret;
 611 }
 612
 613 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 614 /*
 615  *  MPT ioctl handler
 616  *  cmd - specify the particular IOCTL command to be issued
 617  *  arg - data specific to the command. Must not be null.
 618  */
 619 static long
 620 __mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 621 {
 622         mpt_ioctl_header __user *uhdr = (void __user *) arg;
 623         mpt_ioctl_header         khdr;
 624         int iocnum;
 625         unsigned iocnumX;
 626         int nonblock = (file->f_flags & O_NONBLOCK);
 627         int ret;
 628         MPT_ADAPTER *iocp = NULL;
 629
 630         if (copy_from_user(&khdr, uhdr, sizeof(khdr))) {
 631                 printk(KERN_ERR MYNAM "%s::mptctl_ioctl() @%d - "
 632                                 "Unable to copy mpt_ioctl_header data @ %p\n",
 633                                 __FILE__, __LINE__, uhdr);
 634                 return -EFAULT;
 635         }
 636         ret = -ENXIO;                           /* (-6) No such device or address */
 637
 638         /* Verify intended MPT adapter - set iocnum and the adapter
 639          * pointer (iocp)
 640          */
 641         iocnumX = khdr.iocnum & 0xFF;
 642         if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
 643             (iocp == NULL))
 644                 return -ENODEV;
 645
 646         if (!iocp->active) {
 647                 printk(KERN_DEBUG MYNAM "%s::mptctl_ioctl() @%d - Controller disabled.\n",
 648                                 __FILE__, __LINE__);
 649                 return -EFAULT;
 650         }
 651
 652         /* Handle those commands that are just returning
 653          * information stored in the driver.
 654          * These commands should never time out and are unaffected
 655          * by TM and FW reloads.
 656          */
 657         if ((cmd & ~IOCSIZE_MASK) == (MPTIOCINFO & ~IOCSIZE_MASK)) {
 658                 return mptctl_getiocinfo(arg, _IOC_SIZE(cmd));
 659         } else if (cmd == MPTTARGETINFO) {
 660                 return mptctl_gettargetinfo(arg);
 661         } else if (cmd == MPTTEST) {
 662                 return mptctl_readtest(arg);
 663         } else if (cmd == MPTEVENTQUERY) {
 664                 return mptctl_eventquery(arg);
 665         } else if (cmd == MPTEVENTENABLE) {
 666                 return mptctl_eventenable(arg);
 667         } else if (cmd == MPTEVENTREPORT) {
 668                 return mptctl_eventreport(arg);
 669         } else if (cmd == MPTFWREPLACE) {
 670                 return mptctl_replace_fw(arg);
 671         }
 672
 673         /* All of these commands require an interrupt or
 674          * are unknown/illegal.
 675          */
 676         if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
 677                 return ret;
 678
 679         if (cmd == MPTFWDOWNLOAD)
 680                 ret = mptctl_fw_download(arg);
 681         else if (cmd == MPTCOMMAND)
 682                 ret = mptctl_mpt_command(arg);
 683         else if (cmd == MPTHARDRESET)
 684                 ret = mptctl_do_reset(arg);
 685         else if ((cmd & ~IOCSIZE_MASK) == (HP_GETHOSTINFO & ~IOCSIZE_MASK))
 686                 ret = mptctl_hp_hostinfo(arg, _IOC_SIZE(cmd));
 687         else if (cmd == HP_GETTARGETINFO)
 688                 ret = mptctl_hp_targetinfo(arg);
 689         else
 690                 ret = -EINVAL;
 691
 692         mutex_unlock(&iocp->ioctl_cmds.mutex);
 693
 694         return ret;
 695 }
 696
 697 static long
 698 mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 699 {
 700         long ret;
 701         lock_kernel();
 702         ret = __mptctl_ioctl(file, cmd, arg);
 703         unlock_kernel();
 704         return ret;
 705 }
 706
 707 static int mptctl_do_reset(unsigned long arg)
 708 {
 709         struct mpt_ioctl_diag_reset __user *urinfo = (void __user *) arg;
 710         struct mpt_ioctl_diag_reset krinfo;
 711         MPT_ADAPTER             *iocp;
 712
 713         if (copy_from_user(&krinfo, urinfo, sizeof(struct mpt_ioctl_diag_reset))) {
 714                 printk(KERN_ERR MYNAM "%s@%d::mptctl_do_reset - "
 715                                 "Unable to copy mpt_ioctl_diag_reset struct @ %p\n",
 716                                 __FILE__, __LINE__, urinfo);
 717                 return -EFAULT;
 718         }
 719
 720         if (mpt_verify_adapter(krinfo.hdr.iocnum, &iocp) < 0) {
 721                 printk(KERN_DEBUG MYNAM "%s@%d::mptctl_do_reset - ioc%d not found!\n",
 722                                 __FILE__, __LINE__, krinfo.hdr.iocnum);
 723                 return -ENODEV; /* (-6) No such device or address */
 724         }
 725
 726         dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "mptctl_do_reset called.\n",
 727             iocp->name));
 728
 729         if (mpt_HardResetHandler(iocp, CAN_SLEEP) != 0) {
 730                 printk (MYIOC_s_ERR_FMT "%s@%d::mptctl_do_reset - reset failed.\n",
 731                         iocp->name, __FILE__, __LINE__);
 732                 return -1;
 733         }
 734
 735         return 0;
 736 }
 737
 738 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 739 /*
 740  * MPT FW download function.  Cast the arg into the mpt_fw_xfer structure.
 741  * This structure contains: iocnum, firmware length (bytes),
 742  *      pointer to user space memory where the fw image is stored.
 743  *
 744  * Outputs:     None.
 745  * Return:      0 if successful
 746  *              -EFAULT if data unavailable
 747  *              -ENXIO  if no such device
 748  *              -EAGAIN if resource problem
 749  *              -ENOMEM if no memory for SGE
 750  *              -EMLINK if too many chain buffers required
 751  *              -EBADRQC if adapter does not support FW download
 752  *              -EBUSY if adapter is busy
 753  *              -ENOMSG if FW upload returned bad status
 754  */
 755 static int
 756 mptctl_fw_download(unsigned long arg)
 757 {
 758         struct mpt_fw_xfer __user *ufwdl = (void __user *) arg;
 759         struct mpt_fw_xfer       kfwdl;
 760
 761         if (copy_from_user(&kfwdl, ufwdl, sizeof(struct mpt_fw_xfer))) {
 762                 printk(KERN_ERR MYNAM "%s@%d::_ioctl_fwdl - "
 763                                 "Unable to copy mpt_fw_xfer struct @ %p\n",
 764                                 __FILE__, __LINE__, ufwdl);
 765                 return -EFAULT;
 766         }
 767
 768         return mptctl_do_fw_download(kfwdl.iocnum, kfwdl.bufp, kfwdl.fwlen);
 769 }
 770
 771 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 772 /*
 773  * FW Download engine.
 774  * Outputs:     None.
 775  * Return:      0 if successful
 776  *              -EFAULT if data unavailable
 777  *              -ENXIO  if no such device
 778  *              -EAGAIN if resource problem
 779  *              -ENOMEM if no memory for SGE
 780  *              -EMLINK if too many chain buffers required
 781  *              -EBADRQC if adapter does not support FW download
 782  *              -EBUSY if adapter is busy
 783  *              -ENOMSG if FW upload returned bad status
 784  */
 785 static int
 786 mptctl_do_fw_download(int ioc, char __user *ufwbuf, size_t fwlen)
 787 {
 788         FWDownload_t            *dlmsg;
 789         MPT_FRAME_HDR           *mf;
 790         MPT_ADAPTER             *iocp;
 791         FWDownloadTCSGE_t       *ptsge;
 792         MptSge_t                *sgl, *sgIn;
 793         char                    *sgOut;
 794         struct buflist          *buflist;
 795         struct buflist          *bl;
 796         dma_addr_t               sgl_dma;
 797         int                      ret;
 798         int                      numfrags = 0;
 799         int                      maxfrags;
 800         int                      n = 0;
 801         u32                      sgdir;
 802         u32                      nib;
 803         int                      fw_bytes_copied = 0;
 804         int                      i;
 805         int                      sge_offset = 0;
 806         u16                      iocstat;
 807         pFWDownloadReply_t       ReplyMsg = NULL;
 808         unsigned long            timeleft;
 809
 810         if (mpt_verify_adapter(ioc, &iocp) < 0) {
 811                 printk(KERN_DEBUG MYNAM "ioctl_fwdl - ioc%d not found!\n",
 812                                  ioc);
 813                 return -ENODEV; /* (-6) No such device or address */
 814         } else {
 815
 816                 /*  Valid device. Get a message frame and construct the FW download message.
 817                 */
 818                 if ((mf = mpt_get_msg_frame(mptctl_id, iocp)) == NULL)
 819                         return -EAGAIN;
 820         }
 821
 822         dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT
 823             "mptctl_do_fwdl called. mptctl_id = %xh.\n", iocp->name, mptctl_id));
 824         dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.bufp  = %p\n",
 825             iocp->name, ufwbuf));
 826         dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.fwlen = %d\n",
 827             iocp->name, (int)fwlen));
 828         dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.ioc   = %04xh\n",
 829             iocp->name, ioc));
 830
 831         dlmsg = (FWDownload_t*) mf;
 832         ptsge = (FWDownloadTCSGE_t *) &dlmsg->SGL;
 833         sgOut = (char *) (ptsge + 1);
 834
 835         /*
 836          * Construct f/w download request
 837          */
 838         dlmsg->ImageType = MPI_FW_DOWNLOAD_ITYPE_FW;
 839         dlmsg->Reserved = 0;
 840         dlmsg->ChainOffset = 0;
 841         dlmsg->Function = MPI_FUNCTION_FW_DOWNLOAD;
 842         dlmsg->Reserved1[0] = dlmsg->Reserved1[1] = dlmsg->Reserved1[2] = 0;
 843         if (iocp->facts.MsgVersion >= MPI_VERSION_01_05)
 844                 dlmsg->MsgFlags = MPI_FW_DOWNLOAD_MSGFLGS_LAST_SEGMENT;
 845         else
 846                 dlmsg->MsgFlags = 0;
 847
 848
 849         /* Set up the Transaction SGE.
 850          */
 851         ptsge->Reserved = 0;
 852         ptsge->ContextSize = 0;
 853         ptsge->DetailsLength = 12;
 854         ptsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
 855         ptsge->Reserved_0100_Checksum = 0;
 856         ptsge->ImageOffset = 0;
 857         ptsge->ImageSize = cpu_to_le32(fwlen);
 858
 859         /* Add the SGL
 860          */
 861
 862         /*
 863          * Need to kmalloc area(s) for holding firmware image bytes.
 864          * But we need to do it piece meal, using a proper
 865          * scatter gather list (with 128kB MAX hunks).
 866          *
 867          * A practical limit here might be # of sg hunks that fit into
 868          * a single IOC request frame; 12 or 8 (see below), so:
 869          * For FC9xx: 12 x 128kB == 1.5 mB (max)
 870          * For C1030:  8 x 128kB == 1   mB (max)
 871          * We could support chaining, but things get ugly(ier:)
 872          *
 873          * Set the sge_offset to the start of the sgl (bytes).
 874          */
 875         sgdir = 0x04000000;             /* IOC will READ from sys mem */
 876         sge_offset = sizeof(MPIHeader_t) + sizeof(FWDownloadTCSGE_t);
 877         if ((sgl = kbuf_alloc_2_sgl(fwlen, sgdir, sge_offset,
 878                                     &numfrags, &buflist, &sgl_dma, iocp)) == NULL)
 879                 return -ENOMEM;
 880
 881         /*
 882          * We should only need SGL with 2 simple_32bit entries (up to 256 kB)
 883          * for FC9xx f/w image, but calculate max number of sge hunks
 884          * we can fit into a request frame, and limit ourselves to that.
 885          * (currently no chain support)
 886          * maxfrags = (Request Size - FWdownload Size ) / Size of 32 bit SGE
 887          *      Request         maxfrags
 888          *      128             12
 889          *      96              8
 890          *      64              4
 891          */
 892         maxfrags = (iocp->req_sz - sizeof(MPIHeader_t) -
 893                         sizeof(FWDownloadTCSGE_t))
 894                         / iocp->SGE_size;
 895         if (numfrags > maxfrags) {
 896                 ret = -EMLINK;
 897                 goto fwdl_out;
 898         }
 899
 900         dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: sgl buffer = %p, sgfrags = %d\n",
 901             iocp->name, sgl, numfrags));
 902
 903         /*
 904          * Parse SG list, copying sgl itself,
 905          * plus f/w image hunks from user space as we go...
 906          */
 907         ret = -EFAULT;
 908         sgIn = sgl;
 909         bl = buflist;
 910         for (i=0; i < numfrags; i++) {
 911
 912                 /* Get the SGE type: 0 - TCSGE, 3 - Chain, 1 - Simple SGE
 913                  * Skip everything but Simple. If simple, copy from
 914                  *      user space into kernel space.
 915                  * Note: we should not have anything but Simple as
 916                  *      Chain SGE are illegal.
 917                  */
 918                 nib = (sgIn->FlagsLength & 0x30000000) >> 28;
 919                 if (nib == 0 || nib == 3) {
 920                         ;
 921                 } else if (sgIn->Address) {
 922                         iocp->add_sge(sgOut, sgIn->FlagsLength, sgIn->Address);
 923                         n++;
 924                         if (copy_from_user(bl->kptr, ufwbuf+fw_bytes_copied, bl->len)) {
 925                                 printk(MYIOC_s_ERR_FMT "%s@%d::_ioctl_fwdl - "
 926                                         "Unable to copy f/w buffer hunk#%d @ %p\n",
 927                                         iocp->name, __FILE__, __LINE__, n, ufwbuf);
 928                                 goto fwdl_out;
 929                         }
 930                         fw_bytes_copied += bl->len;
 931                 }
 932                 sgIn++;
 933                 bl++;
 934                 sgOut += iocp->SGE_size;
 935         }
 936
 937         DBG_DUMP_FW_DOWNLOAD(iocp, (u32 *)mf, numfrags);
 938
 939         /*
 940          * Finally, perform firmware download.
 941          */
 942         ReplyMsg = NULL;
 943         SET_MGMT_MSG_CONTEXT(iocp->ioctl_cmds.msg_context, dlmsg->MsgContext);
 944         INITIALIZE_MGMT_STATUS(iocp->ioctl_cmds.status)
 945         mpt_put_msg_frame(mptctl_id, iocp, mf);
 946
 947         /* Now wait for the command to complete */
 948 retry_wait:
 949         timeleft = wait_for_completion_timeout(&iocp->ioctl_cmds.done, HZ*60);
 950         if (!(iocp->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
 951                 ret = -ETIME;
 952                 printk(MYIOC_s_WARN_FMT "%s: failed\n", iocp->name, __func__);
 953                 if (iocp->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
 954                         mpt_free_msg_frame(iocp, mf);
 955                         goto fwdl_out;
 956                 }
 957                 if (!timeleft)
 958                         mptctl_timeout_expired(iocp, mf);
 959                 else
 960                         goto retry_wait;
 961                 goto fwdl_out;
 962         }
 963
 964         if (!(iocp->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
 965                 printk(MYIOC_s_WARN_FMT "%s: failed\n", iocp->name, __func__);
 966                 mpt_free_msg_frame(iocp, mf);
 967                 ret = -ENODATA;
 968                 goto fwdl_out;
 969         }
 970
 971         if (sgl)
 972                 kfree_sgl(sgl, sgl_dma, buflist, iocp);
 973
 974         ReplyMsg = (pFWDownloadReply_t)iocp->ioctl_cmds.reply;
 975         iocstat = le16_to_cpu(ReplyMsg->IOCStatus) & MPI_IOCSTATUS_MASK;
 976         if (iocstat == MPI_IOCSTATUS_SUCCESS) {
 977                 printk(MYIOC_s_INFO_FMT "F/W update successfull!\n", iocp->name);
 978                 return 0;
 979         } else if (iocstat == MPI_IOCSTATUS_INVALID_FUNCTION) {
 980                 printk(MYIOC_s_WARN_FMT "Hmmm...  F/W download not supported!?!\n",
 981                         iocp->name);
 982                 printk(MYIOC_s_WARN_FMT "(time to go bang on somebodies door)\n",
 983                         iocp->name);
 984                 return -EBADRQC;
 985         } else if (iocstat == MPI_IOCSTATUS_BUSY) {
 986                 printk(MYIOC_s_WARN_FMT "IOC_BUSY!\n", iocp->name);
 987                 printk(MYIOC_s_WARN_FMT "(try again later?)\n", iocp->name);
 988                 return -EBUSY;
 989         } else {
 990                 printk(MYIOC_s_WARN_FMT "ioctl_fwdl() returned [bad] status = %04xh\n",
 991                         iocp->name, iocstat);
 992                 printk(MYIOC_s_WARN_FMT "(bad VooDoo)\n", iocp->name);
 993                 return -ENOMSG;
 994         }
 995         return 0;
 996
 997 fwdl_out:
 998
 999         CLEAR_MGMT_STATUS(iocp->ioctl_cmds.status);
1000         SET_MGMT_MSG_CONTEXT(iocp->ioctl_cmds.msg_context, 0);
1001         kfree_sgl(sgl, sgl_dma, buflist, iocp);
1002         return ret;
1003 }
1004
1005 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1006 /*
1007  * SGE Allocation routine
1008  *
1009  * Inputs:      bytes - number of bytes to be transferred
1010  *              sgdir - data direction
1011  *              sge_offset - offset (in bytes) from the start of the request
1012  *                      frame to the first SGE
1013  *              ioc - pointer to the mptadapter
1014  * Outputs:     frags - number of scatter gather elements
1015  *              blp - point to the buflist pointer
1016  *              sglbuf_dma - pointer to the (dma) sgl
1017  * Returns:     Null if failes
1018  *              pointer to the (virtual) sgl if successful.
1019  */
1020 static MptSge_t *
1021 kbuf_alloc_2_sgl(int bytes, u32 sgdir, int sge_offset, int *frags,
1022                  struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc)
1023 {
1024         MptSge_t        *sglbuf = NULL;         /* pointer to array of SGE */
1025                                                 /* and chain buffers */
1026         struct buflist  *buflist = NULL;        /* kernel routine */
1027         MptSge_t        *sgl;
1028         int              numfrags = 0;
1029         int              fragcnt = 0;
1030         int              alloc_sz = min(bytes,MAX_KMALLOC_SZ);  // avoid kernel warning msg!
1031         int              bytes_allocd = 0;
1032         int              this_alloc;
1033         dma_addr_t       pa;                                    // phys addr
1034         int              i, buflist_ent;
1035         int              sg_spill = MAX_FRAGS_SPILL1;
1036         int              dir;
1037         /* initialization */
1038         *frags = 0;
1039         *blp = NULL;
1040
1041         /* Allocate and initialize an array of kernel
1042          * structures for the SG elements.
1043          */
1044         i = MAX_SGL_BYTES / 8;
1045         buflist = kzalloc(i, GFP_USER);
1046         if (!buflist)
1047                 return NULL;
1048         buflist_ent = 0;
1049
1050         /* Allocate a single block of memory to store the sg elements and
1051          * the chain buffers.  The calling routine is responsible for
1052          * copying the data in this array into the correct place in the
1053          * request and chain buffers.
1054          */
1055         sglbuf = pci_alloc_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf_dma);
1056         if (sglbuf == NULL)
1057                 goto free_and_fail;
1058
1059         if (sgdir & 0x04000000)
1060                 dir = PCI_DMA_TODEVICE;
1061         else
1062                 dir = PCI_DMA_FROMDEVICE;
1063
1064         /* At start:
1065          *      sgl = sglbuf = point to beginning of sg buffer
1066          *      buflist_ent = 0 = first kernel structure
1067          *      sg_spill = number of SGE that can be written before the first
1068          *              chain element.
1069          *
1070          */
1071         sgl = sglbuf;
1072         sg_spill = ((ioc->req_sz - sge_offset)/ioc->SGE_size) - 1;
1073         while (bytes_allocd < bytes) {
1074                 this_alloc = min(alloc_sz, bytes-bytes_allocd);
1075                 buflist[buflist_ent].len = this_alloc;
1076                 buflist[buflist_ent].kptr = pci_alloc_consistent(ioc->pcidev,
1077                                                                  this_alloc,
1078                                                                  &pa);
1079                 if (buflist[buflist_ent].kptr == NULL) {
1080                         alloc_sz = alloc_sz / 2;
1081                         if (alloc_sz == 0) {
1082                                 printk(MYIOC_s_WARN_FMT "-SG: No can do - "
1083                                     "not enough memory!   :-(\n", ioc->name);
1084                                 printk(MYIOC_s_WARN_FMT "-SG: (freeing %d frags)\n",
1085                                         ioc->name, numfrags);
1086                                 goto free_and_fail;
1087                         }
1088                         continue;
1089                 } else {
1090                         dma_addr_t dma_addr;
1091
1092                         bytes_allocd += this_alloc;
1093                         sgl->FlagsLength = (0x10000000|sgdir|this_alloc);
1094                         dma_addr = pci_map_single(ioc->pcidev,
1095                                 buflist[buflist_ent].kptr, this_alloc, dir);
1096                         sgl->Address = dma_addr;
1097
1098                         fragcnt++;
1099                         numfrags++;
1100                         sgl++;
1101                         buflist_ent++;
1102                 }
1103
1104                 if (bytes_allocd >= bytes)
1105                         break;
1106
1107                 /* Need to chain? */
1108                 if (fragcnt == sg_spill) {
1109                         printk(MYIOC_s_WARN_FMT
1110                             "-SG: No can do - " "Chain required!   :-(\n", ioc->name);
1111                         printk(MYIOC_s_WARN_FMT "(freeing %d frags)\n", ioc->name, numfrags);
1112                         goto free_and_fail;
1113                 }
1114
1115                 /* overflow check... */
1116                 if (numfrags*8 > MAX_SGL_BYTES){
1117                         /* GRRRRR... */
1118                         printk(MYIOC_s_WARN_FMT "-SG: No can do - "
1119                                 "too many SG frags!   :-(\n", ioc->name);
1120                         printk(MYIOC_s_WARN_FMT "-SG: (freeing %d frags)\n",
1121                                 ioc->name, numfrags);
1122                         goto free_and_fail;
1123                 }
1124         }
1125
1126         /* Last sge fixup: set LE+eol+eob bits */
1127         sgl[-1].FlagsLength |= 0xC1000000;
1128
1129         *frags = numfrags;
1130         *blp = buflist;
1131
1132         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: kbuf_alloc_2_sgl() - "
1133            "%d SG frags generated!\n", ioc->name, numfrags));
1134
1135         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: kbuf_alloc_2_sgl() - "
1136            "last (big) alloc_sz=%d\n", ioc->name, alloc_sz));
1137
1138         return sglbuf;
1139
1140 free_and_fail:
1141         if (sglbuf != NULL) {
1142                 for (i = 0; i < numfrags; i++) {
1143                         dma_addr_t dma_addr;
1144                         u8 *kptr;
1145                         int len;
1146
1147                         if ((sglbuf[i].FlagsLength >> 24) == 0x30)
1148                                 continue;
1149
1150                         dma_addr = sglbuf[i].Address;
1151                         kptr = buflist[i].kptr;
1152                         len = buflist[i].len;
1153
1154                         pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1155                 }
1156                 pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf, *sglbuf_dma);
1157         }
1158         kfree(buflist);
1159         return NULL;
1160 }
1161
1162 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1163 /*
1164  * Routine to free the SGL elements.
1165  */
1166 static void
1167 kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma, struct buflist *buflist, MPT_ADAPTER *ioc)
1168 {
1169         MptSge_t        *sg = sgl;
1170         struct buflist  *bl = buflist;
1171         u32              nib;
1172         int              dir;
1173         int              n = 0;
1174
1175         if (sg->FlagsLength & 0x04000000)
1176                 dir = PCI_DMA_TODEVICE;
1177         else
1178                 dir = PCI_DMA_FROMDEVICE;
1179
1180         nib = (sg->FlagsLength & 0xF0000000) >> 28;
1181         while (! (nib & 0x4)) { /* eob */
1182                 /* skip ignore/chain. */
1183                 if (nib == 0 || nib == 3) {
1184                         ;
1185                 } else if (sg->Address) {
1186                         dma_addr_t dma_addr;
1187                         void *kptr;
1188                         int len;
1189
1190                         dma_addr = sg->Address;
1191                         kptr = bl->kptr;
1192                         len = bl->len;
1193                         pci_unmap_single(ioc->pcidev, dma_addr, len, dir);
1194                         pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1195                         n++;
1196                 }
1197                 sg++;
1198                 bl++;
1199                 nib = (le32_to_cpu(sg->FlagsLength) & 0xF0000000) >> 28;
1200         }
1201
1202         /* we're at eob! */
1203         if (sg->Address) {
1204                 dma_addr_t dma_addr;
1205                 void *kptr;
1206                 int len;
1207
1208                 dma_addr = sg->Address;
1209                 kptr = bl->kptr;
1210                 len = bl->len;
1211                 pci_unmap_single(ioc->pcidev, dma_addr, len, dir);
1212                 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1213                 n++;
1214         }
1215
1216         pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sgl, sgl_dma);
1217         kfree(buflist);
1218         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: Free'd 1 SGL buf + %d kbufs!\n",
1219             ioc->name, n));
1220 }
1221
1222 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1223 /*
1224  *      mptctl_getiocinfo - Query the host adapter for IOC information.
1225  *      @arg: User space argument
1226  *
1227  * Outputs:     None.
1228  * Return:      0 if successful
1229  *              -EFAULT if data unavailable
1230  *              -ENODEV  if no such device/adapter
1231  */
1232 static int
1233 mptctl_getiocinfo (unsigned long arg, unsigned int data_size)
1234 {
1235         struct mpt_ioctl_iocinfo __user *uarg = (void __user *) arg;
1236         struct mpt_ioctl_iocinfo *karg;
1237         MPT_ADAPTER             *ioc;
1238         struct pci_dev          *pdev;
1239         int                     iocnum;
1240         unsigned int            port;
1241         int                     cim_rev;
1242         u8                      revision;
1243         struct scsi_device      *sdev;
1244         VirtDevice              *vdevice;
1245
1246         /* Add of PCI INFO results in unaligned access for
1247          * IA64 and Sparc. Reset long to int. Return no PCI
1248          * data for obsolete format.
1249          */
1250         if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev0))
1251                 cim_rev = 0;
1252         else if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev1))
1253                 cim_rev = 1;
1254         else if (data_size == sizeof(struct mpt_ioctl_iocinfo))
1255                 cim_rev = 2;
1256         else if (data_size == (sizeof(struct mpt_ioctl_iocinfo_rev0)+12))
1257                 cim_rev = 0;    /* obsolete */
1258         else
1259                 return -EFAULT;
1260
1261         karg = kmalloc(data_size, GFP_KERNEL);
1262         if (karg == NULL) {
1263                 printk(KERN_ERR MYNAM "%s::mpt_ioctl_iocinfo() @%d - no memory available!\n",
1264                                 __FILE__, __LINE__);
1265                 return -ENOMEM;
1266         }
1267
1268         if (copy_from_user(karg, uarg, data_size)) {
1269                 printk(KERN_ERR MYNAM "%s@%d::mptctl_getiocinfo - "
1270                         "Unable to read in mpt_ioctl_iocinfo struct @ %p\n",
1271                                 __FILE__, __LINE__, uarg);
1272                 kfree(karg);
1273                 return -EFAULT;
1274         }
1275
1276         if (((iocnum = mpt_verify_adapter(karg->hdr.iocnum, &ioc)) < 0) ||
1277             (ioc == NULL)) {
1278                 printk(KERN_DEBUG MYNAM "%s::mptctl_getiocinfo() @%d - ioc%d not found!\n",
1279                                 __FILE__, __LINE__, iocnum);
1280                 kfree(karg);
1281                 return -ENODEV;
1282         }
1283
1284         /* Verify the data transfer size is correct. */
1285         if (karg->hdr.maxDataSize != data_size) {
1286                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_getiocinfo - "
1287                         "Structure size mismatch. Command not completed.\n",
1288                         ioc->name, __FILE__, __LINE__);
1289                 kfree(karg);
1290                 return -EFAULT;
1291         }
1292
1293         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_getiocinfo called.\n",
1294             ioc->name));
1295
1296         /* Fill in the data and return the structure to the calling
1297          * program
1298          */
1299         if (ioc->bus_type == SAS)
1300                 karg->adapterType = MPT_IOCTL_INTERFACE_SAS;
1301         else if (ioc->bus_type == FC)
1302                 karg->adapterType = MPT_IOCTL_INTERFACE_FC;
1303         else
1304                 karg->adapterType = MPT_IOCTL_INTERFACE_SCSI;
1305
1306         if (karg->hdr.port > 1)
1307                 return -EINVAL;
1308         port = karg->hdr.port;
1309
1310         karg->port = port;
1311         pdev = (struct pci_dev *) ioc->pcidev;
1312
1313         karg->pciId = pdev->device;
1314         pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1315         karg->hwRev = revision;
1316         karg->subSystemDevice = pdev->subsystem_device;
1317         karg->subSystemVendor = pdev->subsystem_vendor;
1318
1319         if (cim_rev == 1) {
1320                 /* Get the PCI bus, device, and function numbers for the IOC
1321                  */
1322                 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1323                 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1324                 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1325         } else if (cim_rev == 2) {
1326                 /* Get the PCI bus, device, function and segment ID numbers
1327                    for the IOC */
1328                 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1329                 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1330                 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1331                 karg->pciInfo.segmentID = pci_domain_nr(pdev->bus);
1332         }
1333
1334         /* Get number of devices
1335          */
1336         karg->numDevices = 0;
1337         if (ioc->sh) {
1338                 shost_for_each_device(sdev, ioc->sh) {
1339                         vdevice = sdev->hostdata;
1340                         if (vdevice == NULL || vdevice->vtarget == NULL)
1341                                 continue;
1342                         if (vdevice->vtarget->tflags &
1343                             MPT_TARGET_FLAGS_RAID_COMPONENT)
1344                                 continue;
1345                         karg->numDevices++;
1346                 }
1347         }
1348
1349         /* Set the BIOS and FW Version
1350          */
1351         karg->FWVersion = ioc->facts.FWVersion.Word;
1352         karg->BIOSVersion = ioc->biosVersion;
1353
1354         /* Set the Version Strings.
1355          */
1356         strncpy (karg->driverVersion, MPT_LINUX_PACKAGE_NAME, MPT_IOCTL_VERSION_LENGTH);
1357         karg->driverVersion[MPT_IOCTL_VERSION_LENGTH-1]='\0';
1358
1359         karg->busChangeEvent = 0;
1360         karg->hostId = ioc->pfacts[port].PortSCSIID;
1361         karg->rsvd[0] = karg->rsvd[1] = 0;
1362
1363         /* Copy the data from kernel memory to user memory
1364          */
1365         if (copy_to_user((char __user *)arg, karg, data_size)) {
1366                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_getiocinfo - "
1367                         "Unable to write out mpt_ioctl_iocinfo struct @ %p\n",
1368                         ioc->name, __FILE__, __LINE__, uarg);
1369                 kfree(karg);
1370                 return -EFAULT;
1371         }
1372
1373         kfree(karg);
1374         return 0;
1375 }
1376
1377 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1378 /*
1379  *      mptctl_gettargetinfo - Query the host adapter for target information.
1380  *      @arg: User space argument
1381  *
1382  * Outputs:     None.
1383  * Return:      0 if successful
1384  *              -EFAULT if data unavailable
1385  *              -ENODEV  if no such device/adapter
1386  */
1387 static int
1388 mptctl_gettargetinfo (unsigned long arg)
1389 {
1390         struct mpt_ioctl_targetinfo __user *uarg = (void __user *) arg;
1391         struct mpt_ioctl_targetinfo karg;
1392         MPT_ADAPTER             *ioc;
1393         VirtDevice              *vdevice;
1394         char                    *pmem;
1395         int                     *pdata;
1396         int                     iocnum;
1397         int                     numDevices = 0;
1398         int                     lun;
1399         int                     maxWordsLeft;
1400         int                     numBytes;
1401         u8                      port;
1402         struct scsi_device      *sdev;
1403
1404         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_targetinfo))) {
1405                 printk(KERN_ERR MYNAM "%s@%d::mptctl_gettargetinfo - "
1406                         "Unable to read in mpt_ioctl_targetinfo struct @ %p\n",
1407                                 __FILE__, __LINE__, uarg);
1408                 return -EFAULT;
1409         }
1410
1411         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1412             (ioc == NULL)) {
1413                 printk(KERN_DEBUG MYNAM "%s::mptctl_gettargetinfo() @%d - ioc%d not found!\n",
1414                                 __FILE__, __LINE__, iocnum);
1415                 return -ENODEV;
1416         }
1417
1418         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_gettargetinfo called.\n",
1419             ioc->name));
1420         /* Get the port number and set the maximum number of bytes
1421          * in the returned structure.
1422          * Ignore the port setting.
1423          */
1424         numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1425         maxWordsLeft = numBytes/sizeof(int);
1426         port = karg.hdr.port;
1427
1428         if (maxWordsLeft <= 0) {
1429                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo() - no memory available!\n",
1430                         ioc->name, __FILE__, __LINE__);
1431                 return -ENOMEM;
1432         }
1433
1434         /* Fill in the data and return the structure to the calling
1435          * program
1436          */
1437
1438         /* struct mpt_ioctl_targetinfo does not contain sufficient space
1439          * for the target structures so when the IOCTL is called, there is
1440          * not sufficient stack space for the structure. Allocate memory,
1441          * populate the memory, copy back to the user, then free memory.
1442          * targetInfo format:
1443          * bits 31-24: reserved
1444          *      23-16: LUN
1445          *      15- 8: Bus Number
1446          *       7- 0: Target ID
1447          */
1448         pmem = kzalloc(numBytes, GFP_KERNEL);
1449         if (!pmem) {
1450                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo() - no memory available!\n",
1451                         ioc->name, __FILE__, __LINE__);
1452                 return -ENOMEM;
1453         }
1454         pdata =  (int *) pmem;
1455
1456         /* Get number of devices
1457          */
1458         if (ioc->sh){
1459                 shost_for_each_device(sdev, ioc->sh) {
1460                         if (!maxWordsLeft)
1461                                 continue;
1462                         vdevice = sdev->hostdata;
1463                         if (vdevice == NULL || vdevice->vtarget == NULL)
1464                                 continue;
1465                         if (vdevice->vtarget->tflags &
1466                             MPT_TARGET_FLAGS_RAID_COMPONENT)
1467                                 continue;
1468                         lun = (vdevice->vtarget->raidVolume) ? 0x80 : vdevice->lun;
1469                         *pdata = (((u8)lun << 16) + (vdevice->vtarget->channel << 8) +
1470                             (vdevice->vtarget->id ));
1471                         pdata++;
1472                         numDevices++;
1473                         --maxWordsLeft;
1474                 }
1475         }
1476         karg.numDevices = numDevices;
1477
1478         /* Copy part of the data from kernel memory to user memory
1479          */
1480         if (copy_to_user((char __user *)arg, &karg,
1481                                 sizeof(struct mpt_ioctl_targetinfo))) {
1482                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo - "
1483                         "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1484                         ioc->name, __FILE__, __LINE__, uarg);
1485                 kfree(pmem);
1486                 return -EFAULT;
1487         }
1488
1489         /* Copy the remaining data from kernel memory to user memory
1490          */
1491         if (copy_to_user(uarg->targetInfo, pmem, numBytes)) {
1492                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo - "
1493                         "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1494                         ioc->name, __FILE__, __LINE__, pdata);
1495                 kfree(pmem);
1496                 return -EFAULT;
1497         }
1498
1499         kfree(pmem);
1500
1501         return 0;
1502 }
1503
1504 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1505 /* MPT IOCTL Test function.
1506  *
1507  * Outputs:     None.
1508  * Return:      0 if successful
1509  *              -EFAULT if data unavailable
1510  *              -ENODEV  if no such device/adapter
1511  */
1512 static int
1513 mptctl_readtest (unsigned long arg)
1514 {
1515         struct mpt_ioctl_test __user *uarg = (void __user *) arg;
1516         struct mpt_ioctl_test    karg;
1517         MPT_ADAPTER *ioc;
1518         int iocnum;
1519
1520         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_test))) {
1521                 printk(KERN_ERR MYNAM "%s@%d::mptctl_readtest - "
1522                         "Unable to read in mpt_ioctl_test struct @ %p\n",
1523                                 __FILE__, __LINE__, uarg);
1524                 return -EFAULT;
1525         }
1526
1527         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1528             (ioc == NULL)) {
1529                 printk(KERN_DEBUG MYNAM "%s::mptctl_readtest() @%d - ioc%d not found!\n",
1530                                 __FILE__, __LINE__, iocnum);
1531                 return -ENODEV;
1532         }
1533
1534         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_readtest called.\n",
1535             ioc->name));
1536         /* Fill in the data and return the structure to the calling
1537          * program
1538          */
1539
1540 #ifdef MFCNT
1541         karg.chip_type = ioc->mfcnt;
1542 #else
1543         karg.chip_type = ioc->pcidev->device;
1544 #endif
1545         strncpy (karg.name, ioc->name, MPT_MAX_NAME);
1546         karg.name[MPT_MAX_NAME-1]='\0';
1547         strncpy (karg.product, ioc->prod_name, MPT_PRODUCT_LENGTH);
1548         karg.product[MPT_PRODUCT_LENGTH-1]='\0';
1549
1550         /* Copy the data from kernel memory to user memory
1551          */
1552         if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_test))) {
1553                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_readtest - "
1554                         "Unable to write out mpt_ioctl_test struct @ %p\n",
1555                         ioc->name, __FILE__, __LINE__, uarg);
1556                 return -EFAULT;
1557         }
1558
1559         return 0;
1560 }
1561
1562 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1563 /*
1564  *      mptctl_eventquery - Query the host adapter for the event types
1565  *      that are being logged.
1566  *      @arg: User space argument
1567  *
1568  * Outputs:     None.
1569  * Return:      0 if successful
1570  *              -EFAULT if data unavailable
1571  *              -ENODEV  if no such device/adapter
1572  */
1573 static int
1574 mptctl_eventquery (unsigned long arg)
1575 {
1576         struct mpt_ioctl_eventquery __user *uarg = (void __user *) arg;
1577         struct mpt_ioctl_eventquery      karg;
1578         MPT_ADAPTER *ioc;
1579         int iocnum;
1580
1581         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventquery))) {
1582                 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventquery - "
1583                         "Unable to read in mpt_ioctl_eventquery struct @ %p\n",
1584                                 __FILE__, __LINE__, uarg);
1585                 return -EFAULT;
1586         }
1587
1588         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1589             (ioc == NULL)) {
1590                 printk(KERN_DEBUG MYNAM "%s::mptctl_eventquery() @%d - ioc%d not found!\n",
1591                                 __FILE__, __LINE__, iocnum);
1592                 return -ENODEV;
1593         }
1594
1595         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventquery called.\n",
1596             ioc->name));
1597         karg.eventEntries = MPTCTL_EVENT_LOG_SIZE;
1598         karg.eventTypes = ioc->eventTypes;
1599
1600         /* Copy the data from kernel memory to user memory
1601          */
1602         if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_eventquery))) {
1603                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_eventquery - "
1604                         "Unable to write out mpt_ioctl_eventquery struct @ %p\n",
1605                         ioc->name, __FILE__, __LINE__, uarg);
1606                 return -EFAULT;
1607         }
1608         return 0;
1609 }
1610
1611 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1612 static int
1613 mptctl_eventenable (unsigned long arg)
1614 {
1615         struct mpt_ioctl_eventenable __user *uarg = (void __user *) arg;
1616         struct mpt_ioctl_eventenable     karg;
1617         MPT_ADAPTER *ioc;
1618         int iocnum;
1619
1620         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventenable))) {
1621                 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventenable - "
1622                         "Unable to read in mpt_ioctl_eventenable struct @ %p\n",
1623                                 __FILE__, __LINE__, uarg);
1624                 return -EFAULT;
1625         }
1626
1627         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1628             (ioc == NULL)) {
1629                 printk(KERN_DEBUG MYNAM "%s::mptctl_eventenable() @%d - ioc%d not found!\n",
1630                                 __FILE__, __LINE__, iocnum);
1631                 return -ENODEV;
1632         }
1633
1634         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventenable called.\n",
1635             ioc->name));
1636         if (ioc->events == NULL) {
1637                 /* Have not yet allocated memory - do so now.
1638                  */
1639                 int sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
1640                 ioc->events = kzalloc(sz, GFP_KERNEL);
1641                 if (!ioc->events) {
1642                         printk(MYIOC_s_ERR_FMT
1643                             ": ERROR - Insufficient memory to add adapter!\n",
1644                             ioc->name);
1645                         return -ENOMEM;
1646                 }
1647                 ioc->alloc_total += sz;
1648
1649                 ioc->eventContext = 0;
1650         }
1651
1652         /* Update the IOC event logging flag.
1653          */
1654         ioc->eventTypes = karg.eventTypes;
1655
1656         return 0;
1657 }
1658
1659 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1660 static int
1661 mptctl_eventreport (unsigned long arg)
1662 {
1663         struct mpt_ioctl_eventreport __user *uarg = (void __user *) arg;
1664         struct mpt_ioctl_eventreport     karg;
1665         MPT_ADAPTER              *ioc;
1666         int                      iocnum;
1667         int                      numBytes, maxEvents, max;
1668
1669         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventreport))) {
1670                 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventreport - "
1671                         "Unable to read in mpt_ioctl_eventreport struct @ %p\n",
1672                                 __FILE__, __LINE__, uarg);
1673                 return -EFAULT;
1674         }
1675
1676         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1677             (ioc == NULL)) {
1678                 printk(KERN_DEBUG MYNAM "%s::mptctl_eventreport() @%d - ioc%d not found!\n",
1679                                 __FILE__, __LINE__, iocnum);
1680                 return -ENODEV;
1681         }
1682         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventreport called.\n",
1683             ioc->name));
1684
1685         numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1686         maxEvents = numBytes/sizeof(MPT_IOCTL_EVENTS);
1687
1688
1689         max = MPTCTL_EVENT_LOG_SIZE < maxEvents ? MPTCTL_EVENT_LOG_SIZE : maxEvents;
1690
1691         /* If fewer than 1 event is requested, there must have
1692          * been some type of error.
1693          */
1694         if ((max < 1) || !ioc->events)
1695                 return -ENODATA;
1696
1697         /* reset this flag so SIGIO can restart */
1698         ioc->aen_event_read_flag=0;
1699
1700         /* Copy the data from kernel memory to user memory
1701          */
1702         numBytes = max * sizeof(MPT_IOCTL_EVENTS);
1703         if (copy_to_user(uarg->eventData, ioc->events, numBytes)) {
1704                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_eventreport - "
1705                         "Unable to write out mpt_ioctl_eventreport struct @ %p\n",
1706                         ioc->name, __FILE__, __LINE__, ioc->events);
1707                 return -EFAULT;
1708         }
1709
1710         return 0;
1711 }
1712
1713 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1714 static int
1715 mptctl_replace_fw (unsigned long arg)
1716 {
1717         struct mpt_ioctl_replace_fw __user *uarg = (void __user *) arg;
1718         struct mpt_ioctl_replace_fw      karg;
1719         MPT_ADAPTER              *ioc;
1720         int                      iocnum;
1721         int                      newFwSize;
1722
1723         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_replace_fw))) {
1724                 printk(KERN_ERR MYNAM "%s@%d::mptctl_replace_fw - "
1725                         "Unable to read in mpt_ioctl_replace_fw struct @ %p\n",
1726                                 __FILE__, __LINE__, uarg);
1727                 return -EFAULT;
1728         }
1729
1730         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1731             (ioc == NULL)) {
1732                 printk(KERN_DEBUG MYNAM "%s::mptctl_replace_fw() @%d - ioc%d not found!\n",
1733                                 __FILE__, __LINE__, iocnum);
1734                 return -ENODEV;
1735         }
1736
1737         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_replace_fw called.\n",
1738             ioc->name));
1739         /* If caching FW, Free the old FW image
1740          */
1741         if (ioc->cached_fw == NULL)
1742                 return 0;
1743
1744         mpt_free_fw_memory(ioc);
1745
1746         /* Allocate memory for the new FW image
1747          */
1748         newFwSize = karg.newImageSize;
1749
1750         if (newFwSize & 0x01)
1751                 newFwSize += 1;
1752         if (newFwSize & 0x02)
1753                 newFwSize += 2;
1754
1755         mpt_alloc_fw_memory(ioc, newFwSize);
1756         if (ioc->cached_fw == NULL)
1757                 return -ENOMEM;
1758
1759         /* Copy the data from user memory to kernel space
1760          */
1761         if (copy_from_user(ioc->cached_fw, uarg->newImage, newFwSize)) {
1762                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_replace_fw - "
1763                                 "Unable to read in mpt_ioctl_replace_fw image "
1764                                 "@ %p\n", ioc->name, __FILE__, __LINE__, uarg);
1765                 mpt_free_fw_memory(ioc);
1766                 return -EFAULT;
1767         }
1768
1769         /* Update IOCFactsReply
1770          */
1771         ioc->facts.FWImageSize = newFwSize;
1772         return 0;
1773 }
1774
1775 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1776 /* MPT IOCTL MPTCOMMAND function.
1777  * Cast the arg into the mpt_ioctl_mpt_command structure.
1778  *
1779  * Outputs:     None.
1780  * Return:      0 if successful
1781  *              -EBUSY  if previous command timeout and IOC reset is not complete.
1782  *              -EFAULT if data unavailable
1783  *              -ENODEV if no such device/adapter
1784  *              -ETIME  if timer expires
1785  *              -ENOMEM if memory allocation error
1786  */
1787 static int
1788 mptctl_mpt_command (unsigned long arg)
1789 {
1790         struct mpt_ioctl_command __user *uarg = (void __user *) arg;
1791         struct mpt_ioctl_command  karg;
1792         MPT_ADAPTER     *ioc;
1793         int             iocnum;
1794         int             rc;
1795
1796
1797         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_command))) {
1798                 printk(KERN_ERR MYNAM "%s@%d::mptctl_mpt_command - "
1799                         "Unable to read in mpt_ioctl_command struct @ %p\n",
1800                                 __FILE__, __LINE__, uarg);
1801                 return -EFAULT;
1802         }
1803
1804         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1805             (ioc == NULL)) {
1806                 printk(KERN_DEBUG MYNAM "%s::mptctl_mpt_command() @%d - ioc%d not found!\n",
1807                                 __FILE__, __LINE__, iocnum);
1808                 return -ENODEV;
1809         }
1810
1811         rc = mptctl_do_mpt_command (karg, &uarg->MF);
1812
1813         return rc;
1814 }
1815
1816 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1817 /* Worker routine for the IOCTL MPTCOMMAND and MPTCOMMAND32 (sparc) commands.
1818  *
1819  * Outputs:     None.
1820  * Return:      0 if successful
1821  *              -EBUSY  if previous command timeout and IOC reset is not complete.
1822  *              -EFAULT if data unavailable
1823  *              -ENODEV if no such device/adapter
1824  *              -ETIME  if timer expires
1825  *              -ENOMEM if memory allocation error
1826  *              -EPERM if SCSI I/O and target is untagged
1827  */
1828 static int
1829 mptctl_do_mpt_command (struct mpt_ioctl_command karg, void __user *mfPtr)
1830 {
1831         MPT_ADAPTER     *ioc;
1832         MPT_FRAME_HDR   *mf = NULL;
1833         MPIHeader_t     *hdr;
1834         char            *psge;
1835         struct buflist  bufIn;  /* data In buffer */
1836         struct buflist  bufOut; /* data Out buffer */
1837         dma_addr_t      dma_addr_in;
1838         dma_addr_t      dma_addr_out;
1839         int             sgSize = 0;     /* Num SG elements */
1840         int             iocnum, flagsLength;
1841         int             sz, rc = 0;
1842         int             msgContext;
1843         u16             req_idx;
1844         ulong           timeout;
1845         unsigned long   timeleft;
1846         struct scsi_device *sdev;
1847         unsigned long    flags;
1848         u8               function;
1849
1850         /* bufIn and bufOut are used for user to kernel space transfers
1851          */
1852         bufIn.kptr = bufOut.kptr = NULL;
1853         bufIn.len = bufOut.len = 0;
1854
1855         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1856             (ioc == NULL)) {
1857                 printk(KERN_DEBUG MYNAM "%s::mptctl_do_mpt_command() @%d - ioc%d not found!\n",
1858                                 __FILE__, __LINE__, iocnum);
1859                 return -ENODEV;
1860         }
1861
1862         spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
1863         if (ioc->ioc_reset_in_progress) {
1864                 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
1865                 printk(KERN_ERR MYNAM "%s@%d::mptctl_do_mpt_command - "
1866                         "Busy with diagnostic reset\n", __FILE__, __LINE__);
1867                 return -EBUSY;
1868         }
1869         spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
1870
1871         /* Verify that the final request frame will not be too large.
1872          */
1873         sz = karg.dataSgeOffset * 4;
1874         if (karg.dataInSize > 0)
1875                 sz += ioc->SGE_size;
1876         if (karg.dataOutSize > 0)
1877                 sz += ioc->SGE_size;
1878
1879         if (sz > ioc->req_sz) {
1880                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1881                         "Request frame too large (%d) maximum (%d)\n",
1882                         ioc->name, __FILE__, __LINE__, sz, ioc->req_sz);
1883                 return -EFAULT;
1884         }
1885
1886         /* Get a free request frame and save the message context.
1887          */
1888         if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
1889                 return -EAGAIN;
1890
1891         hdr = (MPIHeader_t *) mf;
1892         msgContext = le32_to_cpu(hdr->MsgContext);
1893         req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1894
1895         /* Copy the request frame
1896          * Reset the saved message context.
1897          * Request frame in user space
1898          */
1899         if (copy_from_user(mf, mfPtr, karg.dataSgeOffset * 4)) {
1900                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1901                         "Unable to read MF from mpt_ioctl_command struct @ %p\n",
1902                         ioc->name, __FILE__, __LINE__, mfPtr);
1903                 function = -1;
1904                 rc = -EFAULT;
1905                 goto done_free_mem;
1906         }
1907         hdr->MsgContext = cpu_to_le32(msgContext);
1908         function = hdr->Function;
1909
1910
1911         /* Verify that this request is allowed.
1912          */
1913         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sending mpi function (0x%02X), req=%p\n",
1914             ioc->name, hdr->Function, mf));
1915
1916         switch (function) {
1917         case MPI_FUNCTION_IOC_FACTS:
1918         case MPI_FUNCTION_PORT_FACTS:
1919                 karg.dataOutSize  = karg.dataInSize = 0;
1920                 break;
1921
1922         case MPI_FUNCTION_CONFIG:
1923         {
1924                 Config_t *config_frame;
1925                 config_frame = (Config_t *)mf;
1926                 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\ttype=0x%02x ext_type=0x%02x "
1927                     "number=0x%02x action=0x%02x\n", ioc->name,
1928                     config_frame->Header.PageType,
1929                     config_frame->ExtPageType,
1930                     config_frame->Header.PageNumber,
1931                     config_frame->Action));
1932                 break;
1933         }
1934
1935         case MPI_FUNCTION_FC_COMMON_TRANSPORT_SEND:
1936         case MPI_FUNCTION_FC_EX_LINK_SRVC_SEND:
1937         case MPI_FUNCTION_FW_UPLOAD:
1938         case MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR:
1939         case MPI_FUNCTION_FW_DOWNLOAD:
1940         case MPI_FUNCTION_FC_PRIMITIVE_SEND:
1941         case MPI_FUNCTION_TOOLBOX:
1942         case MPI_FUNCTION_SAS_IO_UNIT_CONTROL:
1943                 break;
1944
1945         case MPI_FUNCTION_SCSI_IO_REQUEST:
1946                 if (ioc->sh) {
1947                         SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
1948                         int qtag = MPI_SCSIIO_CONTROL_UNTAGGED;
1949                         int scsidir = 0;
1950                         int dataSize;
1951                         u32 id;
1952
1953                         id = (ioc->devices_per_bus == 0) ? 256 : ioc->devices_per_bus;
1954                         if (pScsiReq->TargetID > id) {
1955                                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1956                                         "Target ID out of bounds. \n",
1957                                         ioc->name, __FILE__, __LINE__);
1958                                 rc = -ENODEV;
1959                                 goto done_free_mem;
1960                         }
1961
1962                         if (pScsiReq->Bus >= ioc->number_of_buses) {
1963                                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1964                                         "Target Bus out of bounds. \n",
1965                                         ioc->name, __FILE__, __LINE__);
1966                                 rc = -ENODEV;
1967                                 goto done_free_mem;
1968                         }
1969
1970                         pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
1971                         pScsiReq->MsgFlags |= mpt_msg_flags(ioc);
1972
1973
1974                         /* verify that app has not requested
1975                          *      more sense data than driver
1976                          *      can provide, if so, reset this parameter
1977                          * set the sense buffer pointer low address
1978                          * update the control field to specify Q type
1979                          */
1980                         if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1981                                 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1982                         else
1983                                 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1984
1985                         pScsiReq->SenseBufferLowAddr =
1986                                 cpu_to_le32(ioc->sense_buf_low_dma
1987                                    + (req_idx * MPT_SENSE_BUFFER_ALLOC));
1988
1989                         shost_for_each_device(sdev, ioc->sh) {
1990                                 struct scsi_target *starget = scsi_target(sdev);
1991                                 VirtTarget *vtarget = starget->hostdata;
1992
1993                                 if (vtarget == NULL)
1994                                         continue;
1995
1996                                 if ((pScsiReq->TargetID == vtarget->id) &&
1997                                     (pScsiReq->Bus == vtarget->channel) &&
1998                                     (vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
1999                                         qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
2000                         }
2001
2002                         /* Have the IOCTL driver set the direction based
2003                          * on the dataOutSize (ordering issue with Sparc).
2004                          */
2005                         if (karg.dataOutSize > 0) {
2006                                 scsidir = MPI_SCSIIO_CONTROL_WRITE;
2007                                 dataSize = karg.dataOutSize;
2008                         } else {
2009                                 scsidir = MPI_SCSIIO_CONTROL_READ;
2010                                 dataSize = karg.dataInSize;
2011                         }
2012
2013                         pScsiReq->Control = cpu_to_le32(scsidir | qtag);
2014                         pScsiReq->DataLength = cpu_to_le32(dataSize);
2015
2016
2017                 } else {
2018                         printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2019                                 "SCSI driver is not loaded. \n",
2020                                 ioc->name, __FILE__, __LINE__);
2021                         rc = -EFAULT;
2022                         goto done_free_mem;
2023                 }
2024                 break;
2025
2026         case MPI_FUNCTION_SMP_PASSTHROUGH:
2027                 /* Check mf->PassthruFlags to determine if
2028                  * transfer is ImmediateMode or not.
2029                  * Immediate mode returns data in the ReplyFrame.
2030                  * Else, we are sending request and response data
2031                  * in two SGLs at the end of the mf.
2032                  */
2033                 break;
2034
2035         case MPI_FUNCTION_SATA_PASSTHROUGH:
2036                 if (!ioc->sh) {
2037                         printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2038                                 "SCSI driver is not loaded. \n",
2039                                 ioc->name, __FILE__, __LINE__);
2040                         rc = -EFAULT;
2041                         goto done_free_mem;
2042                 }
2043                 break;
2044
2045         case MPI_FUNCTION_RAID_ACTION:
2046                 /* Just add a SGE
2047                  */
2048                 break;
2049
2050         case MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
2051                 if (ioc->sh) {
2052                         SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
2053                         int qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
2054                         int scsidir = MPI_SCSIIO_CONTROL_READ;
2055                         int dataSize;
2056
2057                         pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
2058                         pScsiReq->MsgFlags |= mpt_msg_flags(ioc);
2059
2060
2061                         /* verify that app has not requested
2062                          *      more sense data than driver
2063                          *      can provide, if so, reset this parameter
2064                          * set the sense buffer pointer low address
2065                          * update the control field to specify Q type
2066                          */
2067                         if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
2068                                 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
2069                         else
2070                                 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
2071
2072                         pScsiReq->SenseBufferLowAddr =
2073                                 cpu_to_le32(ioc->sense_buf_low_dma
2074                                    + (req_idx * MPT_SENSE_BUFFER_ALLOC));
2075
2076                         /* All commands to physical devices are tagged
2077                          */
2078
2079                         /* Have the IOCTL driver set the direction based
2080                          * on the dataOutSize (ordering issue with Sparc).
2081                          */
2082                         if (karg.dataOutSize > 0) {
2083                                 scsidir = MPI_SCSIIO_CONTROL_WRITE;
2084                                 dataSize = karg.dataOutSize;
2085                         } else {
2086                                 scsidir = MPI_SCSIIO_CONTROL_READ;
2087                                 dataSize = karg.dataInSize;
2088                         }
2089
2090                         pScsiReq->Control = cpu_to_le32(scsidir | qtag);
2091                         pScsiReq->DataLength = cpu_to_le32(dataSize);
2092
2093                 } else {
2094                         printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2095                                 "SCSI driver is not loaded. \n",
2096                                 ioc->name, __FILE__, __LINE__);
2097                         rc = -EFAULT;
2098                         goto done_free_mem;
2099                 }
2100                 break;
2101
2102         case MPI_FUNCTION_SCSI_TASK_MGMT:
2103         {
2104                 SCSITaskMgmt_t  *pScsiTm;
2105                 pScsiTm = (SCSITaskMgmt_t *)mf;
2106                 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2107                         "\tTaskType=0x%x MsgFlags=0x%x "
2108                         "TaskMsgContext=0x%x id=%d channel=%d\n",
2109                         ioc->name, pScsiTm->TaskType, le32_to_cpu
2110                         (pScsiTm->TaskMsgContext), pScsiTm->MsgFlags,
2111                         pScsiTm->TargetID, pScsiTm->Bus));
2112                 break;
2113         }
2114
2115         case MPI_FUNCTION_IOC_INIT:
2116                 {
2117                         IOCInit_t       *pInit = (IOCInit_t *) mf;
2118                         u32             high_addr, sense_high;
2119
2120                         /* Verify that all entries in the IOC INIT match
2121                          * existing setup (and in LE format).
2122                          */
2123                         if (sizeof(dma_addr_t) == sizeof(u64)) {
2124                                 high_addr = cpu_to_le32((u32)((u64)ioc->req_frames_dma >> 32));
2125                                 sense_high= cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
2126                         } else {
2127                                 high_addr = 0;
2128                                 sense_high= 0;
2129                         }
2130
2131                         if ((pInit->Flags != 0) || (pInit->MaxDevices != ioc->facts.MaxDevices) ||
2132                                 (pInit->MaxBuses != ioc->facts.MaxBuses) ||
2133                                 (pInit->ReplyFrameSize != cpu_to_le16(ioc->reply_sz)) ||
2134                                 (pInit->HostMfaHighAddr != high_addr) ||
2135                                 (pInit->SenseBufferHighAddr != sense_high)) {
2136                                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2137                                         "IOC_INIT issued with 1 or more incorrect parameters. Rejected.\n",
2138                                         ioc->name, __FILE__, __LINE__);
2139                                 rc = -EFAULT;
2140                                 goto done_free_mem;
2141                         }
2142                 }
2143                 break;
2144         default:
2145                 /*
2146                  * MPI_FUNCTION_PORT_ENABLE
2147                  * MPI_FUNCTION_TARGET_CMD_BUFFER_POST
2148                  * MPI_FUNCTION_TARGET_ASSIST
2149                  * MPI_FUNCTION_TARGET_STATUS_SEND
2150                  * MPI_FUNCTION_TARGET_MODE_ABORT
2151                  * MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET
2152                  * MPI_FUNCTION_IO_UNIT_RESET
2153                  * MPI_FUNCTION_HANDSHAKE
2154                  * MPI_FUNCTION_REPLY_FRAME_REMOVAL
2155                  * MPI_FUNCTION_EVENT_NOTIFICATION
2156                  *  (driver handles event notification)
2157                  * MPI_FUNCTION_EVENT_ACK
2158                  */
2159
2160                 /*  What to do with these???  CHECK ME!!!
2161                         MPI_FUNCTION_FC_LINK_SRVC_BUF_POST
2162                         MPI_FUNCTION_FC_LINK_SRVC_RSP
2163                         MPI_FUNCTION_FC_ABORT
2164                         MPI_FUNCTION_LAN_SEND
2165                         MPI_FUNCTION_LAN_RECEIVE
2166                         MPI_FUNCTION_LAN_RESET
2167                 */
2168
2169                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2170                         "Illegal request (function 0x%x) \n",
2171                         ioc->name, __FILE__, __LINE__, hdr->Function);
2172                 rc = -EFAULT;
2173                 goto done_free_mem;
2174         }
2175
2176         /* Add the SGL ( at most one data in SGE and one data out SGE )
2177          * In the case of two SGE's - the data out (write) will always
2178          * preceede the data in (read) SGE. psgList is used to free the
2179          * allocated memory.
2180          */
2181         psge = (char *) (((int *) mf) + karg.dataSgeOffset);
2182         flagsLength = 0;
2183
2184         if (karg.dataOutSize > 0)
2185                 sgSize ++;
2186
2187         if (karg.dataInSize > 0)
2188                 sgSize ++;
2189
2190         if (sgSize > 0) {
2191
2192                 /* Set up the dataOut memory allocation */
2193                 if (karg.dataOutSize > 0) {
2194                         if (karg.dataInSize > 0) {
2195                                 flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2196                                                 MPI_SGE_FLAGS_END_OF_BUFFER |
2197                                                 MPI_SGE_FLAGS_DIRECTION)
2198                                                 << MPI_SGE_FLAGS_SHIFT;
2199                         } else {
2200                                 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
2201                         }
2202                         flagsLength |= karg.dataOutSize;
2203                         bufOut.len = karg.dataOutSize;
2204                         bufOut.kptr = pci_alloc_consistent(
2205                                         ioc->pcidev, bufOut.len, &dma_addr_out);
2206
2207                         if (bufOut.kptr == NULL) {
2208                                 rc = -ENOMEM;
2209                                 goto done_free_mem;
2210                         } else {
2211                                 /* Set up this SGE.
2212                                  * Copy to MF and to sglbuf
2213                                  */
2214                                 ioc->add_sge(psge, flagsLength, dma_addr_out);
2215                                 psge += ioc->SGE_size;
2216
2217                                 /* Copy user data to kernel space.
2218                                  */
2219                                 if (copy_from_user(bufOut.kptr,
2220                                                 karg.dataOutBufPtr,
2221                                                 bufOut.len)) {
2222                                         printk(MYIOC_s_ERR_FMT
2223                                                 "%s@%d::mptctl_do_mpt_command - Unable "
2224                                                 "to read user data "
2225                                                 "struct @ %p\n",
2226                                                 ioc->name, __FILE__, __LINE__,karg.dataOutBufPtr);
2227                                         rc =  -EFAULT;
2228                                         goto done_free_mem;
2229                                 }
2230                         }
2231                 }
2232
2233                 if (karg.dataInSize > 0) {
2234                         flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
2235                         flagsLength |= karg.dataInSize;
2236
2237                         bufIn.len = karg.dataInSize;
2238                         bufIn.kptr = pci_alloc_consistent(ioc->pcidev,
2239                                         bufIn.len, &dma_addr_in);
2240
2241                         if (bufIn.kptr == NULL) {
2242                                 rc = -ENOMEM;
2243                                 goto done_free_mem;
2244                         } else {
2245                                 /* Set up this SGE
2246                                  * Copy to MF and to sglbuf
2247                                  */
2248                                 ioc->add_sge(psge, flagsLength, dma_addr_in);
2249                         }
2250                 }
2251         } else  {
2252                 /* Add a NULL SGE
2253                  */
2254                 ioc->add_sge(psge, flagsLength, (dma_addr_t) -1);
2255         }
2256
2257         SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, hdr->MsgContext);
2258         INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
2259         if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT) {
2260
2261                 mutex_lock(&ioc->taskmgmt_cmds.mutex);
2262                 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
2263                         mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2264                         goto done_free_mem;
2265                 }
2266
2267                 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
2268
2269                 if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
2270                     (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
2271                         mpt_put_msg_frame_hi_pri(mptctl_id, ioc, mf);
2272                 else {
2273                         rc =mpt_send_handshake_request(mptctl_id, ioc,
2274                                 sizeof(SCSITaskMgmt_t), (u32*)mf, CAN_SLEEP);
2275                         if (rc != 0) {
2276                                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2277                                     "send_handshake FAILED! (ioc %p, mf %p)\n",
2278                                     ioc->name, ioc, mf));
2279                                 mpt_clear_taskmgmt_in_progress_flag(ioc);
2280                                 rc = -ENODATA;
2281                                 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2282                                 goto done_free_mem;
2283                         }
2284                 }
2285
2286         } else
2287                 mpt_put_msg_frame(mptctl_id, ioc, mf);
2288
2289         /* Now wait for the command to complete */
2290         timeout = (karg.timeout > 0) ? karg.timeout : MPT_IOCTL_DEFAULT_TIMEOUT;
2291 retry_wait:
2292         timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
2293                                 HZ*timeout);
2294         if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2295                 rc = -ETIME;
2296                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "%s: TIMED OUT!\n",
2297                     ioc->name, __func__));
2298                 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2299                         if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2300                                 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2301                         goto done_free_mem;
2302                 }
2303                 if (!timeleft) {
2304                         if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2305                                 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2306                         mptctl_timeout_expired(ioc, mf);
2307                         mf = NULL;
2308                 } else
2309                         goto retry_wait;
2310                 goto done_free_mem;
2311         }
2312
2313         if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2314                 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2315
2316
2317         mf = NULL;
2318
2319         /* If a valid reply frame, copy to the user.
2320          * Offset 2: reply length in U32's
2321          */
2322         if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) {
2323                 if (karg.maxReplyBytes < ioc->reply_sz) {
2324                         sz = min(karg.maxReplyBytes,
2325                                 4*ioc->ioctl_cmds.reply[2]);
2326                 } else {
2327                          sz = min(ioc->reply_sz, 4*ioc->ioctl_cmds.reply[2]);
2328                 }
2329                 if (sz > 0) {
2330                         if (copy_to_user(karg.replyFrameBufPtr,
2331                                  ioc->ioctl_cmds.reply, sz)){
2332                                  printk(MYIOC_s_ERR_FMT
2333                                      "%s@%d::mptctl_do_mpt_command - "
2334                                  "Unable to write out reply frame %p\n",
2335                                  ioc->name, __FILE__, __LINE__, karg.replyFrameBufPtr);
2336                                  rc =  -ENODATA;
2337                                  goto done_free_mem;
2338                         }
2339                 }
2340         }
2341
2342         /* If valid sense data, copy to user.
2343          */
2344         if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_SENSE_VALID) {
2345                 sz = min(karg.maxSenseBytes, MPT_SENSE_BUFFER_SIZE);
2346                 if (sz > 0) {
2347                         if (copy_to_user(karg.senseDataPtr,
2348                                 ioc->ioctl_cmds.sense, sz)) {
2349                                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2350                                 "Unable to write sense data to user %p\n",
2351                                 ioc->name, __FILE__, __LINE__,
2352                                 karg.senseDataPtr);
2353                                 rc =  -ENODATA;
2354                                 goto done_free_mem;
2355                         }
2356                 }
2357         }
2358
2359         /* If the overall status is _GOOD and data in, copy data
2360          * to user.
2361          */
2362         if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD) &&
2363                                 (karg.dataInSize > 0) && (bufIn.kptr)) {
2364
2365                 if (copy_to_user(karg.dataInBufPtr,
2366                                  bufIn.kptr, karg.dataInSize)) {
2367                         printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2368                                 "Unable to write data to user %p\n",
2369                                 ioc->name, __FILE__, __LINE__,
2370                                 karg.dataInBufPtr);
2371                         rc =  -ENODATA;
2372                 }
2373         }
2374
2375 done_free_mem:
2376
2377         CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
2378         SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
2379
2380         /* Free the allocated memory.
2381          */
2382         if (bufOut.kptr != NULL) {
2383                 pci_free_consistent(ioc->pcidev,
2384                         bufOut.len, (void *) bufOut.kptr, dma_addr_out);
2385         }
2386
2387         if (bufIn.kptr != NULL) {
2388                 pci_free_consistent(ioc->pcidev,
2389                         bufIn.len, (void *) bufIn.kptr, dma_addr_in);
2390         }
2391
2392         /* mf is null if command issued successfully
2393          * otherwise, failure occured after mf acquired.
2394          */
2395         if (mf)
2396                 mpt_free_msg_frame(ioc, mf);
2397
2398         return rc;
2399 }
2400
2401 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2402 /* Prototype Routine for the HOST INFO command.
2403  *
2404  * Outputs:     None.
2405  * Return:      0 if successful
2406  *              -EFAULT if data unavailable
2407  *              -EBUSY  if previous command timeout and IOC reset is not complete.
2408  *              -ENODEV if no such device/adapter
2409  *              -ETIME  if timer expires
2410  *              -ENOMEM if memory allocation error
2411  */
2412 static int
2413 mptctl_hp_hostinfo(unsigned long arg, unsigned int data_size)
2414 {
2415         hp_host_info_t  __user *uarg = (void __user *) arg;
2416         MPT_ADAPTER             *ioc;
2417         struct pci_dev          *pdev;
2418         char                    *pbuf=NULL;
2419         dma_addr_t              buf_dma;
2420         hp_host_info_t          karg;
2421         CONFIGPARMS             cfg;
2422         ConfigPageHeader_t      hdr;
2423         int                     iocnum;
2424         int                     rc, cim_rev;
2425         ToolboxIstwiReadWriteRequest_t  *IstwiRWRequest;
2426         MPT_FRAME_HDR           *mf = NULL;
2427         MPIHeader_t             *mpi_hdr;
2428         unsigned long           timeleft;
2429         int                     retval;
2430
2431         /* Reset long to int. Should affect IA64 and SPARC only
2432          */
2433         if (data_size == sizeof(hp_host_info_t))
2434                 cim_rev = 1;
2435         else if (data_size == sizeof(hp_host_info_rev0_t))
2436                 cim_rev = 0;    /* obsolete */
2437         else
2438                 return -EFAULT;
2439
2440         if (copy_from_user(&karg, uarg, sizeof(hp_host_info_t))) {
2441                 printk(KERN_ERR MYNAM "%s@%d::mptctl_hp_host_info - "
2442                         "Unable to read in hp_host_info struct @ %p\n",
2443                                 __FILE__, __LINE__, uarg);
2444                 return -EFAULT;
2445         }
2446
2447         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2448             (ioc == NULL)) {
2449                 printk(KERN_DEBUG MYNAM "%s::mptctl_hp_hostinfo() @%d - ioc%d not found!\n",
2450                                 __FILE__, __LINE__, iocnum);
2451                 return -ENODEV;
2452         }
2453         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": mptctl_hp_hostinfo called.\n",
2454             ioc->name));
2455
2456         /* Fill in the data and return the structure to the calling
2457          * program
2458          */
2459         pdev = (struct pci_dev *) ioc->pcidev;
2460
2461         karg.vendor = pdev->vendor;
2462         karg.device = pdev->device;
2463         karg.subsystem_id = pdev->subsystem_device;
2464         karg.subsystem_vendor = pdev->subsystem_vendor;
2465         karg.devfn = pdev->devfn;
2466         karg.bus = pdev->bus->number;
2467
2468         /* Save the SCSI host no. if
2469          * SCSI driver loaded
2470          */
2471         if (ioc->sh != NULL)
2472                 karg.host_no = ioc->sh->host_no;
2473         else
2474                 karg.host_no =  -1;
2475
2476         /* Reformat the fw_version into a string
2477          */
2478         karg.fw_version[0] = ioc->facts.FWVersion.Struct.Major >= 10 ?
2479                 ((ioc->facts.FWVersion.Struct.Major / 10) + '0') : '0';
2480         karg.fw_version[1] = (ioc->facts.FWVersion.Struct.Major % 10 ) + '0';
2481         karg.fw_version[2] = '.';
2482         karg.fw_version[3] = ioc->facts.FWVersion.Struct.Minor >= 10 ?
2483                 ((ioc->facts.FWVersion.Struct.Minor / 10) + '0') : '0';
2484         karg.fw_version[4] = (ioc->facts.FWVersion.Struct.Minor % 10 ) + '0';
2485         karg.fw_version[5] = '.';
2486         karg.fw_version[6] = ioc->facts.FWVersion.Struct.Unit >= 10 ?
2487                 ((ioc->facts.FWVersion.Struct.Unit / 10) + '0') : '0';
2488         karg.fw_version[7] = (ioc->facts.FWVersion.Struct.Unit % 10 ) + '0';
2489         karg.fw_version[8] = '.';
2490         karg.fw_version[9] = ioc->facts.FWVersion.Struct.Dev >= 10 ?
2491                 ((ioc->facts.FWVersion.Struct.Dev / 10) + '0') : '0';
2492         karg.fw_version[10] = (ioc->facts.FWVersion.Struct.Dev % 10 ) + '0';
2493         karg.fw_version[11] = '\0';
2494
2495         /* Issue a config request to get the device serial number
2496          */
2497         hdr.PageVersion = 0;
2498         hdr.PageLength = 0;
2499         hdr.PageNumber = 0;
2500         hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
2501         cfg.cfghdr.hdr = &hdr;
2502         cfg.physAddr = -1;
2503         cfg.pageAddr = 0;
2504         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2505         cfg.dir = 0;    /* read */
2506         cfg.timeout = 10;
2507
2508         strncpy(karg.serial_number, " ", 24);
2509         if (mpt_config(ioc, &cfg) == 0) {
2510                 if (cfg.cfghdr.hdr->PageLength > 0) {
2511                         /* Issue the second config page request */
2512                         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2513
2514                         pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
2515                         if (pbuf) {
2516                                 cfg.physAddr = buf_dma;
2517                                 if (mpt_config(ioc, &cfg) == 0) {
2518                                         ManufacturingPage0_t *pdata = (ManufacturingPage0_t *) pbuf;
2519                                         if (strlen(pdata->BoardTracerNumber) > 1) {
2520                                                 strncpy(karg.serial_number,                                                                         pdata->BoardTracerNumber, 24);
2521                                                 karg.serial_number[24-1]='\0';
2522                                         }
2523                                 }
2524                                 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
2525                                 pbuf = NULL;
2526                         }
2527                 }
2528         }
2529         rc = mpt_GetIocState(ioc, 1);
2530         switch (rc) {
2531         case MPI_IOC_STATE_OPERATIONAL:
2532                 karg.ioc_status =  HP_STATUS_OK;
2533                 break;
2534
2535         case MPI_IOC_STATE_FAULT:
2536                 karg.ioc_status =  HP_STATUS_FAILED;
2537                 break;
2538
2539         case MPI_IOC_STATE_RESET:
2540         case MPI_IOC_STATE_READY:
2541         default:
2542                 karg.ioc_status =  HP_STATUS_OTHER;
2543                 break;
2544         }
2545
2546         karg.base_io_addr = pci_resource_start(pdev, 0);
2547
2548         if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
2549                 karg.bus_phys_width = HP_BUS_WIDTH_UNK;
2550         else
2551                 karg.bus_phys_width = HP_BUS_WIDTH_16;
2552
2553         karg.hard_resets = 0;
2554         karg.soft_resets = 0;
2555         karg.timeouts = 0;
2556         if (ioc->sh != NULL) {
2557                 MPT_SCSI_HOST *hd =  shost_priv(ioc->sh);
2558
2559                 if (hd && (cim_rev == 1)) {
2560                         karg.hard_resets = ioc->hard_resets;
2561                         karg.soft_resets = ioc->soft_resets;
2562                         karg.timeouts = ioc->timeouts;
2563                 }
2564         }
2565
2566         /*
2567          * Gather ISTWI(Industry Standard Two Wire Interface) Data
2568          */
2569         if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
2570                 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
2571                         "%s, no msg frames!!\n", ioc->name, __func__));
2572                 goto out;
2573         }
2574
2575         IstwiRWRequest = (ToolboxIstwiReadWriteRequest_t *)mf;
2576         mpi_hdr = (MPIHeader_t *) mf;
2577         memset(IstwiRWRequest,0,sizeof(ToolboxIstwiReadWriteRequest_t));
2578         IstwiRWRequest->Function = MPI_FUNCTION_TOOLBOX;
2579         IstwiRWRequest->Tool = MPI_TOOLBOX_ISTWI_READ_WRITE_TOOL;
2580         IstwiRWRequest->MsgContext = mpi_hdr->MsgContext;
2581         IstwiRWRequest->Flags = MPI_TB_ISTWI_FLAGS_READ;
2582         IstwiRWRequest->NumAddressBytes = 0x01;
2583         IstwiRWRequest->DataLength = cpu_to_le16(0x04);
2584         if (pdev->devfn & 1)
2585                 IstwiRWRequest->DeviceAddr = 0xB2;
2586         else
2587                 IstwiRWRequest->DeviceAddr = 0xB0;
2588
2589         pbuf = pci_alloc_consistent(ioc->pcidev, 4, &buf_dma);
2590         if (!pbuf)
2591                 goto out;
2592         ioc->add_sge((char *)&IstwiRWRequest->SGL,
2593             (MPT_SGE_FLAGS_SSIMPLE_READ|4), buf_dma);
2594
2595         retval = 0;
2596         SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context,
2597                                 IstwiRWRequest->MsgContext);
2598         INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
2599         mpt_put_msg_frame(mptctl_id, ioc, mf);
2600
2601 retry_wait:
2602         timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
2603                         HZ*MPT_IOCTL_DEFAULT_TIMEOUT);
2604         if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2605                 retval = -ETIME;
2606                 printk(MYIOC_s_WARN_FMT "%s: failed\n", ioc->name, __func__);
2607                 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2608                         mpt_free_msg_frame(ioc, mf);
2609                         goto out;
2610                 }
2611                 if (!timeleft)
2612                         mptctl_timeout_expired(ioc, mf);
2613                 else
2614                         goto retry_wait;
2615                 goto out;
2616         }
2617
2618         /*
2619          *ISTWI Data Definition
2620          * pbuf[0] = FW_VERSION = 0x4
2621          * pbuf[1] = Bay Count = 6 or 4 or 2, depending on
2622          *  the config, you should be seeing one out of these three values
2623          * pbuf[2] = Drive Installed Map = bit pattern depend on which
2624          *   bays have drives in them
2625          * pbuf[3] = Checksum (0x100 = (byte0 + byte2 + byte3)
2626          */
2627         if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID)
2628                 karg.rsvd = *(u32 *)pbuf;
2629
2630  out:
2631         CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
2632         SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
2633
2634         if (pbuf)
2635                 pci_free_consistent(ioc->pcidev, 4, pbuf, buf_dma);
2636
2637         /* Copy the data from kernel memory to user memory
2638          */
2639         if (copy_to_user((char __user *)arg, &karg, sizeof(hp_host_info_t))) {
2640                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_hpgethostinfo - "
2641                         "Unable to write out hp_host_info @ %p\n",
2642                         ioc->name, __FILE__, __LINE__, uarg);
2643                 return -EFAULT;
2644         }
2645
2646         return 0;
2647
2648 }
2649
2650 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2651 /* Prototype Routine for the TARGET INFO command.
2652  *
2653  * Outputs:     None.
2654  * Return:      0 if successful
2655  *              -EFAULT if data unavailable
2656  *              -EBUSY  if previous command timeout and IOC reset is not complete.
2657  *              -ENODEV if no such device/adapter
2658  *              -ETIME  if timer expires
2659  *              -ENOMEM if memory allocation error
2660  */
2661 static int
2662 mptctl_hp_targetinfo(unsigned long arg)
2663 {
2664         hp_target_info_t __user *uarg = (void __user *) arg;
2665         SCSIDevicePage0_t       *pg0_alloc;
2666         SCSIDevicePage3_t       *pg3_alloc;
2667         MPT_ADAPTER             *ioc;
2668         MPT_SCSI_HOST           *hd = NULL;
2669         hp_target_info_t        karg;
2670         int                     iocnum;
2671         int                     data_sz;
2672         dma_addr_t              page_dma;
2673         CONFIGPARMS             cfg;
2674         ConfigPageHeader_t      hdr;
2675         int                     tmp, np, rc = 0;
2676
2677         if (copy_from_user(&karg, uarg, sizeof(hp_target_info_t))) {
2678                 printk(KERN_ERR MYNAM "%s@%d::mptctl_hp_targetinfo - "
2679                         "Unable to read in hp_host_targetinfo struct @ %p\n",
2680                                 __FILE__, __LINE__, uarg);
2681                 return -EFAULT;
2682         }
2683
2684         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2685                 (ioc == NULL)) {
2686                 printk(KERN_DEBUG MYNAM "%s::mptctl_hp_targetinfo() @%d - ioc%d not found!\n",
2687                                 __FILE__, __LINE__, iocnum);
2688                 return -ENODEV;
2689         }
2690         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_hp_targetinfo called.\n",
2691             ioc->name));
2692
2693         /*  There is nothing to do for FCP parts.
2694          */
2695         if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
2696                 return 0;
2697
2698         if ((ioc->spi_data.sdp0length == 0) || (ioc->sh == NULL))
2699                 return 0;
2700
2701         if (ioc->sh->host_no != karg.hdr.host)
2702                 return -ENODEV;
2703
2704        /* Get the data transfer speeds
2705         */
2706         data_sz = ioc->spi_data.sdp0length * 4;
2707         pg0_alloc = (SCSIDevicePage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
2708         if (pg0_alloc) {
2709                 hdr.PageVersion = ioc->spi_data.sdp0version;
2710                 hdr.PageLength = data_sz;
2711                 hdr.PageNumber = 0;
2712                 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2713
2714                 cfg.cfghdr.hdr = &hdr;
2715                 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2716                 cfg.dir = 0;
2717                 cfg.timeout = 0;
2718                 cfg.physAddr = page_dma;
2719
2720                 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2721
2722                 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2723                         np = le32_to_cpu(pg0_alloc->NegotiatedParameters);
2724                         karg.negotiated_width = np & MPI_SCSIDEVPAGE0_NP_WIDE ?
2725                                         HP_BUS_WIDTH_16 : HP_BUS_WIDTH_8;
2726
2727                         if (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) {
2728                                 tmp = (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> 8;
2729                                 if (tmp < 0x09)
2730                                         karg.negotiated_speed = HP_DEV_SPEED_ULTRA320;
2731                                 else if (tmp <= 0x09)
2732                                         karg.negotiated_speed = HP_DEV_SPEED_ULTRA160;
2733                                 else if (tmp <= 0x0A)
2734                                         karg.negotiated_speed = HP_DEV_SPEED_ULTRA2;
2735                                 else if (tmp <= 0x0C)
2736                                         karg.negotiated_speed = HP_DEV_SPEED_ULTRA;
2737                                 else if (tmp <= 0x25)
2738                                         karg.negotiated_speed = HP_DEV_SPEED_FAST;
2739                                 else
2740                                         karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2741                         } else
2742                                 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2743                 }
2744
2745                 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg0_alloc, page_dma);
2746         }
2747
2748         /* Set defaults
2749          */
2750         karg.message_rejects = -1;
2751         karg.phase_errors = -1;
2752         karg.parity_errors = -1;
2753         karg.select_timeouts = -1;
2754
2755         /* Get the target error parameters
2756          */
2757         hdr.PageVersion = 0;
2758         hdr.PageLength = 0;
2759         hdr.PageNumber = 3;
2760         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2761
2762         cfg.cfghdr.hdr = &hdr;
2763         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2764         cfg.dir = 0;
2765         cfg.timeout = 0;
2766         cfg.physAddr = -1;
2767         if ((mpt_config(ioc, &cfg) == 0) && (cfg.cfghdr.hdr->PageLength > 0)) {
2768                 /* Issue the second config page request */
2769                 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2770                 data_sz = (int) cfg.cfghdr.hdr->PageLength * 4;
2771                 pg3_alloc = (SCSIDevicePage3_t *) pci_alloc_consistent(
2772                                                         ioc->pcidev, data_sz, &page_dma);
2773                 if (pg3_alloc) {
2774                         cfg.physAddr = page_dma;
2775                         cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2776                         if ((rc = mpt_config(ioc, &cfg)) == 0) {
2777                                 karg.message_rejects = (u32) le16_to_cpu(pg3_alloc->MsgRejectCount);
2778                                 karg.phase_errors = (u32) le16_to_cpu(pg3_alloc->PhaseErrorCount);
2779                                 karg.parity_errors = (u32) le16_to_cpu(pg3_alloc->ParityErrorCount);
2780                         }
2781                         pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg3_alloc, page_dma);
2782                 }
2783         }
2784         hd = shost_priv(ioc->sh);
2785         if (hd != NULL)
2786                 karg.select_timeouts = hd->sel_timeout[karg.hdr.id];
2787
2788         /* Copy the data from kernel memory to user memory
2789          */
2790         if (copy_to_user((char __user *)arg, &karg, sizeof(hp_target_info_t))) {
2791                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_hp_target_info - "
2792                         "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
2793                         ioc->name, __FILE__, __LINE__, uarg);
2794                 return -EFAULT;
2795         }
2796
2797         return 0;
2798 }
2799
2800 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2801
2802 static const struct file_operations mptctl_fops = {
2803         .owner =        THIS_MODULE,
2804         .llseek =       no_llseek,
2805         .fasync =       mptctl_fasync,
2806         .unlocked_ioctl = mptctl_ioctl,
2807 #ifdef CONFIG_COMPAT
2808         .compat_ioctl = compat_mpctl_ioctl,
2809 #endif
2810 };
2811
2812 static struct miscdevice mptctl_miscdev = {
2813         MPT_MINOR,
2814         MYNAM,
2815         &mptctl_fops
2816 };
2817
2818 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2819
2820 #ifdef CONFIG_COMPAT
2821
2822 static int
2823 compat_mptfwxfer_ioctl(struct file *filp, unsigned int cmd,
2824                         unsigned long arg)
2825 {
2826         struct mpt_fw_xfer32 kfw32;
2827         struct mpt_fw_xfer kfw;
2828         MPT_ADAPTER *iocp = NULL;
2829         int iocnum, iocnumX;
2830         int nonblock = (filp->f_flags & O_NONBLOCK);
2831         int ret;
2832
2833
2834         if (copy_from_user(&kfw32, (char __user *)arg, sizeof(kfw32)))
2835                 return -EFAULT;
2836
2837         /* Verify intended MPT adapter */
2838         iocnumX = kfw32.iocnum & 0xFF;
2839         if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2840             (iocp == NULL)) {
2841                 printk(KERN_DEBUG MYNAM "::compat_mptfwxfer_ioctl @%d - ioc%d not found!\n",
2842                         __LINE__, iocnumX);
2843                 return -ENODEV;
2844         }
2845
2846         if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2847                 return ret;
2848
2849         dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "compat_mptfwxfer_ioctl() called\n",
2850             iocp->name));
2851         kfw.iocnum = iocnum;
2852         kfw.fwlen = kfw32.fwlen;
2853         kfw.bufp = compat_ptr(kfw32.bufp);
2854
2855         ret = mptctl_do_fw_download(kfw.iocnum, kfw.bufp, kfw.fwlen);
2856
2857         mutex_unlock(&iocp->ioctl_cmds.mutex);
2858
2859         return ret;
2860 }
2861
2862 static int
2863 compat_mpt_command(struct file *filp, unsigned int cmd,
2864                         unsigned long arg)
2865 {
2866         struct mpt_ioctl_command32 karg32;
2867         struct mpt_ioctl_command32 __user *uarg = (struct mpt_ioctl_command32 __user *) arg;
2868         struct mpt_ioctl_command karg;
2869         MPT_ADAPTER *iocp = NULL;
2870         int iocnum, iocnumX;
2871         int nonblock = (filp->f_flags & O_NONBLOCK);
2872         int ret;
2873
2874         if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32)))
2875                 return -EFAULT;
2876
2877         /* Verify intended MPT adapter */
2878         iocnumX = karg32.hdr.iocnum & 0xFF;
2879         if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2880             (iocp == NULL)) {
2881                 printk(KERN_DEBUG MYNAM "::compat_mpt_command @%d - ioc%d not found!\n",
2882                         __LINE__, iocnumX);
2883                 return -ENODEV;
2884         }
2885
2886         if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2887                 return ret;
2888
2889         dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "compat_mpt_command() called\n",
2890             iocp->name));
2891         /* Copy data to karg */
2892         karg.hdr.iocnum = karg32.hdr.iocnum;
2893         karg.hdr.port = karg32.hdr.port;
2894         karg.timeout = karg32.timeout;
2895         karg.maxReplyBytes = karg32.maxReplyBytes;
2896
2897         karg.dataInSize = karg32.dataInSize;
2898         karg.dataOutSize = karg32.dataOutSize;
2899         karg.maxSenseBytes = karg32.maxSenseBytes;
2900         karg.dataSgeOffset = karg32.dataSgeOffset;
2901
2902         karg.replyFrameBufPtr = (char __user *)(unsigned long)karg32.replyFrameBufPtr;
2903         karg.dataInBufPtr = (char __user *)(unsigned long)karg32.dataInBufPtr;
2904         karg.dataOutBufPtr = (char __user *)(unsigned long)karg32.dataOutBufPtr;
2905         karg.senseDataPtr = (char __user *)(unsigned long)karg32.senseDataPtr;
2906
2907         /* Pass new structure to do_mpt_command
2908          */
2909         ret = mptctl_do_mpt_command (karg, &uarg->MF);
2910
2911         mutex_unlock(&iocp->ioctl_cmds.mutex);
2912
2913         return ret;
2914 }
2915
2916 static long compat_mpctl_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
2917 {
2918         long ret;
2919         lock_kernel();
2920         switch (cmd) {
2921         case MPTIOCINFO:
2922         case MPTIOCINFO1:
2923         case MPTIOCINFO2:
2924         case MPTTARGETINFO:
2925         case MPTEVENTQUERY:
2926         case MPTEVENTENABLE:
2927         case MPTEVENTREPORT:
2928         case MPTHARDRESET:
2929         case HP_GETHOSTINFO:
2930         case HP_GETTARGETINFO:
2931         case MPTTEST:
2932                 ret = __mptctl_ioctl(f, cmd, arg);
2933                 break;
2934         case MPTCOMMAND32:
2935                 ret = compat_mpt_command(f, cmd, arg);
2936                 break;
2937         case MPTFWDOWNLOAD32:
2938                 ret = compat_mptfwxfer_ioctl(f, cmd, arg);
2939                 break;
2940         default:
2941                 ret = -ENOIOCTLCMD;
2942                 break;
2943         }
2944         unlock_kernel();
2945         return ret;
2946 }
2947
2948 #endif
2949
2950
2951 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2952 /*
2953  *      mptctl_probe - Installs ioctl devices per bus.
2954  *      @pdev: Pointer to pci_dev structure
2955  *
2956  *      Returns 0 for success, non-zero for failure.
2957  *
2958  */
2959
2960 static int
2961 mptctl_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2962 {
2963         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
2964
2965         mutex_init(&ioc->ioctl_cmds.mutex);
2966         init_completion(&ioc->ioctl_cmds.done);
2967         return 0;
2968 }
2969
2970 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2971 /*
2972  *      mptctl_remove - Removed ioctl devices
2973  *      @pdev: Pointer to pci_dev structure
2974  *
2975  *
2976  */
2977 static void
2978 mptctl_remove(struct pci_dev *pdev)
2979 {
2980 }
2981
2982 static struct mpt_pci_driver mptctl_driver = {
2983   .probe                = mptctl_probe,
2984   .remove               = mptctl_remove,
2985 };
2986
2987 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2988 static int __init mptctl_init(void)
2989 {
2990         int err;
2991         int where = 1;
2992
2993         show_mptmod_ver(my_NAME, my_VERSION);
2994
2995         mpt_device_driver_register(&mptctl_driver, MPTCTL_DRIVER);
2996
2997         /* Register this device */
2998         err = misc_register(&mptctl_miscdev);
2999         if (err < 0) {
3000                 printk(KERN_ERR MYNAM ": Can't register misc device [minor=%d].\n", MPT_MINOR);
3001                 goto out_fail;
3002         }
3003         printk(KERN_INFO MYNAM ": Registered with Fusion MPT base driver\n");
3004         printk(KERN_INFO MYNAM ": /dev/%s @ (major,minor=%d,%d)\n",
3005                          mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
3006
3007         /*
3008          *  Install our handler
3009          */
3010         ++where;
3011         mptctl_id = mpt_register(mptctl_reply, MPTCTL_DRIVER);
3012         if (!mptctl_id || mptctl_id >= MPT_MAX_PROTOCOL_DRIVERS) {
3013                 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
3014                 misc_deregister(&mptctl_miscdev);
3015                 err = -EBUSY;
3016                 goto out_fail;
3017         }
3018
3019         mptctl_taskmgmt_id = mpt_register(mptctl_taskmgmt_reply, MPTCTL_DRIVER);
3020         if (!mptctl_taskmgmt_id || mptctl_taskmgmt_id >= MPT_MAX_PROTOCOL_DRIVERS) {
3021                 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
3022                 mpt_deregister(mptctl_id);
3023                 misc_deregister(&mptctl_miscdev);
3024                 err = -EBUSY;
3025                 goto out_fail;
3026         }
3027
3028         mpt_reset_register(mptctl_id, mptctl_ioc_reset);
3029         mpt_event_register(mptctl_id, mptctl_event_process);
3030
3031         return 0;
3032
3033 out_fail:
3034
3035         mpt_device_driver_deregister(MPTCTL_DRIVER);
3036
3037         return err;
3038 }
3039
3040 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3041 static void mptctl_exit(void)
3042 {
3043         misc_deregister(&mptctl_miscdev);
3044         printk(KERN_INFO MYNAM ": Deregistered /dev/%s @ (major,minor=%d,%d)\n",
3045                          mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
3046
3047         /* De-register event handler from base module */
3048         mpt_event_deregister(mptctl_id);
3049
3050         /* De-register reset handler from base module */
3051         mpt_reset_deregister(mptctl_id);
3052
3053         /* De-register callback handler from base module */
3054         mpt_deregister(mptctl_taskmgmt_id);
3055         mpt_deregister(mptctl_id);
3056
3057         mpt_device_driver_deregister(MPTCTL_DRIVER);
3058
3059 }
3060
3061 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3062
3063 module_init(mptctl_init);
3064 module_exit(mptctl_exit);