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-2005 LSI Logic Corporation
8 * (mailto:mpt_linux_developer@lsil.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-2005 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");
83 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
85 static int mptctl_id = -1;
87 static DECLARE_WAIT_QUEUE_HEAD ( mptctl_wait );
89 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
97 * Function prototypes. Called from OS entry point mptctl_ioctl.
98 * arg contents specific to function.
100 static int mptctl_fw_download(unsigned long arg);
101 static int mptctl_getiocinfo(unsigned long arg, unsigned int cmd);
102 static int mptctl_gettargetinfo(unsigned long arg);
103 static int mptctl_readtest(unsigned long arg);
104 static int mptctl_mpt_command(unsigned long arg);
105 static int mptctl_eventquery(unsigned long arg);
106 static int mptctl_eventenable(unsigned long arg);
107 static int mptctl_eventreport(unsigned long arg);
108 static int mptctl_replace_fw(unsigned long arg);
110 static int mptctl_do_reset(unsigned long arg);
111 static int mptctl_hp_hostinfo(unsigned long arg, unsigned int cmd);
112 static int mptctl_hp_targetinfo(unsigned long arg);
114 static int mptctl_probe(struct pci_dev *, const struct pci_device_id *);
115 static void mptctl_remove(struct pci_dev *);
118 static long compat_mpctl_ioctl(struct file *f, unsigned cmd, unsigned long arg);
121 * Private function calls.
123 static int mptctl_do_mpt_command(struct mpt_ioctl_command karg, void __user *mfPtr);
124 static int mptctl_do_fw_download(int ioc, char __user *ufwbuf, size_t fwlen);
125 static MptSge_t *kbuf_alloc_2_sgl(int bytes, u32 dir, int sge_offset, int *frags,
126 struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc);
127 static void kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma,
128 struct buflist *buflist, MPT_ADAPTER *ioc);
129 static void mptctl_timeout_expired (MPT_IOCTL *ioctl);
130 static int mptctl_bus_reset(MPT_IOCTL *ioctl);
131 static int mptctl_set_tm_flags(MPT_SCSI_HOST *hd);
132 static void mptctl_free_tm_flags(MPT_ADAPTER *ioc);
135 * Reset Handler cleanup function
137 static int mptctl_ioc_reset(MPT_ADAPTER *ioc, int reset_phase);
139 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
141 * Scatter gather list (SGL) sizes and limits...
143 //#define MAX_SCSI_FRAGS 9
144 #define MAX_FRAGS_SPILL1 9
145 #define MAX_FRAGS_SPILL2 15
146 #define FRAGS_PER_BUCKET (MAX_FRAGS_SPILL2 + 1)
148 //#define MAX_CHAIN_FRAGS 64
149 //#define MAX_CHAIN_FRAGS (15+15+15+16)
150 #define MAX_CHAIN_FRAGS (4 * MAX_FRAGS_SPILL2 + 1)
152 // Define max sg LIST bytes ( == (#frags + #chains) * 8 bytes each)
153 // Works out to: 592d bytes! (9+1)*8 + 4*(15+1)*8
154 // ^----------------- 80 + 512
155 #define MAX_SGL_BYTES ((MAX_FRAGS_SPILL1 + 1 + (4 * FRAGS_PER_BUCKET)) * 8)
157 /* linux only seems to ever give 128kB MAX contiguous (GFP_USER) mem bytes */
158 #define MAX_KMALLOC_SZ (128*1024)
160 #define MPT_IOCTL_DEFAULT_TIMEOUT 10 /* Default timeout value (seconds) */
162 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
164 * mptctl_syscall_down - Down the MPT adapter syscall semaphore.
165 * @ioc: Pointer to MPT adapter
166 * @nonblock: boolean, non-zero if O_NONBLOCK is set
168 * All of the ioctl commands can potentially sleep, which is illegal
169 * with a spinlock held, thus we perform mutual exclusion here.
171 * Returns negative errno on error, or zero for success.
174 mptctl_syscall_down(MPT_ADAPTER *ioc, int nonblock)
177 dctlprintk((KERN_INFO MYNAM "::mptctl_syscall_down(%p,%d) called\n", ioc, nonblock));
180 if (!mutex_trylock(&ioc->ioctl->ioctl_mutex))
183 if (mutex_lock_interruptible(&ioc->ioctl->ioctl_mutex))
186 dctlprintk((KERN_INFO MYNAM "::mptctl_syscall_down return %d\n", rc));
190 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
192 * This is the callback for any message we have posted. The message itself
193 * will be returned to the message pool when we return from the IRQ
195 * This runs in irq context so be short and sweet.
198 mptctl_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply)
205 dctlprintk(("mptctl_reply()!\n"));
207 cmd = req->u.hdr.Function;
215 dctlprintk(("mptctl_reply() NULL Reply "
216 "Function=%x!\n", cmd));
218 ioc->ioctl->status |= MPT_IOCTL_STATUS_COMMAND_GOOD;
219 ioc->ioctl->reset &= ~MPTCTL_RESET_OK;
221 /* We are done, issue wake up
223 ioc->ioctl->wait_done = 1;
224 wake_up (&mptctl_wait);
229 dctlprintk(("mptctl_reply() with req=%p "
230 "reply=%p Function=%x!\n", req, reply, cmd));
232 /* Copy the reply frame (which much exist
233 * for non-SCSI I/O) to the IOC structure.
235 dctlprintk(("Copying Reply Frame @%p to ioc%d!\n",
237 memcpy(ioc->ioctl->ReplyFrame, reply,
238 min(ioc->reply_sz, 4*reply->u.reply.MsgLength));
239 ioc->ioctl->status |= MPT_IOCTL_STATUS_RF_VALID;
241 /* Set the command status to GOOD if IOC Status is GOOD
242 * OR if SCSI I/O cmd and data underrun or recovered error.
244 iocStatus = le16_to_cpu(reply->u.reply.IOCStatus) & MPI_IOCSTATUS_MASK;
245 if (iocStatus == MPI_IOCSTATUS_SUCCESS)
246 ioc->ioctl->status |= MPT_IOCTL_STATUS_COMMAND_GOOD;
248 if ((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) ||
249 (cmd == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
250 ioc->ioctl->reset &= ~MPTCTL_RESET_OK;
252 if ((iocStatus == MPI_IOCSTATUS_SCSI_DATA_UNDERRUN) ||
253 (iocStatus == MPI_IOCSTATUS_SCSI_RECOVERED_ERROR)) {
254 ioc->ioctl->status |= MPT_IOCTL_STATUS_COMMAND_GOOD;
258 /* Copy the sense data - if present
260 if ((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) &&
261 (reply->u.sreply.SCSIState &
262 MPI_SCSI_STATE_AUTOSENSE_VALID)){
263 sz = req->u.scsireq.SenseBufferLength;
265 le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx);
267 ((u8 *)ioc->sense_buf_pool +
268 (req_index * MPT_SENSE_BUFFER_ALLOC));
269 memcpy(ioc->ioctl->sense, sense_data, sz);
270 ioc->ioctl->status |= MPT_IOCTL_STATUS_SENSE_VALID;
273 if (cmd == MPI_FUNCTION_SCSI_TASK_MGMT)
274 mptctl_free_tm_flags(ioc);
276 /* We are done, issue wake up
278 ioc->ioctl->wait_done = 1;
279 wake_up (&mptctl_wait);
284 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
285 /* mptctl_timeout_expired
287 * Expecting an interrupt, however timed out.
290 static void mptctl_timeout_expired (MPT_IOCTL *ioctl)
294 dctlprintk((KERN_NOTICE MYNAM ": Timeout Expired! Host %d\n",
299 ioctl->wait_done = 0;
300 if (ioctl->reset & MPTCTL_RESET_OK)
301 rc = mptctl_bus_reset(ioctl);
304 /* Issue a reset for this device.
305 * The IOC is not responding.
307 dctlprintk((MYIOC_s_INFO_FMT "Calling HardReset! \n",
309 mpt_HardResetHandler(ioctl->ioc, NO_SLEEP);
320 static int mptctl_bus_reset(MPT_IOCTL *ioctl)
323 SCSITaskMgmt_t *pScsiTm;
329 ioctl->reset &= ~MPTCTL_RESET_OK;
331 if (ioctl->ioc->sh == NULL)
334 hd = (MPT_SCSI_HOST *) ioctl->ioc->sh->hostdata;
338 /* Single threading ....
340 if (mptctl_set_tm_flags(hd) != 0)
345 if ((mf = mpt_get_msg_frame(mptctl_id, ioctl->ioc)) == NULL) {
346 dctlprintk((MYIOC_s_WARN_FMT "IssueTaskMgmt, no msg frames!!\n",
349 mptctl_free_tm_flags(ioctl->ioc);
353 dtmprintk((MYIOC_s_INFO_FMT "IssueTaskMgmt request @ %p\n",
354 ioctl->ioc->name, mf));
356 pScsiTm = (SCSITaskMgmt_t *) mf;
357 pScsiTm->TargetID = ioctl->target;
358 pScsiTm->Bus = hd->port; /* 0 */
359 pScsiTm->ChainOffset = 0;
360 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
361 pScsiTm->Reserved = 0;
362 pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS;
363 pScsiTm->Reserved1 = 0;
364 pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
366 for (ii= 0; ii < 8; ii++)
367 pScsiTm->LUN[ii] = 0;
369 for (ii=0; ii < 7; ii++)
370 pScsiTm->Reserved2[ii] = 0;
372 pScsiTm->TaskMsgContext = 0;
373 dtmprintk((MYIOC_s_INFO_FMT
374 "mptctl_bus_reset: issued.\n", ioctl->ioc->name));
376 DBG_DUMP_TM_REQUEST_FRAME((u32 *)mf);
379 if ((retval = mpt_send_handshake_request(mptctl_id, ioctl->ioc,
380 sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP)) != 0) {
381 dfailprintk((MYIOC_s_ERR_FMT "_send_handshake FAILED!"
382 " (hd %p, ioc %p, mf %p) \n", hd->ioc->name, hd,
384 goto mptctl_bus_reset_done;
387 /* Now wait for the command to complete */
388 ii = wait_event_timeout(mptctl_wait,
389 ioctl->wait_done == 1,
390 HZ*5 /* 5 second timeout */);
392 if(ii <=0 && (ioctl->wait_done != 1 )) {
393 mpt_free_msg_frame(hd->ioc, mf);
394 ioctl->wait_done = 0;
395 retval = -1; /* return failure */
398 mptctl_bus_reset_done:
400 mptctl_free_tm_flags(ioctl->ioc);
405 mptctl_set_tm_flags(MPT_SCSI_HOST *hd) {
408 spin_lock_irqsave(&hd->ioc->FreeQlock, flags);
410 if (hd->tmState == TM_STATE_NONE) {
411 hd->tmState = TM_STATE_IN_PROGRESS;
413 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
415 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
423 mptctl_free_tm_flags(MPT_ADAPTER *ioc)
428 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
432 spin_lock_irqsave(&ioc->FreeQlock, flags);
434 hd->tmState = TM_STATE_NONE;
436 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
441 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
444 * Clean-up functionality. Used only if there has been a
445 * reload of the FW due.
449 mptctl_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
451 MPT_IOCTL *ioctl = ioc->ioctl;
452 dctlprintk((KERN_INFO MYNAM ": IOC %s_reset routed to IOCTL driver!\n",
453 reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
454 reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
459 switch(reset_phase) {
460 case MPT_IOC_SETUP_RESET:
461 ioctl->status |= MPT_IOCTL_STATUS_DID_IOCRESET;
463 case MPT_IOC_POST_RESET:
464 ioctl->status &= ~MPT_IOCTL_STATUS_DID_IOCRESET;
466 case MPT_IOC_PRE_RESET:
474 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
477 * cmd - specify the particular IOCTL command to be issued
478 * arg - data specific to the command. Must not be null.
481 __mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
483 mpt_ioctl_header __user *uhdr = (void __user *) arg;
484 mpt_ioctl_header khdr;
487 int nonblock = (file->f_flags & O_NONBLOCK);
489 MPT_ADAPTER *iocp = NULL;
491 dctlprintk(("mptctl_ioctl() called\n"));
493 if (copy_from_user(&khdr, uhdr, sizeof(khdr))) {
494 printk(KERN_ERR "%s::mptctl_ioctl() @%d - "
495 "Unable to copy mpt_ioctl_header data @ %p\n",
496 __FILE__, __LINE__, uhdr);
499 ret = -ENXIO; /* (-6) No such device or address */
501 /* Verify intended MPT adapter - set iocnum and the adapter
504 iocnumX = khdr.iocnum & 0xFF;
505 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
507 dctlprintk((KERN_ERR "%s::mptctl_ioctl() @%d - ioc%d not found!\n",
508 __FILE__, __LINE__, iocnumX));
513 printk(KERN_ERR "%s::mptctl_ioctl() @%d - Controller disabled.\n",
518 /* Handle those commands that are just returning
519 * information stored in the driver.
520 * These commands should never time out and are unaffected
521 * by TM and FW reloads.
523 if ((cmd & ~IOCSIZE_MASK) == (MPTIOCINFO & ~IOCSIZE_MASK)) {
524 return mptctl_getiocinfo(arg, _IOC_SIZE(cmd));
525 } else if (cmd == MPTTARGETINFO) {
526 return mptctl_gettargetinfo(arg);
527 } else if (cmd == MPTTEST) {
528 return mptctl_readtest(arg);
529 } else if (cmd == MPTEVENTQUERY) {
530 return mptctl_eventquery(arg);
531 } else if (cmd == MPTEVENTENABLE) {
532 return mptctl_eventenable(arg);
533 } else if (cmd == MPTEVENTREPORT) {
534 return mptctl_eventreport(arg);
535 } else if (cmd == MPTFWREPLACE) {
536 return mptctl_replace_fw(arg);
539 /* All of these commands require an interrupt or
540 * are unknown/illegal.
542 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
545 dctlprintk((MYIOC_s_INFO_FMT ": mptctl_ioctl()\n", iocp->name));
547 if (cmd == MPTFWDOWNLOAD)
548 ret = mptctl_fw_download(arg);
549 else if (cmd == MPTCOMMAND)
550 ret = mptctl_mpt_command(arg);
551 else if (cmd == MPTHARDRESET)
552 ret = mptctl_do_reset(arg);
553 else if ((cmd & ~IOCSIZE_MASK) == (HP_GETHOSTINFO & ~IOCSIZE_MASK))
554 ret = mptctl_hp_hostinfo(arg, _IOC_SIZE(cmd));
555 else if (cmd == HP_GETTARGETINFO)
556 ret = mptctl_hp_targetinfo(arg);
560 mutex_unlock(&iocp->ioctl->ioctl_mutex);
566 mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
570 ret = __mptctl_ioctl(file, cmd, arg);
575 static int mptctl_do_reset(unsigned long arg)
577 struct mpt_ioctl_diag_reset __user *urinfo = (void __user *) arg;
578 struct mpt_ioctl_diag_reset krinfo;
581 dctlprintk((KERN_INFO "mptctl_do_reset called.\n"));
583 if (copy_from_user(&krinfo, urinfo, sizeof(struct mpt_ioctl_diag_reset))) {
584 printk(KERN_ERR "%s@%d::mptctl_do_reset - "
585 "Unable to copy mpt_ioctl_diag_reset struct @ %p\n",
586 __FILE__, __LINE__, urinfo);
590 if (mpt_verify_adapter(krinfo.hdr.iocnum, &iocp) < 0) {
591 dctlprintk((KERN_ERR "%s@%d::mptctl_do_reset - ioc%d not found!\n",
592 __FILE__, __LINE__, krinfo.hdr.iocnum));
593 return -ENODEV; /* (-6) No such device or address */
596 if (mpt_HardResetHandler(iocp, CAN_SLEEP) != 0) {
597 printk (KERN_ERR "%s@%d::mptctl_do_reset - reset failed.\n",
605 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
607 * MPT FW download function. Cast the arg into the mpt_fw_xfer structure.
608 * This structure contains: iocnum, firmware length (bytes),
609 * pointer to user space memory where the fw image is stored.
612 * Return: 0 if successful
613 * -EFAULT if data unavailable
614 * -ENXIO if no such device
615 * -EAGAIN if resource problem
616 * -ENOMEM if no memory for SGE
617 * -EMLINK if too many chain buffers required
618 * -EBADRQC if adapter does not support FW download
619 * -EBUSY if adapter is busy
620 * -ENOMSG if FW upload returned bad status
623 mptctl_fw_download(unsigned long arg)
625 struct mpt_fw_xfer __user *ufwdl = (void __user *) arg;
626 struct mpt_fw_xfer kfwdl;
628 dctlprintk((KERN_INFO "mptctl_fwdl called. mptctl_id = %xh\n", mptctl_id)); //tc
629 if (copy_from_user(&kfwdl, ufwdl, sizeof(struct mpt_fw_xfer))) {
630 printk(KERN_ERR "%s@%d::_ioctl_fwdl - "
631 "Unable to copy mpt_fw_xfer struct @ %p\n",
632 __FILE__, __LINE__, ufwdl);
636 return mptctl_do_fw_download(kfwdl.iocnum, kfwdl.bufp, kfwdl.fwlen);
639 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
641 * FW Download engine.
643 * Return: 0 if successful
644 * -EFAULT if data unavailable
645 * -ENXIO if no such device
646 * -EAGAIN if resource problem
647 * -ENOMEM if no memory for SGE
648 * -EMLINK if too many chain buffers required
649 * -EBADRQC if adapter does not support FW download
650 * -EBUSY if adapter is busy
651 * -ENOMSG if FW upload returned bad status
654 mptctl_do_fw_download(int ioc, char __user *ufwbuf, size_t fwlen)
659 FWDownloadTCSGE_t *ptsge;
660 MptSge_t *sgl, *sgIn;
662 struct buflist *buflist;
671 int fw_bytes_copied = 0;
675 pFWDownloadReply_t ReplyMsg = NULL;
677 dctlprintk((KERN_INFO "mptctl_do_fwdl called. mptctl_id = %xh.\n", mptctl_id));
679 dctlprintk((KERN_INFO "DbG: kfwdl.bufp = %p\n", ufwbuf));
680 dctlprintk((KERN_INFO "DbG: kfwdl.fwlen = %d\n", (int)fwlen));
681 dctlprintk((KERN_INFO "DbG: kfwdl.ioc = %04xh\n", ioc));
683 if ((ioc = mpt_verify_adapter(ioc, &iocp)) < 0) {
684 dctlprintk(("%s@%d::_ioctl_fwdl - ioc%d not found!\n",
685 __FILE__, __LINE__, ioc));
686 return -ENODEV; /* (-6) No such device or address */
689 /* Valid device. Get a message frame and construct the FW download message.
691 if ((mf = mpt_get_msg_frame(mptctl_id, iocp)) == NULL)
693 dlmsg = (FWDownload_t*) mf;
694 ptsge = (FWDownloadTCSGE_t *) &dlmsg->SGL;
695 sgOut = (char *) (ptsge + 1);
698 * Construct f/w download request
700 dlmsg->ImageType = MPI_FW_DOWNLOAD_ITYPE_FW;
702 dlmsg->ChainOffset = 0;
703 dlmsg->Function = MPI_FUNCTION_FW_DOWNLOAD;
704 dlmsg->Reserved1[0] = dlmsg->Reserved1[1] = dlmsg->Reserved1[2] = 0;
707 /* Set up the Transaction SGE.
710 ptsge->ContextSize = 0;
711 ptsge->DetailsLength = 12;
712 ptsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
713 ptsge->Reserved_0100_Checksum = 0;
714 ptsge->ImageOffset = 0;
715 ptsge->ImageSize = cpu_to_le32(fwlen);
721 * Need to kmalloc area(s) for holding firmware image bytes.
722 * But we need to do it piece meal, using a proper
723 * scatter gather list (with 128kB MAX hunks).
725 * A practical limit here might be # of sg hunks that fit into
726 * a single IOC request frame; 12 or 8 (see below), so:
727 * For FC9xx: 12 x 128kB == 1.5 mB (max)
728 * For C1030: 8 x 128kB == 1 mB (max)
729 * We could support chaining, but things get ugly(ier:)
731 * Set the sge_offset to the start of the sgl (bytes).
733 sgdir = 0x04000000; /* IOC will READ from sys mem */
734 sge_offset = sizeof(MPIHeader_t) + sizeof(FWDownloadTCSGE_t);
735 if ((sgl = kbuf_alloc_2_sgl(fwlen, sgdir, sge_offset,
736 &numfrags, &buflist, &sgl_dma, iocp)) == NULL)
740 * We should only need SGL with 2 simple_32bit entries (up to 256 kB)
741 * for FC9xx f/w image, but calculate max number of sge hunks
742 * we can fit into a request frame, and limit ourselves to that.
743 * (currently no chain support)
744 * maxfrags = (Request Size - FWdownload Size ) / Size of 32 bit SGE
750 maxfrags = (iocp->req_sz - sizeof(MPIHeader_t) - sizeof(FWDownloadTCSGE_t))
751 / (sizeof(dma_addr_t) + sizeof(u32));
752 if (numfrags > maxfrags) {
757 dctlprintk((KERN_INFO "DbG: sgl buffer = %p, sgfrags = %d\n", sgl, numfrags));
760 * Parse SG list, copying sgl itself,
761 * plus f/w image hunks from user space as we go...
766 for (i=0; i < numfrags; i++) {
768 /* Get the SGE type: 0 - TCSGE, 3 - Chain, 1 - Simple SGE
769 * Skip everything but Simple. If simple, copy from
770 * user space into kernel space.
771 * Note: we should not have anything but Simple as
772 * Chain SGE are illegal.
774 nib = (sgIn->FlagsLength & 0x30000000) >> 28;
775 if (nib == 0 || nib == 3) {
777 } else if (sgIn->Address) {
778 mpt_add_sge(sgOut, sgIn->FlagsLength, sgIn->Address);
780 if (copy_from_user(bl->kptr, ufwbuf+fw_bytes_copied, bl->len)) {
781 printk(KERN_ERR "%s@%d::_ioctl_fwdl - "
782 "Unable to copy f/w buffer hunk#%d @ %p\n",
783 __FILE__, __LINE__, n, ufwbuf);
786 fw_bytes_copied += bl->len;
790 sgOut += (sizeof(dma_addr_t) + sizeof(u32));
796 printk(KERN_INFO MYNAM ": F/W download request:\n" KERN_INFO " ");
797 for (i=0; i < 7+numfrags*2; i++)
798 printk(" %08x", le32_to_cpu(m[i]));
804 * Finally, perform firmware download.
806 iocp->ioctl->wait_done = 0;
807 mpt_put_msg_frame(mptctl_id, iocp, mf);
809 /* Now wait for the command to complete */
810 ret = wait_event_timeout(mptctl_wait,
811 iocp->ioctl->wait_done == 1,
814 if(ret <=0 && (iocp->ioctl->wait_done != 1 )) {
815 /* Now we need to reset the board */
816 mptctl_timeout_expired(iocp->ioctl);
822 kfree_sgl(sgl, sgl_dma, buflist, iocp);
824 ReplyMsg = (pFWDownloadReply_t)iocp->ioctl->ReplyFrame;
825 iocstat = le16_to_cpu(ReplyMsg->IOCStatus) & MPI_IOCSTATUS_MASK;
826 if (iocstat == MPI_IOCSTATUS_SUCCESS) {
827 printk(KERN_INFO MYNAM ": F/W update successfully sent to %s!\n", iocp->name);
829 } else if (iocstat == MPI_IOCSTATUS_INVALID_FUNCTION) {
830 printk(KERN_WARNING MYNAM ": ?Hmmm... %s says it doesn't support F/W download!?!\n",
832 printk(KERN_WARNING MYNAM ": (time to go bang on somebodies door)\n");
834 } else if (iocstat == MPI_IOCSTATUS_BUSY) {
835 printk(KERN_WARNING MYNAM ": Warning! %s says: IOC_BUSY!\n", iocp->name);
836 printk(KERN_WARNING MYNAM ": (try again later?)\n");
839 printk(KERN_WARNING MYNAM "::ioctl_fwdl() ERROR! %s returned [bad] status = %04xh\n",
840 iocp->name, iocstat);
841 printk(KERN_WARNING MYNAM ": (bad VooDoo)\n");
847 kfree_sgl(sgl, sgl_dma, buflist, iocp);
851 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
853 * SGE Allocation routine
855 * Inputs: bytes - number of bytes to be transferred
856 * sgdir - data direction
857 * sge_offset - offset (in bytes) from the start of the request
858 * frame to the first SGE
859 * ioc - pointer to the mptadapter
860 * Outputs: frags - number of scatter gather elements
861 * blp - point to the buflist pointer
862 * sglbuf_dma - pointer to the (dma) sgl
863 * Returns: Null if failes
864 * pointer to the (virtual) sgl if successful.
867 kbuf_alloc_2_sgl(int bytes, u32 sgdir, int sge_offset, int *frags,
868 struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc)
870 MptSge_t *sglbuf = NULL; /* pointer to array of SGE */
871 /* and chain buffers */
872 struct buflist *buflist = NULL; /* kernel routine */
876 int alloc_sz = min(bytes,MAX_KMALLOC_SZ); // avoid kernel warning msg!
877 int bytes_allocd = 0;
879 dma_addr_t pa; // phys addr
881 int sg_spill = MAX_FRAGS_SPILL1;
887 /* Allocate and initialize an array of kernel
888 * structures for the SG elements.
890 i = MAX_SGL_BYTES / 8;
891 buflist = kmalloc(i, GFP_USER);
894 memset(buflist, 0, i);
897 /* Allocate a single block of memory to store the sg elements and
898 * the chain buffers. The calling routine is responsible for
899 * copying the data in this array into the correct place in the
900 * request and chain buffers.
902 sglbuf = pci_alloc_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf_dma);
906 if (sgdir & 0x04000000)
907 dir = PCI_DMA_TODEVICE;
909 dir = PCI_DMA_FROMDEVICE;
912 * sgl = sglbuf = point to beginning of sg buffer
913 * buflist_ent = 0 = first kernel structure
914 * sg_spill = number of SGE that can be written before the first
919 sg_spill = ((ioc->req_sz - sge_offset)/(sizeof(dma_addr_t) + sizeof(u32))) - 1;
920 while (bytes_allocd < bytes) {
921 this_alloc = min(alloc_sz, bytes-bytes_allocd);
922 buflist[buflist_ent].len = this_alloc;
923 buflist[buflist_ent].kptr = pci_alloc_consistent(ioc->pcidev,
926 if (buflist[buflist_ent].kptr == NULL) {
927 alloc_sz = alloc_sz / 2;
929 printk(KERN_WARNING MYNAM "-SG: No can do - "
930 "not enough memory! :-(\n");
931 printk(KERN_WARNING MYNAM "-SG: (freeing %d frags)\n",
939 bytes_allocd += this_alloc;
940 sgl->FlagsLength = (0x10000000|MPT_SGE_FLAGS_ADDRESSING|sgdir|this_alloc);
941 dma_addr = pci_map_single(ioc->pcidev, buflist[buflist_ent].kptr, this_alloc, dir);
942 sgl->Address = dma_addr;
950 if (bytes_allocd >= bytes)
954 if (fragcnt == sg_spill) {
955 printk(KERN_WARNING MYNAM "-SG: No can do - " "Chain required! :-(\n");
956 printk(KERN_WARNING MYNAM "(freeing %d frags)\n", numfrags);
960 /* overflow check... */
961 if (numfrags*8 > MAX_SGL_BYTES){
963 printk(KERN_WARNING MYNAM "-SG: No can do - "
964 "too many SG frags! :-(\n");
965 printk(KERN_WARNING MYNAM "-SG: (freeing %d frags)\n",
971 /* Last sge fixup: set LE+eol+eob bits */
972 sgl[-1].FlagsLength |= 0xC1000000;
977 dctlprintk((KERN_INFO MYNAM "-SG: kbuf_alloc_2_sgl() - "
978 "%d SG frags generated!\n",
981 dctlprintk((KERN_INFO MYNAM "-SG: kbuf_alloc_2_sgl() - "
982 "last (big) alloc_sz=%d\n",
988 if (sglbuf != NULL) {
991 for (i = 0; i < numfrags; i++) {
996 if ((sglbuf[i].FlagsLength >> 24) == 0x30)
999 dma_addr = sglbuf[i].Address;
1000 kptr = buflist[i].kptr;
1001 len = buflist[i].len;
1003 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1005 pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf, *sglbuf_dma);
1011 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1013 * Routine to free the SGL elements.
1016 kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma, struct buflist *buflist, MPT_ADAPTER *ioc)
1019 struct buflist *bl = buflist;
1024 if (sg->FlagsLength & 0x04000000)
1025 dir = PCI_DMA_TODEVICE;
1027 dir = PCI_DMA_FROMDEVICE;
1029 nib = (sg->FlagsLength & 0xF0000000) >> 28;
1030 while (! (nib & 0x4)) { /* eob */
1031 /* skip ignore/chain. */
1032 if (nib == 0 || nib == 3) {
1034 } else if (sg->Address) {
1035 dma_addr_t dma_addr;
1039 dma_addr = sg->Address;
1042 pci_unmap_single(ioc->pcidev, dma_addr, len, dir);
1043 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1048 nib = (le32_to_cpu(sg->FlagsLength) & 0xF0000000) >> 28;
1053 dma_addr_t dma_addr;
1057 dma_addr = sg->Address;
1060 pci_unmap_single(ioc->pcidev, dma_addr, len, dir);
1061 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1065 pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sgl, sgl_dma);
1067 dctlprintk((KERN_INFO MYNAM "-SG: Free'd 1 SGL buf + %d kbufs!\n", n));
1070 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1072 * mptctl_getiocinfo - Query the host adapter for IOC information.
1073 * @arg: User space argument
1076 * Return: 0 if successful
1077 * -EFAULT if data unavailable
1078 * -ENODEV if no such device/adapter
1081 mptctl_getiocinfo (unsigned long arg, unsigned int data_size)
1083 struct mpt_ioctl_iocinfo __user *uarg = (void __user *) arg;
1084 struct mpt_ioctl_iocinfo *karg;
1086 struct pci_dev *pdev;
1087 struct Scsi_Host *sh;
1091 unsigned int max_id;
1097 dctlprintk((": mptctl_getiocinfo called.\n"));
1098 /* Add of PCI INFO results in unaligned access for
1099 * IA64 and Sparc. Reset long to int. Return no PCI
1100 * data for obsolete format.
1102 if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev0))
1104 else if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev1))
1106 else if (data_size == sizeof(struct mpt_ioctl_iocinfo))
1108 else if (data_size == (sizeof(struct mpt_ioctl_iocinfo_rev0)+12))
1109 cim_rev = 0; /* obsolete */
1113 karg = kmalloc(data_size, GFP_KERNEL);
1115 printk(KERN_ERR "%s::mpt_ioctl_iocinfo() @%d - no memory available!\n",
1116 __FILE__, __LINE__);
1120 if (copy_from_user(karg, uarg, data_size)) {
1121 printk(KERN_ERR "%s@%d::mptctl_getiocinfo - "
1122 "Unable to read in mpt_ioctl_iocinfo struct @ %p\n",
1123 __FILE__, __LINE__, uarg);
1128 if (((iocnum = mpt_verify_adapter(karg->hdr.iocnum, &ioc)) < 0) ||
1130 dctlprintk((KERN_ERR "%s::mptctl_getiocinfo() @%d - ioc%d not found!\n",
1131 __FILE__, __LINE__, iocnum));
1136 /* Verify the data transfer size is correct. */
1137 if (karg->hdr.maxDataSize != data_size) {
1138 printk(KERN_ERR "%s@%d::mptctl_getiocinfo - "
1139 "Structure size mismatch. Command not completed.\n",
1140 __FILE__, __LINE__);
1145 /* Fill in the data and return the structure to the calling
1148 if (ioc->bus_type == SAS)
1149 karg->adapterType = MPT_IOCTL_INTERFACE_SAS;
1150 else if (ioc->bus_type == FC)
1151 karg->adapterType = MPT_IOCTL_INTERFACE_FC;
1153 karg->adapterType = MPT_IOCTL_INTERFACE_SCSI;
1155 if (karg->hdr.port > 1)
1157 port = karg->hdr.port;
1160 pdev = (struct pci_dev *) ioc->pcidev;
1162 karg->pciId = pdev->device;
1163 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1164 karg->hwRev = revision;
1165 karg->subSystemDevice = pdev->subsystem_device;
1166 karg->subSystemVendor = pdev->subsystem_vendor;
1169 /* Get the PCI bus, device, and function numbers for the IOC
1171 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1172 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1173 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1174 } else if (cim_rev == 2) {
1175 /* Get the PCI bus, device, function and segment ID numbers
1177 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1178 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1179 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1180 karg->pciInfo.segmentID = pci_domain_nr(pdev->bus);
1183 /* Get number of devices
1185 if ((sh = ioc->sh) != NULL) {
1186 /* sh->max_id = maximum target ID + 1
1188 max_id = sh->max_id - 1;
1189 hd = (MPT_SCSI_HOST *) sh->hostdata;
1191 /* Check all of the target structures and
1194 if (hd && hd->Targets) {
1195 for (ii = 0; ii <= max_id; ii++) {
1196 if (hd->Targets[ii])
1201 karg->numDevices = numDevices;
1203 /* Set the BIOS and FW Version
1205 karg->FWVersion = ioc->facts.FWVersion.Word;
1206 karg->BIOSVersion = ioc->biosVersion;
1208 /* Set the Version Strings.
1210 strncpy (karg->driverVersion, MPT_LINUX_PACKAGE_NAME, MPT_IOCTL_VERSION_LENGTH);
1211 karg->driverVersion[MPT_IOCTL_VERSION_LENGTH-1]='\0';
1213 karg->busChangeEvent = 0;
1214 karg->hostId = ioc->pfacts[port].PortSCSIID;
1215 karg->rsvd[0] = karg->rsvd[1] = 0;
1217 /* Copy the data from kernel memory to user memory
1219 if (copy_to_user((char __user *)arg, karg, data_size)) {
1220 printk(KERN_ERR "%s@%d::mptctl_getiocinfo - "
1221 "Unable to write out mpt_ioctl_iocinfo struct @ %p\n",
1222 __FILE__, __LINE__, uarg);
1231 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1233 * mptctl_gettargetinfo - Query the host adapter for target information.
1234 * @arg: User space argument
1237 * Return: 0 if successful
1238 * -EFAULT if data unavailable
1239 * -ENODEV if no such device/adapter
1242 mptctl_gettargetinfo (unsigned long arg)
1244 struct mpt_ioctl_targetinfo __user *uarg = (void __user *) arg;
1245 struct mpt_ioctl_targetinfo karg;
1247 struct Scsi_Host *sh;
1256 unsigned int max_id;
1257 int id, jj, indexed_lun, lun_index;
1261 u8 port, devType, bus_id;
1263 dctlprintk(("mptctl_gettargetinfo called.\n"));
1264 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_targetinfo))) {
1265 printk(KERN_ERR "%s@%d::mptctl_gettargetinfo - "
1266 "Unable to read in mpt_ioctl_targetinfo struct @ %p\n",
1267 __FILE__, __LINE__, uarg);
1271 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1273 dctlprintk((KERN_ERR "%s::mptctl_gettargetinfo() @%d - ioc%d not found!\n",
1274 __FILE__, __LINE__, iocnum));
1278 /* Get the port number and set the maximum number of bytes
1279 * in the returned structure.
1280 * Ignore the port setting.
1282 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1283 maxWordsLeft = numBytes/sizeof(int);
1284 port = karg.hdr.port;
1286 if (maxWordsLeft <= 0) {
1287 printk(KERN_ERR "%s::mptctl_gettargetinfo() @%d - no memory available!\n",
1288 __FILE__, __LINE__);
1292 /* Fill in the data and return the structure to the calling
1296 /* struct mpt_ioctl_targetinfo does not contain sufficient space
1297 * for the target structures so when the IOCTL is called, there is
1298 * not sufficient stack space for the structure. Allocate memory,
1299 * populate the memory, copy back to the user, then free memory.
1300 * targetInfo format:
1301 * bits 31-24: reserved
1306 pmem = kmalloc(numBytes, GFP_KERNEL);
1308 printk(KERN_ERR "%s::mptctl_gettargetinfo() @%d - no memory available!\n",
1309 __FILE__, __LINE__);
1312 memset(pmem, 0, numBytes);
1313 pdata = (int *) pmem;
1315 /* Get number of devices
1317 if ((sh = ioc->sh) != NULL) {
1319 max_id = sh->max_id - 1;
1320 hd = (MPT_SCSI_HOST *) sh->hostdata;
1322 /* Check all of the target structures.
1323 * Save the Id and increment the counter,
1325 * sh->max_id = maximum target ID + 1
1327 if (hd && hd->Targets) {
1328 mpt_findImVolumes(ioc);
1329 pIoc2 = ioc->raid_data.pIocPg2;
1330 for ( id = 0; id <= max_id; ) {
1331 if ( pIoc2 && pIoc2->NumActiveVolumes ) {
1332 if ( id == pIoc2->RaidVolume[0].VolumeID ) {
1333 if (maxWordsLeft <= 0) {
1334 printk(KERN_ERR "mptctl_gettargetinfo - "
1335 "buffer is full but volume is available on ioc %d\n, numDevices=%d", iocnum, numDevices);
1336 goto data_space_full;
1338 if ( ( pIoc2->RaidVolume[0].Flags & MPI_IOCPAGE2_FLAG_VOLUME_INACTIVE ) == 0 )
1342 bus_id = pIoc2->RaidVolume[0].VolumeBus;
1344 *pdata = ( (devType << 24) | (bus_id << 8) | id );
1345 dctlprintk((KERN_ERR "mptctl_gettargetinfo - "
1346 "volume ioc=%d target=%x numDevices=%d pdata=%p\n", iocnum, *pdata, numDevices, pdata));
1351 pIoc3 = ioc->raid_data.pIocPg3;
1352 for ( jj = 0; jj < pIoc3->NumPhysDisks; jj++ ) {
1353 if ( pIoc3->PhysDisk[jj].PhysDiskID == id )
1358 if ( (vdev = hd->Targets[id]) ) {
1359 for (jj = 0; jj <= MPT_LAST_LUN; jj++) {
1360 lun_index = (jj >> 5);
1361 indexed_lun = (jj % 32);
1362 lun = (1 << indexed_lun);
1363 if (vdev->luns[lun_index] & lun) {
1364 if (maxWordsLeft <= 0) {
1365 printk(KERN_ERR "mptctl_gettargetinfo - "
1366 "buffer is full but more targets are available on ioc %d numDevices=%d\n", iocnum, numDevices);
1367 goto data_space_full;
1369 bus_id = vdev->bus_id;
1371 *pdata = ( (jj << 16) | (bus_id << 8) | id );
1372 dctlprintk((KERN_ERR "mptctl_gettargetinfo - "
1373 "target ioc=%d target=%x numDevices=%d pdata=%p\n", iocnum, *pdata, numDevices, pdata));
1385 karg.numDevices = numDevices;
1387 /* Copy part of the data from kernel memory to user memory
1389 if (copy_to_user((char __user *)arg, &karg,
1390 sizeof(struct mpt_ioctl_targetinfo))) {
1391 printk(KERN_ERR "%s@%d::mptctl_gettargetinfo - "
1392 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1393 __FILE__, __LINE__, uarg);
1398 /* Copy the remaining data from kernel memory to user memory
1400 if (copy_to_user(uarg->targetInfo, pmem, numBytes)) {
1401 printk(KERN_ERR "%s@%d::mptctl_gettargetinfo - "
1402 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1403 __FILE__, __LINE__, pdata);
1413 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1414 /* MPT IOCTL Test function.
1417 * Return: 0 if successful
1418 * -EFAULT if data unavailable
1419 * -ENODEV if no such device/adapter
1422 mptctl_readtest (unsigned long arg)
1424 struct mpt_ioctl_test __user *uarg = (void __user *) arg;
1425 struct mpt_ioctl_test karg;
1429 dctlprintk(("mptctl_readtest called.\n"));
1430 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_test))) {
1431 printk(KERN_ERR "%s@%d::mptctl_readtest - "
1432 "Unable to read in mpt_ioctl_test struct @ %p\n",
1433 __FILE__, __LINE__, uarg);
1437 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1439 dctlprintk((KERN_ERR "%s::mptctl_readtest() @%d - ioc%d not found!\n",
1440 __FILE__, __LINE__, iocnum));
1444 /* Fill in the data and return the structure to the calling
1449 karg.chip_type = ioc->mfcnt;
1451 karg.chip_type = ioc->pcidev->device;
1453 strncpy (karg.name, ioc->name, MPT_MAX_NAME);
1454 karg.name[MPT_MAX_NAME-1]='\0';
1455 strncpy (karg.product, ioc->prod_name, MPT_PRODUCT_LENGTH);
1456 karg.product[MPT_PRODUCT_LENGTH-1]='\0';
1458 /* Copy the data from kernel memory to user memory
1460 if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_test))) {
1461 printk(KERN_ERR "%s@%d::mptctl_readtest - "
1462 "Unable to write out mpt_ioctl_test struct @ %p\n",
1463 __FILE__, __LINE__, uarg);
1470 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1472 * mptctl_eventquery - Query the host adapter for the event types
1473 * that are being logged.
1474 * @arg: User space argument
1477 * Return: 0 if successful
1478 * -EFAULT if data unavailable
1479 * -ENODEV if no such device/adapter
1482 mptctl_eventquery (unsigned long arg)
1484 struct mpt_ioctl_eventquery __user *uarg = (void __user *) arg;
1485 struct mpt_ioctl_eventquery karg;
1489 dctlprintk(("mptctl_eventquery called.\n"));
1490 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventquery))) {
1491 printk(KERN_ERR "%s@%d::mptctl_eventquery - "
1492 "Unable to read in mpt_ioctl_eventquery struct @ %p\n",
1493 __FILE__, __LINE__, uarg);
1497 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1499 dctlprintk((KERN_ERR "%s::mptctl_eventquery() @%d - ioc%d not found!\n",
1500 __FILE__, __LINE__, iocnum));
1504 karg.eventEntries = MPTCTL_EVENT_LOG_SIZE;
1505 karg.eventTypes = ioc->eventTypes;
1507 /* Copy the data from kernel memory to user memory
1509 if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_eventquery))) {
1510 printk(KERN_ERR "%s@%d::mptctl_eventquery - "
1511 "Unable to write out mpt_ioctl_eventquery struct @ %p\n",
1512 __FILE__, __LINE__, uarg);
1518 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1520 mptctl_eventenable (unsigned long arg)
1522 struct mpt_ioctl_eventenable __user *uarg = (void __user *) arg;
1523 struct mpt_ioctl_eventenable karg;
1527 dctlprintk(("mptctl_eventenable called.\n"));
1528 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventenable))) {
1529 printk(KERN_ERR "%s@%d::mptctl_eventenable - "
1530 "Unable to read in mpt_ioctl_eventenable struct @ %p\n",
1531 __FILE__, __LINE__, uarg);
1535 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1537 dctlprintk((KERN_ERR "%s::mptctl_eventenable() @%d - ioc%d not found!\n",
1538 __FILE__, __LINE__, iocnum));
1542 if (ioc->events == NULL) {
1543 /* Have not yet allocated memory - do so now.
1545 int sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
1546 ioc->events = kmalloc(sz, GFP_KERNEL);
1547 if (ioc->events == NULL) {
1548 printk(KERN_ERR MYNAM ": ERROR - Insufficient memory to add adapter!\n");
1551 memset(ioc->events, 0, sz);
1552 ioc->alloc_total += sz;
1554 ioc->eventContext = 0;
1557 /* Update the IOC event logging flag.
1559 ioc->eventTypes = karg.eventTypes;
1564 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1566 mptctl_eventreport (unsigned long arg)
1568 struct mpt_ioctl_eventreport __user *uarg = (void __user *) arg;
1569 struct mpt_ioctl_eventreport karg;
1572 int numBytes, maxEvents, max;
1574 dctlprintk(("mptctl_eventreport called.\n"));
1575 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventreport))) {
1576 printk(KERN_ERR "%s@%d::mptctl_eventreport - "
1577 "Unable to read in mpt_ioctl_eventreport struct @ %p\n",
1578 __FILE__, __LINE__, uarg);
1582 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1584 dctlprintk((KERN_ERR "%s::mptctl_eventreport() @%d - ioc%d not found!\n",
1585 __FILE__, __LINE__, iocnum));
1589 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1590 maxEvents = numBytes/sizeof(MPT_IOCTL_EVENTS);
1593 max = MPTCTL_EVENT_LOG_SIZE < maxEvents ? MPTCTL_EVENT_LOG_SIZE : maxEvents;
1595 /* If fewer than 1 event is requested, there must have
1596 * been some type of error.
1598 if ((max < 1) || !ioc->events)
1601 /* Copy the data from kernel memory to user memory
1603 numBytes = max * sizeof(MPT_IOCTL_EVENTS);
1604 if (copy_to_user(uarg->eventData, ioc->events, numBytes)) {
1605 printk(KERN_ERR "%s@%d::mptctl_eventreport - "
1606 "Unable to write out mpt_ioctl_eventreport struct @ %p\n",
1607 __FILE__, __LINE__, ioc->events);
1614 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1616 mptctl_replace_fw (unsigned long arg)
1618 struct mpt_ioctl_replace_fw __user *uarg = (void __user *) arg;
1619 struct mpt_ioctl_replace_fw karg;
1624 dctlprintk(("mptctl_replace_fw called.\n"));
1625 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_replace_fw))) {
1626 printk(KERN_ERR "%s@%d::mptctl_replace_fw - "
1627 "Unable to read in mpt_ioctl_replace_fw struct @ %p\n",
1628 __FILE__, __LINE__, uarg);
1632 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1634 dctlprintk((KERN_ERR "%s::mptctl_replace_fw() @%d - ioc%d not found!\n",
1635 __FILE__, __LINE__, iocnum));
1639 /* If caching FW, Free the old FW image
1641 if (ioc->cached_fw == NULL)
1644 mpt_free_fw_memory(ioc);
1646 /* Allocate memory for the new FW image
1648 newFwSize = karg.newImageSize;
1650 if (newFwSize & 0x01)
1652 if (newFwSize & 0x02)
1655 mpt_alloc_fw_memory(ioc, newFwSize);
1656 if (ioc->cached_fw == NULL)
1659 /* Copy the data from user memory to kernel space
1661 if (copy_from_user(ioc->cached_fw, uarg->newImage, newFwSize)) {
1662 printk(KERN_ERR "%s@%d::mptctl_replace_fw - "
1663 "Unable to read in mpt_ioctl_replace_fw image "
1664 "@ %p\n", __FILE__, __LINE__, uarg);
1665 mpt_free_fw_memory(ioc);
1669 /* Update IOCFactsReply
1671 ioc->facts.FWImageSize = newFwSize;
1675 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1676 /* MPT IOCTL MPTCOMMAND function.
1677 * Cast the arg into the mpt_ioctl_mpt_command structure.
1680 * Return: 0 if successful
1681 * -EBUSY if previous command timout and IOC reset is not complete.
1682 * -EFAULT if data unavailable
1683 * -ENODEV if no such device/adapter
1684 * -ETIME if timer expires
1685 * -ENOMEM if memory allocation error
1688 mptctl_mpt_command (unsigned long arg)
1690 struct mpt_ioctl_command __user *uarg = (void __user *) arg;
1691 struct mpt_ioctl_command karg;
1696 dctlprintk(("mptctl_command called.\n"));
1698 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_command))) {
1699 printk(KERN_ERR "%s@%d::mptctl_mpt_command - "
1700 "Unable to read in mpt_ioctl_command struct @ %p\n",
1701 __FILE__, __LINE__, uarg);
1705 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1707 dctlprintk((KERN_ERR "%s::mptctl_mpt_command() @%d - ioc%d not found!\n",
1708 __FILE__, __LINE__, iocnum));
1712 rc = mptctl_do_mpt_command (karg, &uarg->MF);
1717 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1718 /* Worker routine for the IOCTL MPTCOMMAND and MPTCOMMAND32 (sparc) commands.
1721 * Return: 0 if successful
1722 * -EBUSY if previous command timout and IOC reset is not complete.
1723 * -EFAULT if data unavailable
1724 * -ENODEV if no such device/adapter
1725 * -ETIME if timer expires
1726 * -ENOMEM if memory allocation error
1727 * -EPERM if SCSI I/O and target is untagged
1730 mptctl_do_mpt_command (struct mpt_ioctl_command karg, void __user *mfPtr)
1733 MPT_FRAME_HDR *mf = NULL;
1736 struct buflist bufIn; /* data In buffer */
1737 struct buflist bufOut; /* data Out buffer */
1738 dma_addr_t dma_addr_in;
1739 dma_addr_t dma_addr_out;
1740 int sgSize = 0; /* Num SG elements */
1741 int iocnum, flagsLength;
1747 dctlprintk(("mptctl_do_mpt_command called.\n"));
1748 bufIn.kptr = bufOut.kptr = NULL;
1750 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1752 dctlprintk((KERN_ERR "%s::mptctl_do_mpt_command() @%d - ioc%d not found!\n",
1753 __FILE__, __LINE__, iocnum));
1757 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1758 "No memory available during driver init.\n",
1759 __FILE__, __LINE__);
1761 } else if (ioc->ioctl->status & MPT_IOCTL_STATUS_DID_IOCRESET) {
1762 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1763 "Busy with IOC Reset \n", __FILE__, __LINE__);
1767 /* Verify that the final request frame will not be too large.
1769 sz = karg.dataSgeOffset * 4;
1770 if (karg.dataInSize > 0)
1771 sz += sizeof(dma_addr_t) + sizeof(u32);
1772 if (karg.dataOutSize > 0)
1773 sz += sizeof(dma_addr_t) + sizeof(u32);
1775 if (sz > ioc->req_sz) {
1776 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1777 "Request frame too large (%d) maximum (%d)\n",
1778 __FILE__, __LINE__, sz, ioc->req_sz);
1782 /* Get a free request frame and save the message context.
1784 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
1787 hdr = (MPIHeader_t *) mf;
1788 msgContext = le32_to_cpu(hdr->MsgContext);
1789 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1791 /* Copy the request frame
1792 * Reset the saved message context.
1793 * Request frame in user space
1795 if (copy_from_user(mf, mfPtr, karg.dataSgeOffset * 4)) {
1796 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1797 "Unable to read MF from mpt_ioctl_command struct @ %p\n",
1798 __FILE__, __LINE__, mfPtr);
1802 hdr->MsgContext = cpu_to_le32(msgContext);
1805 /* Verify that this request is allowed.
1807 switch (hdr->Function) {
1808 case MPI_FUNCTION_IOC_FACTS:
1809 case MPI_FUNCTION_PORT_FACTS:
1810 karg.dataOutSize = karg.dataInSize = 0;
1813 case MPI_FUNCTION_CONFIG:
1814 case MPI_FUNCTION_FC_COMMON_TRANSPORT_SEND:
1815 case MPI_FUNCTION_FC_EX_LINK_SRVC_SEND:
1816 case MPI_FUNCTION_FW_UPLOAD:
1817 case MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR:
1818 case MPI_FUNCTION_FW_DOWNLOAD:
1819 case MPI_FUNCTION_FC_PRIMITIVE_SEND:
1820 case MPI_FUNCTION_TOOLBOX:
1821 case MPI_FUNCTION_SAS_IO_UNIT_CONTROL:
1824 case MPI_FUNCTION_SCSI_IO_REQUEST:
1826 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
1827 VirtTarget *pTarget = NULL;
1828 MPT_SCSI_HOST *hd = NULL;
1829 int qtag = MPI_SCSIIO_CONTROL_UNTAGGED;
1831 int target = (int) pScsiReq->TargetID;
1834 if ((target < 0) || (target >= ioc->sh->max_id)) {
1835 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1836 "Target ID out of bounds. \n",
1837 __FILE__, __LINE__);
1842 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
1843 pScsiReq->MsgFlags |= mpt_msg_flags();
1846 /* verify that app has not requested
1847 * more sense data than driver
1848 * can provide, if so, reset this parameter
1849 * set the sense buffer pointer low address
1850 * update the control field to specify Q type
1852 if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1853 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1855 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1857 pScsiReq->SenseBufferLowAddr =
1858 cpu_to_le32(ioc->sense_buf_low_dma
1859 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
1861 if ((hd = (MPT_SCSI_HOST *) ioc->sh->hostdata)) {
1863 pTarget = hd->Targets[target];
1866 if (pTarget &&(pTarget->tflags & MPT_TARGET_FLAGS_Q_YES))
1867 qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
1869 /* Have the IOCTL driver set the direction based
1870 * on the dataOutSize (ordering issue with Sparc).
1872 if (karg.dataOutSize > 0) {
1873 scsidir = MPI_SCSIIO_CONTROL_WRITE;
1874 dataSize = karg.dataOutSize;
1876 scsidir = MPI_SCSIIO_CONTROL_READ;
1877 dataSize = karg.dataInSize;
1880 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
1881 pScsiReq->DataLength = cpu_to_le32(dataSize);
1883 ioc->ioctl->reset = MPTCTL_RESET_OK;
1884 ioc->ioctl->target = target;
1887 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1888 "SCSI driver is not loaded. \n",
1889 __FILE__, __LINE__);
1895 case MPI_FUNCTION_SMP_PASSTHROUGH:
1896 /* Check mf->PassthruFlags to determine if
1897 * transfer is ImmediateMode or not.
1898 * Immediate mode returns data in the ReplyFrame.
1899 * Else, we are sending request and response data
1900 * in two SGLs at the end of the mf.
1904 case MPI_FUNCTION_SATA_PASSTHROUGH:
1906 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1907 "SCSI driver is not loaded. \n",
1908 __FILE__, __LINE__);
1914 case MPI_FUNCTION_RAID_ACTION:
1919 case MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
1921 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
1922 int qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
1923 int scsidir = MPI_SCSIIO_CONTROL_READ;
1926 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
1927 pScsiReq->MsgFlags |= mpt_msg_flags();
1930 /* verify that app has not requested
1931 * more sense data than driver
1932 * can provide, if so, reset this parameter
1933 * set the sense buffer pointer low address
1934 * update the control field to specify Q type
1936 if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1937 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1939 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1941 pScsiReq->SenseBufferLowAddr =
1942 cpu_to_le32(ioc->sense_buf_low_dma
1943 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
1945 /* All commands to physical devices are tagged
1948 /* Have the IOCTL driver set the direction based
1949 * on the dataOutSize (ordering issue with Sparc).
1951 if (karg.dataOutSize > 0) {
1952 scsidir = MPI_SCSIIO_CONTROL_WRITE;
1953 dataSize = karg.dataOutSize;
1955 scsidir = MPI_SCSIIO_CONTROL_READ;
1956 dataSize = karg.dataInSize;
1959 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
1960 pScsiReq->DataLength = cpu_to_le32(dataSize);
1962 ioc->ioctl->reset = MPTCTL_RESET_OK;
1963 ioc->ioctl->target = pScsiReq->TargetID;
1965 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1966 "SCSI driver is not loaded. \n",
1967 __FILE__, __LINE__);
1973 case MPI_FUNCTION_SCSI_TASK_MGMT:
1975 MPT_SCSI_HOST *hd = NULL;
1976 if ((ioc->sh == NULL) || ((hd = (MPT_SCSI_HOST *)ioc->sh->hostdata) == NULL)) {
1977 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1978 "SCSI driver not loaded or SCSI host not found. \n",
1979 __FILE__, __LINE__);
1982 } else if (mptctl_set_tm_flags(hd) != 0) {
1989 case MPI_FUNCTION_IOC_INIT:
1991 IOCInit_t *pInit = (IOCInit_t *) mf;
1992 u32 high_addr, sense_high;
1994 /* Verify that all entries in the IOC INIT match
1995 * existing setup (and in LE format).
1997 if (sizeof(dma_addr_t) == sizeof(u64)) {
1998 high_addr = cpu_to_le32((u32)((u64)ioc->req_frames_dma >> 32));
1999 sense_high= cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
2005 if ((pInit->Flags != 0) || (pInit->MaxDevices != ioc->facts.MaxDevices) ||
2006 (pInit->MaxBuses != ioc->facts.MaxBuses) ||
2007 (pInit->ReplyFrameSize != cpu_to_le16(ioc->reply_sz)) ||
2008 (pInit->HostMfaHighAddr != high_addr) ||
2009 (pInit->SenseBufferHighAddr != sense_high)) {
2010 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2011 "IOC_INIT issued with 1 or more incorrect parameters. Rejected.\n",
2012 __FILE__, __LINE__);
2020 * MPI_FUNCTION_PORT_ENABLE
2021 * MPI_FUNCTION_TARGET_CMD_BUFFER_POST
2022 * MPI_FUNCTION_TARGET_ASSIST
2023 * MPI_FUNCTION_TARGET_STATUS_SEND
2024 * MPI_FUNCTION_TARGET_MODE_ABORT
2025 * MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET
2026 * MPI_FUNCTION_IO_UNIT_RESET
2027 * MPI_FUNCTION_HANDSHAKE
2028 * MPI_FUNCTION_REPLY_FRAME_REMOVAL
2029 * MPI_FUNCTION_EVENT_NOTIFICATION
2030 * (driver handles event notification)
2031 * MPI_FUNCTION_EVENT_ACK
2034 /* What to do with these??? CHECK ME!!!
2035 MPI_FUNCTION_FC_LINK_SRVC_BUF_POST
2036 MPI_FUNCTION_FC_LINK_SRVC_RSP
2037 MPI_FUNCTION_FC_ABORT
2038 MPI_FUNCTION_LAN_SEND
2039 MPI_FUNCTION_LAN_RECEIVE
2040 MPI_FUNCTION_LAN_RESET
2043 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2044 "Illegal request (function 0x%x) \n",
2045 __FILE__, __LINE__, hdr->Function);
2050 /* Add the SGL ( at most one data in SGE and one data out SGE )
2051 * In the case of two SGE's - the data out (write) will always
2052 * preceede the data in (read) SGE. psgList is used to free the
2055 psge = (char *) (((int *) mf) + karg.dataSgeOffset);
2058 /* bufIn and bufOut are used for user to kernel space transfers
2060 bufIn.kptr = bufOut.kptr = NULL;
2061 bufIn.len = bufOut.len = 0;
2063 if (karg.dataOutSize > 0)
2066 if (karg.dataInSize > 0)
2071 /* Set up the dataOut memory allocation */
2072 if (karg.dataOutSize > 0) {
2073 if (karg.dataInSize > 0) {
2074 flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2075 MPI_SGE_FLAGS_END_OF_BUFFER |
2076 MPI_SGE_FLAGS_DIRECTION |
2078 << MPI_SGE_FLAGS_SHIFT;
2080 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
2082 flagsLength |= karg.dataOutSize;
2083 bufOut.len = karg.dataOutSize;
2084 bufOut.kptr = pci_alloc_consistent(
2085 ioc->pcidev, bufOut.len, &dma_addr_out);
2087 if (bufOut.kptr == NULL) {
2092 * Copy to MF and to sglbuf
2094 mpt_add_sge(psge, flagsLength, dma_addr_out);
2095 psge += (sizeof(u32) + sizeof(dma_addr_t));
2097 /* Copy user data to kernel space.
2099 if (copy_from_user(bufOut.kptr,
2103 "%s@%d::mptctl_do_mpt_command - Unable "
2104 "to read user data "
2106 __FILE__, __LINE__,karg.dataOutBufPtr);
2113 if (karg.dataInSize > 0) {
2114 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
2115 flagsLength |= karg.dataInSize;
2117 bufIn.len = karg.dataInSize;
2118 bufIn.kptr = pci_alloc_consistent(ioc->pcidev,
2119 bufIn.len, &dma_addr_in);
2121 if (bufIn.kptr == NULL) {
2126 * Copy to MF and to sglbuf
2128 mpt_add_sge(psge, flagsLength, dma_addr_in);
2134 mpt_add_sge(psge, flagsLength, (dma_addr_t) -1);
2137 ioc->ioctl->wait_done = 0;
2138 if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT) {
2140 DBG_DUMP_TM_REQUEST_FRAME((u32 *)mf);
2142 if (mpt_send_handshake_request(mptctl_id, ioc,
2143 sizeof(SCSITaskMgmt_t), (u32*)mf,
2145 dfailprintk((MYIOC_s_ERR_FMT "_send_handshake FAILED!"
2146 " (ioc %p, mf %p) \n", ioc->name,
2148 mptctl_free_tm_flags(ioc);
2154 mpt_put_msg_frame(mptctl_id, ioc, mf);
2156 /* Now wait for the command to complete */
2157 timeout = (karg.timeout > 0) ? karg.timeout : MPT_IOCTL_DEFAULT_TIMEOUT;
2158 timeout = wait_event_timeout(mptctl_wait,
2159 ioc->ioctl->wait_done == 1,
2162 if(timeout <=0 && (ioc->ioctl->wait_done != 1 )) {
2163 /* Now we need to reset the board */
2165 if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT)
2166 mptctl_free_tm_flags(ioc);
2168 mptctl_timeout_expired(ioc->ioctl);
2175 /* If a valid reply frame, copy to the user.
2176 * Offset 2: reply length in U32's
2178 if (ioc->ioctl->status & MPT_IOCTL_STATUS_RF_VALID) {
2179 if (karg.maxReplyBytes < ioc->reply_sz) {
2180 sz = min(karg.maxReplyBytes, 4*ioc->ioctl->ReplyFrame[2]);
2182 sz = min(ioc->reply_sz, 4*ioc->ioctl->ReplyFrame[2]);
2186 if (copy_to_user(karg.replyFrameBufPtr,
2187 &ioc->ioctl->ReplyFrame, sz)){
2189 "%s@%d::mptctl_do_mpt_command - "
2190 "Unable to write out reply frame %p\n",
2191 __FILE__, __LINE__, karg.replyFrameBufPtr);
2198 /* If valid sense data, copy to user.
2200 if (ioc->ioctl->status & MPT_IOCTL_STATUS_SENSE_VALID) {
2201 sz = min(karg.maxSenseBytes, MPT_SENSE_BUFFER_SIZE);
2203 if (copy_to_user(karg.senseDataPtr, ioc->ioctl->sense, sz)) {
2204 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2205 "Unable to write sense data to user %p\n",
2214 /* If the overall status is _GOOD and data in, copy data
2217 if ((ioc->ioctl->status & MPT_IOCTL_STATUS_COMMAND_GOOD) &&
2218 (karg.dataInSize > 0) && (bufIn.kptr)) {
2220 if (copy_to_user(karg.dataInBufPtr,
2221 bufIn.kptr, karg.dataInSize)) {
2222 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2223 "Unable to write data to user %p\n",
2232 ioc->ioctl->status &= ~(MPT_IOCTL_STATUS_COMMAND_GOOD |
2233 MPT_IOCTL_STATUS_SENSE_VALID |
2234 MPT_IOCTL_STATUS_RF_VALID );
2236 /* Free the allocated memory.
2238 if (bufOut.kptr != NULL) {
2239 pci_free_consistent(ioc->pcidev,
2240 bufOut.len, (void *) bufOut.kptr, dma_addr_out);
2243 if (bufIn.kptr != NULL) {
2244 pci_free_consistent(ioc->pcidev,
2245 bufIn.len, (void *) bufIn.kptr, dma_addr_in);
2248 /* mf is null if command issued successfully
2249 * otherwise, failure occured after mf acquired.
2252 mpt_free_msg_frame(ioc, mf);
2257 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2258 /* Prototype Routine for the HP HOST INFO command.
2261 * Return: 0 if successful
2262 * -EFAULT if data unavailable
2263 * -EBUSY if previous command timout and IOC reset is not complete.
2264 * -ENODEV if no such device/adapter
2265 * -ETIME if timer expires
2266 * -ENOMEM if memory allocation error
2269 mptctl_hp_hostinfo(unsigned long arg, unsigned int data_size)
2271 hp_host_info_t __user *uarg = (void __user *) arg;
2273 struct pci_dev *pdev;
2276 hp_host_info_t karg;
2278 ConfigPageHeader_t hdr;
2281 ToolboxIstwiReadWriteRequest_t *IstwiRWRequest;
2282 MPT_FRAME_HDR *mf = NULL;
2283 MPIHeader_t *mpi_hdr;
2285 dctlprintk((": mptctl_hp_hostinfo called.\n"));
2286 /* Reset long to int. Should affect IA64 and SPARC only
2288 if (data_size == sizeof(hp_host_info_t))
2290 else if (data_size == sizeof(hp_host_info_rev0_t))
2291 cim_rev = 0; /* obsolete */
2295 if (copy_from_user(&karg, uarg, sizeof(hp_host_info_t))) {
2296 printk(KERN_ERR "%s@%d::mptctl_hp_host_info - "
2297 "Unable to read in hp_host_info struct @ %p\n",
2298 __FILE__, __LINE__, uarg);
2302 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2304 dctlprintk((KERN_ERR "%s::mptctl_hp_hostinfo() @%d - ioc%d not found!\n",
2305 __FILE__, __LINE__, iocnum));
2309 /* Fill in the data and return the structure to the calling
2312 pdev = (struct pci_dev *) ioc->pcidev;
2314 karg.vendor = pdev->vendor;
2315 karg.device = pdev->device;
2316 karg.subsystem_id = pdev->subsystem_device;
2317 karg.subsystem_vendor = pdev->subsystem_vendor;
2318 karg.devfn = pdev->devfn;
2319 karg.bus = pdev->bus->number;
2321 /* Save the SCSI host no. if
2322 * SCSI driver loaded
2324 if (ioc->sh != NULL)
2325 karg.host_no = ioc->sh->host_no;
2329 /* Reformat the fw_version into a string
2331 karg.fw_version[0] = ioc->facts.FWVersion.Struct.Major >= 10 ?
2332 ((ioc->facts.FWVersion.Struct.Major / 10) + '0') : '0';
2333 karg.fw_version[1] = (ioc->facts.FWVersion.Struct.Major % 10 ) + '0';
2334 karg.fw_version[2] = '.';
2335 karg.fw_version[3] = ioc->facts.FWVersion.Struct.Minor >= 10 ?
2336 ((ioc->facts.FWVersion.Struct.Minor / 10) + '0') : '0';
2337 karg.fw_version[4] = (ioc->facts.FWVersion.Struct.Minor % 10 ) + '0';
2338 karg.fw_version[5] = '.';
2339 karg.fw_version[6] = ioc->facts.FWVersion.Struct.Unit >= 10 ?
2340 ((ioc->facts.FWVersion.Struct.Unit / 10) + '0') : '0';
2341 karg.fw_version[7] = (ioc->facts.FWVersion.Struct.Unit % 10 ) + '0';
2342 karg.fw_version[8] = '.';
2343 karg.fw_version[9] = ioc->facts.FWVersion.Struct.Dev >= 10 ?
2344 ((ioc->facts.FWVersion.Struct.Dev / 10) + '0') : '0';
2345 karg.fw_version[10] = (ioc->facts.FWVersion.Struct.Dev % 10 ) + '0';
2346 karg.fw_version[11] = '\0';
2348 /* Issue a config request to get the device serial number
2350 hdr.PageVersion = 0;
2353 hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
2354 cfg.cfghdr.hdr = &hdr;
2357 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2358 cfg.dir = 0; /* read */
2361 strncpy(karg.serial_number, " ", 24);
2362 if (mpt_config(ioc, &cfg) == 0) {
2363 if (cfg.cfghdr.hdr->PageLength > 0) {
2364 /* Issue the second config page request */
2365 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2367 pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
2369 cfg.physAddr = buf_dma;
2370 if (mpt_config(ioc, &cfg) == 0) {
2371 ManufacturingPage0_t *pdata = (ManufacturingPage0_t *) pbuf;
2372 if (strlen(pdata->BoardTracerNumber) > 1) {
2373 strncpy(karg.serial_number, pdata->BoardTracerNumber, 24);
2374 karg.serial_number[24-1]='\0';
2377 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
2382 rc = mpt_GetIocState(ioc, 1);
2384 case MPI_IOC_STATE_OPERATIONAL:
2385 karg.ioc_status = HP_STATUS_OK;
2388 case MPI_IOC_STATE_FAULT:
2389 karg.ioc_status = HP_STATUS_FAILED;
2392 case MPI_IOC_STATE_RESET:
2393 case MPI_IOC_STATE_READY:
2395 karg.ioc_status = HP_STATUS_OTHER;
2399 karg.base_io_addr = pci_resource_start(pdev, 0);
2401 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
2402 karg.bus_phys_width = HP_BUS_WIDTH_UNK;
2404 karg.bus_phys_width = HP_BUS_WIDTH_16;
2406 karg.hard_resets = 0;
2407 karg.soft_resets = 0;
2409 if (ioc->sh != NULL) {
2410 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)ioc->sh->hostdata;
2412 if (hd && (cim_rev == 1)) {
2413 karg.hard_resets = hd->hard_resets;
2414 karg.soft_resets = hd->soft_resets;
2415 karg.timeouts = hd->timeouts;
2420 * Gather ISTWI(Industry Standard Two Wire Interface) Data
2422 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
2423 dfailprintk((MYIOC_s_WARN_FMT "%s, no msg frames!!\n",
2424 ioc->name,__FUNCTION__));
2428 IstwiRWRequest = (ToolboxIstwiReadWriteRequest_t *)mf;
2429 mpi_hdr = (MPIHeader_t *) mf;
2430 memset(IstwiRWRequest,0,sizeof(ToolboxIstwiReadWriteRequest_t));
2431 IstwiRWRequest->Function = MPI_FUNCTION_TOOLBOX;
2432 IstwiRWRequest->Tool = MPI_TOOLBOX_ISTWI_READ_WRITE_TOOL;
2433 IstwiRWRequest->MsgContext = mpi_hdr->MsgContext;
2434 IstwiRWRequest->Flags = MPI_TB_ISTWI_FLAGS_READ;
2435 IstwiRWRequest->NumAddressBytes = 0x01;
2436 IstwiRWRequest->DataLength = cpu_to_le16(0x04);
2437 if (pdev->devfn & 1)
2438 IstwiRWRequest->DeviceAddr = 0xB2;
2440 IstwiRWRequest->DeviceAddr = 0xB0;
2442 pbuf = pci_alloc_consistent(ioc->pcidev, 4, &buf_dma);
2445 mpt_add_sge((char *)&IstwiRWRequest->SGL,
2446 (MPT_SGE_FLAGS_SSIMPLE_READ|4), buf_dma);
2448 ioc->ioctl->wait_done = 0;
2449 mpt_put_msg_frame(mptctl_id, ioc, mf);
2451 rc = wait_event_timeout(mptctl_wait,
2452 ioc->ioctl->wait_done == 1,
2453 HZ*MPT_IOCTL_DEFAULT_TIMEOUT /* 10 sec */);
2455 if(rc <=0 && (ioc->ioctl->wait_done != 1 )) {
2457 * Now we need to reset the board
2459 mpt_free_msg_frame(ioc, mf);
2460 mptctl_timeout_expired(ioc->ioctl);
2465 *ISTWI Data Definition
2466 * pbuf[0] = FW_VERSION = 0x4
2467 * pbuf[1] = Bay Count = 6 or 4 or 2, depending on
2468 * the config, you should be seeing one out of these three values
2469 * pbuf[2] = Drive Installed Map = bit pattern depend on which
2470 * bays have drives in them
2471 * pbuf[3] = Checksum (0x100 = (byte0 + byte2 + byte3)
2473 if (ioc->ioctl->status & MPT_IOCTL_STATUS_RF_VALID)
2474 karg.rsvd = *(u32 *)pbuf;
2478 pci_free_consistent(ioc->pcidev, 4, pbuf, buf_dma);
2480 /* Copy the data from kernel memory to user memory
2482 if (copy_to_user((char __user *)arg, &karg, sizeof(hp_host_info_t))) {
2483 printk(KERN_ERR "%s@%d::mptctl_hpgethostinfo - "
2484 "Unable to write out hp_host_info @ %p\n",
2485 __FILE__, __LINE__, uarg);
2493 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2494 /* Prototype Routine for the HP TARGET INFO command.
2497 * Return: 0 if successful
2498 * -EFAULT if data unavailable
2499 * -EBUSY if previous command timout and IOC reset is not complete.
2500 * -ENODEV if no such device/adapter
2501 * -ETIME if timer expires
2502 * -ENOMEM if memory allocation error
2505 mptctl_hp_targetinfo(unsigned long arg)
2507 hp_target_info_t __user *uarg = (void __user *) arg;
2508 SCSIDevicePage0_t *pg0_alloc;
2509 SCSIDevicePage3_t *pg3_alloc;
2511 MPT_SCSI_HOST *hd = NULL;
2512 hp_target_info_t karg;
2515 dma_addr_t page_dma;
2517 ConfigPageHeader_t hdr;
2518 int tmp, np, rc = 0;
2520 dctlprintk((": mptctl_hp_targetinfo called.\n"));
2521 if (copy_from_user(&karg, uarg, sizeof(hp_target_info_t))) {
2522 printk(KERN_ERR "%s@%d::mptctl_hp_targetinfo - "
2523 "Unable to read in hp_host_targetinfo struct @ %p\n",
2524 __FILE__, __LINE__, uarg);
2528 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2530 dctlprintk((KERN_ERR "%s::mptctl_hp_targetinfo() @%d - ioc%d not found!\n",
2531 __FILE__, __LINE__, iocnum));
2535 /* There is nothing to do for FCP parts.
2537 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
2540 if ((ioc->spi_data.sdp0length == 0) || (ioc->sh == NULL))
2543 if (ioc->sh->host_no != karg.hdr.host)
2546 /* Get the data transfer speeds
2548 data_sz = ioc->spi_data.sdp0length * 4;
2549 pg0_alloc = (SCSIDevicePage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
2551 hdr.PageVersion = ioc->spi_data.sdp0version;
2552 hdr.PageLength = data_sz;
2554 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2556 cfg.cfghdr.hdr = &hdr;
2557 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2560 cfg.physAddr = page_dma;
2562 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2564 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2565 np = le32_to_cpu(pg0_alloc->NegotiatedParameters);
2566 karg.negotiated_width = np & MPI_SCSIDEVPAGE0_NP_WIDE ?
2567 HP_BUS_WIDTH_16 : HP_BUS_WIDTH_8;
2569 if (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) {
2570 tmp = (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> 8;
2572 karg.negotiated_speed = HP_DEV_SPEED_ULTRA320;
2573 else if (tmp <= 0x09)
2574 karg.negotiated_speed = HP_DEV_SPEED_ULTRA160;
2575 else if (tmp <= 0x0A)
2576 karg.negotiated_speed = HP_DEV_SPEED_ULTRA2;
2577 else if (tmp <= 0x0C)
2578 karg.negotiated_speed = HP_DEV_SPEED_ULTRA;
2579 else if (tmp <= 0x25)
2580 karg.negotiated_speed = HP_DEV_SPEED_FAST;
2582 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2584 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2587 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg0_alloc, page_dma);
2592 karg.message_rejects = -1;
2593 karg.phase_errors = -1;
2594 karg.parity_errors = -1;
2595 karg.select_timeouts = -1;
2597 /* Get the target error parameters
2599 hdr.PageVersion = 0;
2602 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2604 cfg.cfghdr.hdr = &hdr;
2605 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2609 if ((mpt_config(ioc, &cfg) == 0) && (cfg.cfghdr.hdr->PageLength > 0)) {
2610 /* Issue the second config page request */
2611 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2612 data_sz = (int) cfg.cfghdr.hdr->PageLength * 4;
2613 pg3_alloc = (SCSIDevicePage3_t *) pci_alloc_consistent(
2614 ioc->pcidev, data_sz, &page_dma);
2616 cfg.physAddr = page_dma;
2617 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2618 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2619 karg.message_rejects = (u32) le16_to_cpu(pg3_alloc->MsgRejectCount);
2620 karg.phase_errors = (u32) le16_to_cpu(pg3_alloc->PhaseErrorCount);
2621 karg.parity_errors = (u32) le16_to_cpu(pg3_alloc->ParityErrorCount);
2623 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg3_alloc, page_dma);
2626 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
2628 karg.select_timeouts = hd->sel_timeout[karg.hdr.id];
2630 /* Copy the data from kernel memory to user memory
2632 if (copy_to_user((char __user *)arg, &karg, sizeof(hp_target_info_t))) {
2633 printk(KERN_ERR "%s@%d::mptctl_hp_target_info - "
2634 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
2635 __FILE__, __LINE__, uarg);
2642 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2644 static struct file_operations mptctl_fops = {
2645 .owner = THIS_MODULE,
2646 .llseek = no_llseek,
2647 .unlocked_ioctl = mptctl_ioctl,
2648 #ifdef CONFIG_COMPAT
2649 .compat_ioctl = compat_mpctl_ioctl,
2653 static struct miscdevice mptctl_miscdev = {
2659 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2661 #ifdef CONFIG_COMPAT
2664 compat_mptfwxfer_ioctl(struct file *filp, unsigned int cmd,
2667 struct mpt_fw_xfer32 kfw32;
2668 struct mpt_fw_xfer kfw;
2669 MPT_ADAPTER *iocp = NULL;
2670 int iocnum, iocnumX;
2671 int nonblock = (filp->f_flags & O_NONBLOCK);
2674 dctlprintk((KERN_INFO MYNAM "::compat_mptfwxfer_ioctl() called\n"));
2676 if (copy_from_user(&kfw32, (char __user *)arg, sizeof(kfw32)))
2679 /* Verify intended MPT adapter */
2680 iocnumX = kfw32.iocnum & 0xFF;
2681 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2683 dctlprintk((KERN_ERR MYNAM "::compat_mptfwxfer_ioctl @%d - ioc%d not found!\n",
2684 __LINE__, iocnumX));
2688 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2691 kfw.iocnum = iocnum;
2692 kfw.fwlen = kfw32.fwlen;
2693 kfw.bufp = compat_ptr(kfw32.bufp);
2695 ret = mptctl_do_fw_download(kfw.iocnum, kfw.bufp, kfw.fwlen);
2697 mutex_unlock(&iocp->ioctl->ioctl_mutex);
2703 compat_mpt_command(struct file *filp, unsigned int cmd,
2706 struct mpt_ioctl_command32 karg32;
2707 struct mpt_ioctl_command32 __user *uarg = (struct mpt_ioctl_command32 __user *) arg;
2708 struct mpt_ioctl_command karg;
2709 MPT_ADAPTER *iocp = NULL;
2710 int iocnum, iocnumX;
2711 int nonblock = (filp->f_flags & O_NONBLOCK);
2714 dctlprintk((KERN_INFO MYNAM "::compat_mpt_command() called\n"));
2716 if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32)))
2719 /* Verify intended MPT adapter */
2720 iocnumX = karg32.hdr.iocnum & 0xFF;
2721 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2723 dctlprintk((KERN_ERR MYNAM "::compat_mpt_command @%d - ioc%d not found!\n",
2724 __LINE__, iocnumX));
2728 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2731 /* Copy data to karg */
2732 karg.hdr.iocnum = karg32.hdr.iocnum;
2733 karg.hdr.port = karg32.hdr.port;
2734 karg.timeout = karg32.timeout;
2735 karg.maxReplyBytes = karg32.maxReplyBytes;
2737 karg.dataInSize = karg32.dataInSize;
2738 karg.dataOutSize = karg32.dataOutSize;
2739 karg.maxSenseBytes = karg32.maxSenseBytes;
2740 karg.dataSgeOffset = karg32.dataSgeOffset;
2742 karg.replyFrameBufPtr = (char __user *)(unsigned long)karg32.replyFrameBufPtr;
2743 karg.dataInBufPtr = (char __user *)(unsigned long)karg32.dataInBufPtr;
2744 karg.dataOutBufPtr = (char __user *)(unsigned long)karg32.dataOutBufPtr;
2745 karg.senseDataPtr = (char __user *)(unsigned long)karg32.senseDataPtr;
2747 /* Pass new structure to do_mpt_command
2749 ret = mptctl_do_mpt_command (karg, &uarg->MF);
2751 mutex_unlock(&iocp->ioctl->ioctl_mutex);
2756 static long compat_mpctl_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
2766 case MPTEVENTENABLE:
2767 case MPTEVENTREPORT:
2769 case HP_GETHOSTINFO:
2770 case HP_GETTARGETINFO:
2772 ret = __mptctl_ioctl(f, cmd, arg);
2775 ret = compat_mpt_command(f, cmd, arg);
2777 case MPTFWDOWNLOAD32:
2778 ret = compat_mptfwxfer_ioctl(f, cmd, arg);
2791 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2793 * mptctl_probe - Installs ioctl devices per bus.
2794 * @pdev: Pointer to pci_dev structure
2796 * Returns 0 for success, non-zero for failure.
2801 mptctl_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2806 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
2809 * Allocate and inite a MPT_IOCTL structure
2811 sz = sizeof (MPT_IOCTL);
2812 mem = kmalloc(sz, GFP_KERNEL);
2819 ioc->ioctl = (MPT_IOCTL *) mem;
2820 ioc->ioctl->ioc = ioc;
2821 mutex_init(&ioc->ioctl->ioctl_mutex);
2826 mptctl_remove(pdev);
2830 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2832 * mptctl_remove - Removed ioctl devices
2833 * @pdev: Pointer to pci_dev structure
2838 mptctl_remove(struct pci_dev *pdev)
2840 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
2842 kfree ( ioc->ioctl );
2845 static struct mpt_pci_driver mptctl_driver = {
2846 .probe = mptctl_probe,
2847 .remove = mptctl_remove,
2850 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2851 static int __init mptctl_init(void)
2856 show_mptmod_ver(my_NAME, my_VERSION);
2858 if(mpt_device_driver_register(&mptctl_driver,
2859 MPTCTL_DRIVER) != 0 ) {
2860 dprintk((KERN_INFO MYNAM
2861 ": failed to register dd callbacks\n"));
2864 /* Register this device */
2865 err = misc_register(&mptctl_miscdev);
2867 printk(KERN_ERR MYNAM ": Can't register misc device [minor=%d].\n", MPT_MINOR);
2870 printk(KERN_INFO MYNAM ": Registered with Fusion MPT base driver\n");
2871 printk(KERN_INFO MYNAM ": /dev/%s @ (major,minor=%d,%d)\n",
2872 mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
2875 * Install our handler
2878 if ((mptctl_id = mpt_register(mptctl_reply, MPTCTL_DRIVER)) < 0) {
2879 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
2880 misc_deregister(&mptctl_miscdev);
2885 if (mpt_reset_register(mptctl_id, mptctl_ioc_reset) == 0) {
2886 dprintk((KERN_INFO MYNAM ": Registered for IOC reset notifications\n"));
2895 mpt_device_driver_deregister(MPTCTL_DRIVER);
2900 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2901 static void mptctl_exit(void)
2903 misc_deregister(&mptctl_miscdev);
2904 printk(KERN_INFO MYNAM ": Deregistered /dev/%s @ (major,minor=%d,%d)\n",
2905 mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
2907 /* De-register reset handler from base module */
2908 mpt_reset_deregister(mptctl_id);
2909 dprintk((KERN_INFO MYNAM ": Deregistered for IOC reset notifications\n"));
2911 /* De-register callback handler from base module */
2912 mpt_deregister(mptctl_id);
2913 printk(KERN_INFO MYNAM ": Deregistered from Fusion MPT base driver\n");
2915 mpt_device_driver_deregister(MPTCTL_DRIVER);
2919 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2921 module_init(mptctl_init);
2922 module_exit(mptctl_exit);