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 <linux/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(MPT_ADAPTER *iocp, unsigned long arg);
104 static int mptctl_getiocinfo(MPT_ADAPTER *iocp, unsigned long arg, unsigned int cmd);
105 static int mptctl_gettargetinfo(MPT_ADAPTER *iocp, unsigned long arg);
106 static int mptctl_readtest(MPT_ADAPTER *iocp, unsigned long arg);
107 static int mptctl_mpt_command(MPT_ADAPTER *iocp, unsigned long arg);
108 static int mptctl_eventquery(MPT_ADAPTER *iocp, unsigned long arg);
109 static int mptctl_eventenable(MPT_ADAPTER *iocp, unsigned long arg);
110 static int mptctl_eventreport(MPT_ADAPTER *iocp, unsigned long arg);
111 static int mptctl_replace_fw(MPT_ADAPTER *iocp, unsigned long arg);
113 static int mptctl_do_reset(MPT_ADAPTER *iocp, unsigned long arg);
114 static int mptctl_hp_hostinfo(MPT_ADAPTER *iocp, unsigned long arg, unsigned int cmd);
115 static int mptctl_hp_targetinfo(MPT_ADAPTER *iocp, unsigned long arg);
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(MPT_ADAPTER *iocp, struct mpt_ioctl_command karg, void __user *mfPtr);
127 static int mptctl_do_fw_download(MPT_ADAPTER *iocp, char __user *ufwbuf, size_t fwlen);
128 static MptSge_t *kbuf_alloc_2_sgl(int bytes, u32 dir, int sge_offset, int *frags,
129 struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc);
130 static void kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma,
131 struct buflist *buflist, MPT_ADAPTER *ioc);
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;
327 mutex_lock(&ioc->taskmgmt_cmds.mutex);
328 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
329 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
335 mf = mpt_get_msg_frame(mptctl_taskmgmt_id, ioc);
338 printk(MYIOC_s_WARN_FMT "TaskMgmt, no msg frames!!\n",
340 mpt_clear_taskmgmt_in_progress_flag(ioc);
345 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
348 pScsiTm = (SCSITaskMgmt_t *) mf;
349 memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t));
350 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
351 pScsiTm->TaskType = tm_type;
352 if ((tm_type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS) &&
353 (ioc->bus_type == FC))
355 MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
356 pScsiTm->TargetID = target_id;
357 pScsiTm->Bus = bus_id;
358 pScsiTm->ChainOffset = 0;
359 pScsiTm->Reserved = 0;
360 pScsiTm->Reserved1 = 0;
361 pScsiTm->TaskMsgContext = 0;
362 for (ii= 0; ii < 8; ii++)
363 pScsiTm->LUN[ii] = 0;
364 for (ii=0; ii < 7; ii++)
365 pScsiTm->Reserved2[ii] = 0;
367 switch (ioc->bus_type) {
381 printk(MYIOC_s_DEBUG_FMT "TaskMgmt type=%d timeout=%ld\n",
382 ioc->name, tm_type, timeout));
384 INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
385 if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
386 (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
387 mpt_put_msg_frame_hi_pri(mptctl_taskmgmt_id, ioc, mf);
389 retval = mpt_send_handshake_request(mptctl_taskmgmt_id, ioc,
390 sizeof(SCSITaskMgmt_t), (u32 *)pScsiTm, CAN_SLEEP);
393 printk(MYIOC_s_ERR_FMT
394 "TaskMgmt send_handshake FAILED!"
395 " (ioc %p, mf %p, rc=%d) \n", ioc->name,
397 mpt_free_msg_frame(ioc, mf);
398 mpt_clear_taskmgmt_in_progress_flag(ioc);
403 /* Now wait for the command to complete */
404 ii = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done, timeout*HZ);
406 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
407 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
408 "TaskMgmt failed\n", ioc->name));
409 mpt_free_msg_frame(ioc, mf);
410 mpt_clear_taskmgmt_in_progress_flag(ioc);
411 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
414 retval = -1; /* return failure */
418 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
419 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
420 "TaskMgmt failed\n", ioc->name));
421 retval = -1; /* return failure */
425 pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply;
426 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
427 "TaskMgmt fw_channel = %d, fw_id = %d, task_type=0x%02X, "
428 "iocstatus=0x%04X\n\tloginfo=0x%08X, response_code=0x%02X, "
429 "term_cmnds=%d\n", ioc->name, pScsiTmReply->Bus,
430 pScsiTmReply->TargetID, tm_type,
431 le16_to_cpu(pScsiTmReply->IOCStatus),
432 le32_to_cpu(pScsiTmReply->IOCLogInfo),
433 pScsiTmReply->ResponseCode,
434 le32_to_cpu(pScsiTmReply->TerminationCount)));
436 iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
438 if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
439 iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED ||
440 iocstatus == MPI_IOCSTATUS_SUCCESS)
443 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
444 "TaskMgmt failed\n", ioc->name));
445 retval = -1; /* return failure */
449 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
450 CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
454 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
455 /* mptctl_timeout_expired
457 * Expecting an interrupt, however timed out.
461 mptctl_timeout_expired(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
465 SCSIIORequest_t *scsi_req = (SCSIIORequest_t *) mf;
466 u8 function = mf->u.hdr.Function;
468 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": %s\n",
469 ioc->name, __func__));
471 if (mpt_fwfault_debug)
472 mpt_halt_firmware(ioc);
474 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
475 if (ioc->ioc_reset_in_progress) {
476 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
477 CLEAR_MGMT_PENDING_STATUS(ioc->ioctl_cmds.status)
478 mpt_free_msg_frame(ioc, mf);
481 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
484 CLEAR_MGMT_PENDING_STATUS(ioc->ioctl_cmds.status)
486 if (ioc->bus_type == SAS) {
487 if (function == MPI_FUNCTION_SCSI_IO_REQUEST)
488 ret_val = mptctl_do_taskmgmt(ioc,
489 MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
490 scsi_req->Bus, scsi_req->TargetID);
491 else if (function == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)
492 ret_val = mptctl_do_taskmgmt(ioc,
493 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
498 if ((function == MPI_FUNCTION_SCSI_IO_REQUEST) ||
499 (function == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH))
500 ret_val = mptctl_do_taskmgmt(ioc,
501 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
507 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling Reset! \n",
509 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
510 mpt_free_msg_frame(ioc, mf);
514 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
517 * Clean-up functionality. Used only if there has been a
518 * reload of the FW due.
522 mptctl_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
524 switch(reset_phase) {
525 case MPT_IOC_SETUP_RESET:
526 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
527 "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__));
529 case MPT_IOC_PRE_RESET:
530 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
531 "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__));
533 case MPT_IOC_POST_RESET:
534 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
535 "%s: MPT_IOC_POST_RESET\n", ioc->name, __func__));
536 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_PENDING) {
537 ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_DID_IOCRESET;
538 complete(&ioc->ioctl_cmds.done);
548 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
549 /* ASYNC Event Notification Support */
551 mptctl_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
555 event = le32_to_cpu(pEvReply->Event) & 0xFF;
557 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s() called\n",
558 ioc->name, __func__));
559 if(async_queue == NULL)
562 /* Raise SIGIO for persistent events.
563 * TODO - this define is not in MPI spec yet,
564 * but they plan to set it to 0x21
567 ioc->aen_event_read_flag=1;
568 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Raised SIGIO to application\n",
570 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
571 "Raised SIGIO to application\n", ioc->name));
572 kill_fasync(&async_queue, SIGIO, POLL_IN);
576 /* This flag is set after SIGIO was raised, and
577 * remains set until the application has read
578 * the event log via ioctl=MPTEVENTREPORT
580 if(ioc->aen_event_read_flag)
583 /* Signal only for the events that are
584 * requested for by the application
586 if (ioc->events && (ioc->eventTypes & ( 1 << event))) {
587 ioc->aen_event_read_flag=1;
588 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
589 "Raised SIGIO to application\n", ioc->name));
590 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
591 "Raised SIGIO to application\n", ioc->name));
592 kill_fasync(&async_queue, SIGIO, POLL_IN);
598 mptctl_fasync(int fd, struct file *filep, int mode)
603 mutex_lock(&mpctl_mutex);
604 list_for_each_entry(ioc, &ioc_list, list)
605 ioc->aen_event_read_flag=0;
607 ret = fasync_helper(fd, filep, mode, &async_queue);
608 mutex_unlock(&mpctl_mutex);
612 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
615 * cmd - specify the particular IOCTL command to be issued
616 * arg - data specific to the command. Must not be null.
619 __mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
621 mpt_ioctl_header __user *uhdr = (void __user *) arg;
622 mpt_ioctl_header khdr;
625 int nonblock = (file->f_flags & O_NONBLOCK);
627 MPT_ADAPTER *iocp = NULL;
629 if (copy_from_user(&khdr, uhdr, sizeof(khdr))) {
630 printk(KERN_ERR MYNAM "%s::mptctl_ioctl() @%d - "
631 "Unable to copy mpt_ioctl_header data @ %p\n",
632 __FILE__, __LINE__, uhdr);
635 ret = -ENXIO; /* (-6) No such device or address */
637 /* Verify intended MPT adapter - set iocnum and the adapter
640 iocnumX = khdr.iocnum & 0xFF;
641 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
646 printk(KERN_DEBUG MYNAM "%s::mptctl_ioctl() @%d - Controller disabled.\n",
651 /* Handle those commands that are just returning
652 * information stored in the driver.
653 * These commands should never time out and are unaffected
654 * by TM and FW reloads.
656 if ((cmd & ~IOCSIZE_MASK) == (MPTIOCINFO & ~IOCSIZE_MASK)) {
657 return mptctl_getiocinfo(iocp, arg, _IOC_SIZE(cmd));
658 } else if (cmd == MPTTARGETINFO) {
659 return mptctl_gettargetinfo(iocp, arg);
660 } else if (cmd == MPTTEST) {
661 return mptctl_readtest(iocp, arg);
662 } else if (cmd == MPTEVENTQUERY) {
663 return mptctl_eventquery(iocp, arg);
664 } else if (cmd == MPTEVENTENABLE) {
665 return mptctl_eventenable(iocp, arg);
666 } else if (cmd == MPTEVENTREPORT) {
667 return mptctl_eventreport(iocp, arg);
668 } else if (cmd == MPTFWREPLACE) {
669 return mptctl_replace_fw(iocp, arg);
672 /* All of these commands require an interrupt or
673 * are unknown/illegal.
675 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
678 if (cmd == MPTFWDOWNLOAD)
679 ret = mptctl_fw_download(iocp, arg);
680 else if (cmd == MPTCOMMAND)
681 ret = mptctl_mpt_command(iocp, arg);
682 else if (cmd == MPTHARDRESET)
683 ret = mptctl_do_reset(iocp, arg);
684 else if ((cmd & ~IOCSIZE_MASK) == (HP_GETHOSTINFO & ~IOCSIZE_MASK))
685 ret = mptctl_hp_hostinfo(iocp, arg, _IOC_SIZE(cmd));
686 else if (cmd == HP_GETTARGETINFO)
687 ret = mptctl_hp_targetinfo(iocp, arg);
691 mutex_unlock(&iocp->ioctl_cmds.mutex);
697 mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
700 mutex_lock(&mpctl_mutex);
701 ret = __mptctl_ioctl(file, cmd, arg);
702 mutex_unlock(&mpctl_mutex);
706 static int mptctl_do_reset(MPT_ADAPTER *iocp, unsigned long arg)
708 struct mpt_ioctl_diag_reset __user *urinfo = (void __user *) arg;
709 struct mpt_ioctl_diag_reset krinfo;
711 if (copy_from_user(&krinfo, urinfo, sizeof(struct mpt_ioctl_diag_reset))) {
712 printk(KERN_ERR MYNAM "%s@%d::mptctl_do_reset - "
713 "Unable to copy mpt_ioctl_diag_reset struct @ %p\n",
714 __FILE__, __LINE__, urinfo);
718 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "mptctl_do_reset called.\n",
721 if (mpt_HardResetHandler(iocp, CAN_SLEEP) != 0) {
722 printk (MYIOC_s_ERR_FMT "%s@%d::mptctl_do_reset - reset failed.\n",
723 iocp->name, __FILE__, __LINE__);
730 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
732 * MPT FW download function. Cast the arg into the mpt_fw_xfer structure.
733 * This structure contains: iocnum, firmware length (bytes),
734 * pointer to user space memory where the fw image is stored.
737 * Return: 0 if successful
738 * -EFAULT if data unavailable
739 * -ENXIO if no such device
740 * -EAGAIN if resource problem
741 * -ENOMEM if no memory for SGE
742 * -EMLINK if too many chain buffers required
743 * -EBADRQC if adapter does not support FW download
744 * -EBUSY if adapter is busy
745 * -ENOMSG if FW upload returned bad status
748 mptctl_fw_download(MPT_ADAPTER *iocp, unsigned long arg)
750 struct mpt_fw_xfer __user *ufwdl = (void __user *) arg;
751 struct mpt_fw_xfer kfwdl;
753 if (copy_from_user(&kfwdl, ufwdl, sizeof(struct mpt_fw_xfer))) {
754 printk(KERN_ERR MYNAM "%s@%d::_ioctl_fwdl - "
755 "Unable to copy mpt_fw_xfer struct @ %p\n",
756 __FILE__, __LINE__, ufwdl);
760 return mptctl_do_fw_download(iocp, kfwdl.bufp, kfwdl.fwlen);
763 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
765 * FW Download engine.
767 * Return: 0 if successful
768 * -EFAULT if data unavailable
769 * -ENXIO if no such device
770 * -EAGAIN if resource problem
771 * -ENOMEM if no memory for SGE
772 * -EMLINK if too many chain buffers required
773 * -EBADRQC if adapter does not support FW download
774 * -EBUSY if adapter is busy
775 * -ENOMSG if FW upload returned bad status
778 mptctl_do_fw_download(MPT_ADAPTER *iocp, char __user *ufwbuf, size_t fwlen)
782 FWDownloadTCSGE_t *ptsge;
783 MptSge_t *sgl, *sgIn;
785 struct buflist *buflist;
794 int fw_bytes_copied = 0;
798 pFWDownloadReply_t ReplyMsg = NULL;
799 unsigned long timeleft;
801 /* Valid device. Get a message frame and construct the FW download message.
803 if ((mf = mpt_get_msg_frame(mptctl_id, iocp)) == NULL)
806 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT
807 "mptctl_do_fwdl called. mptctl_id = %xh.\n", iocp->name, mptctl_id));
808 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.bufp = %p\n",
809 iocp->name, ufwbuf));
810 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.fwlen = %d\n",
811 iocp->name, (int)fwlen));
813 dlmsg = (FWDownload_t*) mf;
814 ptsge = (FWDownloadTCSGE_t *) &dlmsg->SGL;
815 sgOut = (char *) (ptsge + 1);
818 * Construct f/w download request
820 dlmsg->ImageType = MPI_FW_DOWNLOAD_ITYPE_FW;
822 dlmsg->ChainOffset = 0;
823 dlmsg->Function = MPI_FUNCTION_FW_DOWNLOAD;
824 dlmsg->Reserved1[0] = dlmsg->Reserved1[1] = dlmsg->Reserved1[2] = 0;
825 if (iocp->facts.MsgVersion >= MPI_VERSION_01_05)
826 dlmsg->MsgFlags = MPI_FW_DOWNLOAD_MSGFLGS_LAST_SEGMENT;
831 /* Set up the Transaction SGE.
834 ptsge->ContextSize = 0;
835 ptsge->DetailsLength = 12;
836 ptsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
837 ptsge->Reserved_0100_Checksum = 0;
838 ptsge->ImageOffset = 0;
839 ptsge->ImageSize = cpu_to_le32(fwlen);
845 * Need to kmalloc area(s) for holding firmware image bytes.
846 * But we need to do it piece meal, using a proper
847 * scatter gather list (with 128kB MAX hunks).
849 * A practical limit here might be # of sg hunks that fit into
850 * a single IOC request frame; 12 or 8 (see below), so:
851 * For FC9xx: 12 x 128kB == 1.5 mB (max)
852 * For C1030: 8 x 128kB == 1 mB (max)
853 * We could support chaining, but things get ugly(ier:)
855 * Set the sge_offset to the start of the sgl (bytes).
857 sgdir = 0x04000000; /* IOC will READ from sys mem */
858 sge_offset = sizeof(MPIHeader_t) + sizeof(FWDownloadTCSGE_t);
859 if ((sgl = kbuf_alloc_2_sgl(fwlen, sgdir, sge_offset,
860 &numfrags, &buflist, &sgl_dma, iocp)) == NULL)
864 * We should only need SGL with 2 simple_32bit entries (up to 256 kB)
865 * for FC9xx f/w image, but calculate max number of sge hunks
866 * we can fit into a request frame, and limit ourselves to that.
867 * (currently no chain support)
868 * maxfrags = (Request Size - FWdownload Size ) / Size of 32 bit SGE
874 maxfrags = (iocp->req_sz - sizeof(MPIHeader_t) -
875 sizeof(FWDownloadTCSGE_t))
877 if (numfrags > maxfrags) {
882 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: sgl buffer = %p, sgfrags = %d\n",
883 iocp->name, sgl, numfrags));
886 * Parse SG list, copying sgl itself,
887 * plus f/w image hunks from user space as we go...
892 for (i=0; i < numfrags; i++) {
894 /* Get the SGE type: 0 - TCSGE, 3 - Chain, 1 - Simple SGE
895 * Skip everything but Simple. If simple, copy from
896 * user space into kernel space.
897 * Note: we should not have anything but Simple as
898 * Chain SGE are illegal.
900 nib = (sgIn->FlagsLength & 0x30000000) >> 28;
901 if (nib == 0 || nib == 3) {
903 } else if (sgIn->Address) {
904 iocp->add_sge(sgOut, sgIn->FlagsLength, sgIn->Address);
906 if (copy_from_user(bl->kptr, ufwbuf+fw_bytes_copied, bl->len)) {
907 printk(MYIOC_s_ERR_FMT "%s@%d::_ioctl_fwdl - "
908 "Unable to copy f/w buffer hunk#%d @ %p\n",
909 iocp->name, __FILE__, __LINE__, n, ufwbuf);
912 fw_bytes_copied += bl->len;
916 sgOut += iocp->SGE_size;
919 DBG_DUMP_FW_DOWNLOAD(iocp, (u32 *)mf, numfrags);
922 * Finally, perform firmware download.
925 SET_MGMT_MSG_CONTEXT(iocp->ioctl_cmds.msg_context, dlmsg->MsgContext);
926 INITIALIZE_MGMT_STATUS(iocp->ioctl_cmds.status)
927 mpt_put_msg_frame(mptctl_id, iocp, mf);
929 /* Now wait for the command to complete */
931 timeleft = wait_for_completion_timeout(&iocp->ioctl_cmds.done, HZ*60);
932 if (!(iocp->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
934 printk(MYIOC_s_WARN_FMT "%s: failed\n", iocp->name, __func__);
935 if (iocp->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
936 mpt_free_msg_frame(iocp, mf);
940 printk(MYIOC_s_WARN_FMT
941 "FW download timeout, doorbell=0x%08x\n",
942 iocp->name, mpt_GetIocState(iocp, 0));
943 mptctl_timeout_expired(iocp, mf);
949 if (!(iocp->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
950 printk(MYIOC_s_WARN_FMT "%s: failed\n", iocp->name, __func__);
951 mpt_free_msg_frame(iocp, mf);
957 kfree_sgl(sgl, sgl_dma, buflist, iocp);
959 ReplyMsg = (pFWDownloadReply_t)iocp->ioctl_cmds.reply;
960 iocstat = le16_to_cpu(ReplyMsg->IOCStatus) & MPI_IOCSTATUS_MASK;
961 if (iocstat == MPI_IOCSTATUS_SUCCESS) {
962 printk(MYIOC_s_INFO_FMT "F/W update successful!\n", iocp->name);
964 } else if (iocstat == MPI_IOCSTATUS_INVALID_FUNCTION) {
965 printk(MYIOC_s_WARN_FMT "Hmmm... F/W download not supported!?!\n",
967 printk(MYIOC_s_WARN_FMT "(time to go bang on somebodies door)\n",
970 } else if (iocstat == MPI_IOCSTATUS_BUSY) {
971 printk(MYIOC_s_WARN_FMT "IOC_BUSY!\n", iocp->name);
972 printk(MYIOC_s_WARN_FMT "(try again later?)\n", iocp->name);
975 printk(MYIOC_s_WARN_FMT "ioctl_fwdl() returned [bad] status = %04xh\n",
976 iocp->name, iocstat);
977 printk(MYIOC_s_WARN_FMT "(bad VooDoo)\n", iocp->name);
984 CLEAR_MGMT_STATUS(iocp->ioctl_cmds.status);
985 SET_MGMT_MSG_CONTEXT(iocp->ioctl_cmds.msg_context, 0);
986 kfree_sgl(sgl, sgl_dma, buflist, iocp);
990 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
992 * SGE Allocation routine
994 * Inputs: bytes - number of bytes to be transferred
995 * sgdir - data direction
996 * sge_offset - offset (in bytes) from the start of the request
997 * frame to the first SGE
998 * ioc - pointer to the mptadapter
999 * Outputs: frags - number of scatter gather elements
1000 * blp - point to the buflist pointer
1001 * sglbuf_dma - pointer to the (dma) sgl
1002 * Returns: Null if failes
1003 * pointer to the (virtual) sgl if successful.
1006 kbuf_alloc_2_sgl(int bytes, u32 sgdir, int sge_offset, int *frags,
1007 struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc)
1009 MptSge_t *sglbuf = NULL; /* pointer to array of SGE */
1010 /* and chain buffers */
1011 struct buflist *buflist = NULL; /* kernel routine */
1015 int alloc_sz = min(bytes,MAX_KMALLOC_SZ); // avoid kernel warning msg!
1016 int bytes_allocd = 0;
1018 dma_addr_t pa; // phys addr
1020 int sg_spill = MAX_FRAGS_SPILL1;
1026 /* initialization */
1030 /* Allocate and initialize an array of kernel
1031 * structures for the SG elements.
1033 i = MAX_SGL_BYTES / 8;
1034 buflist = kzalloc(i, GFP_USER);
1039 /* Allocate a single block of memory to store the sg elements and
1040 * the chain buffers. The calling routine is responsible for
1041 * copying the data in this array into the correct place in the
1042 * request and chain buffers.
1044 sglbuf = pci_alloc_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf_dma);
1048 if (sgdir & 0x04000000)
1049 dir = PCI_DMA_TODEVICE;
1051 dir = PCI_DMA_FROMDEVICE;
1054 * sgl = sglbuf = point to beginning of sg buffer
1055 * buflist_ent = 0 = first kernel structure
1056 * sg_spill = number of SGE that can be written before the first
1061 sg_spill = ((ioc->req_sz - sge_offset)/ioc->SGE_size) - 1;
1062 while (bytes_allocd < bytes) {
1063 this_alloc = min(alloc_sz, bytes-bytes_allocd);
1064 buflist[buflist_ent].len = this_alloc;
1065 buflist[buflist_ent].kptr = pci_alloc_consistent(ioc->pcidev,
1068 if (buflist[buflist_ent].kptr == NULL) {
1069 alloc_sz = alloc_sz / 2;
1070 if (alloc_sz == 0) {
1071 printk(MYIOC_s_WARN_FMT "-SG: No can do - "
1072 "not enough memory! :-(\n", ioc->name);
1073 printk(MYIOC_s_WARN_FMT "-SG: (freeing %d frags)\n",
1074 ioc->name, numfrags);
1079 dma_addr_t dma_addr;
1081 bytes_allocd += this_alloc;
1082 sgl->FlagsLength = (0x10000000|sgdir|this_alloc);
1083 dma_addr = pci_map_single(ioc->pcidev,
1084 buflist[buflist_ent].kptr, this_alloc, dir);
1085 sgl->Address = dma_addr;
1093 if (bytes_allocd >= bytes)
1096 /* Need to chain? */
1097 if (fragcnt == sg_spill) {
1098 printk(MYIOC_s_WARN_FMT
1099 "-SG: No can do - " "Chain required! :-(\n", ioc->name);
1100 printk(MYIOC_s_WARN_FMT "(freeing %d frags)\n", ioc->name, numfrags);
1104 /* overflow check... */
1105 if (numfrags*8 > MAX_SGL_BYTES){
1107 printk(MYIOC_s_WARN_FMT "-SG: No can do - "
1108 "too many SG frags! :-(\n", ioc->name);
1109 printk(MYIOC_s_WARN_FMT "-SG: (freeing %d frags)\n",
1110 ioc->name, numfrags);
1115 /* Last sge fixup: set LE+eol+eob bits */
1116 sgl[-1].FlagsLength |= 0xC1000000;
1121 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: kbuf_alloc_2_sgl() - "
1122 "%d SG frags generated!\n", ioc->name, numfrags));
1124 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: kbuf_alloc_2_sgl() - "
1125 "last (big) alloc_sz=%d\n", ioc->name, alloc_sz));
1130 if (sglbuf != NULL) {
1131 for (i = 0; i < numfrags; i++) {
1132 dma_addr_t dma_addr;
1136 if ((sglbuf[i].FlagsLength >> 24) == 0x30)
1139 dma_addr = sglbuf[i].Address;
1140 kptr = buflist[i].kptr;
1141 len = buflist[i].len;
1143 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1145 pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf, *sglbuf_dma);
1151 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1153 * Routine to free the SGL elements.
1156 kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma, struct buflist *buflist, MPT_ADAPTER *ioc)
1159 struct buflist *bl = buflist;
1164 if (sg->FlagsLength & 0x04000000)
1165 dir = PCI_DMA_TODEVICE;
1167 dir = PCI_DMA_FROMDEVICE;
1169 nib = (sg->FlagsLength & 0xF0000000) >> 28;
1170 while (! (nib & 0x4)) { /* eob */
1171 /* skip ignore/chain. */
1172 if (nib == 0 || nib == 3) {
1174 } else if (sg->Address) {
1175 dma_addr_t dma_addr;
1179 dma_addr = sg->Address;
1182 pci_unmap_single(ioc->pcidev, dma_addr, len, dir);
1183 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1188 nib = (le32_to_cpu(sg->FlagsLength) & 0xF0000000) >> 28;
1193 dma_addr_t dma_addr;
1197 dma_addr = sg->Address;
1200 pci_unmap_single(ioc->pcidev, dma_addr, len, dir);
1201 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1205 pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sgl, sgl_dma);
1207 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: Free'd 1 SGL buf + %d kbufs!\n",
1211 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1213 * mptctl_getiocinfo - Query the host adapter for IOC information.
1214 * @arg: User space argument
1217 * Return: 0 if successful
1218 * -EFAULT if data unavailable
1219 * -ENODEV if no such device/adapter
1222 mptctl_getiocinfo (MPT_ADAPTER *ioc, unsigned long arg, unsigned int data_size)
1224 struct mpt_ioctl_iocinfo __user *uarg = (void __user *) arg;
1225 struct mpt_ioctl_iocinfo *karg;
1226 struct pci_dev *pdev;
1229 struct scsi_device *sdev;
1230 VirtDevice *vdevice;
1232 /* Add of PCI INFO results in unaligned access for
1233 * IA64 and Sparc. Reset long to int. Return no PCI
1234 * data for obsolete format.
1236 if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev0))
1238 else if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev1))
1240 else if (data_size == sizeof(struct mpt_ioctl_iocinfo))
1242 else if (data_size == (sizeof(struct mpt_ioctl_iocinfo_rev0)+12))
1243 cim_rev = 0; /* obsolete */
1247 karg = memdup_user(uarg, data_size);
1249 printk(KERN_ERR MYNAM "%s@%d::mpt_ioctl_iocinfo() - memdup_user returned error [%ld]\n",
1250 __FILE__, __LINE__, PTR_ERR(karg));
1251 return PTR_ERR(karg);
1254 /* Verify the data transfer size is correct. */
1255 if (karg->hdr.maxDataSize != data_size) {
1256 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_getiocinfo - "
1257 "Structure size mismatch. Command not completed.\n",
1258 ioc->name, __FILE__, __LINE__);
1263 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_getiocinfo called.\n",
1266 /* Fill in the data and return the structure to the calling
1269 if (ioc->bus_type == SAS)
1270 karg->adapterType = MPT_IOCTL_INTERFACE_SAS;
1271 else if (ioc->bus_type == FC)
1272 karg->adapterType = MPT_IOCTL_INTERFACE_FC;
1274 karg->adapterType = MPT_IOCTL_INTERFACE_SCSI;
1276 if (karg->hdr.port > 1) {
1280 port = karg->hdr.port;
1283 pdev = (struct pci_dev *) ioc->pcidev;
1285 karg->pciId = pdev->device;
1286 karg->hwRev = pdev->revision;
1287 karg->subSystemDevice = pdev->subsystem_device;
1288 karg->subSystemVendor = pdev->subsystem_vendor;
1291 /* Get the PCI bus, device, and function numbers for the IOC
1293 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1294 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1295 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1296 } else if (cim_rev == 2) {
1297 /* Get the PCI bus, device, function and segment ID numbers
1299 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1300 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1301 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1302 karg->pciInfo.segmentID = pci_domain_nr(pdev->bus);
1305 /* Get number of devices
1307 karg->numDevices = 0;
1309 shost_for_each_device(sdev, ioc->sh) {
1310 vdevice = sdev->hostdata;
1311 if (vdevice == NULL || vdevice->vtarget == NULL)
1313 if (vdevice->vtarget->tflags &
1314 MPT_TARGET_FLAGS_RAID_COMPONENT)
1320 /* Set the BIOS and FW Version
1322 karg->FWVersion = ioc->facts.FWVersion.Word;
1323 karg->BIOSVersion = ioc->biosVersion;
1325 /* Set the Version Strings.
1327 strncpy (karg->driverVersion, MPT_LINUX_PACKAGE_NAME, MPT_IOCTL_VERSION_LENGTH);
1328 karg->driverVersion[MPT_IOCTL_VERSION_LENGTH-1]='\0';
1330 karg->busChangeEvent = 0;
1331 karg->hostId = ioc->pfacts[port].PortSCSIID;
1332 karg->rsvd[0] = karg->rsvd[1] = 0;
1334 /* Copy the data from kernel memory to user memory
1336 if (copy_to_user((char __user *)arg, karg, data_size)) {
1337 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_getiocinfo - "
1338 "Unable to write out mpt_ioctl_iocinfo struct @ %p\n",
1339 ioc->name, __FILE__, __LINE__, uarg);
1348 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1350 * mptctl_gettargetinfo - Query the host adapter for target information.
1351 * @arg: User space argument
1354 * Return: 0 if successful
1355 * -EFAULT if data unavailable
1356 * -ENODEV if no such device/adapter
1359 mptctl_gettargetinfo (MPT_ADAPTER *ioc, unsigned long arg)
1361 struct mpt_ioctl_targetinfo __user *uarg = (void __user *) arg;
1362 struct mpt_ioctl_targetinfo karg;
1363 VirtDevice *vdevice;
1370 struct scsi_device *sdev;
1372 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_targetinfo))) {
1373 printk(KERN_ERR MYNAM "%s@%d::mptctl_gettargetinfo - "
1374 "Unable to read in mpt_ioctl_targetinfo struct @ %p\n",
1375 __FILE__, __LINE__, uarg);
1379 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_gettargetinfo called.\n",
1381 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1382 maxWordsLeft = numBytes/sizeof(int);
1384 if (maxWordsLeft <= 0) {
1385 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo() - no memory available!\n",
1386 ioc->name, __FILE__, __LINE__);
1390 /* Fill in the data and return the structure to the calling
1394 /* struct mpt_ioctl_targetinfo does not contain sufficient space
1395 * for the target structures so when the IOCTL is called, there is
1396 * not sufficient stack space for the structure. Allocate memory,
1397 * populate the memory, copy back to the user, then free memory.
1398 * targetInfo format:
1399 * bits 31-24: reserved
1404 pmem = kzalloc(numBytes, GFP_KERNEL);
1406 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo() - no memory available!\n",
1407 ioc->name, __FILE__, __LINE__);
1410 pdata = (int *) pmem;
1412 /* Get number of devices
1415 shost_for_each_device(sdev, ioc->sh) {
1418 vdevice = sdev->hostdata;
1419 if (vdevice == NULL || vdevice->vtarget == NULL)
1421 if (vdevice->vtarget->tflags &
1422 MPT_TARGET_FLAGS_RAID_COMPONENT)
1424 lun = (vdevice->vtarget->raidVolume) ? 0x80 : vdevice->lun;
1425 *pdata = (((u8)lun << 16) + (vdevice->vtarget->channel << 8) +
1426 (vdevice->vtarget->id ));
1432 karg.numDevices = numDevices;
1434 /* Copy part of the data from kernel memory to user memory
1436 if (copy_to_user((char __user *)arg, &karg,
1437 sizeof(struct mpt_ioctl_targetinfo))) {
1438 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo - "
1439 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1440 ioc->name, __FILE__, __LINE__, uarg);
1445 /* Copy the remaining data from kernel memory to user memory
1447 if (copy_to_user(uarg->targetInfo, pmem, numBytes)) {
1448 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo - "
1449 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1450 ioc->name, __FILE__, __LINE__, pdata);
1460 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1461 /* MPT IOCTL Test function.
1464 * Return: 0 if successful
1465 * -EFAULT if data unavailable
1466 * -ENODEV if no such device/adapter
1469 mptctl_readtest (MPT_ADAPTER *ioc, unsigned long arg)
1471 struct mpt_ioctl_test __user *uarg = (void __user *) arg;
1472 struct mpt_ioctl_test karg;
1474 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_test))) {
1475 printk(KERN_ERR MYNAM "%s@%d::mptctl_readtest - "
1476 "Unable to read in mpt_ioctl_test struct @ %p\n",
1477 __FILE__, __LINE__, uarg);
1481 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_readtest called.\n",
1483 /* Fill in the data and return the structure to the calling
1488 karg.chip_type = ioc->mfcnt;
1490 karg.chip_type = ioc->pcidev->device;
1492 strncpy (karg.name, ioc->name, MPT_MAX_NAME);
1493 karg.name[MPT_MAX_NAME-1]='\0';
1494 strncpy (karg.product, ioc->prod_name, MPT_PRODUCT_LENGTH);
1495 karg.product[MPT_PRODUCT_LENGTH-1]='\0';
1497 /* Copy the data from kernel memory to user memory
1499 if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_test))) {
1500 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_readtest - "
1501 "Unable to write out mpt_ioctl_test struct @ %p\n",
1502 ioc->name, __FILE__, __LINE__, uarg);
1509 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1511 * mptctl_eventquery - Query the host adapter for the event types
1512 * that are being logged.
1513 * @arg: User space argument
1516 * Return: 0 if successful
1517 * -EFAULT if data unavailable
1518 * -ENODEV if no such device/adapter
1521 mptctl_eventquery (MPT_ADAPTER *ioc, unsigned long arg)
1523 struct mpt_ioctl_eventquery __user *uarg = (void __user *) arg;
1524 struct mpt_ioctl_eventquery karg;
1526 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventquery))) {
1527 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventquery - "
1528 "Unable to read in mpt_ioctl_eventquery struct @ %p\n",
1529 __FILE__, __LINE__, uarg);
1533 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventquery called.\n",
1535 karg.eventEntries = MPTCTL_EVENT_LOG_SIZE;
1536 karg.eventTypes = ioc->eventTypes;
1538 /* Copy the data from kernel memory to user memory
1540 if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_eventquery))) {
1541 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_eventquery - "
1542 "Unable to write out mpt_ioctl_eventquery struct @ %p\n",
1543 ioc->name, __FILE__, __LINE__, uarg);
1549 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1551 mptctl_eventenable (MPT_ADAPTER *ioc, unsigned long arg)
1553 struct mpt_ioctl_eventenable __user *uarg = (void __user *) arg;
1554 struct mpt_ioctl_eventenable karg;
1556 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventenable))) {
1557 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventenable - "
1558 "Unable to read in mpt_ioctl_eventenable struct @ %p\n",
1559 __FILE__, __LINE__, uarg);
1563 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventenable called.\n",
1565 if (ioc->events == NULL) {
1566 /* Have not yet allocated memory - do so now.
1568 int sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
1569 ioc->events = kzalloc(sz, GFP_KERNEL);
1571 printk(MYIOC_s_ERR_FMT
1572 ": ERROR - Insufficient memory to add adapter!\n",
1576 ioc->alloc_total += sz;
1578 ioc->eventContext = 0;
1581 /* Update the IOC event logging flag.
1583 ioc->eventTypes = karg.eventTypes;
1588 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1590 mptctl_eventreport (MPT_ADAPTER *ioc, unsigned long arg)
1592 struct mpt_ioctl_eventreport __user *uarg = (void __user *) arg;
1593 struct mpt_ioctl_eventreport karg;
1594 int numBytes, maxEvents, max;
1596 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventreport))) {
1597 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventreport - "
1598 "Unable to read in mpt_ioctl_eventreport struct @ %p\n",
1599 __FILE__, __LINE__, uarg);
1603 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventreport called.\n",
1606 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1607 maxEvents = numBytes/sizeof(MPT_IOCTL_EVENTS);
1610 max = MPTCTL_EVENT_LOG_SIZE < maxEvents ? MPTCTL_EVENT_LOG_SIZE : maxEvents;
1612 /* If fewer than 1 event is requested, there must have
1613 * been some type of error.
1615 if ((max < 1) || !ioc->events)
1618 /* reset this flag so SIGIO can restart */
1619 ioc->aen_event_read_flag=0;
1621 /* Copy the data from kernel memory to user memory
1623 numBytes = max * sizeof(MPT_IOCTL_EVENTS);
1624 if (copy_to_user(uarg->eventData, ioc->events, numBytes)) {
1625 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_eventreport - "
1626 "Unable to write out mpt_ioctl_eventreport struct @ %p\n",
1627 ioc->name, __FILE__, __LINE__, ioc->events);
1634 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1636 mptctl_replace_fw (MPT_ADAPTER *ioc, unsigned long arg)
1638 struct mpt_ioctl_replace_fw __user *uarg = (void __user *) arg;
1639 struct mpt_ioctl_replace_fw karg;
1642 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_replace_fw))) {
1643 printk(KERN_ERR MYNAM "%s@%d::mptctl_replace_fw - "
1644 "Unable to read in mpt_ioctl_replace_fw struct @ %p\n",
1645 __FILE__, __LINE__, uarg);
1649 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_replace_fw called.\n",
1651 /* If caching FW, Free the old FW image
1653 if (ioc->cached_fw == NULL)
1656 mpt_free_fw_memory(ioc);
1658 /* Allocate memory for the new FW image
1660 newFwSize = ALIGN(karg.newImageSize, 4);
1662 mpt_alloc_fw_memory(ioc, newFwSize);
1663 if (ioc->cached_fw == NULL)
1666 /* Copy the data from user memory to kernel space
1668 if (copy_from_user(ioc->cached_fw, uarg->newImage, newFwSize)) {
1669 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_replace_fw - "
1670 "Unable to read in mpt_ioctl_replace_fw image "
1671 "@ %p\n", ioc->name, __FILE__, __LINE__, uarg);
1672 mpt_free_fw_memory(ioc);
1676 /* Update IOCFactsReply
1678 ioc->facts.FWImageSize = newFwSize;
1682 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1683 /* MPT IOCTL MPTCOMMAND function.
1684 * Cast the arg into the mpt_ioctl_mpt_command structure.
1687 * Return: 0 if successful
1688 * -EBUSY if previous command timeout and IOC reset is not complete.
1689 * -EFAULT if data unavailable
1690 * -ENODEV if no such device/adapter
1691 * -ETIME if timer expires
1692 * -ENOMEM if memory allocation error
1695 mptctl_mpt_command (MPT_ADAPTER *ioc, unsigned long arg)
1697 struct mpt_ioctl_command __user *uarg = (void __user *) arg;
1698 struct mpt_ioctl_command karg;
1702 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_command))) {
1703 printk(KERN_ERR MYNAM "%s@%d::mptctl_mpt_command - "
1704 "Unable to read in mpt_ioctl_command struct @ %p\n",
1705 __FILE__, __LINE__, uarg);
1709 rc = mptctl_do_mpt_command (ioc, karg, &uarg->MF);
1714 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1715 /* Worker routine for the IOCTL MPTCOMMAND and MPTCOMMAND32 (sparc) commands.
1718 * Return: 0 if successful
1719 * -EBUSY if previous command timeout and IOC reset is not complete.
1720 * -EFAULT if data unavailable
1721 * -ENODEV if no such device/adapter
1722 * -ETIME if timer expires
1723 * -ENOMEM if memory allocation error
1724 * -EPERM if SCSI I/O and target is untagged
1727 mptctl_do_mpt_command (MPT_ADAPTER *ioc, struct mpt_ioctl_command karg, void __user *mfPtr)
1729 MPT_FRAME_HDR *mf = NULL;
1732 struct buflist bufIn; /* data In buffer */
1733 struct buflist bufOut; /* data Out buffer */
1734 dma_addr_t dma_addr_in;
1735 dma_addr_t dma_addr_out;
1736 int sgSize = 0; /* Num SG elements */
1742 unsigned long timeleft;
1743 struct scsi_device *sdev;
1744 unsigned long flags;
1747 /* bufIn and bufOut are used for user to kernel space transfers
1749 bufIn.kptr = bufOut.kptr = NULL;
1750 bufIn.len = bufOut.len = 0;
1752 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
1753 if (ioc->ioc_reset_in_progress) {
1754 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
1755 printk(KERN_ERR MYNAM "%s@%d::mptctl_do_mpt_command - "
1756 "Busy with diagnostic reset\n", __FILE__, __LINE__);
1759 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
1761 /* Basic sanity checks to prevent underflows or integer overflows */
1762 if (karg.maxReplyBytes < 0 ||
1763 karg.dataInSize < 0 ||
1764 karg.dataOutSize < 0 ||
1765 karg.dataSgeOffset < 0 ||
1766 karg.maxSenseBytes < 0 ||
1767 karg.dataSgeOffset > ioc->req_sz / 4)
1770 /* Verify that the final request frame will not be too large.
1772 sz = karg.dataSgeOffset * 4;
1773 if (karg.dataInSize > 0)
1774 sz += ioc->SGE_size;
1775 if (karg.dataOutSize > 0)
1776 sz += ioc->SGE_size;
1778 if (sz > ioc->req_sz) {
1779 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1780 "Request frame too large (%d) maximum (%d)\n",
1781 ioc->name, __FILE__, __LINE__, sz, ioc->req_sz);
1785 /* Get a free request frame and save the message context.
1787 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
1790 hdr = (MPIHeader_t *) mf;
1791 msgContext = le32_to_cpu(hdr->MsgContext);
1792 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1794 /* Copy the request frame
1795 * Reset the saved message context.
1796 * Request frame in user space
1798 if (copy_from_user(mf, mfPtr, karg.dataSgeOffset * 4)) {
1799 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1800 "Unable to read MF from mpt_ioctl_command struct @ %p\n",
1801 ioc->name, __FILE__, __LINE__, mfPtr);
1806 hdr->MsgContext = cpu_to_le32(msgContext);
1807 function = hdr->Function;
1810 /* Verify that this request is allowed.
1812 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sending mpi function (0x%02X), req=%p\n",
1813 ioc->name, hdr->Function, mf));
1816 case MPI_FUNCTION_IOC_FACTS:
1817 case MPI_FUNCTION_PORT_FACTS:
1818 karg.dataOutSize = karg.dataInSize = 0;
1821 case MPI_FUNCTION_CONFIG:
1823 Config_t *config_frame;
1824 config_frame = (Config_t *)mf;
1825 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\ttype=0x%02x ext_type=0x%02x "
1826 "number=0x%02x action=0x%02x\n", ioc->name,
1827 config_frame->Header.PageType,
1828 config_frame->ExtPageType,
1829 config_frame->Header.PageNumber,
1830 config_frame->Action));
1834 case MPI_FUNCTION_FC_COMMON_TRANSPORT_SEND:
1835 case MPI_FUNCTION_FC_EX_LINK_SRVC_SEND:
1836 case MPI_FUNCTION_FW_UPLOAD:
1837 case MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR:
1838 case MPI_FUNCTION_FW_DOWNLOAD:
1839 case MPI_FUNCTION_FC_PRIMITIVE_SEND:
1840 case MPI_FUNCTION_TOOLBOX:
1841 case MPI_FUNCTION_SAS_IO_UNIT_CONTROL:
1844 case MPI_FUNCTION_SCSI_IO_REQUEST:
1846 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
1847 int qtag = MPI_SCSIIO_CONTROL_UNTAGGED;
1852 id = (ioc->devices_per_bus == 0) ? 256 : ioc->devices_per_bus;
1853 if (pScsiReq->TargetID > id) {
1854 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1855 "Target ID out of bounds. \n",
1856 ioc->name, __FILE__, __LINE__);
1861 if (pScsiReq->Bus >= ioc->number_of_buses) {
1862 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1863 "Target Bus out of bounds. \n",
1864 ioc->name, __FILE__, __LINE__);
1869 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
1870 pScsiReq->MsgFlags |= mpt_msg_flags(ioc);
1873 /* verify that app has not requested
1874 * more sense data than driver
1875 * can provide, if so, reset this parameter
1876 * set the sense buffer pointer low address
1877 * update the control field to specify Q type
1879 if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1880 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1882 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1884 pScsiReq->SenseBufferLowAddr =
1885 cpu_to_le32(ioc->sense_buf_low_dma
1886 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
1888 shost_for_each_device(sdev, ioc->sh) {
1889 struct scsi_target *starget = scsi_target(sdev);
1890 VirtTarget *vtarget = starget->hostdata;
1892 if (vtarget == NULL)
1895 if ((pScsiReq->TargetID == vtarget->id) &&
1896 (pScsiReq->Bus == vtarget->channel) &&
1897 (vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
1898 qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
1901 /* Have the IOCTL driver set the direction based
1902 * on the dataOutSize (ordering issue with Sparc).
1904 if (karg.dataOutSize > 0) {
1905 scsidir = MPI_SCSIIO_CONTROL_WRITE;
1906 dataSize = karg.dataOutSize;
1908 scsidir = MPI_SCSIIO_CONTROL_READ;
1909 dataSize = karg.dataInSize;
1912 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
1913 pScsiReq->DataLength = cpu_to_le32(dataSize);
1917 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1918 "SCSI driver is not loaded. \n",
1919 ioc->name, __FILE__, __LINE__);
1925 case MPI_FUNCTION_SMP_PASSTHROUGH:
1926 /* Check mf->PassthruFlags to determine if
1927 * transfer is ImmediateMode or not.
1928 * Immediate mode returns data in the ReplyFrame.
1929 * Else, we are sending request and response data
1930 * in two SGLs at the end of the mf.
1934 case MPI_FUNCTION_SATA_PASSTHROUGH:
1936 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1937 "SCSI driver is not loaded. \n",
1938 ioc->name, __FILE__, __LINE__);
1944 case MPI_FUNCTION_RAID_ACTION:
1949 case MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
1951 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
1952 int qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
1953 int scsidir = MPI_SCSIIO_CONTROL_READ;
1956 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
1957 pScsiReq->MsgFlags |= mpt_msg_flags(ioc);
1960 /* verify that app has not requested
1961 * more sense data than driver
1962 * can provide, if so, reset this parameter
1963 * set the sense buffer pointer low address
1964 * update the control field to specify Q type
1966 if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1967 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1969 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1971 pScsiReq->SenseBufferLowAddr =
1972 cpu_to_le32(ioc->sense_buf_low_dma
1973 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
1975 /* All commands to physical devices are tagged
1978 /* Have the IOCTL driver set the direction based
1979 * on the dataOutSize (ordering issue with Sparc).
1981 if (karg.dataOutSize > 0) {
1982 scsidir = MPI_SCSIIO_CONTROL_WRITE;
1983 dataSize = karg.dataOutSize;
1985 scsidir = MPI_SCSIIO_CONTROL_READ;
1986 dataSize = karg.dataInSize;
1989 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
1990 pScsiReq->DataLength = cpu_to_le32(dataSize);
1993 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1994 "SCSI driver is not loaded. \n",
1995 ioc->name, __FILE__, __LINE__);
2001 case MPI_FUNCTION_SCSI_TASK_MGMT:
2003 SCSITaskMgmt_t *pScsiTm;
2004 pScsiTm = (SCSITaskMgmt_t *)mf;
2005 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2006 "\tTaskType=0x%x MsgFlags=0x%x "
2007 "TaskMsgContext=0x%x id=%d channel=%d\n",
2008 ioc->name, pScsiTm->TaskType, le32_to_cpu
2009 (pScsiTm->TaskMsgContext), pScsiTm->MsgFlags,
2010 pScsiTm->TargetID, pScsiTm->Bus));
2014 case MPI_FUNCTION_IOC_INIT:
2016 IOCInit_t *pInit = (IOCInit_t *) mf;
2017 u32 high_addr, sense_high;
2019 /* Verify that all entries in the IOC INIT match
2020 * existing setup (and in LE format).
2022 if (sizeof(dma_addr_t) == sizeof(u64)) {
2023 high_addr = cpu_to_le32((u32)((u64)ioc->req_frames_dma >> 32));
2024 sense_high= cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
2030 if ((pInit->Flags != 0) || (pInit->MaxDevices != ioc->facts.MaxDevices) ||
2031 (pInit->MaxBuses != ioc->facts.MaxBuses) ||
2032 (pInit->ReplyFrameSize != cpu_to_le16(ioc->reply_sz)) ||
2033 (pInit->HostMfaHighAddr != high_addr) ||
2034 (pInit->SenseBufferHighAddr != sense_high)) {
2035 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2036 "IOC_INIT issued with 1 or more incorrect parameters. Rejected.\n",
2037 ioc->name, __FILE__, __LINE__);
2045 * MPI_FUNCTION_PORT_ENABLE
2046 * MPI_FUNCTION_TARGET_CMD_BUFFER_POST
2047 * MPI_FUNCTION_TARGET_ASSIST
2048 * MPI_FUNCTION_TARGET_STATUS_SEND
2049 * MPI_FUNCTION_TARGET_MODE_ABORT
2050 * MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET
2051 * MPI_FUNCTION_IO_UNIT_RESET
2052 * MPI_FUNCTION_HANDSHAKE
2053 * MPI_FUNCTION_REPLY_FRAME_REMOVAL
2054 * MPI_FUNCTION_EVENT_NOTIFICATION
2055 * (driver handles event notification)
2056 * MPI_FUNCTION_EVENT_ACK
2059 /* What to do with these??? CHECK ME!!!
2060 MPI_FUNCTION_FC_LINK_SRVC_BUF_POST
2061 MPI_FUNCTION_FC_LINK_SRVC_RSP
2062 MPI_FUNCTION_FC_ABORT
2063 MPI_FUNCTION_LAN_SEND
2064 MPI_FUNCTION_LAN_RECEIVE
2065 MPI_FUNCTION_LAN_RESET
2068 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2069 "Illegal request (function 0x%x) \n",
2070 ioc->name, __FILE__, __LINE__, hdr->Function);
2075 /* Add the SGL ( at most one data in SGE and one data out SGE )
2076 * In the case of two SGE's - the data out (write) will always
2077 * preceede the data in (read) SGE. psgList is used to free the
2080 psge = (char *) (((int *) mf) + karg.dataSgeOffset);
2083 if (karg.dataOutSize > 0)
2086 if (karg.dataInSize > 0)
2091 /* Set up the dataOut memory allocation */
2092 if (karg.dataOutSize > 0) {
2093 if (karg.dataInSize > 0) {
2094 flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2095 MPI_SGE_FLAGS_END_OF_BUFFER |
2096 MPI_SGE_FLAGS_DIRECTION)
2097 << MPI_SGE_FLAGS_SHIFT;
2099 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
2101 flagsLength |= karg.dataOutSize;
2102 bufOut.len = karg.dataOutSize;
2103 bufOut.kptr = pci_alloc_consistent(
2104 ioc->pcidev, bufOut.len, &dma_addr_out);
2106 if (bufOut.kptr == NULL) {
2111 * Copy to MF and to sglbuf
2113 ioc->add_sge(psge, flagsLength, dma_addr_out);
2114 psge += ioc->SGE_size;
2116 /* Copy user data to kernel space.
2118 if (copy_from_user(bufOut.kptr,
2121 printk(MYIOC_s_ERR_FMT
2122 "%s@%d::mptctl_do_mpt_command - Unable "
2123 "to read user data "
2125 ioc->name, __FILE__, __LINE__,karg.dataOutBufPtr);
2132 if (karg.dataInSize > 0) {
2133 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
2134 flagsLength |= karg.dataInSize;
2136 bufIn.len = karg.dataInSize;
2137 bufIn.kptr = pci_alloc_consistent(ioc->pcidev,
2138 bufIn.len, &dma_addr_in);
2140 if (bufIn.kptr == NULL) {
2145 * Copy to MF and to sglbuf
2147 ioc->add_sge(psge, flagsLength, dma_addr_in);
2153 ioc->add_sge(psge, flagsLength, (dma_addr_t) -1);
2156 SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, hdr->MsgContext);
2157 INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
2158 if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT) {
2160 mutex_lock(&ioc->taskmgmt_cmds.mutex);
2161 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
2162 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2166 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
2168 if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
2169 (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
2170 mpt_put_msg_frame_hi_pri(mptctl_id, ioc, mf);
2172 rc =mpt_send_handshake_request(mptctl_id, ioc,
2173 sizeof(SCSITaskMgmt_t), (u32*)mf, CAN_SLEEP);
2175 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2176 "send_handshake FAILED! (ioc %p, mf %p)\n",
2177 ioc->name, ioc, mf));
2178 mpt_clear_taskmgmt_in_progress_flag(ioc);
2180 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2186 mpt_put_msg_frame(mptctl_id, ioc, mf);
2188 /* Now wait for the command to complete */
2189 timeout = (karg.timeout > 0) ? karg.timeout : MPT_IOCTL_DEFAULT_TIMEOUT;
2191 timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
2193 if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2195 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "%s: TIMED OUT!\n",
2196 ioc->name, __func__));
2197 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2198 if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2199 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2203 printk(MYIOC_s_WARN_FMT
2204 "mpt cmd timeout, doorbell=0x%08x"
2206 ioc->name, mpt_GetIocState(ioc, 0), function);
2207 if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2208 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2209 mptctl_timeout_expired(ioc, mf);
2216 if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2217 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2222 /* If a valid reply frame, copy to the user.
2223 * Offset 2: reply length in U32's
2225 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) {
2226 if (karg.maxReplyBytes < ioc->reply_sz) {
2227 sz = min(karg.maxReplyBytes,
2228 4*ioc->ioctl_cmds.reply[2]);
2230 sz = min(ioc->reply_sz, 4*ioc->ioctl_cmds.reply[2]);
2233 if (copy_to_user(karg.replyFrameBufPtr,
2234 ioc->ioctl_cmds.reply, sz)){
2235 printk(MYIOC_s_ERR_FMT
2236 "%s@%d::mptctl_do_mpt_command - "
2237 "Unable to write out reply frame %p\n",
2238 ioc->name, __FILE__, __LINE__, karg.replyFrameBufPtr);
2245 /* If valid sense data, copy to user.
2247 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_SENSE_VALID) {
2248 sz = min(karg.maxSenseBytes, MPT_SENSE_BUFFER_SIZE);
2250 if (copy_to_user(karg.senseDataPtr,
2251 ioc->ioctl_cmds.sense, sz)) {
2252 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2253 "Unable to write sense data to user %p\n",
2254 ioc->name, __FILE__, __LINE__,
2262 /* If the overall status is _GOOD and data in, copy data
2265 if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD) &&
2266 (karg.dataInSize > 0) && (bufIn.kptr)) {
2268 if (copy_to_user(karg.dataInBufPtr,
2269 bufIn.kptr, karg.dataInSize)) {
2270 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2271 "Unable to write data to user %p\n",
2272 ioc->name, __FILE__, __LINE__,
2280 CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
2281 SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
2283 /* Free the allocated memory.
2285 if (bufOut.kptr != NULL) {
2286 pci_free_consistent(ioc->pcidev,
2287 bufOut.len, (void *) bufOut.kptr, dma_addr_out);
2290 if (bufIn.kptr != NULL) {
2291 pci_free_consistent(ioc->pcidev,
2292 bufIn.len, (void *) bufIn.kptr, dma_addr_in);
2295 /* mf is null if command issued successfully
2296 * otherwise, failure occurred after mf acquired.
2299 mpt_free_msg_frame(ioc, mf);
2304 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2305 /* Prototype Routine for the HOST INFO command.
2308 * Return: 0 if successful
2309 * -EFAULT if data unavailable
2310 * -EBUSY if previous command timeout and IOC reset is not complete.
2311 * -ENODEV if no such device/adapter
2312 * -ETIME if timer expires
2313 * -ENOMEM if memory allocation error
2316 mptctl_hp_hostinfo(MPT_ADAPTER *ioc, unsigned long arg, unsigned int data_size)
2318 hp_host_info_t __user *uarg = (void __user *) arg;
2319 struct pci_dev *pdev;
2322 hp_host_info_t karg;
2324 ConfigPageHeader_t hdr;
2326 ToolboxIstwiReadWriteRequest_t *IstwiRWRequest;
2327 MPT_FRAME_HDR *mf = NULL;
2328 unsigned long timeleft;
2332 /* Reset long to int. Should affect IA64 and SPARC only
2334 if (data_size == sizeof(hp_host_info_t))
2336 else if (data_size == sizeof(hp_host_info_rev0_t))
2337 cim_rev = 0; /* obsolete */
2341 if (copy_from_user(&karg, uarg, sizeof(hp_host_info_t))) {
2342 printk(KERN_ERR MYNAM "%s@%d::mptctl_hp_host_info - "
2343 "Unable to read in hp_host_info struct @ %p\n",
2344 __FILE__, __LINE__, uarg);
2348 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": mptctl_hp_hostinfo called.\n",
2351 /* Fill in the data and return the structure to the calling
2354 pdev = (struct pci_dev *) ioc->pcidev;
2356 karg.vendor = pdev->vendor;
2357 karg.device = pdev->device;
2358 karg.subsystem_id = pdev->subsystem_device;
2359 karg.subsystem_vendor = pdev->subsystem_vendor;
2360 karg.devfn = pdev->devfn;
2361 karg.bus = pdev->bus->number;
2363 /* Save the SCSI host no. if
2364 * SCSI driver loaded
2366 if (ioc->sh != NULL)
2367 karg.host_no = ioc->sh->host_no;
2371 /* Reformat the fw_version into a string */
2372 snprintf(karg.fw_version, sizeof(karg.fw_version),
2373 "%.2hhu.%.2hhu.%.2hhu.%.2hhu",
2374 ioc->facts.FWVersion.Struct.Major,
2375 ioc->facts.FWVersion.Struct.Minor,
2376 ioc->facts.FWVersion.Struct.Unit,
2377 ioc->facts.FWVersion.Struct.Dev);
2379 /* Issue a config request to get the device serial number
2381 hdr.PageVersion = 0;
2384 hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
2385 cfg.cfghdr.hdr = &hdr;
2388 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2389 cfg.dir = 0; /* read */
2392 strncpy(karg.serial_number, " ", 24);
2393 if (mpt_config(ioc, &cfg) == 0) {
2394 if (cfg.cfghdr.hdr->PageLength > 0) {
2395 /* Issue the second config page request */
2396 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2398 pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
2400 cfg.physAddr = buf_dma;
2401 if (mpt_config(ioc, &cfg) == 0) {
2402 ManufacturingPage0_t *pdata = (ManufacturingPage0_t *) pbuf;
2403 if (strlen(pdata->BoardTracerNumber) > 1) {
2404 strlcpy(karg.serial_number,
2405 pdata->BoardTracerNumber, 24);
2408 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
2413 rc = mpt_GetIocState(ioc, 1);
2415 case MPI_IOC_STATE_OPERATIONAL:
2416 karg.ioc_status = HP_STATUS_OK;
2419 case MPI_IOC_STATE_FAULT:
2420 karg.ioc_status = HP_STATUS_FAILED;
2423 case MPI_IOC_STATE_RESET:
2424 case MPI_IOC_STATE_READY:
2426 karg.ioc_status = HP_STATUS_OTHER;
2430 karg.base_io_addr = pci_resource_start(pdev, 0);
2432 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
2433 karg.bus_phys_width = HP_BUS_WIDTH_UNK;
2435 karg.bus_phys_width = HP_BUS_WIDTH_16;
2437 karg.hard_resets = 0;
2438 karg.soft_resets = 0;
2440 if (ioc->sh != NULL) {
2441 MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
2443 if (hd && (cim_rev == 1)) {
2444 karg.hard_resets = ioc->hard_resets;
2445 karg.soft_resets = ioc->soft_resets;
2446 karg.timeouts = ioc->timeouts;
2451 * Gather ISTWI(Industry Standard Two Wire Interface) Data
2453 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
2454 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
2455 "%s, no msg frames!!\n", ioc->name, __func__));
2459 IstwiRWRequest = (ToolboxIstwiReadWriteRequest_t *)mf;
2460 msgcontext = IstwiRWRequest->MsgContext;
2461 memset(IstwiRWRequest,0,sizeof(ToolboxIstwiReadWriteRequest_t));
2462 IstwiRWRequest->MsgContext = msgcontext;
2463 IstwiRWRequest->Function = MPI_FUNCTION_TOOLBOX;
2464 IstwiRWRequest->Tool = MPI_TOOLBOX_ISTWI_READ_WRITE_TOOL;
2465 IstwiRWRequest->Flags = MPI_TB_ISTWI_FLAGS_READ;
2466 IstwiRWRequest->NumAddressBytes = 0x01;
2467 IstwiRWRequest->DataLength = cpu_to_le16(0x04);
2468 if (pdev->devfn & 1)
2469 IstwiRWRequest->DeviceAddr = 0xB2;
2471 IstwiRWRequest->DeviceAddr = 0xB0;
2473 pbuf = pci_alloc_consistent(ioc->pcidev, 4, &buf_dma);
2476 ioc->add_sge((char *)&IstwiRWRequest->SGL,
2477 (MPT_SGE_FLAGS_SSIMPLE_READ|4), buf_dma);
2480 SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context,
2481 IstwiRWRequest->MsgContext);
2482 INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
2483 mpt_put_msg_frame(mptctl_id, ioc, mf);
2486 timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
2487 HZ*MPT_IOCTL_DEFAULT_TIMEOUT);
2488 if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2490 printk(MYIOC_s_WARN_FMT "%s: failed\n", ioc->name, __func__);
2491 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2492 mpt_free_msg_frame(ioc, mf);
2496 printk(MYIOC_s_WARN_FMT
2497 "HOST INFO command timeout, doorbell=0x%08x\n",
2498 ioc->name, mpt_GetIocState(ioc, 0));
2499 mptctl_timeout_expired(ioc, mf);
2506 *ISTWI Data Definition
2507 * pbuf[0] = FW_VERSION = 0x4
2508 * pbuf[1] = Bay Count = 6 or 4 or 2, depending on
2509 * the config, you should be seeing one out of these three values
2510 * pbuf[2] = Drive Installed Map = bit pattern depend on which
2511 * bays have drives in them
2512 * pbuf[3] = Checksum (0x100 = (byte0 + byte2 + byte3)
2514 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID)
2515 karg.rsvd = *(u32 *)pbuf;
2518 CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
2519 SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
2522 pci_free_consistent(ioc->pcidev, 4, pbuf, buf_dma);
2524 /* Copy the data from kernel memory to user memory
2526 if (copy_to_user((char __user *)arg, &karg, sizeof(hp_host_info_t))) {
2527 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_hpgethostinfo - "
2528 "Unable to write out hp_host_info @ %p\n",
2529 ioc->name, __FILE__, __LINE__, uarg);
2537 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2538 /* Prototype Routine for the TARGET INFO command.
2541 * Return: 0 if successful
2542 * -EFAULT if data unavailable
2543 * -EBUSY if previous command timeout and IOC reset is not complete.
2544 * -ENODEV if no such device/adapter
2545 * -ETIME if timer expires
2546 * -ENOMEM if memory allocation error
2549 mptctl_hp_targetinfo(MPT_ADAPTER *ioc, unsigned long arg)
2551 hp_target_info_t __user *uarg = (void __user *) arg;
2552 SCSIDevicePage0_t *pg0_alloc;
2553 SCSIDevicePage3_t *pg3_alloc;
2554 MPT_SCSI_HOST *hd = NULL;
2555 hp_target_info_t karg;
2557 dma_addr_t page_dma;
2559 ConfigPageHeader_t hdr;
2560 int tmp, np, rc = 0;
2562 if (copy_from_user(&karg, uarg, sizeof(hp_target_info_t))) {
2563 printk(KERN_ERR MYNAM "%s@%d::mptctl_hp_targetinfo - "
2564 "Unable to read in hp_host_targetinfo struct @ %p\n",
2565 __FILE__, __LINE__, uarg);
2569 if (karg.hdr.id >= MPT_MAX_FC_DEVICES)
2571 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_hp_targetinfo called.\n",
2574 /* There is nothing to do for FCP parts.
2576 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
2579 if ((ioc->spi_data.sdp0length == 0) || (ioc->sh == NULL))
2582 if (ioc->sh->host_no != karg.hdr.host)
2585 /* Get the data transfer speeds
2587 data_sz = ioc->spi_data.sdp0length * 4;
2588 pg0_alloc = pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
2590 hdr.PageVersion = ioc->spi_data.sdp0version;
2591 hdr.PageLength = data_sz;
2593 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2595 cfg.cfghdr.hdr = &hdr;
2596 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2599 cfg.physAddr = page_dma;
2601 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2603 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2604 np = le32_to_cpu(pg0_alloc->NegotiatedParameters);
2605 karg.negotiated_width = np & MPI_SCSIDEVPAGE0_NP_WIDE ?
2606 HP_BUS_WIDTH_16 : HP_BUS_WIDTH_8;
2608 if (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) {
2609 tmp = (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> 8;
2611 karg.negotiated_speed = HP_DEV_SPEED_ULTRA320;
2612 else if (tmp <= 0x09)
2613 karg.negotiated_speed = HP_DEV_SPEED_ULTRA160;
2614 else if (tmp <= 0x0A)
2615 karg.negotiated_speed = HP_DEV_SPEED_ULTRA2;
2616 else if (tmp <= 0x0C)
2617 karg.negotiated_speed = HP_DEV_SPEED_ULTRA;
2618 else if (tmp <= 0x25)
2619 karg.negotiated_speed = HP_DEV_SPEED_FAST;
2621 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2623 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2626 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg0_alloc, page_dma);
2631 karg.message_rejects = -1;
2632 karg.phase_errors = -1;
2633 karg.parity_errors = -1;
2634 karg.select_timeouts = -1;
2636 /* Get the target error parameters
2638 hdr.PageVersion = 0;
2641 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2643 cfg.cfghdr.hdr = &hdr;
2644 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2648 if ((mpt_config(ioc, &cfg) == 0) && (cfg.cfghdr.hdr->PageLength > 0)) {
2649 /* Issue the second config page request */
2650 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2651 data_sz = (int) cfg.cfghdr.hdr->PageLength * 4;
2652 pg3_alloc = pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
2654 cfg.physAddr = page_dma;
2655 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2656 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2657 karg.message_rejects = (u32) le16_to_cpu(pg3_alloc->MsgRejectCount);
2658 karg.phase_errors = (u32) le16_to_cpu(pg3_alloc->PhaseErrorCount);
2659 karg.parity_errors = (u32) le16_to_cpu(pg3_alloc->ParityErrorCount);
2661 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg3_alloc, page_dma);
2664 hd = shost_priv(ioc->sh);
2666 karg.select_timeouts = hd->sel_timeout[karg.hdr.id];
2668 /* Copy the data from kernel memory to user memory
2670 if (copy_to_user((char __user *)arg, &karg, sizeof(hp_target_info_t))) {
2671 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_hp_target_info - "
2672 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
2673 ioc->name, __FILE__, __LINE__, uarg);
2680 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2682 static const struct file_operations mptctl_fops = {
2683 .owner = THIS_MODULE,
2684 .llseek = no_llseek,
2685 .fasync = mptctl_fasync,
2686 .unlocked_ioctl = mptctl_ioctl,
2687 #ifdef CONFIG_COMPAT
2688 .compat_ioctl = compat_mpctl_ioctl,
2692 static struct miscdevice mptctl_miscdev = {
2698 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2700 #ifdef CONFIG_COMPAT
2703 compat_mptfwxfer_ioctl(struct file *filp, unsigned int cmd,
2706 struct mpt_fw_xfer32 kfw32;
2707 struct mpt_fw_xfer kfw;
2708 MPT_ADAPTER *iocp = NULL;
2709 int iocnum, iocnumX;
2710 int nonblock = (filp->f_flags & O_NONBLOCK);
2714 if (copy_from_user(&kfw32, (char __user *)arg, sizeof(kfw32)))
2717 /* Verify intended MPT adapter */
2718 iocnumX = kfw32.iocnum & 0xFF;
2719 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2721 printk(KERN_DEBUG MYNAM "::compat_mptfwxfer_ioctl @%d - ioc%d not found!\n",
2726 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2729 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "compat_mptfwxfer_ioctl() called\n",
2731 kfw.iocnum = iocnum;
2732 kfw.fwlen = kfw32.fwlen;
2733 kfw.bufp = compat_ptr(kfw32.bufp);
2735 ret = mptctl_do_fw_download(iocp, kfw.bufp, kfw.fwlen);
2737 mutex_unlock(&iocp->ioctl_cmds.mutex);
2743 compat_mpt_command(struct file *filp, unsigned int cmd,
2746 struct mpt_ioctl_command32 karg32;
2747 struct mpt_ioctl_command32 __user *uarg = (struct mpt_ioctl_command32 __user *) arg;
2748 struct mpt_ioctl_command karg;
2749 MPT_ADAPTER *iocp = NULL;
2750 int iocnum, iocnumX;
2751 int nonblock = (filp->f_flags & O_NONBLOCK);
2754 if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32)))
2757 /* Verify intended MPT adapter */
2758 iocnumX = karg32.hdr.iocnum & 0xFF;
2759 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2761 printk(KERN_DEBUG MYNAM "::compat_mpt_command @%d - ioc%d not found!\n",
2766 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2769 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "compat_mpt_command() called\n",
2771 /* Copy data to karg */
2772 karg.hdr.iocnum = karg32.hdr.iocnum;
2773 karg.hdr.port = karg32.hdr.port;
2774 karg.timeout = karg32.timeout;
2775 karg.maxReplyBytes = karg32.maxReplyBytes;
2777 karg.dataInSize = karg32.dataInSize;
2778 karg.dataOutSize = karg32.dataOutSize;
2779 karg.maxSenseBytes = karg32.maxSenseBytes;
2780 karg.dataSgeOffset = karg32.dataSgeOffset;
2782 karg.replyFrameBufPtr = (char __user *)(unsigned long)karg32.replyFrameBufPtr;
2783 karg.dataInBufPtr = (char __user *)(unsigned long)karg32.dataInBufPtr;
2784 karg.dataOutBufPtr = (char __user *)(unsigned long)karg32.dataOutBufPtr;
2785 karg.senseDataPtr = (char __user *)(unsigned long)karg32.senseDataPtr;
2787 /* Pass new structure to do_mpt_command
2789 ret = mptctl_do_mpt_command (iocp, karg, &uarg->MF);
2791 mutex_unlock(&iocp->ioctl_cmds.mutex);
2796 static long compat_mpctl_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
2799 mutex_lock(&mpctl_mutex);
2806 case MPTEVENTENABLE:
2807 case MPTEVENTREPORT:
2809 case HP_GETHOSTINFO:
2810 case HP_GETTARGETINFO:
2812 ret = __mptctl_ioctl(f, cmd, arg);
2815 ret = compat_mpt_command(f, cmd, arg);
2817 case MPTFWDOWNLOAD32:
2818 ret = compat_mptfwxfer_ioctl(f, cmd, arg);
2824 mutex_unlock(&mpctl_mutex);
2831 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2833 * mptctl_probe - Installs ioctl devices per bus.
2834 * @pdev: Pointer to pci_dev structure
2836 * Returns 0 for success, non-zero for failure.
2841 mptctl_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2843 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
2845 mutex_init(&ioc->ioctl_cmds.mutex);
2846 init_completion(&ioc->ioctl_cmds.done);
2850 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2852 * mptctl_remove - Removed ioctl devices
2853 * @pdev: Pointer to pci_dev structure
2858 mptctl_remove(struct pci_dev *pdev)
2862 static struct mpt_pci_driver mptctl_driver = {
2863 .probe = mptctl_probe,
2864 .remove = mptctl_remove,
2867 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2868 static int __init mptctl_init(void)
2873 show_mptmod_ver(my_NAME, my_VERSION);
2875 mpt_device_driver_register(&mptctl_driver, MPTCTL_DRIVER);
2877 /* Register this device */
2878 err = misc_register(&mptctl_miscdev);
2880 printk(KERN_ERR MYNAM ": Can't register misc device [minor=%d].\n", MPT_MINOR);
2883 printk(KERN_INFO MYNAM ": Registered with Fusion MPT base driver\n");
2884 printk(KERN_INFO MYNAM ": /dev/%s @ (major,minor=%d,%d)\n",
2885 mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
2888 * Install our handler
2891 mptctl_id = mpt_register(mptctl_reply, MPTCTL_DRIVER,
2893 if (!mptctl_id || mptctl_id >= MPT_MAX_PROTOCOL_DRIVERS) {
2894 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
2895 misc_deregister(&mptctl_miscdev);
2900 mptctl_taskmgmt_id = mpt_register(mptctl_taskmgmt_reply, MPTCTL_DRIVER,
2901 "mptctl_taskmgmt_reply");
2902 if (!mptctl_taskmgmt_id || mptctl_taskmgmt_id >= MPT_MAX_PROTOCOL_DRIVERS) {
2903 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
2904 mpt_deregister(mptctl_id);
2905 misc_deregister(&mptctl_miscdev);
2910 mpt_reset_register(mptctl_id, mptctl_ioc_reset);
2911 mpt_event_register(mptctl_id, mptctl_event_process);
2917 mpt_device_driver_deregister(MPTCTL_DRIVER);
2922 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2923 static void mptctl_exit(void)
2925 misc_deregister(&mptctl_miscdev);
2926 printk(KERN_INFO MYNAM ": Deregistered /dev/%s @ (major,minor=%d,%d)\n",
2927 mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
2929 /* De-register event handler from base module */
2930 mpt_event_deregister(mptctl_id);
2932 /* De-register reset handler from base module */
2933 mpt_reset_deregister(mptctl_id);
2935 /* De-register callback handler from base module */
2936 mpt_deregister(mptctl_taskmgmt_id);
2937 mpt_deregister(mptctl_id);
2939 mpt_device_driver_deregister(MPTCTL_DRIVER);
2943 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2945 module_init(mptctl_init);
2946 module_exit(mptctl_exit);