projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] fusion - mptctl -firmware download fix
[deliverable/linux.git] / drivers / message / fusion / mptctl.c
CommitLineData
1da177e4
LT		 1/*
2 * linux/drivers/message/fusion/mptctl.c
b6fe4ddc
MED		 3 * mpt Ioctl driver.
4 * For use with LSI Logic PCI chip/adapters
1da177e4
LT		 5 * running LSI Logic Fusion MPT (Message Passing Technology) firmware.
6 *
b6fe4ddc 7 * Copyright (c) 1999-2005 LSI Logic Corporation
1da177e4
LT		 8 * (mailto:mpt_linux_developer@lsil.com)
9 *
1da177e4
LT		 10 */
11/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
12/*
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.
16
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.
21
22 NO WARRANTY
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.
32
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
41
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
45*/
46/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
47
1da177e4
LT		 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>
59
60#include <asm/io.h>
61#include <asm/uaccess.h>
62
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>
68
b6fe4ddc
MED		 69#define COPYRIGHT "Copyright (c) 1999-2005 LSI Logic Corporation"
70#define MODULEAUTHOR "LSI Logic Corporation"
1da177e4
LT		 71#include "mptbase.h"
72#include "mptctl.h"
73
74/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
75#define my_NAME "Fusion MPT misc device (ioctl) driver"
76#define my_VERSION MPT_LINUX_VERSION_COMMON
77#define MYNAM "mptctl"
78
79MODULE_AUTHOR(MODULEAUTHOR);
80MODULE_DESCRIPTION(my_NAME);
81MODULE_LICENSE("GPL");
82
83/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
84
85static int mptctl_id = -1;
86
87static DECLARE_WAIT_QUEUE_HEAD ( mptctl_wait );
88
89/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
90
91struct buflist {
92 u8 *kptr;
93 int len;
94};
95
96/*
97 * Function prototypes. Called from OS entry point mptctl_ioctl.
98 * arg contents specific to function.
99 */
100static int mptctl_fw_download(unsigned long arg);
d485eb83
MED		 101static int mptctl_getiocinfo(unsigned long arg, unsigned int cmd);
102static int mptctl_gettargetinfo(unsigned long arg);
103static int mptctl_readtest(unsigned long arg);
104static int mptctl_mpt_command(unsigned long arg);
105static int mptctl_eventquery(unsigned long arg);
106static int mptctl_eventenable(unsigned long arg);
107static int mptctl_eventreport(unsigned long arg);
108static int mptctl_replace_fw(unsigned long arg);
1da177e4
LT		 109
110static int mptctl_do_reset(unsigned long arg);
111static int mptctl_hp_hostinfo(unsigned long arg, unsigned int cmd);
112static int mptctl_hp_targetinfo(unsigned long arg);
113
114static int mptctl_probe(struct pci_dev *, const struct pci_device_id *);
115static void mptctl_remove(struct pci_dev *);
116
117#ifdef CONFIG_COMPAT
118static long compat_mpctl_ioctl(struct file *f, unsigned cmd, unsigned long arg);
119#endif
120/*
121 * Private function calls.
122 */
d485eb83 123static int mptctl_do_mpt_command(struct mpt_ioctl_command karg, void __user *mfPtr);
1da177e4 124static int mptctl_do_fw_download(int ioc, char __user *ufwbuf, size_t fwlen);
d485eb83 125static MptSge_t *kbuf_alloc_2_sgl(int bytes, u32 dir, int sge_offset, int *frags,
1da177e4 126 struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc);
d485eb83 127static void kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma,
1da177e4
LT		 128 struct buflist *buflist, MPT_ADAPTER *ioc);
129static void mptctl_timeout_expired (MPT_IOCTL *ioctl);
130static int mptctl_bus_reset(MPT_IOCTL *ioctl);
131static int mptctl_set_tm_flags(MPT_SCSI_HOST *hd);
132static void mptctl_free_tm_flags(MPT_ADAPTER *ioc);
133
134/*
135 * Reset Handler cleanup function
136 */
137static int mptctl_ioc_reset(MPT_ADAPTER *ioc, int reset_phase);
138
139/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
140/*
141 * Scatter gather list (SGL) sizes and limits...
142 */
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)
147
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)
151
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)
156
157/* linux only seems to ever give 128kB MAX contiguous (GFP_USER) mem bytes */
158#define MAX_KMALLOC_SZ (128*1024)
159
160#define MPT_IOCTL_DEFAULT_TIMEOUT 10 /* Default timeout value (seconds) */
161
162/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
163/**
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
167 *
168 * All of the ioctl commands can potentially sleep, which is illegal
169 * with a spinlock held, thus we perform mutual exclusion here.
170 *
171 * Returns negative errno on error, or zero for success.
172 */
173static inline int
174mptctl_syscall_down(MPT_ADAPTER *ioc, int nonblock)
175{
176 int rc = 0;
177 dctlprintk((KERN_INFO MYNAM "::mptctl_syscall_down(%p,%d) called\n", ioc, nonblock));
178
179 if (nonblock) {
eeb846ce 180 if (!mutex_trylock(&ioc->ioctl->ioctl_mutex))
1da177e4
LT		 181 rc = -EAGAIN;
182 } else {
eeb846ce 183 if (mutex_lock_interruptible(&ioc->ioctl->ioctl_mutex))
1da177e4
LT		 184 rc = -ERESTARTSYS;
185 }
186 dctlprintk((KERN_INFO MYNAM "::mptctl_syscall_down return %d\n", rc));
187 return rc;
188}
189
190/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
191/*
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
194 *
195 * This runs in irq context so be short and sweet.
196 */
197static int
198mptctl_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply)
199{
200 char *sense_data;
201 int sz, req_index;
202 u16 iocStatus;
203 u8 cmd;
204
205 dctlprintk(("mptctl_reply()!\n"));
206 if (req)
207 cmd = req->u.hdr.Function;
208 else
209 return 1;
210
211 if (ioc->ioctl) {
212
213 if (reply==NULL) {
214
215 dctlprintk(("mptctl_reply() NULL Reply "
216 "Function=%x!\n", cmd));
217
218 ioc->ioctl->status |= MPT_IOCTL_STATUS_COMMAND_GOOD;
219 ioc->ioctl->reset &= ~MPTCTL_RESET_OK;
220
221 /* We are done, issue wake up
222 */
223 ioc->ioctl->wait_done = 1;
224 wake_up (&mptctl_wait);
225 return 1;
226
227 }
228
229 dctlprintk(("mptctl_reply() with req=%p "
230 "reply=%p Function=%x!\n", req, reply, cmd));
231
232 /* Copy the reply frame (which much exist
233 * for non-SCSI I/O) to the IOC structure.
234 */
235 dctlprintk(("Copying Reply Frame @%p to ioc%d!\n",
236 reply, ioc->id));
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;
240
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.
243 */
637fa99b 244 iocStatus = le16_to_cpu(reply->u.reply.IOCStatus) & MPI_IOCSTATUS_MASK;
1da177e4
LT		 245 if (iocStatus == MPI_IOCSTATUS_SUCCESS)
246 ioc->ioctl->status |= MPT_IOCTL_STATUS_COMMAND_GOOD;
247
248 if ((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) ||
249 (cmd == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
250 ioc->ioctl->reset &= ~MPTCTL_RESET_OK;
251
252 if ((iocStatus == MPI_IOCSTATUS_SCSI_DATA_UNDERRUN) ||
253 (iocStatus == MPI_IOCSTATUS_SCSI_RECOVERED_ERROR)) {
254 ioc->ioctl->status |= MPT_IOCTL_STATUS_COMMAND_GOOD;
255 }
256 }
257
258 /* Copy the sense data - if present
259 */
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;
264 req_index =
265 le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx);
266 sense_data =
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;
271 }
272
273 if (cmd == MPI_FUNCTION_SCSI_TASK_MGMT)
274 mptctl_free_tm_flags(ioc);
275
276 /* We are done, issue wake up
277 */
278 ioc->ioctl->wait_done = 1;
279 wake_up (&mptctl_wait);
280 }
281 return 1;
282}
283
284/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
285/* mptctl_timeout_expired
286 *
287 * Expecting an interrupt, however timed out.
288 *
289 */
290static void mptctl_timeout_expired (MPT_IOCTL *ioctl)
291{
292 int rc = 1;
293
294 dctlprintk((KERN_NOTICE MYNAM ": Timeout Expired! Host %d\n",
295 ioctl->ioc->id));
296 if (ioctl == NULL)
297 return;
298
299 ioctl->wait_done = 0;
300 if (ioctl->reset & MPTCTL_RESET_OK)
301 rc = mptctl_bus_reset(ioctl);
302
303 if (rc) {
304 /* Issue a reset for this device.
305 * The IOC is not responding.
306 */
307 dctlprintk((MYIOC_s_INFO_FMT "Calling HardReset! \n",
308 ioctl->ioc->name));
309 mpt_HardResetHandler(ioctl->ioc, NO_SLEEP);
310 }
311 return;
312
313}
314
315/* mptctl_bus_reset
316 *
317 * Bus reset code.
318 *
319 */
320static int mptctl_bus_reset(MPT_IOCTL *ioctl)
321{
322 MPT_FRAME_HDR *mf;
323 SCSITaskMgmt_t *pScsiTm;
324 MPT_SCSI_HOST *hd;
325 int ii;
326 int retval;
327
328
329 ioctl->reset &= ~MPTCTL_RESET_OK;
330
331 if (ioctl->ioc->sh == NULL)
332 return -EPERM;
333
334 hd = (MPT_SCSI_HOST *) ioctl->ioc->sh->hostdata;
335 if (hd == NULL)
336 return -EPERM;
337
338 /* Single threading ....
339 */
340 if (mptctl_set_tm_flags(hd) != 0)
341 return -EPERM;
342
343 /* Send request
344 */
345 if ((mf = mpt_get_msg_frame(mptctl_id, ioctl->ioc)) == NULL) {
346 dctlprintk((MYIOC_s_WARN_FMT "IssueTaskMgmt, no msg frames!!\n",
347 ioctl->ioc->name));
348
349 mptctl_free_tm_flags(ioctl->ioc);
350 return -ENOMEM;
351 }
352
353 dtmprintk((MYIOC_s_INFO_FMT "IssueTaskMgmt request @ %p\n",
354 ioctl->ioc->name, mf));
355
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;
365
366 for (ii= 0; ii < 8; ii++)
367 pScsiTm->LUN[ii] = 0;
368
369 for (ii=0; ii < 7; ii++)
370 pScsiTm->Reserved2[ii] = 0;
371
372 pScsiTm->TaskMsgContext = 0;
373 dtmprintk((MYIOC_s_INFO_FMT
374 "mptctl_bus_reset: issued.\n", ioctl->ioc->name));
375
376 DBG_DUMP_TM_REQUEST_FRAME((u32 *)mf);
377
378 ioctl->wait_done=0;
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,
383 hd->ioc, mf));
384 goto mptctl_bus_reset_done;
385 }
386
387 /* Now wait for the command to complete */
86a7dcaa 388 ii = wait_event_timeout(mptctl_wait,
1da177e4
LT		 389 ioctl->wait_done == 1,
390 HZ*5 /* 5 second timeout */);
391
392 if(ii <=0 && (ioctl->wait_done != 1 )) {
86a7dcaa 393 mpt_free_msg_frame(hd->ioc, mf);
1da177e4
LT		 394 ioctl->wait_done = 0;
395 retval = -1; /* return failure */
396 }
397
398mptctl_bus_reset_done:
399
1da177e4
LT		 400 mptctl_free_tm_flags(ioctl->ioc);
401 return retval;
402}
403
404static int
405mptctl_set_tm_flags(MPT_SCSI_HOST *hd) {
406 unsigned long flags;
407
408 spin_lock_irqsave(&hd->ioc->FreeQlock, flags);
409
410 if (hd->tmState == TM_STATE_NONE) {
411 hd->tmState = TM_STATE_IN_PROGRESS;
412 hd->tmPending = 1;
413 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
414 } else {
415 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
416 return -EBUSY;
417 }
418
419 return 0;
420}
421
422static void
423mptctl_free_tm_flags(MPT_ADAPTER *ioc)
424{
425 MPT_SCSI_HOST * hd;
426 unsigned long flags;
427
428 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
429 if (hd == NULL)
430 return;
431
432 spin_lock_irqsave(&ioc->FreeQlock, flags);
433
434 hd->tmState = TM_STATE_NONE;
435 hd->tmPending = 0;
436 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
437
438 return;
439}
440
441/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
442/* mptctl_ioc_reset
443 *
444 * Clean-up functionality. Used only if there has been a
445 * reload of the FW due.
446 *
447 */
448static int
449mptctl_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
450{
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")));
455
456 if(ioctl == NULL)
457 return 1;
458
459 switch(reset_phase) {
460 case MPT_IOC_SETUP_RESET:
461 ioctl->status |= MPT_IOCTL_STATUS_DID_IOCRESET;
462 break;
463 case MPT_IOC_POST_RESET:
464 ioctl->status &= ~MPT_IOCTL_STATUS_DID_IOCRESET;
465 break;
466 case MPT_IOC_PRE_RESET:
467 default:
468 break;
469 }
470
471 return 1;
472}
473
474/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
475/*
476 * MPT ioctl handler
477 * cmd - specify the particular IOCTL command to be issued
478 * arg - data specific to the command. Must not be null.
479 */
480static long
481__mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
482{
483 mpt_ioctl_header __user *uhdr = (void __user *) arg;
484 mpt_ioctl_header khdr;
485 int iocnum;
486 unsigned iocnumX;
487 int nonblock = (file->f_flags & O_NONBLOCK);
488 int ret;
489 MPT_ADAPTER *iocp = NULL;
490
491 dctlprintk(("mptctl_ioctl() called\n"));
492
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);
497 return -EFAULT;
498 }
499 ret = -ENXIO; /* (-6) No such device or address */
500
501 /* Verify intended MPT adapter - set iocnum and the adapter
502 * pointer (iocp)
503 */
504 iocnumX = khdr.iocnum & 0xFF;
505 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
506 (iocp == NULL)) {
507 dctlprintk((KERN_ERR "%s::mptctl_ioctl() @%d - ioc%d not found!\n",
508 __FILE__, __LINE__, iocnumX));
509 return -ENODEV;
510 }
511
512 if (!iocp->active) {
513 printk(KERN_ERR "%s::mptctl_ioctl() @%d - Controller disabled.\n",
514 __FILE__, __LINE__);
515 return -EFAULT;
516 }
517
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.
522 */
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);
537 }
538
539 /* All of these commands require an interrupt or
540 * are unknown/illegal.
541 */
542 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
543 return ret;
544
545 dctlprintk((MYIOC_s_INFO_FMT ": mptctl_ioctl()\n", iocp->name));
546
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);
557 else
558 ret = -EINVAL;
559
eeb846ce 560 mutex_unlock(&iocp->ioctl->ioctl_mutex);
1da177e4
LT		 561
562 return ret;
563}
564
565static long
566mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
567{
568 long ret;
569 lock_kernel();
570 ret = __mptctl_ioctl(file, cmd, arg);
571 unlock_kernel();
572 return ret;
573}
574
575static int mptctl_do_reset(unsigned long arg)
576{
577 struct mpt_ioctl_diag_reset __user *urinfo = (void __user *) arg;
578 struct mpt_ioctl_diag_reset krinfo;
579 MPT_ADAPTER *iocp;
580
581 dctlprintk((KERN_INFO "mptctl_do_reset called.\n"));
582
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);
587 return -EFAULT;
588 }
589
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 */
594 }
595
596 if (mpt_HardResetHandler(iocp, CAN_SLEEP) != 0) {
597 printk (KERN_ERR "%s@%d::mptctl_do_reset - reset failed.\n",
598 __FILE__, __LINE__);
599 return -1;
600 }
601
602 return 0;
603}
604
605/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
606/*
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.
610 *
611 * Outputs: None.
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
621 */
622static int
623mptctl_fw_download(unsigned long arg)
624{
625 struct mpt_fw_xfer __user *ufwdl = (void __user *) arg;
626 struct mpt_fw_xfer kfwdl;
627
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);
633 return -EFAULT;
634 }
635
636 return mptctl_do_fw_download(kfwdl.iocnum, kfwdl.bufp, kfwdl.fwlen);
637}
638
639/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
640/*
641 * FW Download engine.
642 * Outputs: None.
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
652 */
653static int
654mptctl_do_fw_download(int ioc, char __user *ufwbuf, size_t fwlen)
655{
656 FWDownload_t *dlmsg;
657 MPT_FRAME_HDR *mf;
658 MPT_ADAPTER *iocp;
659 FWDownloadTCSGE_t *ptsge;
660 MptSge_t *sgl, *sgIn;
661 char *sgOut;
662 struct buflist *buflist;
663 struct buflist *bl;
664 dma_addr_t sgl_dma;
665 int ret;
666 int numfrags = 0;
667 int maxfrags;
668 int n = 0;
669 u32 sgdir;
670 u32 nib;
671 int fw_bytes_copied = 0;
672 int i;
673 int sge_offset = 0;
674 u16 iocstat;
675 pFWDownloadReply_t ReplyMsg = NULL;
676
946cbf04 677 dctlprintk(("mptctl_do_fwdl called. mptctl_id = %xh.\n", mptctl_id));
1da177e4 678
946cbf04
ME		 679 dctlprintk(("DbG: kfwdl.bufp = %p\n", ufwbuf));
680 dctlprintk(("DbG: kfwdl.fwlen = %d\n", (int)fwlen));
681 dctlprintk(("DbG: kfwdl.ioc = %04xh\n", ioc));
1da177e4 682
946cbf04
ME		 683 if (mpt_verify_adapter(ioc, &iocp) < 0) {
684 dctlprintk(("ioctl_fwdl - ioc%d not found!\n",
685 ioc));
1da177e4 686 return -ENODEV; /* (-6) No such device or address */
946cbf04 687 } else {
1da177e4 688
946cbf04
ME		 689 /* Valid device. Get a message frame and construct the FW download message.
690 */
691 if ((mf = mpt_get_msg_frame(mptctl_id, iocp)) == NULL)
692 return -EAGAIN;
693 }
1da177e4
LT		 694 dlmsg = (FWDownload_t*) mf;
695 ptsge = (FWDownloadTCSGE_t *) &dlmsg->SGL;
696 sgOut = (char *) (ptsge + 1);
697
698 /*
699 * Construct f/w download request
700 */
701 dlmsg->ImageType = MPI_FW_DOWNLOAD_ITYPE_FW;
702 dlmsg->Reserved = 0;
703 dlmsg->ChainOffset = 0;
704 dlmsg->Function = MPI_FUNCTION_FW_DOWNLOAD;
705 dlmsg->Reserved1[0] = dlmsg->Reserved1[1] = dlmsg->Reserved1[2] = 0;
946cbf04
ME		 706 if (iocp->facts.MsgVersion >= MPI_VERSION_01_05)
707 dlmsg->MsgFlags = MPI_FW_DOWNLOAD_MSGFLGS_LAST_SEGMENT;
708 else
709 dlmsg->MsgFlags = 0;
710
1da177e4
LT		 711
712 /* Set up the Transaction SGE.
713 */
714 ptsge->Reserved = 0;
715 ptsge->ContextSize = 0;
716 ptsge->DetailsLength = 12;
717 ptsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
718 ptsge->Reserved_0100_Checksum = 0;
719 ptsge->ImageOffset = 0;
720 ptsge->ImageSize = cpu_to_le32(fwlen);
721
722 /* Add the SGL
723 */
724
725 /*
726 * Need to kmalloc area(s) for holding firmware image bytes.
727 * But we need to do it piece meal, using a proper
728 * scatter gather list (with 128kB MAX hunks).
729 *
730 * A practical limit here might be # of sg hunks that fit into
731 * a single IOC request frame; 12 or 8 (see below), so:
732 * For FC9xx: 12 x 128kB == 1.5 mB (max)
733 * For C1030: 8 x 128kB == 1 mB (max)
734 * We could support chaining, but things get ugly(ier:)
735 *
736 * Set the sge_offset to the start of the sgl (bytes).
737 */
738 sgdir = 0x04000000; /* IOC will READ from sys mem */
739 sge_offset = sizeof(MPIHeader_t) + sizeof(FWDownloadTCSGE_t);
740 if ((sgl = kbuf_alloc_2_sgl(fwlen, sgdir, sge_offset,
741 &numfrags, &buflist, &sgl_dma, iocp)) == NULL)
742 return -ENOMEM;
743
744 /*
745 * We should only need SGL with 2 simple_32bit entries (up to 256 kB)
746 * for FC9xx f/w image, but calculate max number of sge hunks
747 * we can fit into a request frame, and limit ourselves to that.
748 * (currently no chain support)
749 * maxfrags = (Request Size - FWdownload Size ) / Size of 32 bit SGE
750 * Request maxfrags
751 * 128 12
752 * 96 8
753 * 64 4
754 */
755 maxfrags = (iocp->req_sz - sizeof(MPIHeader_t) - sizeof(FWDownloadTCSGE_t))
756 / (sizeof(dma_addr_t) + sizeof(u32));
757 if (numfrags > maxfrags) {
758 ret = -EMLINK;
759 goto fwdl_out;
760 }
761
946cbf04 762 dctlprintk(("DbG: sgl buffer = %p, sgfrags = %d\n", sgl, numfrags));
1da177e4
LT		 763
764 /*
765 * Parse SG list, copying sgl itself,
766 * plus f/w image hunks from user space as we go...
767 */
768 ret = -EFAULT;
769 sgIn = sgl;
770 bl = buflist;
771 for (i=0; i < numfrags; i++) {
772
773 /* Get the SGE type: 0 - TCSGE, 3 - Chain, 1 - Simple SGE
774 * Skip everything but Simple. If simple, copy from
775 * user space into kernel space.
776 * Note: we should not have anything but Simple as
777 * Chain SGE are illegal.
778 */
779 nib = (sgIn->FlagsLength & 0x30000000) >> 28;
780 if (nib == 0 || nib == 3) {
781 ;
782 } else if (sgIn->Address) {
783 mpt_add_sge(sgOut, sgIn->FlagsLength, sgIn->Address);
784 n++;
785 if (copy_from_user(bl->kptr, ufwbuf+fw_bytes_copied, bl->len)) {
786 printk(KERN_ERR "%s@%d::_ioctl_fwdl - "
787 "Unable to copy f/w buffer hunk#%d @ %p\n",
788 __FILE__, __LINE__, n, ufwbuf);
789 goto fwdl_out;
790 }
791 fw_bytes_copied += bl->len;
792 }
793 sgIn++;
794 bl++;
795 sgOut += (sizeof(dma_addr_t) + sizeof(u32));
796 }
797
798#ifdef MPT_DEBUG
799 {
800 u32 *m = (u32 *)mf;
801 printk(KERN_INFO MYNAM ": F/W download request:\n" KERN_INFO " ");
802 for (i=0; i < 7+numfrags*2; i++)
803 printk(" %08x", le32_to_cpu(m[i]));
804 printk("\n");
805 }
806#endif
807
808 /*
809 * Finally, perform firmware download.
810 */
946cbf04 811 ReplyMsg = NULL;
1da177e4
LT		 812 mpt_put_msg_frame(mptctl_id, iocp, mf);
813
814 /* Now wait for the command to complete */
86a7dcaa 815 ret = wait_event_timeout(mptctl_wait,
1da177e4
LT		 816 iocp->ioctl->wait_done == 1,
817 HZ*60);
818
819 if(ret <=0 && (iocp->ioctl->wait_done != 1 )) {
820 /* Now we need to reset the board */
821 mptctl_timeout_expired(iocp->ioctl);
822 ret = -ENODATA;
823 goto fwdl_out;
824 }
825
826 if (sgl)
827 kfree_sgl(sgl, sgl_dma, buflist, iocp);
828
829 ReplyMsg = (pFWDownloadReply_t)iocp->ioctl->ReplyFrame;
830 iocstat = le16_to_cpu(ReplyMsg->IOCStatus) & MPI_IOCSTATUS_MASK;
831 if (iocstat == MPI_IOCSTATUS_SUCCESS) {
832 printk(KERN_INFO MYNAM ": F/W update successfully sent to %s!\n", iocp->name);
833 return 0;
834 } else if (iocstat == MPI_IOCSTATUS_INVALID_FUNCTION) {
835 printk(KERN_WARNING MYNAM ": ?Hmmm... %s says it doesn't support F/W download!?!\n",
836 iocp->name);
837 printk(KERN_WARNING MYNAM ": (time to go bang on somebodies door)\n");
838 return -EBADRQC;
839 } else if (iocstat == MPI_IOCSTATUS_BUSY) {
840 printk(KERN_WARNING MYNAM ": Warning! %s says: IOC_BUSY!\n", iocp->name);
841 printk(KERN_WARNING MYNAM ": (try again later?)\n");
842 return -EBUSY;
843 } else {
844 printk(KERN_WARNING MYNAM "::ioctl_fwdl() ERROR! %s returned [bad] status = %04xh\n",
845 iocp->name, iocstat);
846 printk(KERN_WARNING MYNAM ": (bad VooDoo)\n");
847 return -ENOMSG;
848 }
849 return 0;
850
851fwdl_out:
852 kfree_sgl(sgl, sgl_dma, buflist, iocp);
853 return ret;
854}
855
856/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
857/*
858 * SGE Allocation routine
859 *
860 * Inputs: bytes - number of bytes to be transferred
861 * sgdir - data direction
862 * sge_offset - offset (in bytes) from the start of the request
863 * frame to the first SGE
864 * ioc - pointer to the mptadapter
865 * Outputs: frags - number of scatter gather elements
866 * blp - point to the buflist pointer
867 * sglbuf_dma - pointer to the (dma) sgl
868 * Returns: Null if failes
869 * pointer to the (virtual) sgl if successful.
870 */
871static MptSge_t *
872kbuf_alloc_2_sgl(int bytes, u32 sgdir, int sge_offset, int *frags,
873 struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc)
874{
875 MptSge_t *sglbuf = NULL; /* pointer to array of SGE */
876 /* and chain buffers */
877 struct buflist *buflist = NULL; /* kernel routine */
878 MptSge_t *sgl;
879 int numfrags = 0;
880 int fragcnt = 0;
881 int alloc_sz = min(bytes,MAX_KMALLOC_SZ); // avoid kernel warning msg!
882 int bytes_allocd = 0;
883 int this_alloc;
884 dma_addr_t pa; // phys addr
885 int i, buflist_ent;
886 int sg_spill = MAX_FRAGS_SPILL1;
887 int dir;
888 /* initialization */
889 *frags = 0;
890 *blp = NULL;
891
892 /* Allocate and initialize an array of kernel
893 * structures for the SG elements.
894 */
895 i = MAX_SGL_BYTES / 8;
896 buflist = kmalloc(i, GFP_USER);
897 if (buflist == NULL)
898 return NULL;
899 memset(buflist, 0, i);
900 buflist_ent = 0;
901
902 /* Allocate a single block of memory to store the sg elements and
903 * the chain buffers. The calling routine is responsible for
904 * copying the data in this array into the correct place in the
905 * request and chain buffers.
906 */
907 sglbuf = pci_alloc_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf_dma);
908 if (sglbuf == NULL)
909 goto free_and_fail;
910
911 if (sgdir & 0x04000000)
912 dir = PCI_DMA_TODEVICE;
913 else
914 dir = PCI_DMA_FROMDEVICE;
915
916 /* At start:
917 * sgl = sglbuf = point to beginning of sg buffer
918 * buflist_ent = 0 = first kernel structure
919 * sg_spill = number of SGE that can be written before the first
920 * chain element.
921 *
922 */
923 sgl = sglbuf;
924 sg_spill = ((ioc->req_sz - sge_offset)/(sizeof(dma_addr_t) + sizeof(u32))) - 1;
925 while (bytes_allocd < bytes) {
926 this_alloc = min(alloc_sz, bytes-bytes_allocd);
927 buflist[buflist_ent].len = this_alloc;
928 buflist[buflist_ent].kptr = pci_alloc_consistent(ioc->pcidev,
929 this_alloc,
930 &pa);
931 if (buflist[buflist_ent].kptr == NULL) {
932 alloc_sz = alloc_sz / 2;
933 if (alloc_sz == 0) {
934 printk(KERN_WARNING MYNAM "-SG: No can do - "
935 "not enough memory! :-(\n");
936 printk(KERN_WARNING MYNAM "-SG: (freeing %d frags)\n",
937 numfrags);
938 goto free_and_fail;
939 }
940 continue;
941 } else {
942 dma_addr_t dma_addr;
943
944 bytes_allocd += this_alloc;
945 sgl->FlagsLength = (0x10000000|MPT_SGE_FLAGS_ADDRESSING|sgdir|this_alloc);
946 dma_addr = pci_map_single(ioc->pcidev, buflist[buflist_ent].kptr, this_alloc, dir);
947 sgl->Address = dma_addr;
948
949 fragcnt++;
950 numfrags++;
951 sgl++;
952 buflist_ent++;
953 }
954
955 if (bytes_allocd >= bytes)
956 break;
957
958 /* Need to chain? */
959 if (fragcnt == sg_spill) {
960 printk(KERN_WARNING MYNAM "-SG: No can do - " "Chain required! :-(\n");
961 printk(KERN_WARNING MYNAM "(freeing %d frags)\n", numfrags);
962 goto free_and_fail;
963 }
964
965 /* overflow check... */
966 if (numfrags*8 > MAX_SGL_BYTES){
967 /* GRRRRR... */
968 printk(KERN_WARNING MYNAM "-SG: No can do - "
969 "too many SG frags! :-(\n");
970 printk(KERN_WARNING MYNAM "-SG: (freeing %d frags)\n",
971 numfrags);
972 goto free_and_fail;
973 }
974 }
975
976 /* Last sge fixup: set LE+eol+eob bits */
977 sgl[-1].FlagsLength |= 0xC1000000;
978
979 *frags = numfrags;
980 *blp = buflist;
981
982 dctlprintk((KERN_INFO MYNAM "-SG: kbuf_alloc_2_sgl() - "
983 "%d SG frags generated!\n",
984 numfrags));
985
986 dctlprintk((KERN_INFO MYNAM "-SG: kbuf_alloc_2_sgl() - "
987 "last (big) alloc_sz=%d\n",
988 alloc_sz));
989
990 return sglbuf;
991
992free_and_fail:
993 if (sglbuf != NULL) {
994 int i;
995
996 for (i = 0; i < numfrags; i++) {
997 dma_addr_t dma_addr;
998 u8 *kptr;
999 int len;
1000
1001 if ((sglbuf[i].FlagsLength >> 24) == 0x30)
1002 continue;
1003
1004 dma_addr = sglbuf[i].Address;
1005 kptr = buflist[i].kptr;
1006 len = buflist[i].len;
1007
1008 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1009 }
1010 pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf, *sglbuf_dma);
1011 }
1012 kfree(buflist);
1013 return NULL;
1014}
1015
1016/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1017/*
1018 * Routine to free the SGL elements.
1019 */
1020static void
1021kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma, struct buflist *buflist, MPT_ADAPTER *ioc)
1022{
1023 MptSge_t *sg = sgl;
1024 struct buflist *bl = buflist;
1025 u32 nib;
1026 int dir;
1027 int n = 0;
1028
1029 if (sg->FlagsLength & 0x04000000)
1030 dir = PCI_DMA_TODEVICE;
1031 else
1032 dir = PCI_DMA_FROMDEVICE;
1033
1034 nib = (sg->FlagsLength & 0xF0000000) >> 28;
1035 while (! (nib & 0x4)) { /* eob */
1036 /* skip ignore/chain. */
1037 if (nib == 0 || nib == 3) {
1038 ;
1039 } else if (sg->Address) {
1040 dma_addr_t dma_addr;
1041 void *kptr;
1042 int len;
1043
1044 dma_addr = sg->Address;
1045 kptr = bl->kptr;
1046 len = bl->len;
1047 pci_unmap_single(ioc->pcidev, dma_addr, len, dir);
1048 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1049 n++;
1050 }
1051 sg++;
1052 bl++;
1053 nib = (le32_to_cpu(sg->FlagsLength) & 0xF0000000) >> 28;
1054 }
1055
1056 /* we're at eob! */
1057 if (sg->Address) {
1058 dma_addr_t dma_addr;
1059 void *kptr;
1060 int len;
1061
1062 dma_addr = sg->Address;
1063 kptr = bl->kptr;
1064 len = bl->len;
1065 pci_unmap_single(ioc->pcidev, dma_addr, len, dir);
1066 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1067 n++;
1068 }
1069
1070 pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sgl, sgl_dma);
1071 kfree(buflist);
1072 dctlprintk((KERN_INFO MYNAM "-SG: Free'd 1 SGL buf + %d kbufs!\n", n));
1073}
1074
1075/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1076/*
1077 * mptctl_getiocinfo - Query the host adapter for IOC information.
1078 * @arg: User space argument
1079 *
1080 * Outputs: None.
1081 * Return: 0 if successful
1082 * -EFAULT if data unavailable
1083 * -ENODEV if no such device/adapter
1084 */
1085static int
1086mptctl_getiocinfo (unsigned long arg, unsigned int data_size)
1087{
1088 struct mpt_ioctl_iocinfo __user *uarg = (void __user *) arg;
1089 struct mpt_ioctl_iocinfo *karg;
1090 MPT_ADAPTER *ioc;
1091 struct pci_dev *pdev;
1092 struct Scsi_Host *sh;
1093 MPT_SCSI_HOST *hd;
1094 int iocnum;
1095 int numDevices = 0;
1096 unsigned int max_id;
1097 int ii;
b6fe4ddc 1098 unsigned int port;
1da177e4
LT		 1099 int cim_rev;
1100 u8 revision;
1101
1102 dctlprintk((": mptctl_getiocinfo called.\n"));
1103 /* Add of PCI INFO results in unaligned access for
1104 * IA64 and Sparc. Reset long to int. Return no PCI
1105 * data for obsolete format.
1106 */
1107 if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev0))
1108 cim_rev = 0;
1109 else if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev1))
1110 cim_rev = 1;
1111 else if (data_size == sizeof(struct mpt_ioctl_iocinfo))
1112 cim_rev = 2;
1113 else if (data_size == (sizeof(struct mpt_ioctl_iocinfo_rev0)+12))
1114 cim_rev = 0; /* obsolete */
1115 else
1116 return -EFAULT;
1117
1118 karg = kmalloc(data_size, GFP_KERNEL);
1119 if (karg == NULL) {
1120 printk(KERN_ERR "%s::mpt_ioctl_iocinfo() @%d - no memory available!\n",
1121 __FILE__, __LINE__);
1122 return -ENOMEM;
1123 }
1124
1125 if (copy_from_user(karg, uarg, data_size)) {
1126 printk(KERN_ERR "%s@%d::mptctl_getiocinfo - "
1127 "Unable to read in mpt_ioctl_iocinfo struct @ %p\n",
1128 __FILE__, __LINE__, uarg);
1129 kfree(karg);
1130 return -EFAULT;
1131 }
1132
1133 if (((iocnum = mpt_verify_adapter(karg->hdr.iocnum, &ioc)) < 0) ||
1134 (ioc == NULL)) {
1135 dctlprintk((KERN_ERR "%s::mptctl_getiocinfo() @%d - ioc%d not found!\n",
1136 __FILE__, __LINE__, iocnum));
1137 kfree(karg);
1138 return -ENODEV;
1139 }
1140
b6fe4ddc 1141 /* Verify the data transfer size is correct. */
1da177e4
LT		 1142 if (karg->hdr.maxDataSize != data_size) {
1143 printk(KERN_ERR "%s@%d::mptctl_getiocinfo - "
1144 "Structure size mismatch. Command not completed.\n",
1145 __FILE__, __LINE__);
1146 kfree(karg);
1147 return -EFAULT;
1148 }
1149
1150 /* Fill in the data and return the structure to the calling
1151 * program
1152 */
9cc1cfbc
ME		 1153 if (ioc->bus_type == SAS)
1154 karg->adapterType = MPT_IOCTL_INTERFACE_SAS;
1155 else if (ioc->bus_type == FC)
1da177e4
LT		 1156 karg->adapterType = MPT_IOCTL_INTERFACE_FC;
1157 else
1158 karg->adapterType = MPT_IOCTL_INTERFACE_SCSI;
1159
b6fe4ddc
MED		 1160 if (karg->hdr.port > 1)
1161 return -EINVAL;
1da177e4
LT		 1162 port = karg->hdr.port;
1163
1164 karg->port = port;
1165 pdev = (struct pci_dev *) ioc->pcidev;
1166
1167 karg->pciId = pdev->device;
1168 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1169 karg->hwRev = revision;
1170 karg->subSystemDevice = pdev->subsystem_device;
1171 karg->subSystemVendor = pdev->subsystem_vendor;
1172
1173 if (cim_rev == 1) {
1174 /* Get the PCI bus, device, and function numbers for the IOC
1175 */
1176 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1177 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1178 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1179 } else if (cim_rev == 2) {
86a7dcaa 1180 /* Get the PCI bus, device, function and segment ID numbers
1da177e4
LT		 1181 for the IOC */
1182 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1183 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1184 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1da177e4
LT		 1185 karg->pciInfo.segmentID = pci_domain_nr(pdev->bus);
1186 }
1187
1188 /* Get number of devices
1189 */
1190 if ((sh = ioc->sh) != NULL) {
1191 /* sh->max_id = maximum target ID + 1
1192 */
1193 max_id = sh->max_id - 1;
1194 hd = (MPT_SCSI_HOST *) sh->hostdata;
1195
1196 /* Check all of the target structures and
1197 * keep a counter.
1198 */
1199 if (hd && hd->Targets) {
1200 for (ii = 0; ii <= max_id; ii++) {
1201 if (hd->Targets[ii])
1202 numDevices++;
1203 }
1204 }
1205 }
1206 karg->numDevices = numDevices;
1207
1208 /* Set the BIOS and FW Version
1209 */
1210 karg->FWVersion = ioc->facts.FWVersion.Word;
1211 karg->BIOSVersion = ioc->biosVersion;
1212
1213 /* Set the Version Strings.
1214 */
1215 strncpy (karg->driverVersion, MPT_LINUX_PACKAGE_NAME, MPT_IOCTL_VERSION_LENGTH);
1216 karg->driverVersion[MPT_IOCTL_VERSION_LENGTH-1]='\0';
1217
1218 karg->busChangeEvent = 0;
1219 karg->hostId = ioc->pfacts[port].PortSCSIID;
1220 karg->rsvd[0] = karg->rsvd[1] = 0;
1221
1222 /* Copy the data from kernel memory to user memory
1223 */
1224 if (copy_to_user((char __user *)arg, karg, data_size)) {
1225 printk(KERN_ERR "%s@%d::mptctl_getiocinfo - "
1226 "Unable to write out mpt_ioctl_iocinfo struct @ %p\n",
1227 __FILE__, __LINE__, uarg);
1228 kfree(karg);
1229 return -EFAULT;
1230 }
1231
1232 kfree(karg);
1233 return 0;
1234}
1235
1236/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1237/*
1238 * mptctl_gettargetinfo - Query the host adapter for target information.
1239 * @arg: User space argument
1240 *
1241 * Outputs: None.
1242 * Return: 0 if successful
1243 * -EFAULT if data unavailable
1244 * -ENODEV if no such device/adapter
1245 */
1246static int
1247mptctl_gettargetinfo (unsigned long arg)
1248{
1249 struct mpt_ioctl_targetinfo __user *uarg = (void __user *) arg;
1250 struct mpt_ioctl_targetinfo karg;
1251 MPT_ADAPTER *ioc;
1252 struct Scsi_Host *sh;
1253 MPT_SCSI_HOST *hd;
c7c82987 1254 VirtTarget *vdev;
1da177e4
LT		 1255 char *pmem;
1256 int *pdata;
1257 IOCPage2_t *pIoc2;
1258 IOCPage3_t *pIoc3;
1259 int iocnum;
1260 int numDevices = 0;
1261 unsigned int max_id;
1262 int id, jj, indexed_lun, lun_index;
1263 u32 lun;
1264 int maxWordsLeft;
1265 int numBytes;
1266 u8 port, devType, bus_id;
1267
1268 dctlprintk(("mptctl_gettargetinfo called.\n"));
1269 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_targetinfo))) {
1270 printk(KERN_ERR "%s@%d::mptctl_gettargetinfo - "
1271 "Unable to read in mpt_ioctl_targetinfo struct @ %p\n",
1272 __FILE__, __LINE__, uarg);
1273 return -EFAULT;
1274 }
1275
1276 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1277 (ioc == NULL)) {
1278 dctlprintk((KERN_ERR "%s::mptctl_gettargetinfo() @%d - ioc%d not found!\n",
1279 __FILE__, __LINE__, iocnum));
1280 return -ENODEV;
1281 }
1282
1283 /* Get the port number and set the maximum number of bytes
1284 * in the returned structure.
1285 * Ignore the port setting.
1286 */
1287 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1288 maxWordsLeft = numBytes/sizeof(int);
1289 port = karg.hdr.port;
1290
1291 if (maxWordsLeft <= 0) {
1292 printk(KERN_ERR "%s::mptctl_gettargetinfo() @%d - no memory available!\n",
1293 __FILE__, __LINE__);
1294 return -ENOMEM;
1295 }
1296
1297 /* Fill in the data and return the structure to the calling
1298 * program
1299 */
1300
1301 /* struct mpt_ioctl_targetinfo does not contain sufficient space
1302 * for the target structures so when the IOCTL is called, there is
1303 * not sufficient stack space for the structure. Allocate memory,
1304 * populate the memory, copy back to the user, then free memory.
1305 * targetInfo format:
1306 * bits 31-24: reserved
1307 * 23-16: LUN
1308 * 15- 8: Bus Number
1309 * 7- 0: Target ID
1310 */
1311 pmem = kmalloc(numBytes, GFP_KERNEL);
1312 if (pmem == NULL) {
1313 printk(KERN_ERR "%s::mptctl_gettargetinfo() @%d - no memory available!\n",
1314 __FILE__, __LINE__);
1315 return -ENOMEM;
1316 }
1317 memset(pmem, 0, numBytes);
1318 pdata = (int *) pmem;
1319
1320 /* Get number of devices
1321 */
1322 if ((sh = ioc->sh) != NULL) {
1323
1324 max_id = sh->max_id - 1;
1325 hd = (MPT_SCSI_HOST *) sh->hostdata;
1326
1327 /* Check all of the target structures.
1328 * Save the Id and increment the counter,
1329 * if ptr non-null.
1330 * sh->max_id = maximum target ID + 1
1331 */
1332 if (hd && hd->Targets) {
1333 mpt_findImVolumes(ioc);
466544d8 1334 pIoc2 = ioc->raid_data.pIocPg2;
1da177e4
LT		 1335 for ( id = 0; id <= max_id; ) {
1336 if ( pIoc2 && pIoc2->NumActiveVolumes ) {
1337 if ( id == pIoc2->RaidVolume[0].VolumeID ) {
1338 if (maxWordsLeft <= 0) {
1339 printk(KERN_ERR "mptctl_gettargetinfo - "
1340 "buffer is full but volume is available on ioc %d\n, numDevices=%d", iocnum, numDevices);
1341 goto data_space_full;
1342 }
1343 if ( ( pIoc2->RaidVolume[0].Flags & MPI_IOCPAGE2_FLAG_VOLUME_INACTIVE ) == 0 )
1344 devType = 0x80;
1345 else
1346 devType = 0xC0;
1347 bus_id = pIoc2->RaidVolume[0].VolumeBus;
1348 numDevices++;
1349 *pdata = ( (devType << 24) | (bus_id << 8) | id );
1350 dctlprintk((KERN_ERR "mptctl_gettargetinfo - "
1351 "volume ioc=%d target=%x numDevices=%d pdata=%p\n", iocnum, *pdata, numDevices, pdata));
1352 pdata++;
1353 --maxWordsLeft;
1354 goto next_id;
1355 } else {
466544d8 1356 pIoc3 = ioc->raid_data.pIocPg3;
1da177e4
LT		 1357 for ( jj = 0; jj < pIoc3->NumPhysDisks; jj++ ) {
1358 if ( pIoc3->PhysDisk[jj].PhysDiskID == id )
1359 goto next_id;
1360 }
1361 }
1362 }
1363 if ( (vdev = hd->Targets[id]) ) {
1364 for (jj = 0; jj <= MPT_LAST_LUN; jj++) {
1365 lun_index = (jj >> 5);
1366 indexed_lun = (jj % 32);
1367 lun = (1 << indexed_lun);
1368 if (vdev->luns[lun_index] & lun) {
1369 if (maxWordsLeft <= 0) {
1370 printk(KERN_ERR "mptctl_gettargetinfo - "
1371 "buffer is full but more targets are available on ioc %d numDevices=%d\n", iocnum, numDevices);
1372 goto data_space_full;
1373 }
1374 bus_id = vdev->bus_id;
1375 numDevices++;
1376 *pdata = ( (jj << 16) | (bus_id << 8) | id );
1377 dctlprintk((KERN_ERR "mptctl_gettargetinfo - "
1378 "target ioc=%d target=%x numDevices=%d pdata=%p\n", iocnum, *pdata, numDevices, pdata));
1379 pdata++;
1380 --maxWordsLeft;
1381 }
1382 }
1383 }
1384next_id:
1385 id++;
1386 }
1387 }
1388 }
1389data_space_full:
1390 karg.numDevices = numDevices;
1391
1392 /* Copy part of the data from kernel memory to user memory
1393 */
1394 if (copy_to_user((char __user *)arg, &karg,
1395 sizeof(struct mpt_ioctl_targetinfo))) {
1396 printk(KERN_ERR "%s@%d::mptctl_gettargetinfo - "
1397 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1398 __FILE__, __LINE__, uarg);
1399 kfree(pmem);
1400 return -EFAULT;
1401 }
1402
1403 /* Copy the remaining data from kernel memory to user memory
1404 */
1405 if (copy_to_user(uarg->targetInfo, pmem, numBytes)) {
1406 printk(KERN_ERR "%s@%d::mptctl_gettargetinfo - "
1407 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1408 __FILE__, __LINE__, pdata);
1409 kfree(pmem);
1410 return -EFAULT;
1411 }
1412
1413 kfree(pmem);
1414
1415 return 0;
1416}
1417
1418/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1419/* MPT IOCTL Test function.
1420 *
1421 * Outputs: None.
1422 * Return: 0 if successful
1423 * -EFAULT if data unavailable
1424 * -ENODEV if no such device/adapter
1425 */
1426static int
1427mptctl_readtest (unsigned long arg)
1428{
1429 struct mpt_ioctl_test __user *uarg = (void __user *) arg;
1430 struct mpt_ioctl_test karg;
1431 MPT_ADAPTER *ioc;
1432 int iocnum;
1433
1434 dctlprintk(("mptctl_readtest called.\n"));
1435 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_test))) {
1436 printk(KERN_ERR "%s@%d::mptctl_readtest - "
1437 "Unable to read in mpt_ioctl_test struct @ %p\n",
1438 __FILE__, __LINE__, uarg);
1439 return -EFAULT;
1440 }
1441
1442 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1443 (ioc == NULL)) {
1444 dctlprintk((KERN_ERR "%s::mptctl_readtest() @%d - ioc%d not found!\n",
1445 __FILE__, __LINE__, iocnum));
1446 return -ENODEV;
1447 }
1448
1449 /* Fill in the data and return the structure to the calling
1450 * program
1451 */
1452
1453#ifdef MFCNT
1454 karg.chip_type = ioc->mfcnt;
1455#else
1456 karg.chip_type = ioc->pcidev->device;
1457#endif
1458 strncpy (karg.name, ioc->name, MPT_MAX_NAME);
1459 karg.name[MPT_MAX_NAME-1]='\0';
1460 strncpy (karg.product, ioc->prod_name, MPT_PRODUCT_LENGTH);
1461 karg.product[MPT_PRODUCT_LENGTH-1]='\0';
1462
1463 /* Copy the data from kernel memory to user memory
1464 */
1465 if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_test))) {
1466 printk(KERN_ERR "%s@%d::mptctl_readtest - "
1467 "Unable to write out mpt_ioctl_test struct @ %p\n",
1468 __FILE__, __LINE__, uarg);
1469 return -EFAULT;
1470 }
1471
1472 return 0;
1473}
1474
1475/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1476/*
1477 * mptctl_eventquery - Query the host adapter for the event types
1478 * that are being logged.
1479 * @arg: User space argument
1480 *
1481 * Outputs: None.
1482 * Return: 0 if successful
1483 * -EFAULT if data unavailable
1484 * -ENODEV if no such device/adapter
1485 */
1486static int
1487mptctl_eventquery (unsigned long arg)
1488{
1489 struct mpt_ioctl_eventquery __user *uarg = (void __user *) arg;
1490 struct mpt_ioctl_eventquery karg;
1491 MPT_ADAPTER *ioc;
1492 int iocnum;
1493
1494 dctlprintk(("mptctl_eventquery called.\n"));
1495 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventquery))) {
1496 printk(KERN_ERR "%s@%d::mptctl_eventquery - "
1497 "Unable to read in mpt_ioctl_eventquery struct @ %p\n",
1498 __FILE__, __LINE__, uarg);
1499 return -EFAULT;
1500 }
1501
1502 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1503 (ioc == NULL)) {
1504 dctlprintk((KERN_ERR "%s::mptctl_eventquery() @%d - ioc%d not found!\n",
1505 __FILE__, __LINE__, iocnum));
1506 return -ENODEV;
1507 }
1508
5b5ef4f6 1509 karg.eventEntries = MPTCTL_EVENT_LOG_SIZE;
1da177e4
LT		 1510 karg.eventTypes = ioc->eventTypes;
1511
1512 /* Copy the data from kernel memory to user memory
1513 */
1514 if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_eventquery))) {
1515 printk(KERN_ERR "%s@%d::mptctl_eventquery - "
1516 "Unable to write out mpt_ioctl_eventquery struct @ %p\n",
1517 __FILE__, __LINE__, uarg);
1518 return -EFAULT;
1519 }
1520 return 0;
1521}
1522
1523/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1524static int
1525mptctl_eventenable (unsigned long arg)
1526{
1527 struct mpt_ioctl_eventenable __user *uarg = (void __user *) arg;
1528 struct mpt_ioctl_eventenable karg;
1529 MPT_ADAPTER *ioc;
1530 int iocnum;
1531
1532 dctlprintk(("mptctl_eventenable called.\n"));
1533 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventenable))) {
1534 printk(KERN_ERR "%s@%d::mptctl_eventenable - "
1535 "Unable to read in mpt_ioctl_eventenable struct @ %p\n",
1536 __FILE__, __LINE__, uarg);
1537 return -EFAULT;
1538 }
1539
1540 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1541 (ioc == NULL)) {
1542 dctlprintk((KERN_ERR "%s::mptctl_eventenable() @%d - ioc%d not found!\n",
1543 __FILE__, __LINE__, iocnum));
1544 return -ENODEV;
1545 }
1546
1547 if (ioc->events == NULL) {
1548 /* Have not yet allocated memory - do so now.
1549 */
1550 int sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
1551 ioc->events = kmalloc(sz, GFP_KERNEL);
1552 if (ioc->events == NULL) {
1553 printk(KERN_ERR MYNAM ": ERROR - Insufficient memory to add adapter!\n");
1554 return -ENOMEM;
1555 }
1556 memset(ioc->events, 0, sz);
1557 ioc->alloc_total += sz;
1558
1da177e4
LT		 1559 ioc->eventContext = 0;
1560 }
1561
1562 /* Update the IOC event logging flag.
1563 */
1564 ioc->eventTypes = karg.eventTypes;
1565
1566 return 0;
1567}
1568
1569/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1570static int
1571mptctl_eventreport (unsigned long arg)
1572{
1573 struct mpt_ioctl_eventreport __user *uarg = (void __user *) arg;
1574 struct mpt_ioctl_eventreport karg;
1575 MPT_ADAPTER *ioc;
1576 int iocnum;
1577 int numBytes, maxEvents, max;
1578
1579 dctlprintk(("mptctl_eventreport called.\n"));
1580 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventreport))) {
1581 printk(KERN_ERR "%s@%d::mptctl_eventreport - "
1582 "Unable to read in mpt_ioctl_eventreport struct @ %p\n",
1583 __FILE__, __LINE__, uarg);
1584 return -EFAULT;
1585 }
1586
1587 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1588 (ioc == NULL)) {
1589 dctlprintk((KERN_ERR "%s::mptctl_eventreport() @%d - ioc%d not found!\n",
1590 __FILE__, __LINE__, iocnum));
1591 return -ENODEV;
1592 }
1593
1594 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1595 maxEvents = numBytes/sizeof(MPT_IOCTL_EVENTS);
1596
1597
5b5ef4f6 1598 max = MPTCTL_EVENT_LOG_SIZE < maxEvents ? MPTCTL_EVENT_LOG_SIZE : maxEvents;
1da177e4
LT		 1599
1600 /* If fewer than 1 event is requested, there must have
1601 * been some type of error.
1602 */
1603 if ((max < 1) || !ioc->events)
1604 return -ENODATA;
1605
1606 /* Copy the data from kernel memory to user memory
1607 */
1608 numBytes = max * sizeof(MPT_IOCTL_EVENTS);
1609 if (copy_to_user(uarg->eventData, ioc->events, numBytes)) {
1610 printk(KERN_ERR "%s@%d::mptctl_eventreport - "
1611 "Unable to write out mpt_ioctl_eventreport struct @ %p\n",
1612 __FILE__, __LINE__, ioc->events);
1613 return -EFAULT;
1614 }
1615
1616 return 0;
1617}
1618
1619/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1620static int
1621mptctl_replace_fw (unsigned long arg)
1622{
1623 struct mpt_ioctl_replace_fw __user *uarg = (void __user *) arg;
1624 struct mpt_ioctl_replace_fw karg;
1625 MPT_ADAPTER *ioc;
1626 int iocnum;
1627 int newFwSize;
1628
1629 dctlprintk(("mptctl_replace_fw called.\n"));
1630 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_replace_fw))) {
1631 printk(KERN_ERR "%s@%d::mptctl_replace_fw - "
1632 "Unable to read in mpt_ioctl_replace_fw struct @ %p\n",
1633 __FILE__, __LINE__, uarg);
1634 return -EFAULT;
1635 }
1636
1637 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1638 (ioc == NULL)) {
1639 dctlprintk((KERN_ERR "%s::mptctl_replace_fw() @%d - ioc%d not found!\n",
1640 __FILE__, __LINE__, iocnum));
1641 return -ENODEV;
1642 }
1643
1644 /* If caching FW, Free the old FW image
1645 */
1646 if (ioc->cached_fw == NULL)
1647 return 0;
1648
1649 mpt_free_fw_memory(ioc);
1650
1651 /* Allocate memory for the new FW image
1652 */
1653 newFwSize = karg.newImageSize;
1654
1655 if (newFwSize & 0x01)
1656 newFwSize += 1;
1657 if (newFwSize & 0x02)
1658 newFwSize += 2;
1659
1660 mpt_alloc_fw_memory(ioc, newFwSize);
1661 if (ioc->cached_fw == NULL)
1662 return -ENOMEM;
1663
1664 /* Copy the data from user memory to kernel space
1665 */
1666 if (copy_from_user(ioc->cached_fw, uarg->newImage, newFwSize)) {
1667 printk(KERN_ERR "%s@%d::mptctl_replace_fw - "
1668 "Unable to read in mpt_ioctl_replace_fw image "
1669 "@ %p\n", __FILE__, __LINE__, uarg);
1670 mpt_free_fw_memory(ioc);
1671 return -EFAULT;
1672 }
1673
1674 /* Update IOCFactsReply
1675 */
1676 ioc->facts.FWImageSize = newFwSize;
1677 return 0;
1678}
1679
1680/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1681/* MPT IOCTL MPTCOMMAND function.
1682 * Cast the arg into the mpt_ioctl_mpt_command structure.
1683 *
1684 * Outputs: None.
1685 * Return: 0 if successful
1686 * -EBUSY if previous command timout and IOC reset is not complete.
1687 * -EFAULT if data unavailable
1688 * -ENODEV if no such device/adapter
1689 * -ETIME if timer expires
1690 * -ENOMEM if memory allocation error
1691 */
1692static int
1693mptctl_mpt_command (unsigned long arg)
1694{
1695 struct mpt_ioctl_command __user *uarg = (void __user *) arg;
1696 struct mpt_ioctl_command karg;
1697 MPT_ADAPTER *ioc;
1698 int iocnum;
1699 int rc;
1700
1701 dctlprintk(("mptctl_command called.\n"));
1702
1703 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_command))) {
1704 printk(KERN_ERR "%s@%d::mptctl_mpt_command - "
1705 "Unable to read in mpt_ioctl_command struct @ %p\n",
1706 __FILE__, __LINE__, uarg);
1707 return -EFAULT;
1708 }
1709
1710 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1711 (ioc == NULL)) {
1712 dctlprintk((KERN_ERR "%s::mptctl_mpt_command() @%d - ioc%d not found!\n",
1713 __FILE__, __LINE__, iocnum));
1714 return -ENODEV;
1715 }
1716
1717 rc = mptctl_do_mpt_command (karg, &uarg->MF);
1718
1719 return rc;
1720}
1721
1722/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1723/* Worker routine for the IOCTL MPTCOMMAND and MPTCOMMAND32 (sparc) commands.
1724 *
1725 * Outputs: None.
1726 * Return: 0 if successful
1727 * -EBUSY if previous command timout and IOC reset is not complete.
1728 * -EFAULT if data unavailable
1729 * -ENODEV if no such device/adapter
1730 * -ETIME if timer expires
1731 * -ENOMEM if memory allocation error
1732 * -EPERM if SCSI I/O and target is untagged
1733 */
1734static int
1735mptctl_do_mpt_command (struct mpt_ioctl_command karg, void __user *mfPtr)
1736{
1737 MPT_ADAPTER *ioc;
1738 MPT_FRAME_HDR *mf = NULL;
1739 MPIHeader_t *hdr;
1740 char *psge;
1741 struct buflist bufIn; /* data In buffer */
1742 struct buflist bufOut; /* data Out buffer */
1743 dma_addr_t dma_addr_in;
1744 dma_addr_t dma_addr_out;
1745 int sgSize = 0; /* Num SG elements */
1746 int iocnum, flagsLength;
1747 int sz, rc = 0;
1748 int msgContext;
1749 u16 req_idx;
1750 ulong timeout;
1751
1752 dctlprintk(("mptctl_do_mpt_command called.\n"));
1753 bufIn.kptr = bufOut.kptr = NULL;
1754
1755 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1756 (ioc == NULL)) {
1757 dctlprintk((KERN_ERR "%s::mptctl_do_mpt_command() @%d - ioc%d not found!\n",
1758 __FILE__, __LINE__, iocnum));
1759 return -ENODEV;
1760 }
1761 if (!ioc->ioctl) {
1762 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1763 "No memory available during driver init.\n",
1764 __FILE__, __LINE__);
1765 return -ENOMEM;
1766 } else if (ioc->ioctl->status & MPT_IOCTL_STATUS_DID_IOCRESET) {
1767 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1768 "Busy with IOC Reset \n", __FILE__, __LINE__);
1769 return -EBUSY;
1770 }
1771
1772 /* Verify that the final request frame will not be too large.
1773 */
1774 sz = karg.dataSgeOffset * 4;
1775 if (karg.dataInSize > 0)
1776 sz += sizeof(dma_addr_t) + sizeof(u32);
1777 if (karg.dataOutSize > 0)
1778 sz += sizeof(dma_addr_t) + sizeof(u32);
1779
1780 if (sz > ioc->req_sz) {
1781 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1782 "Request frame too large (%d) maximum (%d)\n",
1783 __FILE__, __LINE__, sz, ioc->req_sz);
1784 return -EFAULT;
1785 }
1786
1787 /* Get a free request frame and save the message context.
1788 */
1789 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
1790 return -EAGAIN;
1791
1792 hdr = (MPIHeader_t *) mf;
1793 msgContext = le32_to_cpu(hdr->MsgContext);
1794 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1795
1796 /* Copy the request frame
1797 * Reset the saved message context.
1798 * Request frame in user space
1799 */
1800 if (copy_from_user(mf, mfPtr, karg.dataSgeOffset * 4)) {
1801 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1802 "Unable to read MF from mpt_ioctl_command struct @ %p\n",
1803 __FILE__, __LINE__, mfPtr);
1804 rc = -EFAULT;
1805 goto done_free_mem;
1806 }
1807 hdr->MsgContext = cpu_to_le32(msgContext);
1808
1809
1810 /* Verify that this request is allowed.
1811 */
1812 switch (hdr->Function) {
1813 case MPI_FUNCTION_IOC_FACTS:
1814 case MPI_FUNCTION_PORT_FACTS:
1815 karg.dataOutSize = karg.dataInSize = 0;
1816 break;
1817
1818 case MPI_FUNCTION_CONFIG:
1819 case MPI_FUNCTION_FC_COMMON_TRANSPORT_SEND:
1820 case MPI_FUNCTION_FC_EX_LINK_SRVC_SEND:
1821 case MPI_FUNCTION_FW_UPLOAD:
1822 case MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR:
1823 case MPI_FUNCTION_FW_DOWNLOAD:
1824 case MPI_FUNCTION_FC_PRIMITIVE_SEND:
096f7a2a
ME		 1825 case MPI_FUNCTION_TOOLBOX:
1826 case MPI_FUNCTION_SAS_IO_UNIT_CONTROL:
1da177e4
LT		 1827 break;
1828
1829 case MPI_FUNCTION_SCSI_IO_REQUEST:
1830 if (ioc->sh) {
1831 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
c7c82987 1832 VirtTarget *pTarget = NULL;
1da177e4
LT		 1833 MPT_SCSI_HOST *hd = NULL;
1834 int qtag = MPI_SCSIIO_CONTROL_UNTAGGED;
1835 int scsidir = 0;
1836 int target = (int) pScsiReq->TargetID;
1837 int dataSize;
1838
1839 if ((target < 0) || (target >= ioc->sh->max_id)) {
1840 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1841 "Target ID out of bounds. \n",
1842 __FILE__, __LINE__);
1843 rc = -ENODEV;
1844 goto done_free_mem;
1845 }
1846
5f07e249
ME		 1847 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
1848 pScsiReq->MsgFlags |= mpt_msg_flags();
1849
1da177e4
LT		 1850
1851 /* verify that app has not requested
1852 * more sense data than driver
1853 * can provide, if so, reset this parameter
1854 * set the sense buffer pointer low address
1855 * update the control field to specify Q type
1856 */
1857 if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1858 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1859 else
1860 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1861
1862 pScsiReq->SenseBufferLowAddr =
1863 cpu_to_le32(ioc->sense_buf_low_dma
1864 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
1865
1866 if ((hd = (MPT_SCSI_HOST *) ioc->sh->hostdata)) {
1867 if (hd->Targets)
1868 pTarget = hd->Targets[target];
1869 }
1870
1871 if (pTarget &&(pTarget->tflags & MPT_TARGET_FLAGS_Q_YES))
1872 qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
1873
1874 /* Have the IOCTL driver set the direction based
1875 * on the dataOutSize (ordering issue with Sparc).
1876 */
1877 if (karg.dataOutSize > 0) {
1878 scsidir = MPI_SCSIIO_CONTROL_WRITE;
1879 dataSize = karg.dataOutSize;
1880 } else {
1881 scsidir = MPI_SCSIIO_CONTROL_READ;
1882 dataSize = karg.dataInSize;
1883 }
1884
1885 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
1886 pScsiReq->DataLength = cpu_to_le32(dataSize);
1887
1888 ioc->ioctl->reset = MPTCTL_RESET_OK;
1889 ioc->ioctl->target = target;
1890
1891 } else {
1892 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1893 "SCSI driver is not loaded. \n",
1894 __FILE__, __LINE__);
1895 rc = -EFAULT;
1896 goto done_free_mem;
1897 }
1898 break;
1899
096f7a2a
ME		 1900 case MPI_FUNCTION_SMP_PASSTHROUGH:
1901 /* Check mf->PassthruFlags to determine if
1902 * transfer is ImmediateMode or not.
1903 * Immediate mode returns data in the ReplyFrame.
1904 * Else, we are sending request and response data
1905 * in two SGLs at the end of the mf.
1906 */
1907 break;
1908
1909 case MPI_FUNCTION_SATA_PASSTHROUGH:
1910 if (!ioc->sh) {
1911 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1912 "SCSI driver is not loaded. \n",
1913 __FILE__, __LINE__);
1914 rc = -EFAULT;
1915 goto done_free_mem;
1916 }
1917 break;
1918
1da177e4
LT		 1919 case MPI_FUNCTION_RAID_ACTION:
1920 /* Just add a SGE
1921 */
1922 break;
1923
1924 case MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
1925 if (ioc->sh) {
1926 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
1927 int qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
1928 int scsidir = MPI_SCSIIO_CONTROL_READ;
1929 int dataSize;
1930
5f07e249
ME		 1931 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
1932 pScsiReq->MsgFlags |= mpt_msg_flags();
1933
1da177e4
LT		 1934
1935 /* verify that app has not requested
1936 * more sense data than driver
1937 * can provide, if so, reset this parameter
1938 * set the sense buffer pointer low address
1939 * update the control field to specify Q type
1940 */
1941 if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1942 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1943 else
1944 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1945
1946 pScsiReq->SenseBufferLowAddr =
1947 cpu_to_le32(ioc->sense_buf_low_dma
1948 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
1949
1950 /* All commands to physical devices are tagged
1951 */
1952
1953 /* Have the IOCTL driver set the direction based
1954 * on the dataOutSize (ordering issue with Sparc).
1955 */
1956 if (karg.dataOutSize > 0) {
1957 scsidir = MPI_SCSIIO_CONTROL_WRITE;
1958 dataSize = karg.dataOutSize;
1959 } else {
1960 scsidir = MPI_SCSIIO_CONTROL_READ;
1961 dataSize = karg.dataInSize;
1962 }
1963
1964 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
1965 pScsiReq->DataLength = cpu_to_le32(dataSize);
1966
1967 ioc->ioctl->reset = MPTCTL_RESET_OK;
1968 ioc->ioctl->target = pScsiReq->TargetID;
1969 } else {
1970 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1971 "SCSI driver is not loaded. \n",
1972 __FILE__, __LINE__);
1973 rc = -EFAULT;
1974 goto done_free_mem;
1975 }
1976 break;
1977
1978 case MPI_FUNCTION_SCSI_TASK_MGMT:
1979 {
1980 MPT_SCSI_HOST *hd = NULL;
1981 if ((ioc->sh == NULL) || ((hd = (MPT_SCSI_HOST *)ioc->sh->hostdata) == NULL)) {
1982 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1983 "SCSI driver not loaded or SCSI host not found. \n",
1984 __FILE__, __LINE__);
1985 rc = -EFAULT;
1986 goto done_free_mem;
1987 } else if (mptctl_set_tm_flags(hd) != 0) {
1988 rc = -EPERM;
1989 goto done_free_mem;
1990 }
1991 }
1992 break;
1993
1994 case MPI_FUNCTION_IOC_INIT:
1995 {
1996 IOCInit_t *pInit = (IOCInit_t *) mf;
1997 u32 high_addr, sense_high;
1998
1999 /* Verify that all entries in the IOC INIT match
2000 * existing setup (and in LE format).
2001 */
2002 if (sizeof(dma_addr_t) == sizeof(u64)) {
2003 high_addr = cpu_to_le32((u32)((u64)ioc->req_frames_dma >> 32));
2004 sense_high= cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
2005 } else {
2006 high_addr = 0;
2007 sense_high= 0;
2008 }
2009
2010 if ((pInit->Flags != 0) || (pInit->MaxDevices != ioc->facts.MaxDevices) ||
2011 (pInit->MaxBuses != ioc->facts.MaxBuses) ||
2012 (pInit->ReplyFrameSize != cpu_to_le16(ioc->reply_sz)) ||
2013 (pInit->HostMfaHighAddr != high_addr) ||
2014 (pInit->SenseBufferHighAddr != sense_high)) {
2015 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2016 "IOC_INIT issued with 1 or more incorrect parameters. Rejected.\n",
2017 __FILE__, __LINE__);
2018 rc = -EFAULT;
2019 goto done_free_mem;
2020 }
2021 }
2022 break;
2023 default:
2024 /*
2025 * MPI_FUNCTION_PORT_ENABLE
2026 * MPI_FUNCTION_TARGET_CMD_BUFFER_POST
2027 * MPI_FUNCTION_TARGET_ASSIST
2028 * MPI_FUNCTION_TARGET_STATUS_SEND
2029 * MPI_FUNCTION_TARGET_MODE_ABORT
2030 * MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET
2031 * MPI_FUNCTION_IO_UNIT_RESET
2032 * MPI_FUNCTION_HANDSHAKE
2033 * MPI_FUNCTION_REPLY_FRAME_REMOVAL
2034 * MPI_FUNCTION_EVENT_NOTIFICATION
2035 * (driver handles event notification)
2036 * MPI_FUNCTION_EVENT_ACK
2037 */
2038
2039 /* What to do with these??? CHECK ME!!!
2040 MPI_FUNCTION_FC_LINK_SRVC_BUF_POST
2041 MPI_FUNCTION_FC_LINK_SRVC_RSP
2042 MPI_FUNCTION_FC_ABORT
2043 MPI_FUNCTION_LAN_SEND
2044 MPI_FUNCTION_LAN_RECEIVE
2045 MPI_FUNCTION_LAN_RESET
2046 */
2047
2048 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2049 "Illegal request (function 0x%x) \n",
2050 __FILE__, __LINE__, hdr->Function);
2051 rc = -EFAULT;
2052 goto done_free_mem;
2053 }
2054
2055 /* Add the SGL ( at most one data in SGE and one data out SGE )
2056 * In the case of two SGE's - the data out (write) will always
2057 * preceede the data in (read) SGE. psgList is used to free the
2058 * allocated memory.
2059 */
2060 psge = (char *) (((int *) mf) + karg.dataSgeOffset);
2061 flagsLength = 0;
2062
2063 /* bufIn and bufOut are used for user to kernel space transfers
2064 */
2065 bufIn.kptr = bufOut.kptr = NULL;
2066 bufIn.len = bufOut.len = 0;
2067
2068 if (karg.dataOutSize > 0)
2069 sgSize ++;
2070
2071 if (karg.dataInSize > 0)
2072 sgSize ++;
2073
2074 if (sgSize > 0) {
2075
2076 /* Set up the dataOut memory allocation */
2077 if (karg.dataOutSize > 0) {
2078 if (karg.dataInSize > 0) {
2079 flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2080 MPI_SGE_FLAGS_END_OF_BUFFER |
2081 MPI_SGE_FLAGS_DIRECTION |
2082 mpt_addr_size() )
2083 << MPI_SGE_FLAGS_SHIFT;
2084 } else {
2085 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
2086 }
2087 flagsLength |= karg.dataOutSize;
2088 bufOut.len = karg.dataOutSize;
2089 bufOut.kptr = pci_alloc_consistent(
2090 ioc->pcidev, bufOut.len, &dma_addr_out);
2091
2092 if (bufOut.kptr == NULL) {
2093 rc = -ENOMEM;
2094 goto done_free_mem;
2095 } else {
2096 /* Set up this SGE.
2097 * Copy to MF and to sglbuf
2098 */
2099 mpt_add_sge(psge, flagsLength, dma_addr_out);
2100 psge += (sizeof(u32) + sizeof(dma_addr_t));
2101
2102 /* Copy user data to kernel space.
2103 */
2104 if (copy_from_user(bufOut.kptr,
2105 karg.dataOutBufPtr,
2106 bufOut.len)) {
2107 printk(KERN_ERR
2108 "%s@%d::mptctl_do_mpt_command - Unable "
2109 "to read user data "
2110 "struct @ %p\n",
2111 __FILE__, __LINE__,karg.dataOutBufPtr);
2112 rc = -EFAULT;
2113 goto done_free_mem;
2114 }
2115 }
2116 }
2117
2118 if (karg.dataInSize > 0) {
2119 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
2120 flagsLength |= karg.dataInSize;
2121
2122 bufIn.len = karg.dataInSize;
2123 bufIn.kptr = pci_alloc_consistent(ioc->pcidev,
2124 bufIn.len, &dma_addr_in);
2125
2126 if (bufIn.kptr == NULL) {
2127 rc = -ENOMEM;
2128 goto done_free_mem;
2129 } else {
2130 /* Set up this SGE
2131 * Copy to MF and to sglbuf
2132 */
2133 mpt_add_sge(psge, flagsLength, dma_addr_in);
2134 }
2135 }
2136 } else {
2137 /* Add a NULL SGE
2138 */
2139 mpt_add_sge(psge, flagsLength, (dma_addr_t) -1);
2140 }
2141
2142 ioc->ioctl->wait_done = 0;
2143 if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT) {
2144
2145 DBG_DUMP_TM_REQUEST_FRAME((u32 *)mf);
2146
2147 if (mpt_send_handshake_request(mptctl_id, ioc,
2148 sizeof(SCSITaskMgmt_t), (u32*)mf,
2149 CAN_SLEEP) != 0) {
2150 dfailprintk((MYIOC_s_ERR_FMT "_send_handshake FAILED!"
2151 " (ioc %p, mf %p) \n", ioc->name,
2152 ioc, mf));
2153 mptctl_free_tm_flags(ioc);
2154 rc = -ENODATA;
2155 goto done_free_mem;
2156 }
2157
2158 } else
2159 mpt_put_msg_frame(mptctl_id, ioc, mf);
2160
2161 /* Now wait for the command to complete */
2162 timeout = (karg.timeout > 0) ? karg.timeout : MPT_IOCTL_DEFAULT_TIMEOUT;
86a7dcaa 2163 timeout = wait_event_timeout(mptctl_wait,
1da177e4
LT		 2164 ioc->ioctl->wait_done == 1,
2165 HZ*timeout);
2166
2167 if(timeout <=0 && (ioc->ioctl->wait_done != 1 )) {
2168 /* Now we need to reset the board */
2169
2170 if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT)
2171 mptctl_free_tm_flags(ioc);
2172
2173 mptctl_timeout_expired(ioc->ioctl);
2174 rc = -ENODATA;
2175 goto done_free_mem;
2176 }
2177
2178 mf = NULL;
2179
2180 /* If a valid reply frame, copy to the user.
2181 * Offset 2: reply length in U32's
2182 */
2183 if (ioc->ioctl->status & MPT_IOCTL_STATUS_RF_VALID) {
2184 if (karg.maxReplyBytes < ioc->reply_sz) {
2185 sz = min(karg.maxReplyBytes, 4*ioc->ioctl->ReplyFrame[2]);
2186 } else {
2187 sz = min(ioc->reply_sz, 4*ioc->ioctl->ReplyFrame[2]);
2188 }
2189
2190 if (sz > 0) {
2191 if (copy_to_user(karg.replyFrameBufPtr,
2192 &ioc->ioctl->ReplyFrame, sz)){
2193 printk(KERN_ERR
2194 "%s@%d::mptctl_do_mpt_command - "
2195 "Unable to write out reply frame %p\n",
2196 __FILE__, __LINE__, karg.replyFrameBufPtr);
2197 rc = -ENODATA;
2198 goto done_free_mem;
2199 }
2200 }
2201 }
2202
2203 /* If valid sense data, copy to user.
2204 */
2205 if (ioc->ioctl->status & MPT_IOCTL_STATUS_SENSE_VALID) {
2206 sz = min(karg.maxSenseBytes, MPT_SENSE_BUFFER_SIZE);
2207 if (sz > 0) {
2208 if (copy_to_user(karg.senseDataPtr, ioc->ioctl->sense, sz)) {
2209 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2210 "Unable to write sense data to user %p\n",
2211 __FILE__, __LINE__,
2212 karg.senseDataPtr);
2213 rc = -ENODATA;
2214 goto done_free_mem;
2215 }
2216 }
2217 }
2218
2219 /* If the overall status is _GOOD and data in, copy data
2220 * to user.
2221 */
2222 if ((ioc->ioctl->status & MPT_IOCTL_STATUS_COMMAND_GOOD) &&
2223 (karg.dataInSize > 0) && (bufIn.kptr)) {
2224
2225 if (copy_to_user(karg.dataInBufPtr,
2226 bufIn.kptr, karg.dataInSize)) {
2227 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2228 "Unable to write data to user %p\n",
2229 __FILE__, __LINE__,
2230 karg.dataInBufPtr);
2231 rc = -ENODATA;
2232 }
2233 }
2234
2235done_free_mem:
2236
2237 ioc->ioctl->status &= ~(MPT_IOCTL_STATUS_COMMAND_GOOD |
2238 MPT_IOCTL_STATUS_SENSE_VALID |
2239 MPT_IOCTL_STATUS_RF_VALID );
2240
2241 /* Free the allocated memory.
2242 */
2243 if (bufOut.kptr != NULL) {
2244 pci_free_consistent(ioc->pcidev,
2245 bufOut.len, (void *) bufOut.kptr, dma_addr_out);
2246 }
2247
2248 if (bufIn.kptr != NULL) {
2249 pci_free_consistent(ioc->pcidev,
2250 bufIn.len, (void *) bufIn.kptr, dma_addr_in);
2251 }
2252
2253 /* mf is null if command issued successfully
2254 * otherwise, failure occured after mf acquired.
2255 */
2256 if (mf)
2257 mpt_free_msg_frame(ioc, mf);
2258
2259 return rc;
2260}
2261
2262/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2263/* Prototype Routine for the HP HOST INFO command.
2264 *
2265 * Outputs: None.
2266 * Return: 0 if successful
2267 * -EFAULT if data unavailable
2268 * -EBUSY if previous command timout and IOC reset is not complete.
2269 * -ENODEV if no such device/adapter
2270 * -ETIME if timer expires
2271 * -ENOMEM if memory allocation error
2272 */
2273static int
2274mptctl_hp_hostinfo(unsigned long arg, unsigned int data_size)
2275{
2276 hp_host_info_t __user *uarg = (void __user *) arg;
2277 MPT_ADAPTER *ioc;
2278 struct pci_dev *pdev;
592f9c2f 2279 char *pbuf=NULL;
1da177e4
LT		 2280 dma_addr_t buf_dma;
2281 hp_host_info_t karg;
2282 CONFIGPARMS cfg;
2283 ConfigPageHeader_t hdr;
2284 int iocnum;
2285 int rc, cim_rev;
592f9c2f
ME		 2286 ToolboxIstwiReadWriteRequest_t *IstwiRWRequest;
2287 MPT_FRAME_HDR *mf = NULL;
2288 MPIHeader_t *mpi_hdr;
1da177e4
LT		 2289
2290 dctlprintk((": mptctl_hp_hostinfo called.\n"));
2291 /* Reset long to int. Should affect IA64 and SPARC only
2292 */
2293 if (data_size == sizeof(hp_host_info_t))
2294 cim_rev = 1;
2295 else if (data_size == sizeof(hp_host_info_rev0_t))
2296 cim_rev = 0; /* obsolete */
2297 else
2298 return -EFAULT;
2299
2300 if (copy_from_user(&karg, uarg, sizeof(hp_host_info_t))) {
2301 printk(KERN_ERR "%s@%d::mptctl_hp_host_info - "
2302 "Unable to read in hp_host_info struct @ %p\n",
2303 __FILE__, __LINE__, uarg);
2304 return -EFAULT;
2305 }
2306
2307 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2308 (ioc == NULL)) {
2309 dctlprintk((KERN_ERR "%s::mptctl_hp_hostinfo() @%d - ioc%d not found!\n",
2310 __FILE__, __LINE__, iocnum));
2311 return -ENODEV;
2312 }
2313
2314 /* Fill in the data and return the structure to the calling
2315 * program
2316 */
2317 pdev = (struct pci_dev *) ioc->pcidev;
2318
2319 karg.vendor = pdev->vendor;
2320 karg.device = pdev->device;
2321 karg.subsystem_id = pdev->subsystem_device;
2322 karg.subsystem_vendor = pdev->subsystem_vendor;
2323 karg.devfn = pdev->devfn;
2324 karg.bus = pdev->bus->number;
2325
2326 /* Save the SCSI host no. if
2327 * SCSI driver loaded
2328 */
2329 if (ioc->sh != NULL)
2330 karg.host_no = ioc->sh->host_no;
2331 else
2332 karg.host_no = -1;
2333
2334 /* Reformat the fw_version into a string
2335 */
2336 karg.fw_version[0] = ioc->facts.FWVersion.Struct.Major >= 10 ?
2337 ((ioc->facts.FWVersion.Struct.Major / 10) + '0') : '0';
2338 karg.fw_version[1] = (ioc->facts.FWVersion.Struct.Major % 10 ) + '0';
2339 karg.fw_version[2] = '.';
2340 karg.fw_version[3] = ioc->facts.FWVersion.Struct.Minor >= 10 ?
2341 ((ioc->facts.FWVersion.Struct.Minor / 10) + '0') : '0';
2342 karg.fw_version[4] = (ioc->facts.FWVersion.Struct.Minor % 10 ) + '0';
2343 karg.fw_version[5] = '.';
2344 karg.fw_version[6] = ioc->facts.FWVersion.Struct.Unit >= 10 ?
2345 ((ioc->facts.FWVersion.Struct.Unit / 10) + '0') : '0';
2346 karg.fw_version[7] = (ioc->facts.FWVersion.Struct.Unit % 10 ) + '0';
2347 karg.fw_version[8] = '.';
2348 karg.fw_version[9] = ioc->facts.FWVersion.Struct.Dev >= 10 ?
2349 ((ioc->facts.FWVersion.Struct.Dev / 10) + '0') : '0';
2350 karg.fw_version[10] = (ioc->facts.FWVersion.Struct.Dev % 10 ) + '0';
2351 karg.fw_version[11] = '\0';
2352
2353 /* Issue a config request to get the device serial number
2354 */
2355 hdr.PageVersion = 0;
2356 hdr.PageLength = 0;
2357 hdr.PageNumber = 0;
2358 hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
69218ee5 2359 cfg.cfghdr.hdr = &hdr;
1da177e4
LT		 2360 cfg.physAddr = -1;
2361 cfg.pageAddr = 0;
2362 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2363 cfg.dir = 0; /* read */
2364 cfg.timeout = 10;
2365
2366 strncpy(karg.serial_number, " ", 24);
2367 if (mpt_config(ioc, &cfg) == 0) {
69218ee5 2368 if (cfg.cfghdr.hdr->PageLength > 0) {
1da177e4
LT		 2369 /* Issue the second config page request */
2370 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2371
2372 pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
2373 if (pbuf) {
2374 cfg.physAddr = buf_dma;
2375 if (mpt_config(ioc, &cfg) == 0) {
2376 ManufacturingPage0_t *pdata = (ManufacturingPage0_t *) pbuf;
2377 if (strlen(pdata->BoardTracerNumber) > 1) {
2378 strncpy(karg.serial_number, pdata->BoardTracerNumber, 24);
2379 karg.serial_number[24-1]='\0';
2380 }
2381 }
2382 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
2383 pbuf = NULL;
2384 }
2385 }
2386 }
2387 rc = mpt_GetIocState(ioc, 1);
2388 switch (rc) {
2389 case MPI_IOC_STATE_OPERATIONAL:
2390 karg.ioc_status = HP_STATUS_OK;
2391 break;
2392
2393 case MPI_IOC_STATE_FAULT:
2394 karg.ioc_status = HP_STATUS_FAILED;
2395 break;
2396
2397 case MPI_IOC_STATE_RESET:
2398 case MPI_IOC_STATE_READY:
2399 default:
2400 karg.ioc_status = HP_STATUS_OTHER;
2401 break;
2402 }
2403
2404 karg.base_io_addr = pci_resource_start(pdev, 0);
2405
9cc1cfbc 2406 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
1da177e4
LT		 2407 karg.bus_phys_width = HP_BUS_WIDTH_UNK;
2408 else
2409 karg.bus_phys_width = HP_BUS_WIDTH_16;
2410
2411 karg.hard_resets = 0;
2412 karg.soft_resets = 0;
2413 karg.timeouts = 0;
2414 if (ioc->sh != NULL) {
2415 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)ioc->sh->hostdata;
2416
2417 if (hd && (cim_rev == 1)) {
2418 karg.hard_resets = hd->hard_resets;
2419 karg.soft_resets = hd->soft_resets;
2420 karg.timeouts = hd->timeouts;
2421 }
2422 }
2423
592f9c2f
ME		 2424 /*
2425 * Gather ISTWI(Industry Standard Two Wire Interface) Data
2426 */
2427 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
2428 dfailprintk((MYIOC_s_WARN_FMT "%s, no msg frames!!\n",
2429 ioc->name,__FUNCTION__));
2430 goto out;
2431 }
2432
2433 IstwiRWRequest = (ToolboxIstwiReadWriteRequest_t *)mf;
2434 mpi_hdr = (MPIHeader_t *) mf;
2435 memset(IstwiRWRequest,0,sizeof(ToolboxIstwiReadWriteRequest_t));
2436 IstwiRWRequest->Function = MPI_FUNCTION_TOOLBOX;
2437 IstwiRWRequest->Tool = MPI_TOOLBOX_ISTWI_READ_WRITE_TOOL;
2438 IstwiRWRequest->MsgContext = mpi_hdr->MsgContext;
2439 IstwiRWRequest->Flags = MPI_TB_ISTWI_FLAGS_READ;
2440 IstwiRWRequest->NumAddressBytes = 0x01;
2441 IstwiRWRequest->DataLength = cpu_to_le16(0x04);
2442 if (pdev->devfn & 1)
2443 IstwiRWRequest->DeviceAddr = 0xB2;
2444 else
2445 IstwiRWRequest->DeviceAddr = 0xB0;
2446
1da177e4 2447 pbuf = pci_alloc_consistent(ioc->pcidev, 4, &buf_dma);
592f9c2f
ME		 2448 if (!pbuf)
2449 goto out;
2450 mpt_add_sge((char *)&IstwiRWRequest->SGL,
2451 (MPT_SGE_FLAGS_SSIMPLE_READ|4), buf_dma);
2452
2453 ioc->ioctl->wait_done = 0;
2454 mpt_put_msg_frame(mptctl_id, ioc, mf);
2455
2456 rc = wait_event_timeout(mptctl_wait,
2457 ioc->ioctl->wait_done == 1,
2458 HZ*MPT_IOCTL_DEFAULT_TIMEOUT /* 10 sec */);
2459
2460 if(rc <=0 && (ioc->ioctl->wait_done != 1 )) {
2461 /*
2462 * Now we need to reset the board
2463 */
2464 mpt_free_msg_frame(ioc, mf);
2465 mptctl_timeout_expired(ioc->ioctl);
2466 goto out;
1da177e4
LT		 2467 }
2468
592f9c2f
ME		 2469 /*
2470 *ISTWI Data Definition
2471 * pbuf[0] = FW_VERSION = 0x4
2472 * pbuf[1] = Bay Count = 6 or 4 or 2, depending on
2473 * the config, you should be seeing one out of these three values
2474 * pbuf[2] = Drive Installed Map = bit pattern depend on which
2475 * bays have drives in them
2476 * pbuf[3] = Checksum (0x100 = (byte0 + byte2 + byte3)
2477 */
2478 if (ioc->ioctl->status & MPT_IOCTL_STATUS_RF_VALID)
2479 karg.rsvd = *(u32 *)pbuf;
2480
2481 out:
2482 if (pbuf)
2483 pci_free_consistent(ioc->pcidev, 4, pbuf, buf_dma);
2484
1da177e4
LT		 2485 /* Copy the data from kernel memory to user memory
2486 */
2487 if (copy_to_user((char __user *)arg, &karg, sizeof(hp_host_info_t))) {
2488 printk(KERN_ERR "%s@%d::mptctl_hpgethostinfo - "
2489 "Unable to write out hp_host_info @ %p\n",
2490 __FILE__, __LINE__, uarg);
2491 return -EFAULT;
2492 }
2493
2494 return 0;
2495
2496}
2497
2498/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2499/* Prototype Routine for the HP TARGET INFO command.
2500 *
2501 * Outputs: None.
2502 * Return: 0 if successful
2503 * -EFAULT if data unavailable
2504 * -EBUSY if previous command timout and IOC reset is not complete.
2505 * -ENODEV if no such device/adapter
2506 * -ETIME if timer expires
2507 * -ENOMEM if memory allocation error
2508 */
2509static int
2510mptctl_hp_targetinfo(unsigned long arg)
2511{
2512 hp_target_info_t __user *uarg = (void __user *) arg;
2513 SCSIDevicePage0_t *pg0_alloc;
2514 SCSIDevicePage3_t *pg3_alloc;
2515 MPT_ADAPTER *ioc;
2516 MPT_SCSI_HOST *hd = NULL;
2517 hp_target_info_t karg;
2518 int iocnum;
2519 int data_sz;
2520 dma_addr_t page_dma;
2521 CONFIGPARMS cfg;
2522 ConfigPageHeader_t hdr;
2523 int tmp, np, rc = 0;
2524
2525 dctlprintk((": mptctl_hp_targetinfo called.\n"));
2526 if (copy_from_user(&karg, uarg, sizeof(hp_target_info_t))) {
2527 printk(KERN_ERR "%s@%d::mptctl_hp_targetinfo - "
2528 "Unable to read in hp_host_targetinfo struct @ %p\n",
2529 __FILE__, __LINE__, uarg);
2530 return -EFAULT;
2531 }
2532
2533 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2534 (ioc == NULL)) {
2535 dctlprintk((KERN_ERR "%s::mptctl_hp_targetinfo() @%d - ioc%d not found!\n",
2536 __FILE__, __LINE__, iocnum));
2537 return -ENODEV;
2538 }
2539
2540 /* There is nothing to do for FCP parts.
2541 */
9cc1cfbc 2542 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
1da177e4
LT		 2543 return 0;
2544
2545 if ((ioc->spi_data.sdp0length == 0) || (ioc->sh == NULL))
2546 return 0;
2547
2548 if (ioc->sh->host_no != karg.hdr.host)
2549 return -ENODEV;
2550
2551 /* Get the data transfer speeds
2552 */
2553 data_sz = ioc->spi_data.sdp0length * 4;
2554 pg0_alloc = (SCSIDevicePage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
2555 if (pg0_alloc) {
2556 hdr.PageVersion = ioc->spi_data.sdp0version;
2557 hdr.PageLength = data_sz;
2558 hdr.PageNumber = 0;
2559 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2560
69218ee5 2561 cfg.cfghdr.hdr = &hdr;
1da177e4
LT		 2562 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2563 cfg.dir = 0;
2564 cfg.timeout = 0;
2565 cfg.physAddr = page_dma;
2566
2567 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2568
2569 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2570 np = le32_to_cpu(pg0_alloc->NegotiatedParameters);
2571 karg.negotiated_width = np & MPI_SCSIDEVPAGE0_NP_WIDE ?
2572 HP_BUS_WIDTH_16 : HP_BUS_WIDTH_8;
2573
2574 if (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) {
2575 tmp = (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> 8;
2576 if (tmp < 0x09)
2577 karg.negotiated_speed = HP_DEV_SPEED_ULTRA320;
2578 else if (tmp <= 0x09)
2579 karg.negotiated_speed = HP_DEV_SPEED_ULTRA160;
2580 else if (tmp <= 0x0A)
2581 karg.negotiated_speed = HP_DEV_SPEED_ULTRA2;
2582 else if (tmp <= 0x0C)
2583 karg.negotiated_speed = HP_DEV_SPEED_ULTRA;
2584 else if (tmp <= 0x25)
2585 karg.negotiated_speed = HP_DEV_SPEED_FAST;
2586 else
2587 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2588 } else
2589 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2590 }
2591
2592 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg0_alloc, page_dma);
2593 }
2594
2595 /* Set defaults
2596 */
2597 karg.message_rejects = -1;
2598 karg.phase_errors = -1;
2599 karg.parity_errors = -1;
2600 karg.select_timeouts = -1;
2601
2602 /* Get the target error parameters
2603 */
2604 hdr.PageVersion = 0;
2605 hdr.PageLength = 0;
2606 hdr.PageNumber = 3;
2607 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2608
69218ee5 2609 cfg.cfghdr.hdr = &hdr;
1da177e4
LT		 2610 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2611 cfg.dir = 0;
2612 cfg.timeout = 0;
2613 cfg.physAddr = -1;
69218ee5 2614 if ((mpt_config(ioc, &cfg) == 0) && (cfg.cfghdr.hdr->PageLength > 0)) {
1da177e4
LT		 2615 /* Issue the second config page request */
2616 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
69218ee5 2617 data_sz = (int) cfg.cfghdr.hdr->PageLength * 4;
1da177e4
LT		 2618 pg3_alloc = (SCSIDevicePage3_t *) pci_alloc_consistent(
2619 ioc->pcidev, data_sz, &page_dma);
2620 if (pg3_alloc) {
2621 cfg.physAddr = page_dma;
2622 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2623 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2624 karg.message_rejects = (u32) le16_to_cpu(pg3_alloc->MsgRejectCount);
2625 karg.phase_errors = (u32) le16_to_cpu(pg3_alloc->PhaseErrorCount);
2626 karg.parity_errors = (u32) le16_to_cpu(pg3_alloc->ParityErrorCount);
2627 }
2628 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg3_alloc, page_dma);
2629 }
2630 }
2631 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
2632 if (hd != NULL)
2633 karg.select_timeouts = hd->sel_timeout[karg.hdr.id];
2634
2635 /* Copy the data from kernel memory to user memory
2636 */
2637 if (copy_to_user((char __user *)arg, &karg, sizeof(hp_target_info_t))) {
2638 printk(KERN_ERR "%s@%d::mptctl_hp_target_info - "
2639 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
2640 __FILE__, __LINE__, uarg);
2641 return -EFAULT;
2642 }
2643
2644 return 0;
2645}
2646
2647/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2648
2649static struct file_operations mptctl_fops = {
2650 .owner = THIS_MODULE,
2651 .llseek = no_llseek,
2652 .unlocked_ioctl = mptctl_ioctl,
2653#ifdef CONFIG_COMPAT
2654 .compat_ioctl = compat_mpctl_ioctl,
2655#endif
2656};
2657
2658static struct miscdevice mptctl_miscdev = {
2659 MPT_MINOR,
2660 MYNAM,
2661 &mptctl_fops
2662};
2663
2664/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2665
2666#ifdef CONFIG_COMPAT
2667
1da177e4
LT		 2668static int
2669compat_mptfwxfer_ioctl(struct file *filp, unsigned int cmd,
2670 unsigned long arg)
2671{
2672 struct mpt_fw_xfer32 kfw32;
2673 struct mpt_fw_xfer kfw;
2674 MPT_ADAPTER *iocp = NULL;
2675 int iocnum, iocnumX;
2676 int nonblock = (filp->f_flags & O_NONBLOCK);
2677 int ret;
2678
2679 dctlprintk((KERN_INFO MYNAM "::compat_mptfwxfer_ioctl() called\n"));
2680
2681 if (copy_from_user(&kfw32, (char __user *)arg, sizeof(kfw32)))
2682 return -EFAULT;
2683
2684 /* Verify intended MPT adapter */
2685 iocnumX = kfw32.iocnum & 0xFF;
2686 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2687 (iocp == NULL)) {
2688 dctlprintk((KERN_ERR MYNAM "::compat_mptfwxfer_ioctl @%d - ioc%d not found!\n",
2689 __LINE__, iocnumX));
2690 return -ENODEV;
2691 }
2692
2693 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2694 return ret;
2695
2696 kfw.iocnum = iocnum;
2697 kfw.fwlen = kfw32.fwlen;
2698 kfw.bufp = compat_ptr(kfw32.bufp);
2699
2700 ret = mptctl_do_fw_download(kfw.iocnum, kfw.bufp, kfw.fwlen);
2701
eeb846ce 2702 mutex_unlock(&iocp->ioctl->ioctl_mutex);
1da177e4
LT		 2703
2704 return ret;
2705}
2706
2707static int
2708compat_mpt_command(struct file *filp, unsigned int cmd,
2709 unsigned long arg)
2710{
2711 struct mpt_ioctl_command32 karg32;
2712 struct mpt_ioctl_command32 __user *uarg = (struct mpt_ioctl_command32 __user *) arg;
2713 struct mpt_ioctl_command karg;
2714 MPT_ADAPTER *iocp = NULL;
2715 int iocnum, iocnumX;
2716 int nonblock = (filp->f_flags & O_NONBLOCK);
2717 int ret;
2718
2719 dctlprintk((KERN_INFO MYNAM "::compat_mpt_command() called\n"));
2720
2721 if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32)))
2722 return -EFAULT;
2723
2724 /* Verify intended MPT adapter */
2725 iocnumX = karg32.hdr.iocnum & 0xFF;
2726 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2727 (iocp == NULL)) {
2728 dctlprintk((KERN_ERR MYNAM "::compat_mpt_command @%d - ioc%d not found!\n",
2729 __LINE__, iocnumX));
2730 return -ENODEV;
2731 }
2732
2733 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2734 return ret;
2735
2736 /* Copy data to karg */
2737 karg.hdr.iocnum = karg32.hdr.iocnum;
2738 karg.hdr.port = karg32.hdr.port;
2739 karg.timeout = karg32.timeout;
2740 karg.maxReplyBytes = karg32.maxReplyBytes;
2741
2742 karg.dataInSize = karg32.dataInSize;
2743 karg.dataOutSize = karg32.dataOutSize;
2744 karg.maxSenseBytes = karg32.maxSenseBytes;
2745 karg.dataSgeOffset = karg32.dataSgeOffset;
2746
2747 karg.replyFrameBufPtr = (char __user *)(unsigned long)karg32.replyFrameBufPtr;
2748 karg.dataInBufPtr = (char __user *)(unsigned long)karg32.dataInBufPtr;
2749 karg.dataOutBufPtr = (char __user *)(unsigned long)karg32.dataOutBufPtr;
2750 karg.senseDataPtr = (char __user *)(unsigned long)karg32.senseDataPtr;
2751
2752 /* Pass new structure to do_mpt_command
2753 */
2754 ret = mptctl_do_mpt_command (karg, &uarg->MF);
2755
eeb846ce 2756 mutex_unlock(&iocp->ioctl->ioctl_mutex);
1da177e4
LT		 2757
2758 return ret;
2759}
2760
2761static long compat_mpctl_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
2762{
2763 long ret;
2764 lock_kernel();
2765 switch (cmd) {
2766 case MPTIOCINFO:
2767 case MPTIOCINFO1:
2768 case MPTIOCINFO2:
2769 case MPTTARGETINFO:
2770 case MPTEVENTQUERY:
2771 case MPTEVENTENABLE:
2772 case MPTEVENTREPORT:
2773 case MPTHARDRESET:
2774 case HP_GETHOSTINFO:
2775 case HP_GETTARGETINFO:
2776 case MPTTEST:
2777 ret = __mptctl_ioctl(f, cmd, arg);
2778 break;
2779 case MPTCOMMAND32:
2780 ret = compat_mpt_command(f, cmd, arg);
2781 break;
2782 case MPTFWDOWNLOAD32:
2783 ret = compat_mptfwxfer_ioctl(f, cmd, arg);
2784 break;
2785 default:
2786 ret = -ENOIOCTLCMD;
2787 break;
2788 }
2789 unlock_kernel();
2790 return ret;
2791}
2792
2793#endif
2794
2795
2796/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2797/*
2798 * mptctl_probe - Installs ioctl devices per bus.
2799 * @pdev: Pointer to pci_dev structure
2800 *
2801 * Returns 0 for success, non-zero for failure.
2802 *
2803 */
2804
2805static int
2806mptctl_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2807{
2808 int err;
2809 int sz;
2810 u8 *mem;
2811 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
2812
2813 /*
2814 * Allocate and inite a MPT_IOCTL structure
2815 */
2816 sz = sizeof (MPT_IOCTL);
2817 mem = kmalloc(sz, GFP_KERNEL);
2818 if (mem == NULL) {
2819 err = -ENOMEM;
2820 goto out_fail;
2821 }
2822
2823 memset(mem, 0, sz);
2824 ioc->ioctl = (MPT_IOCTL *) mem;
2825 ioc->ioctl->ioc = ioc;
eeb846ce 2826 mutex_init(&ioc->ioctl->ioctl_mutex);
1da177e4
LT		 2827 return 0;
2828
2829out_fail:
2830
2831 mptctl_remove(pdev);
2832 return err;
2833}
2834
2835/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2836/*
2837 * mptctl_remove - Removed ioctl devices
2838 * @pdev: Pointer to pci_dev structure
2839 *
2840 *
2841 */
2842static void
2843mptctl_remove(struct pci_dev *pdev)
2844{
2845 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
2846
2847 kfree ( ioc->ioctl );
2848}
2849
2850static struct mpt_pci_driver mptctl_driver = {
2851 .probe = mptctl_probe,
2852 .remove = mptctl_remove,
2853};
2854
2855/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2856static int __init mptctl_init(void)
2857{
2858 int err;
2859 int where = 1;
2860
2861 show_mptmod_ver(my_NAME, my_VERSION);
2862
2863 if(mpt_device_driver_register(&mptctl_driver,
2864 MPTCTL_DRIVER) != 0 ) {
2865 dprintk((KERN_INFO MYNAM
2866 ": failed to register dd callbacks\n"));
2867 }
2868
2869 /* Register this device */
2870 err = misc_register(&mptctl_miscdev);
2871 if (err < 0) {
2872 printk(KERN_ERR MYNAM ": Can't register misc device [minor=%d].\n", MPT_MINOR);
2873 goto out_fail;
2874 }
2875 printk(KERN_INFO MYNAM ": Registered with Fusion MPT base driver\n");
2876 printk(KERN_INFO MYNAM ": /dev/%s @ (major,minor=%d,%d)\n",
2877 mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
2878
2879 /*
2880 * Install our handler
2881 */
2882 ++where;
2883 if ((mptctl_id = mpt_register(mptctl_reply, MPTCTL_DRIVER)) < 0) {
2884 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
2885 misc_deregister(&mptctl_miscdev);
2886 err = -EBUSY;
2887 goto out_fail;
2888 }
2889
2890 if (mpt_reset_register(mptctl_id, mptctl_ioc_reset) == 0) {
2891 dprintk((KERN_INFO MYNAM ": Registered for IOC reset notifications\n"));
2892 } else {
2893 /* FIXME! */
2894 }
2895
2896 return 0;
2897
2898out_fail:
2899
2900 mpt_device_driver_deregister(MPTCTL_DRIVER);
2901
2902 return err;
2903}
2904
2905/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2906static void mptctl_exit(void)
2907{
2908 misc_deregister(&mptctl_miscdev);
2909 printk(KERN_INFO MYNAM ": Deregistered /dev/%s @ (major,minor=%d,%d)\n",
2910 mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
2911
2912 /* De-register reset handler from base module */
2913 mpt_reset_deregister(mptctl_id);
2914 dprintk((KERN_INFO MYNAM ": Deregistered for IOC reset notifications\n"));
2915
2916 /* De-register callback handler from base module */
2917 mpt_deregister(mptctl_id);
2918 printk(KERN_INFO MYNAM ": Deregistered from Fusion MPT base driver\n");
2919
2920 mpt_device_driver_deregister(MPTCTL_DRIVER);
2921
2922}
2923
2924/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2925
2926module_init(mptctl_init);
2927module_exit(mptctl_exit);
Linux kernel - Deliverables
This page took 0.552116 seconds and 5 git commands to generate.