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