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