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