err.no 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_timeout(mptctl_wait,
 389              ioctl->wait_done == 1,
 390              HZ*5 /* 5 second timeout */);
 391
 392         if(ii <=0 && (ioctl->wait_done != 1 ))  {
 393                 mpt_free_msg_frame(hd->ioc, mf);
 394                 ioctl->wait_done = 0;
 395                 retval = -1; /* return failure */
 396         }
 397
 398 mptctl_bus_reset_done:
 399
 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_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.segmentID = pci_domain_nr(pdev->bus);
1181         }
1182
1183         /* Get number of devices
1184          */
1185         if ((sh = ioc->sh) != NULL) {
1186                  /* sh->max_id = maximum target ID + 1
1187                  */
1188                 max_id = sh->max_id - 1;
1189                 hd = (MPT_SCSI_HOST *) sh->hostdata;
1190
1191                 /* Check all of the target structures and
1192                  * keep a counter.
1193                  */
1194                 if (hd && hd->Targets) {
1195                         for (ii = 0; ii <= max_id; ii++) {
1196                                 if (hd->Targets[ii])
1197                                         numDevices++;
1198                         }
1199                 }
1200         }
1201         karg->numDevices = numDevices;
1202
1203         /* Set the BIOS and FW Version
1204          */
1205         karg->FWVersion = ioc->facts.FWVersion.Word;
1206         karg->BIOSVersion = ioc->biosVersion;
1207
1208         /* Set the Version Strings.
1209          */
1210         strncpy (karg->driverVersion, MPT_LINUX_PACKAGE_NAME, MPT_IOCTL_VERSION_LENGTH);
1211         karg->driverVersion[MPT_IOCTL_VERSION_LENGTH-1]='\0';
1212
1213         karg->busChangeEvent = 0;
1214         karg->hostId = ioc->pfacts[port].PortSCSIID;
1215         karg->rsvd[0] = karg->rsvd[1] = 0;
1216
1217         /* Copy the data from kernel memory to user memory
1218          */
1219         if (copy_to_user((char __user *)arg, karg, data_size)) {
1220                 printk(KERN_ERR "%s@%d::mptctl_getiocinfo - "
1221                         "Unable to write out mpt_ioctl_iocinfo struct @ %p\n",
1222                                 __FILE__, __LINE__, uarg);
1223                 kfree(karg);
1224                 return -EFAULT;
1225         }
1226
1227         kfree(karg);
1228         return 0;
1229 }
1230
1231 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1232 /*
1233  *      mptctl_gettargetinfo - Query the host adapter for target information.
1234  *      @arg: User space argument
1235  *
1236  * Outputs:     None.
1237  * Return:      0 if successful
1238  *              -EFAULT if data unavailable
1239  *              -ENODEV  if no such device/adapter
1240  */
1241 static int
1242 mptctl_gettargetinfo (unsigned long arg)
1243 {
1244         struct mpt_ioctl_targetinfo __user *uarg = (void __user *) arg;
1245         struct mpt_ioctl_targetinfo karg;
1246         MPT_ADAPTER             *ioc;
1247         struct Scsi_Host        *sh;
1248         MPT_SCSI_HOST           *hd;
1249         VirtTarget              *vdev;
1250         char                    *pmem;
1251         int                     *pdata;
1252         IOCPage2_t              *pIoc2;
1253         IOCPage3_t              *pIoc3;
1254         int                     iocnum;
1255         int                     numDevices = 0;
1256         unsigned int            max_id;
1257         int                     id, jj, indexed_lun, lun_index;
1258         u32                     lun;
1259         int                     maxWordsLeft;
1260         int                     numBytes;
1261         u8                      port, devType, bus_id;
1262
1263         dctlprintk(("mptctl_gettargetinfo called.\n"));
1264         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_targetinfo))) {
1265                 printk(KERN_ERR "%s@%d::mptctl_gettargetinfo - "
1266                         "Unable to read in mpt_ioctl_targetinfo struct @ %p\n",
1267                                 __FILE__, __LINE__, uarg);
1268                 return -EFAULT;
1269         }
1270
1271         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1272             (ioc == NULL)) {
1273                 dctlprintk((KERN_ERR "%s::mptctl_gettargetinfo() @%d - ioc%d not found!\n",
1274                                 __FILE__, __LINE__, iocnum));
1275                 return -ENODEV;
1276         }
1277
1278         /* Get the port number and set the maximum number of bytes
1279          * in the returned structure.
1280          * Ignore the port setting.
1281          */
1282         numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1283         maxWordsLeft = numBytes/sizeof(int);
1284         port = karg.hdr.port;
1285
1286         if (maxWordsLeft <= 0) {
1287                 printk(KERN_ERR "%s::mptctl_gettargetinfo() @%d - no memory available!\n",
1288                                 __FILE__, __LINE__);
1289                 return -ENOMEM;
1290         }
1291
1292         /* Fill in the data and return the structure to the calling
1293          * program
1294          */
1295
1296         /* struct mpt_ioctl_targetinfo does not contain sufficient space
1297          * for the target structures so when the IOCTL is called, there is
1298          * not sufficient stack space for the structure. Allocate memory,
1299          * populate the memory, copy back to the user, then free memory.
1300          * targetInfo format:
1301          * bits 31-24: reserved
1302          *      23-16: LUN
1303          *      15- 8: Bus Number
1304          *       7- 0: Target ID
1305          */
1306         pmem = kmalloc(numBytes, GFP_KERNEL);
1307         if (pmem == NULL) {
1308                 printk(KERN_ERR "%s::mptctl_gettargetinfo() @%d - no memory available!\n",
1309                                 __FILE__, __LINE__);
1310                 return -ENOMEM;
1311         }
1312         memset(pmem, 0, numBytes);
1313         pdata =  (int *) pmem;
1314
1315         /* Get number of devices
1316          */
1317         if ((sh = ioc->sh) != NULL) {
1318
1319                 max_id = sh->max_id - 1;
1320                 hd = (MPT_SCSI_HOST *) sh->hostdata;
1321
1322                 /* Check all of the target structures.
1323                  * Save the Id and increment the counter,
1324                  * if ptr non-null.
1325                  * sh->max_id = maximum target ID + 1
1326                  */
1327                 if (hd && hd->Targets) {
1328                         mpt_findImVolumes(ioc);
1329                         pIoc2 = ioc->raid_data.pIocPg2;
1330                         for ( id = 0; id <= max_id; ) {
1331                                 if ( pIoc2 && pIoc2->NumActiveVolumes ) {
1332                                         if ( id == pIoc2->RaidVolume[0].VolumeID ) {
1333                                                 if (maxWordsLeft <= 0) {
1334                                                         printk(KERN_ERR "mptctl_gettargetinfo - "
1335                         "buffer is full but volume is available on ioc %d\n, numDevices=%d", iocnum, numDevices);
1336                                                         goto data_space_full;
1337                                                 }
1338                                                 if ( ( pIoc2->RaidVolume[0].Flags & MPI_IOCPAGE2_FLAG_VOLUME_INACTIVE ) == 0 )
1339                                                         devType = 0x80;
1340                                                 else
1341                                                         devType = 0xC0;
1342                                                 bus_id = pIoc2->RaidVolume[0].VolumeBus;
1343                                                 numDevices++;
1344                                                 *pdata = ( (devType << 24) | (bus_id << 8) | id );
1345                                                 dctlprintk((KERN_ERR "mptctl_gettargetinfo - "
1346                 "volume ioc=%d target=%x numDevices=%d pdata=%p\n", iocnum, *pdata, numDevices, pdata));
1347                                                 pdata++;
1348                                                 --maxWordsLeft;
1349                                                 goto next_id;
1350                                         } else {
1351                                                 pIoc3 = ioc->raid_data.pIocPg3;
1352                                                 for ( jj = 0; jj < pIoc3->NumPhysDisks; jj++ ) {
1353                                                         if ( pIoc3->PhysDisk[jj].PhysDiskID == id )
1354                                                                 goto next_id;
1355                                                 }
1356                                         }
1357                                 }
1358                                 if ( (vdev = hd->Targets[id]) ) {
1359                                         for (jj = 0; jj <= MPT_LAST_LUN; jj++) {
1360                                                 lun_index = (jj >> 5);
1361                                                 indexed_lun = (jj % 32);
1362                                                 lun = (1 << indexed_lun);
1363                                                 if (vdev->luns[lun_index] & lun) {
1364                                                         if (maxWordsLeft <= 0) {
1365                                                                 printk(KERN_ERR "mptctl_gettargetinfo - "
1366                         "buffer is full but more targets are available on ioc %d numDevices=%d\n", iocnum, numDevices);
1367                                                                 goto data_space_full;
1368                                                         }
1369                                                         bus_id = vdev->bus_id;
1370                                                         numDevices++;
1371                                                         *pdata = ( (jj << 16) | (bus_id << 8) | id );
1372                                                         dctlprintk((KERN_ERR "mptctl_gettargetinfo - "
1373                 "target ioc=%d target=%x numDevices=%d pdata=%p\n", iocnum, *pdata, numDevices, pdata));
1374                                                         pdata++;
1375                                                         --maxWordsLeft;
1376                                                 }
1377                                         }
1378                                 }
1379 next_id:
1380                                 id++;
1381                         }
1382                 }
1383         }
1384 data_space_full:
1385         karg.numDevices = numDevices;
1386
1387         /* Copy part of the data from kernel memory to user memory
1388          */
1389         if (copy_to_user((char __user *)arg, &karg,
1390                                 sizeof(struct mpt_ioctl_targetinfo))) {
1391                 printk(KERN_ERR "%s@%d::mptctl_gettargetinfo - "
1392                         "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1393                                 __FILE__, __LINE__, uarg);
1394                 kfree(pmem);
1395                 return -EFAULT;
1396         }
1397
1398         /* Copy the remaining data from kernel memory to user memory
1399          */
1400         if (copy_to_user(uarg->targetInfo, pmem, numBytes)) {
1401                 printk(KERN_ERR "%s@%d::mptctl_gettargetinfo - "
1402                         "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1403                                 __FILE__, __LINE__, pdata);
1404                 kfree(pmem);
1405                 return -EFAULT;
1406         }
1407
1408         kfree(pmem);
1409
1410         return 0;
1411 }
1412
1413 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1414 /* MPT IOCTL Test function.
1415  *
1416  * Outputs:     None.
1417  * Return:      0 if successful
1418  *              -EFAULT if data unavailable
1419  *              -ENODEV  if no such device/adapter
1420  */
1421 static int
1422 mptctl_readtest (unsigned long arg)
1423 {
1424         struct mpt_ioctl_test __user *uarg = (void __user *) arg;
1425         struct mpt_ioctl_test    karg;
1426         MPT_ADAPTER *ioc;
1427         int iocnum;
1428
1429         dctlprintk(("mptctl_readtest called.\n"));
1430         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_test))) {
1431                 printk(KERN_ERR "%s@%d::mptctl_readtest - "
1432                         "Unable to read in mpt_ioctl_test struct @ %p\n",
1433                                 __FILE__, __LINE__, uarg);
1434                 return -EFAULT;
1435         }
1436
1437         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1438             (ioc == NULL)) {
1439                 dctlprintk((KERN_ERR "%s::mptctl_readtest() @%d - ioc%d not found!\n",
1440                                 __FILE__, __LINE__, iocnum));
1441                 return -ENODEV;
1442         }
1443
1444         /* Fill in the data and return the structure to the calling
1445          * program
1446          */
1447
1448 #ifdef MFCNT
1449         karg.chip_type = ioc->mfcnt;
1450 #else
1451         karg.chip_type = ioc->pcidev->device;
1452 #endif
1453         strncpy (karg.name, ioc->name, MPT_MAX_NAME);
1454         karg.name[MPT_MAX_NAME-1]='\0';
1455         strncpy (karg.product, ioc->prod_name, MPT_PRODUCT_LENGTH);
1456         karg.product[MPT_PRODUCT_LENGTH-1]='\0';
1457
1458         /* Copy the data from kernel memory to user memory
1459          */
1460         if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_test))) {
1461                 printk(KERN_ERR "%s@%d::mptctl_readtest - "
1462                         "Unable to write out mpt_ioctl_test struct @ %p\n",
1463                                 __FILE__, __LINE__, uarg);
1464                 return -EFAULT;
1465         }
1466
1467         return 0;
1468 }
1469
1470 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1471 /*
1472  *      mptctl_eventquery - Query the host adapter for the event types
1473  *      that are being logged.
1474  *      @arg: User space argument
1475  *
1476  * Outputs:     None.
1477  * Return:      0 if successful
1478  *              -EFAULT if data unavailable
1479  *              -ENODEV  if no such device/adapter
1480  */
1481 static int
1482 mptctl_eventquery (unsigned long arg)
1483 {
1484         struct mpt_ioctl_eventquery __user *uarg = (void __user *) arg;
1485         struct mpt_ioctl_eventquery      karg;
1486         MPT_ADAPTER *ioc;
1487         int iocnum;
1488
1489         dctlprintk(("mptctl_eventquery called.\n"));
1490         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventquery))) {
1491                 printk(KERN_ERR "%s@%d::mptctl_eventquery - "
1492                         "Unable to read in mpt_ioctl_eventquery struct @ %p\n",
1493                                 __FILE__, __LINE__, uarg);
1494                 return -EFAULT;
1495         }
1496
1497         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1498             (ioc == NULL)) {
1499                 dctlprintk((KERN_ERR "%s::mptctl_eventquery() @%d - ioc%d not found!\n",
1500                                 __FILE__, __LINE__, iocnum));
1501                 return -ENODEV;
1502         }
1503
1504         karg.eventEntries = ioc->eventLogSize;
1505         karg.eventTypes = ioc->eventTypes;
1506
1507         /* Copy the data from kernel memory to user memory
1508          */
1509         if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_eventquery))) {
1510                 printk(KERN_ERR "%s@%d::mptctl_eventquery - "
1511                         "Unable to write out mpt_ioctl_eventquery struct @ %p\n",
1512                                 __FILE__, __LINE__, uarg);
1513                 return -EFAULT;
1514         }
1515         return 0;
1516 }
1517
1518 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1519 static int
1520 mptctl_eventenable (unsigned long arg)
1521 {
1522         struct mpt_ioctl_eventenable __user *uarg = (void __user *) arg;
1523         struct mpt_ioctl_eventenable     karg;
1524         MPT_ADAPTER *ioc;
1525         int iocnum;
1526
1527         dctlprintk(("mptctl_eventenable called.\n"));
1528         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventenable))) {
1529                 printk(KERN_ERR "%s@%d::mptctl_eventenable - "
1530                         "Unable to read in mpt_ioctl_eventenable struct @ %p\n",
1531                                 __FILE__, __LINE__, uarg);
1532                 return -EFAULT;
1533         }
1534
1535         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1536             (ioc == NULL)) {
1537                 dctlprintk((KERN_ERR "%s::mptctl_eventenable() @%d - ioc%d not found!\n",
1538                                 __FILE__, __LINE__, iocnum));
1539                 return -ENODEV;
1540         }
1541
1542         if (ioc->events == NULL) {
1543                 /* Have not yet allocated memory - do so now.
1544                  */
1545                 int sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
1546                 ioc->events = kmalloc(sz, GFP_KERNEL);
1547                 if (ioc->events == NULL) {
1548                         printk(KERN_ERR MYNAM ": ERROR - Insufficient memory to add adapter!\n");
1549                         return -ENOMEM;
1550                 }
1551                 memset(ioc->events, 0, sz);
1552                 ioc->alloc_total += sz;
1553
1554                 ioc->eventLogSize = MPTCTL_EVENT_LOG_SIZE;
1555                 ioc->eventContext = 0;
1556         }
1557
1558         /* Update the IOC event logging flag.
1559          */
1560         ioc->eventTypes = karg.eventTypes;
1561
1562         return 0;
1563 }
1564
1565 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1566 static int
1567 mptctl_eventreport (unsigned long arg)
1568 {
1569         struct mpt_ioctl_eventreport __user *uarg = (void __user *) arg;
1570         struct mpt_ioctl_eventreport     karg;
1571         MPT_ADAPTER              *ioc;
1572         int                      iocnum;
1573         int                      numBytes, maxEvents, max;
1574
1575         dctlprintk(("mptctl_eventreport called.\n"));
1576         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventreport))) {
1577                 printk(KERN_ERR "%s@%d::mptctl_eventreport - "
1578                         "Unable to read in mpt_ioctl_eventreport struct @ %p\n",
1579                                 __FILE__, __LINE__, uarg);
1580                 return -EFAULT;
1581         }
1582
1583         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1584             (ioc == NULL)) {
1585                 dctlprintk((KERN_ERR "%s::mptctl_eventreport() @%d - ioc%d not found!\n",
1586                                 __FILE__, __LINE__, iocnum));
1587                 return -ENODEV;
1588         }
1589
1590         numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1591         maxEvents = numBytes/sizeof(MPT_IOCTL_EVENTS);
1592
1593
1594         max = ioc->eventLogSize < maxEvents ? ioc->eventLogSize : maxEvents;
1595
1596         /* If fewer than 1 event is requested, there must have
1597          * been some type of error.
1598          */
1599         if ((max < 1) || !ioc->events)
1600                 return -ENODATA;
1601
1602         /* Copy the data from kernel memory to user memory
1603          */
1604         numBytes = max * sizeof(MPT_IOCTL_EVENTS);
1605         if (copy_to_user(uarg->eventData, ioc->events, numBytes)) {
1606                 printk(KERN_ERR "%s@%d::mptctl_eventreport - "
1607                         "Unable to write out mpt_ioctl_eventreport struct @ %p\n",
1608                                 __FILE__, __LINE__, ioc->events);
1609                 return -EFAULT;
1610         }
1611
1612         return 0;
1613 }
1614
1615 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1616 static int
1617 mptctl_replace_fw (unsigned long arg)
1618 {
1619         struct mpt_ioctl_replace_fw __user *uarg = (void __user *) arg;
1620         struct mpt_ioctl_replace_fw      karg;
1621         MPT_ADAPTER              *ioc;
1622         int                      iocnum;
1623         int                      newFwSize;
1624
1625         dctlprintk(("mptctl_replace_fw called.\n"));
1626         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_replace_fw))) {
1627                 printk(KERN_ERR "%s@%d::mptctl_replace_fw - "
1628                         "Unable to read in mpt_ioctl_replace_fw struct @ %p\n",
1629                                 __FILE__, __LINE__, uarg);
1630                 return -EFAULT;
1631         }
1632
1633         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1634             (ioc == NULL)) {
1635                 dctlprintk((KERN_ERR "%s::mptctl_replace_fw() @%d - ioc%d not found!\n",
1636                                 __FILE__, __LINE__, iocnum));
1637                 return -ENODEV;
1638         }
1639
1640         /* If caching FW, Free the old FW image
1641          */
1642         if (ioc->cached_fw == NULL)
1643                 return 0;
1644
1645         mpt_free_fw_memory(ioc);
1646
1647         /* Allocate memory for the new FW image
1648          */
1649         newFwSize = karg.newImageSize;
1650
1651         if (newFwSize & 0x01)
1652                 newFwSize += 1;
1653         if (newFwSize & 0x02)
1654                 newFwSize += 2;
1655
1656         mpt_alloc_fw_memory(ioc, newFwSize);
1657         if (ioc->cached_fw == NULL)
1658                 return -ENOMEM;
1659
1660         /* Copy the data from user memory to kernel space
1661          */
1662         if (copy_from_user(ioc->cached_fw, uarg->newImage, newFwSize)) {
1663                 printk(KERN_ERR "%s@%d::mptctl_replace_fw - "
1664                                 "Unable to read in mpt_ioctl_replace_fw image "
1665                                 "@ %p\n", __FILE__, __LINE__, uarg);
1666                 mpt_free_fw_memory(ioc);
1667                 return -EFAULT;
1668         }
1669
1670         /* Update IOCFactsReply
1671          */
1672         ioc->facts.FWImageSize = newFwSize;
1673         return 0;
1674 }
1675
1676 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1677 /* MPT IOCTL MPTCOMMAND function.
1678  * Cast the arg into the mpt_ioctl_mpt_command structure.
1679  *
1680  * Outputs:     None.
1681  * Return:      0 if successful
1682  *              -EBUSY  if previous command timout and IOC reset is not complete.
1683  *              -EFAULT if data unavailable
1684  *              -ENODEV if no such device/adapter
1685  *              -ETIME  if timer expires
1686  *              -ENOMEM if memory allocation error
1687  */
1688 static int
1689 mptctl_mpt_command (unsigned long arg)
1690 {
1691         struct mpt_ioctl_command __user *uarg = (void __user *) arg;
1692         struct mpt_ioctl_command  karg;
1693         MPT_ADAPTER     *ioc;
1694         int             iocnum;
1695         int             rc;
1696
1697         dctlprintk(("mptctl_command called.\n"));
1698
1699         if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_command))) {
1700                 printk(KERN_ERR "%s@%d::mptctl_mpt_command - "
1701                         "Unable to read in mpt_ioctl_command struct @ %p\n",
1702                                 __FILE__, __LINE__, uarg);
1703                 return -EFAULT;
1704         }
1705
1706         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1707             (ioc == NULL)) {
1708                 dctlprintk((KERN_ERR "%s::mptctl_mpt_command() @%d - ioc%d not found!\n",
1709                                 __FILE__, __LINE__, iocnum));
1710                 return -ENODEV;
1711         }
1712
1713         rc = mptctl_do_mpt_command (karg, &uarg->MF);
1714
1715         return rc;
1716 }
1717
1718 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1719 /* Worker routine for the IOCTL MPTCOMMAND and MPTCOMMAND32 (sparc) commands.
1720  *
1721  * Outputs:     None.
1722  * Return:      0 if successful
1723  *              -EBUSY  if previous command timout and IOC reset is not complete.
1724  *              -EFAULT if data unavailable
1725  *              -ENODEV if no such device/adapter
1726  *              -ETIME  if timer expires
1727  *              -ENOMEM if memory allocation error
1728  *              -EPERM if SCSI I/O and target is untagged
1729  */
1730 static int
1731 mptctl_do_mpt_command (struct mpt_ioctl_command karg, void __user *mfPtr)
1732 {
1733         MPT_ADAPTER     *ioc;
1734         MPT_FRAME_HDR   *mf = NULL;
1735         MPIHeader_t     *hdr;
1736         char            *psge;
1737         struct buflist  bufIn;  /* data In buffer */
1738         struct buflist  bufOut; /* data Out buffer */
1739         dma_addr_t      dma_addr_in;
1740         dma_addr_t      dma_addr_out;
1741         int             sgSize = 0;     /* Num SG elements */
1742         int             iocnum, flagsLength;
1743         int             sz, rc = 0;
1744         int             msgContext;
1745         u16             req_idx;
1746         ulong           timeout;
1747
1748         dctlprintk(("mptctl_do_mpt_command called.\n"));
1749         bufIn.kptr = bufOut.kptr = NULL;
1750
1751         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1752             (ioc == NULL)) {
1753                 dctlprintk((KERN_ERR "%s::mptctl_do_mpt_command() @%d - ioc%d not found!\n",
1754                                 __FILE__, __LINE__, iocnum));
1755                 return -ENODEV;
1756         }
1757         if (!ioc->ioctl) {
1758                 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1759                         "No memory available during driver init.\n",
1760                                 __FILE__, __LINE__);
1761                 return -ENOMEM;
1762         } else if (ioc->ioctl->status & MPT_IOCTL_STATUS_DID_IOCRESET) {
1763                 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1764                         "Busy with IOC Reset \n", __FILE__, __LINE__);
1765                 return -EBUSY;
1766         }
1767
1768         /* Verify that the final request frame will not be too large.
1769          */
1770         sz = karg.dataSgeOffset * 4;
1771         if (karg.dataInSize > 0)
1772                 sz += sizeof(dma_addr_t) + sizeof(u32);
1773         if (karg.dataOutSize > 0)
1774                 sz += sizeof(dma_addr_t) + sizeof(u32);
1775
1776         if (sz > ioc->req_sz) {
1777                 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1778                         "Request frame too large (%d) maximum (%d)\n",
1779                                 __FILE__, __LINE__, sz, ioc->req_sz);
1780                 return -EFAULT;
1781         }
1782
1783         /* Get a free request frame and save the message context.
1784          */
1785         if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
1786                 return -EAGAIN;
1787
1788         hdr = (MPIHeader_t *) mf;
1789         msgContext = le32_to_cpu(hdr->MsgContext);
1790         req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1791
1792         /* Copy the request frame
1793          * Reset the saved message context.
1794          * Request frame in user space
1795          */
1796         if (copy_from_user(mf, mfPtr, karg.dataSgeOffset * 4)) {
1797                 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1798                         "Unable to read MF from mpt_ioctl_command struct @ %p\n",
1799                         __FILE__, __LINE__, mfPtr);
1800                 rc = -EFAULT;
1801                 goto done_free_mem;
1802         }
1803         hdr->MsgContext = cpu_to_le32(msgContext);
1804
1805
1806         /* Verify that this request is allowed.
1807          */
1808         switch (hdr->Function) {
1809         case MPI_FUNCTION_IOC_FACTS:
1810         case MPI_FUNCTION_PORT_FACTS:
1811                 karg.dataOutSize  = karg.dataInSize = 0;
1812                 break;
1813
1814         case MPI_FUNCTION_CONFIG:
1815         case MPI_FUNCTION_FC_COMMON_TRANSPORT_SEND:
1816         case MPI_FUNCTION_FC_EX_LINK_SRVC_SEND:
1817         case MPI_FUNCTION_FW_UPLOAD:
1818         case MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR:
1819         case MPI_FUNCTION_FW_DOWNLOAD:
1820         case MPI_FUNCTION_FC_PRIMITIVE_SEND:
1821         case MPI_FUNCTION_TOOLBOX:
1822         case MPI_FUNCTION_SAS_IO_UNIT_CONTROL:
1823                 break;
1824
1825         case MPI_FUNCTION_SCSI_IO_REQUEST:
1826                 if (ioc->sh) {
1827                         SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
1828                         VirtTarget      *pTarget = NULL;
1829                         MPT_SCSI_HOST   *hd = NULL;
1830                         int qtag = MPI_SCSIIO_CONTROL_UNTAGGED;
1831                         int scsidir = 0;
1832                         int target = (int) pScsiReq->TargetID;
1833                         int dataSize;
1834
1835                         if ((target < 0) || (target >= ioc->sh->max_id)) {
1836                                 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1837                                         "Target ID out of bounds. \n",
1838                                         __FILE__, __LINE__);
1839                                 rc = -ENODEV;
1840                                 goto done_free_mem;
1841                         }
1842
1843                         pScsiReq->MsgFlags = mpt_msg_flags();
1844
1845                         /* verify that app has not requested
1846                          *      more sense data than driver
1847                          *      can provide, if so, reset this parameter
1848                          * set the sense buffer pointer low address
1849                          * update the control field to specify Q type
1850                          */
1851                         if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1852                                 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1853                         else
1854                                 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1855
1856                         pScsiReq->SenseBufferLowAddr =
1857                                 cpu_to_le32(ioc->sense_buf_low_dma
1858                                    + (req_idx * MPT_SENSE_BUFFER_ALLOC));
1859
1860                         if ((hd = (MPT_SCSI_HOST *) ioc->sh->hostdata)) {
1861                                 if (hd->Targets)
1862                                         pTarget = hd->Targets[target];
1863                         }
1864
1865                         if (pTarget &&(pTarget->tflags & MPT_TARGET_FLAGS_Q_YES))
1866                                 qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
1867
1868                         /* Have the IOCTL driver set the direction based
1869                          * on the dataOutSize (ordering issue with Sparc).
1870                          */
1871                         if (karg.dataOutSize > 0) {
1872                                 scsidir = MPI_SCSIIO_CONTROL_WRITE;
1873                                 dataSize = karg.dataOutSize;
1874                         } else {
1875                                 scsidir = MPI_SCSIIO_CONTROL_READ;
1876                                 dataSize = karg.dataInSize;
1877                         }
1878
1879                         pScsiReq->Control = cpu_to_le32(scsidir | qtag);
1880                         pScsiReq->DataLength = cpu_to_le32(dataSize);
1881
1882                         ioc->ioctl->reset = MPTCTL_RESET_OK;
1883                         ioc->ioctl->target = target;
1884
1885                 } else {
1886                         printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1887                                 "SCSI driver is not loaded. \n",
1888                                         __FILE__, __LINE__);
1889                         rc = -EFAULT;
1890                         goto done_free_mem;
1891                 }
1892                 break;
1893
1894         case MPI_FUNCTION_SMP_PASSTHROUGH:
1895                 /* Check mf->PassthruFlags to determine if
1896                  * transfer is ImmediateMode or not.
1897                  * Immediate mode returns data in the ReplyFrame.
1898                  * Else, we are sending request and response data
1899                  * in two SGLs at the end of the mf.
1900                  */
1901                 break;
1902
1903         case MPI_FUNCTION_SATA_PASSTHROUGH:
1904                 if (!ioc->sh) {
1905                         printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1906                                 "SCSI driver is not loaded. \n",
1907                                         __FILE__, __LINE__);
1908                         rc = -EFAULT;
1909                         goto done_free_mem;
1910                 }
1911                 break;
1912
1913         case MPI_FUNCTION_RAID_ACTION:
1914                 /* Just add a SGE
1915                  */
1916                 break;
1917
1918         case MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
1919                 if (ioc->sh) {
1920                         SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
1921                         int qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
1922                         int scsidir = MPI_SCSIIO_CONTROL_READ;
1923                         int dataSize;
1924
1925                         pScsiReq->MsgFlags = mpt_msg_flags();
1926
1927                         /* verify that app has not requested
1928                          *      more sense data than driver
1929                          *      can provide, if so, reset this parameter
1930                          * set the sense buffer pointer low address
1931                          * update the control field to specify Q type
1932                          */
1933                         if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1934                                 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1935                         else
1936                                 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1937
1938                         pScsiReq->SenseBufferLowAddr =
1939                                 cpu_to_le32(ioc->sense_buf_low_dma
1940                                    + (req_idx * MPT_SENSE_BUFFER_ALLOC));
1941
1942                         /* All commands to physical devices are tagged
1943                          */
1944
1945                         /* Have the IOCTL driver set the direction based
1946                          * on the dataOutSize (ordering issue with Sparc).
1947                          */
1948                         if (karg.dataOutSize > 0) {
1949                                 scsidir = MPI_SCSIIO_CONTROL_WRITE;
1950                                 dataSize = karg.dataOutSize;
1951                         } else {
1952                                 scsidir = MPI_SCSIIO_CONTROL_READ;
1953                                 dataSize = karg.dataInSize;
1954                         }
1955
1956                         pScsiReq->Control = cpu_to_le32(scsidir | qtag);
1957                         pScsiReq->DataLength = cpu_to_le32(dataSize);
1958
1959                         ioc->ioctl->reset = MPTCTL_RESET_OK;
1960                         ioc->ioctl->target = pScsiReq->TargetID;
1961                 } else {
1962                         printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1963                                 "SCSI driver is not loaded. \n",
1964                                         __FILE__, __LINE__);
1965                         rc = -EFAULT;
1966                         goto done_free_mem;
1967                 }
1968                 break;
1969
1970         case MPI_FUNCTION_SCSI_TASK_MGMT:
1971                 {
1972                         MPT_SCSI_HOST *hd = NULL;
1973                         if ((ioc->sh == NULL) || ((hd = (MPT_SCSI_HOST *)ioc->sh->hostdata) == NULL)) {
1974                                 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1975                                         "SCSI driver not loaded or SCSI host not found. \n",
1976                                         __FILE__, __LINE__);
1977                                 rc = -EFAULT;
1978                                 goto done_free_mem;
1979                         } else if (mptctl_set_tm_flags(hd) != 0) {
1980                                 rc = -EPERM;
1981                                 goto done_free_mem;
1982                         }
1983                 }
1984                 break;
1985
1986         case MPI_FUNCTION_IOC_INIT:
1987                 {
1988                         IOCInit_t       *pInit = (IOCInit_t *) mf;
1989                         u32             high_addr, sense_high;
1990
1991                         /* Verify that all entries in the IOC INIT match
1992                          * existing setup (and in LE format).
1993                          */
1994                         if (sizeof(dma_addr_t) == sizeof(u64)) {
1995                                 high_addr = cpu_to_le32((u32)((u64)ioc->req_frames_dma >> 32));
1996                                 sense_high= cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
1997                         } else {
1998                                 high_addr = 0;
1999                                 sense_high= 0;
2000                         }
2001
2002                         if ((pInit->Flags != 0) || (pInit->MaxDevices != ioc->facts.MaxDevices) ||
2003                                 (pInit->MaxBuses != ioc->facts.MaxBuses) ||
2004                                 (pInit->ReplyFrameSize != cpu_to_le16(ioc->reply_sz)) ||
2005                                 (pInit->HostMfaHighAddr != high_addr) ||
2006                                 (pInit->SenseBufferHighAddr != sense_high)) {
2007                                 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2008                                         "IOC_INIT issued with 1 or more incorrect parameters. Rejected.\n",
2009                                         __FILE__, __LINE__);
2010                                 rc = -EFAULT;
2011                                 goto done_free_mem;
2012                         }
2013                 }
2014                 break;
2015         default:
2016                 /*
2017                  * MPI_FUNCTION_PORT_ENABLE
2018                  * MPI_FUNCTION_TARGET_CMD_BUFFER_POST
2019                  * MPI_FUNCTION_TARGET_ASSIST
2020                  * MPI_FUNCTION_TARGET_STATUS_SEND
2021                  * MPI_FUNCTION_TARGET_MODE_ABORT
2022                  * MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET
2023                  * MPI_FUNCTION_IO_UNIT_RESET
2024                  * MPI_FUNCTION_HANDSHAKE
2025                  * MPI_FUNCTION_REPLY_FRAME_REMOVAL
2026                  * MPI_FUNCTION_EVENT_NOTIFICATION
2027                  *  (driver handles event notification)
2028                  * MPI_FUNCTION_EVENT_ACK
2029                  */
2030
2031                 /*  What to do with these???  CHECK ME!!!
2032                         MPI_FUNCTION_FC_LINK_SRVC_BUF_POST
2033                         MPI_FUNCTION_FC_LINK_SRVC_RSP
2034                         MPI_FUNCTION_FC_ABORT
2035                         MPI_FUNCTION_LAN_SEND
2036                         MPI_FUNCTION_LAN_RECEIVE
2037                         MPI_FUNCTION_LAN_RESET
2038                 */
2039
2040                 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2041                         "Illegal request (function 0x%x) \n",
2042                         __FILE__, __LINE__, hdr->Function);
2043                 rc = -EFAULT;
2044                 goto done_free_mem;
2045         }
2046
2047         /* Add the SGL ( at most one data in SGE and one data out SGE )
2048          * In the case of two SGE's - the data out (write) will always
2049          * preceede the data in (read) SGE. psgList is used to free the
2050          * allocated memory.
2051          */
2052         psge = (char *) (((int *) mf) + karg.dataSgeOffset);
2053         flagsLength = 0;
2054
2055         /* bufIn and bufOut are used for user to kernel space transfers
2056          */
2057         bufIn.kptr = bufOut.kptr = NULL;
2058         bufIn.len = bufOut.len = 0;
2059
2060         if (karg.dataOutSize > 0)
2061                 sgSize ++;
2062
2063         if (karg.dataInSize > 0)
2064                 sgSize ++;
2065
2066         if (sgSize > 0) {
2067
2068                 /* Set up the dataOut memory allocation */
2069                 if (karg.dataOutSize > 0) {
2070                         if (karg.dataInSize > 0) {
2071                                 flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2072                                                 MPI_SGE_FLAGS_END_OF_BUFFER |
2073                                                 MPI_SGE_FLAGS_DIRECTION |
2074                                                 mpt_addr_size() )
2075                                                 << MPI_SGE_FLAGS_SHIFT;
2076                         } else {
2077                                 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
2078                         }
2079                         flagsLength |= karg.dataOutSize;
2080                         bufOut.len = karg.dataOutSize;
2081                         bufOut.kptr = pci_alloc_consistent(
2082                                         ioc->pcidev, bufOut.len, &dma_addr_out);
2083
2084                         if (bufOut.kptr == NULL) {
2085                                 rc = -ENOMEM;
2086                                 goto done_free_mem;
2087                         } else {
2088                                 /* Set up this SGE.
2089                                  * Copy to MF and to sglbuf
2090                                  */
2091                                 mpt_add_sge(psge, flagsLength, dma_addr_out);
2092                                 psge += (sizeof(u32) + sizeof(dma_addr_t));
2093
2094                                 /* Copy user data to kernel space.
2095                                  */
2096                                 if (copy_from_user(bufOut.kptr,
2097                                                 karg.dataOutBufPtr,
2098                                                 bufOut.len)) {
2099                                         printk(KERN_ERR
2100                                                 "%s@%d::mptctl_do_mpt_command - Unable "
2101                                                 "to read user data "
2102                                                 "struct @ %p\n",
2103                                                 __FILE__, __LINE__,karg.dataOutBufPtr);
2104                                         rc =  -EFAULT;
2105                                         goto done_free_mem;
2106                                 }
2107                         }
2108                 }
2109
2110                 if (karg.dataInSize > 0) {
2111                         flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
2112                         flagsLength |= karg.dataInSize;
2113
2114                         bufIn.len = karg.dataInSize;
2115                         bufIn.kptr = pci_alloc_consistent(ioc->pcidev,
2116                                         bufIn.len, &dma_addr_in);
2117
2118                         if (bufIn.kptr == NULL) {
2119                                 rc = -ENOMEM;
2120                                 goto done_free_mem;
2121                         } else {
2122                                 /* Set up this SGE
2123                                  * Copy to MF and to sglbuf
2124                                  */
2125                                 mpt_add_sge(psge, flagsLength, dma_addr_in);
2126                         }
2127                 }
2128         } else  {
2129                 /* Add a NULL SGE
2130                  */
2131                 mpt_add_sge(psge, flagsLength, (dma_addr_t) -1);
2132         }
2133
2134         ioc->ioctl->wait_done = 0;
2135         if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT) {
2136
2137                 DBG_DUMP_TM_REQUEST_FRAME((u32 *)mf);
2138
2139                 if (mpt_send_handshake_request(mptctl_id, ioc,
2140                         sizeof(SCSITaskMgmt_t), (u32*)mf,
2141                         CAN_SLEEP) != 0) {
2142                         dfailprintk((MYIOC_s_ERR_FMT "_send_handshake FAILED!"
2143                                 " (ioc %p, mf %p) \n", ioc->name,
2144                                 ioc, mf));
2145                         mptctl_free_tm_flags(ioc);
2146                         rc = -ENODATA;
2147                         goto done_free_mem;
2148                 }
2149
2150         } else
2151                 mpt_put_msg_frame(mptctl_id, ioc, mf);
2152
2153         /* Now wait for the command to complete */
2154         timeout = (karg.timeout > 0) ? karg.timeout : MPT_IOCTL_DEFAULT_TIMEOUT;
2155         timeout = wait_event_timeout(mptctl_wait,
2156              ioc->ioctl->wait_done == 1,
2157              HZ*timeout);
2158
2159         if(timeout <=0 && (ioc->ioctl->wait_done != 1 )) {
2160         /* Now we need to reset the board */
2161
2162                 if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT)
2163                         mptctl_free_tm_flags(ioc);
2164
2165                 mptctl_timeout_expired(ioc->ioctl);
2166                 rc = -ENODATA;
2167                 goto done_free_mem;
2168         }
2169
2170         mf = NULL;
2171
2172         /* If a valid reply frame, copy to the user.
2173          * Offset 2: reply length in U32's
2174          */
2175         if (ioc->ioctl->status & MPT_IOCTL_STATUS_RF_VALID) {
2176                 if (karg.maxReplyBytes < ioc->reply_sz) {
2177                          sz = min(karg.maxReplyBytes, 4*ioc->ioctl->ReplyFrame[2]);
2178                 } else {
2179                          sz = min(ioc->reply_sz, 4*ioc->ioctl->ReplyFrame[2]);
2180                 }
2181
2182                 if (sz > 0) {
2183                         if (copy_to_user(karg.replyFrameBufPtr,
2184                                  &ioc->ioctl->ReplyFrame, sz)){
2185                                  printk(KERN_ERR
2186                                      "%s@%d::mptctl_do_mpt_command - "
2187                                  "Unable to write out reply frame %p\n",
2188                                  __FILE__, __LINE__, karg.replyFrameBufPtr);
2189                                  rc =  -ENODATA;
2190                                  goto done_free_mem;
2191                         }
2192                 }
2193         }
2194
2195         /* If valid sense data, copy to user.
2196          */
2197         if (ioc->ioctl->status & MPT_IOCTL_STATUS_SENSE_VALID) {
2198                 sz = min(karg.maxSenseBytes, MPT_SENSE_BUFFER_SIZE);
2199                 if (sz > 0) {
2200                         if (copy_to_user(karg.senseDataPtr, ioc->ioctl->sense, sz)) {
2201                                 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2202                                 "Unable to write sense data to user %p\n",
2203                                 __FILE__, __LINE__,
2204                                 karg.senseDataPtr);
2205                                 rc =  -ENODATA;
2206                                 goto done_free_mem;
2207                         }
2208                 }
2209         }
2210
2211         /* If the overall status is _GOOD and data in, copy data
2212          * to user.
2213          */
2214         if ((ioc->ioctl->status & MPT_IOCTL_STATUS_COMMAND_GOOD) &&
2215                                 (karg.dataInSize > 0) && (bufIn.kptr)) {
2216
2217                 if (copy_to_user(karg.dataInBufPtr,
2218                                  bufIn.kptr, karg.dataInSize)) {
2219                         printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2220                                 "Unable to write data to user %p\n",
2221                                 __FILE__, __LINE__,
2222                                 karg.dataInBufPtr);
2223                         rc =  -ENODATA;
2224                 }
2225         }
2226
2227 done_free_mem:
2228
2229         ioc->ioctl->status &= ~(MPT_IOCTL_STATUS_COMMAND_GOOD |
2230                 MPT_IOCTL_STATUS_SENSE_VALID |
2231                 MPT_IOCTL_STATUS_RF_VALID );
2232
2233         /* Free the allocated memory.
2234          */
2235         if (bufOut.kptr != NULL) {
2236                 pci_free_consistent(ioc->pcidev,
2237                         bufOut.len, (void *) bufOut.kptr, dma_addr_out);
2238         }
2239
2240         if (bufIn.kptr != NULL) {
2241                 pci_free_consistent(ioc->pcidev,
2242                         bufIn.len, (void *) bufIn.kptr, dma_addr_in);
2243         }
2244
2245         /* mf is null if command issued successfully
2246          * otherwise, failure occured after mf acquired.
2247          */
2248         if (mf)
2249                 mpt_free_msg_frame(ioc, mf);
2250
2251         return rc;
2252 }
2253
2254 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2255 /* Prototype Routine for the HP HOST INFO command.
2256  *
2257  * Outputs:     None.
2258  * Return:      0 if successful
2259  *              -EFAULT if data unavailable
2260  *              -EBUSY  if previous command timout and IOC reset is not complete.
2261  *              -ENODEV if no such device/adapter
2262  *              -ETIME  if timer expires
2263  *              -ENOMEM if memory allocation error
2264  */
2265 static int
2266 mptctl_hp_hostinfo(unsigned long arg, unsigned int data_size)
2267 {
2268         hp_host_info_t  __user *uarg = (void __user *) arg;
2269         MPT_ADAPTER             *ioc;
2270         struct pci_dev          *pdev;
2271         char                    *pbuf;
2272         dma_addr_t              buf_dma;
2273         hp_host_info_t          karg;
2274         CONFIGPARMS             cfg;
2275         ConfigPageHeader_t      hdr;
2276         int                     iocnum;
2277         int                     rc, cim_rev;
2278
2279         dctlprintk((": mptctl_hp_hostinfo called.\n"));
2280         /* Reset long to int. Should affect IA64 and SPARC only
2281          */
2282         if (data_size == sizeof(hp_host_info_t))
2283                 cim_rev = 1;
2284         else if (data_size == sizeof(hp_host_info_rev0_t))
2285                 cim_rev = 0;    /* obsolete */
2286         else
2287                 return -EFAULT;
2288
2289         if (copy_from_user(&karg, uarg, sizeof(hp_host_info_t))) {
2290                 printk(KERN_ERR "%s@%d::mptctl_hp_host_info - "
2291                         "Unable to read in hp_host_info struct @ %p\n",
2292                                 __FILE__, __LINE__, uarg);
2293                 return -EFAULT;
2294         }
2295
2296         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2297             (ioc == NULL)) {
2298                 dctlprintk((KERN_ERR "%s::mptctl_hp_hostinfo() @%d - ioc%d not found!\n",
2299                                 __FILE__, __LINE__, iocnum));
2300                 return -ENODEV;
2301         }
2302
2303         /* Fill in the data and return the structure to the calling
2304          * program
2305          */
2306         pdev = (struct pci_dev *) ioc->pcidev;
2307
2308         karg.vendor = pdev->vendor;
2309         karg.device = pdev->device;
2310         karg.subsystem_id = pdev->subsystem_device;
2311         karg.subsystem_vendor = pdev->subsystem_vendor;
2312         karg.devfn = pdev->devfn;
2313         karg.bus = pdev->bus->number;
2314
2315         /* Save the SCSI host no. if
2316          * SCSI driver loaded
2317          */
2318         if (ioc->sh != NULL)
2319                 karg.host_no = ioc->sh->host_no;
2320         else
2321                 karg.host_no =  -1;
2322
2323         /* Reformat the fw_version into a string
2324          */
2325         karg.fw_version[0] = ioc->facts.FWVersion.Struct.Major >= 10 ?
2326                 ((ioc->facts.FWVersion.Struct.Major / 10) + '0') : '0';
2327         karg.fw_version[1] = (ioc->facts.FWVersion.Struct.Major % 10 ) + '0';
2328         karg.fw_version[2] = '.';
2329         karg.fw_version[3] = ioc->facts.FWVersion.Struct.Minor >= 10 ?
2330                 ((ioc->facts.FWVersion.Struct.Minor / 10) + '0') : '0';
2331         karg.fw_version[4] = (ioc->facts.FWVersion.Struct.Minor % 10 ) + '0';
2332         karg.fw_version[5] = '.';
2333         karg.fw_version[6] = ioc->facts.FWVersion.Struct.Unit >= 10 ?
2334                 ((ioc->facts.FWVersion.Struct.Unit / 10) + '0') : '0';
2335         karg.fw_version[7] = (ioc->facts.FWVersion.Struct.Unit % 10 ) + '0';
2336         karg.fw_version[8] = '.';
2337         karg.fw_version[9] = ioc->facts.FWVersion.Struct.Dev >= 10 ?
2338                 ((ioc->facts.FWVersion.Struct.Dev / 10) + '0') : '0';
2339         karg.fw_version[10] = (ioc->facts.FWVersion.Struct.Dev % 10 ) + '0';
2340         karg.fw_version[11] = '\0';
2341
2342         /* Issue a config request to get the device serial number
2343          */
2344         hdr.PageVersion = 0;
2345         hdr.PageLength = 0;
2346         hdr.PageNumber = 0;
2347         hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
2348         cfg.cfghdr.hdr = &hdr;
2349         cfg.physAddr = -1;
2350         cfg.pageAddr = 0;
2351         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2352         cfg.dir = 0;    /* read */
2353         cfg.timeout = 10;
2354
2355         strncpy(karg.serial_number, " ", 24);
2356         if (mpt_config(ioc, &cfg) == 0) {
2357                 if (cfg.cfghdr.hdr->PageLength > 0) {
2358                         /* Issue the second config page request */
2359                         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2360
2361                         pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
2362                         if (pbuf) {
2363                                 cfg.physAddr = buf_dma;
2364                                 if (mpt_config(ioc, &cfg) == 0) {
2365                                         ManufacturingPage0_t *pdata = (ManufacturingPage0_t *) pbuf;
2366                                         if (strlen(pdata->BoardTracerNumber) > 1) {
2367                                                 strncpy(karg.serial_number,                                                                         pdata->BoardTracerNumber, 24);
2368                                                 karg.serial_number[24-1]='\0';
2369                                         }
2370                                 }
2371                                 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
2372                                 pbuf = NULL;
2373                         }
2374                 }
2375         }
2376         rc = mpt_GetIocState(ioc, 1);
2377         switch (rc) {
2378         case MPI_IOC_STATE_OPERATIONAL:
2379                 karg.ioc_status =  HP_STATUS_OK;
2380                 break;
2381
2382         case MPI_IOC_STATE_FAULT:
2383                 karg.ioc_status =  HP_STATUS_FAILED;
2384                 break;
2385
2386         case MPI_IOC_STATE_RESET:
2387         case MPI_IOC_STATE_READY:
2388         default:
2389                 karg.ioc_status =  HP_STATUS_OTHER;
2390                 break;
2391         }
2392
2393         karg.base_io_addr = pci_resource_start(pdev, 0);
2394
2395         if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
2396                 karg.bus_phys_width = HP_BUS_WIDTH_UNK;
2397         else
2398                 karg.bus_phys_width = HP_BUS_WIDTH_16;
2399
2400         karg.hard_resets = 0;
2401         karg.soft_resets = 0;
2402         karg.timeouts = 0;
2403         if (ioc->sh != NULL) {
2404                 MPT_SCSI_HOST *hd =  (MPT_SCSI_HOST *)ioc->sh->hostdata;
2405
2406                 if (hd && (cim_rev == 1)) {
2407                         karg.hard_resets = hd->hard_resets;
2408                         karg.soft_resets = hd->soft_resets;
2409                         karg.timeouts = hd->timeouts;
2410                 }
2411         }
2412
2413         cfg.pageAddr = 0;
2414         cfg.action = MPI_TOOLBOX_ISTWI_READ_WRITE_TOOL;
2415         cfg.dir = MPI_TB_ISTWI_FLAGS_READ;
2416         cfg.timeout = 10;
2417         pbuf = pci_alloc_consistent(ioc->pcidev, 4, &buf_dma);
2418         if (pbuf) {
2419                 cfg.physAddr = buf_dma;
2420                 if ((mpt_toolbox(ioc, &cfg)) == 0) {
2421                         karg.rsvd = *(u32 *)pbuf;
2422                 }
2423                 pci_free_consistent(ioc->pcidev, 4, pbuf, buf_dma);
2424                 pbuf = NULL;
2425         }
2426
2427         /* Copy the data from kernel memory to user memory
2428          */
2429         if (copy_to_user((char __user *)arg, &karg, sizeof(hp_host_info_t))) {
2430                 printk(KERN_ERR "%s@%d::mptctl_hpgethostinfo - "
2431                         "Unable to write out hp_host_info @ %p\n",
2432                                 __FILE__, __LINE__, uarg);
2433                 return -EFAULT;
2434         }
2435
2436         return 0;
2437
2438 }
2439
2440 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2441 /* Prototype Routine for the HP TARGET INFO command.
2442  *
2443  * Outputs:     None.
2444  * Return:      0 if successful
2445  *              -EFAULT if data unavailable
2446  *              -EBUSY  if previous command timout and IOC reset is not complete.
2447  *              -ENODEV if no such device/adapter
2448  *              -ETIME  if timer expires
2449  *              -ENOMEM if memory allocation error
2450  */
2451 static int
2452 mptctl_hp_targetinfo(unsigned long arg)
2453 {
2454         hp_target_info_t __user *uarg = (void __user *) arg;
2455         SCSIDevicePage0_t       *pg0_alloc;
2456         SCSIDevicePage3_t       *pg3_alloc;
2457         MPT_ADAPTER             *ioc;
2458         MPT_SCSI_HOST           *hd = NULL;
2459         hp_target_info_t        karg;
2460         int                     iocnum;
2461         int                     data_sz;
2462         dma_addr_t              page_dma;
2463         CONFIGPARMS             cfg;
2464         ConfigPageHeader_t      hdr;
2465         int                     tmp, np, rc = 0;
2466
2467         dctlprintk((": mptctl_hp_targetinfo called.\n"));
2468         if (copy_from_user(&karg, uarg, sizeof(hp_target_info_t))) {
2469                 printk(KERN_ERR "%s@%d::mptctl_hp_targetinfo - "
2470                         "Unable to read in hp_host_targetinfo struct @ %p\n",
2471                                 __FILE__, __LINE__, uarg);
2472                 return -EFAULT;
2473         }
2474
2475         if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2476                 (ioc == NULL)) {
2477                 dctlprintk((KERN_ERR "%s::mptctl_hp_targetinfo() @%d - ioc%d not found!\n",
2478                                 __FILE__, __LINE__, iocnum));
2479                 return -ENODEV;
2480         }
2481
2482         /*  There is nothing to do for FCP parts.
2483          */
2484         if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
2485                 return 0;
2486
2487         if ((ioc->spi_data.sdp0length == 0) || (ioc->sh == NULL))
2488                 return 0;
2489
2490         if (ioc->sh->host_no != karg.hdr.host)
2491                 return -ENODEV;
2492
2493        /* Get the data transfer speeds
2494         */
2495         data_sz = ioc->spi_data.sdp0length * 4;
2496         pg0_alloc = (SCSIDevicePage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
2497         if (pg0_alloc) {
2498                 hdr.PageVersion = ioc->spi_data.sdp0version;
2499                 hdr.PageLength = data_sz;
2500                 hdr.PageNumber = 0;
2501                 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2502
2503                 cfg.cfghdr.hdr = &hdr;
2504                 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2505                 cfg.dir = 0;
2506                 cfg.timeout = 0;
2507                 cfg.physAddr = page_dma;
2508
2509                 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2510
2511                 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2512                         np = le32_to_cpu(pg0_alloc->NegotiatedParameters);
2513                         karg.negotiated_width = np & MPI_SCSIDEVPAGE0_NP_WIDE ?
2514                                         HP_BUS_WIDTH_16 : HP_BUS_WIDTH_8;
2515
2516                         if (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) {
2517                                 tmp = (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> 8;
2518                                 if (tmp < 0x09)
2519                                         karg.negotiated_speed = HP_DEV_SPEED_ULTRA320;
2520                                 else if (tmp <= 0x09)
2521                                         karg.negotiated_speed = HP_DEV_SPEED_ULTRA160;
2522                                 else if (tmp <= 0x0A)
2523                                         karg.negotiated_speed = HP_DEV_SPEED_ULTRA2;
2524                                 else if (tmp <= 0x0C)
2525                                         karg.negotiated_speed = HP_DEV_SPEED_ULTRA;
2526                                 else if (tmp <= 0x25)
2527                                         karg.negotiated_speed = HP_DEV_SPEED_FAST;
2528                                 else
2529                                         karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2530                         } else
2531                                 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2532                 }
2533
2534                 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg0_alloc, page_dma);
2535         }
2536
2537         /* Set defaults
2538          */
2539         karg.message_rejects = -1;
2540         karg.phase_errors = -1;
2541         karg.parity_errors = -1;
2542         karg.select_timeouts = -1;
2543
2544         /* Get the target error parameters
2545          */
2546         hdr.PageVersion = 0;
2547         hdr.PageLength = 0;
2548         hdr.PageNumber = 3;
2549         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2550
2551         cfg.cfghdr.hdr = &hdr;
2552         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2553         cfg.dir = 0;
2554         cfg.timeout = 0;
2555         cfg.physAddr = -1;
2556         if ((mpt_config(ioc, &cfg) == 0) && (cfg.cfghdr.hdr->PageLength > 0)) {
2557                 /* Issue the second config page request */
2558                 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2559                 data_sz = (int) cfg.cfghdr.hdr->PageLength * 4;
2560                 pg3_alloc = (SCSIDevicePage3_t *) pci_alloc_consistent(
2561                                                         ioc->pcidev, data_sz, &page_dma);
2562                 if (pg3_alloc) {
2563                         cfg.physAddr = page_dma;
2564                         cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2565                         if ((rc = mpt_config(ioc, &cfg)) == 0) {
2566                                 karg.message_rejects = (u32) le16_to_cpu(pg3_alloc->MsgRejectCount);
2567                                 karg.phase_errors = (u32) le16_to_cpu(pg3_alloc->PhaseErrorCount);
2568                                 karg.parity_errors = (u32) le16_to_cpu(pg3_alloc->ParityErrorCount);
2569                         }
2570                         pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg3_alloc, page_dma);
2571                 }
2572         }
2573         hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
2574         if (hd != NULL)
2575                 karg.select_timeouts = hd->sel_timeout[karg.hdr.id];
2576
2577         /* Copy the data from kernel memory to user memory
2578          */
2579         if (copy_to_user((char __user *)arg, &karg, sizeof(hp_target_info_t))) {
2580                 printk(KERN_ERR "%s@%d::mptctl_hp_target_info - "
2581                         "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
2582                                 __FILE__, __LINE__, uarg);
2583                 return -EFAULT;
2584         }
2585
2586         return 0;
2587 }
2588
2589 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2590
2591 static struct file_operations mptctl_fops = {
2592         .owner =        THIS_MODULE,
2593         .llseek =       no_llseek,
2594         .unlocked_ioctl = mptctl_ioctl,
2595 #ifdef CONFIG_COMPAT
2596         .compat_ioctl = compat_mpctl_ioctl,
2597 #endif
2598 };
2599
2600 static struct miscdevice mptctl_miscdev = {
2601         MPT_MINOR,
2602         MYNAM,
2603         &mptctl_fops
2604 };
2605
2606 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2607
2608 #ifdef CONFIG_COMPAT
2609
2610 static int
2611 compat_mptfwxfer_ioctl(struct file *filp, unsigned int cmd,
2612                         unsigned long arg)
2613 {
2614         struct mpt_fw_xfer32 kfw32;
2615         struct mpt_fw_xfer kfw;
2616         MPT_ADAPTER *iocp = NULL;
2617         int iocnum, iocnumX;
2618         int nonblock = (filp->f_flags & O_NONBLOCK);
2619         int ret;
2620
2621         dctlprintk((KERN_INFO MYNAM "::compat_mptfwxfer_ioctl() called\n"));
2622
2623         if (copy_from_user(&kfw32, (char __user *)arg, sizeof(kfw32)))
2624                 return -EFAULT;
2625
2626         /* Verify intended MPT adapter */
2627         iocnumX = kfw32.iocnum & 0xFF;
2628         if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2629             (iocp == NULL)) {
2630                 dctlprintk((KERN_ERR MYNAM "::compat_mptfwxfer_ioctl @%d - ioc%d not found!\n",
2631                                 __LINE__, iocnumX));
2632                 return -ENODEV;
2633         }
2634
2635         if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2636                 return ret;
2637
2638         kfw.iocnum = iocnum;
2639         kfw.fwlen = kfw32.fwlen;
2640         kfw.bufp = compat_ptr(kfw32.bufp);
2641
2642         ret = mptctl_do_fw_download(kfw.iocnum, kfw.bufp, kfw.fwlen);
2643
2644         mutex_unlock(&iocp->ioctl->ioctl_mutex);
2645
2646         return ret;
2647 }
2648
2649 static int
2650 compat_mpt_command(struct file *filp, unsigned int cmd,
2651                         unsigned long arg)
2652 {
2653         struct mpt_ioctl_command32 karg32;
2654         struct mpt_ioctl_command32 __user *uarg = (struct mpt_ioctl_command32 __user *) arg;
2655         struct mpt_ioctl_command karg;
2656         MPT_ADAPTER *iocp = NULL;
2657         int iocnum, iocnumX;
2658         int nonblock = (filp->f_flags & O_NONBLOCK);
2659         int ret;
2660
2661         dctlprintk((KERN_INFO MYNAM "::compat_mpt_command() called\n"));
2662
2663         if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32)))
2664                 return -EFAULT;
2665
2666         /* Verify intended MPT adapter */
2667         iocnumX = karg32.hdr.iocnum & 0xFF;
2668         if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2669             (iocp == NULL)) {
2670                 dctlprintk((KERN_ERR MYNAM "::compat_mpt_command @%d - ioc%d not found!\n",
2671                                 __LINE__, iocnumX));
2672                 return -ENODEV;
2673         }
2674
2675         if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2676                 return ret;
2677
2678         /* Copy data to karg */
2679         karg.hdr.iocnum = karg32.hdr.iocnum;
2680         karg.hdr.port = karg32.hdr.port;
2681         karg.timeout = karg32.timeout;
2682         karg.maxReplyBytes = karg32.maxReplyBytes;
2683
2684         karg.dataInSize = karg32.dataInSize;
2685         karg.dataOutSize = karg32.dataOutSize;
2686         karg.maxSenseBytes = karg32.maxSenseBytes;
2687         karg.dataSgeOffset = karg32.dataSgeOffset;
2688
2689         karg.replyFrameBufPtr = (char __user *)(unsigned long)karg32.replyFrameBufPtr;
2690         karg.dataInBufPtr = (char __user *)(unsigned long)karg32.dataInBufPtr;
2691         karg.dataOutBufPtr = (char __user *)(unsigned long)karg32.dataOutBufPtr;
2692         karg.senseDataPtr = (char __user *)(unsigned long)karg32.senseDataPtr;
2693
2694         /* Pass new structure to do_mpt_command
2695          */
2696         ret = mptctl_do_mpt_command (karg, &uarg->MF);
2697
2698         mutex_unlock(&iocp->ioctl->ioctl_mutex);
2699
2700         return ret;
2701 }
2702
2703 static long compat_mpctl_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
2704 {
2705         long ret;
2706         lock_kernel();
2707         switch (cmd) {
2708         case MPTIOCINFO:
2709         case MPTIOCINFO1:
2710         case MPTIOCINFO2:
2711         case MPTTARGETINFO:
2712         case MPTEVENTQUERY:
2713         case MPTEVENTENABLE:
2714         case MPTEVENTREPORT:
2715         case MPTHARDRESET:
2716         case HP_GETHOSTINFO:
2717         case HP_GETTARGETINFO:
2718         case MPTTEST:
2719                 ret = __mptctl_ioctl(f, cmd, arg);
2720                 break;
2721         case MPTCOMMAND32:
2722                 ret = compat_mpt_command(f, cmd, arg);
2723                 break;
2724         case MPTFWDOWNLOAD32:
2725                 ret = compat_mptfwxfer_ioctl(f, cmd, arg);
2726                 break;
2727         default:
2728                 ret = -ENOIOCTLCMD;
2729                 break;
2730         }
2731         unlock_kernel();
2732         return ret;
2733 }
2734
2735 #endif
2736
2737
2738 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2739 /*
2740  *      mptctl_probe - Installs ioctl devices per bus.
2741  *      @pdev: Pointer to pci_dev structure
2742  *
2743  *      Returns 0 for success, non-zero for failure.
2744  *
2745  */
2746
2747 static int
2748 mptctl_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2749 {
2750         int err;
2751         int sz;
2752         u8 *mem;
2753         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
2754
2755         /*
2756          * Allocate and inite a MPT_IOCTL structure
2757         */
2758         sz = sizeof (MPT_IOCTL);
2759         mem = kmalloc(sz, GFP_KERNEL);
2760         if (mem == NULL) {
2761                 err = -ENOMEM;
2762                 goto out_fail;
2763         }
2764
2765         memset(mem, 0, sz);
2766         ioc->ioctl = (MPT_IOCTL *) mem;
2767         ioc->ioctl->ioc = ioc;
2768         mutex_init(&ioc->ioctl->ioctl_mutex);
2769         return 0;
2770
2771 out_fail:
2772
2773         mptctl_remove(pdev);
2774         return err;
2775 }
2776
2777 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2778 /*
2779  *      mptctl_remove - Removed ioctl devices
2780  *      @pdev: Pointer to pci_dev structure
2781  *
2782  *
2783  */
2784 static void
2785 mptctl_remove(struct pci_dev *pdev)
2786 {
2787         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
2788
2789         kfree ( ioc->ioctl );
2790 }
2791
2792 static struct mpt_pci_driver mptctl_driver = {
2793   .probe                = mptctl_probe,
2794   .remove               = mptctl_remove,
2795 };
2796
2797 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2798 static int __init mptctl_init(void)
2799 {
2800         int err;
2801         int where = 1;
2802
2803         show_mptmod_ver(my_NAME, my_VERSION);
2804
2805         if(mpt_device_driver_register(&mptctl_driver,
2806           MPTCTL_DRIVER) != 0 ) {
2807                 dprintk((KERN_INFO MYNAM
2808                 ": failed to register dd callbacks\n"));
2809         }
2810
2811         /* Register this device */
2812         err = misc_register(&mptctl_miscdev);
2813         if (err < 0) {
2814                 printk(KERN_ERR MYNAM ": Can't register misc device [minor=%d].\n", MPT_MINOR);
2815                 goto out_fail;
2816         }
2817         printk(KERN_INFO MYNAM ": Registered with Fusion MPT base driver\n");
2818         printk(KERN_INFO MYNAM ": /dev/%s @ (major,minor=%d,%d)\n",
2819                          mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
2820
2821         /*
2822          *  Install our handler
2823          */
2824         ++where;
2825         if ((mptctl_id = mpt_register(mptctl_reply, MPTCTL_DRIVER)) < 0) {
2826                 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
2827                 misc_deregister(&mptctl_miscdev);
2828                 err = -EBUSY;
2829                 goto out_fail;
2830         }
2831
2832         if (mpt_reset_register(mptctl_id, mptctl_ioc_reset) == 0) {
2833                 dprintk((KERN_INFO MYNAM ": Registered for IOC reset notifications\n"));
2834         } else {
2835                 /* FIXME! */
2836         }
2837
2838         return 0;
2839
2840 out_fail:
2841
2842         mpt_device_driver_deregister(MPTCTL_DRIVER);
2843
2844         return err;
2845 }
2846
2847 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2848 static void mptctl_exit(void)
2849 {
2850         misc_deregister(&mptctl_miscdev);
2851         printk(KERN_INFO MYNAM ": Deregistered /dev/%s @ (major,minor=%d,%d)\n",
2852                          mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
2853
2854         /* De-register reset handler from base module */
2855         mpt_reset_deregister(mptctl_id);
2856         dprintk((KERN_INFO MYNAM ": Deregistered for IOC reset notifications\n"));
2857
2858         /* De-register callback handler from base module */
2859         mpt_deregister(mptctl_id);
2860         printk(KERN_INFO MYNAM ": Deregistered from Fusion MPT base driver\n");
2861
2862         mpt_device_driver_deregister(MPTCTL_DRIVER);
2863
2864 }
2865
2866 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2867
2868 module_init(mptctl_init);
2869 module_exit(mptctl_exit);