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 successfull!\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;
1247 struct scsi_device *sdev;
1248 VirtDevice *vdevice;
1250 /* Add of PCI INFO results in unaligned access for
1251 * IA64 and Sparc. Reset long to int. Return no PCI
1252 * data for obsolete format.
1254 if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev0))
1256 else if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev1))
1258 else if (data_size == sizeof(struct mpt_ioctl_iocinfo))
1260 else if (data_size == (sizeof(struct mpt_ioctl_iocinfo_rev0)+12))
1261 cim_rev = 0; /* obsolete */
1265 karg = kmalloc(data_size, GFP_KERNEL);
1267 printk(KERN_ERR MYNAM "%s::mpt_ioctl_iocinfo() @%d - no memory available!\n",
1268 __FILE__, __LINE__);
1272 if (copy_from_user(karg, uarg, data_size)) {
1273 printk(KERN_ERR MYNAM "%s@%d::mptctl_getiocinfo - "
1274 "Unable to read in mpt_ioctl_iocinfo struct @ %p\n",
1275 __FILE__, __LINE__, uarg);
1280 if (((iocnum = mpt_verify_adapter(karg->hdr.iocnum, &ioc)) < 0) ||
1282 printk(KERN_DEBUG MYNAM "%s::mptctl_getiocinfo() @%d - ioc%d not found!\n",
1283 __FILE__, __LINE__, iocnum);
1288 /* Verify the data transfer size is correct. */
1289 if (karg->hdr.maxDataSize != data_size) {
1290 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_getiocinfo - "
1291 "Structure size mismatch. Command not completed.\n",
1292 ioc->name, __FILE__, __LINE__);
1297 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_getiocinfo called.\n",
1300 /* Fill in the data and return the structure to the calling
1303 if (ioc->bus_type == SAS)
1304 karg->adapterType = MPT_IOCTL_INTERFACE_SAS;
1305 else if (ioc->bus_type == FC)
1306 karg->adapterType = MPT_IOCTL_INTERFACE_FC;
1308 karg->adapterType = MPT_IOCTL_INTERFACE_SCSI;
1310 if (karg->hdr.port > 1) {
1314 port = karg->hdr.port;
1317 pdev = (struct pci_dev *) ioc->pcidev;
1319 karg->pciId = pdev->device;
1320 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1321 karg->hwRev = revision;
1322 karg->subSystemDevice = pdev->subsystem_device;
1323 karg->subSystemVendor = pdev->subsystem_vendor;
1326 /* Get the PCI bus, device, and function numbers for the IOC
1328 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1329 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1330 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1331 } else if (cim_rev == 2) {
1332 /* Get the PCI bus, device, function and segment ID numbers
1334 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1335 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1336 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1337 karg->pciInfo.segmentID = pci_domain_nr(pdev->bus);
1340 /* Get number of devices
1342 karg->numDevices = 0;
1344 shost_for_each_device(sdev, ioc->sh) {
1345 vdevice = sdev->hostdata;
1346 if (vdevice == NULL || vdevice->vtarget == NULL)
1348 if (vdevice->vtarget->tflags &
1349 MPT_TARGET_FLAGS_RAID_COMPONENT)
1355 /* Set the BIOS and FW Version
1357 karg->FWVersion = ioc->facts.FWVersion.Word;
1358 karg->BIOSVersion = ioc->biosVersion;
1360 /* Set the Version Strings.
1362 strncpy (karg->driverVersion, MPT_LINUX_PACKAGE_NAME, MPT_IOCTL_VERSION_LENGTH);
1363 karg->driverVersion[MPT_IOCTL_VERSION_LENGTH-1]='\0';
1365 karg->busChangeEvent = 0;
1366 karg->hostId = ioc->pfacts[port].PortSCSIID;
1367 karg->rsvd[0] = karg->rsvd[1] = 0;
1369 /* Copy the data from kernel memory to user memory
1371 if (copy_to_user((char __user *)arg, karg, data_size)) {
1372 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_getiocinfo - "
1373 "Unable to write out mpt_ioctl_iocinfo struct @ %p\n",
1374 ioc->name, __FILE__, __LINE__, uarg);
1383 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1385 * mptctl_gettargetinfo - Query the host adapter for target information.
1386 * @arg: User space argument
1389 * Return: 0 if successful
1390 * -EFAULT if data unavailable
1391 * -ENODEV if no such device/adapter
1394 mptctl_gettargetinfo (unsigned long arg)
1396 struct mpt_ioctl_targetinfo __user *uarg = (void __user *) arg;
1397 struct mpt_ioctl_targetinfo karg;
1399 VirtDevice *vdevice;
1408 struct scsi_device *sdev;
1410 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_targetinfo))) {
1411 printk(KERN_ERR MYNAM "%s@%d::mptctl_gettargetinfo - "
1412 "Unable to read in mpt_ioctl_targetinfo struct @ %p\n",
1413 __FILE__, __LINE__, uarg);
1417 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1419 printk(KERN_DEBUG MYNAM "%s::mptctl_gettargetinfo() @%d - ioc%d not found!\n",
1420 __FILE__, __LINE__, iocnum);
1424 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_gettargetinfo called.\n",
1426 /* Get the port number and set the maximum number of bytes
1427 * in the returned structure.
1428 * Ignore the port setting.
1430 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1431 maxWordsLeft = numBytes/sizeof(int);
1432 port = karg.hdr.port;
1434 if (maxWordsLeft <= 0) {
1435 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo() - no memory available!\n",
1436 ioc->name, __FILE__, __LINE__);
1440 /* Fill in the data and return the structure to the calling
1444 /* struct mpt_ioctl_targetinfo does not contain sufficient space
1445 * for the target structures so when the IOCTL is called, there is
1446 * not sufficient stack space for the structure. Allocate memory,
1447 * populate the memory, copy back to the user, then free memory.
1448 * targetInfo format:
1449 * bits 31-24: reserved
1454 pmem = kzalloc(numBytes, GFP_KERNEL);
1456 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo() - no memory available!\n",
1457 ioc->name, __FILE__, __LINE__);
1460 pdata = (int *) pmem;
1462 /* Get number of devices
1465 shost_for_each_device(sdev, ioc->sh) {
1468 vdevice = sdev->hostdata;
1469 if (vdevice == NULL || vdevice->vtarget == NULL)
1471 if (vdevice->vtarget->tflags &
1472 MPT_TARGET_FLAGS_RAID_COMPONENT)
1474 lun = (vdevice->vtarget->raidVolume) ? 0x80 : vdevice->lun;
1475 *pdata = (((u8)lun << 16) + (vdevice->vtarget->channel << 8) +
1476 (vdevice->vtarget->id ));
1482 karg.numDevices = numDevices;
1484 /* Copy part of the data from kernel memory to user memory
1486 if (copy_to_user((char __user *)arg, &karg,
1487 sizeof(struct mpt_ioctl_targetinfo))) {
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__, uarg);
1495 /* Copy the remaining data from kernel memory to user memory
1497 if (copy_to_user(uarg->targetInfo, pmem, numBytes)) {
1498 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo - "
1499 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1500 ioc->name, __FILE__, __LINE__, pdata);
1510 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1511 /* MPT IOCTL Test function.
1514 * Return: 0 if successful
1515 * -EFAULT if data unavailable
1516 * -ENODEV if no such device/adapter
1519 mptctl_readtest (unsigned long arg)
1521 struct mpt_ioctl_test __user *uarg = (void __user *) arg;
1522 struct mpt_ioctl_test karg;
1526 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_test))) {
1527 printk(KERN_ERR MYNAM "%s@%d::mptctl_readtest - "
1528 "Unable to read in mpt_ioctl_test struct @ %p\n",
1529 __FILE__, __LINE__, uarg);
1533 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1535 printk(KERN_DEBUG MYNAM "%s::mptctl_readtest() @%d - ioc%d not found!\n",
1536 __FILE__, __LINE__, iocnum);
1540 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_readtest called.\n",
1542 /* Fill in the data and return the structure to the calling
1547 karg.chip_type = ioc->mfcnt;
1549 karg.chip_type = ioc->pcidev->device;
1551 strncpy (karg.name, ioc->name, MPT_MAX_NAME);
1552 karg.name[MPT_MAX_NAME-1]='\0';
1553 strncpy (karg.product, ioc->prod_name, MPT_PRODUCT_LENGTH);
1554 karg.product[MPT_PRODUCT_LENGTH-1]='\0';
1556 /* Copy the data from kernel memory to user memory
1558 if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_test))) {
1559 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_readtest - "
1560 "Unable to write out mpt_ioctl_test struct @ %p\n",
1561 ioc->name, __FILE__, __LINE__, uarg);
1568 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1570 * mptctl_eventquery - Query the host adapter for the event types
1571 * that are being logged.
1572 * @arg: User space argument
1575 * Return: 0 if successful
1576 * -EFAULT if data unavailable
1577 * -ENODEV if no such device/adapter
1580 mptctl_eventquery (unsigned long arg)
1582 struct mpt_ioctl_eventquery __user *uarg = (void __user *) arg;
1583 struct mpt_ioctl_eventquery karg;
1587 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventquery))) {
1588 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventquery - "
1589 "Unable to read in mpt_ioctl_eventquery struct @ %p\n",
1590 __FILE__, __LINE__, uarg);
1594 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1596 printk(KERN_DEBUG MYNAM "%s::mptctl_eventquery() @%d - ioc%d not found!\n",
1597 __FILE__, __LINE__, iocnum);
1601 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventquery called.\n",
1603 karg.eventEntries = MPTCTL_EVENT_LOG_SIZE;
1604 karg.eventTypes = ioc->eventTypes;
1606 /* Copy the data from kernel memory to user memory
1608 if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_eventquery))) {
1609 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_eventquery - "
1610 "Unable to write out mpt_ioctl_eventquery struct @ %p\n",
1611 ioc->name, __FILE__, __LINE__, uarg);
1617 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1619 mptctl_eventenable (unsigned long arg)
1621 struct mpt_ioctl_eventenable __user *uarg = (void __user *) arg;
1622 struct mpt_ioctl_eventenable karg;
1626 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventenable))) {
1627 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventenable - "
1628 "Unable to read in mpt_ioctl_eventenable struct @ %p\n",
1629 __FILE__, __LINE__, uarg);
1633 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1635 printk(KERN_DEBUG MYNAM "%s::mptctl_eventenable() @%d - ioc%d not found!\n",
1636 __FILE__, __LINE__, iocnum);
1640 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventenable called.\n",
1642 if (ioc->events == NULL) {
1643 /* Have not yet allocated memory - do so now.
1645 int sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
1646 ioc->events = kzalloc(sz, GFP_KERNEL);
1648 printk(MYIOC_s_ERR_FMT
1649 ": ERROR - Insufficient memory to add adapter!\n",
1653 ioc->alloc_total += sz;
1655 ioc->eventContext = 0;
1658 /* Update the IOC event logging flag.
1660 ioc->eventTypes = karg.eventTypes;
1665 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1667 mptctl_eventreport (unsigned long arg)
1669 struct mpt_ioctl_eventreport __user *uarg = (void __user *) arg;
1670 struct mpt_ioctl_eventreport karg;
1673 int numBytes, maxEvents, max;
1675 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventreport))) {
1676 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventreport - "
1677 "Unable to read in mpt_ioctl_eventreport struct @ %p\n",
1678 __FILE__, __LINE__, uarg);
1682 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1684 printk(KERN_DEBUG MYNAM "%s::mptctl_eventreport() @%d - ioc%d not found!\n",
1685 __FILE__, __LINE__, iocnum);
1688 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventreport called.\n",
1691 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1692 maxEvents = numBytes/sizeof(MPT_IOCTL_EVENTS);
1695 max = MPTCTL_EVENT_LOG_SIZE < maxEvents ? MPTCTL_EVENT_LOG_SIZE : maxEvents;
1697 /* If fewer than 1 event is requested, there must have
1698 * been some type of error.
1700 if ((max < 1) || !ioc->events)
1703 /* reset this flag so SIGIO can restart */
1704 ioc->aen_event_read_flag=0;
1706 /* Copy the data from kernel memory to user memory
1708 numBytes = max * sizeof(MPT_IOCTL_EVENTS);
1709 if (copy_to_user(uarg->eventData, ioc->events, numBytes)) {
1710 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_eventreport - "
1711 "Unable to write out mpt_ioctl_eventreport struct @ %p\n",
1712 ioc->name, __FILE__, __LINE__, ioc->events);
1719 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1721 mptctl_replace_fw (unsigned long arg)
1723 struct mpt_ioctl_replace_fw __user *uarg = (void __user *) arg;
1724 struct mpt_ioctl_replace_fw karg;
1729 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_replace_fw))) {
1730 printk(KERN_ERR MYNAM "%s@%d::mptctl_replace_fw - "
1731 "Unable to read in mpt_ioctl_replace_fw struct @ %p\n",
1732 __FILE__, __LINE__, uarg);
1736 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1738 printk(KERN_DEBUG MYNAM "%s::mptctl_replace_fw() @%d - ioc%d not found!\n",
1739 __FILE__, __LINE__, iocnum);
1743 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_replace_fw called.\n",
1745 /* If caching FW, Free the old FW image
1747 if (ioc->cached_fw == NULL)
1750 mpt_free_fw_memory(ioc);
1752 /* Allocate memory for the new FW image
1754 newFwSize = karg.newImageSize;
1756 if (newFwSize & 0x01)
1758 if (newFwSize & 0x02)
1761 mpt_alloc_fw_memory(ioc, newFwSize);
1762 if (ioc->cached_fw == NULL)
1765 /* Copy the data from user memory to kernel space
1767 if (copy_from_user(ioc->cached_fw, uarg->newImage, newFwSize)) {
1768 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_replace_fw - "
1769 "Unable to read in mpt_ioctl_replace_fw image "
1770 "@ %p\n", ioc->name, __FILE__, __LINE__, uarg);
1771 mpt_free_fw_memory(ioc);
1775 /* Update IOCFactsReply
1777 ioc->facts.FWImageSize = newFwSize;
1781 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1782 /* MPT IOCTL MPTCOMMAND function.
1783 * Cast the arg into the mpt_ioctl_mpt_command structure.
1786 * Return: 0 if successful
1787 * -EBUSY if previous command timeout and IOC reset is not complete.
1788 * -EFAULT if data unavailable
1789 * -ENODEV if no such device/adapter
1790 * -ETIME if timer expires
1791 * -ENOMEM if memory allocation error
1794 mptctl_mpt_command (unsigned long arg)
1796 struct mpt_ioctl_command __user *uarg = (void __user *) arg;
1797 struct mpt_ioctl_command karg;
1803 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_command))) {
1804 printk(KERN_ERR MYNAM "%s@%d::mptctl_mpt_command - "
1805 "Unable to read in mpt_ioctl_command struct @ %p\n",
1806 __FILE__, __LINE__, uarg);
1810 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1812 printk(KERN_DEBUG MYNAM "%s::mptctl_mpt_command() @%d - ioc%d not found!\n",
1813 __FILE__, __LINE__, iocnum);
1817 rc = mptctl_do_mpt_command (karg, &uarg->MF);
1822 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1823 /* Worker routine for the IOCTL MPTCOMMAND and MPTCOMMAND32 (sparc) commands.
1826 * Return: 0 if successful
1827 * -EBUSY if previous command timeout and IOC reset is not complete.
1828 * -EFAULT if data unavailable
1829 * -ENODEV if no such device/adapter
1830 * -ETIME if timer expires
1831 * -ENOMEM if memory allocation error
1832 * -EPERM if SCSI I/O and target is untagged
1835 mptctl_do_mpt_command (struct mpt_ioctl_command karg, void __user *mfPtr)
1838 MPT_FRAME_HDR *mf = NULL;
1841 struct buflist bufIn; /* data In buffer */
1842 struct buflist bufOut; /* data Out buffer */
1843 dma_addr_t dma_addr_in;
1844 dma_addr_t dma_addr_out;
1845 int sgSize = 0; /* Num SG elements */
1846 int iocnum, flagsLength;
1851 unsigned long timeleft;
1852 struct scsi_device *sdev;
1853 unsigned long flags;
1856 /* bufIn and bufOut are used for user to kernel space transfers
1858 bufIn.kptr = bufOut.kptr = NULL;
1859 bufIn.len = bufOut.len = 0;
1861 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1863 printk(KERN_DEBUG MYNAM "%s::mptctl_do_mpt_command() @%d - ioc%d not found!\n",
1864 __FILE__, __LINE__, iocnum);
1868 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
1869 if (ioc->ioc_reset_in_progress) {
1870 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
1871 printk(KERN_ERR MYNAM "%s@%d::mptctl_do_mpt_command - "
1872 "Busy with diagnostic reset\n", __FILE__, __LINE__);
1875 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
1877 /* Verify that the final request frame will not be too large.
1879 sz = karg.dataSgeOffset * 4;
1880 if (karg.dataInSize > 0)
1881 sz += ioc->SGE_size;
1882 if (karg.dataOutSize > 0)
1883 sz += ioc->SGE_size;
1885 if (sz > ioc->req_sz) {
1886 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1887 "Request frame too large (%d) maximum (%d)\n",
1888 ioc->name, __FILE__, __LINE__, sz, ioc->req_sz);
1892 /* Get a free request frame and save the message context.
1894 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
1897 hdr = (MPIHeader_t *) mf;
1898 msgContext = le32_to_cpu(hdr->MsgContext);
1899 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1901 /* Copy the request frame
1902 * Reset the saved message context.
1903 * Request frame in user space
1905 if (copy_from_user(mf, mfPtr, karg.dataSgeOffset * 4)) {
1906 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1907 "Unable to read MF from mpt_ioctl_command struct @ %p\n",
1908 ioc->name, __FILE__, __LINE__, mfPtr);
1913 hdr->MsgContext = cpu_to_le32(msgContext);
1914 function = hdr->Function;
1917 /* Verify that this request is allowed.
1919 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sending mpi function (0x%02X), req=%p\n",
1920 ioc->name, hdr->Function, mf));
1923 case MPI_FUNCTION_IOC_FACTS:
1924 case MPI_FUNCTION_PORT_FACTS:
1925 karg.dataOutSize = karg.dataInSize = 0;
1928 case MPI_FUNCTION_CONFIG:
1930 Config_t *config_frame;
1931 config_frame = (Config_t *)mf;
1932 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\ttype=0x%02x ext_type=0x%02x "
1933 "number=0x%02x action=0x%02x\n", ioc->name,
1934 config_frame->Header.PageType,
1935 config_frame->ExtPageType,
1936 config_frame->Header.PageNumber,
1937 config_frame->Action));
1941 case MPI_FUNCTION_FC_COMMON_TRANSPORT_SEND:
1942 case MPI_FUNCTION_FC_EX_LINK_SRVC_SEND:
1943 case MPI_FUNCTION_FW_UPLOAD:
1944 case MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR:
1945 case MPI_FUNCTION_FW_DOWNLOAD:
1946 case MPI_FUNCTION_FC_PRIMITIVE_SEND:
1947 case MPI_FUNCTION_TOOLBOX:
1948 case MPI_FUNCTION_SAS_IO_UNIT_CONTROL:
1951 case MPI_FUNCTION_SCSI_IO_REQUEST:
1953 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
1954 int qtag = MPI_SCSIIO_CONTROL_UNTAGGED;
1959 id = (ioc->devices_per_bus == 0) ? 256 : ioc->devices_per_bus;
1960 if (pScsiReq->TargetID > id) {
1961 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1962 "Target ID out of bounds. \n",
1963 ioc->name, __FILE__, __LINE__);
1968 if (pScsiReq->Bus >= ioc->number_of_buses) {
1969 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
1970 "Target Bus out of bounds. \n",
1971 ioc->name, __FILE__, __LINE__);
1976 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
1977 pScsiReq->MsgFlags |= mpt_msg_flags(ioc);
1980 /* verify that app has not requested
1981 * more sense data than driver
1982 * can provide, if so, reset this parameter
1983 * set the sense buffer pointer low address
1984 * update the control field to specify Q type
1986 if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1987 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1989 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1991 pScsiReq->SenseBufferLowAddr =
1992 cpu_to_le32(ioc->sense_buf_low_dma
1993 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
1995 shost_for_each_device(sdev, ioc->sh) {
1996 struct scsi_target *starget = scsi_target(sdev);
1997 VirtTarget *vtarget = starget->hostdata;
1999 if (vtarget == NULL)
2002 if ((pScsiReq->TargetID == vtarget->id) &&
2003 (pScsiReq->Bus == vtarget->channel) &&
2004 (vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
2005 qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
2008 /* Have the IOCTL driver set the direction based
2009 * on the dataOutSize (ordering issue with Sparc).
2011 if (karg.dataOutSize > 0) {
2012 scsidir = MPI_SCSIIO_CONTROL_WRITE;
2013 dataSize = karg.dataOutSize;
2015 scsidir = MPI_SCSIIO_CONTROL_READ;
2016 dataSize = karg.dataInSize;
2019 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
2020 pScsiReq->DataLength = cpu_to_le32(dataSize);
2024 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2025 "SCSI driver is not loaded. \n",
2026 ioc->name, __FILE__, __LINE__);
2032 case MPI_FUNCTION_SMP_PASSTHROUGH:
2033 /* Check mf->PassthruFlags to determine if
2034 * transfer is ImmediateMode or not.
2035 * Immediate mode returns data in the ReplyFrame.
2036 * Else, we are sending request and response data
2037 * in two SGLs at the end of the mf.
2041 case MPI_FUNCTION_SATA_PASSTHROUGH:
2043 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2044 "SCSI driver is not loaded. \n",
2045 ioc->name, __FILE__, __LINE__);
2051 case MPI_FUNCTION_RAID_ACTION:
2056 case MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
2058 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
2059 int qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
2060 int scsidir = MPI_SCSIIO_CONTROL_READ;
2063 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
2064 pScsiReq->MsgFlags |= mpt_msg_flags(ioc);
2067 /* verify that app has not requested
2068 * more sense data than driver
2069 * can provide, if so, reset this parameter
2070 * set the sense buffer pointer low address
2071 * update the control field to specify Q type
2073 if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
2074 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
2076 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
2078 pScsiReq->SenseBufferLowAddr =
2079 cpu_to_le32(ioc->sense_buf_low_dma
2080 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
2082 /* All commands to physical devices are tagged
2085 /* Have the IOCTL driver set the direction based
2086 * on the dataOutSize (ordering issue with Sparc).
2088 if (karg.dataOutSize > 0) {
2089 scsidir = MPI_SCSIIO_CONTROL_WRITE;
2090 dataSize = karg.dataOutSize;
2092 scsidir = MPI_SCSIIO_CONTROL_READ;
2093 dataSize = karg.dataInSize;
2096 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
2097 pScsiReq->DataLength = cpu_to_le32(dataSize);
2100 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2101 "SCSI driver is not loaded. \n",
2102 ioc->name, __FILE__, __LINE__);
2108 case MPI_FUNCTION_SCSI_TASK_MGMT:
2110 SCSITaskMgmt_t *pScsiTm;
2111 pScsiTm = (SCSITaskMgmt_t *)mf;
2112 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2113 "\tTaskType=0x%x MsgFlags=0x%x "
2114 "TaskMsgContext=0x%x id=%d channel=%d\n",
2115 ioc->name, pScsiTm->TaskType, le32_to_cpu
2116 (pScsiTm->TaskMsgContext), pScsiTm->MsgFlags,
2117 pScsiTm->TargetID, pScsiTm->Bus));
2121 case MPI_FUNCTION_IOC_INIT:
2123 IOCInit_t *pInit = (IOCInit_t *) mf;
2124 u32 high_addr, sense_high;
2126 /* Verify that all entries in the IOC INIT match
2127 * existing setup (and in LE format).
2129 if (sizeof(dma_addr_t) == sizeof(u64)) {
2130 high_addr = cpu_to_le32((u32)((u64)ioc->req_frames_dma >> 32));
2131 sense_high= cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
2137 if ((pInit->Flags != 0) || (pInit->MaxDevices != ioc->facts.MaxDevices) ||
2138 (pInit->MaxBuses != ioc->facts.MaxBuses) ||
2139 (pInit->ReplyFrameSize != cpu_to_le16(ioc->reply_sz)) ||
2140 (pInit->HostMfaHighAddr != high_addr) ||
2141 (pInit->SenseBufferHighAddr != sense_high)) {
2142 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2143 "IOC_INIT issued with 1 or more incorrect parameters. Rejected.\n",
2144 ioc->name, __FILE__, __LINE__);
2152 * MPI_FUNCTION_PORT_ENABLE
2153 * MPI_FUNCTION_TARGET_CMD_BUFFER_POST
2154 * MPI_FUNCTION_TARGET_ASSIST
2155 * MPI_FUNCTION_TARGET_STATUS_SEND
2156 * MPI_FUNCTION_TARGET_MODE_ABORT
2157 * MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET
2158 * MPI_FUNCTION_IO_UNIT_RESET
2159 * MPI_FUNCTION_HANDSHAKE
2160 * MPI_FUNCTION_REPLY_FRAME_REMOVAL
2161 * MPI_FUNCTION_EVENT_NOTIFICATION
2162 * (driver handles event notification)
2163 * MPI_FUNCTION_EVENT_ACK
2166 /* What to do with these??? CHECK ME!!!
2167 MPI_FUNCTION_FC_LINK_SRVC_BUF_POST
2168 MPI_FUNCTION_FC_LINK_SRVC_RSP
2169 MPI_FUNCTION_FC_ABORT
2170 MPI_FUNCTION_LAN_SEND
2171 MPI_FUNCTION_LAN_RECEIVE
2172 MPI_FUNCTION_LAN_RESET
2175 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2176 "Illegal request (function 0x%x) \n",
2177 ioc->name, __FILE__, __LINE__, hdr->Function);
2182 /* Add the SGL ( at most one data in SGE and one data out SGE )
2183 * In the case of two SGE's - the data out (write) will always
2184 * preceede the data in (read) SGE. psgList is used to free the
2187 psge = (char *) (((int *) mf) + karg.dataSgeOffset);
2190 if (karg.dataOutSize > 0)
2193 if (karg.dataInSize > 0)
2198 /* Set up the dataOut memory allocation */
2199 if (karg.dataOutSize > 0) {
2200 if (karg.dataInSize > 0) {
2201 flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2202 MPI_SGE_FLAGS_END_OF_BUFFER |
2203 MPI_SGE_FLAGS_DIRECTION)
2204 << MPI_SGE_FLAGS_SHIFT;
2206 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
2208 flagsLength |= karg.dataOutSize;
2209 bufOut.len = karg.dataOutSize;
2210 bufOut.kptr = pci_alloc_consistent(
2211 ioc->pcidev, bufOut.len, &dma_addr_out);
2213 if (bufOut.kptr == NULL) {
2218 * Copy to MF and to sglbuf
2220 ioc->add_sge(psge, flagsLength, dma_addr_out);
2221 psge += ioc->SGE_size;
2223 /* Copy user data to kernel space.
2225 if (copy_from_user(bufOut.kptr,
2228 printk(MYIOC_s_ERR_FMT
2229 "%s@%d::mptctl_do_mpt_command - Unable "
2230 "to read user data "
2232 ioc->name, __FILE__, __LINE__,karg.dataOutBufPtr);
2239 if (karg.dataInSize > 0) {
2240 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
2241 flagsLength |= karg.dataInSize;
2243 bufIn.len = karg.dataInSize;
2244 bufIn.kptr = pci_alloc_consistent(ioc->pcidev,
2245 bufIn.len, &dma_addr_in);
2247 if (bufIn.kptr == NULL) {
2252 * Copy to MF and to sglbuf
2254 ioc->add_sge(psge, flagsLength, dma_addr_in);
2260 ioc->add_sge(psge, flagsLength, (dma_addr_t) -1);
2263 SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, hdr->MsgContext);
2264 INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
2265 if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT) {
2267 mutex_lock(&ioc->taskmgmt_cmds.mutex);
2268 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
2269 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2273 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
2275 if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
2276 (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
2277 mpt_put_msg_frame_hi_pri(mptctl_id, ioc, mf);
2279 rc =mpt_send_handshake_request(mptctl_id, ioc,
2280 sizeof(SCSITaskMgmt_t), (u32*)mf, CAN_SLEEP);
2282 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2283 "send_handshake FAILED! (ioc %p, mf %p)\n",
2284 ioc->name, ioc, mf));
2285 mpt_clear_taskmgmt_in_progress_flag(ioc);
2287 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2293 mpt_put_msg_frame(mptctl_id, ioc, mf);
2295 /* Now wait for the command to complete */
2296 timeout = (karg.timeout > 0) ? karg.timeout : MPT_IOCTL_DEFAULT_TIMEOUT;
2298 timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
2300 if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2302 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "%s: TIMED OUT!\n",
2303 ioc->name, __func__));
2304 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2305 if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2306 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2310 printk(MYIOC_s_WARN_FMT
2311 "mpt cmd timeout, doorbell=0x%08x"
2313 ioc->name, mpt_GetIocState(ioc, 0), function);
2314 if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2315 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2316 mptctl_timeout_expired(ioc, mf);
2323 if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2324 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2329 /* If a valid reply frame, copy to the user.
2330 * Offset 2: reply length in U32's
2332 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) {
2333 if (karg.maxReplyBytes < ioc->reply_sz) {
2334 sz = min(karg.maxReplyBytes,
2335 4*ioc->ioctl_cmds.reply[2]);
2337 sz = min(ioc->reply_sz, 4*ioc->ioctl_cmds.reply[2]);
2340 if (copy_to_user(karg.replyFrameBufPtr,
2341 ioc->ioctl_cmds.reply, sz)){
2342 printk(MYIOC_s_ERR_FMT
2343 "%s@%d::mptctl_do_mpt_command - "
2344 "Unable to write out reply frame %p\n",
2345 ioc->name, __FILE__, __LINE__, karg.replyFrameBufPtr);
2352 /* If valid sense data, copy to user.
2354 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_SENSE_VALID) {
2355 sz = min(karg.maxSenseBytes, MPT_SENSE_BUFFER_SIZE);
2357 if (copy_to_user(karg.senseDataPtr,
2358 ioc->ioctl_cmds.sense, sz)) {
2359 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2360 "Unable to write sense data to user %p\n",
2361 ioc->name, __FILE__, __LINE__,
2369 /* If the overall status is _GOOD and data in, copy data
2372 if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD) &&
2373 (karg.dataInSize > 0) && (bufIn.kptr)) {
2375 if (copy_to_user(karg.dataInBufPtr,
2376 bufIn.kptr, karg.dataInSize)) {
2377 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
2378 "Unable to write data to user %p\n",
2379 ioc->name, __FILE__, __LINE__,
2387 CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
2388 SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
2390 /* Free the allocated memory.
2392 if (bufOut.kptr != NULL) {
2393 pci_free_consistent(ioc->pcidev,
2394 bufOut.len, (void *) bufOut.kptr, dma_addr_out);
2397 if (bufIn.kptr != NULL) {
2398 pci_free_consistent(ioc->pcidev,
2399 bufIn.len, (void *) bufIn.kptr, dma_addr_in);
2402 /* mf is null if command issued successfully
2403 * otherwise, failure occured after mf acquired.
2406 mpt_free_msg_frame(ioc, mf);
2411 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2412 /* Prototype Routine for the HOST INFO command.
2415 * Return: 0 if successful
2416 * -EFAULT if data unavailable
2417 * -EBUSY if previous command timeout and IOC reset is not complete.
2418 * -ENODEV if no such device/adapter
2419 * -ETIME if timer expires
2420 * -ENOMEM if memory allocation error
2423 mptctl_hp_hostinfo(unsigned long arg, unsigned int data_size)
2425 hp_host_info_t __user *uarg = (void __user *) arg;
2427 struct pci_dev *pdev;
2430 hp_host_info_t karg;
2432 ConfigPageHeader_t hdr;
2435 ToolboxIstwiReadWriteRequest_t *IstwiRWRequest;
2436 MPT_FRAME_HDR *mf = NULL;
2437 MPIHeader_t *mpi_hdr;
2438 unsigned long timeleft;
2441 /* Reset long to int. Should affect IA64 and SPARC only
2443 if (data_size == sizeof(hp_host_info_t))
2445 else if (data_size == sizeof(hp_host_info_rev0_t))
2446 cim_rev = 0; /* obsolete */
2450 if (copy_from_user(&karg, uarg, sizeof(hp_host_info_t))) {
2451 printk(KERN_ERR MYNAM "%s@%d::mptctl_hp_host_info - "
2452 "Unable to read in hp_host_info struct @ %p\n",
2453 __FILE__, __LINE__, uarg);
2457 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2459 printk(KERN_DEBUG MYNAM "%s::mptctl_hp_hostinfo() @%d - ioc%d not found!\n",
2460 __FILE__, __LINE__, iocnum);
2463 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": mptctl_hp_hostinfo called.\n",
2466 /* Fill in the data and return the structure to the calling
2469 pdev = (struct pci_dev *) ioc->pcidev;
2471 karg.vendor = pdev->vendor;
2472 karg.device = pdev->device;
2473 karg.subsystem_id = pdev->subsystem_device;
2474 karg.subsystem_vendor = pdev->subsystem_vendor;
2475 karg.devfn = pdev->devfn;
2476 karg.bus = pdev->bus->number;
2478 /* Save the SCSI host no. if
2479 * SCSI driver loaded
2481 if (ioc->sh != NULL)
2482 karg.host_no = ioc->sh->host_no;
2486 /* Reformat the fw_version into a string
2488 karg.fw_version[0] = ioc->facts.FWVersion.Struct.Major >= 10 ?
2489 ((ioc->facts.FWVersion.Struct.Major / 10) + '0') : '0';
2490 karg.fw_version[1] = (ioc->facts.FWVersion.Struct.Major % 10 ) + '0';
2491 karg.fw_version[2] = '.';
2492 karg.fw_version[3] = ioc->facts.FWVersion.Struct.Minor >= 10 ?
2493 ((ioc->facts.FWVersion.Struct.Minor / 10) + '0') : '0';
2494 karg.fw_version[4] = (ioc->facts.FWVersion.Struct.Minor % 10 ) + '0';
2495 karg.fw_version[5] = '.';
2496 karg.fw_version[6] = ioc->facts.FWVersion.Struct.Unit >= 10 ?
2497 ((ioc->facts.FWVersion.Struct.Unit / 10) + '0') : '0';
2498 karg.fw_version[7] = (ioc->facts.FWVersion.Struct.Unit % 10 ) + '0';
2499 karg.fw_version[8] = '.';
2500 karg.fw_version[9] = ioc->facts.FWVersion.Struct.Dev >= 10 ?
2501 ((ioc->facts.FWVersion.Struct.Dev / 10) + '0') : '0';
2502 karg.fw_version[10] = (ioc->facts.FWVersion.Struct.Dev % 10 ) + '0';
2503 karg.fw_version[11] = '\0';
2505 /* Issue a config request to get the device serial number
2507 hdr.PageVersion = 0;
2510 hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
2511 cfg.cfghdr.hdr = &hdr;
2514 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2515 cfg.dir = 0; /* read */
2518 strncpy(karg.serial_number, " ", 24);
2519 if (mpt_config(ioc, &cfg) == 0) {
2520 if (cfg.cfghdr.hdr->PageLength > 0) {
2521 /* Issue the second config page request */
2522 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2524 pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
2526 cfg.physAddr = buf_dma;
2527 if (mpt_config(ioc, &cfg) == 0) {
2528 ManufacturingPage0_t *pdata = (ManufacturingPage0_t *) pbuf;
2529 if (strlen(pdata->BoardTracerNumber) > 1) {
2530 strncpy(karg.serial_number, pdata->BoardTracerNumber, 24);
2531 karg.serial_number[24-1]='\0';
2534 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
2539 rc = mpt_GetIocState(ioc, 1);
2541 case MPI_IOC_STATE_OPERATIONAL:
2542 karg.ioc_status = HP_STATUS_OK;
2545 case MPI_IOC_STATE_FAULT:
2546 karg.ioc_status = HP_STATUS_FAILED;
2549 case MPI_IOC_STATE_RESET:
2550 case MPI_IOC_STATE_READY:
2552 karg.ioc_status = HP_STATUS_OTHER;
2556 karg.base_io_addr = pci_resource_start(pdev, 0);
2558 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
2559 karg.bus_phys_width = HP_BUS_WIDTH_UNK;
2561 karg.bus_phys_width = HP_BUS_WIDTH_16;
2563 karg.hard_resets = 0;
2564 karg.soft_resets = 0;
2566 if (ioc->sh != NULL) {
2567 MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
2569 if (hd && (cim_rev == 1)) {
2570 karg.hard_resets = ioc->hard_resets;
2571 karg.soft_resets = ioc->soft_resets;
2572 karg.timeouts = ioc->timeouts;
2577 * Gather ISTWI(Industry Standard Two Wire Interface) Data
2579 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
2580 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
2581 "%s, no msg frames!!\n", ioc->name, __func__));
2585 IstwiRWRequest = (ToolboxIstwiReadWriteRequest_t *)mf;
2586 mpi_hdr = (MPIHeader_t *) mf;
2587 memset(IstwiRWRequest,0,sizeof(ToolboxIstwiReadWriteRequest_t));
2588 IstwiRWRequest->Function = MPI_FUNCTION_TOOLBOX;
2589 IstwiRWRequest->Tool = MPI_TOOLBOX_ISTWI_READ_WRITE_TOOL;
2590 IstwiRWRequest->MsgContext = mpi_hdr->MsgContext;
2591 IstwiRWRequest->Flags = MPI_TB_ISTWI_FLAGS_READ;
2592 IstwiRWRequest->NumAddressBytes = 0x01;
2593 IstwiRWRequest->DataLength = cpu_to_le16(0x04);
2594 if (pdev->devfn & 1)
2595 IstwiRWRequest->DeviceAddr = 0xB2;
2597 IstwiRWRequest->DeviceAddr = 0xB0;
2599 pbuf = pci_alloc_consistent(ioc->pcidev, 4, &buf_dma);
2602 ioc->add_sge((char *)&IstwiRWRequest->SGL,
2603 (MPT_SGE_FLAGS_SSIMPLE_READ|4), buf_dma);
2606 SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context,
2607 IstwiRWRequest->MsgContext);
2608 INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
2609 mpt_put_msg_frame(mptctl_id, ioc, mf);
2612 timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
2613 HZ*MPT_IOCTL_DEFAULT_TIMEOUT);
2614 if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2616 printk(MYIOC_s_WARN_FMT "%s: failed\n", ioc->name, __func__);
2617 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2618 mpt_free_msg_frame(ioc, mf);
2622 printk(MYIOC_s_WARN_FMT
2623 "HOST INFO command timeout, doorbell=0x%08x\n",
2624 ioc->name, mpt_GetIocState(ioc, 0));
2625 mptctl_timeout_expired(ioc, mf);
2632 *ISTWI Data Definition
2633 * pbuf[0] = FW_VERSION = 0x4
2634 * pbuf[1] = Bay Count = 6 or 4 or 2, depending on
2635 * the config, you should be seeing one out of these three values
2636 * pbuf[2] = Drive Installed Map = bit pattern depend on which
2637 * bays have drives in them
2638 * pbuf[3] = Checksum (0x100 = (byte0 + byte2 + byte3)
2640 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID)
2641 karg.rsvd = *(u32 *)pbuf;
2644 CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
2645 SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
2648 pci_free_consistent(ioc->pcidev, 4, pbuf, buf_dma);
2650 /* Copy the data from kernel memory to user memory
2652 if (copy_to_user((char __user *)arg, &karg, sizeof(hp_host_info_t))) {
2653 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_hpgethostinfo - "
2654 "Unable to write out hp_host_info @ %p\n",
2655 ioc->name, __FILE__, __LINE__, uarg);
2663 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2664 /* Prototype Routine for the TARGET INFO command.
2667 * Return: 0 if successful
2668 * -EFAULT if data unavailable
2669 * -EBUSY if previous command timeout and IOC reset is not complete.
2670 * -ENODEV if no such device/adapter
2671 * -ETIME if timer expires
2672 * -ENOMEM if memory allocation error
2675 mptctl_hp_targetinfo(unsigned long arg)
2677 hp_target_info_t __user *uarg = (void __user *) arg;
2678 SCSIDevicePage0_t *pg0_alloc;
2679 SCSIDevicePage3_t *pg3_alloc;
2681 MPT_SCSI_HOST *hd = NULL;
2682 hp_target_info_t karg;
2685 dma_addr_t page_dma;
2687 ConfigPageHeader_t hdr;
2688 int tmp, np, rc = 0;
2690 if (copy_from_user(&karg, uarg, sizeof(hp_target_info_t))) {
2691 printk(KERN_ERR MYNAM "%s@%d::mptctl_hp_targetinfo - "
2692 "Unable to read in hp_host_targetinfo struct @ %p\n",
2693 __FILE__, __LINE__, uarg);
2697 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2699 printk(KERN_DEBUG MYNAM "%s::mptctl_hp_targetinfo() @%d - ioc%d not found!\n",
2700 __FILE__, __LINE__, iocnum);
2703 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_hp_targetinfo called.\n",
2706 /* There is nothing to do for FCP parts.
2708 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
2711 if ((ioc->spi_data.sdp0length == 0) || (ioc->sh == NULL))
2714 if (ioc->sh->host_no != karg.hdr.host)
2717 /* Get the data transfer speeds
2719 data_sz = ioc->spi_data.sdp0length * 4;
2720 pg0_alloc = (SCSIDevicePage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
2722 hdr.PageVersion = ioc->spi_data.sdp0version;
2723 hdr.PageLength = data_sz;
2725 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2727 cfg.cfghdr.hdr = &hdr;
2728 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2731 cfg.physAddr = page_dma;
2733 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2735 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2736 np = le32_to_cpu(pg0_alloc->NegotiatedParameters);
2737 karg.negotiated_width = np & MPI_SCSIDEVPAGE0_NP_WIDE ?
2738 HP_BUS_WIDTH_16 : HP_BUS_WIDTH_8;
2740 if (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) {
2741 tmp = (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> 8;
2743 karg.negotiated_speed = HP_DEV_SPEED_ULTRA320;
2744 else if (tmp <= 0x09)
2745 karg.negotiated_speed = HP_DEV_SPEED_ULTRA160;
2746 else if (tmp <= 0x0A)
2747 karg.negotiated_speed = HP_DEV_SPEED_ULTRA2;
2748 else if (tmp <= 0x0C)
2749 karg.negotiated_speed = HP_DEV_SPEED_ULTRA;
2750 else if (tmp <= 0x25)
2751 karg.negotiated_speed = HP_DEV_SPEED_FAST;
2753 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2755 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2758 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg0_alloc, page_dma);
2763 karg.message_rejects = -1;
2764 karg.phase_errors = -1;
2765 karg.parity_errors = -1;
2766 karg.select_timeouts = -1;
2768 /* Get the target error parameters
2770 hdr.PageVersion = 0;
2773 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2775 cfg.cfghdr.hdr = &hdr;
2776 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2780 if ((mpt_config(ioc, &cfg) == 0) && (cfg.cfghdr.hdr->PageLength > 0)) {
2781 /* Issue the second config page request */
2782 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2783 data_sz = (int) cfg.cfghdr.hdr->PageLength * 4;
2784 pg3_alloc = (SCSIDevicePage3_t *) pci_alloc_consistent(
2785 ioc->pcidev, data_sz, &page_dma);
2787 cfg.physAddr = page_dma;
2788 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2789 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2790 karg.message_rejects = (u32) le16_to_cpu(pg3_alloc->MsgRejectCount);
2791 karg.phase_errors = (u32) le16_to_cpu(pg3_alloc->PhaseErrorCount);
2792 karg.parity_errors = (u32) le16_to_cpu(pg3_alloc->ParityErrorCount);
2794 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg3_alloc, page_dma);
2797 hd = shost_priv(ioc->sh);
2799 karg.select_timeouts = hd->sel_timeout[karg.hdr.id];
2801 /* Copy the data from kernel memory to user memory
2803 if (copy_to_user((char __user *)arg, &karg, sizeof(hp_target_info_t))) {
2804 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_hp_target_info - "
2805 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
2806 ioc->name, __FILE__, __LINE__, uarg);
2813 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2815 static const struct file_operations mptctl_fops = {
2816 .owner = THIS_MODULE,
2817 .llseek = no_llseek,
2818 .fasync = mptctl_fasync,
2819 .unlocked_ioctl = mptctl_ioctl,
2820 #ifdef CONFIG_COMPAT
2821 .compat_ioctl = compat_mpctl_ioctl,
2825 static struct miscdevice mptctl_miscdev = {
2831 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2833 #ifdef CONFIG_COMPAT
2836 compat_mptfwxfer_ioctl(struct file *filp, unsigned int cmd,
2839 struct mpt_fw_xfer32 kfw32;
2840 struct mpt_fw_xfer kfw;
2841 MPT_ADAPTER *iocp = NULL;
2842 int iocnum, iocnumX;
2843 int nonblock = (filp->f_flags & O_NONBLOCK);
2847 if (copy_from_user(&kfw32, (char __user *)arg, sizeof(kfw32)))
2850 /* Verify intended MPT adapter */
2851 iocnumX = kfw32.iocnum & 0xFF;
2852 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2854 printk(KERN_DEBUG MYNAM "::compat_mptfwxfer_ioctl @%d - ioc%d not found!\n",
2859 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2862 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "compat_mptfwxfer_ioctl() called\n",
2864 kfw.iocnum = iocnum;
2865 kfw.fwlen = kfw32.fwlen;
2866 kfw.bufp = compat_ptr(kfw32.bufp);
2868 ret = mptctl_do_fw_download(kfw.iocnum, kfw.bufp, kfw.fwlen);
2870 mutex_unlock(&iocp->ioctl_cmds.mutex);
2876 compat_mpt_command(struct file *filp, unsigned int cmd,
2879 struct mpt_ioctl_command32 karg32;
2880 struct mpt_ioctl_command32 __user *uarg = (struct mpt_ioctl_command32 __user *) arg;
2881 struct mpt_ioctl_command karg;
2882 MPT_ADAPTER *iocp = NULL;
2883 int iocnum, iocnumX;
2884 int nonblock = (filp->f_flags & O_NONBLOCK);
2887 if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32)))
2890 /* Verify intended MPT adapter */
2891 iocnumX = karg32.hdr.iocnum & 0xFF;
2892 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2894 printk(KERN_DEBUG MYNAM "::compat_mpt_command @%d - ioc%d not found!\n",
2899 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2902 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "compat_mpt_command() called\n",
2904 /* Copy data to karg */
2905 karg.hdr.iocnum = karg32.hdr.iocnum;
2906 karg.hdr.port = karg32.hdr.port;
2907 karg.timeout = karg32.timeout;
2908 karg.maxReplyBytes = karg32.maxReplyBytes;
2910 karg.dataInSize = karg32.dataInSize;
2911 karg.dataOutSize = karg32.dataOutSize;
2912 karg.maxSenseBytes = karg32.maxSenseBytes;
2913 karg.dataSgeOffset = karg32.dataSgeOffset;
2915 karg.replyFrameBufPtr = (char __user *)(unsigned long)karg32.replyFrameBufPtr;
2916 karg.dataInBufPtr = (char __user *)(unsigned long)karg32.dataInBufPtr;
2917 karg.dataOutBufPtr = (char __user *)(unsigned long)karg32.dataOutBufPtr;
2918 karg.senseDataPtr = (char __user *)(unsigned long)karg32.senseDataPtr;
2920 /* Pass new structure to do_mpt_command
2922 ret = mptctl_do_mpt_command (karg, &uarg->MF);
2924 mutex_unlock(&iocp->ioctl_cmds.mutex);
2929 static long compat_mpctl_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
2932 mutex_lock(&mpctl_mutex);
2939 case MPTEVENTENABLE:
2940 case MPTEVENTREPORT:
2942 case HP_GETHOSTINFO:
2943 case HP_GETTARGETINFO:
2945 ret = __mptctl_ioctl(f, cmd, arg);
2948 ret = compat_mpt_command(f, cmd, arg);
2950 case MPTFWDOWNLOAD32:
2951 ret = compat_mptfwxfer_ioctl(f, cmd, arg);
2957 mutex_unlock(&mpctl_mutex);
2964 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2966 * mptctl_probe - Installs ioctl devices per bus.
2967 * @pdev: Pointer to pci_dev structure
2969 * Returns 0 for success, non-zero for failure.
2974 mptctl_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2976 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
2978 mutex_init(&ioc->ioctl_cmds.mutex);
2979 init_completion(&ioc->ioctl_cmds.done);
2983 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2985 * mptctl_remove - Removed ioctl devices
2986 * @pdev: Pointer to pci_dev structure
2991 mptctl_remove(struct pci_dev *pdev)
2995 static struct mpt_pci_driver mptctl_driver = {
2996 .probe = mptctl_probe,
2997 .remove = mptctl_remove,
3000 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3001 static int __init mptctl_init(void)
3006 show_mptmod_ver(my_NAME, my_VERSION);
3008 mpt_device_driver_register(&mptctl_driver, MPTCTL_DRIVER);
3010 /* Register this device */
3011 err = misc_register(&mptctl_miscdev);
3013 printk(KERN_ERR MYNAM ": Can't register misc device [minor=%d].\n", MPT_MINOR);
3016 printk(KERN_INFO MYNAM ": Registered with Fusion MPT base driver\n");
3017 printk(KERN_INFO MYNAM ": /dev/%s @ (major,minor=%d,%d)\n",
3018 mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
3021 * Install our handler
3024 mptctl_id = mpt_register(mptctl_reply, MPTCTL_DRIVER,
3026 if (!mptctl_id || mptctl_id >= MPT_MAX_PROTOCOL_DRIVERS) {
3027 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
3028 misc_deregister(&mptctl_miscdev);
3033 mptctl_taskmgmt_id = mpt_register(mptctl_taskmgmt_reply, MPTCTL_DRIVER,
3034 "mptctl_taskmgmt_reply");
3035 if (!mptctl_taskmgmt_id || mptctl_taskmgmt_id >= MPT_MAX_PROTOCOL_DRIVERS) {
3036 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
3037 mpt_deregister(mptctl_id);
3038 misc_deregister(&mptctl_miscdev);
3043 mpt_reset_register(mptctl_id, mptctl_ioc_reset);
3044 mpt_event_register(mptctl_id, mptctl_event_process);
3050 mpt_device_driver_deregister(MPTCTL_DRIVER);
3055 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3056 static void mptctl_exit(void)
3058 misc_deregister(&mptctl_miscdev);
3059 printk(KERN_INFO MYNAM ": Deregistered /dev/%s @ (major,minor=%d,%d)\n",
3060 mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
3062 /* De-register event handler from base module */
3063 mpt_event_deregister(mptctl_id);
3065 /* De-register reset handler from base module */
3066 mpt_reset_deregister(mptctl_id);
3068 /* De-register callback handler from base module */
3069 mpt_deregister(mptctl_taskmgmt_id);
3070 mpt_deregister(mptctl_id);
3072 mpt_device_driver_deregister(MPTCTL_DRIVER);
3076 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3078 module_init(mptctl_init);
3079 module_exit(mptctl_exit);