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