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