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