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