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                         printk(MYIOC_s_WARN_FMT
 959                                "FW download timeout, doorbell=0x%08x\n",
 960                                iocp->name, mpt_GetIocState(iocp, 0));
 961                         mptctl_timeout_expired(iocp, mf);
 962                 } else
 963                         goto retry_wait;
 964                 goto fwdl_out;
 965         }
 966
 967         if (!(iocp->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
 968                 printk(MYIOC_s_WARN_FMT "%s: failed\n", iocp->name, __func__);
 969                 mpt_free_msg_frame(iocp, mf);
 970                 ret = -ENODATA;
 971                 goto fwdl_out;
 972         }
 973
 974         if (sgl)
 975                 kfree_sgl(sgl, sgl_dma, buflist, iocp);
 976
 977         ReplyMsg = (pFWDownloadReply_t)iocp->ioctl_cmds.reply;
 978         iocstat = le16_to_cpu(ReplyMsg->IOCStatus) & MPI_IOCSTATUS_MASK;
 979         if (iocstat == MPI_IOCSTATUS_SUCCESS) {
 980                 printk(MYIOC_s_INFO_FMT "F/W update successfull!\n", iocp->name);
 981                 return 0;
 982         } else if (iocstat == MPI_IOCSTATUS_INVALID_FUNCTION) {
 983                 printk(MYIOC_s_WARN_FMT "Hmmm...  F/W download not supported!?!\n",
 984                         iocp->name);
 985                 printk(MYIOC_s_WARN_FMT "(time to go bang on somebodies door)\n",
 986                         iocp->name);
 987                 return -EBADRQC;
 988         } else if (iocstat == MPI_IOCSTATUS_BUSY) {
 989                 printk(MYIOC_s_WARN_FMT "IOC_BUSY!\n", iocp->name);
 990                 printk(MYIOC_s_WARN_FMT "(try again later?)\n", iocp->name);
 991                 return -EBUSY;
 992         } else {
 993                 printk(MYIOC_s_WARN_FMT "ioctl_fwdl() returned [bad] status = %04xh\n",
 994                         iocp->name, iocstat);
 995                 printk(MYIOC_s_WARN_FMT "(bad VooDoo)\n", iocp->name);
 996                 return -ENOMSG;
 997         }
 998         return 0;
 999
1000 fwdl_out:
1001
1002         CLEAR_MGMT_STATUS(iocp->ioctl_cmds.status);
1003         SET_MGMT_MSG_CONTEXT(iocp->ioctl_cmds.msg_context, 0);
1004         kfree_sgl(sgl, sgl_dma, buflist, iocp);
1005         return ret;
1006 }
1007
1008 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1009 /*
1010  * SGE Allocation routine
1011  *
1012  * Inputs:      bytes - number of bytes to be transferred
1013  *              sgdir - data direction
1014  *              sge_offset - offset (in bytes) from the start of the request
1015  *                      frame to the first SGE
1016  *              ioc - pointer to the mptadapter
1017  * Outputs:     frags - number of scatter gather elements
1018  *              blp - point to the buflist pointer
1019  *              sglbuf_dma - pointer to the (dma) sgl
1020  * Returns:     Null if failes
1021  *              pointer to the (virtual) sgl if successful.
1022  */
1023 static MptSge_t *
1024 kbuf_alloc_2_sgl(int bytes, u32 sgdir, int sge_offset, int *frags,
1025                  struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc)
1026 {
1027         MptSge_t        *sglbuf = NULL;         /* pointer to array of SGE */
1028                                                 /* and chain buffers */
1029         struct buflist  *buflist = NULL;        /* kernel routine */
1030         MptSge_t        *sgl;
1031         int              numfrags = 0;
1032         int              fragcnt = 0;
1033         int              alloc_sz = min(bytes,MAX_KMALLOC_SZ);  // avoid kernel warning msg!
1034         int              bytes_allocd = 0;
1035         int              this_alloc;
1036         dma_addr_t       pa;                                    // phys addr
1037         int              i, buflist_ent;
1038         int              sg_spill = MAX_FRAGS_SPILL1;
1039         int              dir;
1040         /* initialization */
1041         *frags = 0;
1042         *blp = NULL;
1043
1044         /* Allocate and initialize an array of kernel
1045          * structures for the SG elements.
1046          */
1047         i = MAX_SGL_BYTES / 8;
1048         buflist = kzalloc(i, GFP_USER);
1049         if (!buflist)
1050                 return NULL;
1051         buflist_ent = 0;
1052
1053         /* Allocate a single block of memory to store the sg elements and
1054          * the chain buffers.  The calling routine is responsible for
1055          * copying the data in this array into the correct place in the
1056          * request and chain buffers.
1057          */
1058         sglbuf = pci_alloc_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf_dma);
1059         if (sglbuf == NULL)
1060                 goto free_and_fail;
1061
1062         if (sgdir & 0x04000000)
1063                 dir = PCI_DMA_TODEVICE;
1064         else
1065                 dir = PCI_DMA_FROMDEVICE;
1066
1067         /* At start:
1068          *      sgl = sglbuf = point to beginning of sg buffer
1069          *      buflist_ent = 0 = first kernel structure
1070          *      sg_spill = number of SGE that can be written before the first
1071          *              chain element.
1072          *
1073          */
1074         sgl = sglbuf;
1075         sg_spill = ((ioc->req_sz - sge_offset)/ioc->SGE_size) - 1;
1076         while (bytes_allocd < bytes) {
1077                 this_alloc = min(alloc_sz, bytes-bytes_allocd);
1078                 buflist[buflist_ent].len = this_alloc;
1079                 buflist[buflist_ent].kptr = pci_alloc_consistent(ioc->pcidev,
1080                                                                  this_alloc,
1081                                                                  &pa);
1082                 if (buflist[buflist_ent].kptr == NULL) {
1083                         alloc_sz = alloc_sz / 2;
1084                         if (alloc_sz == 0) {
1085                                 printk(MYIOC_s_WARN_FMT "-SG: No can do - "
1086                                     "not enough memory!   :-(\n", ioc->name);
1087                                 printk(MYIOC_s_WARN_FMT "-SG: (freeing %d frags)\n",
1088                                         ioc->name, numfrags);
1089                                 goto free_and_fail;
1090                         }
1091                         continue;
1092                 } else {
1093                         dma_addr_t dma_addr;
1094
1095                         bytes_allocd += this_alloc;
1096                         sgl->FlagsLength = (0x10000000|sgdir|this_alloc);
1097                         dma_addr = pci_map_single(ioc->pcidev,
1098                                 buflist[buflist_ent].kptr, this_alloc, dir);
1099                         sgl->Address = dma_addr;
1100
1101                         fragcnt++;
1102                         numfrags++;
1103                         sgl++;
1104                         buflist_ent++;
1105                 }
1106
1107                 if (bytes_allocd >= bytes)
1108                         break;
1109
1110                 /* Need to chain? */
1111                 if (fragcnt == sg_spill) {
1112                         printk(MYIOC_s_WARN_FMT
1113                             "-SG: No can do - " "Chain required!   :-(\n", ioc->name);
1114                         printk(MYIOC_s_WARN_FMT "(freeing %d frags)\n", ioc->name, numfrags);
1115                         goto free_and_fail;
1116                 }
1117
1118                 /* overflow check... */
1119                 if (numfrags*8 > MAX_SGL_BYTES){
1120                         /* GRRRRR... */
1121                         printk(MYIOC_s_WARN_FMT "-SG: No can do - "
1122                                 "too many SG frags!   :-(\n", ioc->name);
1123                         printk(MYIOC_s_WARN_FMT "-SG: (freeing %d frags)\n",
1124                                 ioc->name, numfrags);
1125                         goto free_and_fail;
1126                 }
1127         }
1128
1129         /* Last sge fixup: set LE+eol+eob bits */
1130         sgl[-1].FlagsLength |= 0xC1000000;
1131
1132         *frags = numfrags;
1133         *blp = buflist;
1134
1135         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: kbuf_alloc_2_sgl() - "
1136            "%d SG frags generated!\n", ioc->name, numfrags));
1137
1138         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: kbuf_alloc_2_sgl() - "
1139            "last (big) alloc_sz=%d\n", ioc->name, alloc_sz));
1140
1141         return sglbuf;
1142
1143 free_and_fail:
1144         if (sglbuf != NULL) {
1145                 for (i = 0; i < numfrags; i++) {
1146                         dma_addr_t dma_addr;
1147                         u8 *kptr;
1148                         int len;
1149
1150                         if ((sglbuf[i].FlagsLength >> 24) == 0x30)
1151                                 continue;
1152
1153                         dma_addr = sglbuf[i].Address;
1154                         kptr = buflist[i].kptr;
1155                         len = buflist[i].len;
1156
1157                         pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1158                 }
1159                 pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf, *sglbuf_dma);
1160         }
1161         kfree(buflist);
1162         return NULL;
1163 }
1164
1165 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1166 /*
1167  * Routine to free the SGL elements.
1168  */
1169 static void
1170 kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma, struct buflist *buflist, MPT_ADAPTER *ioc)
1171 {
1172         MptSge_t        *sg = sgl;
1173         struct buflist  *bl = buflist;
1174         u32              nib;
1175         int              dir;
1176         int              n = 0;
1177
1178         if (sg->FlagsLength & 0x04000000)
1179                 dir = PCI_DMA_TODEVICE;
1180         else
1181                 dir = PCI_DMA_FROMDEVICE;
1182
1183         nib = (sg->FlagsLength & 0xF0000000) >> 28;
1184         while (! (nib & 0x4)) { /* eob */
1185                 /* skip ignore/chain. */
1186                 if (nib == 0 || nib == 3) {
1187                         ;
1188                 } else if (sg->Address) {
1189                         dma_addr_t dma_addr;
1190                         void *kptr;
1191                         int len;
1192
1193                         dma_addr = sg->Address;
1194                         kptr = bl->kptr;
1195                         len = bl->len;
1196                         pci_unmap_single(ioc->pcidev, dma_addr, len, dir);
1197                         pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1198                         n++;
1199                 }
1200                 sg++;
1201                 bl++;
1202                 nib = (le32_to_cpu(sg->FlagsLength) & 0xF0000000) >> 28;
1203         }
1204
1205         /* we're at eob! */
1206         if (sg->Address) {
1207                 dma_addr_t dma_addr;
1208                 void *kptr;
1209                 int len;
1210
1211                 dma_addr = sg->Address;
1212                 kptr = bl->kptr;
1213                 len = bl->len;
1214                 pci_unmap_single(ioc->pcidev, dma_addr, len, dir);
1215                 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1216                 n++;
1217         }
1218
1219         pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sgl, sgl_dma);
1220         kfree(buflist);
1221         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: Free'd 1 SGL buf + %d kbufs!\n",
1222             ioc->name, n));
1223 }
1224
1225 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1226 /*
1227  *      mptctl_getiocinfo - Query the host adapter for IOC information.
1228  *      @arg: User space argument
1229  *
1230  * Outputs:     None.
1231  * Return:      0 if successful
1232  *              -EFAULT if data unavailable
1233  *              -ENODEV  if no such device/adapter
1234  */
1235 static int
1236 mptctl_getiocinfo (unsigned long arg, unsigned int data_size)
1237 {
1238         struct mpt_ioctl_iocinfo __user *uarg = (void __user *) arg;
1239         struct mpt_ioctl_iocinfo *karg;
1240         MPT_ADAPTER             *ioc;
1241         struct pci_dev          *pdev;
1242         int                     iocnum;
1243         unsigned int            port;
1244         int                     cim_rev;
1245         u8                      revision;
1246         struct scsi_device      *sdev;
1247         VirtDevice              *vdevice;
1248
1249         /* Add of PCI INFO results in unaligned access for
1250          * IA64 and Sparc. Reset long to int. Return no PCI
1251          * data for obsolete format.
1252          */
1253         if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev0))
1254                 cim_rev = 0;
1255         else if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev1))
1256                 cim_rev = 1;
1257         else if (data_size == sizeof(struct mpt_ioctl_iocinfo))
1258                 cim_rev = 2;
1259         else if (data_size == (sizeof(struct mpt_ioctl_iocinfo_rev0)+12))
1260                 cim_rev = 0;    /* obsolete */
1261         else
1262                 return -EFAULT;
1263
1264         karg = kmalloc(data_size, GFP_KERNEL);
1265         if (karg == NULL) {
1266                 printk(KERN_ERR MYNAM "%s::mpt_ioctl_iocinfo() @%d - no memory available!\n",
1267                                 __FILE__, __LINE__);
1268                 return -ENOMEM;
1269         }
1270
1271         if (copy_from_user(karg, uarg, data_size)) {
1272                 printk(KERN_ERR MYNAM "%s@%d::mptctl_getiocinfo - "
1273                         "Unable to read in mpt_ioctl_iocinfo struct @ %p\n",
1274                                 __FILE__, __LINE__, uarg);
1275                 kfree(karg);
1276                 return -EFAULT;
1277         }
1278
1279         if (((iocnum = mpt_verify_adapter(karg->hdr.iocnum, &ioc)) < 0) ||
1280             (ioc == NULL)) {
1281                 printk(KERN_DEBUG MYNAM "%s::mptctl_getiocinfo() @%d - ioc%d not found!\n",
1282                                 __FILE__, __LINE__, iocnum);
1283                 kfree(karg);
1284                 return -ENODEV;
1285         }
1286
1287         /* Verify the data transfer size is correct. */
1288         if (karg->hdr.maxDataSize != data_size) {
1289                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_getiocinfo - "
1290                         "Structure size mismatch. Command not completed.\n",
1291                         ioc->name, __FILE__, __LINE__);
1292                 kfree(karg);
1293                 return -EFAULT;
1294         }
1295
1296         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_getiocinfo called.\n",
1297             ioc->name));
1298
1299         /* Fill in the data and return the structure to the calling
1300          * program
1301          */
1302         if (ioc->bus_type == SAS)
1303                 karg->adapterType = MPT_IOCTL_INTERFACE_SAS;
1304         else if (ioc->bus_type == FC)
1305                 karg->adapterType = MPT_IOCTL_INTERFACE_FC;
1306         else
1307                 karg->adapterType = MPT_IOCTL_INTERFACE_SCSI;
1308
1309         if (karg->hdr.port > 1)
1310                 return -EINVAL;
1311         port = karg->hdr.port;
1312
1313         karg->port = port;
1314         pdev = (struct pci_dev *) ioc->pcidev;
1315
1316         karg->pciId = pdev->device;
1317         pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1318         karg->hwRev = revision;
1319         karg->subSystemDevice = pdev->subsystem_device;
1320         karg->subSystemVendor = pdev->subsystem_vendor;
1321
1322         if (cim_rev == 1) {
1323                 /* Get the PCI bus, device, and function numbers for the IOC
1324                  */
1325                 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1326                 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1327                 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1328         } else if (cim_rev == 2) {
1329                 /* Get the PCI bus, device, function and segment ID numbers
1330                    for the IOC */
1331                 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1332                 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1333                 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1334                 karg->pciInfo.segmentID = pci_domain_nr(pdev->bus);
1335         }
1336
1337         /* Get number of devices
1338          */
1339         karg->numDevices = 0;
1340         if (ioc->sh) {
1341                 shost_for_each_device(sdev, ioc->sh) {
1342                         vdevice = sdev->hostdata;
1343                         if (vdevice == NULL || vdevice->vtarget == NULL)
1344                                 continue;
1345                         if (vdevice->vtarget->tflags &
1346                             MPT_TARGET_FLAGS_RAID_COMPONENT)
1347                                 continue;
1348                         karg->numDevices++;
1349                 }
1350         }
1351
1352         /* Set the BIOS and FW Version
1353          */
1354         karg->FWVersion = ioc->facts.FWVersion.Word;
1355         karg->BIOSVersion = ioc->biosVersion;
1356
1357         /* Set the Version Strings.
1358          */
1359         strncpy (karg->driverVersion, MPT_LINUX_PACKAGE_NAME, MPT_IOCTL_VERSION_LENGTH);
1360         karg->driverVersion[MPT_IOCTL_VERSION_LENGTH-1]='\0';
1361
1362         karg->busChangeEvent = 0;
1363         karg->hostId = ioc->pfacts[port].PortSCSIID;
1364         karg->rsvd[0] = karg->rsvd[1] = 0;
1365
1366         /* Copy the data from kernel memory to user memory
1367          */
1368         if (copy_to_user((char __user *)arg, karg, data_size)) {
1369                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_getiocinfo - "
1370                         "Unable to write out mpt_ioctl_iocinfo struct @ %p\n",
1371                         ioc->name, __FILE__, __LINE__, uarg);
1372                 kfree(karg);
1373                 return -EFAULT;
1374         }
1375
1376         kfree(karg);
1377         return 0;
1378 }
1379
1380 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1381 /*
1382  *      mptctl_gettargetinfo - Query the host adapter for target information.
1383  *      @arg: User space argument
1384  *
1385  * Outputs:     None.
1386  * Return:      0 if successful
1387  *              -EFAULT if data unavailable
1388  *              -ENODEV  if no such device/adapter
1389  */
1390 static int
1391 mptctl_gettargetinfo (unsigned long arg)
1392 {
1393         struct mpt_ioctl_targetinfo __user *uarg = (void __user *) arg;
1394         struct mpt_ioctl_targetinfo karg;
1395         MPT_ADAPTER             *ioc;
1396         VirtDevice              *vdevice;
1397         char                    *pmem;
1398         int                     *pdata;
1399         int                     iocnum;
1400         int                     numDevices = 0;
1401         int                     lun;
1402         int                     maxWordsLeft;
1403         int                     numBytes;
1404         u8                      port;
1405         struct scsi_device      *sdev;
1406
1407         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_targetinfo))) {
1408                 printk(KERN_ERR MYNAM "%s@%d::mptctl_gettargetinfo - "
1409                         "Unable to read in mpt_ioctl_targetinfo struct @ %p\n",
1410                                 __FILE__, __LINE__, uarg);
1411                 return -EFAULT;
1412         }
1413
1414         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1415             (ioc == NULL)) {
1416                 printk(KERN_DEBUG MYNAM "%s::mptctl_gettargetinfo() @%d - ioc%d not found!\n",
1417                                 __FILE__, __LINE__, iocnum);
1418                 return -ENODEV;
1419         }
1420
1421         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_gettargetinfo called.\n",
1422             ioc->name));
1423         /* Get the port number and set the maximum number of bytes
1424          * in the returned structure.
1425          * Ignore the port setting.
1426          */
1427         numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1428         maxWordsLeft = numBytes/sizeof(int);
1429         port = karg.hdr.port;
1430
1431         if (maxWordsLeft <= 0) {
1432                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo() - no memory available!\n",
1433                         ioc->name, __FILE__, __LINE__);
1434                 return -ENOMEM;
1435         }
1436
1437         /* Fill in the data and return the structure to the calling
1438          * program
1439          */
1440
1441         /* struct mpt_ioctl_targetinfo does not contain sufficient space
1442          * for the target structures so when the IOCTL is called, there is
1443          * not sufficient stack space for the structure. Allocate memory,
1444          * populate the memory, copy back to the user, then free memory.
1445          * targetInfo format:
1446          * bits 31-24: reserved
1447          *      23-16: LUN
1448          *      15- 8: Bus Number
1449          *       7- 0: Target ID
1450          */
1451         pmem = kzalloc(numBytes, GFP_KERNEL);
1452         if (!pmem) {
1453                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo() - no memory available!\n",
1454                         ioc->name, __FILE__, __LINE__);
1455                 return -ENOMEM;
1456         }
1457         pdata =  (int *) pmem;
1458
1459         /* Get number of devices
1460          */
1461         if (ioc->sh){
1462                 shost_for_each_device(sdev, ioc->sh) {
1463                         if (!maxWordsLeft)
1464                                 continue;
1465                         vdevice = sdev->hostdata;
1466                         if (vdevice == NULL || vdevice->vtarget == NULL)
1467                                 continue;
1468                         if (vdevice->vtarget->tflags &
1469                             MPT_TARGET_FLAGS_RAID_COMPONENT)
1470                                 continue;
1471                         lun = (vdevice->vtarget->raidVolume) ? 0x80 : vdevice->lun;
1472                         *pdata = (((u8)lun << 16) + (vdevice->vtarget->channel << 8) +
1473                             (vdevice->vtarget->id ));
1474                         pdata++;
1475                         numDevices++;
1476                         --maxWordsLeft;
1477                 }
1478         }
1479         karg.numDevices = numDevices;
1480
1481         /* Copy part of the data from kernel memory to user memory
1482          */
1483         if (copy_to_user((char __user *)arg, &karg,
1484                                 sizeof(struct mpt_ioctl_targetinfo))) {
1485                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo - "
1486                         "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1487                         ioc->name, __FILE__, __LINE__, uarg);
1488                 kfree(pmem);
1489                 return -EFAULT;
1490         }
1491
1492         /* Copy the remaining data from kernel memory to user memory
1493          */
1494         if (copy_to_user(uarg->targetInfo, pmem, numBytes)) {
1495                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo - "
1496                         "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1497                         ioc->name, __FILE__, __LINE__, pdata);
1498                 kfree(pmem);
1499                 return -EFAULT;
1500         }
1501
1502         kfree(pmem);
1503
1504         return 0;
1505 }
1506
1507 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1508 /* MPT IOCTL Test function.
1509  *
1510  * Outputs:     None.
1511  * Return:      0 if successful
1512  *              -EFAULT if data unavailable
1513  *              -ENODEV  if no such device/adapter
1514  */
1515 static int
1516 mptctl_readtest (unsigned long arg)
1517 {
1518         struct mpt_ioctl_test __user *uarg = (void __user *) arg;
1519         struct mpt_ioctl_test    karg;
1520         MPT_ADAPTER *ioc;
1521         int iocnum;
1522
1523         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_test))) {
1524                 printk(KERN_ERR MYNAM "%s@%d::mptctl_readtest - "
1525                         "Unable to read in mpt_ioctl_test struct @ %p\n",
1526                                 __FILE__, __LINE__, uarg);
1527                 return -EFAULT;
1528         }
1529
1530         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1531             (ioc == NULL)) {
1532                 printk(KERN_DEBUG MYNAM "%s::mptctl_readtest() @%d - ioc%d not found!\n",
1533                                 __FILE__, __LINE__, iocnum);
1534                 return -ENODEV;
1535         }
1536
1537         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_readtest called.\n",
1538             ioc->name));
1539         /* Fill in the data and return the structure to the calling
1540          * program
1541          */
1542
1543 #ifdef MFCNT
1544         karg.chip_type = ioc->mfcnt;
1545 #else
1546         karg.chip_type = ioc->pcidev->device;
1547 #endif
1548         strncpy (karg.name, ioc->name, MPT_MAX_NAME);
1549         karg.name[MPT_MAX_NAME-1]='\0';
1550         strncpy (karg.product, ioc->prod_name, MPT_PRODUCT_LENGTH);
1551         karg.product[MPT_PRODUCT_LENGTH-1]='\0';
1552
1553         /* Copy the data from kernel memory to user memory
1554          */
1555         if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_test))) {
1556                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_readtest - "
1557                         "Unable to write out mpt_ioctl_test struct @ %p\n",
1558                         ioc->name, __FILE__, __LINE__, uarg);
1559                 return -EFAULT;
1560         }
1561
1562         return 0;
1563 }
1564
1565 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1566 /*
1567  *      mptctl_eventquery - Query the host adapter for the event types
1568  *      that are being logged.
1569  *      @arg: User space argument
1570  *
1571  * Outputs:     None.
1572  * Return:      0 if successful
1573  *              -EFAULT if data unavailable
1574  *              -ENODEV  if no such device/adapter
1575  */
1576 static int
1577 mptctl_eventquery (unsigned long arg)
1578 {
1579         struct mpt_ioctl_eventquery __user *uarg = (void __user *) arg;
1580         struct mpt_ioctl_eventquery      karg;
1581         MPT_ADAPTER *ioc;
1582         int iocnum;
1583
1584         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventquery))) {
1585                 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventquery - "
1586                         "Unable to read in mpt_ioctl_eventquery struct @ %p\n",
1587                                 __FILE__, __LINE__, uarg);
1588                 return -EFAULT;
1589         }
1590
1591         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1592             (ioc == NULL)) {
1593                 printk(KERN_DEBUG MYNAM "%s::mptctl_eventquery() @%d - ioc%d not found!\n",
1594                                 __FILE__, __LINE__, iocnum);
1595                 return -ENODEV;
1596         }
1597
1598         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventquery called.\n",
1599             ioc->name));
1600         karg.eventEntries = MPTCTL_EVENT_LOG_SIZE;
1601         karg.eventTypes = ioc->eventTypes;
1602
1603         /* Copy the data from kernel memory to user memory
1604          */
1605         if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_eventquery))) {
1606                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_eventquery - "
1607                         "Unable to write out mpt_ioctl_eventquery struct @ %p\n",
1608                         ioc->name, __FILE__, __LINE__, uarg);
1609                 return -EFAULT;
1610         }
1611         return 0;
1612 }
1613
1614 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1615 static int
1616 mptctl_eventenable (unsigned long arg)
1617 {
1618         struct mpt_ioctl_eventenable __user *uarg = (void __user *) arg;
1619         struct mpt_ioctl_eventenable     karg;
1620         MPT_ADAPTER *ioc;
1621         int iocnum;
1622
1623         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventenable))) {
1624                 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventenable - "
1625                         "Unable to read in mpt_ioctl_eventenable struct @ %p\n",
1626                                 __FILE__, __LINE__, uarg);
1627                 return -EFAULT;
1628         }
1629
1630         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1631             (ioc == NULL)) {
1632                 printk(KERN_DEBUG MYNAM "%s::mptctl_eventenable() @%d - ioc%d not found!\n",
1633                                 __FILE__, __LINE__, iocnum);
1634                 return -ENODEV;
1635         }
1636
1637         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventenable called.\n",
1638             ioc->name));
1639         if (ioc->events == NULL) {
1640                 /* Have not yet allocated memory - do so now.
1641                  */
1642                 int sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
1643                 ioc->events = kzalloc(sz, GFP_KERNEL);
1644                 if (!ioc->events) {
1645                         printk(MYIOC_s_ERR_FMT
1646                             ": ERROR - Insufficient memory to add adapter!\n",
1647                             ioc->name);
1648                         return -ENOMEM;
1649                 }
1650                 ioc->alloc_total += sz;
1651
1652                 ioc->eventContext = 0;
1653         }
1654
1655         /* Update the IOC event logging flag.
1656          */
1657         ioc->eventTypes = karg.eventTypes;
1658
1659         return 0;
1660 }
1661
1662 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1663 static int
1664 mptctl_eventreport (unsigned long arg)
1665 {
1666         struct mpt_ioctl_eventreport __user *uarg = (void __user *) arg;
1667         struct mpt_ioctl_eventreport     karg;
1668         MPT_ADAPTER              *ioc;
1669         int                      iocnum;
1670         int                      numBytes, maxEvents, max;
1671
1672         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventreport))) {
1673                 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventreport - "
1674                         "Unable to read in mpt_ioctl_eventreport struct @ %p\n",
1675                                 __FILE__, __LINE__, uarg);
1676                 return -EFAULT;
1677         }
1678
1679         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1680             (ioc == NULL)) {
1681                 printk(KERN_DEBUG MYNAM "%s::mptctl_eventreport() @%d - ioc%d not found!\n",
1682                                 __FILE__, __LINE__, iocnum);
1683                 return -ENODEV;
1684         }
1685         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventreport called.\n",
1686             ioc->name));
1687
1688         numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1689         maxEvents = numBytes/sizeof(MPT_IOCTL_EVENTS);
1690
1691
1692         max = MPTCTL_EVENT_LOG_SIZE < maxEvents ? MPTCTL_EVENT_LOG_SIZE : maxEvents;
1693
1694         /* If fewer than 1 event is requested, there must have
1695          * been some type of error.
1696          */
1697         if ((max < 1) || !ioc->events)
1698                 return -ENODATA;
1699
1700         /* reset this flag so SIGIO can restart */
1701         ioc->aen_event_read_flag=0;
1702
1703         /* Copy the data from kernel memory to user memory
1704          */
1705         numBytes = max * sizeof(MPT_IOCTL_EVENTS);
1706         if (copy_to_user(uarg->eventData, ioc->events, numBytes)) {
1707                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_eventreport - "
1708                         "Unable to write out mpt_ioctl_eventreport struct @ %p\n",
1709                         ioc->name, __FILE__, __LINE__, ioc->events);
1710                 return -EFAULT;
1711         }
1712
1713         return 0;
1714 }
1715
1716 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1717 static int
1718 mptctl_replace_fw (unsigned long arg)
1719 {
1720         struct mpt_ioctl_replace_fw __user *uarg = (void __user *) arg;
1721         struct mpt_ioctl_replace_fw      karg;
1722         MPT_ADAPTER              *ioc;
1723         int                      iocnum;
1724         int                      newFwSize;
1725
1726         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_replace_fw))) {
1727                 printk(KERN_ERR MYNAM "%s@%d::mptctl_replace_fw - "
1728                         "Unable to read in mpt_ioctl_replace_fw struct @ %p\n",
1729                                 __FILE__, __LINE__, uarg);
1730                 return -EFAULT;
1731         }
1732
1733         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1734             (ioc == NULL)) {
1735                 printk(KERN_DEBUG MYNAM "%s::mptctl_replace_fw() @%d - ioc%d not found!\n",
1736                                 __FILE__, __LINE__, iocnum);
1737                 return -ENODEV;
1738         }
1739
1740         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_replace_fw called.\n",
1741             ioc->name));
1742         /* If caching FW, Free the old FW image
1743          */
1744         if (ioc->cached_fw == NULL)
1745                 return 0;
1746
1747         mpt_free_fw_memory(ioc);
1748
1749         /* Allocate memory for the new FW image
1750          */
1751         newFwSize = karg.newImageSize;
1752
1753         if (newFwSize & 0x01)
1754                 newFwSize += 1;
1755         if (newFwSize & 0x02)
1756                 newFwSize += 2;
1757
1758         mpt_alloc_fw_memory(ioc, newFwSize);
1759         if (ioc->cached_fw == NULL)
1760                 return -ENOMEM;
1761
1762         /* Copy the data from user memory to kernel space
1763          */
1764         if (copy_from_user(ioc->cached_fw, uarg->newImage, newFwSize)) {
1765                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_replace_fw - "
1766                                 "Unable to read in mpt_ioctl_replace_fw image "
1767                                 "@ %p\n", ioc->name, __FILE__, __LINE__, uarg);
1768                 mpt_free_fw_memory(ioc);
1769                 return -EFAULT;
1770         }
1771
1772         /* Update IOCFactsReply
1773          */
1774         ioc->facts.FWImageSize = newFwSize;
1775         return 0;
1776 }
1777
1778 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1779 /* MPT IOCTL MPTCOMMAND function.
1780  * Cast the arg into the mpt_ioctl_mpt_command structure.
1781  *
1782  * Outputs:     None.
1783  * Return:      0 if successful
1784  *              -EBUSY  if previous command timeout and IOC reset is not complete.
1785  *              -EFAULT if data unavailable
1786  *              -ENODEV if no such device/adapter
1787  *              -ETIME  if timer expires
1788  *              -ENOMEM if memory allocation error
1789  */
1790 static int
1791 mptctl_mpt_command (unsigned long arg)
1792 {
1793         struct mpt_ioctl_command __user *uarg = (void __user *) arg;
1794         struct mpt_ioctl_command  karg;
1795         MPT_ADAPTER     *ioc;
1796         int             iocnum;
1797         int             rc;
1798
1799
1800         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_command))) {
1801                 printk(KERN_ERR MYNAM "%s@%d::mptctl_mpt_command - "
1802                         "Unable to read in mpt_ioctl_command struct @ %p\n",
1803                                 __FILE__, __LINE__, uarg);
1804                 return -EFAULT;
1805         }
1806
1807         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1808             (ioc == NULL)) {
1809                 printk(KERN_DEBUG MYNAM "%s::mptctl_mpt_command() @%d - ioc%d not found!\n",
1810                                 __FILE__, __LINE__, iocnum);
1811                 return -ENODEV;
1812         }
1813
1814         rc = mptctl_do_mpt_command (karg, &uarg->MF);
1815
1816         return rc;
1817 }
1818
1819 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1820 /* Worker routine for the IOCTL MPTCOMMAND and MPTCOMMAND32 (sparc) commands.
1821  *
1822  * Outputs:     None.
1823  * Return:      0 if successful
1824  *              -EBUSY  if previous command timeout and IOC reset is not complete.
1825  *              -EFAULT if data unavailable
1826  *              -ENODEV if no such device/adapter
1827  *              -ETIME  if timer expires
1828  *              -ENOMEM if memory allocation error
1829  *              -EPERM if SCSI I/O and target is untagged
1830  */
1831 static int
1832 mptctl_do_mpt_command (struct mpt_ioctl_command karg, void __user *mfPtr)
1833 {
1834         MPT_ADAPTER     *ioc;
1835         MPT_FRAME_HDR   *mf = NULL;
1836         MPIHeader_t     *hdr;
1837         char            *psge;
1838         struct buflist  bufIn;  /* data In buffer */
1839         struct buflist  bufOut; /* data Out buffer */
1840         dma_addr_t      dma_addr_in;
1841         dma_addr_t      dma_addr_out;
1842         int             sgSize = 0;     /* Num SG elements */
1843         int             iocnum, flagsLength;
1844         int             sz, rc = 0;
1845         int             msgContext;
1846         u16             req_idx;
1847         ulong           timeout;
1848         unsigned long   timeleft;
1849         struct scsi_device *sdev;
1850         unsigned long    flags;
1851         u8               function;
1852
1853         /* bufIn and bufOut are used for user to kernel space transfers
1854          */
1855         bufIn.kptr = bufOut.kptr = NULL;
1856         bufIn.len = bufOut.len = 0;
1857
1858         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1859             (ioc == NULL)) {
1860                 printk(KERN_DEBUG MYNAM "%s::mptctl_do_mpt_command() @%d - ioc%d not found!\n",
1861                                 __FILE__, __LINE__, iocnum);
1862                 return -ENODEV;
1863         }
1864
1865         spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
1866         if (ioc->ioc_reset_in_progress) {
1867                 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
1868                 printk(KERN_ERR MYNAM "%s@%d::mptctl_do_mpt_command - "
1869                         "Busy with diagnostic reset\n", __FILE__, __LINE__);
1870                 return -EBUSY;
1871         }
1872         spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
1873
1874         /* Verify that the final request frame will not be too large.
1875          */
1876         sz = karg.dataSgeOffset * 4;
1877         if (karg.dataInSize > 0)
1878                 sz += ioc->SGE_size;
1879         if (karg.dataOutSize > 0)
1880                 sz += ioc->SGE_size;
1881
1882         if (sz > ioc->req_sz) {
1883                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1884                         "Request frame too large (%d) maximum (%d)\n",
1885                         ioc->name, __FILE__, __LINE__, sz, ioc->req_sz);
1886                 return -EFAULT;
1887         }
1888
1889         /* Get a free request frame and save the message context.
1890          */
1891         if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
1892                 return -EAGAIN;
1893
1894         hdr = (MPIHeader_t *) mf;
1895         msgContext = le32_to_cpu(hdr->MsgContext);
1896         req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1897
1898         /* Copy the request frame
1899          * Reset the saved message context.
1900          * Request frame in user space
1901          */
1902         if (copy_from_user(mf, mfPtr, karg.dataSgeOffset * 4)) {
1903                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1904                         "Unable to read MF from mpt_ioctl_command struct @ %p\n",
1905                         ioc->name, __FILE__, __LINE__, mfPtr);
1906                 function = -1;
1907                 rc = -EFAULT;
1908                 goto done_free_mem;
1909         }
1910         hdr->MsgContext = cpu_to_le32(msgContext);
1911         function = hdr->Function;
1912
1913
1914         /* Verify that this request is allowed.
1915          */
1916         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sending mpi function (0x%02X), req=%p\n",
1917             ioc->name, hdr->Function, mf));
1918
1919         switch (function) {
1920         case MPI_FUNCTION_IOC_FACTS:
1921         case MPI_FUNCTION_PORT_FACTS:
1922                 karg.dataOutSize  = karg.dataInSize = 0;
1923                 break;
1924
1925         case MPI_FUNCTION_CONFIG:
1926         {
1927                 Config_t *config_frame;
1928                 config_frame = (Config_t *)mf;
1929                 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\ttype=0x%02x ext_type=0x%02x "
1930                     "number=0x%02x action=0x%02x\n", ioc->name,
1931                     config_frame->Header.PageType,
1932                     config_frame->ExtPageType,
1933                     config_frame->Header.PageNumber,
1934                     config_frame->Action));
1935                 break;
1936         }
1937
1938         case MPI_FUNCTION_FC_COMMON_TRANSPORT_SEND:
1939         case MPI_FUNCTION_FC_EX_LINK_SRVC_SEND:
1940         case MPI_FUNCTION_FW_UPLOAD:
1941         case MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR:
1942         case MPI_FUNCTION_FW_DOWNLOAD:
1943         case MPI_FUNCTION_FC_PRIMITIVE_SEND:
1944         case MPI_FUNCTION_TOOLBOX:
1945         case MPI_FUNCTION_SAS_IO_UNIT_CONTROL:
1946                 break;
1947
1948         case MPI_FUNCTION_SCSI_IO_REQUEST:
1949                 if (ioc->sh) {
1950                         SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
1951                         int qtag = MPI_SCSIIO_CONTROL_UNTAGGED;
1952                         int scsidir = 0;
1953                         int dataSize;
1954                         u32 id;
1955
1956                         id = (ioc->devices_per_bus == 0) ? 256 : ioc->devices_per_bus;
1957                         if (pScsiReq->TargetID > id) {
1958                                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1959                                         "Target ID out of bounds. \n",
1960                                         ioc->name, __FILE__, __LINE__);
1961                                 rc = -ENODEV;
1962                                 goto done_free_mem;
1963                         }
1964
1965                         if (pScsiReq->Bus >= ioc->number_of_buses) {
1966                                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1967                                         "Target Bus out of bounds. \n",
1968                                         ioc->name, __FILE__, __LINE__);
1969                                 rc = -ENODEV;
1970                                 goto done_free_mem;
1971                         }
1972
1973                         pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
1974                         pScsiReq->MsgFlags |= mpt_msg_flags(ioc);
1975
1976
1977                         /* verify that app has not requested
1978                          *      more sense data than driver
1979                          *      can provide, if so, reset this parameter
1980                          * set the sense buffer pointer low address
1981                          * update the control field to specify Q type
1982                          */
1983                         if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1984                                 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1985                         else
1986                                 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1987
1988                         pScsiReq->SenseBufferLowAddr =
1989                                 cpu_to_le32(ioc->sense_buf_low_dma
1990                                    + (req_idx * MPT_SENSE_BUFFER_ALLOC));
1991
1992                         shost_for_each_device(sdev, ioc->sh) {
1993                                 struct scsi_target *starget = scsi_target(sdev);
1994                                 VirtTarget *vtarget = starget->hostdata;
1995
1996                                 if (vtarget == NULL)
1997                                         continue;
1998
1999                                 if ((pScsiReq->TargetID == vtarget->id) &&
2000                                     (pScsiReq->Bus == vtarget->channel) &&
2001                                     (vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
2002                                         qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
2003                         }
2004
2005                         /* Have the IOCTL driver set the direction based
2006                          * on the dataOutSize (ordering issue with Sparc).
2007                          */
2008                         if (karg.dataOutSize > 0) {
2009                                 scsidir = MPI_SCSIIO_CONTROL_WRITE;
2010                                 dataSize = karg.dataOutSize;
2011                         } else {
2012                                 scsidir = MPI_SCSIIO_CONTROL_READ;
2013                                 dataSize = karg.dataInSize;
2014                         }
2015
2016                         pScsiReq->Control = cpu_to_le32(scsidir | qtag);
2017                         pScsiReq->DataLength = cpu_to_le32(dataSize);
2018
2019
2020                 } else {
2021                         printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2022                                 "SCSI driver is not loaded. \n",
2023                                 ioc->name, __FILE__, __LINE__);
2024                         rc = -EFAULT;
2025                         goto done_free_mem;
2026                 }
2027                 break;
2028
2029         case MPI_FUNCTION_SMP_PASSTHROUGH:
2030                 /* Check mf->PassthruFlags to determine if
2031                  * transfer is ImmediateMode or not.
2032                  * Immediate mode returns data in the ReplyFrame.
2033                  * Else, we are sending request and response data
2034                  * in two SGLs at the end of the mf.
2035                  */
2036                 break;
2037
2038         case MPI_FUNCTION_SATA_PASSTHROUGH:
2039                 if (!ioc->sh) {
2040                         printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2041                                 "SCSI driver is not loaded. \n",
2042                                 ioc->name, __FILE__, __LINE__);
2043                         rc = -EFAULT;
2044                         goto done_free_mem;
2045                 }
2046                 break;
2047
2048         case MPI_FUNCTION_RAID_ACTION:
2049                 /* Just add a SGE
2050                  */
2051                 break;
2052
2053         case MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
2054                 if (ioc->sh) {
2055                         SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
2056                         int qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
2057                         int scsidir = MPI_SCSIIO_CONTROL_READ;
2058                         int dataSize;
2059
2060                         pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
2061                         pScsiReq->MsgFlags |= mpt_msg_flags(ioc);
2062
2063
2064                         /* verify that app has not requested
2065                          *      more sense data than driver
2066                          *      can provide, if so, reset this parameter
2067                          * set the sense buffer pointer low address
2068                          * update the control field to specify Q type
2069                          */
2070                         if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
2071                                 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
2072                         else
2073                                 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
2074
2075                         pScsiReq->SenseBufferLowAddr =
2076                                 cpu_to_le32(ioc->sense_buf_low_dma
2077                                    + (req_idx * MPT_SENSE_BUFFER_ALLOC));
2078
2079                         /* All commands to physical devices are tagged
2080                          */
2081
2082                         /* Have the IOCTL driver set the direction based
2083                          * on the dataOutSize (ordering issue with Sparc).
2084                          */
2085                         if (karg.dataOutSize > 0) {
2086                                 scsidir = MPI_SCSIIO_CONTROL_WRITE;
2087                                 dataSize = karg.dataOutSize;
2088                         } else {
2089                                 scsidir = MPI_SCSIIO_CONTROL_READ;
2090                                 dataSize = karg.dataInSize;
2091                         }
2092
2093                         pScsiReq->Control = cpu_to_le32(scsidir | qtag);
2094                         pScsiReq->DataLength = cpu_to_le32(dataSize);
2095
2096                 } else {
2097                         printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2098                                 "SCSI driver is not loaded. \n",
2099                                 ioc->name, __FILE__, __LINE__);
2100                         rc = -EFAULT;
2101                         goto done_free_mem;
2102                 }
2103                 break;
2104
2105         case MPI_FUNCTION_SCSI_TASK_MGMT:
2106         {
2107                 SCSITaskMgmt_t  *pScsiTm;
2108                 pScsiTm = (SCSITaskMgmt_t *)mf;
2109                 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2110                         "\tTaskType=0x%x MsgFlags=0x%x "
2111                         "TaskMsgContext=0x%x id=%d channel=%d\n",
2112                         ioc->name, pScsiTm->TaskType, le32_to_cpu
2113                         (pScsiTm->TaskMsgContext), pScsiTm->MsgFlags,
2114                         pScsiTm->TargetID, pScsiTm->Bus));
2115                 break;
2116         }
2117
2118         case MPI_FUNCTION_IOC_INIT:
2119                 {
2120                         IOCInit_t       *pInit = (IOCInit_t *) mf;
2121                         u32             high_addr, sense_high;
2122
2123                         /* Verify that all entries in the IOC INIT match
2124                          * existing setup (and in LE format).
2125                          */
2126                         if (sizeof(dma_addr_t) == sizeof(u64)) {
2127                                 high_addr = cpu_to_le32((u32)((u64)ioc->req_frames_dma >> 32));
2128                                 sense_high= cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
2129                         } else {
2130                                 high_addr = 0;
2131                                 sense_high= 0;
2132                         }
2133
2134                         if ((pInit->Flags != 0) || (pInit->MaxDevices != ioc->facts.MaxDevices) ||
2135                                 (pInit->MaxBuses != ioc->facts.MaxBuses) ||
2136                                 (pInit->ReplyFrameSize != cpu_to_le16(ioc->reply_sz)) ||
2137                                 (pInit->HostMfaHighAddr != high_addr) ||
2138                                 (pInit->SenseBufferHighAddr != sense_high)) {
2139                                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2140                                         "IOC_INIT issued with 1 or more incorrect parameters. Rejected.\n",
2141                                         ioc->name, __FILE__, __LINE__);
2142                                 rc = -EFAULT;
2143                                 goto done_free_mem;
2144                         }
2145                 }
2146                 break;
2147         default:
2148                 /*
2149                  * MPI_FUNCTION_PORT_ENABLE
2150                  * MPI_FUNCTION_TARGET_CMD_BUFFER_POST
2151                  * MPI_FUNCTION_TARGET_ASSIST
2152                  * MPI_FUNCTION_TARGET_STATUS_SEND
2153                  * MPI_FUNCTION_TARGET_MODE_ABORT
2154                  * MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET
2155                  * MPI_FUNCTION_IO_UNIT_RESET
2156                  * MPI_FUNCTION_HANDSHAKE
2157                  * MPI_FUNCTION_REPLY_FRAME_REMOVAL
2158                  * MPI_FUNCTION_EVENT_NOTIFICATION
2159                  *  (driver handles event notification)
2160                  * MPI_FUNCTION_EVENT_ACK
2161                  */
2162
2163                 /*  What to do with these???  CHECK ME!!!
2164                         MPI_FUNCTION_FC_LINK_SRVC_BUF_POST
2165                         MPI_FUNCTION_FC_LINK_SRVC_RSP
2166                         MPI_FUNCTION_FC_ABORT
2167                         MPI_FUNCTION_LAN_SEND
2168                         MPI_FUNCTION_LAN_RECEIVE
2169                         MPI_FUNCTION_LAN_RESET
2170                 */
2171
2172                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2173                         "Illegal request (function 0x%x) \n",
2174                         ioc->name, __FILE__, __LINE__, hdr->Function);
2175                 rc = -EFAULT;
2176                 goto done_free_mem;
2177         }
2178
2179         /* Add the SGL ( at most one data in SGE and one data out SGE )
2180          * In the case of two SGE's - the data out (write) will always
2181          * preceede the data in (read) SGE. psgList is used to free the
2182          * allocated memory.
2183          */
2184         psge = (char *) (((int *) mf) + karg.dataSgeOffset);
2185         flagsLength = 0;
2186
2187         if (karg.dataOutSize > 0)
2188                 sgSize ++;
2189
2190         if (karg.dataInSize > 0)
2191                 sgSize ++;
2192
2193         if (sgSize > 0) {
2194
2195                 /* Set up the dataOut memory allocation */
2196                 if (karg.dataOutSize > 0) {
2197                         if (karg.dataInSize > 0) {
2198                                 flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2199                                                 MPI_SGE_FLAGS_END_OF_BUFFER |
2200                                                 MPI_SGE_FLAGS_DIRECTION)
2201                                                 << MPI_SGE_FLAGS_SHIFT;
2202                         } else {
2203                                 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
2204                         }
2205                         flagsLength |= karg.dataOutSize;
2206                         bufOut.len = karg.dataOutSize;
2207                         bufOut.kptr = pci_alloc_consistent(
2208                                         ioc->pcidev, bufOut.len, &dma_addr_out);
2209
2210                         if (bufOut.kptr == NULL) {
2211                                 rc = -ENOMEM;
2212                                 goto done_free_mem;
2213                         } else {
2214                                 /* Set up this SGE.
2215                                  * Copy to MF and to sglbuf
2216                                  */
2217                                 ioc->add_sge(psge, flagsLength, dma_addr_out);
2218                                 psge += ioc->SGE_size;
2219
2220                                 /* Copy user data to kernel space.
2221                                  */
2222                                 if (copy_from_user(bufOut.kptr,
2223                                                 karg.dataOutBufPtr,
2224                                                 bufOut.len)) {
2225                                         printk(MYIOC_s_ERR_FMT
2226                                                 "%s@%d::mptctl_do_mpt_command - Unable "
2227                                                 "to read user data "
2228                                                 "struct @ %p\n",
2229                                                 ioc->name, __FILE__, __LINE__,karg.dataOutBufPtr);
2230                                         rc =  -EFAULT;
2231                                         goto done_free_mem;
2232                                 }
2233                         }
2234                 }
2235
2236                 if (karg.dataInSize > 0) {
2237                         flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
2238                         flagsLength |= karg.dataInSize;
2239
2240                         bufIn.len = karg.dataInSize;
2241                         bufIn.kptr = pci_alloc_consistent(ioc->pcidev,
2242                                         bufIn.len, &dma_addr_in);
2243
2244                         if (bufIn.kptr == NULL) {
2245                                 rc = -ENOMEM;
2246                                 goto done_free_mem;
2247                         } else {
2248                                 /* Set up this SGE
2249                                  * Copy to MF and to sglbuf
2250                                  */
2251                                 ioc->add_sge(psge, flagsLength, dma_addr_in);
2252                         }
2253                 }
2254         } else  {
2255                 /* Add a NULL SGE
2256                  */
2257                 ioc->add_sge(psge, flagsLength, (dma_addr_t) -1);
2258         }
2259
2260         SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, hdr->MsgContext);
2261         INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
2262         if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT) {
2263
2264                 mutex_lock(&ioc->taskmgmt_cmds.mutex);
2265                 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
2266                         mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2267                         goto done_free_mem;
2268                 }
2269
2270                 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
2271
2272                 if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
2273                     (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
2274                         mpt_put_msg_frame_hi_pri(mptctl_id, ioc, mf);
2275                 else {
2276                         rc =mpt_send_handshake_request(mptctl_id, ioc,
2277                                 sizeof(SCSITaskMgmt_t), (u32*)mf, CAN_SLEEP);
2278                         if (rc != 0) {
2279                                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2280                                     "send_handshake FAILED! (ioc %p, mf %p)\n",
2281                                     ioc->name, ioc, mf));
2282                                 mpt_clear_taskmgmt_in_progress_flag(ioc);
2283                                 rc = -ENODATA;
2284                                 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2285                                 goto done_free_mem;
2286                         }
2287                 }
2288
2289         } else
2290                 mpt_put_msg_frame(mptctl_id, ioc, mf);
2291
2292         /* Now wait for the command to complete */
2293         timeout = (karg.timeout > 0) ? karg.timeout : MPT_IOCTL_DEFAULT_TIMEOUT;
2294 retry_wait:
2295         timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
2296                                 HZ*timeout);
2297         if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2298                 rc = -ETIME;
2299                 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "%s: TIMED OUT!\n",
2300                     ioc->name, __func__));
2301                 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2302                         if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2303                                 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2304                         goto done_free_mem;
2305                 }
2306                 if (!timeleft) {
2307                         printk(MYIOC_s_WARN_FMT
2308                                "mpt cmd timeout, doorbell=0x%08x"
2309                                " function=0x%x\n",
2310                                ioc->name, mpt_GetIocState(ioc, 0), function);
2311                         if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2312                                 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2313                         mptctl_timeout_expired(ioc, mf);
2314                         mf = NULL;
2315                 } else
2316                         goto retry_wait;
2317                 goto done_free_mem;
2318         }
2319
2320         if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2321                 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2322
2323
2324         mf = NULL;
2325
2326         /* If a valid reply frame, copy to the user.
2327          * Offset 2: reply length in U32's
2328          */
2329         if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) {
2330                 if (karg.maxReplyBytes < ioc->reply_sz) {
2331                         sz = min(karg.maxReplyBytes,
2332                                 4*ioc->ioctl_cmds.reply[2]);
2333                 } else {
2334                          sz = min(ioc->reply_sz, 4*ioc->ioctl_cmds.reply[2]);
2335                 }
2336                 if (sz > 0) {
2337                         if (copy_to_user(karg.replyFrameBufPtr,
2338                                  ioc->ioctl_cmds.reply, sz)){
2339                                  printk(MYIOC_s_ERR_FMT
2340                                      "%s@%d::mptctl_do_mpt_command - "
2341                                  "Unable to write out reply frame %p\n",
2342                                  ioc->name, __FILE__, __LINE__, karg.replyFrameBufPtr);
2343                                  rc =  -ENODATA;
2344                                  goto done_free_mem;
2345                         }
2346                 }
2347         }
2348
2349         /* If valid sense data, copy to user.
2350          */
2351         if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_SENSE_VALID) {
2352                 sz = min(karg.maxSenseBytes, MPT_SENSE_BUFFER_SIZE);
2353                 if (sz > 0) {
2354                         if (copy_to_user(karg.senseDataPtr,
2355                                 ioc->ioctl_cmds.sense, sz)) {
2356                                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2357                                 "Unable to write sense data to user %p\n",
2358                                 ioc->name, __FILE__, __LINE__,
2359                                 karg.senseDataPtr);
2360                                 rc =  -ENODATA;
2361                                 goto done_free_mem;
2362                         }
2363                 }
2364         }
2365
2366         /* If the overall status is _GOOD and data in, copy data
2367          * to user.
2368          */
2369         if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD) &&
2370                                 (karg.dataInSize > 0) && (bufIn.kptr)) {
2371
2372                 if (copy_to_user(karg.dataInBufPtr,
2373                                  bufIn.kptr, karg.dataInSize)) {
2374                         printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2375                                 "Unable to write data to user %p\n",
2376                                 ioc->name, __FILE__, __LINE__,
2377                                 karg.dataInBufPtr);
2378                         rc =  -ENODATA;
2379                 }
2380         }
2381
2382 done_free_mem:
2383
2384         CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
2385         SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
2386
2387         /* Free the allocated memory.
2388          */
2389         if (bufOut.kptr != NULL) {
2390                 pci_free_consistent(ioc->pcidev,
2391                         bufOut.len, (void *) bufOut.kptr, dma_addr_out);
2392         }
2393
2394         if (bufIn.kptr != NULL) {
2395                 pci_free_consistent(ioc->pcidev,
2396                         bufIn.len, (void *) bufIn.kptr, dma_addr_in);
2397         }
2398
2399         /* mf is null if command issued successfully
2400          * otherwise, failure occured after mf acquired.
2401          */
2402         if (mf)
2403                 mpt_free_msg_frame(ioc, mf);
2404
2405         return rc;
2406 }
2407
2408 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2409 /* Prototype Routine for the HOST INFO command.
2410  *
2411  * Outputs:     None.
2412  * Return:      0 if successful
2413  *              -EFAULT if data unavailable
2414  *              -EBUSY  if previous command timeout and IOC reset is not complete.
2415  *              -ENODEV if no such device/adapter
2416  *              -ETIME  if timer expires
2417  *              -ENOMEM if memory allocation error
2418  */
2419 static int
2420 mptctl_hp_hostinfo(unsigned long arg, unsigned int data_size)
2421 {
2422         hp_host_info_t  __user *uarg = (void __user *) arg;
2423         MPT_ADAPTER             *ioc;
2424         struct pci_dev          *pdev;
2425         char                    *pbuf=NULL;
2426         dma_addr_t              buf_dma;
2427         hp_host_info_t          karg;
2428         CONFIGPARMS             cfg;
2429         ConfigPageHeader_t      hdr;
2430         int                     iocnum;
2431         int                     rc, cim_rev;
2432         ToolboxIstwiReadWriteRequest_t  *IstwiRWRequest;
2433         MPT_FRAME_HDR           *mf = NULL;
2434         MPIHeader_t             *mpi_hdr;
2435         unsigned long           timeleft;
2436         int                     retval;
2437
2438         /* Reset long to int. Should affect IA64 and SPARC only
2439          */
2440         if (data_size == sizeof(hp_host_info_t))
2441                 cim_rev = 1;
2442         else if (data_size == sizeof(hp_host_info_rev0_t))
2443                 cim_rev = 0;    /* obsolete */
2444         else
2445                 return -EFAULT;
2446
2447         if (copy_from_user(&karg, uarg, sizeof(hp_host_info_t))) {
2448                 printk(KERN_ERR MYNAM "%s@%d::mptctl_hp_host_info - "
2449                         "Unable to read in hp_host_info struct @ %p\n",
2450                                 __FILE__, __LINE__, uarg);
2451                 return -EFAULT;
2452         }
2453
2454         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2455             (ioc == NULL)) {
2456                 printk(KERN_DEBUG MYNAM "%s::mptctl_hp_hostinfo() @%d - ioc%d not found!\n",
2457                                 __FILE__, __LINE__, iocnum);
2458                 return -ENODEV;
2459         }
2460         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": mptctl_hp_hostinfo called.\n",
2461             ioc->name));
2462
2463         /* Fill in the data and return the structure to the calling
2464          * program
2465          */
2466         pdev = (struct pci_dev *) ioc->pcidev;
2467
2468         karg.vendor = pdev->vendor;
2469         karg.device = pdev->device;
2470         karg.subsystem_id = pdev->subsystem_device;
2471         karg.subsystem_vendor = pdev->subsystem_vendor;
2472         karg.devfn = pdev->devfn;
2473         karg.bus = pdev->bus->number;
2474
2475         /* Save the SCSI host no. if
2476          * SCSI driver loaded
2477          */
2478         if (ioc->sh != NULL)
2479                 karg.host_no = ioc->sh->host_no;
2480         else
2481                 karg.host_no =  -1;
2482
2483         /* Reformat the fw_version into a string
2484          */
2485         karg.fw_version[0] = ioc->facts.FWVersion.Struct.Major >= 10 ?
2486                 ((ioc->facts.FWVersion.Struct.Major / 10) + '0') : '0';
2487         karg.fw_version[1] = (ioc->facts.FWVersion.Struct.Major % 10 ) + '0';
2488         karg.fw_version[2] = '.';
2489         karg.fw_version[3] = ioc->facts.FWVersion.Struct.Minor >= 10 ?
2490                 ((ioc->facts.FWVersion.Struct.Minor / 10) + '0') : '0';
2491         karg.fw_version[4] = (ioc->facts.FWVersion.Struct.Minor % 10 ) + '0';
2492         karg.fw_version[5] = '.';
2493         karg.fw_version[6] = ioc->facts.FWVersion.Struct.Unit >= 10 ?
2494                 ((ioc->facts.FWVersion.Struct.Unit / 10) + '0') : '0';
2495         karg.fw_version[7] = (ioc->facts.FWVersion.Struct.Unit % 10 ) + '0';
2496         karg.fw_version[8] = '.';
2497         karg.fw_version[9] = ioc->facts.FWVersion.Struct.Dev >= 10 ?
2498                 ((ioc->facts.FWVersion.Struct.Dev / 10) + '0') : '0';
2499         karg.fw_version[10] = (ioc->facts.FWVersion.Struct.Dev % 10 ) + '0';
2500         karg.fw_version[11] = '\0';
2501
2502         /* Issue a config request to get the device serial number
2503          */
2504         hdr.PageVersion = 0;
2505         hdr.PageLength = 0;
2506         hdr.PageNumber = 0;
2507         hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
2508         cfg.cfghdr.hdr = &hdr;
2509         cfg.physAddr = -1;
2510         cfg.pageAddr = 0;
2511         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2512         cfg.dir = 0;    /* read */
2513         cfg.timeout = 10;
2514
2515         strncpy(karg.serial_number, " ", 24);
2516         if (mpt_config(ioc, &cfg) == 0) {
2517                 if (cfg.cfghdr.hdr->PageLength > 0) {
2518                         /* Issue the second config page request */
2519                         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2520
2521                         pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
2522                         if (pbuf) {
2523                                 cfg.physAddr = buf_dma;
2524                                 if (mpt_config(ioc, &cfg) == 0) {
2525                                         ManufacturingPage0_t *pdata = (ManufacturingPage0_t *) pbuf;
2526                                         if (strlen(pdata->BoardTracerNumber) > 1) {
2527                                                 strncpy(karg.serial_number,                                                                         pdata->BoardTracerNumber, 24);
2528                                                 karg.serial_number[24-1]='\0';
2529                                         }
2530                                 }
2531                                 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
2532                                 pbuf = NULL;
2533                         }
2534                 }
2535         }
2536         rc = mpt_GetIocState(ioc, 1);
2537         switch (rc) {
2538         case MPI_IOC_STATE_OPERATIONAL:
2539                 karg.ioc_status =  HP_STATUS_OK;
2540                 break;
2541
2542         case MPI_IOC_STATE_FAULT:
2543                 karg.ioc_status =  HP_STATUS_FAILED;
2544                 break;
2545
2546         case MPI_IOC_STATE_RESET:
2547         case MPI_IOC_STATE_READY:
2548         default:
2549                 karg.ioc_status =  HP_STATUS_OTHER;
2550                 break;
2551         }
2552
2553         karg.base_io_addr = pci_resource_start(pdev, 0);
2554
2555         if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
2556                 karg.bus_phys_width = HP_BUS_WIDTH_UNK;
2557         else
2558                 karg.bus_phys_width = HP_BUS_WIDTH_16;
2559
2560         karg.hard_resets = 0;
2561         karg.soft_resets = 0;
2562         karg.timeouts = 0;
2563         if (ioc->sh != NULL) {
2564                 MPT_SCSI_HOST *hd =  shost_priv(ioc->sh);
2565
2566                 if (hd && (cim_rev == 1)) {
2567                         karg.hard_resets = ioc->hard_resets;
2568                         karg.soft_resets = ioc->soft_resets;
2569                         karg.timeouts = ioc->timeouts;
2570                 }
2571         }
2572
2573         /*
2574          * Gather ISTWI(Industry Standard Two Wire Interface) Data
2575          */
2576         if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
2577                 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
2578                         "%s, no msg frames!!\n", ioc->name, __func__));
2579                 goto out;
2580         }
2581
2582         IstwiRWRequest = (ToolboxIstwiReadWriteRequest_t *)mf;
2583         mpi_hdr = (MPIHeader_t *) mf;
2584         memset(IstwiRWRequest,0,sizeof(ToolboxIstwiReadWriteRequest_t));
2585         IstwiRWRequest->Function = MPI_FUNCTION_TOOLBOX;
2586         IstwiRWRequest->Tool = MPI_TOOLBOX_ISTWI_READ_WRITE_TOOL;
2587         IstwiRWRequest->MsgContext = mpi_hdr->MsgContext;
2588         IstwiRWRequest->Flags = MPI_TB_ISTWI_FLAGS_READ;
2589         IstwiRWRequest->NumAddressBytes = 0x01;
2590         IstwiRWRequest->DataLength = cpu_to_le16(0x04);
2591         if (pdev->devfn & 1)
2592                 IstwiRWRequest->DeviceAddr = 0xB2;
2593         else
2594                 IstwiRWRequest->DeviceAddr = 0xB0;
2595
2596         pbuf = pci_alloc_consistent(ioc->pcidev, 4, &buf_dma);
2597         if (!pbuf)
2598                 goto out;
2599         ioc->add_sge((char *)&IstwiRWRequest->SGL,
2600             (MPT_SGE_FLAGS_SSIMPLE_READ|4), buf_dma);
2601
2602         retval = 0;
2603         SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context,
2604                                 IstwiRWRequest->MsgContext);
2605         INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
2606         mpt_put_msg_frame(mptctl_id, ioc, mf);
2607
2608 retry_wait:
2609         timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
2610                         HZ*MPT_IOCTL_DEFAULT_TIMEOUT);
2611         if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2612                 retval = -ETIME;
2613                 printk(MYIOC_s_WARN_FMT "%s: failed\n", ioc->name, __func__);
2614                 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2615                         mpt_free_msg_frame(ioc, mf);
2616                         goto out;
2617                 }
2618                 if (!timeleft) {
2619                         printk(MYIOC_s_WARN_FMT
2620                                "HOST INFO command timeout, doorbell=0x%08x\n",
2621                                ioc->name, mpt_GetIocState(ioc, 0));
2622                         mptctl_timeout_expired(ioc, mf);
2623                 } else
2624                         goto retry_wait;
2625                 goto out;
2626         }
2627
2628         /*
2629          *ISTWI Data Definition
2630          * pbuf[0] = FW_VERSION = 0x4
2631          * pbuf[1] = Bay Count = 6 or 4 or 2, depending on
2632          *  the config, you should be seeing one out of these three values
2633          * pbuf[2] = Drive Installed Map = bit pattern depend on which
2634          *   bays have drives in them
2635          * pbuf[3] = Checksum (0x100 = (byte0 + byte2 + byte3)
2636          */
2637         if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID)
2638                 karg.rsvd = *(u32 *)pbuf;
2639
2640  out:
2641         CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
2642         SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
2643
2644         if (pbuf)
2645                 pci_free_consistent(ioc->pcidev, 4, pbuf, buf_dma);
2646
2647         /* Copy the data from kernel memory to user memory
2648          */
2649         if (copy_to_user((char __user *)arg, &karg, sizeof(hp_host_info_t))) {
2650                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_hpgethostinfo - "
2651                         "Unable to write out hp_host_info @ %p\n",
2652                         ioc->name, __FILE__, __LINE__, uarg);
2653                 return -EFAULT;
2654         }
2655
2656         return 0;
2657
2658 }
2659
2660 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2661 /* Prototype Routine for the TARGET INFO command.
2662  *
2663  * Outputs:     None.
2664  * Return:      0 if successful
2665  *              -EFAULT if data unavailable
2666  *              -EBUSY  if previous command timeout and IOC reset is not complete.
2667  *              -ENODEV if no such device/adapter
2668  *              -ETIME  if timer expires
2669  *              -ENOMEM if memory allocation error
2670  */
2671 static int
2672 mptctl_hp_targetinfo(unsigned long arg)
2673 {
2674         hp_target_info_t __user *uarg = (void __user *) arg;
2675         SCSIDevicePage0_t       *pg0_alloc;
2676         SCSIDevicePage3_t       *pg3_alloc;
2677         MPT_ADAPTER             *ioc;
2678         MPT_SCSI_HOST           *hd = NULL;
2679         hp_target_info_t        karg;
2680         int                     iocnum;
2681         int                     data_sz;
2682         dma_addr_t              page_dma;
2683         CONFIGPARMS             cfg;
2684         ConfigPageHeader_t      hdr;
2685         int                     tmp, np, rc = 0;
2686
2687         if (copy_from_user(&karg, uarg, sizeof(hp_target_info_t))) {
2688                 printk(KERN_ERR MYNAM "%s@%d::mptctl_hp_targetinfo - "
2689                         "Unable to read in hp_host_targetinfo struct @ %p\n",
2690                                 __FILE__, __LINE__, uarg);
2691                 return -EFAULT;
2692         }
2693
2694         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2695                 (ioc == NULL)) {
2696                 printk(KERN_DEBUG MYNAM "%s::mptctl_hp_targetinfo() @%d - ioc%d not found!\n",
2697                                 __FILE__, __LINE__, iocnum);
2698                 return -ENODEV;
2699         }
2700         dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_hp_targetinfo called.\n",
2701             ioc->name));
2702
2703         /*  There is nothing to do for FCP parts.
2704          */
2705         if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
2706                 return 0;
2707
2708         if ((ioc->spi_data.sdp0length == 0) || (ioc->sh == NULL))
2709                 return 0;
2710
2711         if (ioc->sh->host_no != karg.hdr.host)
2712                 return -ENODEV;
2713
2714        /* Get the data transfer speeds
2715         */
2716         data_sz = ioc->spi_data.sdp0length * 4;
2717         pg0_alloc = (SCSIDevicePage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
2718         if (pg0_alloc) {
2719                 hdr.PageVersion = ioc->spi_data.sdp0version;
2720                 hdr.PageLength = data_sz;
2721                 hdr.PageNumber = 0;
2722                 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2723
2724                 cfg.cfghdr.hdr = &hdr;
2725                 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2726                 cfg.dir = 0;
2727                 cfg.timeout = 0;
2728                 cfg.physAddr = page_dma;
2729
2730                 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2731
2732                 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2733                         np = le32_to_cpu(pg0_alloc->NegotiatedParameters);
2734                         karg.negotiated_width = np & MPI_SCSIDEVPAGE0_NP_WIDE ?
2735                                         HP_BUS_WIDTH_16 : HP_BUS_WIDTH_8;
2736
2737                         if (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) {
2738                                 tmp = (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> 8;
2739                                 if (tmp < 0x09)
2740                                         karg.negotiated_speed = HP_DEV_SPEED_ULTRA320;
2741                                 else if (tmp <= 0x09)
2742                                         karg.negotiated_speed = HP_DEV_SPEED_ULTRA160;
2743                                 else if (tmp <= 0x0A)
2744                                         karg.negotiated_speed = HP_DEV_SPEED_ULTRA2;
2745                                 else if (tmp <= 0x0C)
2746                                         karg.negotiated_speed = HP_DEV_SPEED_ULTRA;
2747                                 else if (tmp <= 0x25)
2748                                         karg.negotiated_speed = HP_DEV_SPEED_FAST;
2749                                 else
2750                                         karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2751                         } else
2752                                 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2753                 }
2754
2755                 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg0_alloc, page_dma);
2756         }
2757
2758         /* Set defaults
2759          */
2760         karg.message_rejects = -1;
2761         karg.phase_errors = -1;
2762         karg.parity_errors = -1;
2763         karg.select_timeouts = -1;
2764
2765         /* Get the target error parameters
2766          */
2767         hdr.PageVersion = 0;
2768         hdr.PageLength = 0;
2769         hdr.PageNumber = 3;
2770         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2771
2772         cfg.cfghdr.hdr = &hdr;
2773         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2774         cfg.dir = 0;
2775         cfg.timeout = 0;
2776         cfg.physAddr = -1;
2777         if ((mpt_config(ioc, &cfg) == 0) && (cfg.cfghdr.hdr->PageLength > 0)) {
2778                 /* Issue the second config page request */
2779                 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2780                 data_sz = (int) cfg.cfghdr.hdr->PageLength * 4;
2781                 pg3_alloc = (SCSIDevicePage3_t *) pci_alloc_consistent(
2782                                                         ioc->pcidev, data_sz, &page_dma);
2783                 if (pg3_alloc) {
2784                         cfg.physAddr = page_dma;
2785                         cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2786                         if ((rc = mpt_config(ioc, &cfg)) == 0) {
2787                                 karg.message_rejects = (u32) le16_to_cpu(pg3_alloc->MsgRejectCount);
2788                                 karg.phase_errors = (u32) le16_to_cpu(pg3_alloc->PhaseErrorCount);
2789                                 karg.parity_errors = (u32) le16_to_cpu(pg3_alloc->ParityErrorCount);
2790                         }
2791                         pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg3_alloc, page_dma);
2792                 }
2793         }
2794         hd = shost_priv(ioc->sh);
2795         if (hd != NULL)
2796                 karg.select_timeouts = hd->sel_timeout[karg.hdr.id];
2797
2798         /* Copy the data from kernel memory to user memory
2799          */
2800         if (copy_to_user((char __user *)arg, &karg, sizeof(hp_target_info_t))) {
2801                 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_hp_target_info - "
2802                         "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
2803                         ioc->name, __FILE__, __LINE__, uarg);
2804                 return -EFAULT;
2805         }
2806
2807         return 0;
2808 }
2809
2810 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2811
2812 static const struct file_operations mptctl_fops = {
2813         .owner =        THIS_MODULE,
2814         .llseek =       no_llseek,
2815         .fasync =       mptctl_fasync,
2816         .unlocked_ioctl = mptctl_ioctl,
2817 #ifdef CONFIG_COMPAT
2818         .compat_ioctl = compat_mpctl_ioctl,
2819 #endif
2820 };
2821
2822 static struct miscdevice mptctl_miscdev = {
2823         MPT_MINOR,
2824         MYNAM,
2825         &mptctl_fops
2826 };
2827
2828 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2829
2830 #ifdef CONFIG_COMPAT
2831
2832 static int
2833 compat_mptfwxfer_ioctl(struct file *filp, unsigned int cmd,
2834                         unsigned long arg)
2835 {
2836         struct mpt_fw_xfer32 kfw32;
2837         struct mpt_fw_xfer kfw;
2838         MPT_ADAPTER *iocp = NULL;
2839         int iocnum, iocnumX;
2840         int nonblock = (filp->f_flags & O_NONBLOCK);
2841         int ret;
2842
2843
2844         if (copy_from_user(&kfw32, (char __user *)arg, sizeof(kfw32)))
2845                 return -EFAULT;
2846
2847         /* Verify intended MPT adapter */
2848         iocnumX = kfw32.iocnum & 0xFF;
2849         if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2850             (iocp == NULL)) {
2851                 printk(KERN_DEBUG MYNAM "::compat_mptfwxfer_ioctl @%d - ioc%d not found!\n",
2852                         __LINE__, iocnumX);
2853                 return -ENODEV;
2854         }
2855
2856         if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2857                 return ret;
2858
2859         dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "compat_mptfwxfer_ioctl() called\n",
2860             iocp->name));
2861         kfw.iocnum = iocnum;
2862         kfw.fwlen = kfw32.fwlen;
2863         kfw.bufp = compat_ptr(kfw32.bufp);
2864
2865         ret = mptctl_do_fw_download(kfw.iocnum, kfw.bufp, kfw.fwlen);
2866
2867         mutex_unlock(&iocp->ioctl_cmds.mutex);
2868
2869         return ret;
2870 }
2871
2872 static int
2873 compat_mpt_command(struct file *filp, unsigned int cmd,
2874                         unsigned long arg)
2875 {
2876         struct mpt_ioctl_command32 karg32;
2877         struct mpt_ioctl_command32 __user *uarg = (struct mpt_ioctl_command32 __user *) arg;
2878         struct mpt_ioctl_command karg;
2879         MPT_ADAPTER *iocp = NULL;
2880         int iocnum, iocnumX;
2881         int nonblock = (filp->f_flags & O_NONBLOCK);
2882         int ret;
2883
2884         if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32)))
2885                 return -EFAULT;
2886
2887         /* Verify intended MPT adapter */
2888         iocnumX = karg32.hdr.iocnum & 0xFF;
2889         if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2890             (iocp == NULL)) {
2891                 printk(KERN_DEBUG MYNAM "::compat_mpt_command @%d - ioc%d not found!\n",
2892                         __LINE__, iocnumX);
2893                 return -ENODEV;
2894         }
2895
2896         if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2897                 return ret;
2898
2899         dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "compat_mpt_command() called\n",
2900             iocp->name));
2901         /* Copy data to karg */
2902         karg.hdr.iocnum = karg32.hdr.iocnum;
2903         karg.hdr.port = karg32.hdr.port;
2904         karg.timeout = karg32.timeout;
2905         karg.maxReplyBytes = karg32.maxReplyBytes;
2906
2907         karg.dataInSize = karg32.dataInSize;
2908         karg.dataOutSize = karg32.dataOutSize;
2909         karg.maxSenseBytes = karg32.maxSenseBytes;
2910         karg.dataSgeOffset = karg32.dataSgeOffset;
2911
2912         karg.replyFrameBufPtr = (char __user *)(unsigned long)karg32.replyFrameBufPtr;
2913         karg.dataInBufPtr = (char __user *)(unsigned long)karg32.dataInBufPtr;
2914         karg.dataOutBufPtr = (char __user *)(unsigned long)karg32.dataOutBufPtr;
2915         karg.senseDataPtr = (char __user *)(unsigned long)karg32.senseDataPtr;
2916
2917         /* Pass new structure to do_mpt_command
2918          */
2919         ret = mptctl_do_mpt_command (karg, &uarg->MF);
2920
2921         mutex_unlock(&iocp->ioctl_cmds.mutex);
2922
2923         return ret;
2924 }
2925
2926 static long compat_mpctl_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
2927 {
2928         long ret;
2929         lock_kernel();
2930         switch (cmd) {
2931         case MPTIOCINFO:
2932         case MPTIOCINFO1:
2933         case MPTIOCINFO2:
2934         case MPTTARGETINFO:
2935         case MPTEVENTQUERY:
2936         case MPTEVENTENABLE:
2937         case MPTEVENTREPORT:
2938         case MPTHARDRESET:
2939         case HP_GETHOSTINFO:
2940         case HP_GETTARGETINFO:
2941         case MPTTEST:
2942                 ret = __mptctl_ioctl(f, cmd, arg);
2943                 break;
2944         case MPTCOMMAND32:
2945                 ret = compat_mpt_command(f, cmd, arg);
2946                 break;
2947         case MPTFWDOWNLOAD32:
2948                 ret = compat_mptfwxfer_ioctl(f, cmd, arg);
2949                 break;
2950         default:
2951                 ret = -ENOIOCTLCMD;
2952                 break;
2953         }
2954         unlock_kernel();
2955         return ret;
2956 }
2957
2958 #endif
2959
2960
2961 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2962 /*
2963  *      mptctl_probe - Installs ioctl devices per bus.
2964  *      @pdev: Pointer to pci_dev structure
2965  *
2966  *      Returns 0 for success, non-zero for failure.
2967  *
2968  */
2969
2970 static int
2971 mptctl_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2972 {
2973         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
2974
2975         mutex_init(&ioc->ioctl_cmds.mutex);
2976         init_completion(&ioc->ioctl_cmds.done);
2977         return 0;
2978 }
2979
2980 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2981 /*
2982  *      mptctl_remove - Removed ioctl devices
2983  *      @pdev: Pointer to pci_dev structure
2984  *
2985  *
2986  */
2987 static void
2988 mptctl_remove(struct pci_dev *pdev)
2989 {
2990 }
2991
2992 static struct mpt_pci_driver mptctl_driver = {
2993   .probe                = mptctl_probe,
2994   .remove               = mptctl_remove,
2995 };
2996
2997 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2998 static int __init mptctl_init(void)
2999 {
3000         int err;
3001         int where = 1;
3002
3003         show_mptmod_ver(my_NAME, my_VERSION);
3004
3005         mpt_device_driver_register(&mptctl_driver, MPTCTL_DRIVER);
3006
3007         /* Register this device */
3008         err = misc_register(&mptctl_miscdev);
3009         if (err < 0) {
3010                 printk(KERN_ERR MYNAM ": Can't register misc device [minor=%d].\n", MPT_MINOR);
3011                 goto out_fail;
3012         }
3013         printk(KERN_INFO MYNAM ": Registered with Fusion MPT base driver\n");
3014         printk(KERN_INFO MYNAM ": /dev/%s @ (major,minor=%d,%d)\n",
3015                          mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
3016
3017         /*
3018          *  Install our handler
3019          */
3020         ++where;
3021         mptctl_id = mpt_register(mptctl_reply, MPTCTL_DRIVER,
3022             "mptctl_reply");
3023         if (!mptctl_id || mptctl_id >= MPT_MAX_PROTOCOL_DRIVERS) {
3024                 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
3025                 misc_deregister(&mptctl_miscdev);
3026                 err = -EBUSY;
3027                 goto out_fail;
3028         }
3029
3030         mptctl_taskmgmt_id = mpt_register(mptctl_taskmgmt_reply, MPTCTL_DRIVER,
3031             "mptctl_taskmgmt_reply");
3032         if (!mptctl_taskmgmt_id || mptctl_taskmgmt_id >= MPT_MAX_PROTOCOL_DRIVERS) {
3033                 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
3034                 mpt_deregister(mptctl_id);
3035                 misc_deregister(&mptctl_miscdev);
3036                 err = -EBUSY;
3037                 goto out_fail;
3038         }
3039
3040         mpt_reset_register(mptctl_id, mptctl_ioc_reset);
3041         mpt_event_register(mptctl_id, mptctl_event_process);
3042
3043         return 0;
3044
3045 out_fail:
3046
3047         mpt_device_driver_deregister(MPTCTL_DRIVER);
3048
3049         return err;
3050 }
3051
3052 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3053 static void mptctl_exit(void)
3054 {
3055         misc_deregister(&mptctl_miscdev);
3056         printk(KERN_INFO MYNAM ": Deregistered /dev/%s @ (major,minor=%d,%d)\n",
3057                          mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
3058
3059         /* De-register event handler from base module */
3060         mpt_event_deregister(mptctl_id);
3061
3062         /* De-register reset handler from base module */
3063         mpt_reset_deregister(mptctl_id);
3064
3065         /* De-register callback handler from base module */
3066         mpt_deregister(mptctl_taskmgmt_id);
3067         mpt_deregister(mptctl_id);
3068
3069         mpt_device_driver_deregister(MPTCTL_DRIVER);
3070
3071 }
3072
3073 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3074
3075 module_init(mptctl_init);
3076 module_exit(mptctl_exit);