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