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