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