aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/mpt3sas/mpt3sas_ctl.c
diff options
context:
space:
mode:
authorSreekanth Reddy <Sreekanth.Reddy@lsi.com>2012-11-29 21:14:21 -0500
committerJames Bottomley <JBottomley@Parallels.com>2012-12-01 05:09:17 -0500
commitf92363d12359498f9a9960511de1a550f0ec41c2 (patch)
treec7f34e33b085b5da0b36e8d830cd98fc74d5ab58 /drivers/scsi/mpt3sas/mpt3sas_ctl.c
parentd84fd392bd61524c4d81367969424e6c17086c8c (diff)
[SCSI] mpt3sas: add new driver supporting 12GB SAS
These driver files are initially, substantially similar to mpt2sas but, because mpt2sas is going into maintenance mode and mp3sas will become heavily developed, we elected to keep the code bases separate. Signed-off-by: Sreekanth Reddy <Sreekanth.Reddy@lsi.com> Reviewed-by: Nagalakshmi Nandigama <Nagalakshmi.Nandigama@lsi.com> Signed-off-by: James Bottomley <JBottomley@Parallels.com>
Diffstat (limited to 'drivers/scsi/mpt3sas/mpt3sas_ctl.c')
-rw-r--r--drivers/scsi/mpt3sas/mpt3sas_ctl.c3297
1 files changed, 3297 insertions, 0 deletions
diff --git a/drivers/scsi/mpt3sas/mpt3sas_ctl.c b/drivers/scsi/mpt3sas/mpt3sas_ctl.c
new file mode 100644
index 000000000000..8af944d7d13d
--- /dev/null
+++ b/drivers/scsi/mpt3sas/mpt3sas_ctl.c
@@ -0,0 +1,3297 @@
1/*
2 * Management Module Support for MPT (Message Passing Technology) based
3 * controllers
4 *
5 * This code is based on drivers/scsi/mpt3sas/mpt3sas_ctl.c
6 * Copyright (C) 2012 LSI Corporation
7 * (mailto:DL-MPTFusionLinux@lsi.com)
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 2
12 * of the License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * NO WARRANTY
20 * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
21 * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
22 * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
23 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
24 * solely responsible for determining the appropriateness of using and
25 * distributing the Program and assumes all risks associated with its
26 * exercise of rights under this Agreement, including but not limited to
27 * the risks and costs of program errors, damage to or loss of data,
28 * programs or equipment, and unavailability or interruption of operations.
29
30 * DISCLAIMER OF LIABILITY
31 * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
32 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
34 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
35 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
36 * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
37 * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
38
39 * You should have received a copy of the GNU General Public License
40 * along with this program; if not, write to the Free Software
41 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
42 * USA.
43 */
44
45#include <linux/version.h>
46#include <linux/kernel.h>
47#include <linux/module.h>
48#include <linux/errno.h>
49#include <linux/init.h>
50#include <linux/slab.h>
51#include <linux/types.h>
52#include <linux/pci.h>
53#include <linux/delay.h>
54#include <linux/compat.h>
55#include <linux/poll.h>
56
57#include <linux/io.h>
58#include <linux/uaccess.h>
59
60#include "mpt3sas_base.h"
61#include "mpt3sas_ctl.h"
62
63
64static struct fasync_struct *async_queue;
65static DECLARE_WAIT_QUEUE_HEAD(ctl_poll_wait);
66
67
68/**
69 * enum block_state - blocking state
70 * @NON_BLOCKING: non blocking
71 * @BLOCKING: blocking
72 *
73 * These states are for ioctls that need to wait for a response
74 * from firmware, so they probably require sleep.
75 */
76enum block_state {
77 NON_BLOCKING,
78 BLOCKING,
79};
80
81#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
82/**
83 * _ctl_sas_device_find_by_handle - sas device search
84 * @ioc: per adapter object
85 * @handle: sas device handle (assigned by firmware)
86 * Context: Calling function should acquire ioc->sas_device_lock
87 *
88 * This searches for sas_device based on sas_address, then return sas_device
89 * object.
90 */
91static struct _sas_device *
92_ctl_sas_device_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle)
93{
94 struct _sas_device *sas_device, *r;
95
96 r = NULL;
97 list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
98 if (sas_device->handle != handle)
99 continue;
100 r = sas_device;
101 goto out;
102 }
103
104 out:
105 return r;
106}
107
108/**
109 * _ctl_display_some_debug - debug routine
110 * @ioc: per adapter object
111 * @smid: system request message index
112 * @calling_function_name: string pass from calling function
113 * @mpi_reply: reply message frame
114 * Context: none.
115 *
116 * Function for displaying debug info helpful when debugging issues
117 * in this module.
118 */
119static void
120_ctl_display_some_debug(struct MPT3SAS_ADAPTER *ioc, u16 smid,
121 char *calling_function_name, MPI2DefaultReply_t *mpi_reply)
122{
123 Mpi2ConfigRequest_t *mpi_request;
124 char *desc = NULL;
125
126 if (!(ioc->logging_level & MPT_DEBUG_IOCTL))
127 return;
128
129 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
130 switch (mpi_request->Function) {
131 case MPI2_FUNCTION_SCSI_IO_REQUEST:
132 {
133 Mpi2SCSIIORequest_t *scsi_request =
134 (Mpi2SCSIIORequest_t *)mpi_request;
135
136 snprintf(ioc->tmp_string, MPT_STRING_LENGTH,
137 "scsi_io, cmd(0x%02x), cdb_len(%d)",
138 scsi_request->CDB.CDB32[0],
139 le16_to_cpu(scsi_request->IoFlags) & 0xF);
140 desc = ioc->tmp_string;
141 break;
142 }
143 case MPI2_FUNCTION_SCSI_TASK_MGMT:
144 desc = "task_mgmt";
145 break;
146 case MPI2_FUNCTION_IOC_INIT:
147 desc = "ioc_init";
148 break;
149 case MPI2_FUNCTION_IOC_FACTS:
150 desc = "ioc_facts";
151 break;
152 case MPI2_FUNCTION_CONFIG:
153 {
154 Mpi2ConfigRequest_t *config_request =
155 (Mpi2ConfigRequest_t *)mpi_request;
156
157 snprintf(ioc->tmp_string, MPT_STRING_LENGTH,
158 "config, type(0x%02x), ext_type(0x%02x), number(%d)",
159 (config_request->Header.PageType &
160 MPI2_CONFIG_PAGETYPE_MASK), config_request->ExtPageType,
161 config_request->Header.PageNumber);
162 desc = ioc->tmp_string;
163 break;
164 }
165 case MPI2_FUNCTION_PORT_FACTS:
166 desc = "port_facts";
167 break;
168 case MPI2_FUNCTION_PORT_ENABLE:
169 desc = "port_enable";
170 break;
171 case MPI2_FUNCTION_EVENT_NOTIFICATION:
172 desc = "event_notification";
173 break;
174 case MPI2_FUNCTION_FW_DOWNLOAD:
175 desc = "fw_download";
176 break;
177 case MPI2_FUNCTION_FW_UPLOAD:
178 desc = "fw_upload";
179 break;
180 case MPI2_FUNCTION_RAID_ACTION:
181 desc = "raid_action";
182 break;
183 case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
184 {
185 Mpi2SCSIIORequest_t *scsi_request =
186 (Mpi2SCSIIORequest_t *)mpi_request;
187
188 snprintf(ioc->tmp_string, MPT_STRING_LENGTH,
189 "raid_pass, cmd(0x%02x), cdb_len(%d)",
190 scsi_request->CDB.CDB32[0],
191 le16_to_cpu(scsi_request->IoFlags) & 0xF);
192 desc = ioc->tmp_string;
193 break;
194 }
195 case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL:
196 desc = "sas_iounit_cntl";
197 break;
198 case MPI2_FUNCTION_SATA_PASSTHROUGH:
199 desc = "sata_pass";
200 break;
201 case MPI2_FUNCTION_DIAG_BUFFER_POST:
202 desc = "diag_buffer_post";
203 break;
204 case MPI2_FUNCTION_DIAG_RELEASE:
205 desc = "diag_release";
206 break;
207 case MPI2_FUNCTION_SMP_PASSTHROUGH:
208 desc = "smp_passthrough";
209 break;
210 }
211
212 if (!desc)
213 return;
214
215 pr_info(MPT3SAS_FMT "%s: %s, smid(%d)\n",
216 ioc->name, calling_function_name, desc, smid);
217
218 if (!mpi_reply)
219 return;
220
221 if (mpi_reply->IOCStatus || mpi_reply->IOCLogInfo)
222 pr_info(MPT3SAS_FMT
223 "\tiocstatus(0x%04x), loginfo(0x%08x)\n",
224 ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
225 le32_to_cpu(mpi_reply->IOCLogInfo));
226
227 if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
228 mpi_request->Function ==
229 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) {
230 Mpi2SCSIIOReply_t *scsi_reply =
231 (Mpi2SCSIIOReply_t *)mpi_reply;
232 struct _sas_device *sas_device = NULL;
233 unsigned long flags;
234
235 spin_lock_irqsave(&ioc->sas_device_lock, flags);
236 sas_device = _ctl_sas_device_find_by_handle(ioc,
237 le16_to_cpu(scsi_reply->DevHandle));
238 if (sas_device) {
239 pr_warn(MPT3SAS_FMT "\tsas_address(0x%016llx), phy(%d)\n",
240 ioc->name, (unsigned long long)
241 sas_device->sas_address, sas_device->phy);
242 pr_warn(MPT3SAS_FMT
243 "\tenclosure_logical_id(0x%016llx), slot(%d)\n",
244 ioc->name, (unsigned long long)
245 sas_device->enclosure_logical_id, sas_device->slot);
246 }
247 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
248 if (scsi_reply->SCSIState || scsi_reply->SCSIStatus)
249 pr_info(MPT3SAS_FMT
250 "\tscsi_state(0x%02x), scsi_status"
251 "(0x%02x)\n", ioc->name,
252 scsi_reply->SCSIState,
253 scsi_reply->SCSIStatus);
254 }
255}
256
257#endif
258
259/**
260 * mpt3sas_ctl_done - ctl module completion routine
261 * @ioc: per adapter object
262 * @smid: system request message index
263 * @msix_index: MSIX table index supplied by the OS
264 * @reply: reply message frame(lower 32bit addr)
265 * Context: none.
266 *
267 * The callback handler when using ioc->ctl_cb_idx.
268 *
269 * Return 1 meaning mf should be freed from _base_interrupt
270 * 0 means the mf is freed from this function.
271 */
272u8
273mpt3sas_ctl_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
274 u32 reply)
275{
276 MPI2DefaultReply_t *mpi_reply;
277 Mpi2SCSIIOReply_t *scsiio_reply;
278 const void *sense_data;
279 u32 sz;
280
281 if (ioc->ctl_cmds.status == MPT3_CMD_NOT_USED)
282 return 1;
283 if (ioc->ctl_cmds.smid != smid)
284 return 1;
285 ioc->ctl_cmds.status |= MPT3_CMD_COMPLETE;
286 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
287 if (mpi_reply) {
288 memcpy(ioc->ctl_cmds.reply, mpi_reply, mpi_reply->MsgLength*4);
289 ioc->ctl_cmds.status |= MPT3_CMD_REPLY_VALID;
290 /* get sense data */
291 if (mpi_reply->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
292 mpi_reply->Function ==
293 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) {
294 scsiio_reply = (Mpi2SCSIIOReply_t *)mpi_reply;
295 if (scsiio_reply->SCSIState &
296 MPI2_SCSI_STATE_AUTOSENSE_VALID) {
297 sz = min_t(u32, SCSI_SENSE_BUFFERSIZE,
298 le32_to_cpu(scsiio_reply->SenseCount));
299 sense_data = mpt3sas_base_get_sense_buffer(ioc,
300 smid);
301 memcpy(ioc->ctl_cmds.sense, sense_data, sz);
302 }
303 }
304 }
305#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
306 _ctl_display_some_debug(ioc, smid, "ctl_done", mpi_reply);
307#endif
308 ioc->ctl_cmds.status &= ~MPT3_CMD_PENDING;
309 complete(&ioc->ctl_cmds.done);
310 return 1;
311}
312
313/**
314 * _ctl_check_event_type - determines when an event needs logging
315 * @ioc: per adapter object
316 * @event: firmware event
317 *
318 * The bitmask in ioc->event_type[] indicates which events should be
319 * be saved in the driver event_log. This bitmask is set by application.
320 *
321 * Returns 1 when event should be captured, or zero means no match.
322 */
323static int
324_ctl_check_event_type(struct MPT3SAS_ADAPTER *ioc, u16 event)
325{
326 u16 i;
327 u32 desired_event;
328
329 if (event >= 128 || !event || !ioc->event_log)
330 return 0;
331
332 desired_event = (1 << (event % 32));
333 if (!desired_event)
334 desired_event = 1;
335 i = event / 32;
336 return desired_event & ioc->event_type[i];
337}
338
339/**
340 * mpt3sas_ctl_add_to_event_log - add event
341 * @ioc: per adapter object
342 * @mpi_reply: reply message frame
343 *
344 * Return nothing.
345 */
346void
347mpt3sas_ctl_add_to_event_log(struct MPT3SAS_ADAPTER *ioc,
348 Mpi2EventNotificationReply_t *mpi_reply)
349{
350 struct MPT3_IOCTL_EVENTS *event_log;
351 u16 event;
352 int i;
353 u32 sz, event_data_sz;
354 u8 send_aen = 0;
355
356 if (!ioc->event_log)
357 return;
358
359 event = le16_to_cpu(mpi_reply->Event);
360
361 if (_ctl_check_event_type(ioc, event)) {
362
363 /* insert entry into circular event_log */
364 i = ioc->event_context % MPT3SAS_CTL_EVENT_LOG_SIZE;
365 event_log = ioc->event_log;
366 event_log[i].event = event;
367 event_log[i].context = ioc->event_context++;
368
369 event_data_sz = le16_to_cpu(mpi_reply->EventDataLength)*4;
370 sz = min_t(u32, event_data_sz, MPT3_EVENT_DATA_SIZE);
371 memset(event_log[i].data, 0, MPT3_EVENT_DATA_SIZE);
372 memcpy(event_log[i].data, mpi_reply->EventData, sz);
373 send_aen = 1;
374 }
375
376 /* This aen_event_read_flag flag is set until the
377 * application has read the event log.
378 * For MPI2_EVENT_LOG_ENTRY_ADDED, we always notify.
379 */
380 if (event == MPI2_EVENT_LOG_ENTRY_ADDED ||
381 (send_aen && !ioc->aen_event_read_flag)) {
382 ioc->aen_event_read_flag = 1;
383 wake_up_interruptible(&ctl_poll_wait);
384 if (async_queue)
385 kill_fasync(&async_queue, SIGIO, POLL_IN);
386 }
387}
388
389/**
390 * mpt3sas_ctl_event_callback - firmware event handler (called at ISR time)
391 * @ioc: per adapter object
392 * @msix_index: MSIX table index supplied by the OS
393 * @reply: reply message frame(lower 32bit addr)
394 * Context: interrupt.
395 *
396 * This function merely adds a new work task into ioc->firmware_event_thread.
397 * The tasks are worked from _firmware_event_work in user context.
398 *
399 * Return 1 meaning mf should be freed from _base_interrupt
400 * 0 means the mf is freed from this function.
401 */
402u8
403mpt3sas_ctl_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index,
404 u32 reply)
405{
406 Mpi2EventNotificationReply_t *mpi_reply;
407
408 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
409 mpt3sas_ctl_add_to_event_log(ioc, mpi_reply);
410 return 1;
411}
412
413/**
414 * _ctl_verify_adapter - validates ioc_number passed from application
415 * @ioc: per adapter object
416 * @iocpp: The ioc pointer is returned in this.
417 *
418 * Return (-1) means error, else ioc_number.
419 */
420static int
421_ctl_verify_adapter(int ioc_number, struct MPT3SAS_ADAPTER **iocpp)
422{
423 struct MPT3SAS_ADAPTER *ioc;
424
425 list_for_each_entry(ioc, &mpt3sas_ioc_list, list) {
426 if (ioc->id != ioc_number)
427 continue;
428 *iocpp = ioc;
429 return ioc_number;
430 }
431 *iocpp = NULL;
432 return -1;
433}
434
435/**
436 * mpt3sas_ctl_reset_handler - reset callback handler (for ctl)
437 * @ioc: per adapter object
438 * @reset_phase: phase
439 *
440 * The handler for doing any required cleanup or initialization.
441 *
442 * The reset phase can be MPT3_IOC_PRE_RESET, MPT3_IOC_AFTER_RESET,
443 * MPT3_IOC_DONE_RESET
444 */
445void
446mpt3sas_ctl_reset_handler(struct MPT3SAS_ADAPTER *ioc, int reset_phase)
447{
448 int i;
449 u8 issue_reset;
450
451 switch (reset_phase) {
452 case MPT3_IOC_PRE_RESET:
453 dtmprintk(ioc, pr_info(MPT3SAS_FMT
454 "%s: MPT3_IOC_PRE_RESET\n", ioc->name, __func__));
455 for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
456 if (!(ioc->diag_buffer_status[i] &
457 MPT3_DIAG_BUFFER_IS_REGISTERED))
458 continue;
459 if ((ioc->diag_buffer_status[i] &
460 MPT3_DIAG_BUFFER_IS_RELEASED))
461 continue;
462 mpt3sas_send_diag_release(ioc, i, &issue_reset);
463 }
464 break;
465 case MPT3_IOC_AFTER_RESET:
466 dtmprintk(ioc, pr_info(MPT3SAS_FMT
467 "%s: MPT3_IOC_AFTER_RESET\n", ioc->name, __func__));
468 if (ioc->ctl_cmds.status & MPT3_CMD_PENDING) {
469 ioc->ctl_cmds.status |= MPT3_CMD_RESET;
470 mpt3sas_base_free_smid(ioc, ioc->ctl_cmds.smid);
471 complete(&ioc->ctl_cmds.done);
472 }
473 break;
474 case MPT3_IOC_DONE_RESET:
475 dtmprintk(ioc, pr_info(MPT3SAS_FMT
476 "%s: MPT3_IOC_DONE_RESET\n", ioc->name, __func__));
477
478 for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
479 if (!(ioc->diag_buffer_status[i] &
480 MPT3_DIAG_BUFFER_IS_REGISTERED))
481 continue;
482 if ((ioc->diag_buffer_status[i] &
483 MPT3_DIAG_BUFFER_IS_RELEASED))
484 continue;
485 ioc->diag_buffer_status[i] |=
486 MPT3_DIAG_BUFFER_IS_DIAG_RESET;
487 }
488 break;
489 }
490}
491
492/**
493 * _ctl_fasync -
494 * @fd -
495 * @filep -
496 * @mode -
497 *
498 * Called when application request fasyn callback handler.
499 */
500static int
501_ctl_fasync(int fd, struct file *filep, int mode)
502{
503 return fasync_helper(fd, filep, mode, &async_queue);
504}
505
506/**
507 * _ctl_release -
508 * @inode -
509 * @filep -
510 *
511 * Called when application releases the fasyn callback handler.
512 */
513static int
514_ctl_release(struct inode *inode, struct file *filep)
515{
516 return fasync_helper(-1, filep, 0, &async_queue);
517}
518
519/**
520 * _ctl_poll -
521 * @file -
522 * @wait -
523 *
524 */
525static unsigned int
526_ctl_poll(struct file *filep, poll_table *wait)
527{
528 struct MPT3SAS_ADAPTER *ioc;
529
530 poll_wait(filep, &ctl_poll_wait, wait);
531
532 list_for_each_entry(ioc, &mpt3sas_ioc_list, list) {
533 if (ioc->aen_event_read_flag)
534 return POLLIN | POLLRDNORM;
535 }
536 return 0;
537}
538
539/**
540 * _ctl_set_task_mid - assign an active smid to tm request
541 * @ioc: per adapter object
542 * @karg - (struct mpt3_ioctl_command)
543 * @tm_request - pointer to mf from user space
544 *
545 * Returns 0 when an smid if found, else fail.
546 * during failure, the reply frame is filled.
547 */
548static int
549_ctl_set_task_mid(struct MPT3SAS_ADAPTER *ioc, struct mpt3_ioctl_command *karg,
550 Mpi2SCSITaskManagementRequest_t *tm_request)
551{
552 u8 found = 0;
553 u16 i;
554 u16 handle;
555 struct scsi_cmnd *scmd;
556 struct MPT3SAS_DEVICE *priv_data;
557 unsigned long flags;
558 Mpi2SCSITaskManagementReply_t *tm_reply;
559 u32 sz;
560 u32 lun;
561 char *desc = NULL;
562
563 if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK)
564 desc = "abort_task";
565 else if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK)
566 desc = "query_task";
567 else
568 return 0;
569
570 lun = scsilun_to_int((struct scsi_lun *)tm_request->LUN);
571
572 handle = le16_to_cpu(tm_request->DevHandle);
573 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
574 for (i = ioc->scsiio_depth; i && !found; i--) {
575 scmd = ioc->scsi_lookup[i - 1].scmd;
576 if (scmd == NULL || scmd->device == NULL ||
577 scmd->device->hostdata == NULL)
578 continue;
579 if (lun != scmd->device->lun)
580 continue;
581 priv_data = scmd->device->hostdata;
582 if (priv_data->sas_target == NULL)
583 continue;
584 if (priv_data->sas_target->handle != handle)
585 continue;
586 tm_request->TaskMID = cpu_to_le16(ioc->scsi_lookup[i - 1].smid);
587 found = 1;
588 }
589 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
590
591 if (!found) {
592 dctlprintk(ioc, pr_info(MPT3SAS_FMT
593 "%s: handle(0x%04x), lun(%d), no active mid!!\n",
594 ioc->name,
595 desc, le16_to_cpu(tm_request->DevHandle), lun));
596 tm_reply = ioc->ctl_cmds.reply;
597 tm_reply->DevHandle = tm_request->DevHandle;
598 tm_reply->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
599 tm_reply->TaskType = tm_request->TaskType;
600 tm_reply->MsgLength = sizeof(Mpi2SCSITaskManagementReply_t)/4;
601 tm_reply->VP_ID = tm_request->VP_ID;
602 tm_reply->VF_ID = tm_request->VF_ID;
603 sz = min_t(u32, karg->max_reply_bytes, ioc->reply_sz);
604 if (copy_to_user(karg->reply_frame_buf_ptr, ioc->ctl_cmds.reply,
605 sz))
606 pr_err("failure at %s:%d/%s()!\n", __FILE__,
607 __LINE__, __func__);
608 return 1;
609 }
610
611 dctlprintk(ioc, pr_info(MPT3SAS_FMT
612 "%s: handle(0x%04x), lun(%d), task_mid(%d)\n", ioc->name,
613 desc, le16_to_cpu(tm_request->DevHandle), lun,
614 le16_to_cpu(tm_request->TaskMID)));
615 return 0;
616}
617
618/**
619 * _ctl_do_mpt_command - main handler for MPT3COMMAND opcode
620 * @ioc: per adapter object
621 * @karg - (struct mpt3_ioctl_command)
622 * @mf - pointer to mf in user space
623 */
624static long
625_ctl_do_mpt_command(struct MPT3SAS_ADAPTER *ioc, struct mpt3_ioctl_command karg,
626 void __user *mf)
627{
628 MPI2RequestHeader_t *mpi_request = NULL, *request;
629 MPI2DefaultReply_t *mpi_reply;
630 u32 ioc_state;
631 u16 ioc_status;
632 u16 smid;
633 unsigned long timeout, timeleft;
634 u8 issue_reset;
635 u32 sz;
636 void *psge;
637 void *data_out = NULL;
638 dma_addr_t data_out_dma = 0;
639 size_t data_out_sz = 0;
640 void *data_in = NULL;
641 dma_addr_t data_in_dma = 0;
642 size_t data_in_sz = 0;
643 long ret;
644 u16 wait_state_count;
645
646 issue_reset = 0;
647
648 if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) {
649 pr_err(MPT3SAS_FMT "%s: ctl_cmd in use\n",
650 ioc->name, __func__);
651 ret = -EAGAIN;
652 goto out;
653 }
654
655 wait_state_count = 0;
656 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
657 while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
658 if (wait_state_count++ == 10) {
659 pr_err(MPT3SAS_FMT
660 "%s: failed due to ioc not operational\n",
661 ioc->name, __func__);
662 ret = -EFAULT;
663 goto out;
664 }
665 ssleep(1);
666 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
667 pr_info(MPT3SAS_FMT
668 "%s: waiting for operational state(count=%d)\n",
669 ioc->name,
670 __func__, wait_state_count);
671 }
672 if (wait_state_count)
673 pr_info(MPT3SAS_FMT "%s: ioc is operational\n",
674 ioc->name, __func__);
675
676 mpi_request = kzalloc(ioc->request_sz, GFP_KERNEL);
677 if (!mpi_request) {
678 pr_err(MPT3SAS_FMT
679 "%s: failed obtaining a memory for mpi_request\n",
680 ioc->name, __func__);
681 ret = -ENOMEM;
682 goto out;
683 }
684
685 /* Check for overflow and wraparound */
686 if (karg.data_sge_offset * 4 > ioc->request_sz ||
687 karg.data_sge_offset > (UINT_MAX / 4)) {
688 ret = -EINVAL;
689 goto out;
690 }
691
692 /* copy in request message frame from user */
693 if (copy_from_user(mpi_request, mf, karg.data_sge_offset*4)) {
694 pr_err("failure at %s:%d/%s()!\n", __FILE__, __LINE__,
695 __func__);
696 ret = -EFAULT;
697 goto out;
698 }
699
700 if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) {
701 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->ctl_cb_idx);
702 if (!smid) {
703 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
704 ioc->name, __func__);
705 ret = -EAGAIN;
706 goto out;
707 }
708 } else {
709
710 smid = mpt3sas_base_get_smid_scsiio(ioc, ioc->ctl_cb_idx, NULL);
711 if (!smid) {
712 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
713 ioc->name, __func__);
714 ret = -EAGAIN;
715 goto out;
716 }
717 }
718
719 ret = 0;
720 ioc->ctl_cmds.status = MPT3_CMD_PENDING;
721 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
722 request = mpt3sas_base_get_msg_frame(ioc, smid);
723 memcpy(request, mpi_request, karg.data_sge_offset*4);
724 ioc->ctl_cmds.smid = smid;
725 data_out_sz = karg.data_out_size;
726 data_in_sz = karg.data_in_size;
727
728 if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
729 mpi_request->Function == MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) {
730 if (!le16_to_cpu(mpi_request->FunctionDependent1) ||
731 le16_to_cpu(mpi_request->FunctionDependent1) >
732 ioc->facts.MaxDevHandle) {
733 ret = -EINVAL;
734 mpt3sas_base_free_smid(ioc, smid);
735 goto out;
736 }
737 }
738
739 /* obtain dma-able memory for data transfer */
740 if (data_out_sz) /* WRITE */ {
741 data_out = pci_alloc_consistent(ioc->pdev, data_out_sz,
742 &data_out_dma);
743 if (!data_out) {
744 pr_err("failure at %s:%d/%s()!\n", __FILE__,
745 __LINE__, __func__);
746 ret = -ENOMEM;
747 mpt3sas_base_free_smid(ioc, smid);
748 goto out;
749 }
750 if (copy_from_user(data_out, karg.data_out_buf_ptr,
751 data_out_sz)) {
752 pr_err("failure at %s:%d/%s()!\n", __FILE__,
753 __LINE__, __func__);
754 ret = -EFAULT;
755 mpt3sas_base_free_smid(ioc, smid);
756 goto out;
757 }
758 }
759
760 if (data_in_sz) /* READ */ {
761 data_in = pci_alloc_consistent(ioc->pdev, data_in_sz,
762 &data_in_dma);
763 if (!data_in) {
764 pr_err("failure at %s:%d/%s()!\n", __FILE__,
765 __LINE__, __func__);
766 ret = -ENOMEM;
767 mpt3sas_base_free_smid(ioc, smid);
768 goto out;
769 }
770 }
771
772 psge = (void *)request + (karg.data_sge_offset*4);
773
774 /* send command to firmware */
775#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
776 _ctl_display_some_debug(ioc, smid, "ctl_request", NULL);
777#endif
778
779 init_completion(&ioc->ctl_cmds.done);
780 switch (mpi_request->Function) {
781 case MPI2_FUNCTION_SCSI_IO_REQUEST:
782 case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
783 {
784 Mpi2SCSIIORequest_t *scsiio_request =
785 (Mpi2SCSIIORequest_t *)request;
786 scsiio_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
787 scsiio_request->SenseBufferLowAddress =
788 mpt3sas_base_get_sense_buffer_dma(ioc, smid);
789 memset(ioc->ctl_cmds.sense, 0, SCSI_SENSE_BUFFERSIZE);
790 ioc->build_sg(ioc, psge, data_out_dma, data_out_sz,
791 data_in_dma, data_in_sz);
792
793 if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST)
794 mpt3sas_base_put_smid_scsi_io(ioc, smid,
795 le16_to_cpu(mpi_request->FunctionDependent1));
796 else
797 mpt3sas_base_put_smid_default(ioc, smid);
798 break;
799 }
800 case MPI2_FUNCTION_SCSI_TASK_MGMT:
801 {
802 Mpi2SCSITaskManagementRequest_t *tm_request =
803 (Mpi2SCSITaskManagementRequest_t *)request;
804
805 dtmprintk(ioc, pr_info(MPT3SAS_FMT
806 "TASK_MGMT: handle(0x%04x), task_type(0x%02x)\n",
807 ioc->name,
808 le16_to_cpu(tm_request->DevHandle), tm_request->TaskType));
809
810 if (tm_request->TaskType ==
811 MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK ||
812 tm_request->TaskType ==
813 MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK) {
814 if (_ctl_set_task_mid(ioc, &karg, tm_request)) {
815 mpt3sas_base_free_smid(ioc, smid);
816 goto out;
817 }
818 }
819
820 mpt3sas_scsih_set_tm_flag(ioc, le16_to_cpu(
821 tm_request->DevHandle));
822 ioc->build_sg_mpi(ioc, psge, data_out_dma, data_out_sz,
823 data_in_dma, data_in_sz);
824 mpt3sas_base_put_smid_hi_priority(ioc, smid);
825 break;
826 }
827 case MPI2_FUNCTION_SMP_PASSTHROUGH:
828 {
829 Mpi2SmpPassthroughRequest_t *smp_request =
830 (Mpi2SmpPassthroughRequest_t *)mpi_request;
831 u8 *data;
832
833 /* ioc determines which port to use */
834 smp_request->PhysicalPort = 0xFF;
835 if (smp_request->PassthroughFlags &
836 MPI2_SMP_PT_REQ_PT_FLAGS_IMMEDIATE)
837 data = (u8 *)&smp_request->SGL;
838 else {
839 if (unlikely(data_out == NULL)) {
840 pr_err("failure at %s:%d/%s()!\n",
841 __FILE__, __LINE__, __func__);
842 mpt3sas_base_free_smid(ioc, smid);
843 ret = -EINVAL;
844 goto out;
845 }
846 data = data_out;
847 }
848
849 if (data[1] == 0x91 && (data[10] == 1 || data[10] == 2)) {
850 ioc->ioc_link_reset_in_progress = 1;
851 ioc->ignore_loginfos = 1;
852 }
853 ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma,
854 data_in_sz);
855 mpt3sas_base_put_smid_default(ioc, smid);
856 break;
857 }
858 case MPI2_FUNCTION_SATA_PASSTHROUGH:
859 case MPI2_FUNCTION_FW_DOWNLOAD:
860 case MPI2_FUNCTION_FW_UPLOAD:
861 {
862 ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma,
863 data_in_sz);
864 mpt3sas_base_put_smid_default(ioc, smid);
865 break;
866 }
867 case MPI2_FUNCTION_TOOLBOX:
868 {
869 Mpi2ToolboxCleanRequest_t *toolbox_request =
870 (Mpi2ToolboxCleanRequest_t *)mpi_request;
871
872 if (toolbox_request->Tool == MPI2_TOOLBOX_DIAGNOSTIC_CLI_TOOL) {
873 ioc->build_sg(ioc, psge, data_out_dma, data_out_sz,
874 data_in_dma, data_in_sz);
875 } else {
876 ioc->build_sg_mpi(ioc, psge, data_out_dma, data_out_sz,
877 data_in_dma, data_in_sz);
878 }
879 mpt3sas_base_put_smid_default(ioc, smid);
880 break;
881 }
882 case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL:
883 {
884 Mpi2SasIoUnitControlRequest_t *sasiounit_request =
885 (Mpi2SasIoUnitControlRequest_t *)mpi_request;
886
887 if (sasiounit_request->Operation == MPI2_SAS_OP_PHY_HARD_RESET
888 || sasiounit_request->Operation ==
889 MPI2_SAS_OP_PHY_LINK_RESET) {
890 ioc->ioc_link_reset_in_progress = 1;
891 ioc->ignore_loginfos = 1;
892 }
893 /* drop to default case for posting the request */
894 }
895 default:
896 ioc->build_sg_mpi(ioc, psge, data_out_dma, data_out_sz,
897 data_in_dma, data_in_sz);
898 mpt3sas_base_put_smid_default(ioc, smid);
899 break;
900 }
901
902 if (karg.timeout < MPT3_IOCTL_DEFAULT_TIMEOUT)
903 timeout = MPT3_IOCTL_DEFAULT_TIMEOUT;
904 else
905 timeout = karg.timeout;
906 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
907 timeout*HZ);
908 if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) {
909 Mpi2SCSITaskManagementRequest_t *tm_request =
910 (Mpi2SCSITaskManagementRequest_t *)mpi_request;
911 mpt3sas_scsih_clear_tm_flag(ioc, le16_to_cpu(
912 tm_request->DevHandle));
913 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
914 } else if ((mpi_request->Function == MPI2_FUNCTION_SMP_PASSTHROUGH ||
915 mpi_request->Function == MPI2_FUNCTION_SAS_IO_UNIT_CONTROL) &&
916 ioc->ioc_link_reset_in_progress) {
917 ioc->ioc_link_reset_in_progress = 0;
918 ioc->ignore_loginfos = 0;
919 }
920 if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) {
921 pr_err(MPT3SAS_FMT "%s: timeout\n", ioc->name,
922 __func__);
923 _debug_dump_mf(mpi_request, karg.data_sge_offset);
924 if (!(ioc->ctl_cmds.status & MPT3_CMD_RESET))
925 issue_reset = 1;
926 goto issue_host_reset;
927 }
928
929 mpi_reply = ioc->ctl_cmds.reply;
930 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
931
932#ifdef CONFIG_SCSI_MPT3SAS_LOGGING
933 if (mpi_reply->Function == MPI2_FUNCTION_SCSI_TASK_MGMT &&
934 (ioc->logging_level & MPT_DEBUG_TM)) {
935 Mpi2SCSITaskManagementReply_t *tm_reply =
936 (Mpi2SCSITaskManagementReply_t *)mpi_reply;
937
938 pr_info(MPT3SAS_FMT "TASK_MGMT: " \
939 "IOCStatus(0x%04x), IOCLogInfo(0x%08x), "
940 "TerminationCount(0x%08x)\n", ioc->name,
941 le16_to_cpu(tm_reply->IOCStatus),
942 le32_to_cpu(tm_reply->IOCLogInfo),
943 le32_to_cpu(tm_reply->TerminationCount));
944 }
945#endif
946 /* copy out xdata to user */
947 if (data_in_sz) {
948 if (copy_to_user(karg.data_in_buf_ptr, data_in,
949 data_in_sz)) {
950 pr_err("failure at %s:%d/%s()!\n", __FILE__,
951 __LINE__, __func__);
952 ret = -ENODATA;
953 goto out;
954 }
955 }
956
957 /* copy out reply message frame to user */
958 if (karg.max_reply_bytes) {
959 sz = min_t(u32, karg.max_reply_bytes, ioc->reply_sz);
960 if (copy_to_user(karg.reply_frame_buf_ptr, ioc->ctl_cmds.reply,
961 sz)) {
962 pr_err("failure at %s:%d/%s()!\n", __FILE__,
963 __LINE__, __func__);
964 ret = -ENODATA;
965 goto out;
966 }
967 }
968
969 /* copy out sense to user */
970 if (karg.max_sense_bytes && (mpi_request->Function ==
971 MPI2_FUNCTION_SCSI_IO_REQUEST || mpi_request->Function ==
972 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
973 sz = min_t(u32, karg.max_sense_bytes, SCSI_SENSE_BUFFERSIZE);
974 if (copy_to_user(karg.sense_data_ptr, ioc->ctl_cmds.sense,
975 sz)) {
976 pr_err("failure at %s:%d/%s()!\n", __FILE__,
977 __LINE__, __func__);
978 ret = -ENODATA;
979 goto out;
980 }
981 }
982
983 issue_host_reset:
984 if (issue_reset) {
985 ret = -ENODATA;
986 if ((mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
987 mpi_request->Function ==
988 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH ||
989 mpi_request->Function == MPI2_FUNCTION_SATA_PASSTHROUGH)) {
990 pr_info(MPT3SAS_FMT "issue target reset: handle = (0x%04x)\n",
991 ioc->name,
992 le16_to_cpu(mpi_request->FunctionDependent1));
993 mpt3sas_halt_firmware(ioc);
994 mpt3sas_scsih_issue_tm(ioc,
995 le16_to_cpu(mpi_request->FunctionDependent1), 0, 0,
996 0, MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0, 30,
997 0, TM_MUTEX_ON);
998 } else
999 mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1000 FORCE_BIG_HAMMER);
1001 }
1002
1003 out:
1004
1005 /* free memory associated with sg buffers */
1006 if (data_in)
1007 pci_free_consistent(ioc->pdev, data_in_sz, data_in,
1008 data_in_dma);
1009
1010 if (data_out)
1011 pci_free_consistent(ioc->pdev, data_out_sz, data_out,
1012 data_out_dma);
1013
1014 kfree(mpi_request);
1015 ioc->ctl_cmds.status = MPT3_CMD_NOT_USED;
1016 return ret;
1017}
1018
1019/**
1020 * _ctl_getiocinfo - main handler for MPT3IOCINFO opcode
1021 * @ioc: per adapter object
1022 * @arg - user space buffer containing ioctl content
1023 */
1024static long
1025_ctl_getiocinfo(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1026{
1027 struct mpt3_ioctl_iocinfo karg;
1028
1029 if (copy_from_user(&karg, arg, sizeof(karg))) {
1030 pr_err("failure at %s:%d/%s()!\n",
1031 __FILE__, __LINE__, __func__);
1032 return -EFAULT;
1033 }
1034
1035 dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name,
1036 __func__));
1037
1038 memset(&karg, 0 , sizeof(karg));
1039 karg.adapter_type = MPT3_IOCTL_INTERFACE_SAS3;
1040 if (ioc->pfacts)
1041 karg.port_number = ioc->pfacts[0].PortNumber;
1042 karg.hw_rev = ioc->pdev->revision;
1043 karg.pci_id = ioc->pdev->device;
1044 karg.subsystem_device = ioc->pdev->subsystem_device;
1045 karg.subsystem_vendor = ioc->pdev->subsystem_vendor;
1046 karg.pci_information.u.bits.bus = ioc->pdev->bus->number;
1047 karg.pci_information.u.bits.device = PCI_SLOT(ioc->pdev->devfn);
1048 karg.pci_information.u.bits.function = PCI_FUNC(ioc->pdev->devfn);
1049 karg.pci_information.segment_id = pci_domain_nr(ioc->pdev->bus);
1050 karg.firmware_version = ioc->facts.FWVersion.Word;
1051 strcpy(karg.driver_version, MPT3SAS_DRIVER_NAME);
1052 strcat(karg.driver_version, "-");
1053 strcat(karg.driver_version, MPT3SAS_DRIVER_VERSION);
1054 karg.bios_version = le32_to_cpu(ioc->bios_pg3.BiosVersion);
1055
1056 if (copy_to_user(arg, &karg, sizeof(karg))) {
1057 pr_err("failure at %s:%d/%s()!\n",
1058 __FILE__, __LINE__, __func__);
1059 return -EFAULT;
1060 }
1061 return 0;
1062}
1063
1064/**
1065 * _ctl_eventquery - main handler for MPT3EVENTQUERY opcode
1066 * @ioc: per adapter object
1067 * @arg - user space buffer containing ioctl content
1068 */
1069static long
1070_ctl_eventquery(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1071{
1072 struct mpt3_ioctl_eventquery karg;
1073
1074 if (copy_from_user(&karg, arg, sizeof(karg))) {
1075 pr_err("failure at %s:%d/%s()!\n",
1076 __FILE__, __LINE__, __func__);
1077 return -EFAULT;
1078 }
1079
1080 dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name,
1081 __func__));
1082
1083 karg.event_entries = MPT3SAS_CTL_EVENT_LOG_SIZE;
1084 memcpy(karg.event_types, ioc->event_type,
1085 MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32));
1086
1087 if (copy_to_user(arg, &karg, sizeof(karg))) {
1088 pr_err("failure at %s:%d/%s()!\n",
1089 __FILE__, __LINE__, __func__);
1090 return -EFAULT;
1091 }
1092 return 0;
1093}
1094
1095/**
1096 * _ctl_eventenable - main handler for MPT3EVENTENABLE opcode
1097 * @ioc: per adapter object
1098 * @arg - user space buffer containing ioctl content
1099 */
1100static long
1101_ctl_eventenable(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1102{
1103 struct mpt3_ioctl_eventenable karg;
1104
1105 if (copy_from_user(&karg, arg, sizeof(karg))) {
1106 pr_err("failure at %s:%d/%s()!\n",
1107 __FILE__, __LINE__, __func__);
1108 return -EFAULT;
1109 }
1110
1111 dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name,
1112 __func__));
1113
1114 memcpy(ioc->event_type, karg.event_types,
1115 MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32));
1116 mpt3sas_base_validate_event_type(ioc, ioc->event_type);
1117
1118 if (ioc->event_log)
1119 return 0;
1120 /* initialize event_log */
1121 ioc->event_context = 0;
1122 ioc->aen_event_read_flag = 0;
1123 ioc->event_log = kcalloc(MPT3SAS_CTL_EVENT_LOG_SIZE,
1124 sizeof(struct MPT3_IOCTL_EVENTS), GFP_KERNEL);
1125 if (!ioc->event_log) {
1126 pr_err("failure at %s:%d/%s()!\n",
1127 __FILE__, __LINE__, __func__);
1128 return -ENOMEM;
1129 }
1130 return 0;
1131}
1132
1133/**
1134 * _ctl_eventreport - main handler for MPT3EVENTREPORT opcode
1135 * @ioc: per adapter object
1136 * @arg - user space buffer containing ioctl content
1137 */
1138static long
1139_ctl_eventreport(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1140{
1141 struct mpt3_ioctl_eventreport karg;
1142 u32 number_bytes, max_events, max;
1143 struct mpt3_ioctl_eventreport __user *uarg = arg;
1144
1145 if (copy_from_user(&karg, arg, sizeof(karg))) {
1146 pr_err("failure at %s:%d/%s()!\n",
1147 __FILE__, __LINE__, __func__);
1148 return -EFAULT;
1149 }
1150
1151 dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name,
1152 __func__));
1153
1154 number_bytes = karg.hdr.max_data_size -
1155 sizeof(struct mpt3_ioctl_header);
1156 max_events = number_bytes/sizeof(struct MPT3_IOCTL_EVENTS);
1157 max = min_t(u32, MPT3SAS_CTL_EVENT_LOG_SIZE, max_events);
1158
1159 /* If fewer than 1 event is requested, there must have
1160 * been some type of error.
1161 */
1162 if (!max || !ioc->event_log)
1163 return -ENODATA;
1164
1165 number_bytes = max * sizeof(struct MPT3_IOCTL_EVENTS);
1166 if (copy_to_user(uarg->event_data, ioc->event_log, number_bytes)) {
1167 pr_err("failure at %s:%d/%s()!\n",
1168 __FILE__, __LINE__, __func__);
1169 return -EFAULT;
1170 }
1171
1172 /* reset flag so SIGIO can restart */
1173 ioc->aen_event_read_flag = 0;
1174 return 0;
1175}
1176
1177/**
1178 * _ctl_do_reset - main handler for MPT3HARDRESET opcode
1179 * @ioc: per adapter object
1180 * @arg - user space buffer containing ioctl content
1181 */
1182static long
1183_ctl_do_reset(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1184{
1185 struct mpt3_ioctl_diag_reset karg;
1186 int retval;
1187
1188 if (copy_from_user(&karg, arg, sizeof(karg))) {
1189 pr_err("failure at %s:%d/%s()!\n",
1190 __FILE__, __LINE__, __func__);
1191 return -EFAULT;
1192 }
1193
1194 if (ioc->shost_recovery || ioc->pci_error_recovery ||
1195 ioc->is_driver_loading)
1196 return -EAGAIN;
1197
1198 dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name,
1199 __func__));
1200
1201 retval = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1202 FORCE_BIG_HAMMER);
1203 pr_info(MPT3SAS_FMT "host reset: %s\n",
1204 ioc->name, ((!retval) ? "SUCCESS" : "FAILED"));
1205 return 0;
1206}
1207
1208/**
1209 * _ctl_btdh_search_sas_device - searching for sas device
1210 * @ioc: per adapter object
1211 * @btdh: btdh ioctl payload
1212 */
1213static int
1214_ctl_btdh_search_sas_device(struct MPT3SAS_ADAPTER *ioc,
1215 struct mpt3_ioctl_btdh_mapping *btdh)
1216{
1217 struct _sas_device *sas_device;
1218 unsigned long flags;
1219 int rc = 0;
1220
1221 if (list_empty(&ioc->sas_device_list))
1222 return rc;
1223
1224 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1225 list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
1226 if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF &&
1227 btdh->handle == sas_device->handle) {
1228 btdh->bus = sas_device->channel;
1229 btdh->id = sas_device->id;
1230 rc = 1;
1231 goto out;
1232 } else if (btdh->bus == sas_device->channel && btdh->id ==
1233 sas_device->id && btdh->handle == 0xFFFF) {
1234 btdh->handle = sas_device->handle;
1235 rc = 1;
1236 goto out;
1237 }
1238 }
1239 out:
1240 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1241 return rc;
1242}
1243
1244/**
1245 * _ctl_btdh_search_raid_device - searching for raid device
1246 * @ioc: per adapter object
1247 * @btdh: btdh ioctl payload
1248 */
1249static int
1250_ctl_btdh_search_raid_device(struct MPT3SAS_ADAPTER *ioc,
1251 struct mpt3_ioctl_btdh_mapping *btdh)
1252{
1253 struct _raid_device *raid_device;
1254 unsigned long flags;
1255 int rc = 0;
1256
1257 if (list_empty(&ioc->raid_device_list))
1258 return rc;
1259
1260 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1261 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
1262 if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF &&
1263 btdh->handle == raid_device->handle) {
1264 btdh->bus = raid_device->channel;
1265 btdh->id = raid_device->id;
1266 rc = 1;
1267 goto out;
1268 } else if (btdh->bus == raid_device->channel && btdh->id ==
1269 raid_device->id && btdh->handle == 0xFFFF) {
1270 btdh->handle = raid_device->handle;
1271 rc = 1;
1272 goto out;
1273 }
1274 }
1275 out:
1276 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1277 return rc;
1278}
1279
1280/**
1281 * _ctl_btdh_mapping - main handler for MPT3BTDHMAPPING opcode
1282 * @ioc: per adapter object
1283 * @arg - user space buffer containing ioctl content
1284 */
1285static long
1286_ctl_btdh_mapping(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1287{
1288 struct mpt3_ioctl_btdh_mapping karg;
1289 int rc;
1290
1291 if (copy_from_user(&karg, arg, sizeof(karg))) {
1292 pr_err("failure at %s:%d/%s()!\n",
1293 __FILE__, __LINE__, __func__);
1294 return -EFAULT;
1295 }
1296
1297 dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,
1298 __func__));
1299
1300 rc = _ctl_btdh_search_sas_device(ioc, &karg);
1301 if (!rc)
1302 _ctl_btdh_search_raid_device(ioc, &karg);
1303
1304 if (copy_to_user(arg, &karg, sizeof(karg))) {
1305 pr_err("failure at %s:%d/%s()!\n",
1306 __FILE__, __LINE__, __func__);
1307 return -EFAULT;
1308 }
1309 return 0;
1310}
1311
1312/**
1313 * _ctl_diag_capability - return diag buffer capability
1314 * @ioc: per adapter object
1315 * @buffer_type: specifies either TRACE, SNAPSHOT, or EXTENDED
1316 *
1317 * returns 1 when diag buffer support is enabled in firmware
1318 */
1319static u8
1320_ctl_diag_capability(struct MPT3SAS_ADAPTER *ioc, u8 buffer_type)
1321{
1322 u8 rc = 0;
1323
1324 switch (buffer_type) {
1325 case MPI2_DIAG_BUF_TYPE_TRACE:
1326 if (ioc->facts.IOCCapabilities &
1327 MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER)
1328 rc = 1;
1329 break;
1330 case MPI2_DIAG_BUF_TYPE_SNAPSHOT:
1331 if (ioc->facts.IOCCapabilities &
1332 MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER)
1333 rc = 1;
1334 break;
1335 case MPI2_DIAG_BUF_TYPE_EXTENDED:
1336 if (ioc->facts.IOCCapabilities &
1337 MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER)
1338 rc = 1;
1339 }
1340
1341 return rc;
1342}
1343
1344
1345/**
1346 * _ctl_diag_register_2 - wrapper for registering diag buffer support
1347 * @ioc: per adapter object
1348 * @diag_register: the diag_register struct passed in from user space
1349 *
1350 */
1351static long
1352_ctl_diag_register_2(struct MPT3SAS_ADAPTER *ioc,
1353 struct mpt3_diag_register *diag_register)
1354{
1355 int rc, i;
1356 void *request_data = NULL;
1357 dma_addr_t request_data_dma;
1358 u32 request_data_sz = 0;
1359 Mpi2DiagBufferPostRequest_t *mpi_request;
1360 Mpi2DiagBufferPostReply_t *mpi_reply;
1361 u8 buffer_type;
1362 unsigned long timeleft;
1363 u16 smid;
1364 u16 ioc_status;
1365 u32 ioc_state;
1366 u8 issue_reset = 0;
1367
1368 dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,
1369 __func__));
1370
1371 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
1372 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
1373 pr_err(MPT3SAS_FMT
1374 "%s: failed due to ioc not operational\n",
1375 ioc->name, __func__);
1376 rc = -EAGAIN;
1377 goto out;
1378 }
1379
1380 if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) {
1381 pr_err(MPT3SAS_FMT "%s: ctl_cmd in use\n",
1382 ioc->name, __func__);
1383 rc = -EAGAIN;
1384 goto out;
1385 }
1386
1387 buffer_type = diag_register->buffer_type;
1388 if (!_ctl_diag_capability(ioc, buffer_type)) {
1389 pr_err(MPT3SAS_FMT
1390 "%s: doesn't have capability for buffer_type(0x%02x)\n",
1391 ioc->name, __func__, buffer_type);
1392 return -EPERM;
1393 }
1394
1395 if (ioc->diag_buffer_status[buffer_type] &
1396 MPT3_DIAG_BUFFER_IS_REGISTERED) {
1397 pr_err(MPT3SAS_FMT
1398 "%s: already has a registered buffer for buffer_type(0x%02x)\n",
1399 ioc->name, __func__,
1400 buffer_type);
1401 return -EINVAL;
1402 }
1403
1404 if (diag_register->requested_buffer_size % 4) {
1405 pr_err(MPT3SAS_FMT
1406 "%s: the requested_buffer_size is not 4 byte aligned\n",
1407 ioc->name, __func__);
1408 return -EINVAL;
1409 }
1410
1411 smid = mpt3sas_base_get_smid(ioc, ioc->ctl_cb_idx);
1412 if (!smid) {
1413 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
1414 ioc->name, __func__);
1415 rc = -EAGAIN;
1416 goto out;
1417 }
1418
1419 rc = 0;
1420 ioc->ctl_cmds.status = MPT3_CMD_PENDING;
1421 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
1422 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
1423 ioc->ctl_cmds.smid = smid;
1424
1425 request_data = ioc->diag_buffer[buffer_type];
1426 request_data_sz = diag_register->requested_buffer_size;
1427 ioc->unique_id[buffer_type] = diag_register->unique_id;
1428 ioc->diag_buffer_status[buffer_type] = 0;
1429 memcpy(ioc->product_specific[buffer_type],
1430 diag_register->product_specific, MPT3_PRODUCT_SPECIFIC_DWORDS);
1431 ioc->diagnostic_flags[buffer_type] = diag_register->diagnostic_flags;
1432
1433 if (request_data) {
1434 request_data_dma = ioc->diag_buffer_dma[buffer_type];
1435 if (request_data_sz != ioc->diag_buffer_sz[buffer_type]) {
1436 pci_free_consistent(ioc->pdev,
1437 ioc->diag_buffer_sz[buffer_type],
1438 request_data, request_data_dma);
1439 request_data = NULL;
1440 }
1441 }
1442
1443 if (request_data == NULL) {
1444 ioc->diag_buffer_sz[buffer_type] = 0;
1445 ioc->diag_buffer_dma[buffer_type] = 0;
1446 request_data = pci_alloc_consistent(
1447 ioc->pdev, request_data_sz, &request_data_dma);
1448 if (request_data == NULL) {
1449 pr_err(MPT3SAS_FMT "%s: failed allocating memory" \
1450 " for diag buffers, requested size(%d)\n",
1451 ioc->name, __func__, request_data_sz);
1452 mpt3sas_base_free_smid(ioc, smid);
1453 return -ENOMEM;
1454 }
1455 ioc->diag_buffer[buffer_type] = request_data;
1456 ioc->diag_buffer_sz[buffer_type] = request_data_sz;
1457 ioc->diag_buffer_dma[buffer_type] = request_data_dma;
1458 }
1459
1460 mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST;
1461 mpi_request->BufferType = diag_register->buffer_type;
1462 mpi_request->Flags = cpu_to_le32(diag_register->diagnostic_flags);
1463 mpi_request->BufferAddress = cpu_to_le64(request_data_dma);
1464 mpi_request->BufferLength = cpu_to_le32(request_data_sz);
1465 mpi_request->VF_ID = 0; /* TODO */
1466 mpi_request->VP_ID = 0;
1467
1468 dctlprintk(ioc, pr_info(MPT3SAS_FMT
1469 "%s: diag_buffer(0x%p), dma(0x%llx), sz(%d)\n",
1470 ioc->name, __func__, request_data,
1471 (unsigned long long)request_data_dma,
1472 le32_to_cpu(mpi_request->BufferLength)));
1473
1474 for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++)
1475 mpi_request->ProductSpecific[i] =
1476 cpu_to_le32(ioc->product_specific[buffer_type][i]);
1477
1478 init_completion(&ioc->ctl_cmds.done);
1479 mpt3sas_base_put_smid_default(ioc, smid);
1480 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
1481 MPT3_IOCTL_DEFAULT_TIMEOUT*HZ);
1482
1483 if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) {
1484 pr_err(MPT3SAS_FMT "%s: timeout\n", ioc->name,
1485 __func__);
1486 _debug_dump_mf(mpi_request,
1487 sizeof(Mpi2DiagBufferPostRequest_t)/4);
1488 if (!(ioc->ctl_cmds.status & MPT3_CMD_RESET))
1489 issue_reset = 1;
1490 goto issue_host_reset;
1491 }
1492
1493 /* process the completed Reply Message Frame */
1494 if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) {
1495 pr_err(MPT3SAS_FMT "%s: no reply message\n",
1496 ioc->name, __func__);
1497 rc = -EFAULT;
1498 goto out;
1499 }
1500
1501 mpi_reply = ioc->ctl_cmds.reply;
1502 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1503
1504 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
1505 ioc->diag_buffer_status[buffer_type] |=
1506 MPT3_DIAG_BUFFER_IS_REGISTERED;
1507 dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: success\n",
1508 ioc->name, __func__));
1509 } else {
1510 pr_info(MPT3SAS_FMT
1511 "%s: ioc_status(0x%04x) log_info(0x%08x)\n",
1512 ioc->name, __func__,
1513 ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
1514 rc = -EFAULT;
1515 }
1516
1517 issue_host_reset:
1518 if (issue_reset)
1519 mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1520 FORCE_BIG_HAMMER);
1521
1522 out:
1523
1524 if (rc && request_data)
1525 pci_free_consistent(ioc->pdev, request_data_sz,
1526 request_data, request_data_dma);
1527
1528 ioc->ctl_cmds.status = MPT3_CMD_NOT_USED;
1529 return rc;
1530}
1531
1532/**
1533 * mpt3sas_enable_diag_buffer - enabling diag_buffers support driver load time
1534 * @ioc: per adapter object
1535 * @bits_to_register: bitwise field where trace is bit 0, and snapshot is bit 1
1536 *
1537 * This is called when command line option diag_buffer_enable is enabled
1538 * at driver load time.
1539 */
1540void
1541mpt3sas_enable_diag_buffer(struct MPT3SAS_ADAPTER *ioc, u8 bits_to_register)
1542{
1543 struct mpt3_diag_register diag_register;
1544
1545 memset(&diag_register, 0, sizeof(struct mpt3_diag_register));
1546
1547 if (bits_to_register & 1) {
1548 pr_info(MPT3SAS_FMT "registering trace buffer support\n",
1549 ioc->name);
1550 ioc->diag_trigger_master.MasterData =
1551 (MASTER_TRIGGER_FW_FAULT + MASTER_TRIGGER_ADAPTER_RESET);
1552 diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE;
1553 /* register for 2MB buffers */
1554 diag_register.requested_buffer_size = 2 * (1024 * 1024);
1555 diag_register.unique_id = 0x7075900;
1556 _ctl_diag_register_2(ioc, &diag_register);
1557 }
1558
1559 if (bits_to_register & 2) {
1560 pr_info(MPT3SAS_FMT "registering snapshot buffer support\n",
1561 ioc->name);
1562 diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_SNAPSHOT;
1563 /* register for 2MB buffers */
1564 diag_register.requested_buffer_size = 2 * (1024 * 1024);
1565 diag_register.unique_id = 0x7075901;
1566 _ctl_diag_register_2(ioc, &diag_register);
1567 }
1568
1569 if (bits_to_register & 4) {
1570 pr_info(MPT3SAS_FMT "registering extended buffer support\n",
1571 ioc->name);
1572 diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_EXTENDED;
1573 /* register for 2MB buffers */
1574 diag_register.requested_buffer_size = 2 * (1024 * 1024);
1575 diag_register.unique_id = 0x7075901;
1576 _ctl_diag_register_2(ioc, &diag_register);
1577 }
1578}
1579
1580/**
1581 * _ctl_diag_register - application register with driver
1582 * @ioc: per adapter object
1583 * @arg - user space buffer containing ioctl content
1584 *
1585 * This will allow the driver to setup any required buffers that will be
1586 * needed by firmware to communicate with the driver.
1587 */
1588static long
1589_ctl_diag_register(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1590{
1591 struct mpt3_diag_register karg;
1592 long rc;
1593
1594 if (copy_from_user(&karg, arg, sizeof(karg))) {
1595 pr_err("failure at %s:%d/%s()!\n",
1596 __FILE__, __LINE__, __func__);
1597 return -EFAULT;
1598 }
1599
1600 rc = _ctl_diag_register_2(ioc, &karg);
1601 return rc;
1602}
1603
1604/**
1605 * _ctl_diag_unregister - application unregister with driver
1606 * @ioc: per adapter object
1607 * @arg - user space buffer containing ioctl content
1608 *
1609 * This will allow the driver to cleanup any memory allocated for diag
1610 * messages and to free up any resources.
1611 */
1612static long
1613_ctl_diag_unregister(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1614{
1615 struct mpt3_diag_unregister karg;
1616 void *request_data;
1617 dma_addr_t request_data_dma;
1618 u32 request_data_sz;
1619 u8 buffer_type;
1620
1621 if (copy_from_user(&karg, arg, sizeof(karg))) {
1622 pr_err("failure at %s:%d/%s()!\n",
1623 __FILE__, __LINE__, __func__);
1624 return -EFAULT;
1625 }
1626
1627 dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,
1628 __func__));
1629
1630 buffer_type = karg.unique_id & 0x000000ff;
1631 if (!_ctl_diag_capability(ioc, buffer_type)) {
1632 pr_err(MPT3SAS_FMT
1633 "%s: doesn't have capability for buffer_type(0x%02x)\n",
1634 ioc->name, __func__, buffer_type);
1635 return -EPERM;
1636 }
1637
1638 if ((ioc->diag_buffer_status[buffer_type] &
1639 MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
1640 pr_err(MPT3SAS_FMT
1641 "%s: buffer_type(0x%02x) is not registered\n",
1642 ioc->name, __func__, buffer_type);
1643 return -EINVAL;
1644 }
1645 if ((ioc->diag_buffer_status[buffer_type] &
1646 MPT3_DIAG_BUFFER_IS_RELEASED) == 0) {
1647 pr_err(MPT3SAS_FMT
1648 "%s: buffer_type(0x%02x) has not been released\n",
1649 ioc->name, __func__, buffer_type);
1650 return -EINVAL;
1651 }
1652
1653 if (karg.unique_id != ioc->unique_id[buffer_type]) {
1654 pr_err(MPT3SAS_FMT
1655 "%s: unique_id(0x%08x) is not registered\n",
1656 ioc->name, __func__, karg.unique_id);
1657 return -EINVAL;
1658 }
1659
1660 request_data = ioc->diag_buffer[buffer_type];
1661 if (!request_data) {
1662 pr_err(MPT3SAS_FMT
1663 "%s: doesn't have memory allocated for buffer_type(0x%02x)\n",
1664 ioc->name, __func__, buffer_type);
1665 return -ENOMEM;
1666 }
1667
1668 request_data_sz = ioc->diag_buffer_sz[buffer_type];
1669 request_data_dma = ioc->diag_buffer_dma[buffer_type];
1670 pci_free_consistent(ioc->pdev, request_data_sz,
1671 request_data, request_data_dma);
1672 ioc->diag_buffer[buffer_type] = NULL;
1673 ioc->diag_buffer_status[buffer_type] = 0;
1674 return 0;
1675}
1676
1677/**
1678 * _ctl_diag_query - query relevant info associated with diag buffers
1679 * @ioc: per adapter object
1680 * @arg - user space buffer containing ioctl content
1681 *
1682 * The application will send only buffer_type and unique_id. Driver will
1683 * inspect unique_id first, if valid, fill in all the info. If unique_id is
1684 * 0x00, the driver will return info specified by Buffer Type.
1685 */
1686static long
1687_ctl_diag_query(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1688{
1689 struct mpt3_diag_query karg;
1690 void *request_data;
1691 int i;
1692 u8 buffer_type;
1693
1694 if (copy_from_user(&karg, arg, sizeof(karg))) {
1695 pr_err("failure at %s:%d/%s()!\n",
1696 __FILE__, __LINE__, __func__);
1697 return -EFAULT;
1698 }
1699
1700 dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,
1701 __func__));
1702
1703 karg.application_flags = 0;
1704 buffer_type = karg.buffer_type;
1705
1706 if (!_ctl_diag_capability(ioc, buffer_type)) {
1707 pr_err(MPT3SAS_FMT
1708 "%s: doesn't have capability for buffer_type(0x%02x)\n",
1709 ioc->name, __func__, buffer_type);
1710 return -EPERM;
1711 }
1712
1713 if ((ioc->diag_buffer_status[buffer_type] &
1714 MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
1715 pr_err(MPT3SAS_FMT
1716 "%s: buffer_type(0x%02x) is not registered\n",
1717 ioc->name, __func__, buffer_type);
1718 return -EINVAL;
1719 }
1720
1721 if (karg.unique_id & 0xffffff00) {
1722 if (karg.unique_id != ioc->unique_id[buffer_type]) {
1723 pr_err(MPT3SAS_FMT
1724 "%s: unique_id(0x%08x) is not registered\n",
1725 ioc->name, __func__, karg.unique_id);
1726 return -EINVAL;
1727 }
1728 }
1729
1730 request_data = ioc->diag_buffer[buffer_type];
1731 if (!request_data) {
1732 pr_err(MPT3SAS_FMT
1733 "%s: doesn't have buffer for buffer_type(0x%02x)\n",
1734 ioc->name, __func__, buffer_type);
1735 return -ENOMEM;
1736 }
1737
1738 if (ioc->diag_buffer_status[buffer_type] & MPT3_DIAG_BUFFER_IS_RELEASED)
1739 karg.application_flags = (MPT3_APP_FLAGS_APP_OWNED |
1740 MPT3_APP_FLAGS_BUFFER_VALID);
1741 else
1742 karg.application_flags = (MPT3_APP_FLAGS_APP_OWNED |
1743 MPT3_APP_FLAGS_BUFFER_VALID |
1744 MPT3_APP_FLAGS_FW_BUFFER_ACCESS);
1745
1746 for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++)
1747 karg.product_specific[i] =
1748 ioc->product_specific[buffer_type][i];
1749
1750 karg.total_buffer_size = ioc->diag_buffer_sz[buffer_type];
1751 karg.driver_added_buffer_size = 0;
1752 karg.unique_id = ioc->unique_id[buffer_type];
1753 karg.diagnostic_flags = ioc->diagnostic_flags[buffer_type];
1754
1755 if (copy_to_user(arg, &karg, sizeof(struct mpt3_diag_query))) {
1756 pr_err(MPT3SAS_FMT
1757 "%s: unable to write mpt3_diag_query data @ %p\n",
1758 ioc->name, __func__, arg);
1759 return -EFAULT;
1760 }
1761 return 0;
1762}
1763
1764/**
1765 * mpt3sas_send_diag_release - Diag Release Message
1766 * @ioc: per adapter object
1767 * @buffer_type - specifies either TRACE, SNAPSHOT, or EXTENDED
1768 * @issue_reset - specifies whether host reset is required.
1769 *
1770 */
1771int
1772mpt3sas_send_diag_release(struct MPT3SAS_ADAPTER *ioc, u8 buffer_type,
1773 u8 *issue_reset)
1774{
1775 Mpi2DiagReleaseRequest_t *mpi_request;
1776 Mpi2DiagReleaseReply_t *mpi_reply;
1777 u16 smid;
1778 u16 ioc_status;
1779 u32 ioc_state;
1780 int rc;
1781 unsigned long timeleft;
1782
1783 dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,
1784 __func__));
1785
1786 rc = 0;
1787 *issue_reset = 0;
1788
1789 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
1790 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
1791 if (ioc->diag_buffer_status[buffer_type] &
1792 MPT3_DIAG_BUFFER_IS_REGISTERED)
1793 ioc->diag_buffer_status[buffer_type] |=
1794 MPT3_DIAG_BUFFER_IS_RELEASED;
1795 dctlprintk(ioc, pr_info(MPT3SAS_FMT
1796 "%s: skipping due to FAULT state\n", ioc->name,
1797 __func__));
1798 rc = -EAGAIN;
1799 goto out;
1800 }
1801
1802 if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) {
1803 pr_err(MPT3SAS_FMT "%s: ctl_cmd in use\n",
1804 ioc->name, __func__);
1805 rc = -EAGAIN;
1806 goto out;
1807 }
1808
1809 smid = mpt3sas_base_get_smid(ioc, ioc->ctl_cb_idx);
1810 if (!smid) {
1811 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
1812 ioc->name, __func__);
1813 rc = -EAGAIN;
1814 goto out;
1815 }
1816
1817 ioc->ctl_cmds.status = MPT3_CMD_PENDING;
1818 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
1819 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
1820 ioc->ctl_cmds.smid = smid;
1821
1822 mpi_request->Function = MPI2_FUNCTION_DIAG_RELEASE;
1823 mpi_request->BufferType = buffer_type;
1824 mpi_request->VF_ID = 0; /* TODO */
1825 mpi_request->VP_ID = 0;
1826
1827 init_completion(&ioc->ctl_cmds.done);
1828 mpt3sas_base_put_smid_default(ioc, smid);
1829 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
1830 MPT3_IOCTL_DEFAULT_TIMEOUT*HZ);
1831
1832 if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) {
1833 pr_err(MPT3SAS_FMT "%s: timeout\n", ioc->name,
1834 __func__);
1835 _debug_dump_mf(mpi_request,
1836 sizeof(Mpi2DiagReleaseRequest_t)/4);
1837 if (!(ioc->ctl_cmds.status & MPT3_CMD_RESET))
1838 *issue_reset = 1;
1839 rc = -EFAULT;
1840 goto out;
1841 }
1842
1843 /* process the completed Reply Message Frame */
1844 if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) {
1845 pr_err(MPT3SAS_FMT "%s: no reply message\n",
1846 ioc->name, __func__);
1847 rc = -EFAULT;
1848 goto out;
1849 }
1850
1851 mpi_reply = ioc->ctl_cmds.reply;
1852 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1853
1854 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
1855 ioc->diag_buffer_status[buffer_type] |=
1856 MPT3_DIAG_BUFFER_IS_RELEASED;
1857 dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: success\n",
1858 ioc->name, __func__));
1859 } else {
1860 pr_info(MPT3SAS_FMT
1861 "%s: ioc_status(0x%04x) log_info(0x%08x)\n",
1862 ioc->name, __func__,
1863 ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
1864 rc = -EFAULT;
1865 }
1866
1867 out:
1868 ioc->ctl_cmds.status = MPT3_CMD_NOT_USED;
1869 return rc;
1870}
1871
1872/**
1873 * _ctl_diag_release - request to send Diag Release Message to firmware
1874 * @arg - user space buffer containing ioctl content
1875 *
1876 * This allows ownership of the specified buffer to returned to the driver,
1877 * allowing an application to read the buffer without fear that firmware is
1878 * overwritting information in the buffer.
1879 */
1880static long
1881_ctl_diag_release(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1882{
1883 struct mpt3_diag_release karg;
1884 void *request_data;
1885 int rc;
1886 u8 buffer_type;
1887 u8 issue_reset = 0;
1888
1889 if (copy_from_user(&karg, arg, sizeof(karg))) {
1890 pr_err("failure at %s:%d/%s()!\n",
1891 __FILE__, __LINE__, __func__);
1892 return -EFAULT;
1893 }
1894
1895 dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,
1896 __func__));
1897
1898 buffer_type = karg.unique_id & 0x000000ff;
1899 if (!_ctl_diag_capability(ioc, buffer_type)) {
1900 pr_err(MPT3SAS_FMT
1901 "%s: doesn't have capability for buffer_type(0x%02x)\n",
1902 ioc->name, __func__, buffer_type);
1903 return -EPERM;
1904 }
1905
1906 if ((ioc->diag_buffer_status[buffer_type] &
1907 MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
1908 pr_err(MPT3SAS_FMT
1909 "%s: buffer_type(0x%02x) is not registered\n",
1910 ioc->name, __func__, buffer_type);
1911 return -EINVAL;
1912 }
1913
1914 if (karg.unique_id != ioc->unique_id[buffer_type]) {
1915 pr_err(MPT3SAS_FMT
1916 "%s: unique_id(0x%08x) is not registered\n",
1917 ioc->name, __func__, karg.unique_id);
1918 return -EINVAL;
1919 }
1920
1921 if (ioc->diag_buffer_status[buffer_type] &
1922 MPT3_DIAG_BUFFER_IS_RELEASED) {
1923 pr_err(MPT3SAS_FMT
1924 "%s: buffer_type(0x%02x) is already released\n",
1925 ioc->name, __func__,
1926 buffer_type);
1927 return 0;
1928 }
1929
1930 request_data = ioc->diag_buffer[buffer_type];
1931
1932 if (!request_data) {
1933 pr_err(MPT3SAS_FMT
1934 "%s: doesn't have memory allocated for buffer_type(0x%02x)\n",
1935 ioc->name, __func__, buffer_type);
1936 return -ENOMEM;
1937 }
1938
1939 /* buffers were released by due to host reset */
1940 if ((ioc->diag_buffer_status[buffer_type] &
1941 MPT3_DIAG_BUFFER_IS_DIAG_RESET)) {
1942 ioc->diag_buffer_status[buffer_type] |=
1943 MPT3_DIAG_BUFFER_IS_RELEASED;
1944 ioc->diag_buffer_status[buffer_type] &=
1945 ~MPT3_DIAG_BUFFER_IS_DIAG_RESET;
1946 pr_err(MPT3SAS_FMT
1947 "%s: buffer_type(0x%02x) was released due to host reset\n",
1948 ioc->name, __func__, buffer_type);
1949 return 0;
1950 }
1951
1952 rc = mpt3sas_send_diag_release(ioc, buffer_type, &issue_reset);
1953
1954 if (issue_reset)
1955 mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1956 FORCE_BIG_HAMMER);
1957
1958 return rc;
1959}
1960
1961/**
1962 * _ctl_diag_read_buffer - request for copy of the diag buffer
1963 * @ioc: per adapter object
1964 * @arg - user space buffer containing ioctl content
1965 */
1966static long
1967_ctl_diag_read_buffer(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
1968{
1969 struct mpt3_diag_read_buffer karg;
1970 struct mpt3_diag_read_buffer __user *uarg = arg;
1971 void *request_data, *diag_data;
1972 Mpi2DiagBufferPostRequest_t *mpi_request;
1973 Mpi2DiagBufferPostReply_t *mpi_reply;
1974 int rc, i;
1975 u8 buffer_type;
1976 unsigned long timeleft, request_size, copy_size;
1977 u16 smid;
1978 u16 ioc_status;
1979 u8 issue_reset = 0;
1980
1981 if (copy_from_user(&karg, arg, sizeof(karg))) {
1982 pr_err("failure at %s:%d/%s()!\n",
1983 __FILE__, __LINE__, __func__);
1984 return -EFAULT;
1985 }
1986
1987 dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,
1988 __func__));
1989
1990 buffer_type = karg.unique_id & 0x000000ff;
1991 if (!_ctl_diag_capability(ioc, buffer_type)) {
1992 pr_err(MPT3SAS_FMT
1993 "%s: doesn't have capability for buffer_type(0x%02x)\n",
1994 ioc->name, __func__, buffer_type);
1995 return -EPERM;
1996 }
1997
1998 if (karg.unique_id != ioc->unique_id[buffer_type]) {
1999 pr_err(MPT3SAS_FMT
2000 "%s: unique_id(0x%08x) is not registered\n",
2001 ioc->name, __func__, karg.unique_id);
2002 return -EINVAL;
2003 }
2004
2005 request_data = ioc->diag_buffer[buffer_type];
2006 if (!request_data) {
2007 pr_err(MPT3SAS_FMT
2008 "%s: doesn't have buffer for buffer_type(0x%02x)\n",
2009 ioc->name, __func__, buffer_type);
2010 return -ENOMEM;
2011 }
2012
2013 request_size = ioc->diag_buffer_sz[buffer_type];
2014
2015 if ((karg.starting_offset % 4) || (karg.bytes_to_read % 4)) {
2016 pr_err(MPT3SAS_FMT "%s: either the starting_offset " \
2017 "or bytes_to_read are not 4 byte aligned\n", ioc->name,
2018 __func__);
2019 return -EINVAL;
2020 }
2021
2022 if (karg.starting_offset > request_size)
2023 return -EINVAL;
2024
2025 diag_data = (void *)(request_data + karg.starting_offset);
2026 dctlprintk(ioc, pr_info(MPT3SAS_FMT
2027 "%s: diag_buffer(%p), offset(%d), sz(%d)\n",
2028 ioc->name, __func__,
2029 diag_data, karg.starting_offset, karg.bytes_to_read));
2030
2031 /* Truncate data on requests that are too large */
2032 if ((diag_data + karg.bytes_to_read < diag_data) ||
2033 (diag_data + karg.bytes_to_read > request_data + request_size))
2034 copy_size = request_size - karg.starting_offset;
2035 else
2036 copy_size = karg.bytes_to_read;
2037
2038 if (copy_to_user((void __user *)uarg->diagnostic_data,
2039 diag_data, copy_size)) {
2040 pr_err(MPT3SAS_FMT
2041 "%s: Unable to write mpt_diag_read_buffer_t data @ %p\n",
2042 ioc->name, __func__, diag_data);
2043 return -EFAULT;
2044 }
2045
2046 if ((karg.flags & MPT3_FLAGS_REREGISTER) == 0)
2047 return 0;
2048
2049 dctlprintk(ioc, pr_info(MPT3SAS_FMT
2050 "%s: Reregister buffer_type(0x%02x)\n",
2051 ioc->name, __func__, buffer_type));
2052 if ((ioc->diag_buffer_status[buffer_type] &
2053 MPT3_DIAG_BUFFER_IS_RELEASED) == 0) {
2054 dctlprintk(ioc, pr_info(MPT3SAS_FMT
2055 "%s: buffer_type(0x%02x) is still registered\n",
2056 ioc->name, __func__, buffer_type));
2057 return 0;
2058 }
2059 /* Get a free request frame and save the message context.
2060 */
2061
2062 if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) {
2063 pr_err(MPT3SAS_FMT "%s: ctl_cmd in use\n",
2064 ioc->name, __func__);
2065 rc = -EAGAIN;
2066 goto out;
2067 }
2068
2069 smid = mpt3sas_base_get_smid(ioc, ioc->ctl_cb_idx);
2070 if (!smid) {
2071 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
2072 ioc->name, __func__);
2073 rc = -EAGAIN;
2074 goto out;
2075 }
2076
2077 rc = 0;
2078 ioc->ctl_cmds.status = MPT3_CMD_PENDING;
2079 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
2080 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
2081 ioc->ctl_cmds.smid = smid;
2082
2083 mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST;
2084 mpi_request->BufferType = buffer_type;
2085 mpi_request->BufferLength =
2086 cpu_to_le32(ioc->diag_buffer_sz[buffer_type]);
2087 mpi_request->BufferAddress =
2088 cpu_to_le64(ioc->diag_buffer_dma[buffer_type]);
2089 for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++)
2090 mpi_request->ProductSpecific[i] =
2091 cpu_to_le32(ioc->product_specific[buffer_type][i]);
2092 mpi_request->VF_ID = 0; /* TODO */
2093 mpi_request->VP_ID = 0;
2094
2095 init_completion(&ioc->ctl_cmds.done);
2096 mpt3sas_base_put_smid_default(ioc, smid);
2097 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
2098 MPT3_IOCTL_DEFAULT_TIMEOUT*HZ);
2099
2100 if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) {
2101 pr_err(MPT3SAS_FMT "%s: timeout\n", ioc->name,
2102 __func__);
2103 _debug_dump_mf(mpi_request,
2104 sizeof(Mpi2DiagBufferPostRequest_t)/4);
2105 if (!(ioc->ctl_cmds.status & MPT3_CMD_RESET))
2106 issue_reset = 1;
2107 goto issue_host_reset;
2108 }
2109
2110 /* process the completed Reply Message Frame */
2111 if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) {
2112 pr_err(MPT3SAS_FMT "%s: no reply message\n",
2113 ioc->name, __func__);
2114 rc = -EFAULT;
2115 goto out;
2116 }
2117
2118 mpi_reply = ioc->ctl_cmds.reply;
2119 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
2120
2121 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
2122 ioc->diag_buffer_status[buffer_type] |=
2123 MPT3_DIAG_BUFFER_IS_REGISTERED;
2124 dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: success\n",
2125 ioc->name, __func__));
2126 } else {
2127 pr_info(MPT3SAS_FMT
2128 "%s: ioc_status(0x%04x) log_info(0x%08x)\n",
2129 ioc->name, __func__,
2130 ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
2131 rc = -EFAULT;
2132 }
2133
2134 issue_host_reset:
2135 if (issue_reset)
2136 mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2137 FORCE_BIG_HAMMER);
2138
2139 out:
2140
2141 ioc->ctl_cmds.status = MPT3_CMD_NOT_USED;
2142 return rc;
2143}
2144
2145
2146
2147#ifdef CONFIG_COMPAT
2148/**
2149 * _ctl_compat_mpt_command - convert 32bit pointers to 64bit.
2150 * @ioc: per adapter object
2151 * @cmd - ioctl opcode
2152 * @arg - (struct mpt3_ioctl_command32)
2153 *
2154 * MPT3COMMAND32 - Handle 32bit applications running on 64bit os.
2155 */
2156static long
2157_ctl_compat_mpt_command(struct MPT3SAS_ADAPTER *ioc, unsigned cmd,
2158 void __user *arg)
2159{
2160 struct mpt3_ioctl_command32 karg32;
2161 struct mpt3_ioctl_command32 __user *uarg;
2162 struct mpt3_ioctl_command karg;
2163
2164 if (_IOC_SIZE(cmd) != sizeof(struct mpt3_ioctl_command32))
2165 return -EINVAL;
2166
2167 uarg = (struct mpt3_ioctl_command32 __user *) arg;
2168
2169 if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32))) {
2170 pr_err("failure at %s:%d/%s()!\n",
2171 __FILE__, __LINE__, __func__);
2172 return -EFAULT;
2173 }
2174
2175 memset(&karg, 0, sizeof(struct mpt3_ioctl_command));
2176 karg.hdr.ioc_number = karg32.hdr.ioc_number;
2177 karg.hdr.port_number = karg32.hdr.port_number;
2178 karg.hdr.max_data_size = karg32.hdr.max_data_size;
2179 karg.timeout = karg32.timeout;
2180 karg.max_reply_bytes = karg32.max_reply_bytes;
2181 karg.data_in_size = karg32.data_in_size;
2182 karg.data_out_size = karg32.data_out_size;
2183 karg.max_sense_bytes = karg32.max_sense_bytes;
2184 karg.data_sge_offset = karg32.data_sge_offset;
2185 karg.reply_frame_buf_ptr = compat_ptr(karg32.reply_frame_buf_ptr);
2186 karg.data_in_buf_ptr = compat_ptr(karg32.data_in_buf_ptr);
2187 karg.data_out_buf_ptr = compat_ptr(karg32.data_out_buf_ptr);
2188 karg.sense_data_ptr = compat_ptr(karg32.sense_data_ptr);
2189 return _ctl_do_mpt_command(ioc, karg, &uarg->mf);
2190}
2191#endif
2192
2193/**
2194 * _ctl_ioctl_main - main ioctl entry point
2195 * @file - (struct file)
2196 * @cmd - ioctl opcode
2197 * @arg -
2198 * compat - handles 32 bit applications in 64bit os
2199 */
2200static long
2201_ctl_ioctl_main(struct file *file, unsigned int cmd, void __user *arg,
2202 u8 compat)
2203{
2204 struct MPT3SAS_ADAPTER *ioc;
2205 struct mpt3_ioctl_header ioctl_header;
2206 enum block_state state;
2207 long ret = -EINVAL;
2208
2209 /* get IOCTL header */
2210 if (copy_from_user(&ioctl_header, (char __user *)arg,
2211 sizeof(struct mpt3_ioctl_header))) {
2212 pr_err("failure at %s:%d/%s()!\n",
2213 __FILE__, __LINE__, __func__);
2214 return -EFAULT;
2215 }
2216
2217 if (_ctl_verify_adapter(ioctl_header.ioc_number, &ioc) == -1 || !ioc)
2218 return -ENODEV;
2219
2220 if (ioc->shost_recovery || ioc->pci_error_recovery ||
2221 ioc->is_driver_loading)
2222 return -EAGAIN;
2223
2224 state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : BLOCKING;
2225 if (state == NON_BLOCKING) {
2226 if (!mutex_trylock(&ioc->ctl_cmds.mutex))
2227 return -EAGAIN;
2228 } else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
2229 return -ERESTARTSYS;
2230
2231
2232 switch (cmd) {
2233 case MPT3IOCINFO:
2234 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_iocinfo))
2235 ret = _ctl_getiocinfo(ioc, arg);
2236 break;
2237#ifdef CONFIG_COMPAT
2238 case MPT3COMMAND32:
2239#endif
2240 case MPT3COMMAND:
2241 {
2242 struct mpt3_ioctl_command __user *uarg;
2243 struct mpt3_ioctl_command karg;
2244
2245#ifdef CONFIG_COMPAT
2246 if (compat) {
2247 ret = _ctl_compat_mpt_command(ioc, cmd, arg);
2248 break;
2249 }
2250#endif
2251 if (copy_from_user(&karg, arg, sizeof(karg))) {
2252 pr_err("failure at %s:%d/%s()!\n",
2253 __FILE__, __LINE__, __func__);
2254 ret = -EFAULT;
2255 break;
2256 }
2257
2258 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_command)) {
2259 uarg = arg;
2260 ret = _ctl_do_mpt_command(ioc, karg, &uarg->mf);
2261 }
2262 break;
2263 }
2264 case MPT3EVENTQUERY:
2265 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_eventquery))
2266 ret = _ctl_eventquery(ioc, arg);
2267 break;
2268 case MPT3EVENTENABLE:
2269 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_eventenable))
2270 ret = _ctl_eventenable(ioc, arg);
2271 break;
2272 case MPT3EVENTREPORT:
2273 ret = _ctl_eventreport(ioc, arg);
2274 break;
2275 case MPT3HARDRESET:
2276 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_diag_reset))
2277 ret = _ctl_do_reset(ioc, arg);
2278 break;
2279 case MPT3BTDHMAPPING:
2280 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_btdh_mapping))
2281 ret = _ctl_btdh_mapping(ioc, arg);
2282 break;
2283 case MPT3DIAGREGISTER:
2284 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_register))
2285 ret = _ctl_diag_register(ioc, arg);
2286 break;
2287 case MPT3DIAGUNREGISTER:
2288 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_unregister))
2289 ret = _ctl_diag_unregister(ioc, arg);
2290 break;
2291 case MPT3DIAGQUERY:
2292 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_query))
2293 ret = _ctl_diag_query(ioc, arg);
2294 break;
2295 case MPT3DIAGRELEASE:
2296 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_release))
2297 ret = _ctl_diag_release(ioc, arg);
2298 break;
2299 case MPT3DIAGREADBUFFER:
2300 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_read_buffer))
2301 ret = _ctl_diag_read_buffer(ioc, arg);
2302 break;
2303 default:
2304 dctlprintk(ioc, pr_info(MPT3SAS_FMT
2305 "unsupported ioctl opcode(0x%08x)\n", ioc->name, cmd));
2306 break;
2307 }
2308
2309 mutex_unlock(&ioc->ctl_cmds.mutex);
2310 return ret;
2311}
2312
2313/**
2314 * _ctl_ioctl - main ioctl entry point (unlocked)
2315 * @file - (struct file)
2316 * @cmd - ioctl opcode
2317 * @arg -
2318 */
2319static long
2320_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2321{
2322 long ret;
2323
2324 ret = _ctl_ioctl_main(file, cmd, (void __user *)arg, 0);
2325 return ret;
2326}
2327
2328#ifdef CONFIG_COMPAT
2329/**
2330 * _ctl_ioctl_compat - main ioctl entry point (compat)
2331 * @file -
2332 * @cmd -
2333 * @arg -
2334 *
2335 * This routine handles 32 bit applications in 64bit os.
2336 */
2337static long
2338_ctl_ioctl_compat(struct file *file, unsigned cmd, unsigned long arg)
2339{
2340 long ret;
2341
2342 ret = _ctl_ioctl_main(file, cmd, (void __user *)arg, 1);
2343 return ret;
2344}
2345#endif
2346
2347/* scsi host attributes */
2348/**
2349 * _ctl_version_fw_show - firmware version
2350 * @cdev - pointer to embedded class device
2351 * @buf - the buffer returned
2352 *
2353 * A sysfs 'read-only' shost attribute.
2354 */
2355static ssize_t
2356_ctl_version_fw_show(struct device *cdev, struct device_attribute *attr,
2357 char *buf)
2358{
2359 struct Scsi_Host *shost = class_to_shost(cdev);
2360 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2361
2362 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
2363 (ioc->facts.FWVersion.Word & 0xFF000000) >> 24,
2364 (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16,
2365 (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
2366 ioc->facts.FWVersion.Word & 0x000000FF);
2367}
2368static DEVICE_ATTR(version_fw, S_IRUGO, _ctl_version_fw_show, NULL);
2369
2370/**
2371 * _ctl_version_bios_show - bios version
2372 * @cdev - pointer to embedded class device
2373 * @buf - the buffer returned
2374 *
2375 * A sysfs 'read-only' shost attribute.
2376 */
2377static ssize_t
2378_ctl_version_bios_show(struct device *cdev, struct device_attribute *attr,
2379 char *buf)
2380{
2381 struct Scsi_Host *shost = class_to_shost(cdev);
2382 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2383
2384 u32 version = le32_to_cpu(ioc->bios_pg3.BiosVersion);
2385
2386 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
2387 (version & 0xFF000000) >> 24,
2388 (version & 0x00FF0000) >> 16,
2389 (version & 0x0000FF00) >> 8,
2390 version & 0x000000FF);
2391}
2392static DEVICE_ATTR(version_bios, S_IRUGO, _ctl_version_bios_show, NULL);
2393
2394/**
2395 * _ctl_version_mpi_show - MPI (message passing interface) version
2396 * @cdev - pointer to embedded class device
2397 * @buf - the buffer returned
2398 *
2399 * A sysfs 'read-only' shost attribute.
2400 */
2401static ssize_t
2402_ctl_version_mpi_show(struct device *cdev, struct device_attribute *attr,
2403 char *buf)
2404{
2405 struct Scsi_Host *shost = class_to_shost(cdev);
2406 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2407
2408 return snprintf(buf, PAGE_SIZE, "%03x.%02x\n",
2409 ioc->facts.MsgVersion, ioc->facts.HeaderVersion >> 8);
2410}
2411static DEVICE_ATTR(version_mpi, S_IRUGO, _ctl_version_mpi_show, NULL);
2412
2413/**
2414 * _ctl_version_product_show - product name
2415 * @cdev - pointer to embedded class device
2416 * @buf - the buffer returned
2417 *
2418 * A sysfs 'read-only' shost attribute.
2419 */
2420static ssize_t
2421_ctl_version_product_show(struct device *cdev, struct device_attribute *attr,
2422 char *buf)
2423{
2424 struct Scsi_Host *shost = class_to_shost(cdev);
2425 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2426
2427 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.ChipName);
2428}
2429static DEVICE_ATTR(version_product, S_IRUGO, _ctl_version_product_show, NULL);
2430
2431/**
2432 * _ctl_version_nvdata_persistent_show - ndvata persistent version
2433 * @cdev - pointer to embedded class device
2434 * @buf - the buffer returned
2435 *
2436 * A sysfs 'read-only' shost attribute.
2437 */
2438static ssize_t
2439_ctl_version_nvdata_persistent_show(struct device *cdev,
2440 struct device_attribute *attr, char *buf)
2441{
2442 struct Scsi_Host *shost = class_to_shost(cdev);
2443 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2444
2445 return snprintf(buf, PAGE_SIZE, "%08xh\n",
2446 le32_to_cpu(ioc->iounit_pg0.NvdataVersionPersistent.Word));
2447}
2448static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO,
2449 _ctl_version_nvdata_persistent_show, NULL);
2450
2451/**
2452 * _ctl_version_nvdata_default_show - nvdata default version
2453 * @cdev - pointer to embedded class device
2454 * @buf - the buffer returned
2455 *
2456 * A sysfs 'read-only' shost attribute.
2457 */
2458static ssize_t
2459_ctl_version_nvdata_default_show(struct device *cdev, struct device_attribute
2460 *attr, char *buf)
2461{
2462 struct Scsi_Host *shost = class_to_shost(cdev);
2463 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2464
2465 return snprintf(buf, PAGE_SIZE, "%08xh\n",
2466 le32_to_cpu(ioc->iounit_pg0.NvdataVersionDefault.Word));
2467}
2468static DEVICE_ATTR(version_nvdata_default, S_IRUGO,
2469 _ctl_version_nvdata_default_show, NULL);
2470
2471/**
2472 * _ctl_board_name_show - board name
2473 * @cdev - pointer to embedded class device
2474 * @buf - the buffer returned
2475 *
2476 * A sysfs 'read-only' shost attribute.
2477 */
2478static ssize_t
2479_ctl_board_name_show(struct device *cdev, struct device_attribute *attr,
2480 char *buf)
2481{
2482 struct Scsi_Host *shost = class_to_shost(cdev);
2483 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2484
2485 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardName);
2486}
2487static DEVICE_ATTR(board_name, S_IRUGO, _ctl_board_name_show, NULL);
2488
2489/**
2490 * _ctl_board_assembly_show - board assembly name
2491 * @cdev - pointer to embedded class device
2492 * @buf - the buffer returned
2493 *
2494 * A sysfs 'read-only' shost attribute.
2495 */
2496static ssize_t
2497_ctl_board_assembly_show(struct device *cdev, struct device_attribute *attr,
2498 char *buf)
2499{
2500 struct Scsi_Host *shost = class_to_shost(cdev);
2501 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2502
2503 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardAssembly);
2504}
2505static DEVICE_ATTR(board_assembly, S_IRUGO, _ctl_board_assembly_show, NULL);
2506
2507/**
2508 * _ctl_board_tracer_show - board tracer number
2509 * @cdev - pointer to embedded class device
2510 * @buf - the buffer returned
2511 *
2512 * A sysfs 'read-only' shost attribute.
2513 */
2514static ssize_t
2515_ctl_board_tracer_show(struct device *cdev, struct device_attribute *attr,
2516 char *buf)
2517{
2518 struct Scsi_Host *shost = class_to_shost(cdev);
2519 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2520
2521 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardTracerNumber);
2522}
2523static DEVICE_ATTR(board_tracer, S_IRUGO, _ctl_board_tracer_show, NULL);
2524
2525/**
2526 * _ctl_io_delay_show - io missing delay
2527 * @cdev - pointer to embedded class device
2528 * @buf - the buffer returned
2529 *
2530 * This is for firmware implemention for deboucing device
2531 * removal events.
2532 *
2533 * A sysfs 'read-only' shost attribute.
2534 */
2535static ssize_t
2536_ctl_io_delay_show(struct device *cdev, struct device_attribute *attr,
2537 char *buf)
2538{
2539 struct Scsi_Host *shost = class_to_shost(cdev);
2540 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2541
2542 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay);
2543}
2544static DEVICE_ATTR(io_delay, S_IRUGO, _ctl_io_delay_show, NULL);
2545
2546/**
2547 * _ctl_device_delay_show - device missing delay
2548 * @cdev - pointer to embedded class device
2549 * @buf - the buffer returned
2550 *
2551 * This is for firmware implemention for deboucing device
2552 * removal events.
2553 *
2554 * A sysfs 'read-only' shost attribute.
2555 */
2556static ssize_t
2557_ctl_device_delay_show(struct device *cdev, struct device_attribute *attr,
2558 char *buf)
2559{
2560 struct Scsi_Host *shost = class_to_shost(cdev);
2561 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2562
2563 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay);
2564}
2565static DEVICE_ATTR(device_delay, S_IRUGO, _ctl_device_delay_show, NULL);
2566
2567/**
2568 * _ctl_fw_queue_depth_show - global credits
2569 * @cdev - pointer to embedded class device
2570 * @buf - the buffer returned
2571 *
2572 * This is firmware queue depth limit
2573 *
2574 * A sysfs 'read-only' shost attribute.
2575 */
2576static ssize_t
2577_ctl_fw_queue_depth_show(struct device *cdev, struct device_attribute *attr,
2578 char *buf)
2579{
2580 struct Scsi_Host *shost = class_to_shost(cdev);
2581 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2582
2583 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->facts.RequestCredit);
2584}
2585static DEVICE_ATTR(fw_queue_depth, S_IRUGO, _ctl_fw_queue_depth_show, NULL);
2586
2587/**
2588 * _ctl_sas_address_show - sas address
2589 * @cdev - pointer to embedded class device
2590 * @buf - the buffer returned
2591 *
2592 * This is the controller sas address
2593 *
2594 * A sysfs 'read-only' shost attribute.
2595 */
2596static ssize_t
2597_ctl_host_sas_address_show(struct device *cdev, struct device_attribute *attr,
2598 char *buf)
2599
2600{
2601 struct Scsi_Host *shost = class_to_shost(cdev);
2602 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2603
2604 return snprintf(buf, PAGE_SIZE, "0x%016llx\n",
2605 (unsigned long long)ioc->sas_hba.sas_address);
2606}
2607static DEVICE_ATTR(host_sas_address, S_IRUGO,
2608 _ctl_host_sas_address_show, NULL);
2609
2610/**
2611 * _ctl_logging_level_show - logging level
2612 * @cdev - pointer to embedded class device
2613 * @buf - the buffer returned
2614 *
2615 * A sysfs 'read/write' shost attribute.
2616 */
2617static ssize_t
2618_ctl_logging_level_show(struct device *cdev, struct device_attribute *attr,
2619 char *buf)
2620{
2621 struct Scsi_Host *shost = class_to_shost(cdev);
2622 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2623
2624 return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->logging_level);
2625}
2626static ssize_t
2627_ctl_logging_level_store(struct device *cdev, struct device_attribute *attr,
2628 const char *buf, size_t count)
2629{
2630 struct Scsi_Host *shost = class_to_shost(cdev);
2631 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2632 int val = 0;
2633
2634 if (sscanf(buf, "%x", &val) != 1)
2635 return -EINVAL;
2636
2637 ioc->logging_level = val;
2638 pr_info(MPT3SAS_FMT "logging_level=%08xh\n", ioc->name,
2639 ioc->logging_level);
2640 return strlen(buf);
2641}
2642static DEVICE_ATTR(logging_level, S_IRUGO | S_IWUSR, _ctl_logging_level_show,
2643 _ctl_logging_level_store);
2644
2645/**
2646 * _ctl_fwfault_debug_show - show/store fwfault_debug
2647 * @cdev - pointer to embedded class device
2648 * @buf - the buffer returned
2649 *
2650 * mpt3sas_fwfault_debug is command line option
2651 * A sysfs 'read/write' shost attribute.
2652 */
2653static ssize_t
2654_ctl_fwfault_debug_show(struct device *cdev, struct device_attribute *attr,
2655 char *buf)
2656{
2657 struct Scsi_Host *shost = class_to_shost(cdev);
2658 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2659
2660 return snprintf(buf, PAGE_SIZE, "%d\n", ioc->fwfault_debug);
2661}
2662static ssize_t
2663_ctl_fwfault_debug_store(struct device *cdev, struct device_attribute *attr,
2664 const char *buf, size_t count)
2665{
2666 struct Scsi_Host *shost = class_to_shost(cdev);
2667 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2668 int val = 0;
2669
2670 if (sscanf(buf, "%d", &val) != 1)
2671 return -EINVAL;
2672
2673 ioc->fwfault_debug = val;
2674 pr_info(MPT3SAS_FMT "fwfault_debug=%d\n", ioc->name,
2675 ioc->fwfault_debug);
2676 return strlen(buf);
2677}
2678static DEVICE_ATTR(fwfault_debug, S_IRUGO | S_IWUSR,
2679 _ctl_fwfault_debug_show, _ctl_fwfault_debug_store);
2680
2681/**
2682 * _ctl_ioc_reset_count_show - ioc reset count
2683 * @cdev - pointer to embedded class device
2684 * @buf - the buffer returned
2685 *
2686 * This is firmware queue depth limit
2687 *
2688 * A sysfs 'read-only' shost attribute.
2689 */
2690static ssize_t
2691_ctl_ioc_reset_count_show(struct device *cdev, struct device_attribute *attr,
2692 char *buf)
2693{
2694 struct Scsi_Host *shost = class_to_shost(cdev);
2695 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2696
2697 return snprintf(buf, PAGE_SIZE, "%d\n", ioc->ioc_reset_count);
2698}
2699static DEVICE_ATTR(ioc_reset_count, S_IRUGO, _ctl_ioc_reset_count_show, NULL);
2700
2701/**
2702 * _ctl_ioc_reply_queue_count_show - number of reply queues
2703 * @cdev - pointer to embedded class device
2704 * @buf - the buffer returned
2705 *
2706 * This is number of reply queues
2707 *
2708 * A sysfs 'read-only' shost attribute.
2709 */
2710static ssize_t
2711_ctl_ioc_reply_queue_count_show(struct device *cdev,
2712 struct device_attribute *attr, char *buf)
2713{
2714 u8 reply_queue_count;
2715 struct Scsi_Host *shost = class_to_shost(cdev);
2716 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2717
2718 if ((ioc->facts.IOCCapabilities &
2719 MPI2_IOCFACTS_CAPABILITY_MSI_X_INDEX) && ioc->msix_enable)
2720 reply_queue_count = ioc->reply_queue_count;
2721 else
2722 reply_queue_count = 1;
2723
2724 return snprintf(buf, PAGE_SIZE, "%d\n", reply_queue_count);
2725}
2726static DEVICE_ATTR(reply_queue_count, S_IRUGO, _ctl_ioc_reply_queue_count_show,
2727 NULL);
2728
2729struct DIAG_BUFFER_START {
2730 __le32 Size;
2731 __le32 DiagVersion;
2732 u8 BufferType;
2733 u8 Reserved[3];
2734 __le32 Reserved1;
2735 __le32 Reserved2;
2736 __le32 Reserved3;
2737};
2738
2739/**
2740 * _ctl_host_trace_buffer_size_show - host buffer size (trace only)
2741 * @cdev - pointer to embedded class device
2742 * @buf - the buffer returned
2743 *
2744 * A sysfs 'read-only' shost attribute.
2745 */
2746static ssize_t
2747_ctl_host_trace_buffer_size_show(struct device *cdev,
2748 struct device_attribute *attr, char *buf)
2749{
2750 struct Scsi_Host *shost = class_to_shost(cdev);
2751 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2752 u32 size = 0;
2753 struct DIAG_BUFFER_START *request_data;
2754
2755 if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) {
2756 pr_err(MPT3SAS_FMT
2757 "%s: host_trace_buffer is not registered\n",
2758 ioc->name, __func__);
2759 return 0;
2760 }
2761
2762 if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2763 MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
2764 pr_err(MPT3SAS_FMT
2765 "%s: host_trace_buffer is not registered\n",
2766 ioc->name, __func__);
2767 return 0;
2768 }
2769
2770 request_data = (struct DIAG_BUFFER_START *)
2771 ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE];
2772 if ((le32_to_cpu(request_data->DiagVersion) == 0x00000000 ||
2773 le32_to_cpu(request_data->DiagVersion) == 0x01000000 ||
2774 le32_to_cpu(request_data->DiagVersion) == 0x01010000) &&
2775 le32_to_cpu(request_data->Reserved3) == 0x4742444c)
2776 size = le32_to_cpu(request_data->Size);
2777
2778 ioc->ring_buffer_sz = size;
2779 return snprintf(buf, PAGE_SIZE, "%d\n", size);
2780}
2781static DEVICE_ATTR(host_trace_buffer_size, S_IRUGO,
2782 _ctl_host_trace_buffer_size_show, NULL);
2783
2784/**
2785 * _ctl_host_trace_buffer_show - firmware ring buffer (trace only)
2786 * @cdev - pointer to embedded class device
2787 * @buf - the buffer returned
2788 *
2789 * A sysfs 'read/write' shost attribute.
2790 *
2791 * You will only be able to read 4k bytes of ring buffer at a time.
2792 * In order to read beyond 4k bytes, you will have to write out the
2793 * offset to the same attribute, it will move the pointer.
2794 */
2795static ssize_t
2796_ctl_host_trace_buffer_show(struct device *cdev, struct device_attribute *attr,
2797 char *buf)
2798{
2799 struct Scsi_Host *shost = class_to_shost(cdev);
2800 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2801 void *request_data;
2802 u32 size;
2803
2804 if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) {
2805 pr_err(MPT3SAS_FMT
2806 "%s: host_trace_buffer is not registered\n",
2807 ioc->name, __func__);
2808 return 0;
2809 }
2810
2811 if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2812 MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
2813 pr_err(MPT3SAS_FMT
2814 "%s: host_trace_buffer is not registered\n",
2815 ioc->name, __func__);
2816 return 0;
2817 }
2818
2819 if (ioc->ring_buffer_offset > ioc->ring_buffer_sz)
2820 return 0;
2821
2822 size = ioc->ring_buffer_sz - ioc->ring_buffer_offset;
2823 size = (size >= PAGE_SIZE) ? (PAGE_SIZE - 1) : size;
2824 request_data = ioc->diag_buffer[0] + ioc->ring_buffer_offset;
2825 memcpy(buf, request_data, size);
2826 return size;
2827}
2828
2829static ssize_t
2830_ctl_host_trace_buffer_store(struct device *cdev, struct device_attribute *attr,
2831 const char *buf, size_t count)
2832{
2833 struct Scsi_Host *shost = class_to_shost(cdev);
2834 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2835 int val = 0;
2836
2837 if (sscanf(buf, "%d", &val) != 1)
2838 return -EINVAL;
2839
2840 ioc->ring_buffer_offset = val;
2841 return strlen(buf);
2842}
2843static DEVICE_ATTR(host_trace_buffer, S_IRUGO | S_IWUSR,
2844 _ctl_host_trace_buffer_show, _ctl_host_trace_buffer_store);
2845
2846
2847/*****************************************/
2848
2849/**
2850 * _ctl_host_trace_buffer_enable_show - firmware ring buffer (trace only)
2851 * @cdev - pointer to embedded class device
2852 * @buf - the buffer returned
2853 *
2854 * A sysfs 'read/write' shost attribute.
2855 *
2856 * This is a mechnism to post/release host_trace_buffers
2857 */
2858static ssize_t
2859_ctl_host_trace_buffer_enable_show(struct device *cdev,
2860 struct device_attribute *attr, char *buf)
2861{
2862 struct Scsi_Host *shost = class_to_shost(cdev);
2863 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2864
2865 if ((!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) ||
2866 ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2867 MPT3_DIAG_BUFFER_IS_REGISTERED) == 0))
2868 return snprintf(buf, PAGE_SIZE, "off\n");
2869 else if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2870 MPT3_DIAG_BUFFER_IS_RELEASED))
2871 return snprintf(buf, PAGE_SIZE, "release\n");
2872 else
2873 return snprintf(buf, PAGE_SIZE, "post\n");
2874}
2875
2876static ssize_t
2877_ctl_host_trace_buffer_enable_store(struct device *cdev,
2878 struct device_attribute *attr, const char *buf, size_t count)
2879{
2880 struct Scsi_Host *shost = class_to_shost(cdev);
2881 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2882 char str[10] = "";
2883 struct mpt3_diag_register diag_register;
2884 u8 issue_reset = 0;
2885
2886 /* don't allow post/release occurr while recovery is active */
2887 if (ioc->shost_recovery || ioc->remove_host ||
2888 ioc->pci_error_recovery || ioc->is_driver_loading)
2889 return -EBUSY;
2890
2891 if (sscanf(buf, "%9s", str) != 1)
2892 return -EINVAL;
2893
2894 if (!strcmp(str, "post")) {
2895 /* exit out if host buffers are already posted */
2896 if ((ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) &&
2897 (ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2898 MPT3_DIAG_BUFFER_IS_REGISTERED) &&
2899 ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2900 MPT3_DIAG_BUFFER_IS_RELEASED) == 0))
2901 goto out;
2902 memset(&diag_register, 0, sizeof(struct mpt3_diag_register));
2903 pr_info(MPT3SAS_FMT "posting host trace buffers\n",
2904 ioc->name);
2905 diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE;
2906 diag_register.requested_buffer_size = (1024 * 1024);
2907 diag_register.unique_id = 0x7075900;
2908 ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] = 0;
2909 _ctl_diag_register_2(ioc, &diag_register);
2910 } else if (!strcmp(str, "release")) {
2911 /* exit out if host buffers are already released */
2912 if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE])
2913 goto out;
2914 if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2915 MPT3_DIAG_BUFFER_IS_REGISTERED) == 0)
2916 goto out;
2917 if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
2918 MPT3_DIAG_BUFFER_IS_RELEASED))
2919 goto out;
2920 pr_info(MPT3SAS_FMT "releasing host trace buffer\n",
2921 ioc->name);
2922 mpt3sas_send_diag_release(ioc, MPI2_DIAG_BUF_TYPE_TRACE,
2923 &issue_reset);
2924 }
2925
2926 out:
2927 return strlen(buf);
2928}
2929static DEVICE_ATTR(host_trace_buffer_enable, S_IRUGO | S_IWUSR,
2930 _ctl_host_trace_buffer_enable_show,
2931 _ctl_host_trace_buffer_enable_store);
2932
2933/*********** diagnostic trigger suppport *********************************/
2934
2935/**
2936 * _ctl_diag_trigger_master_show - show the diag_trigger_master attribute
2937 * @cdev - pointer to embedded class device
2938 * @buf - the buffer returned
2939 *
2940 * A sysfs 'read/write' shost attribute.
2941 */
2942static ssize_t
2943_ctl_diag_trigger_master_show(struct device *cdev,
2944 struct device_attribute *attr, char *buf)
2945
2946{
2947 struct Scsi_Host *shost = class_to_shost(cdev);
2948 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2949 unsigned long flags;
2950 ssize_t rc;
2951
2952 spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
2953 rc = sizeof(struct SL_WH_MASTER_TRIGGER_T);
2954 memcpy(buf, &ioc->diag_trigger_master, rc);
2955 spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags);
2956 return rc;
2957}
2958
2959/**
2960 * _ctl_diag_trigger_master_store - store the diag_trigger_master attribute
2961 * @cdev - pointer to embedded class device
2962 * @buf - the buffer returned
2963 *
2964 * A sysfs 'read/write' shost attribute.
2965 */
2966static ssize_t
2967_ctl_diag_trigger_master_store(struct device *cdev,
2968 struct device_attribute *attr, const char *buf, size_t count)
2969
2970{
2971 struct Scsi_Host *shost = class_to_shost(cdev);
2972 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
2973 unsigned long flags;
2974 ssize_t rc;
2975
2976 spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
2977 rc = min(sizeof(struct SL_WH_MASTER_TRIGGER_T), count);
2978 memset(&ioc->diag_trigger_master, 0,
2979 sizeof(struct SL_WH_MASTER_TRIGGER_T));
2980 memcpy(&ioc->diag_trigger_master, buf, rc);
2981 ioc->diag_trigger_master.MasterData |=
2982 (MASTER_TRIGGER_FW_FAULT + MASTER_TRIGGER_ADAPTER_RESET);
2983 spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags);
2984 return rc;
2985}
2986static DEVICE_ATTR(diag_trigger_master, S_IRUGO | S_IWUSR,
2987 _ctl_diag_trigger_master_show, _ctl_diag_trigger_master_store);
2988
2989
2990/**
2991 * _ctl_diag_trigger_event_show - show the diag_trigger_event attribute
2992 * @cdev - pointer to embedded class device
2993 * @buf - the buffer returned
2994 *
2995 * A sysfs 'read/write' shost attribute.
2996 */
2997static ssize_t
2998_ctl_diag_trigger_event_show(struct device *cdev,
2999 struct device_attribute *attr, char *buf)
3000{
3001 struct Scsi_Host *shost = class_to_shost(cdev);
3002 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3003 unsigned long flags;
3004 ssize_t rc;
3005
3006 spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
3007 rc = sizeof(struct SL_WH_EVENT_TRIGGERS_T);
3008 memcpy(buf, &ioc->diag_trigger_event, rc);
3009 spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags);
3010 return rc;
3011}
3012
3013/**
3014 * _ctl_diag_trigger_event_store - store the diag_trigger_event attribute
3015 * @cdev - pointer to embedded class device
3016 * @buf - the buffer returned
3017 *
3018 * A sysfs 'read/write' shost attribute.
3019 */
3020static ssize_t
3021_ctl_diag_trigger_event_store(struct device *cdev,
3022 struct device_attribute *attr, const char *buf, size_t count)
3023
3024{
3025 struct Scsi_Host *shost = class_to_shost(cdev);
3026 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3027 unsigned long flags;
3028 ssize_t sz;
3029
3030 spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
3031 sz = min(sizeof(struct SL_WH_EVENT_TRIGGERS_T), count);
3032 memset(&ioc->diag_trigger_event, 0,
3033 sizeof(struct SL_WH_EVENT_TRIGGERS_T));
3034 memcpy(&ioc->diag_trigger_event, buf, sz);
3035 if (ioc->diag_trigger_event.ValidEntries > NUM_VALID_ENTRIES)
3036 ioc->diag_trigger_event.ValidEntries = NUM_VALID_ENTRIES;
3037 spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags);
3038 return sz;
3039}
3040static DEVICE_ATTR(diag_trigger_event, S_IRUGO | S_IWUSR,
3041 _ctl_diag_trigger_event_show, _ctl_diag_trigger_event_store);
3042
3043
3044/**
3045 * _ctl_diag_trigger_scsi_show - show the diag_trigger_scsi attribute
3046 * @cdev - pointer to embedded class device
3047 * @buf - the buffer returned
3048 *
3049 * A sysfs 'read/write' shost attribute.
3050 */
3051static ssize_t
3052_ctl_diag_trigger_scsi_show(struct device *cdev,
3053 struct device_attribute *attr, char *buf)
3054{
3055 struct Scsi_Host *shost = class_to_shost(cdev);
3056 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3057 unsigned long flags;
3058 ssize_t rc;
3059
3060 spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
3061 rc = sizeof(struct SL_WH_SCSI_TRIGGERS_T);
3062 memcpy(buf, &ioc->diag_trigger_scsi, rc);
3063 spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags);
3064 return rc;
3065}
3066
3067/**
3068 * _ctl_diag_trigger_scsi_store - store the diag_trigger_scsi attribute
3069 * @cdev - pointer to embedded class device
3070 * @buf - the buffer returned
3071 *
3072 * A sysfs 'read/write' shost attribute.
3073 */
3074static ssize_t
3075_ctl_diag_trigger_scsi_store(struct device *cdev,
3076 struct device_attribute *attr, const char *buf, size_t count)
3077{
3078 struct Scsi_Host *shost = class_to_shost(cdev);
3079 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3080 unsigned long flags;
3081 ssize_t sz;
3082
3083 spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
3084 sz = min(sizeof(struct SL_WH_SCSI_TRIGGERS_T), count);
3085 memset(&ioc->diag_trigger_scsi, 0,
3086 sizeof(struct SL_WH_EVENT_TRIGGERS_T));
3087 memcpy(&ioc->diag_trigger_scsi, buf, sz);
3088 if (ioc->diag_trigger_scsi.ValidEntries > NUM_VALID_ENTRIES)
3089 ioc->diag_trigger_scsi.ValidEntries = NUM_VALID_ENTRIES;
3090 spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags);
3091 return sz;
3092}
3093static DEVICE_ATTR(diag_trigger_scsi, S_IRUGO | S_IWUSR,
3094 _ctl_diag_trigger_scsi_show, _ctl_diag_trigger_scsi_store);
3095
3096
3097/**
3098 * _ctl_diag_trigger_scsi_show - show the diag_trigger_mpi attribute
3099 * @cdev - pointer to embedded class device
3100 * @buf - the buffer returned
3101 *
3102 * A sysfs 'read/write' shost attribute.
3103 */
3104static ssize_t
3105_ctl_diag_trigger_mpi_show(struct device *cdev,
3106 struct device_attribute *attr, char *buf)
3107{
3108 struct Scsi_Host *shost = class_to_shost(cdev);
3109 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3110 unsigned long flags;
3111 ssize_t rc;
3112
3113 spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
3114 rc = sizeof(struct SL_WH_MPI_TRIGGERS_T);
3115 memcpy(buf, &ioc->diag_trigger_mpi, rc);
3116 spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags);
3117 return rc;
3118}
3119
3120/**
3121 * _ctl_diag_trigger_mpi_store - store the diag_trigger_mpi attribute
3122 * @cdev - pointer to embedded class device
3123 * @buf - the buffer returned
3124 *
3125 * A sysfs 'read/write' shost attribute.
3126 */
3127static ssize_t
3128_ctl_diag_trigger_mpi_store(struct device *cdev,
3129 struct device_attribute *attr, const char *buf, size_t count)
3130{
3131 struct Scsi_Host *shost = class_to_shost(cdev);
3132 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
3133 unsigned long flags;
3134 ssize_t sz;
3135
3136 spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
3137 sz = min(sizeof(struct SL_WH_MPI_TRIGGERS_T), count);
3138 memset(&ioc->diag_trigger_mpi, 0,
3139 sizeof(struct SL_WH_EVENT_TRIGGERS_T));
3140 memcpy(&ioc->diag_trigger_mpi, buf, sz);
3141 if (ioc->diag_trigger_mpi.ValidEntries > NUM_VALID_ENTRIES)
3142 ioc->diag_trigger_mpi.ValidEntries = NUM_VALID_ENTRIES;
3143 spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags);
3144 return sz;
3145}
3146
3147static DEVICE_ATTR(diag_trigger_mpi, S_IRUGO | S_IWUSR,
3148 _ctl_diag_trigger_mpi_show, _ctl_diag_trigger_mpi_store);
3149
3150/*********** diagnostic trigger suppport *** END ****************************/
3151
3152
3153
3154/*****************************************/
3155
3156struct device_attribute *mpt3sas_host_attrs[] = {
3157 &dev_attr_version_fw,
3158 &dev_attr_version_bios,
3159 &dev_attr_version_mpi,
3160 &dev_attr_version_product,
3161 &dev_attr_version_nvdata_persistent,
3162 &dev_attr_version_nvdata_default,
3163 &dev_attr_board_name,
3164 &dev_attr_board_assembly,
3165 &dev_attr_board_tracer,
3166 &dev_attr_io_delay,
3167 &dev_attr_device_delay,
3168 &dev_attr_logging_level,
3169 &dev_attr_fwfault_debug,
3170 &dev_attr_fw_queue_depth,
3171 &dev_attr_host_sas_address,
3172 &dev_attr_ioc_reset_count,
3173 &dev_attr_host_trace_buffer_size,
3174 &dev_attr_host_trace_buffer,
3175 &dev_attr_host_trace_buffer_enable,
3176 &dev_attr_reply_queue_count,
3177 &dev_attr_diag_trigger_master,
3178 &dev_attr_diag_trigger_event,
3179 &dev_attr_diag_trigger_scsi,
3180 &dev_attr_diag_trigger_mpi,
3181 NULL,
3182};
3183
3184/* device attributes */
3185
3186/**
3187 * _ctl_device_sas_address_show - sas address
3188 * @cdev - pointer to embedded class device
3189 * @buf - the buffer returned
3190 *
3191 * This is the sas address for the target
3192 *
3193 * A sysfs 'read-only' shost attribute.
3194 */
3195static ssize_t
3196_ctl_device_sas_address_show(struct device *dev, struct device_attribute *attr,
3197 char *buf)
3198{
3199 struct scsi_device *sdev = to_scsi_device(dev);
3200 struct MPT3SAS_DEVICE *sas_device_priv_data = sdev->hostdata;
3201
3202 return snprintf(buf, PAGE_SIZE, "0x%016llx\n",
3203 (unsigned long long)sas_device_priv_data->sas_target->sas_address);
3204}
3205static DEVICE_ATTR(sas_address, S_IRUGO, _ctl_device_sas_address_show, NULL);
3206
3207/**
3208 * _ctl_device_handle_show - device handle
3209 * @cdev - pointer to embedded class device
3210 * @buf - the buffer returned
3211 *
3212 * This is the firmware assigned device handle
3213 *
3214 * A sysfs 'read-only' shost attribute.
3215 */
3216static ssize_t
3217_ctl_device_handle_show(struct device *dev, struct device_attribute *attr,
3218 char *buf)
3219{
3220 struct scsi_device *sdev = to_scsi_device(dev);
3221 struct MPT3SAS_DEVICE *sas_device_priv_data = sdev->hostdata;
3222
3223 return snprintf(buf, PAGE_SIZE, "0x%04x\n",
3224 sas_device_priv_data->sas_target->handle);
3225}
3226static DEVICE_ATTR(sas_device_handle, S_IRUGO, _ctl_device_handle_show, NULL);
3227
3228struct device_attribute *mpt3sas_dev_attrs[] = {
3229 &dev_attr_sas_address,
3230 &dev_attr_sas_device_handle,
3231 NULL,
3232};
3233
3234static const struct file_operations ctl_fops = {
3235 .owner = THIS_MODULE,
3236 .unlocked_ioctl = _ctl_ioctl,
3237 .release = _ctl_release,
3238 .poll = _ctl_poll,
3239 .fasync = _ctl_fasync,
3240#ifdef CONFIG_COMPAT
3241 .compat_ioctl = _ctl_ioctl_compat,
3242#endif
3243};
3244
3245static struct miscdevice ctl_dev = {
3246 .minor = MPT3SAS_MINOR,
3247 .name = MPT3SAS_DEV_NAME,
3248 .fops = &ctl_fops,
3249};
3250
3251/**
3252 * mpt3sas_ctl_init - main entry point for ctl.
3253 *
3254 */
3255void
3256mpt3sas_ctl_init(void)
3257{
3258 async_queue = NULL;
3259 if (misc_register(&ctl_dev) < 0)
3260 pr_err("%s can't register misc device [minor=%d]\n",
3261 MPT3SAS_DRIVER_NAME, MPT3SAS_MINOR);
3262
3263 init_waitqueue_head(&ctl_poll_wait);
3264}
3265
3266/**
3267 * mpt3sas_ctl_exit - exit point for ctl
3268 *
3269 */
3270void
3271mpt3sas_ctl_exit(void)
3272{
3273 struct MPT3SAS_ADAPTER *ioc;
3274 int i;
3275
3276 list_for_each_entry(ioc, &mpt3sas_ioc_list, list) {
3277
3278 /* free memory associated to diag buffers */
3279 for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
3280 if (!ioc->diag_buffer[i])
3281 continue;
3282 if (!(ioc->diag_buffer_status[i] &
3283 MPT3_DIAG_BUFFER_IS_REGISTERED))
3284 continue;
3285 if ((ioc->diag_buffer_status[i] &
3286 MPT3_DIAG_BUFFER_IS_RELEASED))
3287 continue;
3288 pci_free_consistent(ioc->pdev, ioc->diag_buffer_sz[i],
3289 ioc->diag_buffer[i], ioc->diag_buffer_dma[i]);
3290 ioc->diag_buffer[i] = NULL;
3291 ioc->diag_buffer_status[i] = 0;
3292 }
3293
3294 kfree(ioc->event_log);
3295 }
3296 misc_deregister(&ctl_dev);
3297}
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-25 07:39:36 -0500