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

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