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