projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] spi transport class: export spi_dv_pending
[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
1da177e4
LT		 8 * (mailto:mpt_linux_developer@lsil.com)
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));
316 mpt_HardResetHandler(ioctl->ioc, NO_SLEEP);
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;
364 pScsiTm->TargetID = ioctl->target;
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;
1162 struct Scsi_Host *sh;
1163 MPT_SCSI_HOST *hd;
1164 int iocnum;
1165 int numDevices = 0;
1166 unsigned int max_id;
1167 int ii;
b6fe4ddc 1168 unsigned int port;
1da177e4
LT		 1169 int cim_rev;
1170 u8 revision;
1171
1172 dctlprintk((": mptctl_getiocinfo called.\n"));
1173 /* Add of PCI INFO results in unaligned access for
1174 * IA64 and Sparc. Reset long to int. Return no PCI
1175 * data for obsolete format.
1176 */
1177 if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev0))
1178 cim_rev = 0;
1179 else if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev1))
1180 cim_rev = 1;
1181 else if (data_size == sizeof(struct mpt_ioctl_iocinfo))
1182 cim_rev = 2;
1183 else if (data_size == (sizeof(struct mpt_ioctl_iocinfo_rev0)+12))
1184 cim_rev = 0; /* obsolete */
1185 else
1186 return -EFAULT;
1187
1188 karg = kmalloc(data_size, GFP_KERNEL);
1189 if (karg == NULL) {
1190 printk(KERN_ERR "%s::mpt_ioctl_iocinfo() @%d - no memory available!\n",
1191 __FILE__, __LINE__);
1192 return -ENOMEM;
1193 }
1194
1195 if (copy_from_user(karg, uarg, data_size)) {
1196 printk(KERN_ERR "%s@%d::mptctl_getiocinfo - "
1197 "Unable to read in mpt_ioctl_iocinfo struct @ %p\n",
1198 __FILE__, __LINE__, uarg);
1199 kfree(karg);
1200 return -EFAULT;
1201 }
1202
1203 if (((iocnum = mpt_verify_adapter(karg->hdr.iocnum, &ioc)) < 0) ||
1204 (ioc == NULL)) {
1205 dctlprintk((KERN_ERR "%s::mptctl_getiocinfo() @%d - ioc%d not found!\n",
1206 __FILE__, __LINE__, iocnum));
1207 kfree(karg);
1208 return -ENODEV;
1209 }
1210
b6fe4ddc 1211 /* Verify the data transfer size is correct. */
1da177e4
LT		 1212 if (karg->hdr.maxDataSize != data_size) {
1213 printk(KERN_ERR "%s@%d::mptctl_getiocinfo - "
1214 "Structure size mismatch. Command not completed.\n",
1215 __FILE__, __LINE__);
1216 kfree(karg);
1217 return -EFAULT;
1218 }
1219
1220 /* Fill in the data and return the structure to the calling
1221 * program
1222 */
9cc1cfbc
ME		 1223 if (ioc->bus_type == SAS)
1224 karg->adapterType = MPT_IOCTL_INTERFACE_SAS;
1225 else if (ioc->bus_type == FC)
1da177e4
LT		 1226 karg->adapterType = MPT_IOCTL_INTERFACE_FC;
1227 else
1228 karg->adapterType = MPT_IOCTL_INTERFACE_SCSI;
1229
b6fe4ddc
MED		 1230 if (karg->hdr.port > 1)
1231 return -EINVAL;
1da177e4
LT		 1232 port = karg->hdr.port;
1233
1234 karg->port = port;
1235 pdev = (struct pci_dev *) ioc->pcidev;
1236
1237 karg->pciId = pdev->device;
1238 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1239 karg->hwRev = revision;
1240 karg->subSystemDevice = pdev->subsystem_device;
1241 karg->subSystemVendor = pdev->subsystem_vendor;
1242
1243 if (cim_rev == 1) {
1244 /* Get the PCI bus, device, and function numbers for the IOC
1245 */
1246 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1247 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1248 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1249 } else if (cim_rev == 2) {
86a7dcaa 1250 /* Get the PCI bus, device, function and segment ID numbers
1da177e4
LT		 1251 for the IOC */
1252 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1253 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1254 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1da177e4
LT		 1255 karg->pciInfo.segmentID = pci_domain_nr(pdev->bus);
1256 }
1257
1258 /* Get number of devices
1259 */
1260 if ((sh = ioc->sh) != NULL) {
1261 /* sh->max_id = maximum target ID + 1
1262 */
1263 max_id = sh->max_id - 1;
1264 hd = (MPT_SCSI_HOST *) sh->hostdata;
1265
1266 /* Check all of the target structures and
1267 * keep a counter.
1268 */
1269 if (hd && hd->Targets) {
1270 for (ii = 0; ii <= max_id; ii++) {
1271 if (hd->Targets[ii])
1272 numDevices++;
1273 }
1274 }
1275 }
1276 karg->numDevices = numDevices;
1277
1278 /* Set the BIOS and FW Version
1279 */
1280 karg->FWVersion = ioc->facts.FWVersion.Word;
1281 karg->BIOSVersion = ioc->biosVersion;
1282
1283 /* Set the Version Strings.
1284 */
1285 strncpy (karg->driverVersion, MPT_LINUX_PACKAGE_NAME, MPT_IOCTL_VERSION_LENGTH);
1286 karg->driverVersion[MPT_IOCTL_VERSION_LENGTH-1]='\0';
1287
1288 karg->busChangeEvent = 0;
1289 karg->hostId = ioc->pfacts[port].PortSCSIID;
1290 karg->rsvd[0] = karg->rsvd[1] = 0;
1291
1292 /* Copy the data from kernel memory to user memory
1293 */
1294 if (copy_to_user((char __user *)arg, karg, data_size)) {
1295 printk(KERN_ERR "%s@%d::mptctl_getiocinfo - "
1296 "Unable to write out mpt_ioctl_iocinfo struct @ %p\n",
1297 __FILE__, __LINE__, uarg);
1298 kfree(karg);
1299 return -EFAULT;
1300 }
1301
1302 kfree(karg);
1303 return 0;
1304}
1305
1306/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1307/*
1308 * mptctl_gettargetinfo - Query the host adapter for target information.
1309 * @arg: User space argument
1310 *
1311 * Outputs: None.
1312 * Return: 0 if successful
1313 * -EFAULT if data unavailable
1314 * -ENODEV if no such device/adapter
1315 */
1316static int
1317mptctl_gettargetinfo (unsigned long arg)
1318{
1319 struct mpt_ioctl_targetinfo __user *uarg = (void __user *) arg;
1320 struct mpt_ioctl_targetinfo karg;
1321 MPT_ADAPTER *ioc;
1322 struct Scsi_Host *sh;
1323 MPT_SCSI_HOST *hd;
c7c82987 1324 VirtTarget *vdev;
1da177e4
LT		 1325 char *pmem;
1326 int *pdata;
1327 IOCPage2_t *pIoc2;
1328 IOCPage3_t *pIoc3;
1329 int iocnum;
1330 int numDevices = 0;
1331 unsigned int max_id;
1332 int id, jj, indexed_lun, lun_index;
1333 u32 lun;
1334 int maxWordsLeft;
1335 int numBytes;
1336 u8 port, devType, bus_id;
1337
1338 dctlprintk(("mptctl_gettargetinfo called.\n"));
1339 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_targetinfo))) {
1340 printk(KERN_ERR "%s@%d::mptctl_gettargetinfo - "
1341 "Unable to read in mpt_ioctl_targetinfo struct @ %p\n",
1342 __FILE__, __LINE__, uarg);
1343 return -EFAULT;
1344 }
1345
1346 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1347 (ioc == NULL)) {
1348 dctlprintk((KERN_ERR "%s::mptctl_gettargetinfo() @%d - ioc%d not found!\n",
1349 __FILE__, __LINE__, iocnum));
1350 return -ENODEV;
1351 }
1352
1353 /* Get the port number and set the maximum number of bytes
1354 * in the returned structure.
1355 * Ignore the port setting.
1356 */
1357 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1358 maxWordsLeft = numBytes/sizeof(int);
1359 port = karg.hdr.port;
1360
1361 if (maxWordsLeft <= 0) {
1362 printk(KERN_ERR "%s::mptctl_gettargetinfo() @%d - no memory available!\n",
1363 __FILE__, __LINE__);
1364 return -ENOMEM;
1365 }
1366
1367 /* Fill in the data and return the structure to the calling
1368 * program
1369 */
1370
1371 /* struct mpt_ioctl_targetinfo does not contain sufficient space
1372 * for the target structures so when the IOCTL is called, there is
1373 * not sufficient stack space for the structure. Allocate memory,
1374 * populate the memory, copy back to the user, then free memory.
1375 * targetInfo format:
1376 * bits 31-24: reserved
1377 * 23-16: LUN
1378 * 15- 8: Bus Number
1379 * 7- 0: Target ID
1380 */
1381 pmem = kmalloc(numBytes, GFP_KERNEL);
1382 if (pmem == NULL) {
1383 printk(KERN_ERR "%s::mptctl_gettargetinfo() @%d - no memory available!\n",
1384 __FILE__, __LINE__);
1385 return -ENOMEM;
1386 }
1387 memset(pmem, 0, numBytes);
1388 pdata = (int *) pmem;
1389
1390 /* Get number of devices
1391 */
1392 if ((sh = ioc->sh) != NULL) {
1393
1394 max_id = sh->max_id - 1;
1395 hd = (MPT_SCSI_HOST *) sh->hostdata;
1396
1397 /* Check all of the target structures.
1398 * Save the Id and increment the counter,
1399 * if ptr non-null.
1400 * sh->max_id = maximum target ID + 1
1401 */
1402 if (hd && hd->Targets) {
1403 mpt_findImVolumes(ioc);
466544d8 1404 pIoc2 = ioc->raid_data.pIocPg2;
1da177e4
LT		 1405 for ( id = 0; id <= max_id; ) {
1406 if ( pIoc2 && pIoc2->NumActiveVolumes ) {
1407 if ( id == pIoc2->RaidVolume[0].VolumeID ) {
1408 if (maxWordsLeft <= 0) {
1409 printk(KERN_ERR "mptctl_gettargetinfo - "
1410 "buffer is full but volume is available on ioc %d\n, numDevices=%d", iocnum, numDevices);
1411 goto data_space_full;
1412 }
1413 if ( ( pIoc2->RaidVolume[0].Flags & MPI_IOCPAGE2_FLAG_VOLUME_INACTIVE ) == 0 )
1414 devType = 0x80;
1415 else
1416 devType = 0xC0;
1417 bus_id = pIoc2->RaidVolume[0].VolumeBus;
1418 numDevices++;
1419 *pdata = ( (devType << 24) | (bus_id << 8) | id );
1420 dctlprintk((KERN_ERR "mptctl_gettargetinfo - "
1421 "volume ioc=%d target=%x numDevices=%d pdata=%p\n", iocnum, *pdata, numDevices, pdata));
1422 pdata++;
1423 --maxWordsLeft;
1424 goto next_id;
1425 } else {
466544d8 1426 pIoc3 = ioc->raid_data.pIocPg3;
1da177e4
LT		 1427 for ( jj = 0; jj < pIoc3->NumPhysDisks; jj++ ) {
1428 if ( pIoc3->PhysDisk[jj].PhysDiskID == id )
1429 goto next_id;
1430 }
1431 }
1432 }
1433 if ( (vdev = hd->Targets[id]) ) {
1434 for (jj = 0; jj <= MPT_LAST_LUN; jj++) {
1435 lun_index = (jj >> 5);
1436 indexed_lun = (jj % 32);
1437 lun = (1 << indexed_lun);
1438 if (vdev->luns[lun_index] & lun) {
1439 if (maxWordsLeft <= 0) {
1440 printk(KERN_ERR "mptctl_gettargetinfo - "
1441 "buffer is full but more targets are available on ioc %d numDevices=%d\n", iocnum, numDevices);
1442 goto data_space_full;
1443 }
1444 bus_id = vdev->bus_id;
1445 numDevices++;
1446 *pdata = ( (jj << 16) | (bus_id << 8) | id );
1447 dctlprintk((KERN_ERR "mptctl_gettargetinfo - "
1448 "target ioc=%d target=%x numDevices=%d pdata=%p\n", iocnum, *pdata, numDevices, pdata));
1449 pdata++;
1450 --maxWordsLeft;
1451 }
1452 }
1453 }
1454next_id:
1455 id++;
1456 }
1457 }
1458 }
1459data_space_full:
1460 karg.numDevices = numDevices;
1461
1462 /* Copy part of the data from kernel memory to user memory
1463 */
1464 if (copy_to_user((char __user *)arg, &karg,
1465 sizeof(struct mpt_ioctl_targetinfo))) {
1466 printk(KERN_ERR "%s@%d::mptctl_gettargetinfo - "
1467 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1468 __FILE__, __LINE__, uarg);
1469 kfree(pmem);
1470 return -EFAULT;
1471 }
1472
1473 /* Copy the remaining data from kernel memory to user memory
1474 */
1475 if (copy_to_user(uarg->targetInfo, pmem, numBytes)) {
1476 printk(KERN_ERR "%s@%d::mptctl_gettargetinfo - "
1477 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
1478 __FILE__, __LINE__, pdata);
1479 kfree(pmem);
1480 return -EFAULT;
1481 }
1482
1483 kfree(pmem);
1484
1485 return 0;
1486}
1487
1488/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1489/* MPT IOCTL Test function.
1490 *
1491 * Outputs: None.
1492 * Return: 0 if successful
1493 * -EFAULT if data unavailable
1494 * -ENODEV if no such device/adapter
1495 */
1496static int
1497mptctl_readtest (unsigned long arg)
1498{
1499 struct mpt_ioctl_test __user *uarg = (void __user *) arg;
1500 struct mpt_ioctl_test karg;
1501 MPT_ADAPTER *ioc;
1502 int iocnum;
1503
1504 dctlprintk(("mptctl_readtest called.\n"));
1505 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_test))) {
1506 printk(KERN_ERR "%s@%d::mptctl_readtest - "
1507 "Unable to read in mpt_ioctl_test struct @ %p\n",
1508 __FILE__, __LINE__, uarg);
1509 return -EFAULT;
1510 }
1511
1512 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1513 (ioc == NULL)) {
1514 dctlprintk((KERN_ERR "%s::mptctl_readtest() @%d - ioc%d not found!\n",
1515 __FILE__, __LINE__, iocnum));
1516 return -ENODEV;
1517 }
1518
1519 /* Fill in the data and return the structure to the calling
1520 * program
1521 */
1522
1523#ifdef MFCNT
1524 karg.chip_type = ioc->mfcnt;
1525#else
1526 karg.chip_type = ioc->pcidev->device;
1527#endif
1528 strncpy (karg.name, ioc->name, MPT_MAX_NAME);
1529 karg.name[MPT_MAX_NAME-1]='\0';
1530 strncpy (karg.product, ioc->prod_name, MPT_PRODUCT_LENGTH);
1531 karg.product[MPT_PRODUCT_LENGTH-1]='\0';
1532
1533 /* Copy the data from kernel memory to user memory
1534 */
1535 if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_test))) {
1536 printk(KERN_ERR "%s@%d::mptctl_readtest - "
1537 "Unable to write out mpt_ioctl_test struct @ %p\n",
1538 __FILE__, __LINE__, uarg);
1539 return -EFAULT;
1540 }
1541
1542 return 0;
1543}
1544
1545/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1546/*
1547 * mptctl_eventquery - Query the host adapter for the event types
1548 * that are being logged.
1549 * @arg: User space argument
1550 *
1551 * Outputs: None.
1552 * Return: 0 if successful
1553 * -EFAULT if data unavailable
1554 * -ENODEV if no such device/adapter
1555 */
1556static int
1557mptctl_eventquery (unsigned long arg)
1558{
1559 struct mpt_ioctl_eventquery __user *uarg = (void __user *) arg;
1560 struct mpt_ioctl_eventquery karg;
1561 MPT_ADAPTER *ioc;
1562 int iocnum;
1563
1564 dctlprintk(("mptctl_eventquery called.\n"));
1565 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventquery))) {
1566 printk(KERN_ERR "%s@%d::mptctl_eventquery - "
1567 "Unable to read in mpt_ioctl_eventquery struct @ %p\n",
1568 __FILE__, __LINE__, uarg);
1569 return -EFAULT;
1570 }
1571
1572 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1573 (ioc == NULL)) {
1574 dctlprintk((KERN_ERR "%s::mptctl_eventquery() @%d - ioc%d not found!\n",
1575 __FILE__, __LINE__, iocnum));
1576 return -ENODEV;
1577 }
1578
5b5ef4f6 1579 karg.eventEntries = MPTCTL_EVENT_LOG_SIZE;
1da177e4
LT		 1580 karg.eventTypes = ioc->eventTypes;
1581
1582 /* Copy the data from kernel memory to user memory
1583 */
1584 if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_eventquery))) {
1585 printk(KERN_ERR "%s@%d::mptctl_eventquery - "
1586 "Unable to write out mpt_ioctl_eventquery struct @ %p\n",
1587 __FILE__, __LINE__, uarg);
1588 return -EFAULT;
1589 }
1590 return 0;
1591}
1592
1593/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1594static int
1595mptctl_eventenable (unsigned long arg)
1596{
1597 struct mpt_ioctl_eventenable __user *uarg = (void __user *) arg;
1598 struct mpt_ioctl_eventenable karg;
1599 MPT_ADAPTER *ioc;
1600 int iocnum;
1601
1602 dctlprintk(("mptctl_eventenable called.\n"));
1603 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventenable))) {
1604 printk(KERN_ERR "%s@%d::mptctl_eventenable - "
1605 "Unable to read in mpt_ioctl_eventenable struct @ %p\n",
1606 __FILE__, __LINE__, uarg);
1607 return -EFAULT;
1608 }
1609
1610 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1611 (ioc == NULL)) {
1612 dctlprintk((KERN_ERR "%s::mptctl_eventenable() @%d - ioc%d not found!\n",
1613 __FILE__, __LINE__, iocnum));
1614 return -ENODEV;
1615 }
1616
1617 if (ioc->events == NULL) {
1618 /* Have not yet allocated memory - do so now.
1619 */
1620 int sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
1621 ioc->events = kmalloc(sz, GFP_KERNEL);
1622 if (ioc->events == NULL) {
1623 printk(KERN_ERR MYNAM ": ERROR - Insufficient memory to add adapter!\n");
1624 return -ENOMEM;
1625 }
1626 memset(ioc->events, 0, sz);
1627 ioc->alloc_total += sz;
1628
1da177e4
LT		 1629 ioc->eventContext = 0;
1630 }
1631
1632 /* Update the IOC event logging flag.
1633 */
1634 ioc->eventTypes = karg.eventTypes;
1635
1636 return 0;
1637}
1638
1639/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1640static int
1641mptctl_eventreport (unsigned long arg)
1642{
1643 struct mpt_ioctl_eventreport __user *uarg = (void __user *) arg;
1644 struct mpt_ioctl_eventreport karg;
1645 MPT_ADAPTER *ioc;
1646 int iocnum;
1647 int numBytes, maxEvents, max;
1648
1649 dctlprintk(("mptctl_eventreport called.\n"));
1650 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventreport))) {
1651 printk(KERN_ERR "%s@%d::mptctl_eventreport - "
1652 "Unable to read in mpt_ioctl_eventreport struct @ %p\n",
1653 __FILE__, __LINE__, uarg);
1654 return -EFAULT;
1655 }
1656
1657 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1658 (ioc == NULL)) {
1659 dctlprintk((KERN_ERR "%s::mptctl_eventreport() @%d - ioc%d not found!\n",
1660 __FILE__, __LINE__, iocnum));
1661 return -ENODEV;
1662 }
1663
1664 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1665 maxEvents = numBytes/sizeof(MPT_IOCTL_EVENTS);
1666
1667
5b5ef4f6 1668 max = MPTCTL_EVENT_LOG_SIZE < maxEvents ? MPTCTL_EVENT_LOG_SIZE : maxEvents;
1da177e4
LT		 1669
1670 /* If fewer than 1 event is requested, there must have
1671 * been some type of error.
1672 */
1673 if ((max < 1) || !ioc->events)
1674 return -ENODATA;
1675
ea5a7a82
ME		 1676 /* reset this flag so SIGIO can restart */
1677 ioc->aen_event_read_flag=0;
1678
1da177e4
LT		 1679 /* Copy the data from kernel memory to user memory
1680 */
1681 numBytes = max * sizeof(MPT_IOCTL_EVENTS);
1682 if (copy_to_user(uarg->eventData, ioc->events, numBytes)) {
1683 printk(KERN_ERR "%s@%d::mptctl_eventreport - "
1684 "Unable to write out mpt_ioctl_eventreport struct @ %p\n",
1685 __FILE__, __LINE__, ioc->events);
1686 return -EFAULT;
1687 }
1688
1689 return 0;
1690}
1691
1692/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1693static int
1694mptctl_replace_fw (unsigned long arg)
1695{
1696 struct mpt_ioctl_replace_fw __user *uarg = (void __user *) arg;
1697 struct mpt_ioctl_replace_fw karg;
1698 MPT_ADAPTER *ioc;
1699 int iocnum;
1700 int newFwSize;
1701
1702 dctlprintk(("mptctl_replace_fw called.\n"));
1703 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_replace_fw))) {
1704 printk(KERN_ERR "%s@%d::mptctl_replace_fw - "
1705 "Unable to read in mpt_ioctl_replace_fw struct @ %p\n",
1706 __FILE__, __LINE__, uarg);
1707 return -EFAULT;
1708 }
1709
1710 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1711 (ioc == NULL)) {
1712 dctlprintk((KERN_ERR "%s::mptctl_replace_fw() @%d - ioc%d not found!\n",
1713 __FILE__, __LINE__, iocnum));
1714 return -ENODEV;
1715 }
1716
1717 /* If caching FW, Free the old FW image
1718 */
1719 if (ioc->cached_fw == NULL)
1720 return 0;
1721
1722 mpt_free_fw_memory(ioc);
1723
1724 /* Allocate memory for the new FW image
1725 */
1726 newFwSize = karg.newImageSize;
1727
1728 if (newFwSize & 0x01)
1729 newFwSize += 1;
1730 if (newFwSize & 0x02)
1731 newFwSize += 2;
1732
1733 mpt_alloc_fw_memory(ioc, newFwSize);
1734 if (ioc->cached_fw == NULL)
1735 return -ENOMEM;
1736
1737 /* Copy the data from user memory to kernel space
1738 */
1739 if (copy_from_user(ioc->cached_fw, uarg->newImage, newFwSize)) {
1740 printk(KERN_ERR "%s@%d::mptctl_replace_fw - "
1741 "Unable to read in mpt_ioctl_replace_fw image "
1742 "@ %p\n", __FILE__, __LINE__, uarg);
1743 mpt_free_fw_memory(ioc);
1744 return -EFAULT;
1745 }
1746
1747 /* Update IOCFactsReply
1748 */
1749 ioc->facts.FWImageSize = newFwSize;
1750 return 0;
1751}
1752
1753/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1754/* MPT IOCTL MPTCOMMAND function.
1755 * Cast the arg into the mpt_ioctl_mpt_command structure.
1756 *
1757 * Outputs: None.
1758 * Return: 0 if successful
1759 * -EBUSY if previous command timout and IOC reset is not complete.
1760 * -EFAULT if data unavailable
1761 * -ENODEV if no such device/adapter
1762 * -ETIME if timer expires
1763 * -ENOMEM if memory allocation error
1764 */
1765static int
1766mptctl_mpt_command (unsigned long arg)
1767{
1768 struct mpt_ioctl_command __user *uarg = (void __user *) arg;
1769 struct mpt_ioctl_command karg;
1770 MPT_ADAPTER *ioc;
1771 int iocnum;
1772 int rc;
1773
1774 dctlprintk(("mptctl_command called.\n"));
1775
1776 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_command))) {
1777 printk(KERN_ERR "%s@%d::mptctl_mpt_command - "
1778 "Unable to read in mpt_ioctl_command struct @ %p\n",
1779 __FILE__, __LINE__, uarg);
1780 return -EFAULT;
1781 }
1782
1783 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1784 (ioc == NULL)) {
1785 dctlprintk((KERN_ERR "%s::mptctl_mpt_command() @%d - ioc%d not found!\n",
1786 __FILE__, __LINE__, iocnum));
1787 return -ENODEV;
1788 }
1789
1790 rc = mptctl_do_mpt_command (karg, &uarg->MF);
1791
1792 return rc;
1793}
1794
1795/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1796/* Worker routine for the IOCTL MPTCOMMAND and MPTCOMMAND32 (sparc) commands.
1797 *
1798 * Outputs: None.
1799 * Return: 0 if successful
1800 * -EBUSY if previous command timout and IOC reset is not complete.
1801 * -EFAULT if data unavailable
1802 * -ENODEV if no such device/adapter
1803 * -ETIME if timer expires
1804 * -ENOMEM if memory allocation error
1805 * -EPERM if SCSI I/O and target is untagged
1806 */
1807static int
1808mptctl_do_mpt_command (struct mpt_ioctl_command karg, void __user *mfPtr)
1809{
1810 MPT_ADAPTER *ioc;
1811 MPT_FRAME_HDR *mf = NULL;
1812 MPIHeader_t *hdr;
1813 char *psge;
1814 struct buflist bufIn; /* data In buffer */
1815 struct buflist bufOut; /* data Out buffer */
1816 dma_addr_t dma_addr_in;
1817 dma_addr_t dma_addr_out;
1818 int sgSize = 0; /* Num SG elements */
1819 int iocnum, flagsLength;
1820 int sz, rc = 0;
1821 int msgContext;
1822 u16 req_idx;
1823 ulong timeout;
1824
1825 dctlprintk(("mptctl_do_mpt_command called.\n"));
1826 bufIn.kptr = bufOut.kptr = NULL;
1827
1828 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
1829 (ioc == NULL)) {
1830 dctlprintk((KERN_ERR "%s::mptctl_do_mpt_command() @%d - ioc%d not found!\n",
1831 __FILE__, __LINE__, iocnum));
1832 return -ENODEV;
1833 }
1834 if (!ioc->ioctl) {
1835 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1836 "No memory available during driver init.\n",
1837 __FILE__, __LINE__);
1838 return -ENOMEM;
1839 } else if (ioc->ioctl->status & MPT_IOCTL_STATUS_DID_IOCRESET) {
1840 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1841 "Busy with IOC Reset \n", __FILE__, __LINE__);
1842 return -EBUSY;
1843 }
1844
1845 /* Verify that the final request frame will not be too large.
1846 */
1847 sz = karg.dataSgeOffset * 4;
1848 if (karg.dataInSize > 0)
1849 sz += sizeof(dma_addr_t) + sizeof(u32);
1850 if (karg.dataOutSize > 0)
1851 sz += sizeof(dma_addr_t) + sizeof(u32);
1852
1853 if (sz > ioc->req_sz) {
1854 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1855 "Request frame too large (%d) maximum (%d)\n",
1856 __FILE__, __LINE__, sz, ioc->req_sz);
1857 return -EFAULT;
1858 }
1859
1860 /* Get a free request frame and save the message context.
1861 */
1862 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
1863 return -EAGAIN;
1864
1865 hdr = (MPIHeader_t *) mf;
1866 msgContext = le32_to_cpu(hdr->MsgContext);
1867 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1868
1869 /* Copy the request frame
1870 * Reset the saved message context.
1871 * Request frame in user space
1872 */
1873 if (copy_from_user(mf, mfPtr, karg.dataSgeOffset * 4)) {
1874 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1875 "Unable to read MF from mpt_ioctl_command struct @ %p\n",
1876 __FILE__, __LINE__, mfPtr);
1877 rc = -EFAULT;
1878 goto done_free_mem;
1879 }
1880 hdr->MsgContext = cpu_to_le32(msgContext);
1881
1882
1883 /* Verify that this request is allowed.
1884 */
1885 switch (hdr->Function) {
1886 case MPI_FUNCTION_IOC_FACTS:
1887 case MPI_FUNCTION_PORT_FACTS:
1888 karg.dataOutSize = karg.dataInSize = 0;
1889 break;
1890
1891 case MPI_FUNCTION_CONFIG:
1892 case MPI_FUNCTION_FC_COMMON_TRANSPORT_SEND:
1893 case MPI_FUNCTION_FC_EX_LINK_SRVC_SEND:
1894 case MPI_FUNCTION_FW_UPLOAD:
1895 case MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR:
1896 case MPI_FUNCTION_FW_DOWNLOAD:
1897 case MPI_FUNCTION_FC_PRIMITIVE_SEND:
096f7a2a
ME		 1898 case MPI_FUNCTION_TOOLBOX:
1899 case MPI_FUNCTION_SAS_IO_UNIT_CONTROL:
1da177e4
LT		 1900 break;
1901
1902 case MPI_FUNCTION_SCSI_IO_REQUEST:
1903 if (ioc->sh) {
1904 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
c7c82987 1905 VirtTarget *pTarget = NULL;
1da177e4
LT		 1906 MPT_SCSI_HOST *hd = NULL;
1907 int qtag = MPI_SCSIIO_CONTROL_UNTAGGED;
1908 int scsidir = 0;
1909 int target = (int) pScsiReq->TargetID;
1910 int dataSize;
1911
1912 if ((target < 0) || (target >= ioc->sh->max_id)) {
1913 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1914 "Target ID out of bounds. \n",
1915 __FILE__, __LINE__);
1916 rc = -ENODEV;
1917 goto done_free_mem;
1918 }
1919
5f07e249
ME		 1920 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
1921 pScsiReq->MsgFlags |= mpt_msg_flags();
1922
1da177e4
LT		 1923
1924 /* verify that app has not requested
1925 * more sense data than driver
1926 * can provide, if so, reset this parameter
1927 * set the sense buffer pointer low address
1928 * update the control field to specify Q type
1929 */
1930 if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1931 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1932 else
1933 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1934
1935 pScsiReq->SenseBufferLowAddr =
1936 cpu_to_le32(ioc->sense_buf_low_dma
1937 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
1938
1939 if ((hd = (MPT_SCSI_HOST *) ioc->sh->hostdata)) {
1940 if (hd->Targets)
1941 pTarget = hd->Targets[target];
1942 }
1943
1944 if (pTarget &&(pTarget->tflags & MPT_TARGET_FLAGS_Q_YES))
1945 qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
1946
1947 /* Have the IOCTL driver set the direction based
1948 * on the dataOutSize (ordering issue with Sparc).
1949 */
1950 if (karg.dataOutSize > 0) {
1951 scsidir = MPI_SCSIIO_CONTROL_WRITE;
1952 dataSize = karg.dataOutSize;
1953 } else {
1954 scsidir = MPI_SCSIIO_CONTROL_READ;
1955 dataSize = karg.dataInSize;
1956 }
1957
1958 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
1959 pScsiReq->DataLength = cpu_to_le32(dataSize);
1960
1961 ioc->ioctl->reset = MPTCTL_RESET_OK;
1962 ioc->ioctl->target = target;
1963
1964 } else {
1965 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1966 "SCSI driver is not loaded. \n",
1967 __FILE__, __LINE__);
1968 rc = -EFAULT;
1969 goto done_free_mem;
1970 }
1971 break;
1972
096f7a2a
ME		 1973 case MPI_FUNCTION_SMP_PASSTHROUGH:
1974 /* Check mf->PassthruFlags to determine if
1975 * transfer is ImmediateMode or not.
1976 * Immediate mode returns data in the ReplyFrame.
1977 * Else, we are sending request and response data
1978 * in two SGLs at the end of the mf.
1979 */
1980 break;
1981
1982 case MPI_FUNCTION_SATA_PASSTHROUGH:
1983 if (!ioc->sh) {
1984 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
1985 "SCSI driver is not loaded. \n",
1986 __FILE__, __LINE__);
1987 rc = -EFAULT;
1988 goto done_free_mem;
1989 }
1990 break;
1991
1da177e4
LT		 1992 case MPI_FUNCTION_RAID_ACTION:
1993 /* Just add a SGE
1994 */
1995 break;
1996
1997 case MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
1998 if (ioc->sh) {
1999 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
2000 int qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
2001 int scsidir = MPI_SCSIIO_CONTROL_READ;
2002 int dataSize;
2003
5f07e249
ME		 2004 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
2005 pScsiReq->MsgFlags |= mpt_msg_flags();
2006
1da177e4
LT		 2007
2008 /* verify that app has not requested
2009 * more sense data than driver
2010 * can provide, if so, reset this parameter
2011 * set the sense buffer pointer low address
2012 * update the control field to specify Q type
2013 */
2014 if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
2015 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
2016 else
2017 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
2018
2019 pScsiReq->SenseBufferLowAddr =
2020 cpu_to_le32(ioc->sense_buf_low_dma
2021 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
2022
2023 /* All commands to physical devices are tagged
2024 */
2025
2026 /* Have the IOCTL driver set the direction based
2027 * on the dataOutSize (ordering issue with Sparc).
2028 */
2029 if (karg.dataOutSize > 0) {
2030 scsidir = MPI_SCSIIO_CONTROL_WRITE;
2031 dataSize = karg.dataOutSize;
2032 } else {
2033 scsidir = MPI_SCSIIO_CONTROL_READ;
2034 dataSize = karg.dataInSize;
2035 }
2036
2037 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
2038 pScsiReq->DataLength = cpu_to_le32(dataSize);
2039
2040 ioc->ioctl->reset = MPTCTL_RESET_OK;
2041 ioc->ioctl->target = pScsiReq->TargetID;
2042 } else {
2043 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2044 "SCSI driver is not loaded. \n",
2045 __FILE__, __LINE__);
2046 rc = -EFAULT;
2047 goto done_free_mem;
2048 }
2049 break;
2050
2051 case MPI_FUNCTION_SCSI_TASK_MGMT:
2052 {
2053 MPT_SCSI_HOST *hd = NULL;
2054 if ((ioc->sh == NULL) || ((hd = (MPT_SCSI_HOST *)ioc->sh->hostdata) == NULL)) {
2055 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2056 "SCSI driver not loaded or SCSI host not found. \n",
2057 __FILE__, __LINE__);
2058 rc = -EFAULT;
2059 goto done_free_mem;
2060 } else if (mptctl_set_tm_flags(hd) != 0) {
2061 rc = -EPERM;
2062 goto done_free_mem;
2063 }
2064 }
2065 break;
2066
2067 case MPI_FUNCTION_IOC_INIT:
2068 {
2069 IOCInit_t *pInit = (IOCInit_t *) mf;
2070 u32 high_addr, sense_high;
2071
2072 /* Verify that all entries in the IOC INIT match
2073 * existing setup (and in LE format).
2074 */
2075 if (sizeof(dma_addr_t) == sizeof(u64)) {
2076 high_addr = cpu_to_le32((u32)((u64)ioc->req_frames_dma >> 32));
2077 sense_high= cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
2078 } else {
2079 high_addr = 0;
2080 sense_high= 0;
2081 }
2082
2083 if ((pInit->Flags != 0) || (pInit->MaxDevices != ioc->facts.MaxDevices) ||
2084 (pInit->MaxBuses != ioc->facts.MaxBuses) ||
2085 (pInit->ReplyFrameSize != cpu_to_le16(ioc->reply_sz)) ||
2086 (pInit->HostMfaHighAddr != high_addr) ||
2087 (pInit->SenseBufferHighAddr != sense_high)) {
2088 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2089 "IOC_INIT issued with 1 or more incorrect parameters. Rejected.\n",
2090 __FILE__, __LINE__);
2091 rc = -EFAULT;
2092 goto done_free_mem;
2093 }
2094 }
2095 break;
2096 default:
2097 /*
2098 * MPI_FUNCTION_PORT_ENABLE
2099 * MPI_FUNCTION_TARGET_CMD_BUFFER_POST
2100 * MPI_FUNCTION_TARGET_ASSIST
2101 * MPI_FUNCTION_TARGET_STATUS_SEND
2102 * MPI_FUNCTION_TARGET_MODE_ABORT
2103 * MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET
2104 * MPI_FUNCTION_IO_UNIT_RESET
2105 * MPI_FUNCTION_HANDSHAKE
2106 * MPI_FUNCTION_REPLY_FRAME_REMOVAL
2107 * MPI_FUNCTION_EVENT_NOTIFICATION
2108 * (driver handles event notification)
2109 * MPI_FUNCTION_EVENT_ACK
2110 */
2111
2112 /* What to do with these??? CHECK ME!!!
2113 MPI_FUNCTION_FC_LINK_SRVC_BUF_POST
2114 MPI_FUNCTION_FC_LINK_SRVC_RSP
2115 MPI_FUNCTION_FC_ABORT
2116 MPI_FUNCTION_LAN_SEND
2117 MPI_FUNCTION_LAN_RECEIVE
2118 MPI_FUNCTION_LAN_RESET
2119 */
2120
2121 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2122 "Illegal request (function 0x%x) \n",
2123 __FILE__, __LINE__, hdr->Function);
2124 rc = -EFAULT;
2125 goto done_free_mem;
2126 }
2127
2128 /* Add the SGL ( at most one data in SGE and one data out SGE )
2129 * In the case of two SGE's - the data out (write) will always
2130 * preceede the data in (read) SGE. psgList is used to free the
2131 * allocated memory.
2132 */
2133 psge = (char *) (((int *) mf) + karg.dataSgeOffset);
2134 flagsLength = 0;
2135
2136 /* bufIn and bufOut are used for user to kernel space transfers
2137 */
2138 bufIn.kptr = bufOut.kptr = NULL;
2139 bufIn.len = bufOut.len = 0;
2140
2141 if (karg.dataOutSize > 0)
2142 sgSize ++;
2143
2144 if (karg.dataInSize > 0)
2145 sgSize ++;
2146
2147 if (sgSize > 0) {
2148
2149 /* Set up the dataOut memory allocation */
2150 if (karg.dataOutSize > 0) {
2151 if (karg.dataInSize > 0) {
2152 flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2153 MPI_SGE_FLAGS_END_OF_BUFFER |
2154 MPI_SGE_FLAGS_DIRECTION |
2155 mpt_addr_size() )
2156 << MPI_SGE_FLAGS_SHIFT;
2157 } else {
2158 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
2159 }
2160 flagsLength |= karg.dataOutSize;
2161 bufOut.len = karg.dataOutSize;
2162 bufOut.kptr = pci_alloc_consistent(
2163 ioc->pcidev, bufOut.len, &dma_addr_out);
2164
2165 if (bufOut.kptr == NULL) {
2166 rc = -ENOMEM;
2167 goto done_free_mem;
2168 } else {
2169 /* Set up this SGE.
2170 * Copy to MF and to sglbuf
2171 */
2172 mpt_add_sge(psge, flagsLength, dma_addr_out);
2173 psge += (sizeof(u32) + sizeof(dma_addr_t));
2174
2175 /* Copy user data to kernel space.
2176 */
2177 if (copy_from_user(bufOut.kptr,
2178 karg.dataOutBufPtr,
2179 bufOut.len)) {
2180 printk(KERN_ERR
2181 "%s@%d::mptctl_do_mpt_command - Unable "
2182 "to read user data "
2183 "struct @ %p\n",
2184 __FILE__, __LINE__,karg.dataOutBufPtr);
2185 rc = -EFAULT;
2186 goto done_free_mem;
2187 }
2188 }
2189 }
2190
2191 if (karg.dataInSize > 0) {
2192 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
2193 flagsLength |= karg.dataInSize;
2194
2195 bufIn.len = karg.dataInSize;
2196 bufIn.kptr = pci_alloc_consistent(ioc->pcidev,
2197 bufIn.len, &dma_addr_in);
2198
2199 if (bufIn.kptr == NULL) {
2200 rc = -ENOMEM;
2201 goto done_free_mem;
2202 } else {
2203 /* Set up this SGE
2204 * Copy to MF and to sglbuf
2205 */
2206 mpt_add_sge(psge, flagsLength, dma_addr_in);
2207 }
2208 }
2209 } else {
2210 /* Add a NULL SGE
2211 */
2212 mpt_add_sge(psge, flagsLength, (dma_addr_t) -1);
2213 }
2214
2215 ioc->ioctl->wait_done = 0;
2216 if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT) {
2217
2218 DBG_DUMP_TM_REQUEST_FRAME((u32 *)mf);
2219
2220 if (mpt_send_handshake_request(mptctl_id, ioc,
2221 sizeof(SCSITaskMgmt_t), (u32*)mf,
2222 CAN_SLEEP) != 0) {
2223 dfailprintk((MYIOC_s_ERR_FMT "_send_handshake FAILED!"
2224 " (ioc %p, mf %p) \n", ioc->name,
2225 ioc, mf));
2226 mptctl_free_tm_flags(ioc);
2227 rc = -ENODATA;
2228 goto done_free_mem;
2229 }
2230
2231 } else
2232 mpt_put_msg_frame(mptctl_id, ioc, mf);
2233
2234 /* Now wait for the command to complete */
2235 timeout = (karg.timeout > 0) ? karg.timeout : MPT_IOCTL_DEFAULT_TIMEOUT;
86a7dcaa 2236 timeout = wait_event_timeout(mptctl_wait,
1da177e4
LT		 2237 ioc->ioctl->wait_done == 1,
2238 HZ*timeout);
2239
2240 if(timeout <=0 && (ioc->ioctl->wait_done != 1 )) {
2241 /* Now we need to reset the board */
2242
2243 if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT)
2244 mptctl_free_tm_flags(ioc);
2245
2246 mptctl_timeout_expired(ioc->ioctl);
2247 rc = -ENODATA;
2248 goto done_free_mem;
2249 }
2250
2251 mf = NULL;
2252
2253 /* If a valid reply frame, copy to the user.
2254 * Offset 2: reply length in U32's
2255 */
2256 if (ioc->ioctl->status & MPT_IOCTL_STATUS_RF_VALID) {
2257 if (karg.maxReplyBytes < ioc->reply_sz) {
2258 sz = min(karg.maxReplyBytes, 4*ioc->ioctl->ReplyFrame[2]);
2259 } else {
2260 sz = min(ioc->reply_sz, 4*ioc->ioctl->ReplyFrame[2]);
2261 }
2262
2263 if (sz > 0) {
2264 if (copy_to_user(karg.replyFrameBufPtr,
2265 &ioc->ioctl->ReplyFrame, sz)){
2266 printk(KERN_ERR
2267 "%s@%d::mptctl_do_mpt_command - "
2268 "Unable to write out reply frame %p\n",
2269 __FILE__, __LINE__, karg.replyFrameBufPtr);
2270 rc = -ENODATA;
2271 goto done_free_mem;
2272 }
2273 }
2274 }
2275
2276 /* If valid sense data, copy to user.
2277 */
2278 if (ioc->ioctl->status & MPT_IOCTL_STATUS_SENSE_VALID) {
2279 sz = min(karg.maxSenseBytes, MPT_SENSE_BUFFER_SIZE);
2280 if (sz > 0) {
2281 if (copy_to_user(karg.senseDataPtr, ioc->ioctl->sense, sz)) {
2282 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2283 "Unable to write sense data to user %p\n",
2284 __FILE__, __LINE__,
2285 karg.senseDataPtr);
2286 rc = -ENODATA;
2287 goto done_free_mem;
2288 }
2289 }
2290 }
2291
2292 /* If the overall status is _GOOD and data in, copy data
2293 * to user.
2294 */
2295 if ((ioc->ioctl->status & MPT_IOCTL_STATUS_COMMAND_GOOD) &&
2296 (karg.dataInSize > 0) && (bufIn.kptr)) {
2297
2298 if (copy_to_user(karg.dataInBufPtr,
2299 bufIn.kptr, karg.dataInSize)) {
2300 printk(KERN_ERR "%s@%d::mptctl_do_mpt_command - "
2301 "Unable to write data to user %p\n",
2302 __FILE__, __LINE__,
2303 karg.dataInBufPtr);
2304 rc = -ENODATA;
2305 }
2306 }
2307
2308done_free_mem:
2309
2310 ioc->ioctl->status &= ~(MPT_IOCTL_STATUS_COMMAND_GOOD |
2311 MPT_IOCTL_STATUS_SENSE_VALID |
2312 MPT_IOCTL_STATUS_RF_VALID );
2313
2314 /* Free the allocated memory.
2315 */
2316 if (bufOut.kptr != NULL) {
2317 pci_free_consistent(ioc->pcidev,
2318 bufOut.len, (void *) bufOut.kptr, dma_addr_out);
2319 }
2320
2321 if (bufIn.kptr != NULL) {
2322 pci_free_consistent(ioc->pcidev,
2323 bufIn.len, (void *) bufIn.kptr, dma_addr_in);
2324 }
2325
2326 /* mf is null if command issued successfully
2327 * otherwise, failure occured after mf acquired.
2328 */
2329 if (mf)
2330 mpt_free_msg_frame(ioc, mf);
2331
2332 return rc;
2333}
2334
2335/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
ba856d32 2336/* Prototype Routine for the HOST INFO command.
1da177e4
LT		 2337 *
2338 * Outputs: None.
2339 * Return: 0 if successful
2340 * -EFAULT if data unavailable
2341 * -EBUSY if previous command timout and IOC reset is not complete.
2342 * -ENODEV if no such device/adapter
2343 * -ETIME if timer expires
2344 * -ENOMEM if memory allocation error
2345 */
2346static int
2347mptctl_hp_hostinfo(unsigned long arg, unsigned int data_size)
2348{
2349 hp_host_info_t __user *uarg = (void __user *) arg;
2350 MPT_ADAPTER *ioc;
2351 struct pci_dev *pdev;
592f9c2f 2352 char *pbuf=NULL;
1da177e4
LT		 2353 dma_addr_t buf_dma;
2354 hp_host_info_t karg;
2355 CONFIGPARMS cfg;
2356 ConfigPageHeader_t hdr;
2357 int iocnum;
2358 int rc, cim_rev;
592f9c2f
ME		 2359 ToolboxIstwiReadWriteRequest_t *IstwiRWRequest;
2360 MPT_FRAME_HDR *mf = NULL;
2361 MPIHeader_t *mpi_hdr;
1da177e4
LT		 2362
2363 dctlprintk((": mptctl_hp_hostinfo called.\n"));
2364 /* Reset long to int. Should affect IA64 and SPARC only
2365 */
2366 if (data_size == sizeof(hp_host_info_t))
2367 cim_rev = 1;
2368 else if (data_size == sizeof(hp_host_info_rev0_t))
2369 cim_rev = 0; /* obsolete */
2370 else
2371 return -EFAULT;
2372
2373 if (copy_from_user(&karg, uarg, sizeof(hp_host_info_t))) {
2374 printk(KERN_ERR "%s@%d::mptctl_hp_host_info - "
2375 "Unable to read in hp_host_info struct @ %p\n",
2376 __FILE__, __LINE__, uarg);
2377 return -EFAULT;
2378 }
2379
2380 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2381 (ioc == NULL)) {
2382 dctlprintk((KERN_ERR "%s::mptctl_hp_hostinfo() @%d - ioc%d not found!\n",
2383 __FILE__, __LINE__, iocnum));
2384 return -ENODEV;
2385 }
2386
2387 /* Fill in the data and return the structure to the calling
2388 * program
2389 */
2390 pdev = (struct pci_dev *) ioc->pcidev;
2391
2392 karg.vendor = pdev->vendor;
2393 karg.device = pdev->device;
2394 karg.subsystem_id = pdev->subsystem_device;
2395 karg.subsystem_vendor = pdev->subsystem_vendor;
2396 karg.devfn = pdev->devfn;
2397 karg.bus = pdev->bus->number;
2398
2399 /* Save the SCSI host no. if
2400 * SCSI driver loaded
2401 */
2402 if (ioc->sh != NULL)
2403 karg.host_no = ioc->sh->host_no;
2404 else
2405 karg.host_no = -1;
2406
2407 /* Reformat the fw_version into a string
2408 */
2409 karg.fw_version[0] = ioc->facts.FWVersion.Struct.Major >= 10 ?
2410 ((ioc->facts.FWVersion.Struct.Major / 10) + '0') : '0';
2411 karg.fw_version[1] = (ioc->facts.FWVersion.Struct.Major % 10 ) + '0';
2412 karg.fw_version[2] = '.';
2413 karg.fw_version[3] = ioc->facts.FWVersion.Struct.Minor >= 10 ?
2414 ((ioc->facts.FWVersion.Struct.Minor / 10) + '0') : '0';
2415 karg.fw_version[4] = (ioc->facts.FWVersion.Struct.Minor % 10 ) + '0';
2416 karg.fw_version[5] = '.';
2417 karg.fw_version[6] = ioc->facts.FWVersion.Struct.Unit >= 10 ?
2418 ((ioc->facts.FWVersion.Struct.Unit / 10) + '0') : '0';
2419 karg.fw_version[7] = (ioc->facts.FWVersion.Struct.Unit % 10 ) + '0';
2420 karg.fw_version[8] = '.';
2421 karg.fw_version[9] = ioc->facts.FWVersion.Struct.Dev >= 10 ?
2422 ((ioc->facts.FWVersion.Struct.Dev / 10) + '0') : '0';
2423 karg.fw_version[10] = (ioc->facts.FWVersion.Struct.Dev % 10 ) + '0';
2424 karg.fw_version[11] = '\0';
2425
2426 /* Issue a config request to get the device serial number
2427 */
2428 hdr.PageVersion = 0;
2429 hdr.PageLength = 0;
2430 hdr.PageNumber = 0;
2431 hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
69218ee5 2432 cfg.cfghdr.hdr = &hdr;
1da177e4
LT		 2433 cfg.physAddr = -1;
2434 cfg.pageAddr = 0;
2435 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2436 cfg.dir = 0; /* read */
2437 cfg.timeout = 10;
2438
2439 strncpy(karg.serial_number, " ", 24);
2440 if (mpt_config(ioc, &cfg) == 0) {
69218ee5 2441 if (cfg.cfghdr.hdr->PageLength > 0) {
1da177e4
LT		 2442 /* Issue the second config page request */
2443 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2444
2445 pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
2446 if (pbuf) {
2447 cfg.physAddr = buf_dma;
2448 if (mpt_config(ioc, &cfg) == 0) {
2449 ManufacturingPage0_t *pdata = (ManufacturingPage0_t *) pbuf;
2450 if (strlen(pdata->BoardTracerNumber) > 1) {
2451 strncpy(karg.serial_number, pdata->BoardTracerNumber, 24);
2452 karg.serial_number[24-1]='\0';
2453 }
2454 }
2455 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
2456 pbuf = NULL;
2457 }
2458 }
2459 }
2460 rc = mpt_GetIocState(ioc, 1);
2461 switch (rc) {
2462 case MPI_IOC_STATE_OPERATIONAL:
2463 karg.ioc_status = HP_STATUS_OK;
2464 break;
2465
2466 case MPI_IOC_STATE_FAULT:
2467 karg.ioc_status = HP_STATUS_FAILED;
2468 break;
2469
2470 case MPI_IOC_STATE_RESET:
2471 case MPI_IOC_STATE_READY:
2472 default:
2473 karg.ioc_status = HP_STATUS_OTHER;
2474 break;
2475 }
2476
2477 karg.base_io_addr = pci_resource_start(pdev, 0);
2478
9cc1cfbc 2479 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
1da177e4
LT		 2480 karg.bus_phys_width = HP_BUS_WIDTH_UNK;
2481 else
2482 karg.bus_phys_width = HP_BUS_WIDTH_16;
2483
2484 karg.hard_resets = 0;
2485 karg.soft_resets = 0;
2486 karg.timeouts = 0;
2487 if (ioc->sh != NULL) {
2488 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)ioc->sh->hostdata;
2489
2490 if (hd && (cim_rev == 1)) {
2491 karg.hard_resets = hd->hard_resets;
2492 karg.soft_resets = hd->soft_resets;
2493 karg.timeouts = hd->timeouts;
2494 }
2495 }
2496
592f9c2f
ME		 2497 /*
2498 * Gather ISTWI(Industry Standard Two Wire Interface) Data
2499 */
2500 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
2501 dfailprintk((MYIOC_s_WARN_FMT "%s, no msg frames!!\n",
2502 ioc->name,__FUNCTION__));
2503 goto out;
2504 }
2505
2506 IstwiRWRequest = (ToolboxIstwiReadWriteRequest_t *)mf;
2507 mpi_hdr = (MPIHeader_t *) mf;
2508 memset(IstwiRWRequest,0,sizeof(ToolboxIstwiReadWriteRequest_t));
2509 IstwiRWRequest->Function = MPI_FUNCTION_TOOLBOX;
2510 IstwiRWRequest->Tool = MPI_TOOLBOX_ISTWI_READ_WRITE_TOOL;
2511 IstwiRWRequest->MsgContext = mpi_hdr->MsgContext;
2512 IstwiRWRequest->Flags = MPI_TB_ISTWI_FLAGS_READ;
2513 IstwiRWRequest->NumAddressBytes = 0x01;
2514 IstwiRWRequest->DataLength = cpu_to_le16(0x04);
2515 if (pdev->devfn & 1)
2516 IstwiRWRequest->DeviceAddr = 0xB2;
2517 else
2518 IstwiRWRequest->DeviceAddr = 0xB0;
2519
1da177e4 2520 pbuf = pci_alloc_consistent(ioc->pcidev, 4, &buf_dma);
592f9c2f
ME		 2521 if (!pbuf)
2522 goto out;
2523 mpt_add_sge((char *)&IstwiRWRequest->SGL,
2524 (MPT_SGE_FLAGS_SSIMPLE_READ|4), buf_dma);
2525
2526 ioc->ioctl->wait_done = 0;
2527 mpt_put_msg_frame(mptctl_id, ioc, mf);
2528
2529 rc = wait_event_timeout(mptctl_wait,
2530 ioc->ioctl->wait_done == 1,
2531 HZ*MPT_IOCTL_DEFAULT_TIMEOUT /* 10 sec */);
2532
2533 if(rc <=0 && (ioc->ioctl->wait_done != 1 )) {
2534 /*
2535 * Now we need to reset the board
2536 */
2537 mpt_free_msg_frame(ioc, mf);
2538 mptctl_timeout_expired(ioc->ioctl);
2539 goto out;
1da177e4
LT		 2540 }
2541
592f9c2f
ME		 2542 /*
2543 *ISTWI Data Definition
2544 * pbuf[0] = FW_VERSION = 0x4
2545 * pbuf[1] = Bay Count = 6 or 4 or 2, depending on
2546 * the config, you should be seeing one out of these three values
2547 * pbuf[2] = Drive Installed Map = bit pattern depend on which
2548 * bays have drives in them
2549 * pbuf[3] = Checksum (0x100 = (byte0 + byte2 + byte3)
2550 */
2551 if (ioc->ioctl->status & MPT_IOCTL_STATUS_RF_VALID)
2552 karg.rsvd = *(u32 *)pbuf;
2553
2554 out:
2555 if (pbuf)
2556 pci_free_consistent(ioc->pcidev, 4, pbuf, buf_dma);
2557
1da177e4
LT		 2558 /* Copy the data from kernel memory to user memory
2559 */
2560 if (copy_to_user((char __user *)arg, &karg, sizeof(hp_host_info_t))) {
2561 printk(KERN_ERR "%s@%d::mptctl_hpgethostinfo - "
2562 "Unable to write out hp_host_info @ %p\n",
2563 __FILE__, __LINE__, uarg);
2564 return -EFAULT;
2565 }
2566
2567 return 0;
2568
2569}
2570
2571/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
ba856d32 2572/* Prototype Routine for the TARGET INFO command.
1da177e4
LT		 2573 *
2574 * Outputs: None.
2575 * Return: 0 if successful
2576 * -EFAULT if data unavailable
2577 * -EBUSY if previous command timout and IOC reset is not complete.
2578 * -ENODEV if no such device/adapter
2579 * -ETIME if timer expires
2580 * -ENOMEM if memory allocation error
2581 */
2582static int
2583mptctl_hp_targetinfo(unsigned long arg)
2584{
2585 hp_target_info_t __user *uarg = (void __user *) arg;
2586 SCSIDevicePage0_t *pg0_alloc;
2587 SCSIDevicePage3_t *pg3_alloc;
2588 MPT_ADAPTER *ioc;
2589 MPT_SCSI_HOST *hd = NULL;
2590 hp_target_info_t karg;
2591 int iocnum;
2592 int data_sz;
2593 dma_addr_t page_dma;
2594 CONFIGPARMS cfg;
2595 ConfigPageHeader_t hdr;
2596 int tmp, np, rc = 0;
2597
2598 dctlprintk((": mptctl_hp_targetinfo called.\n"));
2599 if (copy_from_user(&karg, uarg, sizeof(hp_target_info_t))) {
2600 printk(KERN_ERR "%s@%d::mptctl_hp_targetinfo - "
2601 "Unable to read in hp_host_targetinfo struct @ %p\n",
2602 __FILE__, __LINE__, uarg);
2603 return -EFAULT;
2604 }
2605
2606 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
2607 (ioc == NULL)) {
2608 dctlprintk((KERN_ERR "%s::mptctl_hp_targetinfo() @%d - ioc%d not found!\n",
2609 __FILE__, __LINE__, iocnum));
2610 return -ENODEV;
2611 }
2612
2613 /* There is nothing to do for FCP parts.
2614 */
9cc1cfbc 2615 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
1da177e4
LT		 2616 return 0;
2617
2618 if ((ioc->spi_data.sdp0length == 0) || (ioc->sh == NULL))
2619 return 0;
2620
2621 if (ioc->sh->host_no != karg.hdr.host)
2622 return -ENODEV;
2623
2624 /* Get the data transfer speeds
2625 */
2626 data_sz = ioc->spi_data.sdp0length * 4;
2627 pg0_alloc = (SCSIDevicePage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
2628 if (pg0_alloc) {
2629 hdr.PageVersion = ioc->spi_data.sdp0version;
2630 hdr.PageLength = data_sz;
2631 hdr.PageNumber = 0;
2632 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2633
69218ee5 2634 cfg.cfghdr.hdr = &hdr;
1da177e4
LT		 2635 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2636 cfg.dir = 0;
2637 cfg.timeout = 0;
2638 cfg.physAddr = page_dma;
2639
2640 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2641
2642 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2643 np = le32_to_cpu(pg0_alloc->NegotiatedParameters);
2644 karg.negotiated_width = np & MPI_SCSIDEVPAGE0_NP_WIDE ?
2645 HP_BUS_WIDTH_16 : HP_BUS_WIDTH_8;
2646
2647 if (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) {
2648 tmp = (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> 8;
2649 if (tmp < 0x09)
2650 karg.negotiated_speed = HP_DEV_SPEED_ULTRA320;
2651 else if (tmp <= 0x09)
2652 karg.negotiated_speed = HP_DEV_SPEED_ULTRA160;
2653 else if (tmp <= 0x0A)
2654 karg.negotiated_speed = HP_DEV_SPEED_ULTRA2;
2655 else if (tmp <= 0x0C)
2656 karg.negotiated_speed = HP_DEV_SPEED_ULTRA;
2657 else if (tmp <= 0x25)
2658 karg.negotiated_speed = HP_DEV_SPEED_FAST;
2659 else
2660 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2661 } else
2662 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2663 }
2664
2665 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg0_alloc, page_dma);
2666 }
2667
2668 /* Set defaults
2669 */
2670 karg.message_rejects = -1;
2671 karg.phase_errors = -1;
2672 karg.parity_errors = -1;
2673 karg.select_timeouts = -1;
2674
2675 /* Get the target error parameters
2676 */
2677 hdr.PageVersion = 0;
2678 hdr.PageLength = 0;
2679 hdr.PageNumber = 3;
2680 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2681
69218ee5 2682 cfg.cfghdr.hdr = &hdr;
1da177e4
LT		 2683 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2684 cfg.dir = 0;
2685 cfg.timeout = 0;
2686 cfg.physAddr = -1;
69218ee5 2687 if ((mpt_config(ioc, &cfg) == 0) && (cfg.cfghdr.hdr->PageLength > 0)) {
1da177e4
LT		 2688 /* Issue the second config page request */
2689 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
69218ee5 2690 data_sz = (int) cfg.cfghdr.hdr->PageLength * 4;
1da177e4
LT		 2691 pg3_alloc = (SCSIDevicePage3_t *) pci_alloc_consistent(
2692 ioc->pcidev, data_sz, &page_dma);
2693 if (pg3_alloc) {
2694 cfg.physAddr = page_dma;
2695 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2696 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2697 karg.message_rejects = (u32) le16_to_cpu(pg3_alloc->MsgRejectCount);
2698 karg.phase_errors = (u32) le16_to_cpu(pg3_alloc->PhaseErrorCount);
2699 karg.parity_errors = (u32) le16_to_cpu(pg3_alloc->ParityErrorCount);
2700 }
2701 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg3_alloc, page_dma);
2702 }
2703 }
2704 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
2705 if (hd != NULL)
2706 karg.select_timeouts = hd->sel_timeout[karg.hdr.id];
2707
2708 /* Copy the data from kernel memory to user memory
2709 */
2710 if (copy_to_user((char __user *)arg, &karg, sizeof(hp_target_info_t))) {
2711 printk(KERN_ERR "%s@%d::mptctl_hp_target_info - "
2712 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
2713 __FILE__, __LINE__, uarg);
2714 return -EFAULT;
2715 }
2716
2717 return 0;
2718}
2719
2720/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2721
2722static struct file_operations mptctl_fops = {
2723 .owner = THIS_MODULE,
2724 .llseek = no_llseek,
ea5a7a82
ME		 2725 .release = mptctl_release,
2726 .fasync = mptctl_fasync,
1da177e4
LT		 2727 .unlocked_ioctl = mptctl_ioctl,
2728#ifdef CONFIG_COMPAT
2729 .compat_ioctl = compat_mpctl_ioctl,
2730#endif
2731};
2732
2733static struct miscdevice mptctl_miscdev = {
2734 MPT_MINOR,
2735 MYNAM,
2736 &mptctl_fops
2737};
2738
2739/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2740
2741#ifdef CONFIG_COMPAT
2742
1da177e4
LT		 2743static int
2744compat_mptfwxfer_ioctl(struct file *filp, unsigned int cmd,
2745 unsigned long arg)
2746{
2747 struct mpt_fw_xfer32 kfw32;
2748 struct mpt_fw_xfer kfw;
2749 MPT_ADAPTER *iocp = NULL;
2750 int iocnum, iocnumX;
2751 int nonblock = (filp->f_flags & O_NONBLOCK);
2752 int ret;
2753
2754 dctlprintk((KERN_INFO MYNAM "::compat_mptfwxfer_ioctl() called\n"));
2755
2756 if (copy_from_user(&kfw32, (char __user *)arg, sizeof(kfw32)))
2757 return -EFAULT;
2758
2759 /* Verify intended MPT adapter */
2760 iocnumX = kfw32.iocnum & 0xFF;
2761 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2762 (iocp == NULL)) {
2763 dctlprintk((KERN_ERR MYNAM "::compat_mptfwxfer_ioctl @%d - ioc%d not found!\n",
2764 __LINE__, iocnumX));
2765 return -ENODEV;
2766 }
2767
2768 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2769 return ret;
2770
2771 kfw.iocnum = iocnum;
2772 kfw.fwlen = kfw32.fwlen;
2773 kfw.bufp = compat_ptr(kfw32.bufp);
2774
2775 ret = mptctl_do_fw_download(kfw.iocnum, kfw.bufp, kfw.fwlen);
2776
eeb846ce 2777 mutex_unlock(&iocp->ioctl->ioctl_mutex);
1da177e4
LT		 2778
2779 return ret;
2780}
2781
2782static int
2783compat_mpt_command(struct file *filp, unsigned int cmd,
2784 unsigned long arg)
2785{
2786 struct mpt_ioctl_command32 karg32;
2787 struct mpt_ioctl_command32 __user *uarg = (struct mpt_ioctl_command32 __user *) arg;
2788 struct mpt_ioctl_command karg;
2789 MPT_ADAPTER *iocp = NULL;
2790 int iocnum, iocnumX;
2791 int nonblock = (filp->f_flags & O_NONBLOCK);
2792 int ret;
2793
2794 dctlprintk((KERN_INFO MYNAM "::compat_mpt_command() called\n"));
2795
2796 if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32)))
2797 return -EFAULT;
2798
2799 /* Verify intended MPT adapter */
2800 iocnumX = karg32.hdr.iocnum & 0xFF;
2801 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2802 (iocp == NULL)) {
2803 dctlprintk((KERN_ERR MYNAM "::compat_mpt_command @%d - ioc%d not found!\n",
2804 __LINE__, iocnumX));
2805 return -ENODEV;
2806 }
2807
2808 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2809 return ret;
2810
2811 /* Copy data to karg */
2812 karg.hdr.iocnum = karg32.hdr.iocnum;
2813 karg.hdr.port = karg32.hdr.port;
2814 karg.timeout = karg32.timeout;
2815 karg.maxReplyBytes = karg32.maxReplyBytes;
2816
2817 karg.dataInSize = karg32.dataInSize;
2818 karg.dataOutSize = karg32.dataOutSize;
2819 karg.maxSenseBytes = karg32.maxSenseBytes;
2820 karg.dataSgeOffset = karg32.dataSgeOffset;
2821
2822 karg.replyFrameBufPtr = (char __user *)(unsigned long)karg32.replyFrameBufPtr;
2823 karg.dataInBufPtr = (char __user *)(unsigned long)karg32.dataInBufPtr;
2824 karg.dataOutBufPtr = (char __user *)(unsigned long)karg32.dataOutBufPtr;
2825 karg.senseDataPtr = (char __user *)(unsigned long)karg32.senseDataPtr;
2826
2827 /* Pass new structure to do_mpt_command
2828 */
2829 ret = mptctl_do_mpt_command (karg, &uarg->MF);
2830
eeb846ce 2831 mutex_unlock(&iocp->ioctl->ioctl_mutex);
1da177e4
LT		 2832
2833 return ret;
2834}
2835
2836static long compat_mpctl_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
2837{
2838 long ret;
2839 lock_kernel();
2840 switch (cmd) {
2841 case MPTIOCINFO:
2842 case MPTIOCINFO1:
2843 case MPTIOCINFO2:
2844 case MPTTARGETINFO:
2845 case MPTEVENTQUERY:
2846 case MPTEVENTENABLE:
2847 case MPTEVENTREPORT:
2848 case MPTHARDRESET:
2849 case HP_GETHOSTINFO:
2850 case HP_GETTARGETINFO:
2851 case MPTTEST:
2852 ret = __mptctl_ioctl(f, cmd, arg);
2853 break;
2854 case MPTCOMMAND32:
2855 ret = compat_mpt_command(f, cmd, arg);
2856 break;
2857 case MPTFWDOWNLOAD32:
2858 ret = compat_mptfwxfer_ioctl(f, cmd, arg);
2859 break;
2860 default:
2861 ret = -ENOIOCTLCMD;
2862 break;
2863 }
2864 unlock_kernel();
2865 return ret;
2866}
2867
2868#endif
2869
2870
2871/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2872/*
2873 * mptctl_probe - Installs ioctl devices per bus.
2874 * @pdev: Pointer to pci_dev structure
2875 *
2876 * Returns 0 for success, non-zero for failure.
2877 *
2878 */
2879
2880static int
2881mptctl_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2882{
2883 int err;
2884 int sz;
2885 u8 *mem;
2886 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
2887
2888 /*
2889 * Allocate and inite a MPT_IOCTL structure
2890 */
2891 sz = sizeof (MPT_IOCTL);
2892 mem = kmalloc(sz, GFP_KERNEL);
2893 if (mem == NULL) {
2894 err = -ENOMEM;
2895 goto out_fail;
2896 }
2897
2898 memset(mem, 0, sz);
2899 ioc->ioctl = (MPT_IOCTL *) mem;
2900 ioc->ioctl->ioc = ioc;
eeb846ce 2901 mutex_init(&ioc->ioctl->ioctl_mutex);
1da177e4
LT		 2902 return 0;
2903
2904out_fail:
2905
2906 mptctl_remove(pdev);
2907 return err;
2908}
2909
2910/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2911/*
2912 * mptctl_remove - Removed ioctl devices
2913 * @pdev: Pointer to pci_dev structure
2914 *
2915 *
2916 */
2917static void
2918mptctl_remove(struct pci_dev *pdev)
2919{
2920 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
2921
2922 kfree ( ioc->ioctl );
2923}
2924
2925static struct mpt_pci_driver mptctl_driver = {
2926 .probe = mptctl_probe,
2927 .remove = mptctl_remove,
2928};
2929
2930/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2931static int __init mptctl_init(void)
2932{
2933 int err;
2934 int where = 1;
2935
2936 show_mptmod_ver(my_NAME, my_VERSION);
2937
2938 if(mpt_device_driver_register(&mptctl_driver,
2939 MPTCTL_DRIVER) != 0 ) {
2940 dprintk((KERN_INFO MYNAM
2941 ": failed to register dd callbacks\n"));
2942 }
2943
2944 /* Register this device */
2945 err = misc_register(&mptctl_miscdev);
2946 if (err < 0) {
2947 printk(KERN_ERR MYNAM ": Can't register misc device [minor=%d].\n", MPT_MINOR);
2948 goto out_fail;
2949 }
2950 printk(KERN_INFO MYNAM ": Registered with Fusion MPT base driver\n");
2951 printk(KERN_INFO MYNAM ": /dev/%s @ (major,minor=%d,%d)\n",
2952 mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
2953
2954 /*
2955 * Install our handler
2956 */
2957 ++where;
2958 if ((mptctl_id = mpt_register(mptctl_reply, MPTCTL_DRIVER)) < 0) {
2959 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
2960 misc_deregister(&mptctl_miscdev);
2961 err = -EBUSY;
2962 goto out_fail;
2963 }
2964
2965 if (mpt_reset_register(mptctl_id, mptctl_ioc_reset) == 0) {
2966 dprintk((KERN_INFO MYNAM ": Registered for IOC reset notifications\n"));
2967 } else {
2968 /* FIXME! */
2969 }
2970
ea5a7a82 2971 if (mpt_event_register(mptctl_id, mptctl_event_process) == 0) {
3a892bef 2972 devtverboseprintk((KERN_INFO MYNAM
ea5a7a82
ME		 2973 ": Registered for IOC event notifications\n"));
2974 }
2975
1da177e4
LT		 2976 return 0;
2977
2978out_fail:
2979
2980 mpt_device_driver_deregister(MPTCTL_DRIVER);
2981
2982 return err;
2983}
2984
2985/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2986static void mptctl_exit(void)
2987{
2988 misc_deregister(&mptctl_miscdev);
2989 printk(KERN_INFO MYNAM ": Deregistered /dev/%s @ (major,minor=%d,%d)\n",
2990 mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
2991
2992 /* De-register reset handler from base module */
2993 mpt_reset_deregister(mptctl_id);
2994 dprintk((KERN_INFO MYNAM ": Deregistered for IOC reset notifications\n"));
2995
2996 /* De-register callback handler from base module */
2997 mpt_deregister(mptctl_id);
2998 printk(KERN_INFO MYNAM ": Deregistered from Fusion MPT base driver\n");
2999
3000 mpt_device_driver_deregister(MPTCTL_DRIVER);
3001
3002}
3003
3004/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3005
3006module_init(mptctl_init);
3007module_exit(mptctl_exit);
Linux kernel - Deliverables
This page took 0.29379 seconds and 5 git commands to generate.