git.oblomov.eu Git - linux-2.6/blob - drivers/message/fusion/mptctl.c

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