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