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