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