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