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