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