2 * linux/drivers/message/fusion/mptctl.c
4 * For use with LSI PCI chip/adapters
5 * running LSI Fusion MPT (Message Passing Technology) firmware.
7 * Copyright (c) 1999-2008 LSI Corporation
8 * (mailto:DL-MPTFusionLinux@lsi.com)
11 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
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.
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.
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.
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
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
46 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
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>
61 #include <asm/uaccess.h>
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>
69 #define COPYRIGHT "Copyright (c) 1999-2008 LSI Corporation"
70 #define MODULEAUTHOR "LSI Corporation"
74 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
75 #define my_NAME "Fusion MPT misc device (ioctl) driver"
76 #define my_VERSION MPT_LINUX_VERSION_COMMON
77 #define MYNAM "mptctl"
79 MODULE_AUTHOR(MODULEAUTHOR);
80 MODULE_DESCRIPTION(my_NAME);
81 MODULE_LICENSE("GPL");
82 MODULE_VERSION(my_VERSION);
84 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
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;
90 static DECLARE_WAIT_QUEUE_HEAD ( mptctl_wait );
92 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
100 * Function prototypes. Called from OS entry point mptctl_ioctl.
101 * arg contents specific to function.
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);
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);
117 static int mptctl_probe(struct pci_dev *, const struct pci_device_id *);
118 static void mptctl_remove(struct pci_dev *);
121 static long compat_mpctl_ioctl(struct file *f, unsigned cmd, unsigned long arg);
124 * Private function calls.
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);
134 * Reset Handler cleanup function
136 static int mptctl_ioc_reset(MPT_ADAPTER *ioc, int reset_phase);
139 * Event Handler function
141 static int mptctl_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
142 static struct fasync_struct *async_queue=NULL;
144 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
146 * Scatter gather list (SGL) sizes and limits...
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)
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)
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)
162 /* linux only seems to ever give 128kB MAX contiguous (GFP_USER) mem bytes */
163 #define MAX_KMALLOC_SZ (128*1024)
165 #define MPT_IOCTL_DEFAULT_TIMEOUT 10 /* Default timeout value (seconds) */
167 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
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
173 * All of the ioctl commands can potentially sleep, which is illegal
174 * with a spinlock held, thus we perform mutual exclusion here.
176 * Returns negative errno on error, or zero for success.
179 mptctl_syscall_down(MPT_ADAPTER *ioc, int nonblock)
184 if (!mutex_trylock(&ioc->ioctl_cmds.mutex))
187 if (mutex_lock_interruptible(&ioc->ioctl_cmds.mutex))
193 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
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
198 * This runs in irq context so be short and sweet.
201 mptctl_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply)
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,
215 * Handling continuation of the same reply. Processing the first
216 * reply, and eating the other replys that come later.
218 if (ioc->ioctl_cmds.msg_context != req->u.hdr.MsgContext)
219 goto out_continuation;
221 ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
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);
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)));
236 if ((req->u.hdr.Function == MPI_FUNCTION_SCSI_IO_REQUEST) ||
237 (req->u.hdr.Function ==
238 MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
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)));
249 if (reply->u.sreply.SCSIState &
250 MPI_SCSI_STATE_AUTOSENSE_VALID) {
251 sz = req->u.scsireq.SenseBufferLength;
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;
262 /* We are done, issue wake up
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);
272 ioc->ioctl_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
273 complete(&ioc->ioctl_cmds.done);
278 if (reply && (reply->u.reply.MsgFlags &
279 MPI_MSGFLAGS_CONTINUATION_REPLY))
286 mptctl_taskmgmt_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
291 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
292 "TaskMgmt completed (mf=%p, mr=%p)\n",
295 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
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));
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);
316 mptctl_do_taskmgmt(MPT_ADAPTER *ioc, u8 tm_type, u8 bus_id, u8 target_id)
319 SCSITaskMgmt_t *pScsiTm;
320 SCSITaskMgmtReply_t *pScsiTmReply;
323 unsigned long timeout;
324 unsigned long time_count;
328 mutex_lock(&ioc->taskmgmt_cmds.mutex);
329 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
330 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
336 mf = mpt_get_msg_frame(mptctl_taskmgmt_id, ioc);
339 printk(MYIOC_s_WARN_FMT "TaskMgmt, no msg frames!!\n",
341 mpt_clear_taskmgmt_in_progress_flag(ioc);
346 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
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))
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;
368 switch (ioc->bus_type) {
382 printk(MYIOC_s_DEBUG_FMT "TaskMgmt type=%d timeout=%ld\n",
383 ioc->name, tm_type, timeout));
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);
391 retval = mpt_send_handshake_request(mptctl_taskmgmt_id, ioc,
392 sizeof(SCSITaskMgmt_t), (u32 *)pScsiTm, CAN_SLEEP);
395 printk(MYIOC_s_ERR_FMT
396 "TaskMgmt send_handshake FAILED!"
397 " (ioc %p, mf %p, rc=%d) \n", ioc->name,
399 mpt_free_msg_frame(ioc, mf);
400 mpt_clear_taskmgmt_in_progress_flag(ioc);
405 /* Now wait for the command to complete */
406 ii = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done, timeout*HZ);
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)
416 retval = -1; /* return failure */
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 */
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)));
438 iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
440 if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
441 iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED ||
442 iocstatus == MPI_IOCSTATUS_SUCCESS)
445 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
446 "TaskMgmt failed\n", ioc->name));
447 retval = -1; /* return failure */
451 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
452 CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
456 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
457 /* mptctl_timeout_expired
459 * Expecting an interrupt, however timed out.
463 mptctl_timeout_expired(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
467 SCSIIORequest_t *scsi_req = (SCSIIORequest_t *) mf;
468 u8 function = mf->u.hdr.Function;
470 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": %s\n",
471 ioc->name, __func__));
473 if (mpt_fwfault_debug)
474 mpt_halt_firmware(ioc);
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);
483 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
486 CLEAR_MGMT_PENDING_STATUS(ioc->ioctl_cmds.status)
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,
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,
509 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling Reset! \n",
511 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
512 mpt_free_msg_frame(ioc, mf);
516 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
519 * Clean-up functionality. Used only if there has been a
520 * reload of the FW due.
524 mptctl_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
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__));
531 case MPT_IOC_PRE_RESET:
532 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
533 "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__));
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);
550 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
551 /* ASYNC Event Notification Support */
553 mptctl_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
557 event = le32_to_cpu(pEvReply->Event) & 0xFF;
559 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s() called\n",
560 ioc->name, __func__));
561 if(async_queue == NULL)
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
568 if (event == 0x21 ) {
569 ioc->aen_event_read_flag=1;
570 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Raised SIGIO to application\n",
572 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
573 "Raised SIGIO to application\n", ioc->name));
574 kill_fasync(&async_queue, SIGIO, POLL_IN);
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
582 if(ioc->aen_event_read_flag)
585 /* Signal only for the events that are
586 * requested for by the application
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);
600 mptctl_fasync(int fd, struct file *filep, int mode)
605 mutex_lock(&mpctl_mutex);
606 list_for_each_entry(ioc, &ioc_list, list)
607 ioc->aen_event_read_flag=0;
609 ret = fasync_helper(fd, filep, mode, &async_queue);
610 mutex_unlock(&mpctl_mutex);
614 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
617 * cmd - specify the particular IOCTL command to be issued
618 * arg - data specific to the command. Must not be null.
621 __mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
623 mpt_ioctl_header __user *uhdr = (void __user *) arg;
624 mpt_ioctl_header khdr;
627 int nonblock = (file->f_flags & O_NONBLOCK);
629 MPT_ADAPTER *iocp = NULL;
631 if (copy_from_user(&khdr, uhdr, sizeof(khdr))) {
632 printk(KERN_ERR MYNAM "%s::mptctl_ioctl() @%d - "
633 "Unable to copy mpt_ioctl_header data @ %p\n",
634 __FILE__, __LINE__, uhdr);
637 ret = -ENXIO; /* (-6) No such device or address */
639 /* Verify intended MPT adapter - set iocnum and the adapter
642 iocnumX = khdr.iocnum & 0xFF;
643 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
648 printk(KERN_DEBUG MYNAM "%s::mptctl_ioctl() @%d - Controller disabled.\n",
653 /* Handle those commands that are just returning
654 * information stored in the driver.
655 * These commands should never time out and are unaffected
656 * by TM and FW reloads.
658 if ((cmd & ~IOCSIZE_MASK) == (MPTIOCINFO & ~IOCSIZE_MASK)) {
659 return mptctl_getiocinfo(arg, _IOC_SIZE(cmd));
660 } else if (cmd == MPTTARGETINFO) {
661 return mptctl_gettargetinfo(arg);
662 } else if (cmd == MPTTEST) {
663 return mptctl_readtest(arg);
664 } else if (cmd == MPTEVENTQUERY) {
665 return mptctl_eventquery(arg);
666 } else if (cmd == MPTEVENTENABLE) {
667 return mptctl_eventenable(arg);
668 } else if (cmd == MPTEVENTREPORT) {
669 return mptctl_eventreport(arg);
670 } else if (cmd == MPTFWREPLACE) {
671 return mptctl_replace_fw(arg);
674 /* All of these commands require an interrupt or
675 * are unknown/illegal.
677 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
680 if (cmd == MPTFWDOWNLOAD)
681 ret = mptctl_fw_download(arg);
682 else if (cmd == MPTCOMMAND)
683 ret = mptctl_mpt_command(arg);
684 else if (cmd == MPTHARDRESET)
685 ret = mptctl_do_reset(arg);
686 else if ((cmd & ~IOCSIZE_MASK) == (HP_GETHOSTINFO & ~IOCSIZE_MASK))
687 ret = mptctl_hp_hostinfo(arg, _IOC_SIZE(cmd));
688 else if (cmd == HP_GETTARGETINFO)
689 ret = mptctl_hp_targetinfo(arg);
693 mutex_unlock(&iocp->ioctl_cmds.mutex);
699 mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
702 mutex_lock(&mpctl_mutex);
703 ret = __mptctl_ioctl(file, cmd, arg);
704 mutex_unlock(&mpctl_mutex);
708 static int mptctl_do_reset(unsigned long arg)
710 struct mpt_ioctl_diag_reset __user *urinfo = (void __user *) arg;
711 struct mpt_ioctl_diag_reset krinfo;
714 if (copy_from_user(&krinfo, urinfo, sizeof(struct mpt_ioctl_diag_reset))) {
715 printk(KERN_ERR MYNAM "%s@%d::mptctl_do_reset - "
716 "Unable to copy mpt_ioctl_diag_reset struct @ %p\n",
717 __FILE__, __LINE__, urinfo);
721 if (mpt_verify_adapter(krinfo.hdr.iocnum, &iocp) < 0) {
722 printk(KERN_DEBUG MYNAM "%s@%d::mptctl_do_reset - ioc%d not found!\n",
723 __FILE__, __LINE__, krinfo.hdr.iocnum);
724 return -ENODEV; /* (-6) No such device or address */
727 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "mptctl_do_reset called.\n",
730 if (mpt_HardResetHandler(iocp, CAN_SLEEP) != 0) {
731 printk (MYIOC_s_ERR_FMT "%s@%d::mptctl_do_reset - reset failed.\n",
732 iocp->name, __FILE__, __LINE__);
739 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
741 * MPT FW download function. Cast the arg into the mpt_fw_xfer structure.
742 * This structure contains: iocnum, firmware length (bytes),
743 * pointer to user space memory where the fw image is stored.
746 * Return: 0 if successful
747 * -EFAULT if data unavailable
748 * -ENXIO if no such device
749 * -EAGAIN if resource problem
750 * -ENOMEM if no memory for SGE
751 * -EMLINK if too many chain buffers required
752 * -EBADRQC if adapter does not support FW download
753 * -EBUSY if adapter is busy
754 * -ENOMSG if FW upload returned bad status
757 mptctl_fw_download(unsigned long arg)
759 struct mpt_fw_xfer __user *ufwdl = (void __user *) arg;
760 struct mpt_fw_xfer kfwdl;
762 if (copy_from_user(&kfwdl, ufwdl, sizeof(struct mpt_fw_xfer))) {
763 printk(KERN_ERR MYNAM "%s@%d::_ioctl_fwdl - "
764 "Unable to copy mpt_fw_xfer struct @ %p\n",
765 __FILE__, __LINE__, ufwdl);
769 return mptctl_do_fw_download(kfwdl.iocnum, kfwdl.bufp, kfwdl.fwlen);
772 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
774 * FW Download engine.
776 * Return: 0 if successful
777 * -EFAULT if data unavailable
778 * -ENXIO if no such device
779 * -EAGAIN if resource problem
780 * -ENOMEM if no memory for SGE
781 * -EMLINK if too many chain buffers required
782 * -EBADRQC if adapter does not support FW download
783 * -EBUSY if adapter is busy
784 * -ENOMSG if FW upload returned bad status
787 mptctl_do_fw_download(int ioc, char __user *ufwbuf, size_t fwlen)
792 FWDownloadTCSGE_t *ptsge;
793 MptSge_t *sgl, *sgIn;
795 struct buflist *buflist;
804 int fw_bytes_copied = 0;
808 pFWDownloadReply_t ReplyMsg = NULL;
809 unsigned long timeleft;
811 if (mpt_verify_adapter(ioc, &iocp) < 0) {
812 printk(KERN_DEBUG MYNAM "ioctl_fwdl - ioc%d not found!\n",
814 return -ENODEV; /* (-6) No such device or address */
817 /* Valid device. Get a message frame and construct the FW download message.
819 if ((mf = mpt_get_msg_frame(mptctl_id, iocp)) == NULL)
823 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT
824 "mptctl_do_fwdl called. mptctl_id = %xh.\n", iocp->name, mptctl_id));
825 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.bufp = %p\n",
826 iocp->name, ufwbuf));
827 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.fwlen = %d\n",
828 iocp->name, (int)fwlen));
829 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.ioc = %04xh\n",
832 dlmsg = (FWDownload_t*) mf;
833 ptsge = (FWDownloadTCSGE_t *) &dlmsg->SGL;
834 sgOut = (char *) (ptsge + 1);
837 * Construct f/w download request
839 dlmsg->ImageType = MPI_FW_DOWNLOAD_ITYPE_FW;
841 dlmsg->ChainOffset = 0;
842 dlmsg->Function = MPI_FUNCTION_FW_DOWNLOAD;
843 dlmsg->Reserved1[0] = dlmsg->Reserved1[1] = dlmsg->Reserved1[2] = 0;
844 if (iocp->facts.MsgVersion >= MPI_VERSION_01_05)
845 dlmsg->MsgFlags = MPI_FW_DOWNLOAD_MSGFLGS_LAST_SEGMENT;
850 /* Set up the Transaction SGE.
853 ptsge->ContextSize = 0;
854 ptsge->DetailsLength = 12;
855 ptsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
856 ptsge->Reserved_0100_Checksum = 0;
857 ptsge->ImageOffset = 0;
858 ptsge->ImageSize = cpu_to_le32(fwlen);
864 * Need to kmalloc area(s) for holding firmware image bytes.
865 * But we need to do it piece meal, using a proper
866 * scatter gather list (with 128kB MAX hunks).
868 * A practical limit here might be # of sg hunks that fit into
869 * a single IOC request frame; 12 or 8 (see below), so:
870 * For FC9xx: 12 x 128kB == 1.5 mB (max)
871 * For C1030: 8 x 128kB == 1 mB (max)
872 * We could support chaining, but things get ugly(ier:)
874 * Set the sge_offset to the start of the sgl (bytes).
876 sgdir = 0x04000000; /* IOC will READ from sys mem */
877 sge_offset = sizeof(MPIHeader_t) + sizeof(FWDownloadTCSGE_t);
878 if ((sgl = kbuf_alloc_2_sgl(fwlen, sgdir, sge_offset,
879 &numfrags, &buflist, &sgl_dma, iocp)) == NULL)
883 * We should only need SGL with 2 simple_32bit entries (up to 256 kB)
884 * for FC9xx f/w image, but calculate max number of sge hunks
885 * we can fit into a request frame, and limit ourselves to that.
886 * (currently no chain support)
887 * maxfrags = (Request Size - FWdownload Size ) / Size of 32 bit SGE
893 maxfrags = (iocp->req_sz - sizeof(MPIHeader_t) -
894 sizeof(FWDownloadTCSGE_t))
896 if (numfrags > maxfrags) {
901 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: sgl buffer = %p, sgfrags = %d\n",
902 iocp->name, sgl, numfrags));
905 * Parse SG list, copying sgl itself,
906 * plus f/w image hunks from user space as we go...
911 for (i=0; i < numfrags; i++) {
913 /* Get the SGE type: 0 - TCSGE, 3 - Chain, 1 - Simple SGE
914 * Skip everything but Simple. If simple, copy from
915 * user space into kernel space.
916 * Note: we should not have anything but Simple as
917 * Chain SGE are illegal.
919 nib = (sgIn->FlagsLength & 0x30000000) >> 28;
920 if (nib == 0 || nib == 3) {
922 } else if (sgIn->Address) {
923 iocp->add_sge(sgOut, sgIn->FlagsLength, sgIn->Address);
925 if (copy_from_user(bl->kptr, ufwbuf+fw_bytes_copied, bl->len)) {
926 printk(MYIOC_s_ERR_FMT "%s@%d::_ioctl_fwdl - "
927 "Unable to copy f/w buffer hunk#%d @ %p\n",
928 iocp->name, __FILE__, __LINE__, n, ufwbuf);
931 fw_bytes_copied += bl->len;
935 sgOut += iocp->SGE_size;
938 DBG_DUMP_FW_DOWNLOAD(iocp, (u32 *)mf, numfrags);
941 * Finally, perform firmware download.
944 SET_MGMT_MSG_CONTEXT(iocp->ioctl_cmds.msg_context, dlmsg->MsgContext);
945 INITIALIZE_MGMT_STATUS(iocp->ioctl_cmds.status)
946 mpt_put_msg_frame(mptctl_id, iocp, mf);
948 /* Now wait for the command to complete */
950 timeleft = wait_for_completion_timeout(&iocp->ioctl_cmds.done, HZ*60);
951 if (!(iocp->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
953 printk(MYIOC_s_WARN_FMT "%s: failed\n", iocp->name, __func__);
954 if (iocp->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
955 mpt_free_msg_frame(iocp, mf);
959 printk(MYIOC_s_WARN_FMT
960 "FW download timeout, doorbell=0x%08x\n",
961 iocp->name, mpt_GetIocState(iocp, 0));
962 mptctl_timeout_expired(iocp, mf);
968 if (!(iocp->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
969 printk(MYIOC_s_WARN_FMT "%s: failed\n", iocp->name, __func__);
970 mpt_free_msg_frame(iocp, mf);
976 kfree_sgl(sgl, sgl_dma, buflist, iocp);
978 ReplyMsg = (pFWDownloadReply_t)iocp->ioctl_cmds.reply;
979 iocstat = le16_to_cpu(ReplyMsg->IOCStatus) & MPI_IOCSTATUS_MASK;
980 if (iocstat == MPI_IOCSTATUS_SUCCESS) {
981 printk(MYIOC_s_INFO_FMT "F/W update successful!\n", iocp->name);
983 } else if (iocstat == MPI_IOCSTATUS_INVALID_FUNCTION) {
984 printk(MYIOC_s_WARN_FMT "Hmmm... F/W download not supported!?!\n",
986 printk(MYIOC_s_WARN_FMT "(time to go bang on somebodies door)\n",
989 } else if (iocstat == MPI_IOCSTATUS_BUSY) {
990 printk(MYIOC_s_WARN_FMT "IOC_BUSY!\n", iocp->name);
991 printk(MYIOC_s_WARN_FMT "(try again later?)\n", iocp->name);
994 printk(MYIOC_s_WARN_FMT "ioctl_fwdl() returned [bad] status = %04xh\n",
995 iocp->name, iocstat);
996 printk(MYIOC_s_WARN_FMT "(bad VooDoo)\n", iocp->name);
1003 CLEAR_MGMT_STATUS(iocp->ioctl_cmds.status);
1004 SET_MGMT_MSG_CONTEXT(iocp->ioctl_cmds.msg_context, 0);
1005 kfree_sgl(sgl, sgl_dma, buflist, iocp);
1009 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1011 * SGE Allocation routine
1013 * Inputs: bytes - number of bytes to be transferred
1014 * sgdir - data direction
1015 * sge_offset - offset (in bytes) from the start of the request
1016 * frame to the first SGE
1017 * ioc - pointer to the mptadapter
1018 * Outputs: frags - number of scatter gather elements
1019 * blp - point to the buflist pointer
1020 * sglbuf_dma - pointer to the (dma) sgl
1021 * Returns: Null if failes
1022 * pointer to the (virtual) sgl if successful.
1025 kbuf_alloc_2_sgl(int bytes, u32 sgdir, int sge_offset, int *frags,
1026 struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc)
1028 MptSge_t *sglbuf = NULL; /* pointer to array of SGE */
1029 /* and chain buffers */
1030 struct buflist *buflist = NULL; /* kernel routine */
1034 int alloc_sz = min(bytes,MAX_KMALLOC_SZ); // avoid kernel warning msg!
1035 int bytes_allocd = 0;
1037 dma_addr_t pa; // phys addr
1039 int sg_spill = MAX_FRAGS_SPILL1;
1041 /* initialization */
1045 /* Allocate and initialize an array of kernel
1046 * structures for the SG elements.
1048 i = MAX_SGL_BYTES / 8;
1049 buflist = kzalloc(i, GFP_USER);
1054 /* Allocate a single block of memory to store the sg elements and
1055 * the chain buffers. The calling routine is responsible for
1056 * copying the data in this array into the correct place in the
1057 * request and chain buffers.
1059 sglbuf = pci_alloc_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf_dma);
1063 if (sgdir & 0x04000000)
1064 dir = PCI_DMA_TODEVICE;
1066 dir = PCI_DMA_FROMDEVICE;
1069 * sgl = sglbuf = point to beginning of sg buffer
1070 * buflist_ent = 0 = first kernel structure
1071 * sg_spill = number of SGE that can be written before the first
1076 sg_spill = ((ioc->req_sz - sge_offset)/ioc->SGE_size) - 1;
1077 while (bytes_allocd < bytes) {
1078 this_alloc = min(alloc_sz, bytes-bytes_allocd);
1079 buflist[buflist_ent].len = this_alloc;
1080 buflist[buflist_ent].kptr = pci_alloc_consistent(ioc->pcidev,
1083 if (buflist[buflist_ent].kptr == NULL) {
1084 alloc_sz = alloc_sz / 2;
1085 if (alloc_sz == 0) {
1086 printk(MYIOC_s_WARN_FMT "-SG: No can do - "
1087 "not enough memory! :-(\n", ioc->name);
1088 printk(MYIOC_s_WARN_FMT "-SG: (freeing %d frags)\n",
1089 ioc->name, numfrags);
1094 dma_addr_t dma_addr;
1096 bytes_allocd += this_alloc;
1097 sgl->FlagsLength = (0x10000000|sgdir|this_alloc);
1098 dma_addr = pci_map_single(ioc->pcidev,
1099 buflist[buflist_ent].kptr, this_alloc, dir);
1100 sgl->Address = dma_addr;
1108 if (bytes_allocd >= bytes)
1111 /* Need to chain? */
1112 if (fragcnt == sg_spill) {
1113 printk(MYIOC_s_WARN_FMT
1114 "-SG: No can do - " "Chain required! :-(\n", ioc->name);
1115 printk(MYIOC_s_WARN_FMT "(freeing %d frags)\n", ioc->name, numfrags);
1119 /* overflow check... */
1120 if (numfrags*8 > MAX_SGL_BYTES){
1122 printk(MYIOC_s_WARN_FMT "-SG: No can do - "
1123 "too many SG frags! :-(\n", ioc->name);
1124 printk(MYIOC_s_WARN_FMT "-SG: (freeing %d frags)\n",
1125 ioc->name, numfrags);
1130 /* Last sge fixup: set LE+eol+eob bits */
1131 sgl[-1].FlagsLength |= 0xC1000000;
1136 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: kbuf_alloc_2_sgl() - "
1137 "%d SG frags generated!\n", ioc->name, numfrags));
1139 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: kbuf_alloc_2_sgl() - "
1140 "last (big) alloc_sz=%d\n", ioc->name, alloc_sz));
1145 if (sglbuf != NULL) {
1146 for (i = 0; i < numfrags; i++) {
1147 dma_addr_t dma_addr;
1151 if ((sglbuf[i].FlagsLength >> 24) == 0x30)
1154 dma_addr = sglbuf[i].Address;
1155 kptr = buflist[i].kptr;
1156 len = buflist[i].len;
1158 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1160 pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf, *sglbuf_dma);
1166 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1168 * Routine to free the SGL elements.
1171 kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma, struct buflist *buflist, MPT_ADAPTER *ioc)
1174 struct buflist *bl = buflist;
1179 if (sg->FlagsLength & 0x04000000)
1180 dir = PCI_DMA_TODEVICE;
1182 dir = PCI_DMA_FROMDEVICE;
1184 nib = (sg->FlagsLength & 0xF0000000) >> 28;
1185 while (! (nib & 0x4)) { /* eob */
1186 /* skip ignore/chain. */
1187 if (nib == 0 || nib == 3) {
1189 } else if (sg->Address) {
1190 dma_addr_t dma_addr;
1194 dma_addr = sg->Address;
1197 pci_unmap_single(ioc->pcidev, dma_addr, len, dir);
1198 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1203 nib = (le32_to_cpu(sg->FlagsLength) & 0xF0000000) >> 28;
1208 dma_addr_t dma_addr;
1212 dma_addr = sg->Address;
1215 pci_unmap_single(ioc->pcidev, dma_addr, len, dir);
1216 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1220 pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sgl, sgl_dma);
1222 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: Free'd 1 SGL buf + %d kbufs!\n",
1226 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1228 * mptctl_getiocinfo - Query the host adapter for IOC information.
1229 * @arg: User space argument
1232 * Return: 0 if successful
1233 * -EFAULT if data unavailable
1234 * -ENODEV if no such device/adapter
1237 mptctl_getiocinfo (unsigned long arg, unsigned int data_size)
1239 struct mpt_ioctl_iocinfo __user *uarg = (void __user *) arg;
1240 struct mpt_ioctl_iocinfo *karg;
1242 struct pci_dev *pdev;
1246 struct scsi_device *sdev;
1247 VirtDevice *vdevice;
1249 /* Add of PCI INFO results in unaligned access for
1250 * IA64 and Sparc. Reset long to int. Return no PCI
1251 * data for obsolete format.
1253 if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev0))
1255 else if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev1))
1257 else if (data_size == sizeof(struct mpt_ioctl_iocinfo))
1259 else if (data_size == (sizeof(struct mpt_ioctl_iocinfo_rev0)+12))
1260 cim_rev = 0; /* obsolete */
1264 karg = memdup_user(uarg, data_size);
1266 printk(KERN_ERR MYNAM "%s@%d::mpt_ioctl_iocinfo() - memdup_user returned error [%ld]\n",
1267 __FILE__, __LINE__, PTR_ERR(karg));
1268 return PTR_ERR(karg);
1271 if (((iocnum = mpt_verify_adapter(karg->hdr.iocnum, &ioc)) < 0) ||
1273 printk(KERN_DEBUG MYNAM "%s::mptctl_getiocinfo() @%d - ioc%d not found!\n",
1274 __FILE__, __LINE__, iocnum);
1279 /* Verify the data transfer size is correct. */
1280 if (karg->hdr.maxDataSize != data_size) {
1281 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_getiocinfo - "
1282 "Structure size mismatch. Command not completed.\n",
1283 ioc->name, __FILE__, __LINE__);
1288 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_getiocinfo called.\n",
1291 /* Fill in the data and return the structure to the calling
1294 if (ioc->bus_type == SAS)
1295 karg->adapterType = MPT_IOCTL_INTERFACE_SAS;
1296 else if (ioc->bus_type == FC)
1297 karg->adapterType = MPT_IOCTL_INTERFACE_FC;
1299 karg->adapterType = MPT_IOCTL_INTERFACE_SCSI;
1301 if (karg->hdr.port > 1) {
1305 port = karg->hdr.port;
1308 pdev = (struct pci_dev *) ioc->pcidev;
1310 karg->pciId = pdev->device;
1311 karg->hwRev = pdev->revision;
1312 karg->subSystemDevice = pdev->subsystem_device;
1313 karg->subSystemVendor = pdev->subsystem_vendor;
1316 /* Get the PCI bus, device, and function numbers for the IOC
1318 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1319 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1320 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1321 } else if (cim_rev == 2) {
1322 /* Get the PCI bus, device, function and segment ID numbers
1324 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1325 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1326 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1327 karg->pciInfo.segmentID = pci_domain_nr(pdev->bus);
1330 /* Get number of devices
1332 karg->numDevices = 0;
1334 shost_for_each_device(sdev, ioc->sh) {
1335 vdevice = sdev->hostdata;
1336 if (vdevice == NULL || vdevice->vtarget == NULL)
1338 if (vdevice->vtarget->tflags &
1339 MPT_TARGET_FLAGS_RAID_COMPONENT)
1345 /* Set the BIOS and FW Version
1347 karg->FWVersion = ioc->facts.FWVersion.Word;
1348 karg->BIOSVersion = ioc->biosVersion;
1350 /* Set the Version Strings.
1352 strncpy (karg->driverVersion, MPT_LINUX_PACKAGE_NAME, MPT_IOCTL_VERSION_LENGTH);
1353 karg->driverVersion[MPT_IOCTL_VERSION_LENGTH-1]='\0';
1355 karg->busChangeEvent = 0;
1356 karg->hostId = ioc->pfacts[port].PortSCSIID;
1357 karg->rsvd[0] = karg->rsvd[1] = 0;
1359 /* Copy the data from kernel memory to user memory
1361 if (copy_to_user((char __user *)arg, karg, data_size)) {
1362 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_getiocinfo - "
1363 "Unable to write out mpt_ioctl_iocinfo struct @ %p\n",
1364 ioc->name, __FILE__, __LINE__, uarg);
1373 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1375 * mptctl_gettargetinfo - Query the host adapter for target information.
1376 * @arg: User space argument
1379 * Return: 0 if successful
1380 * -EFAULT if data unavailable
1381 * -ENODEV if no such device/adapter
1384 mptctl_gettargetinfo (unsigned long arg)
1386 struct mpt_ioctl_targetinfo __user *uarg = (void __user *) arg;
1387 struct mpt_ioctl_targetinfo karg;
1389 VirtDevice *vdevice;
1398 struct scsi_device *sdev;
1400 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_targetinfo))) {
1401 printk(KERN_ERR MYNAM "%s@%d::mptctl_gettargetinfo - "
1402 "Unable to read in mpt_ioctl_targetinfo struct @ %p\n",
1403 __FILE__, __LINE__, uarg);
1407 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1409 printk(KERN_DEBUG MYNAM "%s::mptctl_gettargetinfo() @%d - ioc%d not found!\n",
1410 __FILE__, __LINE__, iocnum);
1414 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_gettargetinfo called.\n",
1416 /* Get the port number and set the maximum number of bytes
1417 * in the returned structure.
1418 * Ignore the port setting.
1420 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1421 maxWordsLeft = numBytes/sizeof(int);
1422 port = karg.hdr.port;
1424 if (maxWordsLeft <= 0) {
1425 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo() - no memory available!\n",
1426 ioc->name, __FILE__, __LINE__);
1430 /* Fill in the data and return the structure to the calling
1434 /* struct mpt_ioctl_targetinfo does not contain sufficient space
1435 * for the target structures so when the IOCTL is called, there is
1436 * not sufficient stack space for the structure. Allocate memory,
1437 * populate the memory, copy back to the user, then free memory.
1438 * targetInfo format:
1439 * bits 31-24: reserved
1444 pmem = kzalloc(numBytes, GFP_KERNEL);
1446 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo() - no memory available!\n",
1447 ioc->name, __FILE__, __LINE__);
1450 pdata = (int *) pmem;
1452 /* Get number of devices
1455 shost_for_each_device(sdev, ioc->sh) {
1458 vdevice = sdev->hostdata;
1459 if (vdevice == NULL || vdevice->vtarget == NULL)
1461 if (vdevice->vtarget->tflags &
1462 MPT_TARGET_FLAGS_RAID_COMPONENT)
1464 lun = (vdevice->vtarget->raidVolume) ? 0x80 : vdevice->lun;
1465 *pdata = (((u8)lun << 16) + (vdevice->vtarget->channel << 8) +
1466 (vdevice->vtarget->id ));
1472 karg.numDevices = numDevices;
1474 /* Copy part of the data from kernel memory to user memory
1476 if (copy_to_user((char __user *)arg, &karg,
1477 sizeof(struct mpt_ioctl_targetinfo))) {
1478 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo - "
1479 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1480 ioc->name, __FILE__, __LINE__, uarg);
1485 /* Copy the remaining data from kernel memory to user memory
1487 if (copy_to_user(uarg->targetInfo, pmem, numBytes)) {
1488 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo - "
1489 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1490 ioc->name, __FILE__, __LINE__, pdata);
1500 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1501 /* MPT IOCTL Test function.
1504 * Return: 0 if successful
1505 * -EFAULT if data unavailable
1506 * -ENODEV if no such device/adapter
1509 mptctl_readtest (unsigned long arg)
1511 struct mpt_ioctl_test __user *uarg = (void __user *) arg;
1512 struct mpt_ioctl_test karg;
1516 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_test))) {
1517 printk(KERN_ERR MYNAM "%s@%d::mptctl_readtest - "
1518 "Unable to read in mpt_ioctl_test struct @ %p\n",
1519 __FILE__, __LINE__, uarg);
1523 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1525 printk(KERN_DEBUG MYNAM "%s::mptctl_readtest() @%d - ioc%d not found!\n",
1526 __FILE__, __LINE__, iocnum);
1530 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_readtest called.\n",
1532 /* Fill in the data and return the structure to the calling
1537 karg.chip_type = ioc->mfcnt;
1539 karg.chip_type = ioc->pcidev->device;
1541 strncpy (karg.name, ioc->name, MPT_MAX_NAME);
1542 karg.name[MPT_MAX_NAME-1]='\0';
1543 strncpy (karg.product, ioc->prod_name, MPT_PRODUCT_LENGTH);
1544 karg.product[MPT_PRODUCT_LENGTH-1]='\0';
1546 /* Copy the data from kernel memory to user memory
1548 if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_test))) {
1549 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_readtest - "
1550 "Unable to write out mpt_ioctl_test struct @ %p\n",
1551 ioc->name, __FILE__, __LINE__, uarg);
1558 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1560 * mptctl_eventquery - Query the host adapter for the event types
1561 * that are being logged.
1562 * @arg: User space argument
1565 * Return: 0 if successful
1566 * -EFAULT if data unavailable
1567 * -ENODEV if no such device/adapter
1570 mptctl_eventquery (unsigned long arg)
1572 struct mpt_ioctl_eventquery __user *uarg = (void __user *) arg;
1573 struct mpt_ioctl_eventquery karg;
1577 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventquery))) {
1578 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventquery - "
1579 "Unable to read in mpt_ioctl_eventquery struct @ %p\n",
1580 __FILE__, __LINE__, uarg);
1584 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1586 printk(KERN_DEBUG MYNAM "%s::mptctl_eventquery() @%d - ioc%d not found!\n",
1587 __FILE__, __LINE__, iocnum);
1591 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventquery called.\n",
1593 karg.eventEntries = MPTCTL_EVENT_LOG_SIZE;
1594 karg.eventTypes = ioc->eventTypes;
1596 /* Copy the data from kernel memory to user memory
1598 if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_eventquery))) {
1599 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_eventquery - "
1600 "Unable to write out mpt_ioctl_eventquery struct @ %p\n",
1601 ioc->name, __FILE__, __LINE__, uarg);
1607 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1609 mptctl_eventenable (unsigned long arg)
1611 struct mpt_ioctl_eventenable __user *uarg = (void __user *) arg;
1612 struct mpt_ioctl_eventenable karg;
1616 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventenable))) {
1617 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventenable - "
1618 "Unable to read in mpt_ioctl_eventenable struct @ %p\n",
1619 __FILE__, __LINE__, uarg);
1623 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1625 printk(KERN_DEBUG MYNAM "%s::mptctl_eventenable() @%d - ioc%d not found!\n",
1626 __FILE__, __LINE__, iocnum);
1630 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventenable called.\n",
1632 if (ioc->events == NULL) {
1633 /* Have not yet allocated memory - do so now.
1635 int sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
1636 ioc->events = kzalloc(sz, GFP_KERNEL);
1638 printk(MYIOC_s_ERR_FMT
1639 ": ERROR - Insufficient memory to add adapter!\n",
1643 ioc->alloc_total += sz;
1645 ioc->eventContext = 0;
1648 /* Update the IOC event logging flag.
1650 ioc->eventTypes = karg.eventTypes;
1655 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1657 mptctl_eventreport (unsigned long arg)
1659 struct mpt_ioctl_eventreport __user *uarg = (void __user *) arg;
1660 struct mpt_ioctl_eventreport karg;
1663 int numBytes, maxEvents, max;
1665 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventreport))) {
1666 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventreport - "
1667 "Unable to read in mpt_ioctl_eventreport struct @ %p\n",
1668 __FILE__, __LINE__, uarg);
1672 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1674 printk(KERN_DEBUG MYNAM "%s::mptctl_eventreport() @%d - ioc%d not found!\n",
1675 __FILE__, __LINE__, iocnum);
1678 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventreport called.\n",
1681 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1682 maxEvents = numBytes/sizeof(MPT_IOCTL_EVENTS);
1685 max = MPTCTL_EVENT_LOG_SIZE < maxEvents ? MPTCTL_EVENT_LOG_SIZE : maxEvents;
1687 /* If fewer than 1 event is requested, there must have
1688 * been some type of error.
1690 if ((max < 1) || !ioc->events)
1693 /* reset this flag so SIGIO can restart */
1694 ioc->aen_event_read_flag=0;
1696 /* Copy the data from kernel memory to user memory
1698 numBytes = max * sizeof(MPT_IOCTL_EVENTS);
1699 if (copy_to_user(uarg->eventData, ioc->events, numBytes)) {
1700 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_eventreport - "
1701 "Unable to write out mpt_ioctl_eventreport struct @ %p\n",
1702 ioc->name, __FILE__, __LINE__, ioc->events);
1709 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1711 mptctl_replace_fw (unsigned long arg)
1713 struct mpt_ioctl_replace_fw __user *uarg = (void __user *) arg;
1714 struct mpt_ioctl_replace_fw karg;
1719 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_replace_fw))) {
1720 printk(KERN_ERR MYNAM "%s@%d::mptctl_replace_fw - "
1721 "Unable to read in mpt_ioctl_replace_fw struct @ %p\n",
1722 __FILE__, __LINE__, uarg);
1726 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1728 printk(KERN_DEBUG MYNAM "%s::mptctl_replace_fw() @%d - ioc%d not found!\n",
1729 __FILE__, __LINE__, iocnum);
1733 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_replace_fw called.\n",
1735 /* If caching FW, Free the old FW image
1737 if (ioc->cached_fw == NULL)
1740 mpt_free_fw_memory(ioc);
1742 /* Allocate memory for the new FW image
1744 newFwSize = ALIGN(karg.newImageSize, 4);
1746 mpt_alloc_fw_memory(ioc, newFwSize);
1747 if (ioc->cached_fw == NULL)
1750 /* Copy the data from user memory to kernel space
1752 if (copy_from_user(ioc->cached_fw, uarg->newImage, newFwSize)) {
1753 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_replace_fw - "
1754 "Unable to read in mpt_ioctl_replace_fw image "
1755 "@ %p\n", ioc->name, __FILE__, __LINE__, uarg);
1756 mpt_free_fw_memory(ioc);
1760 /* Update IOCFactsReply
1762 ioc->facts.FWImageSize = newFwSize;
1766 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1767 /* MPT IOCTL MPTCOMMAND function.
1768 * Cast the arg into the mpt_ioctl_mpt_command structure.
1771 * Return: 0 if successful
1772 * -EBUSY if previous command timeout and IOC reset is not complete.
1773 * -EFAULT if data unavailable
1774 * -ENODEV if no such device/adapter
1775 * -ETIME if timer expires
1776 * -ENOMEM if memory allocation error
1779 mptctl_mpt_command (unsigned long arg)
1781 struct mpt_ioctl_command __user *uarg = (void __user *) arg;
1782 struct mpt_ioctl_command karg;
1788 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_command))) {
1789 printk(KERN_ERR MYNAM "%s@%d::mptctl_mpt_command - "
1790 "Unable to read in mpt_ioctl_command struct @ %p\n",
1791 __FILE__, __LINE__, uarg);
1795 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1797 printk(KERN_DEBUG MYNAM "%s::mptctl_mpt_command() @%d - ioc%d not found!\n",
1798 __FILE__, __LINE__, iocnum);
1802 rc = mptctl_do_mpt_command (karg, &uarg->MF);
1807 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1808 /* Worker routine for the IOCTL MPTCOMMAND and MPTCOMMAND32 (sparc) commands.
1811 * Return: 0 if successful
1812 * -EBUSY if previous command timeout and IOC reset is not complete.
1813 * -EFAULT if data unavailable
1814 * -ENODEV if no such device/adapter
1815 * -ETIME if timer expires
1816 * -ENOMEM if memory allocation error
1817 * -EPERM if SCSI I/O and target is untagged
1820 mptctl_do_mpt_command (struct mpt_ioctl_command karg, void __user *mfPtr)
1823 MPT_FRAME_HDR *mf = NULL;
1826 struct buflist bufIn; /* data In buffer */
1827 struct buflist bufOut; /* data Out buffer */
1828 dma_addr_t dma_addr_in;
1829 dma_addr_t dma_addr_out;
1830 int sgSize = 0; /* Num SG elements */
1831 int iocnum, flagsLength;
1836 unsigned long timeleft;
1837 struct scsi_device *sdev;
1838 unsigned long flags;
1841 /* bufIn and bufOut are used for user to kernel space transfers
1843 bufIn.kptr = bufOut.kptr = NULL;
1844 bufIn.len = bufOut.len = 0;
1846 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1848 printk(KERN_DEBUG MYNAM "%s::mptctl_do_mpt_command() @%d - ioc%d not found!\n",
1849 __FILE__, __LINE__, iocnum);
1853 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
1854 if (ioc->ioc_reset_in_progress) {
1855 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
1856 printk(KERN_ERR MYNAM "%s@%d::mptctl_do_mpt_command - "
1857 "Busy with diagnostic reset\n", __FILE__, __LINE__);
1860 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
1862 /* Basic sanity checks to prevent underflows or integer overflows */
1863 if (karg.maxReplyBytes < 0 ||
1864 karg.dataInSize < 0 ||
1865 karg.dataOutSize < 0 ||
1866 karg.dataSgeOffset < 0 ||
1867 karg.maxSenseBytes < 0 ||
1868 karg.dataSgeOffset > ioc->req_sz / 4)
1871 /* Verify that the final request frame will not be too large.
1873 sz = karg.dataSgeOffset * 4;
1874 if (karg.dataInSize > 0)
1875 sz += ioc->SGE_size;
1876 if (karg.dataOutSize > 0)
1877 sz += ioc->SGE_size;
1879 if (sz > ioc->req_sz) {
1880 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1881 "Request frame too large (%d) maximum (%d)\n",
1882 ioc->name, __FILE__, __LINE__, sz, ioc->req_sz);
1886 /* Get a free request frame and save the message context.
1888 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
1891 hdr = (MPIHeader_t *) mf;
1892 msgContext = le32_to_cpu(hdr->MsgContext);
1893 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1895 /* Copy the request frame
1896 * Reset the saved message context.
1897 * Request frame in user space
1899 if (copy_from_user(mf, mfPtr, karg.dataSgeOffset * 4)) {
1900 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1901 "Unable to read MF from mpt_ioctl_command struct @ %p\n",
1902 ioc->name, __FILE__, __LINE__, mfPtr);
1907 hdr->MsgContext = cpu_to_le32(msgContext);
1908 function = hdr->Function;
1911 /* Verify that this request is allowed.
1913 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sending mpi function (0x%02X), req=%p\n",
1914 ioc->name, hdr->Function, mf));
1917 case MPI_FUNCTION_IOC_FACTS:
1918 case MPI_FUNCTION_PORT_FACTS:
1919 karg.dataOutSize = karg.dataInSize = 0;
1922 case MPI_FUNCTION_CONFIG:
1924 Config_t *config_frame;
1925 config_frame = (Config_t *)mf;
1926 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\ttype=0x%02x ext_type=0x%02x "
1927 "number=0x%02x action=0x%02x\n", ioc->name,
1928 config_frame->Header.PageType,
1929 config_frame->ExtPageType,
1930 config_frame->Header.PageNumber,
1931 config_frame->Action));
1935 case MPI_FUNCTION_FC_COMMON_TRANSPORT_SEND:
1936 case MPI_FUNCTION_FC_EX_LINK_SRVC_SEND:
1937 case MPI_FUNCTION_FW_UPLOAD:
1938 case MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR:
1939 case MPI_FUNCTION_FW_DOWNLOAD:
1940 case MPI_FUNCTION_FC_PRIMITIVE_SEND:
1941 case MPI_FUNCTION_TOOLBOX:
1942 case MPI_FUNCTION_SAS_IO_UNIT_CONTROL:
1945 case MPI_FUNCTION_SCSI_IO_REQUEST:
1947 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
1948 int qtag = MPI_SCSIIO_CONTROL_UNTAGGED;
1953 id = (ioc->devices_per_bus == 0) ? 256 : ioc->devices_per_bus;
1954 if (pScsiReq->TargetID > id) {
1955 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1956 "Target ID out of bounds. \n",
1957 ioc->name, __FILE__, __LINE__);
1962 if (pScsiReq->Bus >= ioc->number_of_buses) {
1963 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1964 "Target Bus out of bounds. \n",
1965 ioc->name, __FILE__, __LINE__);
1970 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
1971 pScsiReq->MsgFlags |= mpt_msg_flags(ioc);
1974 /* verify that app has not requested
1975 * more sense data than driver
1976 * can provide, if so, reset this parameter
1977 * set the sense buffer pointer low address
1978 * update the control field to specify Q type
1980 if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1981 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1983 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1985 pScsiReq->SenseBufferLowAddr =
1986 cpu_to_le32(ioc->sense_buf_low_dma
1987 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
1989 shost_for_each_device(sdev, ioc->sh) {
1990 struct scsi_target *starget = scsi_target(sdev);
1991 VirtTarget *vtarget = starget->hostdata;
1993 if (vtarget == NULL)
1996 if ((pScsiReq->TargetID == vtarget->id) &&
1997 (pScsiReq->Bus == vtarget->channel) &&
1998 (vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
1999 qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
2002 /* Have the IOCTL driver set the direction based
2003 * on the dataOutSize (ordering issue with Sparc).
2005 if (karg.dataOutSize > 0) {
2006 scsidir = MPI_SCSIIO_CONTROL_WRITE;
2007 dataSize = karg.dataOutSize;
2009 scsidir = MPI_SCSIIO_CONTROL_READ;
2010 dataSize = karg.dataInSize;
2013 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
2014 pScsiReq->DataLength = cpu_to_le32(dataSize);
2018 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2019 "SCSI driver is not loaded. \n",
2020 ioc->name, __FILE__, __LINE__);
2026 case MPI_FUNCTION_SMP_PASSTHROUGH:
2027 /* Check mf->PassthruFlags to determine if
2028 * transfer is ImmediateMode or not.
2029 * Immediate mode returns data in the ReplyFrame.
2030 * Else, we are sending request and response data
2031 * in two SGLs at the end of the mf.
2035 case MPI_FUNCTION_SATA_PASSTHROUGH:
2037 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2038 "SCSI driver is not loaded. \n",
2039 ioc->name, __FILE__, __LINE__);
2045 case MPI_FUNCTION_RAID_ACTION:
2050 case MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
2052 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
2053 int qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
2054 int scsidir = MPI_SCSIIO_CONTROL_READ;
2057 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
2058 pScsiReq->MsgFlags |= mpt_msg_flags(ioc);
2061 /* verify that app has not requested
2062 * more sense data than driver
2063 * can provide, if so, reset this parameter
2064 * set the sense buffer pointer low address
2065 * update the control field to specify Q type
2067 if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
2068 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
2070 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
2072 pScsiReq->SenseBufferLowAddr =
2073 cpu_to_le32(ioc->sense_buf_low_dma
2074 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
2076 /* All commands to physical devices are tagged
2079 /* Have the IOCTL driver set the direction based
2080 * on the dataOutSize (ordering issue with Sparc).
2082 if (karg.dataOutSize > 0) {
2083 scsidir = MPI_SCSIIO_CONTROL_WRITE;
2084 dataSize = karg.dataOutSize;
2086 scsidir = MPI_SCSIIO_CONTROL_READ;
2087 dataSize = karg.dataInSize;
2090 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
2091 pScsiReq->DataLength = cpu_to_le32(dataSize);
2094 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2095 "SCSI driver is not loaded. \n",
2096 ioc->name, __FILE__, __LINE__);
2102 case MPI_FUNCTION_SCSI_TASK_MGMT:
2104 SCSITaskMgmt_t *pScsiTm;
2105 pScsiTm = (SCSITaskMgmt_t *)mf;
2106 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2107 "\tTaskType=0x%x MsgFlags=0x%x "
2108 "TaskMsgContext=0x%x id=%d channel=%d\n",
2109 ioc->name, pScsiTm->TaskType, le32_to_cpu
2110 (pScsiTm->TaskMsgContext), pScsiTm->MsgFlags,
2111 pScsiTm->TargetID, pScsiTm->Bus));
2115 case MPI_FUNCTION_IOC_INIT:
2117 IOCInit_t *pInit = (IOCInit_t *) mf;
2118 u32 high_addr, sense_high;
2120 /* Verify that all entries in the IOC INIT match
2121 * existing setup (and in LE format).
2123 if (sizeof(dma_addr_t) == sizeof(u64)) {
2124 high_addr = cpu_to_le32((u32)((u64)ioc->req_frames_dma >> 32));
2125 sense_high= cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
2131 if ((pInit->Flags != 0) || (pInit->MaxDevices != ioc->facts.MaxDevices) ||
2132 (pInit->MaxBuses != ioc->facts.MaxBuses) ||
2133 (pInit->ReplyFrameSize != cpu_to_le16(ioc->reply_sz)) ||
2134 (pInit->HostMfaHighAddr != high_addr) ||
2135 (pInit->SenseBufferHighAddr != sense_high)) {
2136 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2137 "IOC_INIT issued with 1 or more incorrect parameters. Rejected.\n",
2138 ioc->name, __FILE__, __LINE__);
2146 * MPI_FUNCTION_PORT_ENABLE
2147 * MPI_FUNCTION_TARGET_CMD_BUFFER_POST
2148 * MPI_FUNCTION_TARGET_ASSIST
2149 * MPI_FUNCTION_TARGET_STATUS_SEND
2150 * MPI_FUNCTION_TARGET_MODE_ABORT
2151 * MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET
2152 * MPI_FUNCTION_IO_UNIT_RESET
2153 * MPI_FUNCTION_HANDSHAKE
2154 * MPI_FUNCTION_REPLY_FRAME_REMOVAL
2155 * MPI_FUNCTION_EVENT_NOTIFICATION
2156 * (driver handles event notification)
2157 * MPI_FUNCTION_EVENT_ACK
2160 /* What to do with these??? CHECK ME!!!
2161 MPI_FUNCTION_FC_LINK_SRVC_BUF_POST
2162 MPI_FUNCTION_FC_LINK_SRVC_RSP
2163 MPI_FUNCTION_FC_ABORT
2164 MPI_FUNCTION_LAN_SEND
2165 MPI_FUNCTION_LAN_RECEIVE
2166 MPI_FUNCTION_LAN_RESET
2169 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2170 "Illegal request (function 0x%x) \n",
2171 ioc->name, __FILE__, __LINE__, hdr->Function);
2176 /* Add the SGL ( at most one data in SGE and one data out SGE )
2177 * In the case of two SGE's - the data out (write) will always
2178 * preceede the data in (read) SGE. psgList is used to free the
2181 psge = (char *) (((int *) mf) + karg.dataSgeOffset);
2184 if (karg.dataOutSize > 0)
2187 if (karg.dataInSize > 0)
2192 /* Set up the dataOut memory allocation */
2193 if (karg.dataOutSize > 0) {
2194 if (karg.dataInSize > 0) {
2195 flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2196 MPI_SGE_FLAGS_END_OF_BUFFER |
2197 MPI_SGE_FLAGS_DIRECTION)
2198 << MPI_SGE_FLAGS_SHIFT;
2200 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
2202 flagsLength |= karg.dataOutSize;
2203 bufOut.len = karg.dataOutSize;
2204 bufOut.kptr = pci_alloc_consistent(
2205 ioc->pcidev, bufOut.len, &dma_addr_out);
2207 if (bufOut.kptr == NULL) {
2212 * Copy to MF and to sglbuf
2214 ioc->add_sge(psge, flagsLength, dma_addr_out);
2215 psge += ioc->SGE_size;
2217 /* Copy user data to kernel space.
2219 if (copy_from_user(bufOut.kptr,
2222 printk(MYIOC_s_ERR_FMT
2223 "%s@%d::mptctl_do_mpt_command - Unable "
2224 "to read user data "
2226 ioc->name, __FILE__, __LINE__,karg.dataOutBufPtr);
2233 if (karg.dataInSize > 0) {
2234 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
2235 flagsLength |= karg.dataInSize;
2237 bufIn.len = karg.dataInSize;
2238 bufIn.kptr = pci_alloc_consistent(ioc->pcidev,
2239 bufIn.len, &dma_addr_in);
2241 if (bufIn.kptr == NULL) {
2246 * Copy to MF and to sglbuf
2248 ioc->add_sge(psge, flagsLength, dma_addr_in);
2254 ioc->add_sge(psge, flagsLength, (dma_addr_t) -1);
2257 SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, hdr->MsgContext);
2258 INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
2259 if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT) {
2261 mutex_lock(&ioc->taskmgmt_cmds.mutex);
2262 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
2263 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2267 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
2269 if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
2270 (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
2271 mpt_put_msg_frame_hi_pri(mptctl_id, ioc, mf);
2273 rc =mpt_send_handshake_request(mptctl_id, ioc,
2274 sizeof(SCSITaskMgmt_t), (u32*)mf, CAN_SLEEP);
2276 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2277 "send_handshake FAILED! (ioc %p, mf %p)\n",
2278 ioc->name, ioc, mf));
2279 mpt_clear_taskmgmt_in_progress_flag(ioc);
2281 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2287 mpt_put_msg_frame(mptctl_id, ioc, mf);
2289 /* Now wait for the command to complete */
2290 timeout = (karg.timeout > 0) ? karg.timeout : MPT_IOCTL_DEFAULT_TIMEOUT;
2292 timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
2294 if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2296 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "%s: TIMED OUT!\n",
2297 ioc->name, __func__));
2298 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2299 if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2300 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2304 printk(MYIOC_s_WARN_FMT
2305 "mpt cmd timeout, doorbell=0x%08x"
2307 ioc->name, mpt_GetIocState(ioc, 0), function);
2308 if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2309 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2310 mptctl_timeout_expired(ioc, mf);
2317 if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2318 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2323 /* If a valid reply frame, copy to the user.
2324 * Offset 2: reply length in U32's
2326 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) {
2327 if (karg.maxReplyBytes < ioc->reply_sz) {
2328 sz = min(karg.maxReplyBytes,
2329 4*ioc->ioctl_cmds.reply[2]);
2331 sz = min(ioc->reply_sz, 4*ioc->ioctl_cmds.reply[2]);
2334 if (copy_to_user(karg.replyFrameBufPtr,
2335 ioc->ioctl_cmds.reply, sz)){
2336 printk(MYIOC_s_ERR_FMT
2337 "%s@%d::mptctl_do_mpt_command - "
2338 "Unable to write out reply frame %p\n",
2339 ioc->name, __FILE__, __LINE__, karg.replyFrameBufPtr);
2346 /* If valid sense data, copy to user.
2348 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_SENSE_VALID) {
2349 sz = min(karg.maxSenseBytes, MPT_SENSE_BUFFER_SIZE);
2351 if (copy_to_user(karg.senseDataPtr,
2352 ioc->ioctl_cmds.sense, sz)) {
2353 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2354 "Unable to write sense data to user %p\n",
2355 ioc->name, __FILE__, __LINE__,
2363 /* If the overall status is _GOOD and data in, copy data
2366 if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD) &&
2367 (karg.dataInSize > 0) && (bufIn.kptr)) {
2369 if (copy_to_user(karg.dataInBufPtr,
2370 bufIn.kptr, karg.dataInSize)) {
2371 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2372 "Unable to write data to user %p\n",
2373 ioc->name, __FILE__, __LINE__,
2381 CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
2382 SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
2384 /* Free the allocated memory.
2386 if (bufOut.kptr != NULL) {
2387 pci_free_consistent(ioc->pcidev,
2388 bufOut.len, (void *) bufOut.kptr, dma_addr_out);
2391 if (bufIn.kptr != NULL) {
2392 pci_free_consistent(ioc->pcidev,
2393 bufIn.len, (void *) bufIn.kptr, dma_addr_in);
2396 /* mf is null if command issued successfully
2397 * otherwise, failure occurred after mf acquired.
2400 mpt_free_msg_frame(ioc, mf);
2405 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2406 /* Prototype Routine for the HOST INFO command.
2409 * Return: 0 if successful
2410 * -EFAULT if data unavailable
2411 * -EBUSY if previous command timeout and IOC reset is not complete.
2412 * -ENODEV if no such device/adapter
2413 * -ETIME if timer expires
2414 * -ENOMEM if memory allocation error
2417 mptctl_hp_hostinfo(unsigned long arg, unsigned int data_size)
2419 hp_host_info_t __user *uarg = (void __user *) arg;
2421 struct pci_dev *pdev;
2424 hp_host_info_t karg;
2426 ConfigPageHeader_t hdr;
2429 ToolboxIstwiReadWriteRequest_t *IstwiRWRequest;
2430 MPT_FRAME_HDR *mf = NULL;
2431 unsigned long timeleft;
2435 /* Reset long to int. Should affect IA64 and SPARC only
2437 if (data_size == sizeof(hp_host_info_t))
2439 else if (data_size == sizeof(hp_host_info_rev0_t))
2440 cim_rev = 0; /* obsolete */
2444 if (copy_from_user(&karg, uarg, sizeof(hp_host_info_t))) {
2445 printk(KERN_ERR MYNAM "%s@%d::mptctl_hp_host_info - "
2446 "Unable to read in hp_host_info struct @ %p\n",
2447 __FILE__, __LINE__, uarg);
2451 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2453 printk(KERN_DEBUG MYNAM "%s::mptctl_hp_hostinfo() @%d - ioc%d not found!\n",
2454 __FILE__, __LINE__, iocnum);
2457 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": mptctl_hp_hostinfo called.\n",
2460 /* Fill in the data and return the structure to the calling
2463 pdev = (struct pci_dev *) ioc->pcidev;
2465 karg.vendor = pdev->vendor;
2466 karg.device = pdev->device;
2467 karg.subsystem_id = pdev->subsystem_device;
2468 karg.subsystem_vendor = pdev->subsystem_vendor;
2469 karg.devfn = pdev->devfn;
2470 karg.bus = pdev->bus->number;
2472 /* Save the SCSI host no. if
2473 * SCSI driver loaded
2475 if (ioc->sh != NULL)
2476 karg.host_no = ioc->sh->host_no;
2480 /* Reformat the fw_version into a string
2482 karg.fw_version[0] = ioc->facts.FWVersion.Struct.Major >= 10 ?
2483 ((ioc->facts.FWVersion.Struct.Major / 10) + '0') : '0';
2484 karg.fw_version[1] = (ioc->facts.FWVersion.Struct.Major % 10 ) + '0';
2485 karg.fw_version[2] = '.';
2486 karg.fw_version[3] = ioc->facts.FWVersion.Struct.Minor >= 10 ?
2487 ((ioc->facts.FWVersion.Struct.Minor / 10) + '0') : '0';
2488 karg.fw_version[4] = (ioc->facts.FWVersion.Struct.Minor % 10 ) + '0';
2489 karg.fw_version[5] = '.';
2490 karg.fw_version[6] = ioc->facts.FWVersion.Struct.Unit >= 10 ?
2491 ((ioc->facts.FWVersion.Struct.Unit / 10) + '0') : '0';
2492 karg.fw_version[7] = (ioc->facts.FWVersion.Struct.Unit % 10 ) + '0';
2493 karg.fw_version[8] = '.';
2494 karg.fw_version[9] = ioc->facts.FWVersion.Struct.Dev >= 10 ?
2495 ((ioc->facts.FWVersion.Struct.Dev / 10) + '0') : '0';
2496 karg.fw_version[10] = (ioc->facts.FWVersion.Struct.Dev % 10 ) + '0';
2497 karg.fw_version[11] = '\0';
2499 /* Issue a config request to get the device serial number
2501 hdr.PageVersion = 0;
2504 hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
2505 cfg.cfghdr.hdr = &hdr;
2508 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2509 cfg.dir = 0; /* read */
2512 strncpy(karg.serial_number, " ", 24);
2513 if (mpt_config(ioc, &cfg) == 0) {
2514 if (cfg.cfghdr.hdr->PageLength > 0) {
2515 /* Issue the second config page request */
2516 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2518 pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
2520 cfg.physAddr = buf_dma;
2521 if (mpt_config(ioc, &cfg) == 0) {
2522 ManufacturingPage0_t *pdata = (ManufacturingPage0_t *) pbuf;
2523 if (strlen(pdata->BoardTracerNumber) > 1) {
2524 strncpy(karg.serial_number, pdata->BoardTracerNumber, 24);
2525 karg.serial_number[24-1]='\0';
2528 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
2533 rc = mpt_GetIocState(ioc, 1);
2535 case MPI_IOC_STATE_OPERATIONAL:
2536 karg.ioc_status = HP_STATUS_OK;
2539 case MPI_IOC_STATE_FAULT:
2540 karg.ioc_status = HP_STATUS_FAILED;
2543 case MPI_IOC_STATE_RESET:
2544 case MPI_IOC_STATE_READY:
2546 karg.ioc_status = HP_STATUS_OTHER;
2550 karg.base_io_addr = pci_resource_start(pdev, 0);
2552 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
2553 karg.bus_phys_width = HP_BUS_WIDTH_UNK;
2555 karg.bus_phys_width = HP_BUS_WIDTH_16;
2557 karg.hard_resets = 0;
2558 karg.soft_resets = 0;
2560 if (ioc->sh != NULL) {
2561 MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
2563 if (hd && (cim_rev == 1)) {
2564 karg.hard_resets = ioc->hard_resets;
2565 karg.soft_resets = ioc->soft_resets;
2566 karg.timeouts = ioc->timeouts;
2571 * Gather ISTWI(Industry Standard Two Wire Interface) Data
2573 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
2574 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
2575 "%s, no msg frames!!\n", ioc->name, __func__));
2579 IstwiRWRequest = (ToolboxIstwiReadWriteRequest_t *)mf;
2580 msgcontext = IstwiRWRequest->MsgContext;
2581 memset(IstwiRWRequest,0,sizeof(ToolboxIstwiReadWriteRequest_t));
2582 IstwiRWRequest->MsgContext = msgcontext;
2583 IstwiRWRequest->Function = MPI_FUNCTION_TOOLBOX;
2584 IstwiRWRequest->Tool = MPI_TOOLBOX_ISTWI_READ_WRITE_TOOL;
2585 IstwiRWRequest->Flags = MPI_TB_ISTWI_FLAGS_READ;
2586 IstwiRWRequest->NumAddressBytes = 0x01;
2587 IstwiRWRequest->DataLength = cpu_to_le16(0x04);
2588 if (pdev->devfn & 1)
2589 IstwiRWRequest->DeviceAddr = 0xB2;
2591 IstwiRWRequest->DeviceAddr = 0xB0;
2593 pbuf = pci_alloc_consistent(ioc->pcidev, 4, &buf_dma);
2596 ioc->add_sge((char *)&IstwiRWRequest->SGL,
2597 (MPT_SGE_FLAGS_SSIMPLE_READ|4), buf_dma);
2600 SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context,
2601 IstwiRWRequest->MsgContext);
2602 INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
2603 mpt_put_msg_frame(mptctl_id, ioc, mf);
2606 timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
2607 HZ*MPT_IOCTL_DEFAULT_TIMEOUT);
2608 if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2610 printk(MYIOC_s_WARN_FMT "%s: failed\n", ioc->name, __func__);
2611 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2612 mpt_free_msg_frame(ioc, mf);
2616 printk(MYIOC_s_WARN_FMT
2617 "HOST INFO command timeout, doorbell=0x%08x\n",
2618 ioc->name, mpt_GetIocState(ioc, 0));
2619 mptctl_timeout_expired(ioc, mf);
2626 *ISTWI Data Definition
2627 * pbuf[0] = FW_VERSION = 0x4
2628 * pbuf[1] = Bay Count = 6 or 4 or 2, depending on
2629 * the config, you should be seeing one out of these three values
2630 * pbuf[2] = Drive Installed Map = bit pattern depend on which
2631 * bays have drives in them
2632 * pbuf[3] = Checksum (0x100 = (byte0 + byte2 + byte3)
2634 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID)
2635 karg.rsvd = *(u32 *)pbuf;
2638 CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
2639 SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
2642 pci_free_consistent(ioc->pcidev, 4, pbuf, buf_dma);
2644 /* Copy the data from kernel memory to user memory
2646 if (copy_to_user((char __user *)arg, &karg, sizeof(hp_host_info_t))) {
2647 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_hpgethostinfo - "
2648 "Unable to write out hp_host_info @ %p\n",
2649 ioc->name, __FILE__, __LINE__, uarg);
2657 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2658 /* Prototype Routine for the TARGET INFO command.
2661 * Return: 0 if successful
2662 * -EFAULT if data unavailable
2663 * -EBUSY if previous command timeout and IOC reset is not complete.
2664 * -ENODEV if no such device/adapter
2665 * -ETIME if timer expires
2666 * -ENOMEM if memory allocation error
2669 mptctl_hp_targetinfo(unsigned long arg)
2671 hp_target_info_t __user *uarg = (void __user *) arg;
2672 SCSIDevicePage0_t *pg0_alloc;
2673 SCSIDevicePage3_t *pg3_alloc;
2675 MPT_SCSI_HOST *hd = NULL;
2676 hp_target_info_t karg;
2679 dma_addr_t page_dma;
2681 ConfigPageHeader_t hdr;
2682 int tmp, np, rc = 0;
2684 if (copy_from_user(&karg, uarg, sizeof(hp_target_info_t))) {
2685 printk(KERN_ERR MYNAM "%s@%d::mptctl_hp_targetinfo - "
2686 "Unable to read in hp_host_targetinfo struct @ %p\n",
2687 __FILE__, __LINE__, uarg);
2691 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2693 printk(KERN_DEBUG MYNAM "%s::mptctl_hp_targetinfo() @%d - ioc%d not found!\n",
2694 __FILE__, __LINE__, iocnum);
2697 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_hp_targetinfo called.\n",
2700 /* There is nothing to do for FCP parts.
2702 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
2705 if ((ioc->spi_data.sdp0length == 0) || (ioc->sh == NULL))
2708 if (ioc->sh->host_no != karg.hdr.host)
2711 /* Get the data transfer speeds
2713 data_sz = ioc->spi_data.sdp0length * 4;
2714 pg0_alloc = (SCSIDevicePage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
2716 hdr.PageVersion = ioc->spi_data.sdp0version;
2717 hdr.PageLength = data_sz;
2719 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2721 cfg.cfghdr.hdr = &hdr;
2722 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2725 cfg.physAddr = page_dma;
2727 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2729 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2730 np = le32_to_cpu(pg0_alloc->NegotiatedParameters);
2731 karg.negotiated_width = np & MPI_SCSIDEVPAGE0_NP_WIDE ?
2732 HP_BUS_WIDTH_16 : HP_BUS_WIDTH_8;
2734 if (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) {
2735 tmp = (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> 8;
2737 karg.negotiated_speed = HP_DEV_SPEED_ULTRA320;
2738 else if (tmp <= 0x09)
2739 karg.negotiated_speed = HP_DEV_SPEED_ULTRA160;
2740 else if (tmp <= 0x0A)
2741 karg.negotiated_speed = HP_DEV_SPEED_ULTRA2;
2742 else if (tmp <= 0x0C)
2743 karg.negotiated_speed = HP_DEV_SPEED_ULTRA;
2744 else if (tmp <= 0x25)
2745 karg.negotiated_speed = HP_DEV_SPEED_FAST;
2747 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2749 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2752 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg0_alloc, page_dma);
2757 karg.message_rejects = -1;
2758 karg.phase_errors = -1;
2759 karg.parity_errors = -1;
2760 karg.select_timeouts = -1;
2762 /* Get the target error parameters
2764 hdr.PageVersion = 0;
2767 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2769 cfg.cfghdr.hdr = &hdr;
2770 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2774 if ((mpt_config(ioc, &cfg) == 0) && (cfg.cfghdr.hdr->PageLength > 0)) {
2775 /* Issue the second config page request */
2776 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2777 data_sz = (int) cfg.cfghdr.hdr->PageLength * 4;
2778 pg3_alloc = (SCSIDevicePage3_t *) pci_alloc_consistent(
2779 ioc->pcidev, data_sz, &page_dma);
2781 cfg.physAddr = page_dma;
2782 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2783 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2784 karg.message_rejects = (u32) le16_to_cpu(pg3_alloc->MsgRejectCount);
2785 karg.phase_errors = (u32) le16_to_cpu(pg3_alloc->PhaseErrorCount);
2786 karg.parity_errors = (u32) le16_to_cpu(pg3_alloc->ParityErrorCount);
2788 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg3_alloc, page_dma);
2791 hd = shost_priv(ioc->sh);
2793 karg.select_timeouts = hd->sel_timeout[karg.hdr.id];
2795 /* Copy the data from kernel memory to user memory
2797 if (copy_to_user((char __user *)arg, &karg, sizeof(hp_target_info_t))) {
2798 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_hp_target_info - "
2799 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
2800 ioc->name, __FILE__, __LINE__, uarg);
2807 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2809 static const struct file_operations mptctl_fops = {
2810 .owner = THIS_MODULE,
2811 .llseek = no_llseek,
2812 .fasync = mptctl_fasync,
2813 .unlocked_ioctl = mptctl_ioctl,
2814 #ifdef CONFIG_COMPAT
2815 .compat_ioctl = compat_mpctl_ioctl,
2819 static struct miscdevice mptctl_miscdev = {
2825 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2827 #ifdef CONFIG_COMPAT
2830 compat_mptfwxfer_ioctl(struct file *filp, unsigned int cmd,
2833 struct mpt_fw_xfer32 kfw32;
2834 struct mpt_fw_xfer kfw;
2835 MPT_ADAPTER *iocp = NULL;
2836 int iocnum, iocnumX;
2837 int nonblock = (filp->f_flags & O_NONBLOCK);
2841 if (copy_from_user(&kfw32, (char __user *)arg, sizeof(kfw32)))
2844 /* Verify intended MPT adapter */
2845 iocnumX = kfw32.iocnum & 0xFF;
2846 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2848 printk(KERN_DEBUG MYNAM "::compat_mptfwxfer_ioctl @%d - ioc%d not found!\n",
2853 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2856 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "compat_mptfwxfer_ioctl() called\n",
2858 kfw.iocnum = iocnum;
2859 kfw.fwlen = kfw32.fwlen;
2860 kfw.bufp = compat_ptr(kfw32.bufp);
2862 ret = mptctl_do_fw_download(kfw.iocnum, kfw.bufp, kfw.fwlen);
2864 mutex_unlock(&iocp->ioctl_cmds.mutex);
2870 compat_mpt_command(struct file *filp, unsigned int cmd,
2873 struct mpt_ioctl_command32 karg32;
2874 struct mpt_ioctl_command32 __user *uarg = (struct mpt_ioctl_command32 __user *) arg;
2875 struct mpt_ioctl_command karg;
2876 MPT_ADAPTER *iocp = NULL;
2877 int iocnum, iocnumX;
2878 int nonblock = (filp->f_flags & O_NONBLOCK);
2881 if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32)))
2884 /* Verify intended MPT adapter */
2885 iocnumX = karg32.hdr.iocnum & 0xFF;
2886 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2888 printk(KERN_DEBUG MYNAM "::compat_mpt_command @%d - ioc%d not found!\n",
2893 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2896 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "compat_mpt_command() called\n",
2898 /* Copy data to karg */
2899 karg.hdr.iocnum = karg32.hdr.iocnum;
2900 karg.hdr.port = karg32.hdr.port;
2901 karg.timeout = karg32.timeout;
2902 karg.maxReplyBytes = karg32.maxReplyBytes;
2904 karg.dataInSize = karg32.dataInSize;
2905 karg.dataOutSize = karg32.dataOutSize;
2906 karg.maxSenseBytes = karg32.maxSenseBytes;
2907 karg.dataSgeOffset = karg32.dataSgeOffset;
2909 karg.replyFrameBufPtr = (char __user *)(unsigned long)karg32.replyFrameBufPtr;
2910 karg.dataInBufPtr = (char __user *)(unsigned long)karg32.dataInBufPtr;
2911 karg.dataOutBufPtr = (char __user *)(unsigned long)karg32.dataOutBufPtr;
2912 karg.senseDataPtr = (char __user *)(unsigned long)karg32.senseDataPtr;
2914 /* Pass new structure to do_mpt_command
2916 ret = mptctl_do_mpt_command (karg, &uarg->MF);
2918 mutex_unlock(&iocp->ioctl_cmds.mutex);
2923 static long compat_mpctl_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
2926 mutex_lock(&mpctl_mutex);
2933 case MPTEVENTENABLE:
2934 case MPTEVENTREPORT:
2936 case HP_GETHOSTINFO:
2937 case HP_GETTARGETINFO:
2939 ret = __mptctl_ioctl(f, cmd, arg);
2942 ret = compat_mpt_command(f, cmd, arg);
2944 case MPTFWDOWNLOAD32:
2945 ret = compat_mptfwxfer_ioctl(f, cmd, arg);
2951 mutex_unlock(&mpctl_mutex);
2958 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2960 * mptctl_probe - Installs ioctl devices per bus.
2961 * @pdev: Pointer to pci_dev structure
2963 * Returns 0 for success, non-zero for failure.
2968 mptctl_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2970 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
2972 mutex_init(&ioc->ioctl_cmds.mutex);
2973 init_completion(&ioc->ioctl_cmds.done);
2977 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2979 * mptctl_remove - Removed ioctl devices
2980 * @pdev: Pointer to pci_dev structure
2985 mptctl_remove(struct pci_dev *pdev)
2989 static struct mpt_pci_driver mptctl_driver = {
2990 .probe = mptctl_probe,
2991 .remove = mptctl_remove,
2994 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2995 static int __init mptctl_init(void)
3000 show_mptmod_ver(my_NAME, my_VERSION);
3002 mpt_device_driver_register(&mptctl_driver, MPTCTL_DRIVER);
3004 /* Register this device */
3005 err = misc_register(&mptctl_miscdev);
3007 printk(KERN_ERR MYNAM ": Can't register misc device [minor=%d].\n", MPT_MINOR);
3010 printk(KERN_INFO MYNAM ": Registered with Fusion MPT base driver\n");
3011 printk(KERN_INFO MYNAM ": /dev/%s @ (major,minor=%d,%d)\n",
3012 mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
3015 * Install our handler
3018 mptctl_id = mpt_register(mptctl_reply, MPTCTL_DRIVER,
3020 if (!mptctl_id || mptctl_id >= MPT_MAX_PROTOCOL_DRIVERS) {
3021 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
3022 misc_deregister(&mptctl_miscdev);
3027 mptctl_taskmgmt_id = mpt_register(mptctl_taskmgmt_reply, MPTCTL_DRIVER,
3028 "mptctl_taskmgmt_reply");
3029 if (!mptctl_taskmgmt_id || mptctl_taskmgmt_id >= MPT_MAX_PROTOCOL_DRIVERS) {
3030 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
3031 mpt_deregister(mptctl_id);
3032 misc_deregister(&mptctl_miscdev);
3037 mpt_reset_register(mptctl_id, mptctl_ioc_reset);
3038 mpt_event_register(mptctl_id, mptctl_event_process);
3044 mpt_device_driver_deregister(MPTCTL_DRIVER);
3049 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3050 static void mptctl_exit(void)
3052 misc_deregister(&mptctl_miscdev);
3053 printk(KERN_INFO MYNAM ": Deregistered /dev/%s @ (major,minor=%d,%d)\n",
3054 mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
3056 /* De-register event handler from base module */
3057 mpt_event_deregister(mptctl_id);
3059 /* De-register reset handler from base module */
3060 mpt_reset_deregister(mptctl_id);
3062 /* De-register callback handler from base module */
3063 mpt_deregister(mptctl_taskmgmt_id);
3064 mpt_deregister(mptctl_id);
3066 mpt_device_driver_deregister(MPTCTL_DRIVER);
3070 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3072 module_init(mptctl_init);
3073 module_exit(mptctl_exit);