blob: 24aebad6036670a2c377b59322115ed28ebacce0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/drivers/message/fusion/mptctl.c
Moore, Eric Dean b6fe4dd2005-04-22 18:01:34 -04003 * mpt Ioctl driver.
Prakash, Sathyaf36789e2007-08-14 16:22:54 +05304 * For use with LSI PCI chip/adapters
5 * running LSI Fusion MPT (Message Passing Technology) firmware.
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
Prakash, Sathyacddc0ab2008-05-21 00:56:41 +05307 * Copyright (c) 1999-2008 LSI Corporation
Eric Moore16d20102007-06-13 16:31:07 -06008 * (mailto:DL-MPTFusionLinux@lsi.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 */
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#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>
Arnd Bergmannc45d15d2010-06-02 14:28:52 +020057#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070058#include <linux/compat.h>
59
60#include <asm/io.h>
Linus Torvalds7c0f6ba2016-12-24 11:46:01 -080061#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
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
Prakash, Sathyacddc0ab2008-05-21 00:56:41 +053069#define COPYRIGHT "Copyright (c) 1999-2008 LSI Corporation"
Prakash, Sathyaf36789e2007-08-14 16:22:54 +053070#define MODULEAUTHOR "LSI Corporation"
Linus Torvalds1da177e2005-04-16 15:20:36 -070071#include "mptbase.h"
72#include "mptctl.h"
73
74/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
75#define my_NAME "Fusion MPT misc device (ioctl) driver"
76#define my_VERSION MPT_LINUX_VERSION_COMMON
77#define MYNAM "mptctl"
78
79MODULE_AUTHOR(MODULEAUTHOR);
80MODULE_DESCRIPTION(my_NAME);
81MODULE_LICENSE("GPL");
Eric Moore9f4203b2007-01-04 20:47:47 -070082MODULE_VERSION(my_VERSION);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
84/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
85
Arnd Bergmannc45d15d2010-06-02 14:28:52 +020086static DEFINE_MUTEX(mpctl_mutex);
Prakash, Sathyaf606f572007-08-14 16:12:53 +053087static u8 mptctl_id = MPT_MAX_PROTOCOL_DRIVERS;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +053088static u8 mptctl_taskmgmt_id = MPT_MAX_PROTOCOL_DRIVERS;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
90static DECLARE_WAIT_QUEUE_HEAD ( mptctl_wait );
91
92/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
93
94struct buflist {
95 u8 *kptr;
96 int len;
97};
98
99/*
100 * Function prototypes. Called from OS entry point mptctl_ioctl.
101 * arg contents specific to function.
102 */
Dan Carpenter28d76df2020-01-14 15:34:14 +0300103static int mptctl_fw_download(MPT_ADAPTER *iocp, unsigned long arg);
104static int mptctl_getiocinfo(MPT_ADAPTER *iocp, unsigned long arg, unsigned int cmd);
105static int mptctl_gettargetinfo(MPT_ADAPTER *iocp, unsigned long arg);
106static int mptctl_readtest(MPT_ADAPTER *iocp, unsigned long arg);
107static int mptctl_mpt_command(MPT_ADAPTER *iocp, unsigned long arg);
108static int mptctl_eventquery(MPT_ADAPTER *iocp, unsigned long arg);
109static int mptctl_eventenable(MPT_ADAPTER *iocp, unsigned long arg);
110static int mptctl_eventreport(MPT_ADAPTER *iocp, unsigned long arg);
111static int mptctl_replace_fw(MPT_ADAPTER *iocp, unsigned long arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112
Dan Carpenter28d76df2020-01-14 15:34:14 +0300113static int mptctl_do_reset(MPT_ADAPTER *iocp, unsigned long arg);
114static int mptctl_hp_hostinfo(MPT_ADAPTER *iocp, unsigned long arg, unsigned int cmd);
115static int mptctl_hp_targetinfo(MPT_ADAPTER *iocp, unsigned long arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
117static int mptctl_probe(struct pci_dev *, const struct pci_device_id *);
118static void mptctl_remove(struct pci_dev *);
119
120#ifdef CONFIG_COMPAT
121static long compat_mpctl_ioctl(struct file *f, unsigned cmd, unsigned long arg);
122#endif
123/*
124 * Private function calls.
125 */
Dan Carpenter28d76df2020-01-14 15:34:14 +0300126static int mptctl_do_mpt_command(MPT_ADAPTER *iocp, struct mpt_ioctl_command karg, void __user *mfPtr);
127static int mptctl_do_fw_download(MPT_ADAPTER *iocp, char __user *ufwbuf, size_t fwlen);
Moore, Eric Dean d485eb82005-05-11 17:37:26 -0600128static MptSge_t *kbuf_alloc_2_sgl(int bytes, u32 dir, int sge_offset, int *frags,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc);
Moore, Eric Dean d485eb82005-05-11 17:37:26 -0600130static void kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 struct buflist *buflist, MPT_ADAPTER *ioc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
133/*
134 * Reset Handler cleanup function
135 */
136static int mptctl_ioc_reset(MPT_ADAPTER *ioc, int reset_phase);
137
Moore, Ericea5a7a822006-02-02 17:20:01 -0700138/*
139 * Event Handler function
140 */
141static int mptctl_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
Moore, Ericc972c702006-03-14 09:14:06 -0700142static struct fasync_struct *async_queue=NULL;
Moore, Ericea5a7a822006-02-02 17:20:01 -0700143
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
145/*
146 * Scatter gather list (SGL) sizes and limits...
147 */
148//#define MAX_SCSI_FRAGS 9
149#define MAX_FRAGS_SPILL1 9
150#define MAX_FRAGS_SPILL2 15
151#define FRAGS_PER_BUCKET (MAX_FRAGS_SPILL2 + 1)
152
153//#define MAX_CHAIN_FRAGS 64
154//#define MAX_CHAIN_FRAGS (15+15+15+16)
155#define MAX_CHAIN_FRAGS (4 * MAX_FRAGS_SPILL2 + 1)
156
157// Define max sg LIST bytes ( == (#frags + #chains) * 8 bytes each)
158// Works out to: 592d bytes! (9+1)*8 + 4*(15+1)*8
159// ^----------------- 80 + 512
160#define MAX_SGL_BYTES ((MAX_FRAGS_SPILL1 + 1 + (4 * FRAGS_PER_BUCKET)) * 8)
161
162/* linux only seems to ever give 128kB MAX contiguous (GFP_USER) mem bytes */
163#define MAX_KMALLOC_SZ (128*1024)
164
165#define MPT_IOCTL_DEFAULT_TIMEOUT 10 /* Default timeout value (seconds) */
166
167/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
168/**
169 * mptctl_syscall_down - Down the MPT adapter syscall semaphore.
170 * @ioc: Pointer to MPT adapter
171 * @nonblock: boolean, non-zero if O_NONBLOCK is set
172 *
173 * All of the ioctl commands can potentially sleep, which is illegal
174 * with a spinlock held, thus we perform mutual exclusion here.
175 *
176 * Returns negative errno on error, or zero for success.
177 */
178static inline int
179mptctl_syscall_down(MPT_ADAPTER *ioc, int nonblock)
180{
181 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182
183 if (nonblock) {
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530184 if (!mutex_trylock(&ioc->ioctl_cmds.mutex))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 rc = -EAGAIN;
186 } else {
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530187 if (mutex_lock_interruptible(&ioc->ioctl_cmds.mutex))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 rc = -ERESTARTSYS;
189 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 return rc;
191}
192
193/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
194/*
195 * This is the callback for any message we have posted. The message itself
196 * will be returned to the message pool when we return from the IRQ
197 *
198 * This runs in irq context so be short and sweet.
199 */
200static int
201mptctl_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply)
202{
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530203 char *sense_data;
204 int req_index;
205 int sz;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530207 if (!req)
208 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530210 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));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530214 /*
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530221 ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530223 if (!reply)
224 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530226 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530230 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)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530236 if ((req->u.hdr.Function == MPI_FUNCTION_SCSI_IO_REQUEST) ||
237 (req->u.hdr.Function ==
238 MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530240 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)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530249 if (reply->u.sreply.SCSIState &
250 MPI_SCSI_STATE_AUTOSENSE_VALID) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 sz = req->u.scsireq.SenseBufferLength;
252 req_index =
253 le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx);
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530254 sense_data = ((u8 *)ioc->sense_buf_pool +
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 (req_index * MPT_SENSE_BUFFER_ALLOC));
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530256 memcpy(ioc->ioctl_cmds.sense, sense_data, sz);
257 ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_SENSE_VALID;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 }
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530260
261 out:
262 /* We are done, issue wake up
263 */
264 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_PENDING) {
Kashyap, Desaib68bf092010-06-17 14:40:56 +0530265 if (req->u.hdr.Function == MPI_FUNCTION_SCSI_TASK_MGMT) {
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530266 mpt_clear_taskmgmt_in_progress_flag(ioc);
Kashyap, Desaib68bf092010-06-17 14:40:56 +0530267 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 }
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530275 }
276
277 out_continuation:
278 if (reply && (reply->u.reply.MsgFlags &
279 MPI_MSGFLAGS_CONTINUATION_REPLY))
280 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 return 1;
282}
283
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530284
285static int
286mptctl_taskmgmt_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
287{
288 if (!mf)
289 return 0;
290
291 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
292 "TaskMgmt completed (mf=%p, mr=%p)\n",
293 ioc->name, mf, mr));
294
295 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
296
297 if (!mr)
298 goto out;
299
300 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
301 memcpy(ioc->taskmgmt_cmds.reply, mr,
302 min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
303 out:
304 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
305 mpt_clear_taskmgmt_in_progress_flag(ioc);
306 ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
307 complete(&ioc->taskmgmt_cmds.done);
Kashyap, Desaib68bf092010-06-17 14:40:56 +0530308 if (ioc->bus_type == SAS)
309 ioc->schedule_target_reset(ioc);
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530310 return 1;
311 }
312 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313}
314
Kashyap, Desai7d757f12010-03-18 19:13:10 +0530315static int
316mptctl_do_taskmgmt(MPT_ADAPTER *ioc, u8 tm_type, u8 bus_id, u8 target_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317{
318 MPT_FRAME_HDR *mf;
319 SCSITaskMgmt_t *pScsiTm;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530320 SCSITaskMgmtReply_t *pScsiTmReply;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 int ii;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530322 int retval;
323 unsigned long timeout;
324 unsigned long time_count;
325 u16 iocstatus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530328 mutex_lock(&ioc->taskmgmt_cmds.mutex);
329 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
330 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 return -EPERM;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530332 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530334 retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530336 mf = mpt_get_msg_frame(mptctl_taskmgmt_id, ioc);
337 if (mf == NULL) {
Kashyap, Desai7d757f12010-03-18 19:13:10 +0530338 dtmprintk(ioc,
339 printk(MYIOC_s_WARN_FMT "TaskMgmt, no msg frames!!\n",
340 ioc->name));
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530341 mpt_clear_taskmgmt_in_progress_flag(ioc);
342 retval = -ENOMEM;
Kashyap, Desai7d757f12010-03-18 19:13:10 +0530343 goto tm_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 }
345
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530346 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
347 ioc->name, mf));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
349 pScsiTm = (SCSITaskMgmt_t *) mf;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530350 memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
Kashyap, Desai7d757f12010-03-18 19:13:10 +0530352 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;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530359 pScsiTm->ChainOffset = 0;
360 pScsiTm->Reserved = 0;
361 pScsiTm->Reserved1 = 0;
362 pScsiTm->TaskMsgContext = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 for (ii= 0; ii < 8; ii++)
364 pScsiTm->LUN[ii] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 for (ii=0; ii < 7; ii++)
366 pScsiTm->Reserved2[ii] = 0;
367
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530368 switch (ioc->bus_type) {
369 case FC:
370 timeout = 40;
371 break;
372 case SAS:
373 timeout = 30;
374 break;
375 case SPI:
Kashyap, Desai7d757f12010-03-18 19:13:10 +0530376 default:
377 timeout = 10;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530378 break;
379 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380
Kashyap, Desai7d757f12010-03-18 19:13:10 +0530381 dtmprintk(ioc,
382 printk(MYIOC_s_DEBUG_FMT "TaskMgmt type=%d timeout=%ld\n",
383 ioc->name, tm_type, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530385 INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530386 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);
Prakash, Sathya7a195f42007-08-14 16:08:40 +0530390 else {
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530391 retval = mpt_send_handshake_request(mptctl_taskmgmt_id, ioc,
392 sizeof(SCSITaskMgmt_t), (u32 *)pScsiTm, CAN_SLEEP);
Prakash, Sathya7a195f42007-08-14 16:08:40 +0530393 if (retval != 0) {
Kashyap, Desai7d757f12010-03-18 19:13:10 +0530394 dfailprintk(ioc,
395 printk(MYIOC_s_ERR_FMT
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530396 "TaskMgmt send_handshake FAILED!"
397 " (ioc %p, mf %p, rc=%d) \n", ioc->name,
398 ioc, mf, retval));
Kashyap, Desai7d757f12010-03-18 19:13:10 +0530399 mpt_free_msg_frame(ioc, mf);
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530400 mpt_clear_taskmgmt_in_progress_flag(ioc);
Kashyap, Desai7d757f12010-03-18 19:13:10 +0530401 goto tm_done;
Prakash, Sathya7a195f42007-08-14 16:08:40 +0530402 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 }
404
405 /* Now wait for the command to complete */
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530406 ii = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done, timeout*HZ);
Kashyap, Desai7d757f12010-03-18 19:13:10 +0530407
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530408 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 */
Kashyap, Desai7d757f12010-03-18 19:13:10 +0530417 goto tm_done;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530418 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530420 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 */
Kashyap, Desai7d757f12010-03-18 19:13:10 +0530424 goto tm_done;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530425 }
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,
Kashyap, Desai7d757f12010-03-18 19:13:10 +0530432 pScsiTmReply->TargetID, tm_type,
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530433 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));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 retval = -1; /* return failure */
448 }
449
Kashyap, Desai7d757f12010-03-18 19:13:10 +0530450 tm_done:
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530451 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
452 CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 return retval;
454}
455
Kashyap, Desai7d757f12010-03-18 19:13:10 +0530456/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
457/* mptctl_timeout_expired
458 *
459 * Expecting an interrupt, however timed out.
460 *
461 */
462static void
463mptctl_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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
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 */
523static int
524mptctl_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
525{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 switch(reset_phase) {
527 case MPT_IOC_SETUP_RESET:
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530528 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
529 "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 break;
531 case MPT_IOC_PRE_RESET:
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530532 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 default:
544 break;
545 }
546
547 return 1;
548}
549
550/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Moore, Ericea5a7a822006-02-02 17:20:01 -0700551/* ASYNC Event Notification Support */
552static int
553mptctl_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
554{
555 u8 event;
556
557 event = le32_to_cpu(pEvReply->Event) & 0xFF;
558
Prakash, Sathya09120a82007-07-24 15:49:05 +0530559 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s() called\n",
Harvey Harrisoncadbd4a2008-07-03 23:47:27 -0700560 ioc->name, __func__));
Moore, Ericea5a7a822006-02-02 17:20:01 -0700561 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 */
Colin Ian King244830a2019-02-07 12:44:07 +0000568 if (event == 0x21) {
Moore, Ericea5a7a822006-02-02 17:20:01 -0700569 ioc->aen_event_read_flag=1;
Prakash, Sathya09120a82007-07-24 15:49:05 +0530570 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));
Moore, Ericea5a7a822006-02-02 17:20:01 -0700574 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;
Prakash, Sathya09120a82007-07-24 15:49:05 +0530590 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));
Moore, Ericea5a7a822006-02-02 17:20:01 -0700594 kill_fasync(&async_queue, SIGIO, POLL_IN);
595 }
596 return 1;
597}
598
599static int
600mptctl_fasync(int fd, struct file *filep, int mode)
601{
602 MPT_ADAPTER *ioc;
Jonathan Corbetb7e3e1f2008-06-19 15:41:11 -0600603 int ret;
Moore, Ericea5a7a822006-02-02 17:20:01 -0700604
Arnd Bergmannc45d15d2010-06-02 14:28:52 +0200605 mutex_lock(&mpctl_mutex);
Moore, Ericea5a7a822006-02-02 17:20:01 -0700606 list_for_each_entry(ioc, &ioc_list, list)
607 ioc->aen_event_read_flag=0;
608
Jonathan Corbetb7e3e1f2008-06-19 15:41:11 -0600609 ret = fasync_helper(fd, filep, mode, &async_queue);
Arnd Bergmannc45d15d2010-06-02 14:28:52 +0200610 mutex_unlock(&mpctl_mutex);
Jonathan Corbetb7e3e1f2008-06-19 15:41:11 -0600611 return ret;
Moore, Ericea5a7a822006-02-02 17:20:01 -0700612}
613
Moore, Ericea5a7a822006-02-02 17:20:01 -0700614/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615/*
616 * MPT ioctl handler
617 * cmd - specify the particular IOCTL command to be issued
618 * arg - data specific to the command. Must not be null.
619 */
620static long
621__mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
622{
623 mpt_ioctl_header __user *uhdr = (void __user *) arg;
624 mpt_ioctl_header khdr;
625 int iocnum;
626 unsigned iocnumX;
627 int nonblock = (file->f_flags & O_NONBLOCK);
628 int ret;
629 MPT_ADAPTER *iocp = NULL;
630
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 if (copy_from_user(&khdr, uhdr, sizeof(khdr))) {
Eric Moore29dd3602007-09-14 18:46:51 -0600632 printk(KERN_ERR MYNAM "%s::mptctl_ioctl() @%d - "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 "Unable to copy mpt_ioctl_header data @ %p\n",
634 __FILE__, __LINE__, uhdr);
635 return -EFAULT;
636 }
637 ret = -ENXIO; /* (-6) No such device or address */
638
639 /* Verify intended MPT adapter - set iocnum and the adapter
640 * pointer (iocp)
641 */
642 iocnumX = khdr.iocnum & 0xFF;
643 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
Kashyap, Desaie39e1452009-10-07 11:26:54 +0530644 (iocp == NULL))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
647 if (!iocp->active) {
Eric Moore29dd3602007-09-14 18:46:51 -0600648 printk(KERN_DEBUG MYNAM "%s::mptctl_ioctl() @%d - Controller disabled.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 __FILE__, __LINE__);
650 return -EFAULT;
651 }
652
653 /* Handle those commands that are just returning
654 * information stored in the driver.
655 * These commands should never time out and are unaffected
656 * by TM and FW reloads.
657 */
658 if ((cmd & ~IOCSIZE_MASK) == (MPTIOCINFO & ~IOCSIZE_MASK)) {
Dan Carpenter28d76df2020-01-14 15:34:14 +0300659 return mptctl_getiocinfo(iocp, arg, _IOC_SIZE(cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 } else if (cmd == MPTTARGETINFO) {
Dan Carpenter28d76df2020-01-14 15:34:14 +0300661 return mptctl_gettargetinfo(iocp, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 } else if (cmd == MPTTEST) {
Dan Carpenter28d76df2020-01-14 15:34:14 +0300663 return mptctl_readtest(iocp, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 } else if (cmd == MPTEVENTQUERY) {
Dan Carpenter28d76df2020-01-14 15:34:14 +0300665 return mptctl_eventquery(iocp, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 } else if (cmd == MPTEVENTENABLE) {
Dan Carpenter28d76df2020-01-14 15:34:14 +0300667 return mptctl_eventenable(iocp, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 } else if (cmd == MPTEVENTREPORT) {
Dan Carpenter28d76df2020-01-14 15:34:14 +0300669 return mptctl_eventreport(iocp, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 } else if (cmd == MPTFWREPLACE) {
Dan Carpenter28d76df2020-01-14 15:34:14 +0300671 return mptctl_replace_fw(iocp, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 }
673
674 /* All of these commands require an interrupt or
675 * are unknown/illegal.
676 */
677 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
678 return ret;
679
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 if (cmd == MPTFWDOWNLOAD)
Dan Carpenter28d76df2020-01-14 15:34:14 +0300681 ret = mptctl_fw_download(iocp, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 else if (cmd == MPTCOMMAND)
Dan Carpenter28d76df2020-01-14 15:34:14 +0300683 ret = mptctl_mpt_command(iocp, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 else if (cmd == MPTHARDRESET)
Dan Carpenter28d76df2020-01-14 15:34:14 +0300685 ret = mptctl_do_reset(iocp, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 else if ((cmd & ~IOCSIZE_MASK) == (HP_GETHOSTINFO & ~IOCSIZE_MASK))
Dan Carpenter28d76df2020-01-14 15:34:14 +0300687 ret = mptctl_hp_hostinfo(iocp, arg, _IOC_SIZE(cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 else if (cmd == HP_GETTARGETINFO)
Dan Carpenter28d76df2020-01-14 15:34:14 +0300689 ret = mptctl_hp_targetinfo(iocp, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 else
691 ret = -EINVAL;
692
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530693 mutex_unlock(&iocp->ioctl_cmds.mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694
695 return ret;
696}
697
698static long
699mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
700{
701 long ret;
Arnd Bergmannc45d15d2010-06-02 14:28:52 +0200702 mutex_lock(&mpctl_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 ret = __mptctl_ioctl(file, cmd, arg);
Arnd Bergmannc45d15d2010-06-02 14:28:52 +0200704 mutex_unlock(&mpctl_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 return ret;
706}
707
Dan Carpenter28d76df2020-01-14 15:34:14 +0300708static int mptctl_do_reset(MPT_ADAPTER *iocp, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709{
710 struct mpt_ioctl_diag_reset __user *urinfo = (void __user *) arg;
711 struct mpt_ioctl_diag_reset krinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 if (copy_from_user(&krinfo, urinfo, sizeof(struct mpt_ioctl_diag_reset))) {
Eric Moore29dd3602007-09-14 18:46:51 -0600714 printk(KERN_ERR MYNAM "%s@%d::mptctl_do_reset - "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 "Unable to copy mpt_ioctl_diag_reset struct @ %p\n",
716 __FILE__, __LINE__, urinfo);
717 return -EFAULT;
718 }
719
Prakash, Sathya09120a82007-07-24 15:49:05 +0530720 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "mptctl_do_reset called.\n",
721 iocp->name));
722
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 if (mpt_HardResetHandler(iocp, CAN_SLEEP) != 0) {
Eric Moore29dd3602007-09-14 18:46:51 -0600724 printk (MYIOC_s_ERR_FMT "%s@%d::mptctl_do_reset - reset failed.\n",
725 iocp->name, __FILE__, __LINE__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 return -1;
727 }
728
729 return 0;
730}
731
732/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
733/*
734 * MPT FW download function. Cast the arg into the mpt_fw_xfer structure.
735 * This structure contains: iocnum, firmware length (bytes),
736 * pointer to user space memory where the fw image is stored.
737 *
738 * Outputs: None.
739 * Return: 0 if successful
740 * -EFAULT if data unavailable
741 * -ENXIO if no such device
742 * -EAGAIN if resource problem
743 * -ENOMEM if no memory for SGE
744 * -EMLINK if too many chain buffers required
745 * -EBADRQC if adapter does not support FW download
746 * -EBUSY if adapter is busy
747 * -ENOMSG if FW upload returned bad status
748 */
749static int
Dan Carpenter28d76df2020-01-14 15:34:14 +0300750mptctl_fw_download(MPT_ADAPTER *iocp, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751{
752 struct mpt_fw_xfer __user *ufwdl = (void __user *) arg;
753 struct mpt_fw_xfer kfwdl;
754
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 if (copy_from_user(&kfwdl, ufwdl, sizeof(struct mpt_fw_xfer))) {
Eric Moore29dd3602007-09-14 18:46:51 -0600756 printk(KERN_ERR MYNAM "%s@%d::_ioctl_fwdl - "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 "Unable to copy mpt_fw_xfer struct @ %p\n",
758 __FILE__, __LINE__, ufwdl);
759 return -EFAULT;
760 }
761
Dan Carpenter28d76df2020-01-14 15:34:14 +0300762 return mptctl_do_fw_download(iocp, kfwdl.bufp, kfwdl.fwlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763}
764
765/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
766/*
767 * FW Download engine.
768 * Outputs: None.
769 * Return: 0 if successful
770 * -EFAULT if data unavailable
771 * -ENXIO if no such device
772 * -EAGAIN if resource problem
773 * -ENOMEM if no memory for SGE
774 * -EMLINK if too many chain buffers required
775 * -EBADRQC if adapter does not support FW download
776 * -EBUSY if adapter is busy
777 * -ENOMSG if FW upload returned bad status
778 */
779static int
Dan Carpenter28d76df2020-01-14 15:34:14 +0300780mptctl_do_fw_download(MPT_ADAPTER *iocp, char __user *ufwbuf, size_t fwlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781{
782 FWDownload_t *dlmsg;
783 MPT_FRAME_HDR *mf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 FWDownloadTCSGE_t *ptsge;
785 MptSge_t *sgl, *sgIn;
786 char *sgOut;
787 struct buflist *buflist;
788 struct buflist *bl;
789 dma_addr_t sgl_dma;
790 int ret;
791 int numfrags = 0;
792 int maxfrags;
793 int n = 0;
794 u32 sgdir;
795 u32 nib;
796 int fw_bytes_copied = 0;
797 int i;
798 int sge_offset = 0;
799 u16 iocstat;
800 pFWDownloadReply_t ReplyMsg = NULL;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530801 unsigned long timeleft;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
Dan Carpenter28d76df2020-01-14 15:34:14 +0300803 /* Valid device. Get a message frame and construct the FW download message.
804 */
805 if ((mf = mpt_get_msg_frame(mptctl_id, iocp)) == NULL)
806 return -EAGAIN;
Prakash, Sathya09120a82007-07-24 15:49:05 +0530807
808 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT
809 "mptctl_do_fwdl called. mptctl_id = %xh.\n", iocp->name, mptctl_id));
810 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.bufp = %p\n",
811 iocp->name, ufwbuf));
812 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.fwlen = %d\n",
813 iocp->name, (int)fwlen));
Prakash, Sathya09120a82007-07-24 15:49:05 +0530814
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 dlmsg = (FWDownload_t*) mf;
816 ptsge = (FWDownloadTCSGE_t *) &dlmsg->SGL;
817 sgOut = (char *) (ptsge + 1);
818
819 /*
820 * Construct f/w download request
821 */
822 dlmsg->ImageType = MPI_FW_DOWNLOAD_ITYPE_FW;
823 dlmsg->Reserved = 0;
824 dlmsg->ChainOffset = 0;
825 dlmsg->Function = MPI_FUNCTION_FW_DOWNLOAD;
826 dlmsg->Reserved1[0] = dlmsg->Reserved1[1] = dlmsg->Reserved1[2] = 0;
Moore, Eric946cbf02006-02-02 17:19:50 -0700827 if (iocp->facts.MsgVersion >= MPI_VERSION_01_05)
828 dlmsg->MsgFlags = MPI_FW_DOWNLOAD_MSGFLGS_LAST_SEGMENT;
829 else
830 dlmsg->MsgFlags = 0;
831
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
833 /* Set up the Transaction SGE.
834 */
835 ptsge->Reserved = 0;
836 ptsge->ContextSize = 0;
837 ptsge->DetailsLength = 12;
838 ptsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
839 ptsge->Reserved_0100_Checksum = 0;
840 ptsge->ImageOffset = 0;
841 ptsge->ImageSize = cpu_to_le32(fwlen);
842
843 /* Add the SGL
844 */
845
846 /*
847 * Need to kmalloc area(s) for holding firmware image bytes.
848 * But we need to do it piece meal, using a proper
849 * scatter gather list (with 128kB MAX hunks).
850 *
851 * A practical limit here might be # of sg hunks that fit into
852 * a single IOC request frame; 12 or 8 (see below), so:
853 * For FC9xx: 12 x 128kB == 1.5 mB (max)
854 * For C1030: 8 x 128kB == 1 mB (max)
855 * We could support chaining, but things get ugly(ier:)
856 *
857 * Set the sge_offset to the start of the sgl (bytes).
858 */
859 sgdir = 0x04000000; /* IOC will READ from sys mem */
860 sge_offset = sizeof(MPIHeader_t) + sizeof(FWDownloadTCSGE_t);
861 if ((sgl = kbuf_alloc_2_sgl(fwlen, sgdir, sge_offset,
862 &numfrags, &buflist, &sgl_dma, iocp)) == NULL)
863 return -ENOMEM;
864
865 /*
866 * We should only need SGL with 2 simple_32bit entries (up to 256 kB)
867 * for FC9xx f/w image, but calculate max number of sge hunks
868 * we can fit into a request frame, and limit ourselves to that.
869 * (currently no chain support)
870 * maxfrags = (Request Size - FWdownload Size ) / Size of 32 bit SGE
871 * Request maxfrags
872 * 128 12
873 * 96 8
874 * 64 4
875 */
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530876 maxfrags = (iocp->req_sz - sizeof(MPIHeader_t) -
877 sizeof(FWDownloadTCSGE_t))
878 / iocp->SGE_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 if (numfrags > maxfrags) {
880 ret = -EMLINK;
881 goto fwdl_out;
882 }
883
Prakash, Sathya09120a82007-07-24 15:49:05 +0530884 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: sgl buffer = %p, sgfrags = %d\n",
885 iocp->name, sgl, numfrags));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886
887 /*
888 * Parse SG list, copying sgl itself,
889 * plus f/w image hunks from user space as we go...
890 */
891 ret = -EFAULT;
892 sgIn = sgl;
893 bl = buflist;
894 for (i=0; i < numfrags; i++) {
895
896 /* Get the SGE type: 0 - TCSGE, 3 - Chain, 1 - Simple SGE
897 * Skip everything but Simple. If simple, copy from
898 * user space into kernel space.
899 * Note: we should not have anything but Simple as
900 * Chain SGE are illegal.
901 */
902 nib = (sgIn->FlagsLength & 0x30000000) >> 28;
903 if (nib == 0 || nib == 3) {
904 ;
905 } else if (sgIn->Address) {
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530906 iocp->add_sge(sgOut, sgIn->FlagsLength, sgIn->Address);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 n++;
908 if (copy_from_user(bl->kptr, ufwbuf+fw_bytes_copied, bl->len)) {
Eric Moore29dd3602007-09-14 18:46:51 -0600909 printk(MYIOC_s_ERR_FMT "%s@%d::_ioctl_fwdl - "
910 "Unable to copy f/w buffer hunk#%d @ %p\n",
911 iocp->name, __FILE__, __LINE__, n, ufwbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 goto fwdl_out;
913 }
914 fw_bytes_copied += bl->len;
915 }
916 sgIn++;
917 bl++;
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530918 sgOut += iocp->SGE_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 }
920
Prakash, Sathya09120a82007-07-24 15:49:05 +0530921 DBG_DUMP_FW_DOWNLOAD(iocp, (u32 *)mf, numfrags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922
923 /*
924 * Finally, perform firmware download.
925 */
Moore, Eric946cbf02006-02-02 17:19:50 -0700926 ReplyMsg = NULL;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530927 SET_MGMT_MSG_CONTEXT(iocp->ioctl_cmds.msg_context, dlmsg->MsgContext);
928 INITIALIZE_MGMT_STATUS(iocp->ioctl_cmds.status)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 mpt_put_msg_frame(mptctl_id, iocp, mf);
930
931 /* Now wait for the command to complete */
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530932retry_wait:
933 timeleft = wait_for_completion_timeout(&iocp->ioctl_cmds.done, HZ*60);
934 if (!(iocp->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
935 ret = -ETIME;
936 printk(MYIOC_s_WARN_FMT "%s: failed\n", iocp->name, __func__);
937 if (iocp->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
938 mpt_free_msg_frame(iocp, mf);
939 goto fwdl_out;
940 }
Kei Tokunaga97009a22010-06-22 19:01:51 +0900941 if (!timeleft) {
942 printk(MYIOC_s_WARN_FMT
943 "FW download timeout, doorbell=0x%08x\n",
944 iocp->name, mpt_GetIocState(iocp, 0));
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530945 mptctl_timeout_expired(iocp, mf);
Kei Tokunaga97009a22010-06-22 19:01:51 +0900946 } else
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530947 goto retry_wait;
948 goto fwdl_out;
949 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530951 if (!(iocp->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
952 printk(MYIOC_s_WARN_FMT "%s: failed\n", iocp->name, __func__);
953 mpt_free_msg_frame(iocp, mf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 ret = -ENODATA;
955 goto fwdl_out;
956 }
957
958 if (sgl)
959 kfree_sgl(sgl, sgl_dma, buflist, iocp);
960
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530961 ReplyMsg = (pFWDownloadReply_t)iocp->ioctl_cmds.reply;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 iocstat = le16_to_cpu(ReplyMsg->IOCStatus) & MPI_IOCSTATUS_MASK;
963 if (iocstat == MPI_IOCSTATUS_SUCCESS) {
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300964 printk(MYIOC_s_INFO_FMT "F/W update successful!\n", iocp->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 return 0;
966 } else if (iocstat == MPI_IOCSTATUS_INVALID_FUNCTION) {
Eric Moore29dd3602007-09-14 18:46:51 -0600967 printk(MYIOC_s_WARN_FMT "Hmmm... F/W download not supported!?!\n",
968 iocp->name);
969 printk(MYIOC_s_WARN_FMT "(time to go bang on somebodies door)\n",
970 iocp->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 return -EBADRQC;
972 } else if (iocstat == MPI_IOCSTATUS_BUSY) {
Eric Moore29dd3602007-09-14 18:46:51 -0600973 printk(MYIOC_s_WARN_FMT "IOC_BUSY!\n", iocp->name);
974 printk(MYIOC_s_WARN_FMT "(try again later?)\n", iocp->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 return -EBUSY;
976 } else {
Eric Moore29dd3602007-09-14 18:46:51 -0600977 printk(MYIOC_s_WARN_FMT "ioctl_fwdl() returned [bad] status = %04xh\n",
978 iocp->name, iocstat);
979 printk(MYIOC_s_WARN_FMT "(bad VooDoo)\n", iocp->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 return -ENOMSG;
981 }
982 return 0;
983
984fwdl_out:
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +0530985
986 CLEAR_MGMT_STATUS(iocp->ioctl_cmds.status);
987 SET_MGMT_MSG_CONTEXT(iocp->ioctl_cmds.msg_context, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 kfree_sgl(sgl, sgl_dma, buflist, iocp);
989 return ret;
990}
991
992/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
993/*
994 * SGE Allocation routine
995 *
996 * Inputs: bytes - number of bytes to be transferred
997 * sgdir - data direction
998 * sge_offset - offset (in bytes) from the start of the request
999 * frame to the first SGE
1000 * ioc - pointer to the mptadapter
1001 * Outputs: frags - number of scatter gather elements
1002 * blp - point to the buflist pointer
1003 * sglbuf_dma - pointer to the (dma) sgl
1004 * Returns: Null if failes
1005 * pointer to the (virtual) sgl if successful.
1006 */
1007static MptSge_t *
1008kbuf_alloc_2_sgl(int bytes, u32 sgdir, int sge_offset, int *frags,
1009 struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc)
1010{
1011 MptSge_t *sglbuf = NULL; /* pointer to array of SGE */
1012 /* and chain buffers */
1013 struct buflist *buflist = NULL; /* kernel routine */
1014 MptSge_t *sgl;
1015 int numfrags = 0;
1016 int fragcnt = 0;
1017 int alloc_sz = min(bytes,MAX_KMALLOC_SZ); // avoid kernel warning msg!
1018 int bytes_allocd = 0;
1019 int this_alloc;
1020 dma_addr_t pa; // phys addr
1021 int i, buflist_ent;
1022 int sg_spill = MAX_FRAGS_SPILL1;
1023 int dir;
Dan Carpenter49121202015-11-11 01:15:24 +03001024
1025 if (bytes < 0)
1026 return NULL;
1027
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 /* initialization */
1029 *frags = 0;
1030 *blp = NULL;
1031
1032 /* Allocate and initialize an array of kernel
1033 * structures for the SG elements.
1034 */
1035 i = MAX_SGL_BYTES / 8;
Mariusz Kozlowskid7383a22007-08-10 14:50:50 -07001036 buflist = kzalloc(i, GFP_USER);
1037 if (!buflist)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 buflist_ent = 0;
1040
1041 /* Allocate a single block of memory to store the sg elements and
1042 * the chain buffers. The calling routine is responsible for
1043 * copying the data in this array into the correct place in the
1044 * request and chain buffers.
1045 */
1046 sglbuf = pci_alloc_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf_dma);
1047 if (sglbuf == NULL)
1048 goto free_and_fail;
1049
1050 if (sgdir & 0x04000000)
1051 dir = PCI_DMA_TODEVICE;
1052 else
1053 dir = PCI_DMA_FROMDEVICE;
1054
1055 /* At start:
1056 * sgl = sglbuf = point to beginning of sg buffer
1057 * buflist_ent = 0 = first kernel structure
1058 * sg_spill = number of SGE that can be written before the first
1059 * chain element.
1060 *
1061 */
1062 sgl = sglbuf;
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05301063 sg_spill = ((ioc->req_sz - sge_offset)/ioc->SGE_size) - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 while (bytes_allocd < bytes) {
1065 this_alloc = min(alloc_sz, bytes-bytes_allocd);
1066 buflist[buflist_ent].len = this_alloc;
1067 buflist[buflist_ent].kptr = pci_alloc_consistent(ioc->pcidev,
1068 this_alloc,
1069 &pa);
1070 if (buflist[buflist_ent].kptr == NULL) {
1071 alloc_sz = alloc_sz / 2;
1072 if (alloc_sz == 0) {
Eric Moore29dd3602007-09-14 18:46:51 -06001073 printk(MYIOC_s_WARN_FMT "-SG: No can do - "
1074 "not enough memory! :-(\n", ioc->name);
1075 printk(MYIOC_s_WARN_FMT "-SG: (freeing %d frags)\n",
1076 ioc->name, numfrags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 goto free_and_fail;
1078 }
1079 continue;
1080 } else {
1081 dma_addr_t dma_addr;
1082
1083 bytes_allocd += this_alloc;
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05301084 sgl->FlagsLength = (0x10000000|sgdir|this_alloc);
1085 dma_addr = pci_map_single(ioc->pcidev,
1086 buflist[buflist_ent].kptr, this_alloc, dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 sgl->Address = dma_addr;
1088
1089 fragcnt++;
1090 numfrags++;
1091 sgl++;
1092 buflist_ent++;
1093 }
1094
1095 if (bytes_allocd >= bytes)
1096 break;
1097
1098 /* Need to chain? */
1099 if (fragcnt == sg_spill) {
Eric Moore29dd3602007-09-14 18:46:51 -06001100 printk(MYIOC_s_WARN_FMT
1101 "-SG: No can do - " "Chain required! :-(\n", ioc->name);
1102 printk(MYIOC_s_WARN_FMT "(freeing %d frags)\n", ioc->name, numfrags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 goto free_and_fail;
1104 }
1105
1106 /* overflow check... */
1107 if (numfrags*8 > MAX_SGL_BYTES){
1108 /* GRRRRR... */
Eric Moore29dd3602007-09-14 18:46:51 -06001109 printk(MYIOC_s_WARN_FMT "-SG: No can do - "
1110 "too many SG frags! :-(\n", ioc->name);
1111 printk(MYIOC_s_WARN_FMT "-SG: (freeing %d frags)\n",
1112 ioc->name, numfrags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 goto free_and_fail;
1114 }
1115 }
1116
1117 /* Last sge fixup: set LE+eol+eob bits */
1118 sgl[-1].FlagsLength |= 0xC1000000;
1119
1120 *frags = numfrags;
1121 *blp = buflist;
1122
Prakash, Sathya09120a82007-07-24 15:49:05 +05301123 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: kbuf_alloc_2_sgl() - "
1124 "%d SG frags generated!\n", ioc->name, numfrags));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125
Prakash, Sathya09120a82007-07-24 15:49:05 +05301126 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: kbuf_alloc_2_sgl() - "
1127 "last (big) alloc_sz=%d\n", ioc->name, alloc_sz));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128
1129 return sglbuf;
1130
1131free_and_fail:
1132 if (sglbuf != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 for (i = 0; i < numfrags; i++) {
1134 dma_addr_t dma_addr;
1135 u8 *kptr;
1136 int len;
1137
1138 if ((sglbuf[i].FlagsLength >> 24) == 0x30)
1139 continue;
1140
1141 dma_addr = sglbuf[i].Address;
1142 kptr = buflist[i].kptr;
1143 len = buflist[i].len;
1144
1145 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1146 }
1147 pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf, *sglbuf_dma);
1148 }
1149 kfree(buflist);
1150 return NULL;
1151}
1152
1153/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1154/*
1155 * Routine to free the SGL elements.
1156 */
1157static void
1158kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma, struct buflist *buflist, MPT_ADAPTER *ioc)
1159{
1160 MptSge_t *sg = sgl;
1161 struct buflist *bl = buflist;
1162 u32 nib;
1163 int dir;
1164 int n = 0;
1165
1166 if (sg->FlagsLength & 0x04000000)
1167 dir = PCI_DMA_TODEVICE;
1168 else
1169 dir = PCI_DMA_FROMDEVICE;
1170
1171 nib = (sg->FlagsLength & 0xF0000000) >> 28;
1172 while (! (nib & 0x4)) { /* eob */
1173 /* skip ignore/chain. */
1174 if (nib == 0 || nib == 3) {
1175 ;
1176 } else if (sg->Address) {
1177 dma_addr_t dma_addr;
1178 void *kptr;
1179 int len;
1180
1181 dma_addr = sg->Address;
1182 kptr = bl->kptr;
1183 len = bl->len;
1184 pci_unmap_single(ioc->pcidev, dma_addr, len, dir);
1185 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1186 n++;
1187 }
1188 sg++;
1189 bl++;
1190 nib = (le32_to_cpu(sg->FlagsLength) & 0xF0000000) >> 28;
1191 }
1192
1193 /* we're at eob! */
1194 if (sg->Address) {
1195 dma_addr_t dma_addr;
1196 void *kptr;
1197 int len;
1198
1199 dma_addr = sg->Address;
1200 kptr = bl->kptr;
1201 len = bl->len;
1202 pci_unmap_single(ioc->pcidev, dma_addr, len, dir);
1203 pci_free_consistent(ioc->pcidev, len, kptr, dma_addr);
1204 n++;
1205 }
1206
1207 pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sgl, sgl_dma);
1208 kfree(buflist);
Prakash, Sathya09120a82007-07-24 15:49:05 +05301209 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: Free'd 1 SGL buf + %d kbufs!\n",
1210 ioc->name, n));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211}
1212
1213/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1214/*
1215 * mptctl_getiocinfo - Query the host adapter for IOC information.
1216 * @arg: User space argument
1217 *
1218 * Outputs: None.
1219 * Return: 0 if successful
1220 * -EFAULT if data unavailable
1221 * -ENODEV if no such device/adapter
1222 */
1223static int
Dan Carpenter28d76df2020-01-14 15:34:14 +03001224mptctl_getiocinfo (MPT_ADAPTER *ioc, unsigned long arg, unsigned int data_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225{
1226 struct mpt_ioctl_iocinfo __user *uarg = (void __user *) arg;
1227 struct mpt_ioctl_iocinfo *karg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 struct pci_dev *pdev;
Moore, Eric Dean b6fe4dd2005-04-22 18:01:34 -04001229 unsigned int port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 int cim_rev;
Eric Moore793955f2007-01-29 09:42:20 -07001231 struct scsi_device *sdev;
Eric Moorea69de502007-09-14 18:48:19 -06001232 VirtDevice *vdevice;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 /* Add of PCI INFO results in unaligned access for
1235 * IA64 and Sparc. Reset long to int. Return no PCI
1236 * data for obsolete format.
1237 */
1238 if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev0))
1239 cim_rev = 0;
1240 else if (data_size == sizeof(struct mpt_ioctl_iocinfo_rev1))
1241 cim_rev = 1;
1242 else if (data_size == sizeof(struct mpt_ioctl_iocinfo))
1243 cim_rev = 2;
1244 else if (data_size == (sizeof(struct mpt_ioctl_iocinfo_rev0)+12))
1245 cim_rev = 0; /* obsolete */
1246 else
1247 return -EFAULT;
1248
Joe Lawrence3e67c452014-06-25 17:06:12 -04001249 karg = memdup_user(uarg, data_size);
1250 if (IS_ERR(karg)) {
1251 printk(KERN_ERR MYNAM "%s@%d::mpt_ioctl_iocinfo() - memdup_user returned error [%ld]\n",
1252 __FILE__, __LINE__, PTR_ERR(karg));
1253 return PTR_ERR(karg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 }
1255
Moore, Eric Dean b6fe4dd2005-04-22 18:01:34 -04001256 /* Verify the data transfer size is correct. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 if (karg->hdr.maxDataSize != data_size) {
Eric Moore29dd3602007-09-14 18:46:51 -06001258 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_getiocinfo - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 "Structure size mismatch. Command not completed.\n",
Eric Moore29dd3602007-09-14 18:46:51 -06001260 ioc->name, __FILE__, __LINE__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 kfree(karg);
1262 return -EFAULT;
1263 }
1264
Prakash, Sathya09120a82007-07-24 15:49:05 +05301265 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_getiocinfo called.\n",
1266 ioc->name));
1267
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 /* Fill in the data and return the structure to the calling
1269 * program
1270 */
Moore, Eric9cc1cfb2006-02-02 17:19:33 -07001271 if (ioc->bus_type == SAS)
1272 karg->adapterType = MPT_IOCTL_INTERFACE_SAS;
1273 else if (ioc->bus_type == FC)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 karg->adapterType = MPT_IOCTL_INTERFACE_FC;
1275 else
1276 karg->adapterType = MPT_IOCTL_INTERFACE_SCSI;
1277
Jesper Juhlefee0bd2010-12-26 22:14:01 +01001278 if (karg->hdr.port > 1) {
1279 kfree(karg);
Moore, Eric Dean b6fe4dd2005-04-22 18:01:34 -04001280 return -EINVAL;
Jesper Juhlefee0bd2010-12-26 22:14:01 +01001281 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 port = karg->hdr.port;
1283
1284 karg->port = port;
1285 pdev = (struct pci_dev *) ioc->pcidev;
1286
1287 karg->pciId = pdev->device;
Sergei Shtylyov9ceb5c12012-05-31 16:26:06 -07001288 karg->hwRev = pdev->revision;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 karg->subSystemDevice = pdev->subsystem_device;
1290 karg->subSystemVendor = pdev->subsystem_vendor;
1291
1292 if (cim_rev == 1) {
1293 /* Get the PCI bus, device, and function numbers for the IOC
1294 */
1295 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1296 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1297 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
1298 } else if (cim_rev == 2) {
Moore, Eric86a7dca2006-02-02 17:19:37 -07001299 /* Get the PCI bus, device, function and segment ID numbers
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 for the IOC */
1301 karg->pciInfo.u.bits.busNumber = pdev->bus->number;
1302 karg->pciInfo.u.bits.deviceNumber = PCI_SLOT( pdev->devfn );
1303 karg->pciInfo.u.bits.functionNumber = PCI_FUNC( pdev->devfn );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 karg->pciInfo.segmentID = pci_domain_nr(pdev->bus);
1305 }
1306
1307 /* Get number of devices
1308 */
Eric Moore793955f2007-01-29 09:42:20 -07001309 karg->numDevices = 0;
1310 if (ioc->sh) {
1311 shost_for_each_device(sdev, ioc->sh) {
Eric Moorea69de502007-09-14 18:48:19 -06001312 vdevice = sdev->hostdata;
Kashyap, Desai08f5c5c2010-03-18 19:22:45 +05301313 if (vdevice == NULL || vdevice->vtarget == NULL)
1314 continue;
Eric Moorea69de502007-09-14 18:48:19 -06001315 if (vdevice->vtarget->tflags &
Eric Moore793955f2007-01-29 09:42:20 -07001316 MPT_TARGET_FLAGS_RAID_COMPONENT)
1317 continue;
1318 karg->numDevices++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 }
1320 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321
1322 /* Set the BIOS and FW Version
1323 */
1324 karg->FWVersion = ioc->facts.FWVersion.Word;
1325 karg->BIOSVersion = ioc->biosVersion;
1326
1327 /* Set the Version Strings.
1328 */
1329 strncpy (karg->driverVersion, MPT_LINUX_PACKAGE_NAME, MPT_IOCTL_VERSION_LENGTH);
1330 karg->driverVersion[MPT_IOCTL_VERSION_LENGTH-1]='\0';
1331
1332 karg->busChangeEvent = 0;
1333 karg->hostId = ioc->pfacts[port].PortSCSIID;
1334 karg->rsvd[0] = karg->rsvd[1] = 0;
1335
1336 /* Copy the data from kernel memory to user memory
1337 */
1338 if (copy_to_user((char __user *)arg, karg, data_size)) {
Eric Moore29dd3602007-09-14 18:46:51 -06001339 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_getiocinfo - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 "Unable to write out mpt_ioctl_iocinfo struct @ %p\n",
Eric Moore29dd3602007-09-14 18:46:51 -06001341 ioc->name, __FILE__, __LINE__, uarg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 kfree(karg);
1343 return -EFAULT;
1344 }
1345
1346 kfree(karg);
1347 return 0;
1348}
1349
1350/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1351/*
1352 * mptctl_gettargetinfo - Query the host adapter for target information.
1353 * @arg: User space argument
1354 *
1355 * Outputs: None.
1356 * Return: 0 if successful
1357 * -EFAULT if data unavailable
1358 * -ENODEV if no such device/adapter
1359 */
1360static int
Dan Carpenter28d76df2020-01-14 15:34:14 +03001361mptctl_gettargetinfo (MPT_ADAPTER *ioc, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362{
1363 struct mpt_ioctl_targetinfo __user *uarg = (void __user *) arg;
1364 struct mpt_ioctl_targetinfo karg;
Eric Moorea69de502007-09-14 18:48:19 -06001365 VirtDevice *vdevice;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 char *pmem;
1367 int *pdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 int numDevices = 0;
Eric Moore793955f2007-01-29 09:42:20 -07001369 int lun;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 int maxWordsLeft;
1371 int numBytes;
Eric Moore793955f2007-01-29 09:42:20 -07001372 u8 port;
1373 struct scsi_device *sdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_targetinfo))) {
Eric Moore29dd3602007-09-14 18:46:51 -06001376 printk(KERN_ERR MYNAM "%s@%d::mptctl_gettargetinfo - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 "Unable to read in mpt_ioctl_targetinfo struct @ %p\n",
1378 __FILE__, __LINE__, uarg);
1379 return -EFAULT;
1380 }
1381
Prakash, Sathya09120a82007-07-24 15:49:05 +05301382 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_gettargetinfo called.\n",
1383 ioc->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 /* Get the port number and set the maximum number of bytes
1385 * in the returned structure.
1386 * Ignore the port setting.
1387 */
1388 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1389 maxWordsLeft = numBytes/sizeof(int);
1390 port = karg.hdr.port;
1391
1392 if (maxWordsLeft <= 0) {
Eric Moore29dd3602007-09-14 18:46:51 -06001393 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo() - no memory available!\n",
1394 ioc->name, __FILE__, __LINE__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 return -ENOMEM;
1396 }
1397
1398 /* Fill in the data and return the structure to the calling
1399 * program
1400 */
1401
1402 /* struct mpt_ioctl_targetinfo does not contain sufficient space
1403 * for the target structures so when the IOCTL is called, there is
1404 * not sufficient stack space for the structure. Allocate memory,
1405 * populate the memory, copy back to the user, then free memory.
1406 * targetInfo format:
1407 * bits 31-24: reserved
1408 * 23-16: LUN
1409 * 15- 8: Bus Number
1410 * 7- 0: Target ID
1411 */
Mariusz Kozlowskid7383a22007-08-10 14:50:50 -07001412 pmem = kzalloc(numBytes, GFP_KERNEL);
1413 if (!pmem) {
Eric Moore29dd3602007-09-14 18:46:51 -06001414 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo() - no memory available!\n",
1415 ioc->name, __FILE__, __LINE__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 return -ENOMEM;
1417 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 pdata = (int *) pmem;
1419
1420 /* Get number of devices
1421 */
Eric Moore793955f2007-01-29 09:42:20 -07001422 if (ioc->sh){
1423 shost_for_each_device(sdev, ioc->sh) {
1424 if (!maxWordsLeft)
1425 continue;
Eric Moorea69de502007-09-14 18:48:19 -06001426 vdevice = sdev->hostdata;
Kashyap, Desai08f5c5c2010-03-18 19:22:45 +05301427 if (vdevice == NULL || vdevice->vtarget == NULL)
1428 continue;
Eric Moorea69de502007-09-14 18:48:19 -06001429 if (vdevice->vtarget->tflags &
Eric Moore793955f2007-01-29 09:42:20 -07001430 MPT_TARGET_FLAGS_RAID_COMPONENT)
1431 continue;
Eric Moorea69de502007-09-14 18:48:19 -06001432 lun = (vdevice->vtarget->raidVolume) ? 0x80 : vdevice->lun;
1433 *pdata = (((u8)lun << 16) + (vdevice->vtarget->channel << 8) +
1434 (vdevice->vtarget->id ));
Eric Moore793955f2007-01-29 09:42:20 -07001435 pdata++;
1436 numDevices++;
1437 --maxWordsLeft;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 }
1439 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 karg.numDevices = numDevices;
1441
1442 /* Copy part of the data from kernel memory to user memory
1443 */
1444 if (copy_to_user((char __user *)arg, &karg,
1445 sizeof(struct mpt_ioctl_targetinfo))) {
Eric Moore29dd3602007-09-14 18:46:51 -06001446 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
Eric Moore29dd3602007-09-14 18:46:51 -06001448 ioc->name, __FILE__, __LINE__, uarg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 kfree(pmem);
1450 return -EFAULT;
1451 }
1452
1453 /* Copy the remaining data from kernel memory to user memory
1454 */
1455 if (copy_to_user(uarg->targetInfo, pmem, numBytes)) {
Eric Moore29dd3602007-09-14 18:46:51 -06001456 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
Eric Moore29dd3602007-09-14 18:46:51 -06001458 ioc->name, __FILE__, __LINE__, pdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 kfree(pmem);
1460 return -EFAULT;
1461 }
1462
1463 kfree(pmem);
1464
1465 return 0;
1466}
1467
1468/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1469/* MPT IOCTL Test function.
1470 *
1471 * Outputs: None.
1472 * Return: 0 if successful
1473 * -EFAULT if data unavailable
1474 * -ENODEV if no such device/adapter
1475 */
1476static int
Dan Carpenter28d76df2020-01-14 15:34:14 +03001477mptctl_readtest (MPT_ADAPTER *ioc, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478{
1479 struct mpt_ioctl_test __user *uarg = (void __user *) arg;
1480 struct mpt_ioctl_test karg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_test))) {
Eric Moore29dd3602007-09-14 18:46:51 -06001483 printk(KERN_ERR MYNAM "%s@%d::mptctl_readtest - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 "Unable to read in mpt_ioctl_test struct @ %p\n",
1485 __FILE__, __LINE__, uarg);
1486 return -EFAULT;
1487 }
1488
Prakash, Sathya09120a82007-07-24 15:49:05 +05301489 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_readtest called.\n",
1490 ioc->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 /* Fill in the data and return the structure to the calling
1492 * program
1493 */
1494
1495#ifdef MFCNT
1496 karg.chip_type = ioc->mfcnt;
1497#else
1498 karg.chip_type = ioc->pcidev->device;
1499#endif
1500 strncpy (karg.name, ioc->name, MPT_MAX_NAME);
1501 karg.name[MPT_MAX_NAME-1]='\0';
1502 strncpy (karg.product, ioc->prod_name, MPT_PRODUCT_LENGTH);
1503 karg.product[MPT_PRODUCT_LENGTH-1]='\0';
1504
1505 /* Copy the data from kernel memory to user memory
1506 */
1507 if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_test))) {
Eric Moore29dd3602007-09-14 18:46:51 -06001508 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_readtest - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 "Unable to write out mpt_ioctl_test struct @ %p\n",
Eric Moore29dd3602007-09-14 18:46:51 -06001510 ioc->name, __FILE__, __LINE__, uarg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 return -EFAULT;
1512 }
1513
1514 return 0;
1515}
1516
1517/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1518/*
1519 * mptctl_eventquery - Query the host adapter for the event types
1520 * that are being logged.
1521 * @arg: User space argument
1522 *
1523 * Outputs: None.
1524 * Return: 0 if successful
1525 * -EFAULT if data unavailable
1526 * -ENODEV if no such device/adapter
1527 */
1528static int
Dan Carpenter28d76df2020-01-14 15:34:14 +03001529mptctl_eventquery (MPT_ADAPTER *ioc, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530{
1531 struct mpt_ioctl_eventquery __user *uarg = (void __user *) arg;
1532 struct mpt_ioctl_eventquery karg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventquery))) {
Eric Moore29dd3602007-09-14 18:46:51 -06001535 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventquery - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 "Unable to read in mpt_ioctl_eventquery struct @ %p\n",
1537 __FILE__, __LINE__, uarg);
1538 return -EFAULT;
1539 }
1540
Prakash, Sathya09120a82007-07-24 15:49:05 +05301541 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventquery called.\n",
1542 ioc->name));
Moore, Eric5b5ef4f2006-02-02 17:19:40 -07001543 karg.eventEntries = MPTCTL_EVENT_LOG_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 karg.eventTypes = ioc->eventTypes;
1545
1546 /* Copy the data from kernel memory to user memory
1547 */
1548 if (copy_to_user((char __user *)arg, &karg, sizeof(struct mpt_ioctl_eventquery))) {
Eric Moore29dd3602007-09-14 18:46:51 -06001549 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_eventquery - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 "Unable to write out mpt_ioctl_eventquery struct @ %p\n",
Eric Moore29dd3602007-09-14 18:46:51 -06001551 ioc->name, __FILE__, __LINE__, uarg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552 return -EFAULT;
1553 }
1554 return 0;
1555}
1556
1557/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1558static int
Dan Carpenter28d76df2020-01-14 15:34:14 +03001559mptctl_eventenable (MPT_ADAPTER *ioc, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560{
1561 struct mpt_ioctl_eventenable __user *uarg = (void __user *) arg;
1562 struct mpt_ioctl_eventenable karg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventenable))) {
Eric Moore29dd3602007-09-14 18:46:51 -06001565 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventenable - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 "Unable to read in mpt_ioctl_eventenable struct @ %p\n",
1567 __FILE__, __LINE__, uarg);
1568 return -EFAULT;
1569 }
1570
Prakash, Sathya09120a82007-07-24 15:49:05 +05301571 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventenable called.\n",
1572 ioc->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 if (ioc->events == NULL) {
1574 /* Have not yet allocated memory - do so now.
1575 */
1576 int sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
Mariusz Kozlowskid7383a22007-08-10 14:50:50 -07001577 ioc->events = kzalloc(sz, GFP_KERNEL);
1578 if (!ioc->events) {
Eric Moore29dd3602007-09-14 18:46:51 -06001579 printk(MYIOC_s_ERR_FMT
1580 ": ERROR - Insufficient memory to add adapter!\n",
1581 ioc->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 return -ENOMEM;
1583 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 ioc->alloc_total += sz;
1585
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 ioc->eventContext = 0;
1587 }
1588
1589 /* Update the IOC event logging flag.
1590 */
1591 ioc->eventTypes = karg.eventTypes;
1592
1593 return 0;
1594}
1595
1596/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1597static int
Dan Carpenter28d76df2020-01-14 15:34:14 +03001598mptctl_eventreport (MPT_ADAPTER *ioc, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599{
1600 struct mpt_ioctl_eventreport __user *uarg = (void __user *) arg;
1601 struct mpt_ioctl_eventreport karg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 int numBytes, maxEvents, max;
1603
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventreport))) {
Eric Moore29dd3602007-09-14 18:46:51 -06001605 printk(KERN_ERR MYNAM "%s@%d::mptctl_eventreport - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 "Unable to read in mpt_ioctl_eventreport struct @ %p\n",
1607 __FILE__, __LINE__, uarg);
1608 return -EFAULT;
1609 }
1610
Prakash, Sathya09120a82007-07-24 15:49:05 +05301611 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventreport called.\n",
1612 ioc->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613
1614 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
1615 maxEvents = numBytes/sizeof(MPT_IOCTL_EVENTS);
1616
1617
Moore, Eric5b5ef4f2006-02-02 17:19:40 -07001618 max = MPTCTL_EVENT_LOG_SIZE < maxEvents ? MPTCTL_EVENT_LOG_SIZE : maxEvents;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619
1620 /* If fewer than 1 event is requested, there must have
1621 * been some type of error.
1622 */
1623 if ((max < 1) || !ioc->events)
1624 return -ENODATA;
1625
Moore, Ericea5a7a822006-02-02 17:20:01 -07001626 /* reset this flag so SIGIO can restart */
1627 ioc->aen_event_read_flag=0;
1628
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 /* Copy the data from kernel memory to user memory
1630 */
1631 numBytes = max * sizeof(MPT_IOCTL_EVENTS);
1632 if (copy_to_user(uarg->eventData, ioc->events, numBytes)) {
Eric Moore29dd3602007-09-14 18:46:51 -06001633 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_eventreport - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 "Unable to write out mpt_ioctl_eventreport struct @ %p\n",
Eric Moore29dd3602007-09-14 18:46:51 -06001635 ioc->name, __FILE__, __LINE__, ioc->events);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 return -EFAULT;
1637 }
1638
1639 return 0;
1640}
1641
1642/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1643static int
Dan Carpenter28d76df2020-01-14 15:34:14 +03001644mptctl_replace_fw (MPT_ADAPTER *ioc, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645{
1646 struct mpt_ioctl_replace_fw __user *uarg = (void __user *) arg;
1647 struct mpt_ioctl_replace_fw karg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 int newFwSize;
1649
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_replace_fw))) {
Eric Moore29dd3602007-09-14 18:46:51 -06001651 printk(KERN_ERR MYNAM "%s@%d::mptctl_replace_fw - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 "Unable to read in mpt_ioctl_replace_fw struct @ %p\n",
1653 __FILE__, __LINE__, uarg);
1654 return -EFAULT;
1655 }
1656
Prakash, Sathya09120a82007-07-24 15:49:05 +05301657 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_replace_fw called.\n",
1658 ioc->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 /* If caching FW, Free the old FW image
1660 */
1661 if (ioc->cached_fw == NULL)
1662 return 0;
1663
1664 mpt_free_fw_memory(ioc);
1665
1666 /* Allocate memory for the new FW image
1667 */
Rasmus Villemoesf6e495a2014-07-01 14:56:20 +02001668 newFwSize = ALIGN(karg.newImageSize, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669
1670 mpt_alloc_fw_memory(ioc, newFwSize);
1671 if (ioc->cached_fw == NULL)
1672 return -ENOMEM;
1673
1674 /* Copy the data from user memory to kernel space
1675 */
1676 if (copy_from_user(ioc->cached_fw, uarg->newImage, newFwSize)) {
Eric Moore29dd3602007-09-14 18:46:51 -06001677 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_replace_fw - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678 "Unable to read in mpt_ioctl_replace_fw image "
Eric Moore29dd3602007-09-14 18:46:51 -06001679 "@ %p\n", ioc->name, __FILE__, __LINE__, uarg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 mpt_free_fw_memory(ioc);
1681 return -EFAULT;
1682 }
1683
1684 /* Update IOCFactsReply
1685 */
1686 ioc->facts.FWImageSize = newFwSize;
1687 return 0;
1688}
1689
1690/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1691/* MPT IOCTL MPTCOMMAND function.
1692 * Cast the arg into the mpt_ioctl_mpt_command structure.
1693 *
1694 * Outputs: None.
1695 * Return: 0 if successful
Joe Perchesfc1323b2008-02-03 17:21:01 +02001696 * -EBUSY if previous command timeout and IOC reset is not complete.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 * -EFAULT if data unavailable
1698 * -ENODEV if no such device/adapter
1699 * -ETIME if timer expires
1700 * -ENOMEM if memory allocation error
1701 */
1702static int
Dan Carpenter28d76df2020-01-14 15:34:14 +03001703mptctl_mpt_command (MPT_ADAPTER *ioc, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704{
1705 struct mpt_ioctl_command __user *uarg = (void __user *) arg;
1706 struct mpt_ioctl_command karg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 int rc;
1708
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709
1710 if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_command))) {
Eric Moore29dd3602007-09-14 18:46:51 -06001711 printk(KERN_ERR MYNAM "%s@%d::mptctl_mpt_command - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 "Unable to read in mpt_ioctl_command struct @ %p\n",
1713 __FILE__, __LINE__, uarg);
1714 return -EFAULT;
1715 }
1716
Dan Carpenter28d76df2020-01-14 15:34:14 +03001717 rc = mptctl_do_mpt_command (ioc, karg, &uarg->MF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718
1719 return rc;
1720}
1721
1722/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1723/* Worker routine for the IOCTL MPTCOMMAND and MPTCOMMAND32 (sparc) commands.
1724 *
1725 * Outputs: None.
1726 * Return: 0 if successful
Joe Perchesfc1323b2008-02-03 17:21:01 +02001727 * -EBUSY if previous command timeout and IOC reset is not complete.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 * -EFAULT if data unavailable
1729 * -ENODEV if no such device/adapter
1730 * -ETIME if timer expires
1731 * -ENOMEM if memory allocation error
1732 * -EPERM if SCSI I/O and target is untagged
1733 */
1734static int
Dan Carpenter28d76df2020-01-14 15:34:14 +03001735mptctl_do_mpt_command (MPT_ADAPTER *ioc, struct mpt_ioctl_command karg, void __user *mfPtr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 MPT_FRAME_HDR *mf = NULL;
1738 MPIHeader_t *hdr;
1739 char *psge;
1740 struct buflist bufIn; /* data In buffer */
1741 struct buflist bufOut; /* data Out buffer */
1742 dma_addr_t dma_addr_in;
1743 dma_addr_t dma_addr_out;
1744 int sgSize = 0; /* Num SG elements */
Dan Carpenter28d76df2020-01-14 15:34:14 +03001745 int flagsLength;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 int sz, rc = 0;
1747 int msgContext;
1748 u16 req_idx;
1749 ulong timeout;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05301750 unsigned long timeleft;
Eric Moore793955f2007-01-29 09:42:20 -07001751 struct scsi_device *sdev;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05301752 unsigned long flags;
1753 u8 function;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754
Eric Mooreab371282007-09-29 10:22:54 -06001755 /* bufIn and bufOut are used for user to kernel space transfers
1756 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 bufIn.kptr = bufOut.kptr = NULL;
Eric Mooreab371282007-09-29 10:22:54 -06001758 bufIn.len = bufOut.len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05301760 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
1761 if (ioc->ioc_reset_in_progress) {
1762 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
Eric Moore29dd3602007-09-14 18:46:51 -06001763 printk(KERN_ERR MYNAM "%s@%d::mptctl_do_mpt_command - "
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05301764 "Busy with diagnostic reset\n", __FILE__, __LINE__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 return -EBUSY;
1766 }
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05301767 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768
Dan Carpentere819cdb2015-07-03 11:53:03 +03001769 /* Basic sanity checks to prevent underflows or integer overflows */
1770 if (karg.maxReplyBytes < 0 ||
1771 karg.dataInSize < 0 ||
1772 karg.dataOutSize < 0 ||
1773 karg.dataSgeOffset < 0 ||
1774 karg.maxSenseBytes < 0 ||
1775 karg.dataSgeOffset > ioc->req_sz / 4)
1776 return -EINVAL;
1777
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 /* Verify that the final request frame will not be too large.
1779 */
1780 sz = karg.dataSgeOffset * 4;
1781 if (karg.dataInSize > 0)
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05301782 sz += ioc->SGE_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 if (karg.dataOutSize > 0)
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05301784 sz += ioc->SGE_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785
1786 if (sz > ioc->req_sz) {
Eric Moore29dd3602007-09-14 18:46:51 -06001787 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 "Request frame too large (%d) maximum (%d)\n",
Eric Moore29dd3602007-09-14 18:46:51 -06001789 ioc->name, __FILE__, __LINE__, sz, ioc->req_sz);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 return -EFAULT;
1791 }
1792
1793 /* Get a free request frame and save the message context.
1794 */
1795 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
1796 return -EAGAIN;
1797
1798 hdr = (MPIHeader_t *) mf;
1799 msgContext = le32_to_cpu(hdr->MsgContext);
1800 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1801
1802 /* Copy the request frame
1803 * Reset the saved message context.
1804 * Request frame in user space
1805 */
1806 if (copy_from_user(mf, mfPtr, karg.dataSgeOffset * 4)) {
Eric Moore29dd3602007-09-14 18:46:51 -06001807 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 "Unable to read MF from mpt_ioctl_command struct @ %p\n",
Eric Moore29dd3602007-09-14 18:46:51 -06001809 ioc->name, __FILE__, __LINE__, mfPtr);
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05301810 function = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 rc = -EFAULT;
1812 goto done_free_mem;
1813 }
1814 hdr->MsgContext = cpu_to_le32(msgContext);
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05301815 function = hdr->Function;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816
1817
1818 /* Verify that this request is allowed.
1819 */
Prakash, Sathya09120a82007-07-24 15:49:05 +05301820 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sending mpi function (0x%02X), req=%p\n",
1821 ioc->name, hdr->Function, mf));
1822
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05301823 switch (function) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 case MPI_FUNCTION_IOC_FACTS:
1825 case MPI_FUNCTION_PORT_FACTS:
1826 karg.dataOutSize = karg.dataInSize = 0;
1827 break;
1828
1829 case MPI_FUNCTION_CONFIG:
Prakash, Sathya09120a82007-07-24 15:49:05 +05301830 {
1831 Config_t *config_frame;
1832 config_frame = (Config_t *)mf;
1833 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\ttype=0x%02x ext_type=0x%02x "
1834 "number=0x%02x action=0x%02x\n", ioc->name,
1835 config_frame->Header.PageType,
1836 config_frame->ExtPageType,
1837 config_frame->Header.PageNumber,
1838 config_frame->Action));
1839 break;
1840 }
1841
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 case MPI_FUNCTION_FC_COMMON_TRANSPORT_SEND:
1843 case MPI_FUNCTION_FC_EX_LINK_SRVC_SEND:
1844 case MPI_FUNCTION_FW_UPLOAD:
1845 case MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR:
1846 case MPI_FUNCTION_FW_DOWNLOAD:
1847 case MPI_FUNCTION_FC_PRIMITIVE_SEND:
Moore, Eric096f7a22006-02-02 17:19:30 -07001848 case MPI_FUNCTION_TOOLBOX:
1849 case MPI_FUNCTION_SAS_IO_UNIT_CONTROL:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 break;
1851
1852 case MPI_FUNCTION_SCSI_IO_REQUEST:
1853 if (ioc->sh) {
1854 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855 int qtag = MPI_SCSIIO_CONTROL_UNTAGGED;
1856 int scsidir = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 int dataSize;
Eric Moore793955f2007-01-29 09:42:20 -07001858 u32 id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859
Eric Moore793955f2007-01-29 09:42:20 -07001860 id = (ioc->devices_per_bus == 0) ? 256 : ioc->devices_per_bus;
1861 if (pScsiReq->TargetID > id) {
Eric Moore29dd3602007-09-14 18:46:51 -06001862 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 "Target ID out of bounds. \n",
Eric Moore29dd3602007-09-14 18:46:51 -06001864 ioc->name, __FILE__, __LINE__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 rc = -ENODEV;
1866 goto done_free_mem;
1867 }
1868
Eric Moore793955f2007-01-29 09:42:20 -07001869 if (pScsiReq->Bus >= ioc->number_of_buses) {
Eric Moore29dd3602007-09-14 18:46:51 -06001870 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
Eric Moore793955f2007-01-29 09:42:20 -07001871 "Target Bus out of bounds. \n",
Eric Moore29dd3602007-09-14 18:46:51 -06001872 ioc->name, __FILE__, __LINE__);
Eric Moore793955f2007-01-29 09:42:20 -07001873 rc = -ENODEV;
1874 goto done_free_mem;
1875 }
1876
Moore, Eric5f07e242006-02-02 17:19:44 -07001877 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05301878 pScsiReq->MsgFlags |= mpt_msg_flags(ioc);
Moore, Eric5f07e242006-02-02 17:19:44 -07001879
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880
1881 /* verify that app has not requested
1882 * more sense data than driver
1883 * can provide, if so, reset this parameter
1884 * set the sense buffer pointer low address
1885 * update the control field to specify Q type
1886 */
1887 if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1888 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1889 else
1890 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1891
1892 pScsiReq->SenseBufferLowAddr =
1893 cpu_to_le32(ioc->sense_buf_low_dma
1894 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
1895
Eric Moore793955f2007-01-29 09:42:20 -07001896 shost_for_each_device(sdev, ioc->sh) {
1897 struct scsi_target *starget = scsi_target(sdev);
1898 VirtTarget *vtarget = starget->hostdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899
Kashyap, Desai08f5c5c2010-03-18 19:22:45 +05301900 if (vtarget == NULL)
1901 continue;
1902
Eric Moore793955f2007-01-29 09:42:20 -07001903 if ((pScsiReq->TargetID == vtarget->id) &&
1904 (pScsiReq->Bus == vtarget->channel) &&
1905 (vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
1906 qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
1907 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908
1909 /* Have the IOCTL driver set the direction based
1910 * on the dataOutSize (ordering issue with Sparc).
1911 */
1912 if (karg.dataOutSize > 0) {
1913 scsidir = MPI_SCSIIO_CONTROL_WRITE;
1914 dataSize = karg.dataOutSize;
1915 } else {
1916 scsidir = MPI_SCSIIO_CONTROL_READ;
1917 dataSize = karg.dataInSize;
1918 }
1919
1920 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
1921 pScsiReq->DataLength = cpu_to_le32(dataSize);
1922
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923
1924 } else {
Eric Moore29dd3602007-09-14 18:46:51 -06001925 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 "SCSI driver is not loaded. \n",
Eric Moore29dd3602007-09-14 18:46:51 -06001927 ioc->name, __FILE__, __LINE__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 rc = -EFAULT;
1929 goto done_free_mem;
1930 }
1931 break;
1932
Moore, Eric096f7a22006-02-02 17:19:30 -07001933 case MPI_FUNCTION_SMP_PASSTHROUGH:
1934 /* Check mf->PassthruFlags to determine if
1935 * transfer is ImmediateMode or not.
1936 * Immediate mode returns data in the ReplyFrame.
1937 * Else, we are sending request and response data
1938 * in two SGLs at the end of the mf.
1939 */
1940 break;
1941
1942 case MPI_FUNCTION_SATA_PASSTHROUGH:
1943 if (!ioc->sh) {
Eric Moore29dd3602007-09-14 18:46:51 -06001944 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
Moore, Eric096f7a22006-02-02 17:19:30 -07001945 "SCSI driver is not loaded. \n",
Eric Moore29dd3602007-09-14 18:46:51 -06001946 ioc->name, __FILE__, __LINE__);
Moore, Eric096f7a22006-02-02 17:19:30 -07001947 rc = -EFAULT;
1948 goto done_free_mem;
1949 }
1950 break;
1951
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 case MPI_FUNCTION_RAID_ACTION:
1953 /* Just add a SGE
1954 */
1955 break;
1956
1957 case MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
1958 if (ioc->sh) {
1959 SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
1960 int qtag = MPI_SCSIIO_CONTROL_SIMPLEQ;
1961 int scsidir = MPI_SCSIIO_CONTROL_READ;
1962 int dataSize;
1963
Moore, Eric5f07e242006-02-02 17:19:44 -07001964 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05301965 pScsiReq->MsgFlags |= mpt_msg_flags(ioc);
Moore, Eric5f07e242006-02-02 17:19:44 -07001966
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967
1968 /* verify that app has not requested
1969 * more sense data than driver
1970 * can provide, if so, reset this parameter
1971 * set the sense buffer pointer low address
1972 * update the control field to specify Q type
1973 */
1974 if (karg.maxSenseBytes > MPT_SENSE_BUFFER_SIZE)
1975 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1976 else
1977 pScsiReq->SenseBufferLength = karg.maxSenseBytes;
1978
1979 pScsiReq->SenseBufferLowAddr =
1980 cpu_to_le32(ioc->sense_buf_low_dma
1981 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
1982
1983 /* All commands to physical devices are tagged
1984 */
1985
1986 /* Have the IOCTL driver set the direction based
1987 * on the dataOutSize (ordering issue with Sparc).
1988 */
1989 if (karg.dataOutSize > 0) {
1990 scsidir = MPI_SCSIIO_CONTROL_WRITE;
1991 dataSize = karg.dataOutSize;
1992 } else {
1993 scsidir = MPI_SCSIIO_CONTROL_READ;
1994 dataSize = karg.dataInSize;
1995 }
1996
1997 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
1998 pScsiReq->DataLength = cpu_to_le32(dataSize);
1999
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 } else {
Eric Moore29dd3602007-09-14 18:46:51 -06002001 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002 "SCSI driver is not loaded. \n",
Eric Moore29dd3602007-09-14 18:46:51 -06002003 ioc->name, __FILE__, __LINE__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 rc = -EFAULT;
2005 goto done_free_mem;
2006 }
2007 break;
2008
2009 case MPI_FUNCTION_SCSI_TASK_MGMT:
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302010 {
2011 SCSITaskMgmt_t *pScsiTm;
2012 pScsiTm = (SCSITaskMgmt_t *)mf;
2013 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2014 "\tTaskType=0x%x MsgFlags=0x%x "
2015 "TaskMsgContext=0x%x id=%d channel=%d\n",
2016 ioc->name, pScsiTm->TaskType, le32_to_cpu
2017 (pScsiTm->TaskMsgContext), pScsiTm->MsgFlags,
2018 pScsiTm->TargetID, pScsiTm->Bus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 break;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302020 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021
2022 case MPI_FUNCTION_IOC_INIT:
2023 {
2024 IOCInit_t *pInit = (IOCInit_t *) mf;
2025 u32 high_addr, sense_high;
2026
2027 /* Verify that all entries in the IOC INIT match
2028 * existing setup (and in LE format).
2029 */
2030 if (sizeof(dma_addr_t) == sizeof(u64)) {
2031 high_addr = cpu_to_le32((u32)((u64)ioc->req_frames_dma >> 32));
2032 sense_high= cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
2033 } else {
2034 high_addr = 0;
2035 sense_high= 0;
2036 }
2037
2038 if ((pInit->Flags != 0) || (pInit->MaxDevices != ioc->facts.MaxDevices) ||
2039 (pInit->MaxBuses != ioc->facts.MaxBuses) ||
2040 (pInit->ReplyFrameSize != cpu_to_le16(ioc->reply_sz)) ||
2041 (pInit->HostMfaHighAddr != high_addr) ||
2042 (pInit->SenseBufferHighAddr != sense_high)) {
Eric Moore29dd3602007-09-14 18:46:51 -06002043 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044 "IOC_INIT issued with 1 or more incorrect parameters. Rejected.\n",
Eric Moore29dd3602007-09-14 18:46:51 -06002045 ioc->name, __FILE__, __LINE__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046 rc = -EFAULT;
2047 goto done_free_mem;
2048 }
2049 }
2050 break;
2051 default:
2052 /*
2053 * MPI_FUNCTION_PORT_ENABLE
2054 * MPI_FUNCTION_TARGET_CMD_BUFFER_POST
2055 * MPI_FUNCTION_TARGET_ASSIST
2056 * MPI_FUNCTION_TARGET_STATUS_SEND
2057 * MPI_FUNCTION_TARGET_MODE_ABORT
2058 * MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET
2059 * MPI_FUNCTION_IO_UNIT_RESET
2060 * MPI_FUNCTION_HANDSHAKE
2061 * MPI_FUNCTION_REPLY_FRAME_REMOVAL
2062 * MPI_FUNCTION_EVENT_NOTIFICATION
2063 * (driver handles event notification)
2064 * MPI_FUNCTION_EVENT_ACK
2065 */
2066
2067 /* What to do with these??? CHECK ME!!!
2068 MPI_FUNCTION_FC_LINK_SRVC_BUF_POST
2069 MPI_FUNCTION_FC_LINK_SRVC_RSP
2070 MPI_FUNCTION_FC_ABORT
2071 MPI_FUNCTION_LAN_SEND
2072 MPI_FUNCTION_LAN_RECEIVE
2073 MPI_FUNCTION_LAN_RESET
2074 */
2075
Eric Moore29dd3602007-09-14 18:46:51 -06002076 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 "Illegal request (function 0x%x) \n",
Eric Moore29dd3602007-09-14 18:46:51 -06002078 ioc->name, __FILE__, __LINE__, hdr->Function);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079 rc = -EFAULT;
2080 goto done_free_mem;
2081 }
2082
2083 /* Add the SGL ( at most one data in SGE and one data out SGE )
2084 * In the case of two SGE's - the data out (write) will always
2085 * preceede the data in (read) SGE. psgList is used to free the
2086 * allocated memory.
2087 */
2088 psge = (char *) (((int *) mf) + karg.dataSgeOffset);
2089 flagsLength = 0;
2090
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 if (karg.dataOutSize > 0)
2092 sgSize ++;
2093
2094 if (karg.dataInSize > 0)
2095 sgSize ++;
2096
2097 if (sgSize > 0) {
2098
2099 /* Set up the dataOut memory allocation */
2100 if (karg.dataOutSize > 0) {
2101 if (karg.dataInSize > 0) {
2102 flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2103 MPI_SGE_FLAGS_END_OF_BUFFER |
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05302104 MPI_SGE_FLAGS_DIRECTION)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105 << MPI_SGE_FLAGS_SHIFT;
2106 } else {
2107 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
2108 }
2109 flagsLength |= karg.dataOutSize;
2110 bufOut.len = karg.dataOutSize;
2111 bufOut.kptr = pci_alloc_consistent(
2112 ioc->pcidev, bufOut.len, &dma_addr_out);
2113
2114 if (bufOut.kptr == NULL) {
2115 rc = -ENOMEM;
2116 goto done_free_mem;
2117 } else {
2118 /* Set up this SGE.
2119 * Copy to MF and to sglbuf
2120 */
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05302121 ioc->add_sge(psge, flagsLength, dma_addr_out);
2122 psge += ioc->SGE_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123
2124 /* Copy user data to kernel space.
2125 */
2126 if (copy_from_user(bufOut.kptr,
2127 karg.dataOutBufPtr,
2128 bufOut.len)) {
Eric Moore29dd3602007-09-14 18:46:51 -06002129 printk(MYIOC_s_ERR_FMT
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130 "%s@%d::mptctl_do_mpt_command - Unable "
2131 "to read user data "
2132 "struct @ %p\n",
Eric Moore29dd3602007-09-14 18:46:51 -06002133 ioc->name, __FILE__, __LINE__,karg.dataOutBufPtr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134 rc = -EFAULT;
2135 goto done_free_mem;
2136 }
2137 }
2138 }
2139
2140 if (karg.dataInSize > 0) {
2141 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
2142 flagsLength |= karg.dataInSize;
2143
2144 bufIn.len = karg.dataInSize;
2145 bufIn.kptr = pci_alloc_consistent(ioc->pcidev,
2146 bufIn.len, &dma_addr_in);
2147
2148 if (bufIn.kptr == NULL) {
2149 rc = -ENOMEM;
2150 goto done_free_mem;
2151 } else {
2152 /* Set up this SGE
2153 * Copy to MF and to sglbuf
2154 */
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05302155 ioc->add_sge(psge, flagsLength, dma_addr_in);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156 }
2157 }
2158 } else {
2159 /* Add a NULL SGE
2160 */
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05302161 ioc->add_sge(psge, flagsLength, (dma_addr_t) -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162 }
2163
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302164 SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, hdr->MsgContext);
2165 INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166 if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT) {
2167
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302168 mutex_lock(&ioc->taskmgmt_cmds.mutex);
2169 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
2170 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2171 goto done_free_mem;
2172 }
2173
Prakash, Sathya09120a82007-07-24 15:49:05 +05302174 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175
Prakash, Sathya7a195f42007-08-14 16:08:40 +05302176 if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
2177 (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
2178 mpt_put_msg_frame_hi_pri(mptctl_id, ioc, mf);
2179 else {
2180 rc =mpt_send_handshake_request(mptctl_id, ioc,
2181 sizeof(SCSITaskMgmt_t), (u32*)mf, CAN_SLEEP);
2182 if (rc != 0) {
2183 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302184 "send_handshake FAILED! (ioc %p, mf %p)\n",
Prakash, Sathya7a195f42007-08-14 16:08:40 +05302185 ioc->name, ioc, mf));
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302186 mpt_clear_taskmgmt_in_progress_flag(ioc);
Prakash, Sathya7a195f42007-08-14 16:08:40 +05302187 rc = -ENODATA;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302188 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
Prakash, Sathya7a195f42007-08-14 16:08:40 +05302189 goto done_free_mem;
2190 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191 }
2192
2193 } else
2194 mpt_put_msg_frame(mptctl_id, ioc, mf);
2195
2196 /* Now wait for the command to complete */
2197 timeout = (karg.timeout > 0) ? karg.timeout : MPT_IOCTL_DEFAULT_TIMEOUT;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302198retry_wait:
2199 timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
2200 HZ*timeout);
2201 if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2202 rc = -ETIME;
2203 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "%s: TIMED OUT!\n",
2204 ioc->name, __func__));
2205 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2206 if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2207 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2208 goto done_free_mem;
2209 }
2210 if (!timeleft) {
Kei Tokunaga97009a22010-06-22 19:01:51 +09002211 printk(MYIOC_s_WARN_FMT
2212 "mpt cmd timeout, doorbell=0x%08x"
2213 " function=0x%x\n",
2214 ioc->name, mpt_GetIocState(ioc, 0), function);
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302215 if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2216 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2217 mptctl_timeout_expired(ioc, mf);
2218 mf = NULL;
2219 } else
2220 goto retry_wait;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221 goto done_free_mem;
2222 }
2223
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302224 if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
2225 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
2226
2227
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 mf = NULL;
2229
2230 /* If a valid reply frame, copy to the user.
2231 * Offset 2: reply length in U32's
2232 */
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302233 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234 if (karg.maxReplyBytes < ioc->reply_sz) {
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302235 sz = min(karg.maxReplyBytes,
2236 4*ioc->ioctl_cmds.reply[2]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237 } else {
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302238 sz = min(ioc->reply_sz, 4*ioc->ioctl_cmds.reply[2]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240 if (sz > 0) {
2241 if (copy_to_user(karg.replyFrameBufPtr,
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302242 ioc->ioctl_cmds.reply, sz)){
Eric Moore29dd3602007-09-14 18:46:51 -06002243 printk(MYIOC_s_ERR_FMT
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 "%s@%d::mptctl_do_mpt_command - "
2245 "Unable to write out reply frame %p\n",
Eric Moore29dd3602007-09-14 18:46:51 -06002246 ioc->name, __FILE__, __LINE__, karg.replyFrameBufPtr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 rc = -ENODATA;
2248 goto done_free_mem;
2249 }
2250 }
2251 }
2252
2253 /* If valid sense data, copy to user.
2254 */
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302255 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_SENSE_VALID) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256 sz = min(karg.maxSenseBytes, MPT_SENSE_BUFFER_SIZE);
2257 if (sz > 0) {
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302258 if (copy_to_user(karg.senseDataPtr,
2259 ioc->ioctl_cmds.sense, sz)) {
Eric Moore29dd3602007-09-14 18:46:51 -06002260 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261 "Unable to write sense data to user %p\n",
Eric Moore29dd3602007-09-14 18:46:51 -06002262 ioc->name, __FILE__, __LINE__,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263 karg.senseDataPtr);
2264 rc = -ENODATA;
2265 goto done_free_mem;
2266 }
2267 }
2268 }
2269
2270 /* If the overall status is _GOOD and data in, copy data
2271 * to user.
2272 */
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302273 if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274 (karg.dataInSize > 0) && (bufIn.kptr)) {
2275
2276 if (copy_to_user(karg.dataInBufPtr,
2277 bufIn.kptr, karg.dataInSize)) {
Eric Moore29dd3602007-09-14 18:46:51 -06002278 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 "Unable to write data to user %p\n",
Eric Moore29dd3602007-09-14 18:46:51 -06002280 ioc->name, __FILE__, __LINE__,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281 karg.dataInBufPtr);
2282 rc = -ENODATA;
2283 }
2284 }
2285
2286done_free_mem:
2287
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302288 CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
2289 SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290
2291 /* Free the allocated memory.
2292 */
2293 if (bufOut.kptr != NULL) {
2294 pci_free_consistent(ioc->pcidev,
2295 bufOut.len, (void *) bufOut.kptr, dma_addr_out);
2296 }
2297
2298 if (bufIn.kptr != NULL) {
2299 pci_free_consistent(ioc->pcidev,
2300 bufIn.len, (void *) bufIn.kptr, dma_addr_in);
2301 }
2302
2303 /* mf is null if command issued successfully
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002304 * otherwise, failure occurred after mf acquired.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305 */
2306 if (mf)
2307 mpt_free_msg_frame(ioc, mf);
2308
2309 return rc;
2310}
2311
2312/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Eric Mooreba856d32006-07-11 17:34:01 -06002313/* Prototype Routine for the HOST INFO command.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 *
2315 * Outputs: None.
2316 * Return: 0 if successful
2317 * -EFAULT if data unavailable
Joe Perchesfc1323b2008-02-03 17:21:01 +02002318 * -EBUSY if previous command timeout and IOC reset is not complete.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319 * -ENODEV if no such device/adapter
2320 * -ETIME if timer expires
2321 * -ENOMEM if memory allocation error
2322 */
2323static int
Dan Carpenter28d76df2020-01-14 15:34:14 +03002324mptctl_hp_hostinfo(MPT_ADAPTER *ioc, unsigned long arg, unsigned int data_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325{
2326 hp_host_info_t __user *uarg = (void __user *) arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327 struct pci_dev *pdev;
Moore, Eric592f9c22006-02-02 17:19:47 -07002328 char *pbuf=NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329 dma_addr_t buf_dma;
2330 hp_host_info_t karg;
2331 CONFIGPARMS cfg;
2332 ConfigPageHeader_t hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333 int rc, cim_rev;
Moore, Eric592f9c22006-02-02 17:19:47 -07002334 ToolboxIstwiReadWriteRequest_t *IstwiRWRequest;
2335 MPT_FRAME_HDR *mf = NULL;
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302336 unsigned long timeleft;
2337 int retval;
Tomas Henzl73d02c202014-05-28 18:04:20 +02002338 u32 msgcontext;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340 /* Reset long to int. Should affect IA64 and SPARC only
2341 */
2342 if (data_size == sizeof(hp_host_info_t))
2343 cim_rev = 1;
2344 else if (data_size == sizeof(hp_host_info_rev0_t))
2345 cim_rev = 0; /* obsolete */
2346 else
2347 return -EFAULT;
2348
2349 if (copy_from_user(&karg, uarg, sizeof(hp_host_info_t))) {
Eric Moore29dd3602007-09-14 18:46:51 -06002350 printk(KERN_ERR MYNAM "%s@%d::mptctl_hp_host_info - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002351 "Unable to read in hp_host_info struct @ %p\n",
2352 __FILE__, __LINE__, uarg);
2353 return -EFAULT;
2354 }
2355
Prakash, Sathya09120a82007-07-24 15:49:05 +05302356 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": mptctl_hp_hostinfo called.\n",
2357 ioc->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358
2359 /* Fill in the data and return the structure to the calling
2360 * program
2361 */
2362 pdev = (struct pci_dev *) ioc->pcidev;
2363
2364 karg.vendor = pdev->vendor;
2365 karg.device = pdev->device;
2366 karg.subsystem_id = pdev->subsystem_device;
2367 karg.subsystem_vendor = pdev->subsystem_vendor;
2368 karg.devfn = pdev->devfn;
2369 karg.bus = pdev->bus->number;
2370
2371 /* Save the SCSI host no. if
2372 * SCSI driver loaded
2373 */
2374 if (ioc->sh != NULL)
2375 karg.host_no = ioc->sh->host_no;
2376 else
2377 karg.host_no = -1;
2378
Andy Shevchenko332b4b22018-01-15 19:05:58 +02002379 /* Reformat the fw_version into a string */
2380 snprintf(karg.fw_version, sizeof(karg.fw_version),
2381 "%.2hhu.%.2hhu.%.2hhu.%.2hhu",
2382 ioc->facts.FWVersion.Struct.Major,
2383 ioc->facts.FWVersion.Struct.Minor,
2384 ioc->facts.FWVersion.Struct.Unit,
2385 ioc->facts.FWVersion.Struct.Dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386
2387 /* Issue a config request to get the device serial number
2388 */
2389 hdr.PageVersion = 0;
2390 hdr.PageLength = 0;
2391 hdr.PageNumber = 0;
2392 hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
Christoph Hellwig69218ee2005-08-18 16:26:15 +02002393 cfg.cfghdr.hdr = &hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394 cfg.physAddr = -1;
2395 cfg.pageAddr = 0;
2396 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2397 cfg.dir = 0; /* read */
2398 cfg.timeout = 10;
2399
2400 strncpy(karg.serial_number, " ", 24);
2401 if (mpt_config(ioc, &cfg) == 0) {
Christoph Hellwig69218ee2005-08-18 16:26:15 +02002402 if (cfg.cfghdr.hdr->PageLength > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403 /* Issue the second config page request */
2404 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2405
2406 pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
2407 if (pbuf) {
2408 cfg.physAddr = buf_dma;
2409 if (mpt_config(ioc, &cfg) == 0) {
2410 ManufacturingPage0_t *pdata = (ManufacturingPage0_t *) pbuf;
2411 if (strlen(pdata->BoardTracerNumber) > 1) {
Dominique Martinet7bd1d612018-07-13 03:25:37 +02002412 strlcpy(karg.serial_number,
2413 pdata->BoardTracerNumber, 24);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414 }
2415 }
2416 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
2417 pbuf = NULL;
2418 }
2419 }
2420 }
2421 rc = mpt_GetIocState(ioc, 1);
2422 switch (rc) {
2423 case MPI_IOC_STATE_OPERATIONAL:
2424 karg.ioc_status = HP_STATUS_OK;
2425 break;
2426
2427 case MPI_IOC_STATE_FAULT:
2428 karg.ioc_status = HP_STATUS_FAILED;
2429 break;
2430
2431 case MPI_IOC_STATE_RESET:
2432 case MPI_IOC_STATE_READY:
2433 default:
2434 karg.ioc_status = HP_STATUS_OTHER;
2435 break;
2436 }
2437
2438 karg.base_io_addr = pci_resource_start(pdev, 0);
2439
Moore, Eric9cc1cfb2006-02-02 17:19:33 -07002440 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002441 karg.bus_phys_width = HP_BUS_WIDTH_UNK;
2442 else
2443 karg.bus_phys_width = HP_BUS_WIDTH_16;
2444
2445 karg.hard_resets = 0;
2446 karg.soft_resets = 0;
2447 karg.timeouts = 0;
2448 if (ioc->sh != NULL) {
Eric Mooree7eae9f2007-09-29 10:15:59 -06002449 MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450
2451 if (hd && (cim_rev == 1)) {
Kashyap, Desai2f187862009-05-29 16:52:37 +05302452 karg.hard_resets = ioc->hard_resets;
2453 karg.soft_resets = ioc->soft_resets;
2454 karg.timeouts = ioc->timeouts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455 }
2456 }
2457
Moore, Eric592f9c22006-02-02 17:19:47 -07002458 /*
2459 * Gather ISTWI(Industry Standard Two Wire Interface) Data
2460 */
2461 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302462 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
2463 "%s, no msg frames!!\n", ioc->name, __func__));
Moore, Eric592f9c22006-02-02 17:19:47 -07002464 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 }
2466
Moore, Eric592f9c22006-02-02 17:19:47 -07002467 IstwiRWRequest = (ToolboxIstwiReadWriteRequest_t *)mf;
Tomas Henzl73d02c202014-05-28 18:04:20 +02002468 msgcontext = IstwiRWRequest->MsgContext;
Moore, Eric592f9c22006-02-02 17:19:47 -07002469 memset(IstwiRWRequest,0,sizeof(ToolboxIstwiReadWriteRequest_t));
Tomas Henzl73d02c202014-05-28 18:04:20 +02002470 IstwiRWRequest->MsgContext = msgcontext;
Moore, Eric592f9c22006-02-02 17:19:47 -07002471 IstwiRWRequest->Function = MPI_FUNCTION_TOOLBOX;
2472 IstwiRWRequest->Tool = MPI_TOOLBOX_ISTWI_READ_WRITE_TOOL;
Moore, Eric592f9c22006-02-02 17:19:47 -07002473 IstwiRWRequest->Flags = MPI_TB_ISTWI_FLAGS_READ;
2474 IstwiRWRequest->NumAddressBytes = 0x01;
2475 IstwiRWRequest->DataLength = cpu_to_le16(0x04);
2476 if (pdev->devfn & 1)
2477 IstwiRWRequest->DeviceAddr = 0xB2;
2478 else
2479 IstwiRWRequest->DeviceAddr = 0xB0;
2480
2481 pbuf = pci_alloc_consistent(ioc->pcidev, 4, &buf_dma);
2482 if (!pbuf)
2483 goto out;
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05302484 ioc->add_sge((char *)&IstwiRWRequest->SGL,
Moore, Eric592f9c22006-02-02 17:19:47 -07002485 (MPT_SGE_FLAGS_SSIMPLE_READ|4), buf_dma);
2486
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302487 retval = 0;
2488 SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context,
2489 IstwiRWRequest->MsgContext);
2490 INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
Moore, Eric592f9c22006-02-02 17:19:47 -07002491 mpt_put_msg_frame(mptctl_id, ioc, mf);
2492
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302493retry_wait:
2494 timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
2495 HZ*MPT_IOCTL_DEFAULT_TIMEOUT);
2496 if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2497 retval = -ETIME;
2498 printk(MYIOC_s_WARN_FMT "%s: failed\n", ioc->name, __func__);
2499 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2500 mpt_free_msg_frame(ioc, mf);
2501 goto out;
2502 }
Kei Tokunaga97009a22010-06-22 19:01:51 +09002503 if (!timeleft) {
2504 printk(MYIOC_s_WARN_FMT
2505 "HOST INFO command timeout, doorbell=0x%08x\n",
2506 ioc->name, mpt_GetIocState(ioc, 0));
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302507 mptctl_timeout_expired(ioc, mf);
Kei Tokunaga97009a22010-06-22 19:01:51 +09002508 } else
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302509 goto retry_wait;
Moore, Eric592f9c22006-02-02 17:19:47 -07002510 goto out;
2511 }
2512
Prakash, Sathya09120a82007-07-24 15:49:05 +05302513 /*
Moore, Eric592f9c22006-02-02 17:19:47 -07002514 *ISTWI Data Definition
2515 * pbuf[0] = FW_VERSION = 0x4
2516 * pbuf[1] = Bay Count = 6 or 4 or 2, depending on
2517 * the config, you should be seeing one out of these three values
2518 * pbuf[2] = Drive Installed Map = bit pattern depend on which
2519 * bays have drives in them
2520 * pbuf[3] = Checksum (0x100 = (byte0 + byte2 + byte3)
2521 */
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302522 if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID)
Moore, Eric592f9c22006-02-02 17:19:47 -07002523 karg.rsvd = *(u32 *)pbuf;
2524
2525 out:
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302526 CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
2527 SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
2528
Moore, Eric592f9c22006-02-02 17:19:47 -07002529 if (pbuf)
2530 pci_free_consistent(ioc->pcidev, 4, pbuf, buf_dma);
2531
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532 /* Copy the data from kernel memory to user memory
2533 */
2534 if (copy_to_user((char __user *)arg, &karg, sizeof(hp_host_info_t))) {
Eric Moore29dd3602007-09-14 18:46:51 -06002535 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_hpgethostinfo - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536 "Unable to write out hp_host_info @ %p\n",
Eric Moore29dd3602007-09-14 18:46:51 -06002537 ioc->name, __FILE__, __LINE__, uarg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002538 return -EFAULT;
2539 }
2540
2541 return 0;
2542
2543}
2544
2545/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Eric Mooreba856d32006-07-11 17:34:01 -06002546/* Prototype Routine for the TARGET INFO command.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547 *
2548 * Outputs: None.
2549 * Return: 0 if successful
2550 * -EFAULT if data unavailable
Joe Perchesfc1323b2008-02-03 17:21:01 +02002551 * -EBUSY if previous command timeout and IOC reset is not complete.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552 * -ENODEV if no such device/adapter
2553 * -ETIME if timer expires
2554 * -ENOMEM if memory allocation error
2555 */
2556static int
Dan Carpenter28d76df2020-01-14 15:34:14 +03002557mptctl_hp_targetinfo(MPT_ADAPTER *ioc, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558{
2559 hp_target_info_t __user *uarg = (void __user *) arg;
2560 SCSIDevicePage0_t *pg0_alloc;
2561 SCSIDevicePage3_t *pg3_alloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562 MPT_SCSI_HOST *hd = NULL;
2563 hp_target_info_t karg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002564 int data_sz;
2565 dma_addr_t page_dma;
2566 CONFIGPARMS cfg;
2567 ConfigPageHeader_t hdr;
2568 int tmp, np, rc = 0;
2569
Linus Torvalds1da177e2005-04-16 15:20:36 -07002570 if (copy_from_user(&karg, uarg, sizeof(hp_target_info_t))) {
Eric Moore29dd3602007-09-14 18:46:51 -06002571 printk(KERN_ERR MYNAM "%s@%d::mptctl_hp_targetinfo - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002572 "Unable to read in hp_host_targetinfo struct @ %p\n",
2573 __FILE__, __LINE__, uarg);
2574 return -EFAULT;
2575 }
2576
Dan Carpentera7043e92018-01-25 17:27:27 +03002577 if (karg.hdr.id >= MPT_MAX_FC_DEVICES)
2578 return -EINVAL;
Eric Moore29dd3602007-09-14 18:46:51 -06002579 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_hp_targetinfo called.\n",
Prakash, Sathya09120a82007-07-24 15:49:05 +05302580 ioc->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581
2582 /* There is nothing to do for FCP parts.
2583 */
Moore, Eric9cc1cfb2006-02-02 17:19:33 -07002584 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002585 return 0;
2586
2587 if ((ioc->spi_data.sdp0length == 0) || (ioc->sh == NULL))
2588 return 0;
2589
2590 if (ioc->sh->host_no != karg.hdr.host)
2591 return -ENODEV;
2592
2593 /* Get the data transfer speeds
2594 */
2595 data_sz = ioc->spi_data.sdp0length * 4;
Li Heng8fee79e2020-07-29 17:19:50 +08002596 pg0_alloc = pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597 if (pg0_alloc) {
2598 hdr.PageVersion = ioc->spi_data.sdp0version;
2599 hdr.PageLength = data_sz;
2600 hdr.PageNumber = 0;
2601 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2602
Christoph Hellwig69218ee2005-08-18 16:26:15 +02002603 cfg.cfghdr.hdr = &hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2605 cfg.dir = 0;
2606 cfg.timeout = 0;
2607 cfg.physAddr = page_dma;
2608
2609 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2610
2611 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2612 np = le32_to_cpu(pg0_alloc->NegotiatedParameters);
2613 karg.negotiated_width = np & MPI_SCSIDEVPAGE0_NP_WIDE ?
2614 HP_BUS_WIDTH_16 : HP_BUS_WIDTH_8;
2615
2616 if (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) {
2617 tmp = (np & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> 8;
2618 if (tmp < 0x09)
2619 karg.negotiated_speed = HP_DEV_SPEED_ULTRA320;
2620 else if (tmp <= 0x09)
2621 karg.negotiated_speed = HP_DEV_SPEED_ULTRA160;
2622 else if (tmp <= 0x0A)
2623 karg.negotiated_speed = HP_DEV_SPEED_ULTRA2;
2624 else if (tmp <= 0x0C)
2625 karg.negotiated_speed = HP_DEV_SPEED_ULTRA;
2626 else if (tmp <= 0x25)
2627 karg.negotiated_speed = HP_DEV_SPEED_FAST;
2628 else
2629 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2630 } else
2631 karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
2632 }
2633
2634 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg0_alloc, page_dma);
2635 }
2636
2637 /* Set defaults
2638 */
2639 karg.message_rejects = -1;
2640 karg.phase_errors = -1;
2641 karg.parity_errors = -1;
2642 karg.select_timeouts = -1;
2643
2644 /* Get the target error parameters
2645 */
2646 hdr.PageVersion = 0;
2647 hdr.PageLength = 0;
2648 hdr.PageNumber = 3;
2649 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
2650
Christoph Hellwig69218ee2005-08-18 16:26:15 +02002651 cfg.cfghdr.hdr = &hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2653 cfg.dir = 0;
2654 cfg.timeout = 0;
2655 cfg.physAddr = -1;
Christoph Hellwig69218ee2005-08-18 16:26:15 +02002656 if ((mpt_config(ioc, &cfg) == 0) && (cfg.cfghdr.hdr->PageLength > 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002657 /* Issue the second config page request */
2658 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
Christoph Hellwig69218ee2005-08-18 16:26:15 +02002659 data_sz = (int) cfg.cfghdr.hdr->PageLength * 4;
Li Heng8fee79e2020-07-29 17:19:50 +08002660 pg3_alloc = pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661 if (pg3_alloc) {
2662 cfg.physAddr = page_dma;
2663 cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
2664 if ((rc = mpt_config(ioc, &cfg)) == 0) {
2665 karg.message_rejects = (u32) le16_to_cpu(pg3_alloc->MsgRejectCount);
2666 karg.phase_errors = (u32) le16_to_cpu(pg3_alloc->PhaseErrorCount);
2667 karg.parity_errors = (u32) le16_to_cpu(pg3_alloc->ParityErrorCount);
2668 }
2669 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg3_alloc, page_dma);
2670 }
2671 }
Eric Mooree7eae9f2007-09-29 10:15:59 -06002672 hd = shost_priv(ioc->sh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673 if (hd != NULL)
2674 karg.select_timeouts = hd->sel_timeout[karg.hdr.id];
2675
2676 /* Copy the data from kernel memory to user memory
2677 */
2678 if (copy_to_user((char __user *)arg, &karg, sizeof(hp_target_info_t))) {
Eric Moore29dd3602007-09-14 18:46:51 -06002679 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_hp_target_info - "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002680 "Unable to write out mpt_ioctl_targetinfo struct @ %p\n",
Eric Moore29dd3602007-09-14 18:46:51 -06002681 ioc->name, __FILE__, __LINE__, uarg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 return -EFAULT;
2683 }
2684
2685 return 0;
2686}
2687
2688/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2689
Arjan van de Venfa027c22007-02-12 00:55:33 -08002690static const struct file_operations mptctl_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002691 .owner = THIS_MODULE,
2692 .llseek = no_llseek,
Moore, Ericea5a7a822006-02-02 17:20:01 -07002693 .fasync = mptctl_fasync,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002694 .unlocked_ioctl = mptctl_ioctl,
2695#ifdef CONFIG_COMPAT
2696 .compat_ioctl = compat_mpctl_ioctl,
2697#endif
2698};
2699
2700static struct miscdevice mptctl_miscdev = {
2701 MPT_MINOR,
2702 MYNAM,
2703 &mptctl_fops
2704};
2705
2706/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2707
2708#ifdef CONFIG_COMPAT
2709
Linus Torvalds1da177e2005-04-16 15:20:36 -07002710static int
2711compat_mptfwxfer_ioctl(struct file *filp, unsigned int cmd,
2712 unsigned long arg)
2713{
2714 struct mpt_fw_xfer32 kfw32;
2715 struct mpt_fw_xfer kfw;
2716 MPT_ADAPTER *iocp = NULL;
2717 int iocnum, iocnumX;
2718 int nonblock = (filp->f_flags & O_NONBLOCK);
2719 int ret;
2720
Linus Torvalds1da177e2005-04-16 15:20:36 -07002721
2722 if (copy_from_user(&kfw32, (char __user *)arg, sizeof(kfw32)))
2723 return -EFAULT;
2724
2725 /* Verify intended MPT adapter */
2726 iocnumX = kfw32.iocnum & 0xFF;
2727 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2728 (iocp == NULL)) {
Prakash, Sathya09120a82007-07-24 15:49:05 +05302729 printk(KERN_DEBUG MYNAM "::compat_mptfwxfer_ioctl @%d - ioc%d not found!\n",
Eric Moore29dd3602007-09-14 18:46:51 -06002730 __LINE__, iocnumX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002731 return -ENODEV;
2732 }
2733
2734 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2735 return ret;
2736
Prakash, Sathya09120a82007-07-24 15:49:05 +05302737 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "compat_mptfwxfer_ioctl() called\n",
2738 iocp->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739 kfw.iocnum = iocnum;
2740 kfw.fwlen = kfw32.fwlen;
2741 kfw.bufp = compat_ptr(kfw32.bufp);
2742
Dan Carpenter28d76df2020-01-14 15:34:14 +03002743 ret = mptctl_do_fw_download(iocp, kfw.bufp, kfw.fwlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002744
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302745 mutex_unlock(&iocp->ioctl_cmds.mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002746
2747 return ret;
2748}
2749
2750static int
2751compat_mpt_command(struct file *filp, unsigned int cmd,
2752 unsigned long arg)
2753{
2754 struct mpt_ioctl_command32 karg32;
2755 struct mpt_ioctl_command32 __user *uarg = (struct mpt_ioctl_command32 __user *) arg;
2756 struct mpt_ioctl_command karg;
2757 MPT_ADAPTER *iocp = NULL;
2758 int iocnum, iocnumX;
2759 int nonblock = (filp->f_flags & O_NONBLOCK);
2760 int ret;
2761
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762 if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32)))
2763 return -EFAULT;
2764
2765 /* Verify intended MPT adapter */
2766 iocnumX = karg32.hdr.iocnum & 0xFF;
2767 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
2768 (iocp == NULL)) {
Prakash, Sathya09120a82007-07-24 15:49:05 +05302769 printk(KERN_DEBUG MYNAM "::compat_mpt_command @%d - ioc%d not found!\n",
Eric Moore29dd3602007-09-14 18:46:51 -06002770 __LINE__, iocnumX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771 return -ENODEV;
2772 }
2773
2774 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
2775 return ret;
2776
Prakash, Sathya09120a82007-07-24 15:49:05 +05302777 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "compat_mpt_command() called\n",
2778 iocp->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002779 /* Copy data to karg */
2780 karg.hdr.iocnum = karg32.hdr.iocnum;
2781 karg.hdr.port = karg32.hdr.port;
2782 karg.timeout = karg32.timeout;
2783 karg.maxReplyBytes = karg32.maxReplyBytes;
2784
2785 karg.dataInSize = karg32.dataInSize;
2786 karg.dataOutSize = karg32.dataOutSize;
2787 karg.maxSenseBytes = karg32.maxSenseBytes;
2788 karg.dataSgeOffset = karg32.dataSgeOffset;
2789
2790 karg.replyFrameBufPtr = (char __user *)(unsigned long)karg32.replyFrameBufPtr;
2791 karg.dataInBufPtr = (char __user *)(unsigned long)karg32.dataInBufPtr;
2792 karg.dataOutBufPtr = (char __user *)(unsigned long)karg32.dataOutBufPtr;
2793 karg.senseDataPtr = (char __user *)(unsigned long)karg32.senseDataPtr;
2794
2795 /* Pass new structure to do_mpt_command
2796 */
Dan Carpenter28d76df2020-01-14 15:34:14 +03002797 ret = mptctl_do_mpt_command (iocp, karg, &uarg->MF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302799 mutex_unlock(&iocp->ioctl_cmds.mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800
2801 return ret;
2802}
2803
2804static long compat_mpctl_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
2805{
2806 long ret;
Arnd Bergmannc45d15d2010-06-02 14:28:52 +02002807 mutex_lock(&mpctl_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002808 switch (cmd) {
2809 case MPTIOCINFO:
2810 case MPTIOCINFO1:
2811 case MPTIOCINFO2:
2812 case MPTTARGETINFO:
2813 case MPTEVENTQUERY:
2814 case MPTEVENTENABLE:
2815 case MPTEVENTREPORT:
2816 case MPTHARDRESET:
2817 case HP_GETHOSTINFO:
2818 case HP_GETTARGETINFO:
2819 case MPTTEST:
2820 ret = __mptctl_ioctl(f, cmd, arg);
2821 break;
2822 case MPTCOMMAND32:
2823 ret = compat_mpt_command(f, cmd, arg);
2824 break;
2825 case MPTFWDOWNLOAD32:
2826 ret = compat_mptfwxfer_ioctl(f, cmd, arg);
2827 break;
2828 default:
2829 ret = -ENOIOCTLCMD;
2830 break;
2831 }
Arnd Bergmannc45d15d2010-06-02 14:28:52 +02002832 mutex_unlock(&mpctl_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002833 return ret;
2834}
2835
2836#endif
2837
2838
2839/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2840/*
2841 * mptctl_probe - Installs ioctl devices per bus.
2842 * @pdev: Pointer to pci_dev structure
2843 *
2844 * Returns 0 for success, non-zero for failure.
2845 *
2846 */
2847
2848static int
2849mptctl_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2850{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
2852
Kashyap, Desaiea2a788d2009-05-29 16:46:50 +05302853 mutex_init(&ioc->ioctl_cmds.mutex);
2854 init_completion(&ioc->ioctl_cmds.done);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002856}
2857
2858/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2859/*
2860 * mptctl_remove - Removed ioctl devices
2861 * @pdev: Pointer to pci_dev structure
2862 *
2863 *
2864 */
2865static void
2866mptctl_remove(struct pci_dev *pdev)
2867{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868}
2869
2870static struct mpt_pci_driver mptctl_driver = {
2871 .probe = mptctl_probe,
2872 .remove = mptctl_remove,
2873};
2874
2875/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2876static int __init mptctl_init(void)
2877{
2878 int err;
2879 int where = 1;
2880
2881 show_mptmod_ver(my_NAME, my_VERSION);
2882
Prakash, Sathya09120a82007-07-24 15:49:05 +05302883 mpt_device_driver_register(&mptctl_driver, MPTCTL_DRIVER);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002884
2885 /* Register this device */
2886 err = misc_register(&mptctl_miscdev);
2887 if (err < 0) {
2888 printk(KERN_ERR MYNAM ": Can't register misc device [minor=%d].\n", MPT_MINOR);
2889 goto out_fail;
2890 }
2891 printk(KERN_INFO MYNAM ": Registered with Fusion MPT base driver\n");
2892 printk(KERN_INFO MYNAM ": /dev/%s @ (major,minor=%d,%d)\n",
2893 mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
2894
2895 /*
2896 * Install our handler
2897 */
2898 ++where;
Kashyap, Desai213aaca2010-07-26 18:57:36 +05302899 mptctl_id = mpt_register(mptctl_reply, MPTCTL_DRIVER,
2900 "mptctl_reply");
Prakash, Sathyaf606f572007-08-14 16:12:53 +05302901 if (!mptctl_id || mptctl_id >= MPT_MAX_PROTOCOL_DRIVERS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002902 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
2903 misc_deregister(&mptctl_miscdev);
2904 err = -EBUSY;
2905 goto out_fail;
2906 }
2907
Kashyap, Desai213aaca2010-07-26 18:57:36 +05302908 mptctl_taskmgmt_id = mpt_register(mptctl_taskmgmt_reply, MPTCTL_DRIVER,
2909 "mptctl_taskmgmt_reply");
Kei Tokunaga65c054f2010-03-15 14:48:43 +09002910 if (!mptctl_taskmgmt_id || mptctl_taskmgmt_id >= MPT_MAX_PROTOCOL_DRIVERS) {
2911 printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
2912 mpt_deregister(mptctl_id);
2913 misc_deregister(&mptctl_miscdev);
2914 err = -EBUSY;
2915 goto out_fail;
2916 }
2917
Prakash, Sathya09120a82007-07-24 15:49:05 +05302918 mpt_reset_register(mptctl_id, mptctl_ioc_reset);
2919 mpt_event_register(mptctl_id, mptctl_event_process);
Moore, Ericea5a7a822006-02-02 17:20:01 -07002920
Linus Torvalds1da177e2005-04-16 15:20:36 -07002921 return 0;
2922
2923out_fail:
2924
2925 mpt_device_driver_deregister(MPTCTL_DRIVER);
2926
2927 return err;
2928}
2929
2930/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2931static void mptctl_exit(void)
2932{
2933 misc_deregister(&mptctl_miscdev);
2934 printk(KERN_INFO MYNAM ": Deregistered /dev/%s @ (major,minor=%d,%d)\n",
2935 mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);
2936
Kei Tokunaga65c054f2010-03-15 14:48:43 +09002937 /* De-register event handler from base module */
2938 mpt_event_deregister(mptctl_id);
2939
Linus Torvalds1da177e2005-04-16 15:20:36 -07002940 /* De-register reset handler from base module */
2941 mpt_reset_deregister(mptctl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942
2943 /* De-register callback handler from base module */
Kei Tokunaga65c054f2010-03-15 14:48:43 +09002944 mpt_deregister(mptctl_taskmgmt_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002945 mpt_deregister(mptctl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002946
2947 mpt_device_driver_deregister(MPTCTL_DRIVER);
2948
2949}
2950
2951/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2952
2953module_init(mptctl_init);
2954module_exit(mptctl_exit);