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