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