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