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

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