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