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