2 * linux/drivers/message/fusion/mptctl.c
4 * For use with LSI Logic PCI chip/adapters
5 * running LSI Logic Fusion MPT (Message Passing Technology) firmware.
7 * Copyright (c) 1999-2007 LSI Logic 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/smp_lock.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-2007 LSI Logic Corporation"
70 #define MODULEAUTHOR "LSI Logic 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 int mptctl_id = -1;
88 static DECLARE_WAIT_QUEUE_HEAD ( mptctl_wait );
90 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
98 * Function prototypes. Called from OS entry point mptctl_ioctl.
99 * arg contents specific to function.
101 static int mptctl_fw_download(unsigned long arg);
102 static int mptctl_getiocinfo(unsigned long arg, unsigned int cmd);
103 static int mptctl_gettargetinfo(unsigned long arg);
104 static int mptctl_readtest(unsigned long arg);
105 static int mptctl_mpt_command(unsigned long arg);
106 static int mptctl_eventquery(unsigned long arg);
107 static int mptctl_eventenable(unsigned long arg);
108 static int mptctl_eventreport(unsigned long arg);
109 static int mptctl_replace_fw(unsigned long arg);
111 static int mptctl_do_reset(unsigned long arg);
112 static int mptctl_hp_hostinfo(unsigned long arg, unsigned int cmd);
113 static int mptctl_hp_targetinfo(unsigned long arg);
115 static int mptctl_probe(struct pci_dev *, const struct pci_device_id *);
116 static void mptctl_remove(struct pci_dev *);
119 static long compat_mpctl_ioctl(struct file *f, unsigned cmd, unsigned long arg);
122 * Private function calls.
124 static int mptctl_do_mpt_command(struct mpt_ioctl_command karg, void __user *mfPtr);
125 static int mptctl_do_fw_download(int ioc, char __user *ufwbuf, size_t fwlen);
126 static MptSge_t *kbuf_alloc_2_sgl(int bytes, u32 dir, int sge_offset, int *frags,
127 struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc);
128 static void kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma,
129 struct buflist *buflist, MPT_ADAPTER *ioc);
130 static void mptctl_timeout_expired (MPT_IOCTL *ioctl);
131 static int mptctl_bus_reset(MPT_IOCTL *ioctl);
132 static int mptctl_set_tm_flags(MPT_SCSI_HOST *hd);
133 static void mptctl_free_tm_flags(MPT_ADAPTER *ioc);
136 * Reset Handler cleanup function
138 static int mptctl_ioc_reset(MPT_ADAPTER *ioc, int reset_phase);
141 * Event Handler function
143 static int mptctl_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
144 static struct fasync_struct *async_queue=NULL;
146 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
148 * Scatter gather list (SGL) sizes and limits...
150 //#define MAX_SCSI_FRAGS 9
151 #define MAX_FRAGS_SPILL1 9
152 #define MAX_FRAGS_SPILL2 15
153 #define FRAGS_PER_BUCKET (MAX_FRAGS_SPILL2 + 1)
155 //#define MAX_CHAIN_FRAGS 64
156 //#define MAX_CHAIN_FRAGS (15+15+15+16)
157 #define MAX_CHAIN_FRAGS (4 * MAX_FRAGS_SPILL2 + 1)
159 // Define max sg LIST bytes ( == (#frags + #chains) * 8 bytes each)
160 // Works out to: 592d bytes! (9+1)*8 + 4*(15+1)*8
161 // ^----------------- 80 + 512
162 #define MAX_SGL_BYTES ((MAX_FRAGS_SPILL1 + 1 + (4 * FRAGS_PER_BUCKET)) * 8)
164 /* linux only seems to ever give 128kB MAX contiguous (GFP_USER) mem bytes */
165 #define MAX_KMALLOC_SZ (128*1024)
167 #define MPT_IOCTL_DEFAULT_TIMEOUT 10 /* Default timeout value (seconds) */
169 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
171 * mptctl_syscall_down - Down the MPT adapter syscall semaphore.
172 * @ioc: Pointer to MPT adapter
173 * @nonblock: boolean, non-zero if O_NONBLOCK is set
175 * All of the ioctl commands can potentially sleep, which is illegal
176 * with a spinlock held, thus we perform mutual exclusion here.
178 * Returns negative errno on error, or zero for success.
181 mptctl_syscall_down(MPT_ADAPTER *ioc, int nonblock)
184 // dctlprintk(ioc, printk(KERN_DEBUG MYNAM "::mptctl_syscall_down(%p,%d) called\n", ioc, nonblock));
187 if (!mutex_trylock(&ioc->ioctl->ioctl_mutex))
190 if (mutex_lock_interruptible(&ioc->ioctl->ioctl_mutex))
193 // dctlprintk(ioc, printk(KERN_DEBUG MYNAM "::mptctl_syscall_down return %d\n", rc));
197 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
199 * This is the callback for any message we have posted. The message itself
200 * will be returned to the message pool when we return from the IRQ
202 * This runs in irq context so be short and sweet.
205 mptctl_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply)
213 cmd = req->u.hdr.Function;
216 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\tcompleting mpi function (0x%02X), req=%p, "
217 "reply=%p\n", ioc->name, req->u.hdr.Function, req, reply));
223 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_reply() NULL Reply "
224 "Function=%x!\n", ioc->name, cmd));
226 ioc->ioctl->status |= MPT_IOCTL_STATUS_COMMAND_GOOD;
227 ioc->ioctl->reset &= ~MPTCTL_RESET_OK;
229 /* We are done, issue wake up
231 ioc->ioctl->wait_done = 1;
232 wake_up (&mptctl_wait);
237 /* Copy the reply frame (which much exist
238 * for non-SCSI I/O) to the IOC structure.
240 memcpy(ioc->ioctl->ReplyFrame, reply,
241 min(ioc->reply_sz, 4*reply->u.reply.MsgLength));
242 ioc->ioctl->status |= MPT_IOCTL_STATUS_RF_VALID;
244 /* Set the command status to GOOD if IOC Status is GOOD
245 * OR if SCSI I/O cmd and data underrun or recovered error.
247 iocStatus = le16_to_cpu(reply->u.reply.IOCStatus) & MPI_IOCSTATUS_MASK;
248 if (iocStatus == MPI_IOCSTATUS_SUCCESS)
249 ioc->ioctl->status |= MPT_IOCTL_STATUS_COMMAND_GOOD;
251 if (iocStatus || reply->u.reply.IOCLogInfo)
252 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\tiocstatus (0x%04X), "
253 "loginfo (0x%08X)\n", ioc->name,
255 le32_to_cpu(reply->u.reply.IOCLogInfo)));
257 if ((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) ||
258 (cmd == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
260 if (reply->u.sreply.SCSIStatus || reply->u.sreply.SCSIState)
261 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
262 "\tscsi_status (0x%02x), scsi_state (0x%02x), "
263 "tag = (0x%04x), transfer_count (0x%08x)\n", ioc->name,
264 reply->u.sreply.SCSIStatus,
265 reply->u.sreply.SCSIState,
266 le16_to_cpu(reply->u.sreply.TaskTag),
267 le32_to_cpu(reply->u.sreply.TransferCount)));
269 ioc->ioctl->reset &= ~MPTCTL_RESET_OK;
271 if ((iocStatus == MPI_IOCSTATUS_SCSI_DATA_UNDERRUN) ||
272 (iocStatus == MPI_IOCSTATUS_SCSI_RECOVERED_ERROR)) {
273 ioc->ioctl->status |= MPT_IOCTL_STATUS_COMMAND_GOOD;
277 /* Copy the sense data - if present
279 if ((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) &&
280 (reply->u.sreply.SCSIState &
281 MPI_SCSI_STATE_AUTOSENSE_VALID)){
282 sz = req->u.scsireq.SenseBufferLength;
284 le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx);
286 ((u8 *)ioc->sense_buf_pool +
287 (req_index * MPT_SENSE_BUFFER_ALLOC));
288 memcpy(ioc->ioctl->sense, sense_data, sz);
289 ioc->ioctl->status |= MPT_IOCTL_STATUS_SENSE_VALID;
292 if (cmd == MPI_FUNCTION_SCSI_TASK_MGMT)
293 mptctl_free_tm_flags(ioc);
295 /* We are done, issue wake up
297 ioc->ioctl->wait_done = 1;
298 wake_up (&mptctl_wait);
303 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
304 /* mptctl_timeout_expired
306 * Expecting an interrupt, however timed out.
309 static void mptctl_timeout_expired (MPT_IOCTL *ioctl)
313 dctlprintk(ioctl->ioc, printk(MYIOC_s_DEBUG_FMT ": Timeout Expired! Host %d\n",
314 ioctl->ioc->name, ioctl->ioc->id));
318 ioctl->wait_done = 0;
319 if (ioctl->reset & MPTCTL_RESET_OK)
320 rc = mptctl_bus_reset(ioctl);
323 /* Issue a reset for this device.
324 * The IOC is not responding.
326 dctlprintk(ioctl->ioc, printk(MYIOC_s_DEBUG_FMT "Calling HardReset! \n",
328 mpt_HardResetHandler(ioctl->ioc, CAN_SLEEP);
339 static int mptctl_bus_reset(MPT_IOCTL *ioctl)
342 SCSITaskMgmt_t *pScsiTm;
348 ioctl->reset &= ~MPTCTL_RESET_OK;
350 if (ioctl->ioc->sh == NULL)
353 hd = (MPT_SCSI_HOST *) ioctl->ioc->sh->hostdata;
357 /* Single threading ....
359 if (mptctl_set_tm_flags(hd) != 0)
364 if ((mf = mpt_get_msg_frame(mptctl_id, ioctl->ioc)) == NULL) {
365 dtmprintk(ioctl->ioc, printk(MYIOC_s_DEBUG_FMT "IssueTaskMgmt, no msg frames!!\n",
368 mptctl_free_tm_flags(ioctl->ioc);
372 dtmprintk(ioctl->ioc, printk(MYIOC_s_DEBUG_FMT "IssueTaskMgmt request @ %p\n",
373 ioctl->ioc->name, mf));
375 pScsiTm = (SCSITaskMgmt_t *) mf;
376 pScsiTm->TargetID = ioctl->id;
377 pScsiTm->Bus = hd->port; /* 0 */
378 pScsiTm->ChainOffset = 0;
379 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
380 pScsiTm->Reserved = 0;
381 pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS;
382 pScsiTm->Reserved1 = 0;
383 pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
385 for (ii= 0; ii < 8; ii++)
386 pScsiTm->LUN[ii] = 0;
388 for (ii=0; ii < 7; ii++)
389 pScsiTm->Reserved2[ii] = 0;
391 pScsiTm->TaskMsgContext = 0;
392 dtmprintk(ioctl->ioc, printk(MYIOC_s_DEBUG_FMT
393 "mptctl_bus_reset: issued.\n", ioctl->ioc->name));
395 DBG_DUMP_TM_REQUEST_FRAME(ioctl->ioc, (u32 *)mf);
399 if ((ioctl->ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
400 (ioctl->ioc->facts.MsgVersion >= MPI_VERSION_01_05))
401 mpt_put_msg_frame_hi_pri(mptctl_id, ioctl->ioc, mf);
403 retval = mpt_send_handshake_request(mptctl_id, ioctl->ioc,
404 sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP);
406 dfailprintk(ioctl->ioc, printk(MYIOC_s_ERR_FMT "_send_handshake FAILED!"
407 " (hd %p, ioc %p, mf %p) \n", hd->ioc->name, hd,
409 goto mptctl_bus_reset_done;
413 /* Now wait for the command to complete */
414 ii = wait_event_timeout(mptctl_wait,
415 ioctl->wait_done == 1,
416 HZ*5 /* 5 second timeout */);
418 if(ii <=0 && (ioctl->wait_done != 1 )) {
419 mpt_free_msg_frame(hd->ioc, mf);
420 ioctl->wait_done = 0;
421 retval = -1; /* return failure */
424 mptctl_bus_reset_done:
426 mptctl_free_tm_flags(ioctl->ioc);
431 mptctl_set_tm_flags(MPT_SCSI_HOST *hd) {
434 spin_lock_irqsave(&hd->ioc->FreeQlock, flags);
436 if (hd->tmState == TM_STATE_NONE) {
437 hd->tmState = TM_STATE_IN_PROGRESS;
439 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
441 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
449 mptctl_free_tm_flags(MPT_ADAPTER *ioc)
454 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
458 spin_lock_irqsave(&ioc->FreeQlock, flags);
460 hd->tmState = TM_STATE_NONE;
462 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
467 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
470 * Clean-up functionality. Used only if there has been a
471 * reload of the FW due.
475 mptctl_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
477 MPT_IOCTL *ioctl = ioc->ioctl;
478 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": IOC %s_reset routed to IOCTL driver!\n",ioc->name,
479 reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
480 reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
485 switch(reset_phase) {
486 case MPT_IOC_SETUP_RESET:
487 ioctl->status |= MPT_IOCTL_STATUS_DID_IOCRESET;
489 case MPT_IOC_POST_RESET:
490 ioctl->status &= ~MPT_IOCTL_STATUS_DID_IOCRESET;
492 case MPT_IOC_PRE_RESET:
500 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
501 /* ASYNC Event Notification Support */
503 mptctl_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
507 event = le32_to_cpu(pEvReply->Event) & 0xFF;
509 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s() called\n",
510 ioc->name, __FUNCTION__));
511 if(async_queue == NULL)
514 /* Raise SIGIO for persistent events.
515 * TODO - this define is not in MPI spec yet,
516 * but they plan to set it to 0x21
518 if (event == 0x21 ) {
519 ioc->aen_event_read_flag=1;
520 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Raised SIGIO to application\n",
522 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
523 "Raised SIGIO to application\n", ioc->name));
524 kill_fasync(&async_queue, SIGIO, POLL_IN);
528 /* This flag is set after SIGIO was raised, and
529 * remains set until the application has read
530 * the event log via ioctl=MPTEVENTREPORT
532 if(ioc->aen_event_read_flag)
535 /* Signal only for the events that are
536 * requested for by the application
538 if (ioc->events && (ioc->eventTypes & ( 1 << event))) {
539 ioc->aen_event_read_flag=1;
540 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
541 "Raised SIGIO to application\n", ioc->name));
542 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
543 "Raised SIGIO to application\n", ioc->name));
544 kill_fasync(&async_queue, SIGIO, POLL_IN);
550 mptctl_fasync(int fd, struct file *filep, int mode)
554 list_for_each_entry(ioc, &ioc_list, list)
555 ioc->aen_event_read_flag=0;
557 return fasync_helper(fd, filep, mode, &async_queue);
561 mptctl_release(struct inode *inode, struct file *filep)
563 return fasync_helper(-1, filep, 0, &async_queue);
566 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
569 * cmd - specify the particular IOCTL command to be issued
570 * arg - data specific to the command. Must not be null.
573 __mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
575 mpt_ioctl_header __user *uhdr = (void __user *) arg;
576 mpt_ioctl_header khdr;
579 int nonblock = (file->f_flags & O_NONBLOCK);
581 MPT_ADAPTER *iocp = NULL;
583 if (copy_from_user(&khdr, uhdr, sizeof(khdr))) {
584 printk(KERN_ERR "%s::mptctl_ioctl() @%d - "
585 "Unable to copy mpt_ioctl_header data @ %p\n",
586 __FILE__, __LINE__, uhdr);
589 ret = -ENXIO; /* (-6) No such device or address */
591 /* Verify intended MPT adapter - set iocnum and the adapter
594 iocnumX = khdr.iocnum & 0xFF;
595 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
597 printk(KERN_DEBUG "%s::mptctl_ioctl() @%d - ioc%d not found!\n",
598 __FILE__, __LINE__, iocnumX);
603 printk(KERN_DEBUG "%s::mptctl_ioctl() @%d - Controller disabled.\n",
608 /* Handle those commands that are just returning
609 * information stored in the driver.
610 * These commands should never time out and are unaffected
611 * by TM and FW reloads.
613 if ((cmd & ~IOCSIZE_MASK) == (MPTIOCINFO & ~IOCSIZE_MASK)) {
614 return mptctl_getiocinfo(arg, _IOC_SIZE(cmd));
615 } else if (cmd == MPTTARGETINFO) {
616 return mptctl_gettargetinfo(arg);
617 } else if (cmd == MPTTEST) {
618 return mptctl_readtest(arg);
619 } else if (cmd == MPTEVENTQUERY) {
620 return mptctl_eventquery(arg);
621 } else if (cmd == MPTEVENTENABLE) {
622 return mptctl_eventenable(arg);
623 } else if (cmd == MPTEVENTREPORT) {
624 return mptctl_eventreport(arg);
625 } else if (cmd == MPTFWREPLACE) {
626 return mptctl_replace_fw(arg);
629 /* All of these commands require an interrupt or
630 * are unknown/illegal.
632 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
635 if (cmd == MPTFWDOWNLOAD)
636 ret = mptctl_fw_download(arg);
637 else if (cmd == MPTCOMMAND)
638 ret = mptctl_mpt_command(arg);
639 else if (cmd == MPTHARDRESET)
640 ret = mptctl_do_reset(arg);
641 else if ((cmd & ~IOCSIZE_MASK) == (HP_GETHOSTINFO & ~IOCSIZE_MASK))
642 ret = mptctl_hp_hostinfo(arg, _IOC_SIZE(cmd));
643 else if (cmd == HP_GETTARGETINFO)
644 ret = mptctl_hp_targetinfo(arg);
648 mutex_unlock(&iocp->ioctl->ioctl_mutex);
654 mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
658 ret = __mptctl_ioctl(file, cmd, arg);
663 static int mptctl_do_reset(unsigned long arg)
665 struct mpt_ioctl_diag_reset __user *urinfo = (void __user *) arg;
666 struct mpt_ioctl_diag_reset krinfo;
669 if (copy_from_user(&krinfo, urinfo, sizeof(struct mpt_ioctl_diag_reset))) {
670 printk(KERN_ERR "%s@%d::mptctl_do_reset - "
671 "Unable to copy mpt_ioctl_diag_reset struct @ %p\n",
672 __FILE__, __LINE__, urinfo);
676 if (mpt_verify_adapter(krinfo.hdr.iocnum, &iocp) < 0) {
677 printk(KERN_DEBUG "%s@%d::mptctl_do_reset - ioc%d not found!\n",
678 __FILE__, __LINE__, krinfo.hdr.iocnum);
679 return -ENODEV; /* (-6) No such device or address */
682 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "mptctl_do_reset called.\n",
685 if (mpt_HardResetHandler(iocp, CAN_SLEEP) != 0) {
686 printk (KERN_ERR "%s@%d::mptctl_do_reset - reset failed.\n",
694 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
696 * MPT FW download function. Cast the arg into the mpt_fw_xfer structure.
697 * This structure contains: iocnum, firmware length (bytes),
698 * pointer to user space memory where the fw image is stored.
701 * Return: 0 if successful
702 * -EFAULT if data unavailable
703 * -ENXIO if no such device
704 * -EAGAIN if resource problem
705 * -ENOMEM if no memory for SGE
706 * -EMLINK if too many chain buffers required
707 * -EBADRQC if adapter does not support FW download
708 * -EBUSY if adapter is busy
709 * -ENOMSG if FW upload returned bad status
712 mptctl_fw_download(unsigned long arg)
714 struct mpt_fw_xfer __user *ufwdl = (void __user *) arg;
715 struct mpt_fw_xfer kfwdl;
717 if (copy_from_user(&kfwdl, ufwdl, sizeof(struct mpt_fw_xfer))) {
718 printk(KERN_ERR "%s@%d::_ioctl_fwdl - "
719 "Unable to copy mpt_fw_xfer struct @ %p\n",
720 __FILE__, __LINE__, ufwdl);
724 return mptctl_do_fw_download(kfwdl.iocnum, kfwdl.bufp, kfwdl.fwlen);
727 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
729 * FW Download engine.
731 * Return: 0 if successful
732 * -EFAULT if data unavailable
733 * -ENXIO if no such device
734 * -EAGAIN if resource problem
735 * -ENOMEM if no memory for SGE
736 * -EMLINK if too many chain buffers required
737 * -EBADRQC if adapter does not support FW download
738 * -EBUSY if adapter is busy
739 * -ENOMSG if FW upload returned bad status
742 mptctl_do_fw_download(int ioc, char __user *ufwbuf, size_t fwlen)
747 FWDownloadTCSGE_t *ptsge;
748 MptSge_t *sgl, *sgIn;
750 struct buflist *buflist;
759 int fw_bytes_copied = 0;
763 pFWDownloadReply_t ReplyMsg = NULL;
765 if (mpt_verify_adapter(ioc, &iocp) < 0) {
766 printk(KERN_DEBUG "ioctl_fwdl - ioc%d not found!\n", ioc);
767 return -ENODEV; /* (-6) No such device or address */
770 /* Valid device. Get a message frame and construct the FW download message.
772 if ((mf = mpt_get_msg_frame(mptctl_id, iocp)) == NULL)
776 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT
777 "mptctl_do_fwdl called. mptctl_id = %xh.\n", iocp->name, mptctl_id));
778 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.bufp = %p\n",
779 iocp->name, ufwbuf));
780 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.fwlen = %d\n",
781 iocp->name, (int)fwlen));
782 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.ioc = %04xh\n",
785 dlmsg = (FWDownload_t*) mf;
786 ptsge = (FWDownloadTCSGE_t *) &dlmsg->SGL;
787 sgOut = (char *) (ptsge + 1);
790 * Construct f/w download request
792 dlmsg->ImageType = MPI_FW_DOWNLOAD_ITYPE_FW;
794 dlmsg->ChainOffset = 0;
795 dlmsg->Function = MPI_FUNCTION_FW_DOWNLOAD;
796 dlmsg->Reserved1[0] = dlmsg->Reserved1[1] = dlmsg->Reserved1[2] = 0;
797 if (iocp->facts.MsgVersion >= MPI_VERSION_01_05)
798 dlmsg->MsgFlags = MPI_FW_DOWNLOAD_MSGFLGS_LAST_SEGMENT;
803 /* Set up the Transaction SGE.
806 ptsge->ContextSize = 0;
807 ptsge->DetailsLength = 12;
808 ptsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
809 ptsge->Reserved_0100_Checksum = 0;
810 ptsge->ImageOffset = 0;
811 ptsge->ImageSize = cpu_to_le32(fwlen);
817 * Need to kmalloc area(s) for holding firmware image bytes.
818 * But we need to do it piece meal, using a proper
819 * scatter gather list (with 128kB MAX hunks).
821 * A practical limit here might be # of sg hunks that fit into
822 * a single IOC request frame; 12 or 8 (see below), so:
823 * For FC9xx: 12 x 128kB == 1.5 mB (max)
824 * For C1030: 8 x 128kB == 1 mB (max)
825 * We could support chaining, but things get ugly(ier:)
827 * Set the sge_offset to the start of the sgl (bytes).
829 sgdir = 0x04000000; /* IOC will READ from sys mem */
830 sge_offset = sizeof(MPIHeader_t) + sizeof(FWDownloadTCSGE_t);
831 if ((sgl = kbuf_alloc_2_sgl(fwlen, sgdir, sge_offset,
832 &numfrags, &buflist, &sgl_dma, iocp)) == NULL)
836 * We should only need SGL with 2 simple_32bit entries (up to 256 kB)
837 * for FC9xx f/w image, but calculate max number of sge hunks
838 * we can fit into a request frame, and limit ourselves to that.
839 * (currently no chain support)
840 * maxfrags = (Request Size - FWdownload Size ) / Size of 32 bit SGE
846 maxfrags = (iocp->req_sz - sizeof(MPIHeader_t) - sizeof(FWDownloadTCSGE_t))
847 / (sizeof(dma_addr_t) + sizeof(u32));
848 if (numfrags > maxfrags) {
853 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: sgl buffer = %p, sgfrags = %d\n",
854 iocp->name, sgl, numfrags));
857 * Parse SG list, copying sgl itself,
858 * plus f/w image hunks from user space as we go...
863 for (i=0; i < numfrags; i++) {
865 /* Get the SGE type: 0 - TCSGE, 3 - Chain, 1 - Simple SGE
866 * Skip everything but Simple. If simple, copy from
867 * user space into kernel space.
868 * Note: we should not have anything but Simple as
869 * Chain SGE are illegal.
871 nib = (sgIn->FlagsLength & 0x30000000) >> 28;
872 if (nib == 0 || nib == 3) {
874 } else if (sgIn->Address) {
875 mpt_add_sge(sgOut, sgIn->FlagsLength, sgIn->Address);
877 if (copy_from_user(bl->kptr, ufwbuf+fw_bytes_copied, bl->len)) {
878 printk(KERN_ERR "%s@%d::_ioctl_fwdl - "
879 "Unable to copy f/w buffer hunk#%d @ %p\n",
880 __FILE__, __LINE__, n, ufwbuf);
883 fw_bytes_copied += bl->len;
887 sgOut += (sizeof(dma_addr_t) + sizeof(u32));
890 DBG_DUMP_FW_DOWNLOAD(iocp, (u32 *)mf, numfrags);
893 * Finally, perform firmware download.
896 mpt_put_msg_frame(mptctl_id, iocp, mf);
898 /* Now wait for the command to complete */
899 ret = wait_event_timeout(mptctl_wait,
900 iocp->ioctl->wait_done == 1,
903 if(ret <=0 && (iocp->ioctl->wait_done != 1 )) {
904 /* Now we need to reset the board */
905 mptctl_timeout_expired(iocp->ioctl);
911 kfree_sgl(sgl, sgl_dma, buflist, iocp);
913 ReplyMsg = (pFWDownloadReply_t)iocp->ioctl->ReplyFrame;
914 iocstat = le16_to_cpu(ReplyMsg->IOCStatus) & MPI_IOCSTATUS_MASK;
915 if (iocstat == MPI_IOCSTATUS_SUCCESS) {
916 printk(KERN_INFO MYNAM ": F/W update successfully sent to %s!\n", iocp->name);
918 } else if (iocstat == MPI_IOCSTATUS_INVALID_FUNCTION) {
919 printk(KERN_WARNING MYNAM ": ?Hmmm... %s says it doesn't support F/W download!?!\n",
921 printk(KERN_WARNING MYNAM ": (time to go bang on somebodies door)\n");
923 } else if (iocstat == MPI_IOCSTATUS_BUSY) {
924 printk(KERN_WARNING MYNAM ": Warning! %s says: IOC_BUSY!\n", iocp->name);
925 printk(KERN_WARNING MYNAM ": (try again later?)\n");
928 printk(KERN_WARNING MYNAM "::ioctl_fwdl() ERROR! %s returned [bad] status = %04xh\n",
929 iocp->name, iocstat);
930 printk(KERN_WARNING MYNAM ": (bad VooDoo)\n");
936 kfree_sgl(sgl, sgl_dma, buflist, iocp);
940 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
942 * SGE Allocation routine
944 * Inputs: bytes - number of bytes to be transferred
945 * sgdir - data direction
946 * sge_offset - offset (in bytes) from the start of the request
947 * frame to the first SGE
948 * ioc - pointer to the mptadapter
949 * Outputs: frags - number of scatter gather elements
950 * blp - point to the buflist pointer
951 * sglbuf_dma - pointer to the (dma) sgl
952 * Returns: Null if failes
953 * pointer to the (virtual) sgl if successful.
956 kbuf_alloc_2_sgl(int bytes, u32 sgdir, int sge_offset, int *frags,
957 struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc)
959 MptSge_t *sglbuf = NULL; /* pointer to array of SGE */
960 /* and chain buffers */
961 struct buflist *buflist = NULL; /* kernel routine */
965 int alloc_sz = min(bytes,MAX_KMALLOC_SZ); // avoid kernel warning msg!
966 int bytes_allocd = 0;
968 dma_addr_t pa; // phys addr
970 int sg_spill = MAX_FRAGS_SPILL1;
976 /* Allocate and initialize an array of kernel
977 * structures for the SG elements.
979 i = MAX_SGL_BYTES / 8;
980 buflist = kmalloc(i, GFP_USER);
983 memset(buflist, 0, i);
986 /* Allocate a single block of memory to store the sg elements and
987 * the chain buffers. The calling routine is responsible for
988 * copying the data in this array into the correct place in the
989 * request and chain buffers.
991 sglbuf = pci_alloc_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf_dma);
995 if (sgdir & 0x04000000)
996 dir = PCI_DMA_TODEVICE;
998 dir = PCI_DMA_FROMDEVICE;
1001 * sgl = sglbuf = point to beginning of sg buffer
1002 * buflist_ent = 0 = first kernel structure
1003 * sg_spill = number of SGE that can be written before the first
1008 sg_spill = ((ioc->req_sz - sge_offset)/(sizeof(dma_addr_t) + sizeof(u32))) - 1;
1009 while (bytes_allocd < bytes) {
1010 this_alloc = min(alloc_sz, bytes-bytes_allocd);
1011 buflist[buflist_ent].len = this_alloc;
1012 buflist[buflist_ent].kptr = pci_alloc_consistent(ioc->pcidev,
1015 if (buflist[buflist_ent].kptr == NULL) {
1016 alloc_sz = alloc_sz / 2;
1017 if (alloc_sz == 0) {
1018 printk(KERN_WARNING MYNAM "-SG: No can do - "
1019 "not enough memory! :-(\n");
1020 printk(KERN_WARNING MYNAM "-SG: (freeing %d frags)\n",
1026 dma_addr_t dma_addr;
1028 bytes_allocd += this_alloc;
1029 sgl->FlagsLength = (0x10000000|MPT_SGE_FLAGS_ADDRESSING|sgdir|this_alloc);
1030 dma_addr = pci_map_single(ioc->pcidev, buflist[buflist_ent].kptr, this_alloc, dir);
1031 sgl->Address = dma_addr;
1039 if (bytes_allocd >= bytes)
1042 /* Need to chain? */
1043 if (fragcnt == sg_spill) {
1044 printk(KERN_WARNING MYNAM "-SG: No can do - " "Chain required! :-(\n");
1045 printk(KERN_WARNING MYNAM "(freeing %d frags)\n", numfrags);
1049 /* overflow check... */
1050 if (numfrags*8 > MAX_SGL_BYTES){
1052 printk(KERN_WARNING MYNAM "-SG: No can do - "
1053 "too many SG frags! :-(\n");
1054 printk(KERN_WARNING MYNAM "-SG: (freeing %d frags)\n",
1060 /* Last sge fixup: set LE+eol+eob bits */
1061 sgl[-1].FlagsLength |= 0xC1000000;
1066 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: kbuf_alloc_2_sgl() - "
1067 "%d SG frags generated!\n", ioc->name, numfrags));
1069 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: kbuf_alloc_2_sgl() - "
1070 "last (big) alloc_sz=%d\n", ioc->name, alloc_sz));
1075 if (sglbuf != NULL) {
1078 for (i = 0; i < numfrags; i++) {
1079 dma_addr_t dma_addr;
1083 if ((sglbuf[i].FlagsLength >> 24) == 0x30)
1086 dma_addr = sglbuf[i].Address;
1087 kptr = buflist[i].kptr;
1088 len = buflist[i].len;
1090 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1092 pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf, *sglbuf_dma);
1098 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1100 * Routine to free the SGL elements.
1103 kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma, struct buflist *buflist, MPT_ADAPTER *ioc)
1106 struct buflist *bl = buflist;
1111 if (sg->FlagsLength & 0x04000000)
1112 dir = PCI_DMA_TODEVICE;
1114 dir = PCI_DMA_FROMDEVICE;
1116 nib = (sg->FlagsLength & 0xF0000000) >> 28;
1117 while (! (nib & 0x4)) { /* eob */
1118 /* skip ignore/chain. */
1119 if (nib == 0 || nib == 3) {
1121 } else if (sg->Address) {
1122 dma_addr_t dma_addr;
1126 dma_addr = sg->Address;
1129 pci_unmap_single(ioc->pcidev, dma_addr, len, dir);
1130 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1135 nib = (le32_to_cpu(sg->FlagsLength) & 0xF0000000) >> 28;
1140 dma_addr_t dma_addr;
1144 dma_addr = sg->Address;
1147 pci_unmap_single(ioc->pcidev, dma_addr, len, dir);
1148 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1152 pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sgl, sgl_dma);
1154 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: Free'd 1 SGL buf + %d kbufs!\n",
1158 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1160 * mptctl_getiocinfo - Query the host adapter for IOC information.
1161 * @arg: User space argument
1164 * Return: 0 if successful
1165 * -EFAULT if data unavailable
1166 * -ENODEV if no such device/adapter
1169 mptctl_getiocinfo (unsigned long arg, unsigned int data_size)
1171 struct mpt_ioctl_iocinfo __user *uarg = (void __user *) arg;
1172 struct mpt_ioctl_iocinfo *karg;
1174 struct pci_dev *pdev;
1179 struct scsi_device *sdev;
1182 /* Add of PCI INFO results in unaligned access for
1183 * IA64 and Sparc. Reset long to int. Return no PCI
1184 * data for obsolete format.
1186 if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev0))
1188 else if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev1))
1190 else if (data_size == sizeof(struct mpt_ioctl_iocinfo))
1192 else if (data_size == (sizeof(struct mpt_ioctl_iocinfo_rev0)+12))
1193 cim_rev = 0; /* obsolete */
1197 karg = kmalloc(data_size, GFP_KERNEL);
1199 printk(KERN_ERR "%s::mpt_ioctl_iocinfo() @%d - no memory available!\n",
1200 __FILE__, __LINE__);
1204 if (copy_from_user(karg, uarg, data_size)) {
1205 printk(KERN_ERR "%s@%d::mptctl_getiocinfo - "
1206 "Unable to read in mpt_ioctl_iocinfo struct @ %p\n",
1207 __FILE__, __LINE__, uarg);
1212 if (((iocnum = mpt_verify_adapter(karg->hdr.iocnum, &ioc)) < 0) ||
1214 printk(KERN_DEBUG "%s::mptctl_getiocinfo() @%d - ioc%d not found!\n",
1215 __FILE__, __LINE__, iocnum);
1220 /* Verify the data transfer size is correct. */
1221 if (karg->hdr.maxDataSize != data_size) {
1222 printk(KERN_ERR "%s@%d::mptctl_getiocinfo - "
1223 "Structure size mismatch. Command not completed.\n",
1224 __FILE__, __LINE__);
1229 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_getiocinfo called.\n",
1232 /* Fill in the data and return the structure to the calling
1235 if (ioc->bus_type == SAS)
1236 karg->adapterType = MPT_IOCTL_INTERFACE_SAS;
1237 else if (ioc->bus_type == FC)
1238 karg->adapterType = MPT_IOCTL_INTERFACE_FC;
1240 karg->adapterType = MPT_IOCTL_INTERFACE_SCSI;
1242 if (karg->hdr.port > 1)
1244 port = karg->hdr.port;
1247 pdev = (struct pci_dev *) ioc->pcidev;
1249 karg->pciId = pdev->device;
1250 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1251 karg->hwRev = revision;
1252 karg->subSystemDevice = pdev->subsystem_device;
1253 karg->subSystemVendor = pdev->subsystem_vendor;
1256 /* Get the PCI bus, device, and function numbers for the IOC
1258 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1259 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1260 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1261 } else if (cim_rev == 2) {
1262 /* Get the PCI bus, device, function and segment ID numbers
1264 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1265 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1266 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1267 karg->pciInfo.segmentID = pci_domain_nr(pdev->bus);
1270 /* Get number of devices
1272 karg->numDevices = 0;
1274 shost_for_each_device(sdev, ioc->sh) {
1275 vdev = sdev->hostdata;
1276 if (vdev->vtarget->tflags &
1277 MPT_TARGET_FLAGS_RAID_COMPONENT)
1283 /* Set the BIOS and FW Version
1285 karg->FWVersion = ioc->facts.FWVersion.Word;
1286 karg->BIOSVersion = ioc->biosVersion;
1288 /* Set the Version Strings.
1290 strncpy (karg->driverVersion, MPT_LINUX_PACKAGE_NAME, MPT_IOCTL_VERSION_LENGTH);
1291 karg->driverVersion[MPT_IOCTL_VERSION_LENGTH-1]='\0';
1293 karg->busChangeEvent = 0;
1294 karg->hostId = ioc->pfacts[port].PortSCSIID;
1295 karg->rsvd[0] = karg->rsvd[1] = 0;
1297 /* Copy the data from kernel memory to user memory
1299 if (copy_to_user((char __user *)arg, karg, data_size)) {
1300 printk(KERN_ERR "%s@%d::mptctl_getiocinfo - "
1301 "Unable to write out mpt_ioctl_iocinfo struct @ %p\n",
1302 __FILE__, __LINE__, uarg);
1311 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1313 * mptctl_gettargetinfo - Query the host adapter for target information.
1314 * @arg: User space argument
1317 * Return: 0 if successful
1318 * -EFAULT if data unavailable
1319 * -ENODEV if no such device/adapter
1322 mptctl_gettargetinfo (unsigned long arg)
1324 struct mpt_ioctl_targetinfo __user *uarg = (void __user *) arg;
1325 struct mpt_ioctl_targetinfo karg;
1336 struct scsi_device *sdev;
1338 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_targetinfo))) {
1339 printk(KERN_ERR "%s@%d::mptctl_gettargetinfo - "
1340 "Unable to read in mpt_ioctl_targetinfo struct @ %p\n",
1341 __FILE__, __LINE__, uarg);
1345 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1347 printk(KERN_DEBUG "%s::mptctl_gettargetinfo() @%d - ioc%d not found!\n",
1348 __FILE__, __LINE__, iocnum);
1352 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_gettargetinfo called.\n",
1354 /* Get the port number and set the maximum number of bytes
1355 * in the returned structure.
1356 * Ignore the port setting.
1358 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1359 maxWordsLeft = numBytes/sizeof(int);
1360 port = karg.hdr.port;
1362 if (maxWordsLeft <= 0) {
1363 printk(KERN_ERR "%s::mptctl_gettargetinfo() @%d - no memory available!\n",
1364 __FILE__, __LINE__);
1368 /* Fill in the data and return the structure to the calling
1372 /* struct mpt_ioctl_targetinfo does not contain sufficient space
1373 * for the target structures so when the IOCTL is called, there is
1374 * not sufficient stack space for the structure. Allocate memory,
1375 * populate the memory, copy back to the user, then free memory.
1376 * targetInfo format:
1377 * bits 31-24: reserved
1382 pmem = kmalloc(numBytes, GFP_KERNEL);
1384 printk(KERN_ERR "%s::mptctl_gettargetinfo() @%d - no memory available!\n",
1385 __FILE__, __LINE__);
1388 memset(pmem, 0, numBytes);
1389 pdata = (int *) pmem;
1391 /* Get number of devices
1394 shost_for_each_device(sdev, ioc->sh) {
1397 vdev = sdev->hostdata;
1398 if (vdev->vtarget->tflags &
1399 MPT_TARGET_FLAGS_RAID_COMPONENT)
1401 lun = (vdev->vtarget->raidVolume) ? 0x80 : vdev->lun;
1402 *pdata = (((u8)lun << 16) + (vdev->vtarget->channel << 8) +
1403 (vdev->vtarget->id ));
1409 karg.numDevices = numDevices;
1411 /* Copy part of the data from kernel memory to user memory
1413 if (copy_to_user((char __user *)arg, &karg,
1414 sizeof(struct mpt_ioctl_targetinfo))) {
1415 printk(KERN_ERR "%s@%d::mptctl_gettargetinfo - "
1416 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1417 __FILE__, __LINE__, uarg);
1422 /* Copy the remaining data from kernel memory to user memory
1424 if (copy_to_user(uarg->targetInfo, pmem, numBytes)) {
1425 printk(KERN_ERR "%s@%d::mptctl_gettargetinfo - "
1426 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1427 __FILE__, __LINE__, pdata);
1437 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1438 /* MPT IOCTL Test function.
1441 * Return: 0 if successful
1442 * -EFAULT if data unavailable
1443 * -ENODEV if no such device/adapter
1446 mptctl_readtest (unsigned long arg)
1448 struct mpt_ioctl_test __user *uarg = (void __user *) arg;
1449 struct mpt_ioctl_test karg;
1453 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_test))) {
1454 printk(KERN_ERR "%s@%d::mptctl_readtest - "
1455 "Unable to read in mpt_ioctl_test struct @ %p\n",
1456 __FILE__, __LINE__, uarg);
1460 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1462 printk(KERN_DEBUG "%s::mptctl_readtest() @%d - ioc%d not found!\n",
1463 __FILE__, __LINE__, iocnum);
1467 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_readtest called.\n",
1469 /* Fill in the data and return the structure to the calling
1474 karg.chip_type = ioc->mfcnt;
1476 karg.chip_type = ioc->pcidev->device;
1478 strncpy (karg.name, ioc->name, MPT_MAX_NAME);
1479 karg.name[MPT_MAX_NAME-1]='\0';
1480 strncpy (karg.product, ioc->prod_name, MPT_PRODUCT_LENGTH);
1481 karg.product[MPT_PRODUCT_LENGTH-1]='\0';
1483 /* Copy the data from kernel memory to user memory
1485 if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_test))) {
1486 printk(KERN_ERR "%s@%d::mptctl_readtest - "
1487 "Unable to write out mpt_ioctl_test struct @ %p\n",
1488 __FILE__, __LINE__, uarg);
1495 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1497 * mptctl_eventquery - Query the host adapter for the event types
1498 * that are being logged.
1499 * @arg: User space argument
1502 * Return: 0 if successful
1503 * -EFAULT if data unavailable
1504 * -ENODEV if no such device/adapter
1507 mptctl_eventquery (unsigned long arg)
1509 struct mpt_ioctl_eventquery __user *uarg = (void __user *) arg;
1510 struct mpt_ioctl_eventquery karg;
1514 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventquery))) {
1515 printk(KERN_ERR "%s@%d::mptctl_eventquery - "
1516 "Unable to read in mpt_ioctl_eventquery struct @ %p\n",
1517 __FILE__, __LINE__, uarg);
1521 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1523 printk(KERN_DEBUG "%s::mptctl_eventquery() @%d - ioc%d not found!\n",
1524 __FILE__, __LINE__, iocnum);
1528 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventquery called.\n",
1530 karg.eventEntries = MPTCTL_EVENT_LOG_SIZE;
1531 karg.eventTypes = ioc->eventTypes;
1533 /* Copy the data from kernel memory to user memory
1535 if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_eventquery))) {
1536 printk(KERN_ERR "%s@%d::mptctl_eventquery - "
1537 "Unable to write out mpt_ioctl_eventquery struct @ %p\n",
1538 __FILE__, __LINE__, uarg);
1544 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1546 mptctl_eventenable (unsigned long arg)
1548 struct mpt_ioctl_eventenable __user *uarg = (void __user *) arg;
1549 struct mpt_ioctl_eventenable karg;
1553 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventenable))) {
1554 printk(KERN_ERR "%s@%d::mptctl_eventenable - "
1555 "Unable to read in mpt_ioctl_eventenable struct @ %p\n",
1556 __FILE__, __LINE__, uarg);
1560 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1562 printk(KERN_DEBUG "%s::mptctl_eventenable() @%d - ioc%d not found!\n",
1563 __FILE__, __LINE__, iocnum);
1567 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventenable called.\n",
1569 if (ioc->events == NULL) {
1570 /* Have not yet allocated memory - do so now.
1572 int sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
1573 ioc->events = kmalloc(sz, GFP_KERNEL);
1574 if (ioc->events == NULL) {
1575 printk(KERN_ERR MYNAM ": ERROR - Insufficient memory to add adapter!\n");
1578 memset(ioc->events, 0, sz);
1579 ioc->alloc_total += sz;
1581 ioc->eventContext = 0;
1584 /* Update the IOC event logging flag.
1586 ioc->eventTypes = karg.eventTypes;
1591 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1593 mptctl_eventreport (unsigned long arg)
1595 struct mpt_ioctl_eventreport __user *uarg = (void __user *) arg;
1596 struct mpt_ioctl_eventreport karg;
1599 int numBytes, maxEvents, max;
1601 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventreport))) {
1602 printk(KERN_ERR "%s@%d::mptctl_eventreport - "
1603 "Unable to read in mpt_ioctl_eventreport struct @ %p\n",
1604 __FILE__, __LINE__, uarg);
1608 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1610 printk(KERN_DEBUG "%s::mptctl_eventreport() @%d - ioc%d not found!\n",
1611 __FILE__, __LINE__, iocnum);
1614 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventreport called.\n",
1617 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1618 maxEvents = numBytes/sizeof(MPT_IOCTL_EVENTS);
1621 max = MPTCTL_EVENT_LOG_SIZE < maxEvents ? MPTCTL_EVENT_LOG_SIZE : maxEvents;
1623 /* If fewer than 1 event is requested, there must have
1624 * been some type of error.
1626 if ((max < 1) || !ioc->events)
1629 /* reset this flag so SIGIO can restart */
1630 ioc->aen_event_read_flag=0;
1632 /* Copy the data from kernel memory to user memory
1634 numBytes = max * sizeof(MPT_IOCTL_EVENTS);
1635 if (copy_to_user(uarg->eventData, ioc->events, numBytes)) {
1636 printk(KERN_ERR "%s@%d::mptctl_eventreport - "
1637 "Unable to write out mpt_ioctl_eventreport struct @ %p\n",
1638 __FILE__, __LINE__, ioc->events);
1645 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1647 mptctl_replace_fw (unsigned long arg)
1649 struct mpt_ioctl_replace_fw __user *uarg = (void __user *) arg;
1650 struct mpt_ioctl_replace_fw karg;
1655 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_replace_fw))) {
1656 printk(KERN_ERR "%s@%d::mptctl_replace_fw - "
1657 "Unable to read in mpt_ioctl_replace_fw struct @ %p\n",
1658 __FILE__, __LINE__, uarg);
1662 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1664 printk(KERN_DEBUG "%s::mptctl_replace_fw() @%d - ioc%d not found!\n",
1665 __FILE__, __LINE__, iocnum);
1669 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_replace_fw called.\n",
1671 /* If caching FW, Free the old FW image
1673 if (ioc->cached_fw == NULL)
1676 mpt_free_fw_memory(ioc);
1678 /* Allocate memory for the new FW image
1680 newFwSize = karg.newImageSize;
1682 if (newFwSize & 0x01)
1684 if (newFwSize & 0x02)
1687 mpt_alloc_fw_memory(ioc, newFwSize);
1688 if (ioc->cached_fw == NULL)
1691 /* Copy the data from user memory to kernel space
1693 if (copy_from_user(ioc->cached_fw, uarg->newImage, newFwSize)) {
1694 printk(KERN_ERR "%s@%d::mptctl_replace_fw - "
1695 "Unable to read in mpt_ioctl_replace_fw image "
1696 "@ %p\n", __FILE__, __LINE__, uarg);
1697 mpt_free_fw_memory(ioc);
1701 /* Update IOCFactsReply
1703 ioc->facts.FWImageSize = newFwSize;
1707 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1708 /* MPT IOCTL MPTCOMMAND function.
1709 * Cast the arg into the mpt_ioctl_mpt_command structure.
1712 * Return: 0 if successful
1713 * -EBUSY if previous command timout and IOC reset is not complete.
1714 * -EFAULT if data unavailable
1715 * -ENODEV if no such device/adapter
1716 * -ETIME if timer expires
1717 * -ENOMEM if memory allocation error
1720 mptctl_mpt_command (unsigned long arg)
1722 struct mpt_ioctl_command __user *uarg = (void __user *) arg;
1723 struct mpt_ioctl_command karg;
1729 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_command))) {
1730 printk(KERN_ERR "%s@%d::mptctl_mpt_command - "
1731 "Unable to read in mpt_ioctl_command struct @ %p\n",
1732 __FILE__, __LINE__, uarg);
1736 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1738 printk(KERN_DEBUG "%s::mptctl_mpt_command() @%d - ioc%d not found!\n",
1739 __FILE__, __LINE__, iocnum);
1743 rc = mptctl_do_mpt_command (karg, &uarg->MF);
1748 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1749 /* Worker routine for the IOCTL MPTCOMMAND and MPTCOMMAND32 (sparc) commands.
1752 * Return: 0 if successful
1753 * -EBUSY if previous command timout and IOC reset is not complete.
1754 * -EFAULT if data unavailable
1755 * -ENODEV if no such device/adapter
1756 * -ETIME if timer expires
1757 * -ENOMEM if memory allocation error
1758 * -EPERM if SCSI I/O and target is untagged
1761 mptctl_do_mpt_command (struct mpt_ioctl_command karg, void __user *mfPtr)
1764 MPT_FRAME_HDR *mf = NULL;
1767 struct buflist bufIn; /* data In buffer */
1768 struct buflist bufOut; /* data Out buffer */
1769 dma_addr_t dma_addr_in;
1770 dma_addr_t dma_addr_out;
1771 int sgSize = 0; /* Num SG elements */
1772 int iocnum, flagsLength;
1777 struct scsi_device *sdev;
1779 bufIn.kptr = bufOut.kptr = NULL;
1781 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1783 printk(KERN_DEBUG "%s::mptctl_do_mpt_command() @%d - ioc%d not found!\n",
1784 __FILE__, __LINE__, iocnum);
1788 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1789 "No memory available during driver init.\n",
1790 __FILE__, __LINE__);
1792 } else if (ioc->ioctl->status & MPT_IOCTL_STATUS_DID_IOCRESET) {
1793 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1794 "Busy with IOC Reset \n", __FILE__, __LINE__);
1798 /* Verify that the final request frame will not be too large.
1800 sz = karg.dataSgeOffset * 4;
1801 if (karg.dataInSize > 0)
1802 sz += sizeof(dma_addr_t) + sizeof(u32);
1803 if (karg.dataOutSize > 0)
1804 sz += sizeof(dma_addr_t) + sizeof(u32);
1806 if (sz > ioc->req_sz) {
1807 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1808 "Request frame too large (%d) maximum (%d)\n",
1809 __FILE__, __LINE__, sz, ioc->req_sz);
1813 /* Get a free request frame and save the message context.
1815 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
1818 hdr = (MPIHeader_t *) mf;
1819 msgContext = le32_to_cpu(hdr->MsgContext);
1820 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1822 /* Copy the request frame
1823 * Reset the saved message context.
1824 * Request frame in user space
1826 if (copy_from_user(mf, mfPtr, karg.dataSgeOffset * 4)) {
1827 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1828 "Unable to read MF from mpt_ioctl_command struct @ %p\n",
1829 __FILE__, __LINE__, mfPtr);
1833 hdr->MsgContext = cpu_to_le32(msgContext);
1836 /* Verify that this request is allowed.
1838 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sending mpi function (0x%02X), req=%p\n",
1839 ioc->name, hdr->Function, mf));
1841 switch (hdr->Function) {
1842 case MPI_FUNCTION_IOC_FACTS:
1843 case MPI_FUNCTION_PORT_FACTS:
1844 karg.dataOutSize = karg.dataInSize = 0;
1847 case MPI_FUNCTION_CONFIG:
1849 Config_t *config_frame;
1850 config_frame = (Config_t *)mf;
1851 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\ttype=0x%02x ext_type=0x%02x "
1852 "number=0x%02x action=0x%02x\n", ioc->name,
1853 config_frame->Header.PageType,
1854 config_frame->ExtPageType,
1855 config_frame->Header.PageNumber,
1856 config_frame->Action));
1860 case MPI_FUNCTION_FC_COMMON_TRANSPORT_SEND:
1861 case MPI_FUNCTION_FC_EX_LINK_SRVC_SEND:
1862 case MPI_FUNCTION_FW_UPLOAD:
1863 case MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR:
1864 case MPI_FUNCTION_FW_DOWNLOAD:
1865 case MPI_FUNCTION_FC_PRIMITIVE_SEND:
1866 case MPI_FUNCTION_TOOLBOX:
1867 case MPI_FUNCTION_SAS_IO_UNIT_CONTROL:
1870 case MPI_FUNCTION_SCSI_IO_REQUEST:
1872 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
1873 int qtag = MPI_SCSIIO_CONTROL_UNTAGGED;
1878 id = (ioc->devices_per_bus == 0) ? 256 : ioc->devices_per_bus;
1879 if (pScsiReq->TargetID > id) {
1880 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1881 "Target ID out of bounds. \n",
1882 __FILE__, __LINE__);
1887 if (pScsiReq->Bus >= ioc->number_of_buses) {
1888 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1889 "Target Bus out of bounds. \n",
1890 __FILE__, __LINE__);
1895 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
1896 pScsiReq->MsgFlags |= mpt_msg_flags();
1899 /* verify that app has not requested
1900 * more sense data than driver
1901 * can provide, if so, reset this parameter
1902 * set the sense buffer pointer low address
1903 * update the control field to specify Q type
1905 if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1906 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1908 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1910 pScsiReq->SenseBufferLowAddr =
1911 cpu_to_le32(ioc->sense_buf_low_dma
1912 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
1914 shost_for_each_device(sdev, ioc->sh) {
1915 struct scsi_target *starget = scsi_target(sdev);
1916 VirtTarget *vtarget = starget->hostdata;
1918 if ((pScsiReq->TargetID == vtarget->id) &&
1919 (pScsiReq->Bus == vtarget->channel) &&
1920 (vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
1921 qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
1924 /* Have the IOCTL driver set the direction based
1925 * on the dataOutSize (ordering issue with Sparc).
1927 if (karg.dataOutSize > 0) {
1928 scsidir = MPI_SCSIIO_CONTROL_WRITE;
1929 dataSize = karg.dataOutSize;
1931 scsidir = MPI_SCSIIO_CONTROL_READ;
1932 dataSize = karg.dataInSize;
1935 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
1936 pScsiReq->DataLength = cpu_to_le32(dataSize);
1938 ioc->ioctl->reset = MPTCTL_RESET_OK;
1939 ioc->ioctl->id = pScsiReq->TargetID;
1942 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1943 "SCSI driver is not loaded. \n",
1944 __FILE__, __LINE__);
1950 case MPI_FUNCTION_SMP_PASSTHROUGH:
1951 /* Check mf->PassthruFlags to determine if
1952 * transfer is ImmediateMode or not.
1953 * Immediate mode returns data in the ReplyFrame.
1954 * Else, we are sending request and response data
1955 * in two SGLs at the end of the mf.
1959 case MPI_FUNCTION_SATA_PASSTHROUGH:
1961 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1962 "SCSI driver is not loaded. \n",
1963 __FILE__, __LINE__);
1969 case MPI_FUNCTION_RAID_ACTION:
1974 case MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
1976 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
1977 int qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
1978 int scsidir = MPI_SCSIIO_CONTROL_READ;
1981 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
1982 pScsiReq->MsgFlags |= mpt_msg_flags();
1985 /* verify that app has not requested
1986 * more sense data than driver
1987 * can provide, if so, reset this parameter
1988 * set the sense buffer pointer low address
1989 * update the control field to specify Q type
1991 if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1992 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1994 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1996 pScsiReq->SenseBufferLowAddr =
1997 cpu_to_le32(ioc->sense_buf_low_dma
1998 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
2000 /* All commands to physical devices are tagged
2003 /* Have the IOCTL driver set the direction based
2004 * on the dataOutSize (ordering issue with Sparc).
2006 if (karg.dataOutSize > 0) {
2007 scsidir = MPI_SCSIIO_CONTROL_WRITE;
2008 dataSize = karg.dataOutSize;
2010 scsidir = MPI_SCSIIO_CONTROL_READ;
2011 dataSize = karg.dataInSize;
2014 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
2015 pScsiReq->DataLength = cpu_to_le32(dataSize);
2017 ioc->ioctl->reset = MPTCTL_RESET_OK;
2018 ioc->ioctl->id = pScsiReq->TargetID;
2020 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2021 "SCSI driver is not loaded. \n",
2022 __FILE__, __LINE__);
2028 case MPI_FUNCTION_SCSI_TASK_MGMT:
2030 MPT_SCSI_HOST *hd = NULL;
2031 if ((ioc->sh == NULL) || ((hd = (MPT_SCSI_HOST *)ioc->sh->hostdata) == NULL)) {
2032 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2033 "SCSI driver not loaded or SCSI host not found. \n",
2034 __FILE__, __LINE__);
2037 } else if (mptctl_set_tm_flags(hd) != 0) {
2044 case MPI_FUNCTION_IOC_INIT:
2046 IOCInit_t *pInit = (IOCInit_t *) mf;
2047 u32 high_addr, sense_high;
2049 /* Verify that all entries in the IOC INIT match
2050 * existing setup (and in LE format).
2052 if (sizeof(dma_addr_t) == sizeof(u64)) {
2053 high_addr = cpu_to_le32((u32)((u64)ioc->req_frames_dma >> 32));
2054 sense_high= cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
2060 if ((pInit->Flags != 0) || (pInit->MaxDevices != ioc->facts.MaxDevices) ||
2061 (pInit->MaxBuses != ioc->facts.MaxBuses) ||
2062 (pInit->ReplyFrameSize != cpu_to_le16(ioc->reply_sz)) ||
2063 (pInit->HostMfaHighAddr != high_addr) ||
2064 (pInit->SenseBufferHighAddr != sense_high)) {
2065 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2066 "IOC_INIT issued with 1 or more incorrect parameters. Rejected.\n",
2067 __FILE__, __LINE__);
2075 * MPI_FUNCTION_PORT_ENABLE
2076 * MPI_FUNCTION_TARGET_CMD_BUFFER_POST
2077 * MPI_FUNCTION_TARGET_ASSIST
2078 * MPI_FUNCTION_TARGET_STATUS_SEND
2079 * MPI_FUNCTION_TARGET_MODE_ABORT
2080 * MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET
2081 * MPI_FUNCTION_IO_UNIT_RESET
2082 * MPI_FUNCTION_HANDSHAKE
2083 * MPI_FUNCTION_REPLY_FRAME_REMOVAL
2084 * MPI_FUNCTION_EVENT_NOTIFICATION
2085 * (driver handles event notification)
2086 * MPI_FUNCTION_EVENT_ACK
2089 /* What to do with these??? CHECK ME!!!
2090 MPI_FUNCTION_FC_LINK_SRVC_BUF_POST
2091 MPI_FUNCTION_FC_LINK_SRVC_RSP
2092 MPI_FUNCTION_FC_ABORT
2093 MPI_FUNCTION_LAN_SEND
2094 MPI_FUNCTION_LAN_RECEIVE
2095 MPI_FUNCTION_LAN_RESET
2098 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2099 "Illegal request (function 0x%x) \n",
2100 __FILE__, __LINE__, hdr->Function);
2105 /* Add the SGL ( at most one data in SGE and one data out SGE )
2106 * In the case of two SGE's - the data out (write) will always
2107 * preceede the data in (read) SGE. psgList is used to free the
2110 psge = (char *) (((int *) mf) + karg.dataSgeOffset);
2113 /* bufIn and bufOut are used for user to kernel space transfers
2115 bufIn.kptr = bufOut.kptr = NULL;
2116 bufIn.len = bufOut.len = 0;
2118 if (karg.dataOutSize > 0)
2121 if (karg.dataInSize > 0)
2126 /* Set up the dataOut memory allocation */
2127 if (karg.dataOutSize > 0) {
2128 if (karg.dataInSize > 0) {
2129 flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2130 MPI_SGE_FLAGS_END_OF_BUFFER |
2131 MPI_SGE_FLAGS_DIRECTION |
2133 << MPI_SGE_FLAGS_SHIFT;
2135 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
2137 flagsLength |= karg.dataOutSize;
2138 bufOut.len = karg.dataOutSize;
2139 bufOut.kptr = pci_alloc_consistent(
2140 ioc->pcidev, bufOut.len, &dma_addr_out);
2142 if (bufOut.kptr == NULL) {
2147 * Copy to MF and to sglbuf
2149 mpt_add_sge(psge, flagsLength, dma_addr_out);
2150 psge += (sizeof(u32) + sizeof(dma_addr_t));
2152 /* Copy user data to kernel space.
2154 if (copy_from_user(bufOut.kptr,
2158 "%s@%d::mptctl_do_mpt_command - Unable "
2159 "to read user data "
2161 __FILE__, __LINE__,karg.dataOutBufPtr);
2168 if (karg.dataInSize > 0) {
2169 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
2170 flagsLength |= karg.dataInSize;
2172 bufIn.len = karg.dataInSize;
2173 bufIn.kptr = pci_alloc_consistent(ioc->pcidev,
2174 bufIn.len, &dma_addr_in);
2176 if (bufIn.kptr == NULL) {
2181 * Copy to MF and to sglbuf
2183 mpt_add_sge(psge, flagsLength, dma_addr_in);
2189 mpt_add_sge(psge, flagsLength, (dma_addr_t) -1);
2192 ioc->ioctl->wait_done = 0;
2193 if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT) {
2195 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
2197 if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
2198 (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
2199 mpt_put_msg_frame_hi_pri(mptctl_id, ioc, mf);
2201 rc =mpt_send_handshake_request(mptctl_id, ioc,
2202 sizeof(SCSITaskMgmt_t), (u32*)mf, CAN_SLEEP);
2204 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2205 "_send_handshake FAILED! (ioc %p, mf %p)\n",
2206 ioc->name, ioc, mf));
2207 mptctl_free_tm_flags(ioc);
2214 mpt_put_msg_frame(mptctl_id, ioc, mf);
2216 /* Now wait for the command to complete */
2217 timeout = (karg.timeout > 0) ? karg.timeout : MPT_IOCTL_DEFAULT_TIMEOUT;
2218 timeout = wait_event_timeout(mptctl_wait,
2219 ioc->ioctl->wait_done == 1,
2222 if(timeout <=0 && (ioc->ioctl->wait_done != 1 )) {
2223 /* Now we need to reset the board */
2225 if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT)
2226 mptctl_free_tm_flags(ioc);
2228 mptctl_timeout_expired(ioc->ioctl);
2235 /* If a valid reply frame, copy to the user.
2236 * Offset 2: reply length in U32's
2238 if (ioc->ioctl->status & MPT_IOCTL_STATUS_RF_VALID) {
2239 if (karg.maxReplyBytes < ioc->reply_sz) {
2240 sz = min(karg.maxReplyBytes, 4*ioc->ioctl->ReplyFrame[2]);
2242 sz = min(ioc->reply_sz, 4*ioc->ioctl->ReplyFrame[2]);
2246 if (copy_to_user(karg.replyFrameBufPtr,
2247 &ioc->ioctl->ReplyFrame, sz)){
2249 "%s@%d::mptctl_do_mpt_command - "
2250 "Unable to write out reply frame %p\n",
2251 __FILE__, __LINE__, karg.replyFrameBufPtr);
2258 /* If valid sense data, copy to user.
2260 if (ioc->ioctl->status & MPT_IOCTL_STATUS_SENSE_VALID) {
2261 sz = min(karg.maxSenseBytes, MPT_SENSE_BUFFER_SIZE);
2263 if (copy_to_user(karg.senseDataPtr, ioc->ioctl->sense, sz)) {
2264 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2265 "Unable to write sense data to user %p\n",
2274 /* If the overall status is _GOOD and data in, copy data
2277 if ((ioc->ioctl->status & MPT_IOCTL_STATUS_COMMAND_GOOD) &&
2278 (karg.dataInSize > 0) && (bufIn.kptr)) {
2280 if (copy_to_user(karg.dataInBufPtr,
2281 bufIn.kptr, karg.dataInSize)) {
2282 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2283 "Unable to write data to user %p\n",
2292 ioc->ioctl->status &= ~(MPT_IOCTL_STATUS_COMMAND_GOOD |
2293 MPT_IOCTL_STATUS_SENSE_VALID |
2294 MPT_IOCTL_STATUS_RF_VALID );
2296 /* Free the allocated memory.
2298 if (bufOut.kptr != NULL) {
2299 pci_free_consistent(ioc->pcidev,
2300 bufOut.len, (void *) bufOut.kptr, dma_addr_out);
2303 if (bufIn.kptr != NULL) {
2304 pci_free_consistent(ioc->pcidev,
2305 bufIn.len, (void *) bufIn.kptr, dma_addr_in);
2308 /* mf is null if command issued successfully
2309 * otherwise, failure occured after mf acquired.
2312 mpt_free_msg_frame(ioc, mf);
2317 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2318 /* Prototype Routine for the HOST INFO command.
2321 * Return: 0 if successful
2322 * -EFAULT if data unavailable
2323 * -EBUSY if previous command timout and IOC reset is not complete.
2324 * -ENODEV if no such device/adapter
2325 * -ETIME if timer expires
2326 * -ENOMEM if memory allocation error
2329 mptctl_hp_hostinfo(unsigned long arg, unsigned int data_size)
2331 hp_host_info_t __user *uarg = (void __user *) arg;
2333 struct pci_dev *pdev;
2336 hp_host_info_t karg;
2338 ConfigPageHeader_t hdr;
2341 ToolboxIstwiReadWriteRequest_t *IstwiRWRequest;
2342 MPT_FRAME_HDR *mf = NULL;
2343 MPIHeader_t *mpi_hdr;
2345 /* Reset long to int. Should affect IA64 and SPARC only
2347 if (data_size == sizeof(hp_host_info_t))
2349 else if (data_size == sizeof(hp_host_info_rev0_t))
2350 cim_rev = 0; /* obsolete */
2354 if (copy_from_user(&karg, uarg, sizeof(hp_host_info_t))) {
2355 printk(KERN_ERR "%s@%d::mptctl_hp_host_info - "
2356 "Unable to read in hp_host_info struct @ %p\n",
2357 __FILE__, __LINE__, uarg);
2361 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2363 printk(KERN_DEBUG "%s::mptctl_hp_hostinfo() @%d - ioc%d not found!\n",
2364 __FILE__, __LINE__, iocnum);
2367 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": mptctl_hp_hostinfo called.\n",
2370 /* Fill in the data and return the structure to the calling
2373 pdev = (struct pci_dev *) ioc->pcidev;
2375 karg.vendor = pdev->vendor;
2376 karg.device = pdev->device;
2377 karg.subsystem_id = pdev->subsystem_device;
2378 karg.subsystem_vendor = pdev->subsystem_vendor;
2379 karg.devfn = pdev->devfn;
2380 karg.bus = pdev->bus->number;
2382 /* Save the SCSI host no. if
2383 * SCSI driver loaded
2385 if (ioc->sh != NULL)
2386 karg.host_no = ioc->sh->host_no;
2390 /* Reformat the fw_version into a string
2392 karg.fw_version[0] = ioc->facts.FWVersion.Struct.Major >= 10 ?
2393 ((ioc->facts.FWVersion.Struct.Major / 10) + '0') : '0';
2394 karg.fw_version[1] = (ioc->facts.FWVersion.Struct.Major % 10 ) + '0';
2395 karg.fw_version[2] = '.';
2396 karg.fw_version[3] = ioc->facts.FWVersion.Struct.Minor >= 10 ?
2397 ((ioc->facts.FWVersion.Struct.Minor / 10) + '0') : '0';
2398 karg.fw_version[4] = (ioc->facts.FWVersion.Struct.Minor % 10 ) + '0';
2399 karg.fw_version[5] = '.';
2400 karg.fw_version[6] = ioc->facts.FWVersion.Struct.Unit >= 10 ?
2401 ((ioc->facts.FWVersion.Struct.Unit / 10) + '0') : '0';
2402 karg.fw_version[7] = (ioc->facts.FWVersion.Struct.Unit % 10 ) + '0';
2403 karg.fw_version[8] = '.';
2404 karg.fw_version[9] = ioc->facts.FWVersion.Struct.Dev >= 10 ?
2405 ((ioc->facts.FWVersion.Struct.Dev / 10) + '0') : '0';
2406 karg.fw_version[10] = (ioc->facts.FWVersion.Struct.Dev % 10 ) + '0';
2407 karg.fw_version[11] = '\0';
2409 /* Issue a config request to get the device serial number
2411 hdr.PageVersion = 0;
2414 hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
2415 cfg.cfghdr.hdr = &hdr;
2418 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2419 cfg.dir = 0; /* read */
2422 strncpy(karg.serial_number, " ", 24);
2423 if (mpt_config(ioc, &cfg) == 0) {
2424 if (cfg.cfghdr.hdr->PageLength > 0) {
2425 /* Issue the second config page request */
2426 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2428 pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
2430 cfg.physAddr = buf_dma;
2431 if (mpt_config(ioc, &cfg) == 0) {
2432 ManufacturingPage0_t *pdata = (ManufacturingPage0_t *) pbuf;
2433 if (strlen(pdata->BoardTracerNumber) > 1) {
2434 strncpy(karg.serial_number, pdata->BoardTracerNumber, 24);
2435 karg.serial_number[24-1]='\0';
2438 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
2443 rc = mpt_GetIocState(ioc, 1);
2445 case MPI_IOC_STATE_OPERATIONAL:
2446 karg.ioc_status = HP_STATUS_OK;
2449 case MPI_IOC_STATE_FAULT:
2450 karg.ioc_status = HP_STATUS_FAILED;
2453 case MPI_IOC_STATE_RESET:
2454 case MPI_IOC_STATE_READY:
2456 karg.ioc_status = HP_STATUS_OTHER;
2460 karg.base_io_addr = pci_resource_start(pdev, 0);
2462 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
2463 karg.bus_phys_width = HP_BUS_WIDTH_UNK;
2465 karg.bus_phys_width = HP_BUS_WIDTH_16;
2467 karg.hard_resets = 0;
2468 karg.soft_resets = 0;
2470 if (ioc->sh != NULL) {
2471 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)ioc->sh->hostdata;
2473 if (hd && (cim_rev == 1)) {
2474 karg.hard_resets = hd->hard_resets;
2475 karg.soft_resets = hd->soft_resets;
2476 karg.timeouts = hd->timeouts;
2481 * Gather ISTWI(Industry Standard Two Wire Interface) Data
2483 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
2484 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, no msg frames!!\n",
2485 ioc->name,__FUNCTION__));
2489 IstwiRWRequest = (ToolboxIstwiReadWriteRequest_t *)mf;
2490 mpi_hdr = (MPIHeader_t *) mf;
2491 memset(IstwiRWRequest,0,sizeof(ToolboxIstwiReadWriteRequest_t));
2492 IstwiRWRequest->Function = MPI_FUNCTION_TOOLBOX;
2493 IstwiRWRequest->Tool = MPI_TOOLBOX_ISTWI_READ_WRITE_TOOL;
2494 IstwiRWRequest->MsgContext = mpi_hdr->MsgContext;
2495 IstwiRWRequest->Flags = MPI_TB_ISTWI_FLAGS_READ;
2496 IstwiRWRequest->NumAddressBytes = 0x01;
2497 IstwiRWRequest->DataLength = cpu_to_le16(0x04);
2498 if (pdev->devfn & 1)
2499 IstwiRWRequest->DeviceAddr = 0xB2;
2501 IstwiRWRequest->DeviceAddr = 0xB0;
2503 pbuf = pci_alloc_consistent(ioc->pcidev, 4, &buf_dma);
2506 mpt_add_sge((char *)&IstwiRWRequest->SGL,
2507 (MPT_SGE_FLAGS_SSIMPLE_READ|4), buf_dma);
2509 ioc->ioctl->wait_done = 0;
2510 mpt_put_msg_frame(mptctl_id, ioc, mf);
2512 rc = wait_event_timeout(mptctl_wait,
2513 ioc->ioctl->wait_done == 1,
2514 HZ*MPT_IOCTL_DEFAULT_TIMEOUT /* 10 sec */);
2516 if(rc <=0 && (ioc->ioctl->wait_done != 1 )) {
2518 * Now we need to reset the board
2520 mpt_free_msg_frame(ioc, mf);
2521 mptctl_timeout_expired(ioc->ioctl);
2526 *ISTWI Data Definition
2527 * pbuf[0] = FW_VERSION = 0x4
2528 * pbuf[1] = Bay Count = 6 or 4 or 2, depending on
2529 * the config, you should be seeing one out of these three values
2530 * pbuf[2] = Drive Installed Map = bit pattern depend on which
2531 * bays have drives in them
2532 * pbuf[3] = Checksum (0x100 = (byte0 + byte2 + byte3)
2534 if (ioc->ioctl->status & MPT_IOCTL_STATUS_RF_VALID)
2535 karg.rsvd = *(u32 *)pbuf;
2539 pci_free_consistent(ioc->pcidev, 4, pbuf, buf_dma);
2541 /* Copy the data from kernel memory to user memory
2543 if (copy_to_user((char __user *)arg, &karg, sizeof(hp_host_info_t))) {
2544 printk(KERN_ERR "%s@%d::mptctl_hpgethostinfo - "
2545 "Unable to write out hp_host_info @ %p\n",
2546 __FILE__, __LINE__, uarg);
2554 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2555 /* Prototype Routine for the TARGET INFO command.
2558 * Return: 0 if successful
2559 * -EFAULT if data unavailable
2560 * -EBUSY if previous command timout and IOC reset is not complete.
2561 * -ENODEV if no such device/adapter
2562 * -ETIME if timer expires
2563 * -ENOMEM if memory allocation error
2566 mptctl_hp_targetinfo(unsigned long arg)
2568 hp_target_info_t __user *uarg = (void __user *) arg;
2569 SCSIDevicePage0_t *pg0_alloc;
2570 SCSIDevicePage3_t *pg3_alloc;
2572 MPT_SCSI_HOST *hd = NULL;
2573 hp_target_info_t karg;
2576 dma_addr_t page_dma;
2578 ConfigPageHeader_t hdr;
2579 int tmp, np, rc = 0;
2581 if (copy_from_user(&karg, uarg, sizeof(hp_target_info_t))) {
2582 printk(KERN_ERR "%s@%d::mptctl_hp_targetinfo - "
2583 "Unable to read in hp_host_targetinfo struct @ %p\n",
2584 __FILE__, __LINE__, uarg);
2588 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2590 printk(KERN_DEBUG "%s::mptctl_hp_targetinfo() @%d - ioc%d not found!\n",
2591 __FILE__, __LINE__, iocnum);
2594 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": mptctl_hp_targetinfo called.\n",
2597 /* There is nothing to do for FCP parts.
2599 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
2602 if ((ioc->spi_data.sdp0length == 0) || (ioc->sh == NULL))
2605 if (ioc->sh->host_no != karg.hdr.host)
2608 /* Get the data transfer speeds
2610 data_sz = ioc->spi_data.sdp0length * 4;
2611 pg0_alloc = (SCSIDevicePage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
2613 hdr.PageVersion = ioc->spi_data.sdp0version;
2614 hdr.PageLength = data_sz;
2616 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2618 cfg.cfghdr.hdr = &hdr;
2619 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2622 cfg.physAddr = page_dma;
2624 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2626 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2627 np = le32_to_cpu(pg0_alloc->NegotiatedParameters);
2628 karg.negotiated_width = np & MPI_SCSIDEVPAGE0_NP_WIDE ?
2629 HP_BUS_WIDTH_16 : HP_BUS_WIDTH_8;
2631 if (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) {
2632 tmp = (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> 8;
2634 karg.negotiated_speed = HP_DEV_SPEED_ULTRA320;
2635 else if (tmp <= 0x09)
2636 karg.negotiated_speed = HP_DEV_SPEED_ULTRA160;
2637 else if (tmp <= 0x0A)
2638 karg.negotiated_speed = HP_DEV_SPEED_ULTRA2;
2639 else if (tmp <= 0x0C)
2640 karg.negotiated_speed = HP_DEV_SPEED_ULTRA;
2641 else if (tmp <= 0x25)
2642 karg.negotiated_speed = HP_DEV_SPEED_FAST;
2644 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2646 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2649 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg0_alloc, page_dma);
2654 karg.message_rejects = -1;
2655 karg.phase_errors = -1;
2656 karg.parity_errors = -1;
2657 karg.select_timeouts = -1;
2659 /* Get the target error parameters
2661 hdr.PageVersion = 0;
2664 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2666 cfg.cfghdr.hdr = &hdr;
2667 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2671 if ((mpt_config(ioc, &cfg) == 0) && (cfg.cfghdr.hdr->PageLength > 0)) {
2672 /* Issue the second config page request */
2673 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2674 data_sz = (int) cfg.cfghdr.hdr->PageLength * 4;
2675 pg3_alloc = (SCSIDevicePage3_t *) pci_alloc_consistent(
2676 ioc->pcidev, data_sz, &page_dma);
2678 cfg.physAddr = page_dma;
2679 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2680 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2681 karg.message_rejects = (u32) le16_to_cpu(pg3_alloc->MsgRejectCount);
2682 karg.phase_errors = (u32) le16_to_cpu(pg3_alloc->PhaseErrorCount);
2683 karg.parity_errors = (u32) le16_to_cpu(pg3_alloc->ParityErrorCount);
2685 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg3_alloc, page_dma);
2688 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
2690 karg.select_timeouts = hd->sel_timeout[karg.hdr.id];
2692 /* Copy the data from kernel memory to user memory
2694 if (copy_to_user((char __user *)arg, &karg, sizeof(hp_target_info_t))) {
2695 printk(KERN_ERR "%s@%d::mptctl_hp_target_info - "
2696 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
2697 __FILE__, __LINE__, uarg);
2704 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2706 static const struct file_operations mptctl_fops = {
2707 .owner = THIS_MODULE,
2708 .llseek = no_llseek,
2709 .release = mptctl_release,
2710 .fasync = mptctl_fasync,
2711 .unlocked_ioctl = mptctl_ioctl,
2712 #ifdef CONFIG_COMPAT
2713 .compat_ioctl = compat_mpctl_ioctl,
2717 static struct miscdevice mptctl_miscdev = {
2723 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2725 #ifdef CONFIG_COMPAT
2728 compat_mptfwxfer_ioctl(struct file *filp, unsigned int cmd,
2731 struct mpt_fw_xfer32 kfw32;
2732 struct mpt_fw_xfer kfw;
2733 MPT_ADAPTER *iocp = NULL;
2734 int iocnum, iocnumX;
2735 int nonblock = (filp->f_flags & O_NONBLOCK);
2739 if (copy_from_user(&kfw32, (char __user *)arg, sizeof(kfw32)))
2742 /* Verify intended MPT adapter */
2743 iocnumX = kfw32.iocnum & 0xFF;
2744 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2746 printk(KERN_DEBUG MYNAM "::compat_mptfwxfer_ioctl @%d - ioc%d not found!\n",
2751 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2754 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "compat_mptfwxfer_ioctl() called\n",
2756 kfw.iocnum = iocnum;
2757 kfw.fwlen = kfw32.fwlen;
2758 kfw.bufp = compat_ptr(kfw32.bufp);
2760 ret = mptctl_do_fw_download(kfw.iocnum, kfw.bufp, kfw.fwlen);
2762 mutex_unlock(&iocp->ioctl->ioctl_mutex);
2768 compat_mpt_command(struct file *filp, unsigned int cmd,
2771 struct mpt_ioctl_command32 karg32;
2772 struct mpt_ioctl_command32 __user *uarg = (struct mpt_ioctl_command32 __user *) arg;
2773 struct mpt_ioctl_command karg;
2774 MPT_ADAPTER *iocp = NULL;
2775 int iocnum, iocnumX;
2776 int nonblock = (filp->f_flags & O_NONBLOCK);
2779 if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32)))
2782 /* Verify intended MPT adapter */
2783 iocnumX = karg32.hdr.iocnum & 0xFF;
2784 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2786 printk(KERN_DEBUG MYNAM "::compat_mpt_command @%d - ioc%d not found!\n",
2791 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2794 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "compat_mpt_command() called\n",
2796 /* Copy data to karg */
2797 karg.hdr.iocnum = karg32.hdr.iocnum;
2798 karg.hdr.port = karg32.hdr.port;
2799 karg.timeout = karg32.timeout;
2800 karg.maxReplyBytes = karg32.maxReplyBytes;
2802 karg.dataInSize = karg32.dataInSize;
2803 karg.dataOutSize = karg32.dataOutSize;
2804 karg.maxSenseBytes = karg32.maxSenseBytes;
2805 karg.dataSgeOffset = karg32.dataSgeOffset;
2807 karg.replyFrameBufPtr = (char __user *)(unsigned long)karg32.replyFrameBufPtr;
2808 karg.dataInBufPtr = (char __user *)(unsigned long)karg32.dataInBufPtr;
2809 karg.dataOutBufPtr = (char __user *)(unsigned long)karg32.dataOutBufPtr;
2810 karg.senseDataPtr = (char __user *)(unsigned long)karg32.senseDataPtr;
2812 /* Pass new structure to do_mpt_command
2814 ret = mptctl_do_mpt_command (karg, &uarg->MF);
2816 mutex_unlock(&iocp->ioctl->ioctl_mutex);
2821 static long compat_mpctl_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
2831 case MPTEVENTENABLE:
2832 case MPTEVENTREPORT:
2834 case HP_GETHOSTINFO:
2835 case HP_GETTARGETINFO:
2837 ret = __mptctl_ioctl(f, cmd, arg);
2840 ret = compat_mpt_command(f, cmd, arg);
2842 case MPTFWDOWNLOAD32:
2843 ret = compat_mptfwxfer_ioctl(f, cmd, arg);
2856 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2858 * mptctl_probe - Installs ioctl devices per bus.
2859 * @pdev: Pointer to pci_dev structure
2861 * Returns 0 for success, non-zero for failure.
2866 mptctl_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2871 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
2874 * Allocate and inite a MPT_IOCTL structure
2876 sz = sizeof (MPT_IOCTL);
2877 mem = kmalloc(sz, GFP_KERNEL);
2884 ioc->ioctl = (MPT_IOCTL *) mem;
2885 ioc->ioctl->ioc = ioc;
2886 mutex_init(&ioc->ioctl->ioctl_mutex);
2891 mptctl_remove(pdev);
2895 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2897 * mptctl_remove - Removed ioctl devices
2898 * @pdev: Pointer to pci_dev structure
2903 mptctl_remove(struct pci_dev *pdev)
2905 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
2907 kfree ( ioc->ioctl );
2910 static struct mpt_pci_driver mptctl_driver = {
2911 .probe = mptctl_probe,
2912 .remove = mptctl_remove,
2915 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2916 static int __init mptctl_init(void)
2921 show_mptmod_ver(my_NAME, my_VERSION);
2923 mpt_device_driver_register(&mptctl_driver, MPTCTL_DRIVER);
2925 /* Register this device */
2926 err = misc_register(&mptctl_miscdev);
2928 printk(KERN_ERR MYNAM ": Can't register misc device [minor=%d].\n", MPT_MINOR);
2931 printk(KERN_INFO MYNAM ": Registered with Fusion MPT base driver\n");
2932 printk(KERN_INFO MYNAM ": /dev/%s @ (major,minor=%d,%d)\n",
2933 mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
2936 * Install our handler
2939 if ((mptctl_id = mpt_register(mptctl_reply, MPTCTL_DRIVER)) < 0) {
2940 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
2941 misc_deregister(&mptctl_miscdev);
2946 mpt_reset_register(mptctl_id, mptctl_ioc_reset);
2947 mpt_event_register(mptctl_id, mptctl_event_process);
2953 mpt_device_driver_deregister(MPTCTL_DRIVER);
2958 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2959 static void mptctl_exit(void)
2961 misc_deregister(&mptctl_miscdev);
2962 printk(KERN_INFO MYNAM ": Deregistered /dev/%s @ (major,minor=%d,%d)\n",
2963 mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
2965 /* De-register reset handler from base module */
2966 mpt_reset_deregister(mptctl_id);
2968 /* De-register callback handler from base module */
2969 mpt_deregister(mptctl_id);
2971 mpt_device_driver_deregister(MPTCTL_DRIVER);
2975 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2977 module_init(mptctl_init);
2978 module_exit(mptctl_exit);