2 * Management Module Support for MPT (Message Passing Technology) based
5 * This code is based on drivers/scsi/mpt3sas/mpt3sas_ctl.c
6 * Copyright (C) 2012-2014 LSI Corporation
7 * Copyright (C) 2013-2014 Avago Technologies
8 * (mailto: MPT-FusionLinux.pdl@avagotech.com)
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version 2
13 * of the License, or (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
21 * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
22 * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
23 * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
24 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
25 * solely responsible for determining the appropriateness of using and
26 * distributing the Program and assumes all risks associated with its
27 * exercise of rights under this Agreement, including but not limited to
28 * the risks and costs of program errors, damage to or loss of data,
29 * programs or equipment, and unavailability or interruption of operations.
31 * DISCLAIMER OF LIABILITY
32 * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
33 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
34 * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
35 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
36 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
37 * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
38 * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
40 * You should have received a copy of the GNU General Public License
41 * along with this program; if not, write to the Free Software
42 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
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>
58 #include <linux/uaccess.h>
60 #include "mpt3sas_base.h"
61 #include "mpt3sas_ctl.h"
64 static struct fasync_struct
*async_queue
;
65 static DECLARE_WAIT_QUEUE_HEAD(ctl_poll_wait
);
69 * enum block_state - blocking state
70 * @NON_BLOCKING: non blocking
73 * These states are for ioctls that need to wait for a response
74 * from firmware, so they probably require sleep.
82 * _ctl_sas_device_find_by_handle - sas device search
83 * @ioc: per adapter object
84 * @handle: sas device handle (assigned by firmware)
85 * Context: Calling function should acquire ioc->sas_device_lock
87 * This searches for sas_device based on sas_address, then return sas_device
90 static struct _sas_device
*
91 _ctl_sas_device_find_by_handle(struct MPT3SAS_ADAPTER
*ioc
, u16 handle
)
93 struct _sas_device
*sas_device
, *r
;
96 list_for_each_entry(sas_device
, &ioc
->sas_device_list
, list
) {
97 if (sas_device
->handle
!= handle
)
108 * _ctl_display_some_debug - debug routine
109 * @ioc: per adapter object
110 * @smid: system request message index
111 * @calling_function_name: string pass from calling function
112 * @mpi_reply: reply message frame
115 * Function for displaying debug info helpful when debugging issues
119 _ctl_display_some_debug(struct MPT3SAS_ADAPTER
*ioc
, u16 smid
,
120 char *calling_function_name
, MPI2DefaultReply_t
*mpi_reply
)
122 Mpi2ConfigRequest_t
*mpi_request
;
125 if (!(ioc
->logging_level
& MPT_DEBUG_IOCTL
))
128 mpi_request
= mpt3sas_base_get_msg_frame(ioc
, smid
);
129 switch (mpi_request
->Function
) {
130 case MPI2_FUNCTION_SCSI_IO_REQUEST
:
132 Mpi2SCSIIORequest_t
*scsi_request
=
133 (Mpi2SCSIIORequest_t
*)mpi_request
;
135 snprintf(ioc
->tmp_string
, MPT_STRING_LENGTH
,
136 "scsi_io, cmd(0x%02x), cdb_len(%d)",
137 scsi_request
->CDB
.CDB32
[0],
138 le16_to_cpu(scsi_request
->IoFlags
) & 0xF);
139 desc
= ioc
->tmp_string
;
142 case MPI2_FUNCTION_SCSI_TASK_MGMT
:
145 case MPI2_FUNCTION_IOC_INIT
:
148 case MPI2_FUNCTION_IOC_FACTS
:
151 case MPI2_FUNCTION_CONFIG
:
153 Mpi2ConfigRequest_t
*config_request
=
154 (Mpi2ConfigRequest_t
*)mpi_request
;
156 snprintf(ioc
->tmp_string
, MPT_STRING_LENGTH
,
157 "config, type(0x%02x), ext_type(0x%02x), number(%d)",
158 (config_request
->Header
.PageType
&
159 MPI2_CONFIG_PAGETYPE_MASK
), config_request
->ExtPageType
,
160 config_request
->Header
.PageNumber
);
161 desc
= ioc
->tmp_string
;
164 case MPI2_FUNCTION_PORT_FACTS
:
167 case MPI2_FUNCTION_PORT_ENABLE
:
168 desc
= "port_enable";
170 case MPI2_FUNCTION_EVENT_NOTIFICATION
:
171 desc
= "event_notification";
173 case MPI2_FUNCTION_FW_DOWNLOAD
:
174 desc
= "fw_download";
176 case MPI2_FUNCTION_FW_UPLOAD
:
179 case MPI2_FUNCTION_RAID_ACTION
:
180 desc
= "raid_action";
182 case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
:
184 Mpi2SCSIIORequest_t
*scsi_request
=
185 (Mpi2SCSIIORequest_t
*)mpi_request
;
187 snprintf(ioc
->tmp_string
, MPT_STRING_LENGTH
,
188 "raid_pass, cmd(0x%02x), cdb_len(%d)",
189 scsi_request
->CDB
.CDB32
[0],
190 le16_to_cpu(scsi_request
->IoFlags
) & 0xF);
191 desc
= ioc
->tmp_string
;
194 case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL
:
195 desc
= "sas_iounit_cntl";
197 case MPI2_FUNCTION_SATA_PASSTHROUGH
:
200 case MPI2_FUNCTION_DIAG_BUFFER_POST
:
201 desc
= "diag_buffer_post";
203 case MPI2_FUNCTION_DIAG_RELEASE
:
204 desc
= "diag_release";
206 case MPI2_FUNCTION_SMP_PASSTHROUGH
:
207 desc
= "smp_passthrough";
214 pr_info(MPT3SAS_FMT
"%s: %s, smid(%d)\n",
215 ioc
->name
, calling_function_name
, desc
, smid
);
220 if (mpi_reply
->IOCStatus
|| mpi_reply
->IOCLogInfo
)
222 "\tiocstatus(0x%04x), loginfo(0x%08x)\n",
223 ioc
->name
, le16_to_cpu(mpi_reply
->IOCStatus
),
224 le32_to_cpu(mpi_reply
->IOCLogInfo
));
226 if (mpi_request
->Function
== MPI2_FUNCTION_SCSI_IO_REQUEST
||
227 mpi_request
->Function
==
228 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
) {
229 Mpi2SCSIIOReply_t
*scsi_reply
=
230 (Mpi2SCSIIOReply_t
*)mpi_reply
;
231 struct _sas_device
*sas_device
= NULL
;
234 spin_lock_irqsave(&ioc
->sas_device_lock
, flags
);
235 sas_device
= _ctl_sas_device_find_by_handle(ioc
,
236 le16_to_cpu(scsi_reply
->DevHandle
));
238 pr_warn(MPT3SAS_FMT
"\tsas_address(0x%016llx), phy(%d)\n",
239 ioc
->name
, (unsigned long long)
240 sas_device
->sas_address
, sas_device
->phy
);
242 "\tenclosure_logical_id(0x%016llx), slot(%d)\n",
243 ioc
->name
, (unsigned long long)
244 sas_device
->enclosure_logical_id
, sas_device
->slot
);
246 spin_unlock_irqrestore(&ioc
->sas_device_lock
, flags
);
247 if (scsi_reply
->SCSIState
|| scsi_reply
->SCSIStatus
)
249 "\tscsi_state(0x%02x), scsi_status"
250 "(0x%02x)\n", ioc
->name
,
251 scsi_reply
->SCSIState
,
252 scsi_reply
->SCSIStatus
);
257 * mpt3sas_ctl_done - ctl module completion routine
258 * @ioc: per adapter object
259 * @smid: system request message index
260 * @msix_index: MSIX table index supplied by the OS
261 * @reply: reply message frame(lower 32bit addr)
264 * The callback handler when using ioc->ctl_cb_idx.
266 * Return 1 meaning mf should be freed from _base_interrupt
267 * 0 means the mf is freed from this function.
270 mpt3sas_ctl_done(struct MPT3SAS_ADAPTER
*ioc
, u16 smid
, u8 msix_index
,
273 MPI2DefaultReply_t
*mpi_reply
;
274 Mpi2SCSIIOReply_t
*scsiio_reply
;
275 const void *sense_data
;
278 if (ioc
->ctl_cmds
.status
== MPT3_CMD_NOT_USED
)
280 if (ioc
->ctl_cmds
.smid
!= smid
)
282 ioc
->ctl_cmds
.status
|= MPT3_CMD_COMPLETE
;
283 mpi_reply
= mpt3sas_base_get_reply_virt_addr(ioc
, reply
);
285 memcpy(ioc
->ctl_cmds
.reply
, mpi_reply
, mpi_reply
->MsgLength
*4);
286 ioc
->ctl_cmds
.status
|= MPT3_CMD_REPLY_VALID
;
288 if (mpi_reply
->Function
== MPI2_FUNCTION_SCSI_IO_REQUEST
||
289 mpi_reply
->Function
==
290 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
) {
291 scsiio_reply
= (Mpi2SCSIIOReply_t
*)mpi_reply
;
292 if (scsiio_reply
->SCSIState
&
293 MPI2_SCSI_STATE_AUTOSENSE_VALID
) {
294 sz
= min_t(u32
, SCSI_SENSE_BUFFERSIZE
,
295 le32_to_cpu(scsiio_reply
->SenseCount
));
296 sense_data
= mpt3sas_base_get_sense_buffer(ioc
,
298 memcpy(ioc
->ctl_cmds
.sense
, sense_data
, sz
);
302 _ctl_display_some_debug(ioc
, smid
, "ctl_done", mpi_reply
);
303 ioc
->ctl_cmds
.status
&= ~MPT3_CMD_PENDING
;
304 complete(&ioc
->ctl_cmds
.done
);
309 * _ctl_check_event_type - determines when an event needs logging
310 * @ioc: per adapter object
311 * @event: firmware event
313 * The bitmask in ioc->event_type[] indicates which events should be
314 * be saved in the driver event_log. This bitmask is set by application.
316 * Returns 1 when event should be captured, or zero means no match.
319 _ctl_check_event_type(struct MPT3SAS_ADAPTER
*ioc
, u16 event
)
324 if (event
>= 128 || !event
|| !ioc
->event_log
)
327 desired_event
= (1 << (event
% 32));
331 return desired_event
& ioc
->event_type
[i
];
335 * mpt3sas_ctl_add_to_event_log - add event
336 * @ioc: per adapter object
337 * @mpi_reply: reply message frame
342 mpt3sas_ctl_add_to_event_log(struct MPT3SAS_ADAPTER
*ioc
,
343 Mpi2EventNotificationReply_t
*mpi_reply
)
345 struct MPT3_IOCTL_EVENTS
*event_log
;
348 u32 sz
, event_data_sz
;
354 event
= le16_to_cpu(mpi_reply
->Event
);
356 if (_ctl_check_event_type(ioc
, event
)) {
358 /* insert entry into circular event_log */
359 i
= ioc
->event_context
% MPT3SAS_CTL_EVENT_LOG_SIZE
;
360 event_log
= ioc
->event_log
;
361 event_log
[i
].event
= event
;
362 event_log
[i
].context
= ioc
->event_context
++;
364 event_data_sz
= le16_to_cpu(mpi_reply
->EventDataLength
)*4;
365 sz
= min_t(u32
, event_data_sz
, MPT3_EVENT_DATA_SIZE
);
366 memset(event_log
[i
].data
, 0, MPT3_EVENT_DATA_SIZE
);
367 memcpy(event_log
[i
].data
, mpi_reply
->EventData
, sz
);
371 /* This aen_event_read_flag flag is set until the
372 * application has read the event log.
373 * For MPI2_EVENT_LOG_ENTRY_ADDED, we always notify.
375 if (event
== MPI2_EVENT_LOG_ENTRY_ADDED
||
376 (send_aen
&& !ioc
->aen_event_read_flag
)) {
377 ioc
->aen_event_read_flag
= 1;
378 wake_up_interruptible(&ctl_poll_wait
);
380 kill_fasync(&async_queue
, SIGIO
, POLL_IN
);
385 * mpt3sas_ctl_event_callback - firmware event handler (called at ISR time)
386 * @ioc: per adapter object
387 * @msix_index: MSIX table index supplied by the OS
388 * @reply: reply message frame(lower 32bit addr)
389 * Context: interrupt.
391 * This function merely adds a new work task into ioc->firmware_event_thread.
392 * The tasks are worked from _firmware_event_work in user context.
394 * Return 1 meaning mf should be freed from _base_interrupt
395 * 0 means the mf is freed from this function.
398 mpt3sas_ctl_event_callback(struct MPT3SAS_ADAPTER
*ioc
, u8 msix_index
,
401 Mpi2EventNotificationReply_t
*mpi_reply
;
403 mpi_reply
= mpt3sas_base_get_reply_virt_addr(ioc
, reply
);
405 mpt3sas_ctl_add_to_event_log(ioc
, mpi_reply
);
410 * _ctl_verify_adapter - validates ioc_number passed from application
411 * @ioc: per adapter object
412 * @iocpp: The ioc pointer is returned in this.
413 * @mpi_version: will be MPI2_VERSION for mpt2ctl ioctl device &
414 * MPI25_VERSION | MPI26_VERSION for mpt3ctl ioctl device.
416 * Return (-1) means error, else ioc_number.
419 _ctl_verify_adapter(int ioc_number
, struct MPT3SAS_ADAPTER
**iocpp
,
422 struct MPT3SAS_ADAPTER
*ioc
;
424 /* global ioc lock to protect controller on list operations */
425 spin_lock(&gioc_lock
);
426 list_for_each_entry(ioc
, &mpt3sas_ioc_list
, list
) {
427 if (ioc
->id
!= ioc_number
)
429 /* Check whether this ioctl command is from right
430 * ioctl device or not, if not continue the search.
432 version
= ioc
->hba_mpi_version_belonged
;
433 /* MPI25_VERSION and MPI26_VERSION uses same ioctl
436 if (mpi_version
== (MPI25_VERSION
| MPI26_VERSION
)) {
437 if ((version
== MPI25_VERSION
) ||
438 (version
== MPI26_VERSION
))
443 if (version
!= mpi_version
)
447 spin_unlock(&gioc_lock
);
451 spin_unlock(&gioc_lock
);
457 * mpt3sas_ctl_reset_handler - reset callback handler (for ctl)
458 * @ioc: per adapter object
459 * @reset_phase: phase
461 * The handler for doing any required cleanup or initialization.
463 * The reset phase can be MPT3_IOC_PRE_RESET, MPT3_IOC_AFTER_RESET,
464 * MPT3_IOC_DONE_RESET
467 mpt3sas_ctl_reset_handler(struct MPT3SAS_ADAPTER
*ioc
, int reset_phase
)
472 switch (reset_phase
) {
473 case MPT3_IOC_PRE_RESET
:
474 dtmprintk(ioc
, pr_info(MPT3SAS_FMT
475 "%s: MPT3_IOC_PRE_RESET\n", ioc
->name
, __func__
));
476 for (i
= 0; i
< MPI2_DIAG_BUF_TYPE_COUNT
; i
++) {
477 if (!(ioc
->diag_buffer_status
[i
] &
478 MPT3_DIAG_BUFFER_IS_REGISTERED
))
480 if ((ioc
->diag_buffer_status
[i
] &
481 MPT3_DIAG_BUFFER_IS_RELEASED
))
483 mpt3sas_send_diag_release(ioc
, i
, &issue_reset
);
486 case MPT3_IOC_AFTER_RESET
:
487 dtmprintk(ioc
, pr_info(MPT3SAS_FMT
488 "%s: MPT3_IOC_AFTER_RESET\n", ioc
->name
, __func__
));
489 if (ioc
->ctl_cmds
.status
& MPT3_CMD_PENDING
) {
490 ioc
->ctl_cmds
.status
|= MPT3_CMD_RESET
;
491 mpt3sas_base_free_smid(ioc
, ioc
->ctl_cmds
.smid
);
492 complete(&ioc
->ctl_cmds
.done
);
495 case MPT3_IOC_DONE_RESET
:
496 dtmprintk(ioc
, pr_info(MPT3SAS_FMT
497 "%s: MPT3_IOC_DONE_RESET\n", ioc
->name
, __func__
));
499 for (i
= 0; i
< MPI2_DIAG_BUF_TYPE_COUNT
; i
++) {
500 if (!(ioc
->diag_buffer_status
[i
] &
501 MPT3_DIAG_BUFFER_IS_REGISTERED
))
503 if ((ioc
->diag_buffer_status
[i
] &
504 MPT3_DIAG_BUFFER_IS_RELEASED
))
506 ioc
->diag_buffer_status
[i
] |=
507 MPT3_DIAG_BUFFER_IS_DIAG_RESET
;
519 * Called when application request fasyn callback handler.
522 _ctl_fasync(int fd
, struct file
*filep
, int mode
)
524 return fasync_helper(fd
, filep
, mode
, &async_queue
);
534 _ctl_poll(struct file
*filep
, poll_table
*wait
)
536 struct MPT3SAS_ADAPTER
*ioc
;
538 poll_wait(filep
, &ctl_poll_wait
, wait
);
540 /* global ioc lock to protect controller on list operations */
541 spin_lock(&gioc_lock
);
542 list_for_each_entry(ioc
, &mpt3sas_ioc_list
, list
) {
543 if (ioc
->aen_event_read_flag
) {
544 spin_unlock(&gioc_lock
);
545 return POLLIN
| POLLRDNORM
;
548 spin_unlock(&gioc_lock
);
553 * _ctl_set_task_mid - assign an active smid to tm request
554 * @ioc: per adapter object
555 * @karg - (struct mpt3_ioctl_command)
556 * @tm_request - pointer to mf from user space
558 * Returns 0 when an smid if found, else fail.
559 * during failure, the reply frame is filled.
562 _ctl_set_task_mid(struct MPT3SAS_ADAPTER
*ioc
, struct mpt3_ioctl_command
*karg
,
563 Mpi2SCSITaskManagementRequest_t
*tm_request
)
568 struct scsi_cmnd
*scmd
;
569 struct MPT3SAS_DEVICE
*priv_data
;
571 Mpi2SCSITaskManagementReply_t
*tm_reply
;
576 if (tm_request
->TaskType
== MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK
)
578 else if (tm_request
->TaskType
== MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK
)
583 lun
= scsilun_to_int((struct scsi_lun
*)tm_request
->LUN
);
585 handle
= le16_to_cpu(tm_request
->DevHandle
);
586 spin_lock_irqsave(&ioc
->scsi_lookup_lock
, flags
);
587 for (i
= ioc
->scsiio_depth
; i
&& !found
; i
--) {
588 scmd
= ioc
->scsi_lookup
[i
- 1].scmd
;
589 if (scmd
== NULL
|| scmd
->device
== NULL
||
590 scmd
->device
->hostdata
== NULL
)
592 if (lun
!= scmd
->device
->lun
)
594 priv_data
= scmd
->device
->hostdata
;
595 if (priv_data
->sas_target
== NULL
)
597 if (priv_data
->sas_target
->handle
!= handle
)
599 tm_request
->TaskMID
= cpu_to_le16(ioc
->scsi_lookup
[i
- 1].smid
);
602 spin_unlock_irqrestore(&ioc
->scsi_lookup_lock
, flags
);
605 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
606 "%s: handle(0x%04x), lun(%d), no active mid!!\n",
608 desc
, le16_to_cpu(tm_request
->DevHandle
), lun
));
609 tm_reply
= ioc
->ctl_cmds
.reply
;
610 tm_reply
->DevHandle
= tm_request
->DevHandle
;
611 tm_reply
->Function
= MPI2_FUNCTION_SCSI_TASK_MGMT
;
612 tm_reply
->TaskType
= tm_request
->TaskType
;
613 tm_reply
->MsgLength
= sizeof(Mpi2SCSITaskManagementReply_t
)/4;
614 tm_reply
->VP_ID
= tm_request
->VP_ID
;
615 tm_reply
->VF_ID
= tm_request
->VF_ID
;
616 sz
= min_t(u32
, karg
->max_reply_bytes
, ioc
->reply_sz
);
617 if (copy_to_user(karg
->reply_frame_buf_ptr
, ioc
->ctl_cmds
.reply
,
619 pr_err("failure at %s:%d/%s()!\n", __FILE__
,
624 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
625 "%s: handle(0x%04x), lun(%d), task_mid(%d)\n", ioc
->name
,
626 desc
, le16_to_cpu(tm_request
->DevHandle
), lun
,
627 le16_to_cpu(tm_request
->TaskMID
)));
632 * _ctl_do_mpt_command - main handler for MPT3COMMAND opcode
633 * @ioc: per adapter object
634 * @karg - (struct mpt3_ioctl_command)
635 * @mf - pointer to mf in user space
638 _ctl_do_mpt_command(struct MPT3SAS_ADAPTER
*ioc
, struct mpt3_ioctl_command karg
,
641 MPI2RequestHeader_t
*mpi_request
= NULL
, *request
;
642 MPI2DefaultReply_t
*mpi_reply
;
645 unsigned long timeout
;
649 void *data_out
= NULL
;
650 dma_addr_t data_out_dma
= 0;
651 size_t data_out_sz
= 0;
652 void *data_in
= NULL
;
653 dma_addr_t data_in_dma
= 0;
654 size_t data_in_sz
= 0;
656 u16 wait_state_count
;
657 u16 device_handle
= MPT3SAS_INVALID_DEVICE_HANDLE
;
661 if (ioc
->ctl_cmds
.status
!= MPT3_CMD_NOT_USED
) {
662 pr_err(MPT3SAS_FMT
"%s: ctl_cmd in use\n",
663 ioc
->name
, __func__
);
668 wait_state_count
= 0;
669 ioc_state
= mpt3sas_base_get_iocstate(ioc
, 1);
670 while (ioc_state
!= MPI2_IOC_STATE_OPERATIONAL
) {
671 if (wait_state_count
++ == 10) {
673 "%s: failed due to ioc not operational\n",
674 ioc
->name
, __func__
);
679 ioc_state
= mpt3sas_base_get_iocstate(ioc
, 1);
681 "%s: waiting for operational state(count=%d)\n",
683 __func__
, wait_state_count
);
685 if (wait_state_count
)
686 pr_info(MPT3SAS_FMT
"%s: ioc is operational\n",
687 ioc
->name
, __func__
);
689 mpi_request
= kzalloc(ioc
->request_sz
, GFP_KERNEL
);
692 "%s: failed obtaining a memory for mpi_request\n",
693 ioc
->name
, __func__
);
698 /* Check for overflow and wraparound */
699 if (karg
.data_sge_offset
* 4 > ioc
->request_sz
||
700 karg
.data_sge_offset
> (UINT_MAX
/ 4)) {
705 /* copy in request message frame from user */
706 if (copy_from_user(mpi_request
, mf
, karg
.data_sge_offset
*4)) {
707 pr_err("failure at %s:%d/%s()!\n", __FILE__
, __LINE__
,
713 if (mpi_request
->Function
== MPI2_FUNCTION_SCSI_TASK_MGMT
) {
714 smid
= mpt3sas_base_get_smid_hpr(ioc
, ioc
->ctl_cb_idx
);
716 pr_err(MPT3SAS_FMT
"%s: failed obtaining a smid\n",
717 ioc
->name
, __func__
);
723 smid
= mpt3sas_base_get_smid_scsiio(ioc
, ioc
->ctl_cb_idx
, NULL
);
725 pr_err(MPT3SAS_FMT
"%s: failed obtaining a smid\n",
726 ioc
->name
, __func__
);
733 ioc
->ctl_cmds
.status
= MPT3_CMD_PENDING
;
734 memset(ioc
->ctl_cmds
.reply
, 0, ioc
->reply_sz
);
735 request
= mpt3sas_base_get_msg_frame(ioc
, smid
);
736 memcpy(request
, mpi_request
, karg
.data_sge_offset
*4);
737 ioc
->ctl_cmds
.smid
= smid
;
738 data_out_sz
= karg
.data_out_size
;
739 data_in_sz
= karg
.data_in_size
;
741 if (mpi_request
->Function
== MPI2_FUNCTION_SCSI_IO_REQUEST
||
742 mpi_request
->Function
== MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
||
743 mpi_request
->Function
== MPI2_FUNCTION_SCSI_TASK_MGMT
||
744 mpi_request
->Function
== MPI2_FUNCTION_SATA_PASSTHROUGH
) {
746 device_handle
= le16_to_cpu(mpi_request
->FunctionDependent1
);
747 if (!device_handle
|| (device_handle
>
748 ioc
->facts
.MaxDevHandle
)) {
750 mpt3sas_base_free_smid(ioc
, smid
);
755 /* obtain dma-able memory for data transfer */
756 if (data_out_sz
) /* WRITE */ {
757 data_out
= pci_alloc_consistent(ioc
->pdev
, data_out_sz
,
760 pr_err("failure at %s:%d/%s()!\n", __FILE__
,
763 mpt3sas_base_free_smid(ioc
, smid
);
766 if (copy_from_user(data_out
, karg
.data_out_buf_ptr
,
768 pr_err("failure at %s:%d/%s()!\n", __FILE__
,
771 mpt3sas_base_free_smid(ioc
, smid
);
776 if (data_in_sz
) /* READ */ {
777 data_in
= pci_alloc_consistent(ioc
->pdev
, data_in_sz
,
780 pr_err("failure at %s:%d/%s()!\n", __FILE__
,
783 mpt3sas_base_free_smid(ioc
, smid
);
788 psge
= (void *)request
+ (karg
.data_sge_offset
*4);
790 /* send command to firmware */
791 _ctl_display_some_debug(ioc
, smid
, "ctl_request", NULL
);
793 init_completion(&ioc
->ctl_cmds
.done
);
794 switch (mpi_request
->Function
) {
795 case MPI2_FUNCTION_SCSI_IO_REQUEST
:
796 case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
:
798 Mpi2SCSIIORequest_t
*scsiio_request
=
799 (Mpi2SCSIIORequest_t
*)request
;
800 scsiio_request
->SenseBufferLength
= SCSI_SENSE_BUFFERSIZE
;
801 scsiio_request
->SenseBufferLowAddress
=
802 mpt3sas_base_get_sense_buffer_dma(ioc
, smid
);
803 memset(ioc
->ctl_cmds
.sense
, 0, SCSI_SENSE_BUFFERSIZE
);
804 if (test_bit(device_handle
, ioc
->device_remove_in_progress
)) {
805 dtmprintk(ioc
, pr_info(MPT3SAS_FMT
806 "handle(0x%04x) :ioctl failed due to device removal in progress\n",
807 ioc
->name
, device_handle
));
808 mpt3sas_base_free_smid(ioc
, smid
);
812 ioc
->build_sg(ioc
, psge
, data_out_dma
, data_out_sz
,
813 data_in_dma
, data_in_sz
);
814 if (mpi_request
->Function
== MPI2_FUNCTION_SCSI_IO_REQUEST
)
815 ioc
->put_smid_scsi_io(ioc
, smid
, device_handle
);
817 ioc
->put_smid_default(ioc
, smid
);
820 case MPI2_FUNCTION_SCSI_TASK_MGMT
:
822 Mpi2SCSITaskManagementRequest_t
*tm_request
=
823 (Mpi2SCSITaskManagementRequest_t
*)request
;
825 dtmprintk(ioc
, pr_info(MPT3SAS_FMT
826 "TASK_MGMT: handle(0x%04x), task_type(0x%02x)\n",
828 le16_to_cpu(tm_request
->DevHandle
), tm_request
->TaskType
));
830 if (tm_request
->TaskType
==
831 MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK
||
832 tm_request
->TaskType
==
833 MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK
) {
834 if (_ctl_set_task_mid(ioc
, &karg
, tm_request
)) {
835 mpt3sas_base_free_smid(ioc
, smid
);
840 if (test_bit(device_handle
, ioc
->device_remove_in_progress
)) {
841 dtmprintk(ioc
, pr_info(MPT3SAS_FMT
842 "handle(0x%04x) :ioctl failed due to device removal in progress\n",
843 ioc
->name
, device_handle
));
844 mpt3sas_base_free_smid(ioc
, smid
);
848 mpt3sas_scsih_set_tm_flag(ioc
, le16_to_cpu(
849 tm_request
->DevHandle
));
850 ioc
->build_sg_mpi(ioc
, psge
, data_out_dma
, data_out_sz
,
851 data_in_dma
, data_in_sz
);
852 ioc
->put_smid_hi_priority(ioc
, smid
, 0);
855 case MPI2_FUNCTION_SMP_PASSTHROUGH
:
857 Mpi2SmpPassthroughRequest_t
*smp_request
=
858 (Mpi2SmpPassthroughRequest_t
*)mpi_request
;
861 /* ioc determines which port to use */
862 smp_request
->PhysicalPort
= 0xFF;
863 if (smp_request
->PassthroughFlags
&
864 MPI2_SMP_PT_REQ_PT_FLAGS_IMMEDIATE
)
865 data
= (u8
*)&smp_request
->SGL
;
867 if (unlikely(data_out
== NULL
)) {
868 pr_err("failure at %s:%d/%s()!\n",
869 __FILE__
, __LINE__
, __func__
);
870 mpt3sas_base_free_smid(ioc
, smid
);
877 if (data
[1] == 0x91 && (data
[10] == 1 || data
[10] == 2)) {
878 ioc
->ioc_link_reset_in_progress
= 1;
879 ioc
->ignore_loginfos
= 1;
881 ioc
->build_sg(ioc
, psge
, data_out_dma
, data_out_sz
, data_in_dma
,
883 ioc
->put_smid_default(ioc
, smid
);
886 case MPI2_FUNCTION_SATA_PASSTHROUGH
:
888 if (test_bit(device_handle
, ioc
->device_remove_in_progress
)) {
889 dtmprintk(ioc
, pr_info(MPT3SAS_FMT
890 "handle(0x%04x) :ioctl failed due to device removal in progress\n",
891 ioc
->name
, device_handle
));
892 mpt3sas_base_free_smid(ioc
, smid
);
896 ioc
->build_sg(ioc
, psge
, data_out_dma
, data_out_sz
, data_in_dma
,
898 ioc
->put_smid_default(ioc
, smid
);
901 case MPI2_FUNCTION_FW_DOWNLOAD
:
902 case MPI2_FUNCTION_FW_UPLOAD
:
904 ioc
->build_sg(ioc
, psge
, data_out_dma
, data_out_sz
, data_in_dma
,
906 ioc
->put_smid_default(ioc
, smid
);
909 case MPI2_FUNCTION_TOOLBOX
:
911 Mpi2ToolboxCleanRequest_t
*toolbox_request
=
912 (Mpi2ToolboxCleanRequest_t
*)mpi_request
;
914 if (toolbox_request
->Tool
== MPI2_TOOLBOX_DIAGNOSTIC_CLI_TOOL
) {
915 ioc
->build_sg(ioc
, psge
, data_out_dma
, data_out_sz
,
916 data_in_dma
, data_in_sz
);
918 ioc
->build_sg_mpi(ioc
, psge
, data_out_dma
, data_out_sz
,
919 data_in_dma
, data_in_sz
);
921 ioc
->put_smid_default(ioc
, smid
);
924 case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL
:
926 Mpi2SasIoUnitControlRequest_t
*sasiounit_request
=
927 (Mpi2SasIoUnitControlRequest_t
*)mpi_request
;
929 if (sasiounit_request
->Operation
== MPI2_SAS_OP_PHY_HARD_RESET
930 || sasiounit_request
->Operation
==
931 MPI2_SAS_OP_PHY_LINK_RESET
) {
932 ioc
->ioc_link_reset_in_progress
= 1;
933 ioc
->ignore_loginfos
= 1;
935 /* drop to default case for posting the request */
938 ioc
->build_sg_mpi(ioc
, psge
, data_out_dma
, data_out_sz
,
939 data_in_dma
, data_in_sz
);
940 ioc
->put_smid_default(ioc
, smid
);
944 if (karg
.timeout
< MPT3_IOCTL_DEFAULT_TIMEOUT
)
945 timeout
= MPT3_IOCTL_DEFAULT_TIMEOUT
;
947 timeout
= karg
.timeout
;
948 wait_for_completion_timeout(&ioc
->ctl_cmds
.done
, timeout
*HZ
);
949 if (mpi_request
->Function
== MPI2_FUNCTION_SCSI_TASK_MGMT
) {
950 Mpi2SCSITaskManagementRequest_t
*tm_request
=
951 (Mpi2SCSITaskManagementRequest_t
*)mpi_request
;
952 mpt3sas_scsih_clear_tm_flag(ioc
, le16_to_cpu(
953 tm_request
->DevHandle
));
954 mpt3sas_trigger_master(ioc
, MASTER_TRIGGER_TASK_MANAGMENT
);
955 } else if ((mpi_request
->Function
== MPI2_FUNCTION_SMP_PASSTHROUGH
||
956 mpi_request
->Function
== MPI2_FUNCTION_SAS_IO_UNIT_CONTROL
) &&
957 ioc
->ioc_link_reset_in_progress
) {
958 ioc
->ioc_link_reset_in_progress
= 0;
959 ioc
->ignore_loginfos
= 0;
961 if (!(ioc
->ctl_cmds
.status
& MPT3_CMD_COMPLETE
)) {
962 pr_err(MPT3SAS_FMT
"%s: timeout\n", ioc
->name
,
964 _debug_dump_mf(mpi_request
, karg
.data_sge_offset
);
965 if (!(ioc
->ctl_cmds
.status
& MPT3_CMD_RESET
))
967 goto issue_host_reset
;
970 mpi_reply
= ioc
->ctl_cmds
.reply
;
972 if (mpi_reply
->Function
== MPI2_FUNCTION_SCSI_TASK_MGMT
&&
973 (ioc
->logging_level
& MPT_DEBUG_TM
)) {
974 Mpi2SCSITaskManagementReply_t
*tm_reply
=
975 (Mpi2SCSITaskManagementReply_t
*)mpi_reply
;
977 pr_info(MPT3SAS_FMT
"TASK_MGMT: " \
978 "IOCStatus(0x%04x), IOCLogInfo(0x%08x), "
979 "TerminationCount(0x%08x)\n", ioc
->name
,
980 le16_to_cpu(tm_reply
->IOCStatus
),
981 le32_to_cpu(tm_reply
->IOCLogInfo
),
982 le32_to_cpu(tm_reply
->TerminationCount
));
985 /* copy out xdata to user */
987 if (copy_to_user(karg
.data_in_buf_ptr
, data_in
,
989 pr_err("failure at %s:%d/%s()!\n", __FILE__
,
996 /* copy out reply message frame to user */
997 if (karg
.max_reply_bytes
) {
998 sz
= min_t(u32
, karg
.max_reply_bytes
, ioc
->reply_sz
);
999 if (copy_to_user(karg
.reply_frame_buf_ptr
, ioc
->ctl_cmds
.reply
,
1001 pr_err("failure at %s:%d/%s()!\n", __FILE__
,
1002 __LINE__
, __func__
);
1008 /* copy out sense to user */
1009 if (karg
.max_sense_bytes
&& (mpi_request
->Function
==
1010 MPI2_FUNCTION_SCSI_IO_REQUEST
|| mpi_request
->Function
==
1011 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
)) {
1012 sz
= min_t(u32
, karg
.max_sense_bytes
, SCSI_SENSE_BUFFERSIZE
);
1013 if (copy_to_user(karg
.sense_data_ptr
, ioc
->ctl_cmds
.sense
,
1015 pr_err("failure at %s:%d/%s()!\n", __FILE__
,
1016 __LINE__
, __func__
);
1025 if ((mpi_request
->Function
== MPI2_FUNCTION_SCSI_IO_REQUEST
||
1026 mpi_request
->Function
==
1027 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
||
1028 mpi_request
->Function
== MPI2_FUNCTION_SATA_PASSTHROUGH
)) {
1029 pr_info(MPT3SAS_FMT
"issue target reset: handle = (0x%04x)\n",
1031 le16_to_cpu(mpi_request
->FunctionDependent1
));
1032 mpt3sas_halt_firmware(ioc
);
1033 mpt3sas_scsih_issue_locked_tm(ioc
,
1034 le16_to_cpu(mpi_request
->FunctionDependent1
), 0, 0,
1035 0, MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET
, 0, 30);
1037 mpt3sas_base_hard_reset_handler(ioc
, FORCE_BIG_HAMMER
);
1042 /* free memory associated with sg buffers */
1044 pci_free_consistent(ioc
->pdev
, data_in_sz
, data_in
,
1048 pci_free_consistent(ioc
->pdev
, data_out_sz
, data_out
,
1052 ioc
->ctl_cmds
.status
= MPT3_CMD_NOT_USED
;
1057 * _ctl_getiocinfo - main handler for MPT3IOCINFO opcode
1058 * @ioc: per adapter object
1059 * @arg - user space buffer containing ioctl content
1062 _ctl_getiocinfo(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1064 struct mpt3_ioctl_iocinfo karg
;
1066 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1067 pr_err("failure at %s:%d/%s()!\n",
1068 __FILE__
, __LINE__
, __func__
);
1072 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s: enter\n", ioc
->name
,
1075 memset(&karg
, 0 , sizeof(karg
));
1077 karg
.port_number
= ioc
->pfacts
[0].PortNumber
;
1078 karg
.hw_rev
= ioc
->pdev
->revision
;
1079 karg
.pci_id
= ioc
->pdev
->device
;
1080 karg
.subsystem_device
= ioc
->pdev
->subsystem_device
;
1081 karg
.subsystem_vendor
= ioc
->pdev
->subsystem_vendor
;
1082 karg
.pci_information
.u
.bits
.bus
= ioc
->pdev
->bus
->number
;
1083 karg
.pci_information
.u
.bits
.device
= PCI_SLOT(ioc
->pdev
->devfn
);
1084 karg
.pci_information
.u
.bits
.function
= PCI_FUNC(ioc
->pdev
->devfn
);
1085 karg
.pci_information
.segment_id
= pci_domain_nr(ioc
->pdev
->bus
);
1086 karg
.firmware_version
= ioc
->facts
.FWVersion
.Word
;
1087 strcpy(karg
.driver_version
, ioc
->driver_name
);
1088 strcat(karg
.driver_version
, "-");
1089 switch (ioc
->hba_mpi_version_belonged
) {
1091 if (ioc
->is_warpdrive
)
1092 karg
.adapter_type
= MPT2_IOCTL_INTERFACE_SAS2_SSS6200
;
1094 karg
.adapter_type
= MPT2_IOCTL_INTERFACE_SAS2
;
1095 strcat(karg
.driver_version
, MPT2SAS_DRIVER_VERSION
);
1099 if (ioc
->is_gen35_ioc
)
1100 karg
.adapter_type
= MPT3_IOCTL_INTERFACE_SAS35
;
1102 karg
.adapter_type
= MPT3_IOCTL_INTERFACE_SAS3
;
1103 strcat(karg
.driver_version
, MPT3SAS_DRIVER_VERSION
);
1106 karg
.bios_version
= le32_to_cpu(ioc
->bios_pg3
.BiosVersion
);
1108 if (copy_to_user(arg
, &karg
, sizeof(karg
))) {
1109 pr_err("failure at %s:%d/%s()!\n",
1110 __FILE__
, __LINE__
, __func__
);
1117 * _ctl_eventquery - main handler for MPT3EVENTQUERY opcode
1118 * @ioc: per adapter object
1119 * @arg - user space buffer containing ioctl content
1122 _ctl_eventquery(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1124 struct mpt3_ioctl_eventquery karg
;
1126 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1127 pr_err("failure at %s:%d/%s()!\n",
1128 __FILE__
, __LINE__
, __func__
);
1132 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s: enter\n", ioc
->name
,
1135 karg
.event_entries
= MPT3SAS_CTL_EVENT_LOG_SIZE
;
1136 memcpy(karg
.event_types
, ioc
->event_type
,
1137 MPI2_EVENT_NOTIFY_EVENTMASK_WORDS
* sizeof(u32
));
1139 if (copy_to_user(arg
, &karg
, sizeof(karg
))) {
1140 pr_err("failure at %s:%d/%s()!\n",
1141 __FILE__
, __LINE__
, __func__
);
1148 * _ctl_eventenable - main handler for MPT3EVENTENABLE opcode
1149 * @ioc: per adapter object
1150 * @arg - user space buffer containing ioctl content
1153 _ctl_eventenable(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1155 struct mpt3_ioctl_eventenable karg
;
1157 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1158 pr_err("failure at %s:%d/%s()!\n",
1159 __FILE__
, __LINE__
, __func__
);
1163 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s: enter\n", ioc
->name
,
1166 memcpy(ioc
->event_type
, karg
.event_types
,
1167 MPI2_EVENT_NOTIFY_EVENTMASK_WORDS
* sizeof(u32
));
1168 mpt3sas_base_validate_event_type(ioc
, ioc
->event_type
);
1172 /* initialize event_log */
1173 ioc
->event_context
= 0;
1174 ioc
->aen_event_read_flag
= 0;
1175 ioc
->event_log
= kcalloc(MPT3SAS_CTL_EVENT_LOG_SIZE
,
1176 sizeof(struct MPT3_IOCTL_EVENTS
), GFP_KERNEL
);
1177 if (!ioc
->event_log
) {
1178 pr_err("failure at %s:%d/%s()!\n",
1179 __FILE__
, __LINE__
, __func__
);
1186 * _ctl_eventreport - main handler for MPT3EVENTREPORT opcode
1187 * @ioc: per adapter object
1188 * @arg - user space buffer containing ioctl content
1191 _ctl_eventreport(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1193 struct mpt3_ioctl_eventreport karg
;
1194 u32 number_bytes
, max_events
, max
;
1195 struct mpt3_ioctl_eventreport __user
*uarg
= arg
;
1197 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1198 pr_err("failure at %s:%d/%s()!\n",
1199 __FILE__
, __LINE__
, __func__
);
1203 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s: enter\n", ioc
->name
,
1206 number_bytes
= karg
.hdr
.max_data_size
-
1207 sizeof(struct mpt3_ioctl_header
);
1208 max_events
= number_bytes
/sizeof(struct MPT3_IOCTL_EVENTS
);
1209 max
= min_t(u32
, MPT3SAS_CTL_EVENT_LOG_SIZE
, max_events
);
1211 /* If fewer than 1 event is requested, there must have
1212 * been some type of error.
1214 if (!max
|| !ioc
->event_log
)
1217 number_bytes
= max
* sizeof(struct MPT3_IOCTL_EVENTS
);
1218 if (copy_to_user(uarg
->event_data
, ioc
->event_log
, number_bytes
)) {
1219 pr_err("failure at %s:%d/%s()!\n",
1220 __FILE__
, __LINE__
, __func__
);
1224 /* reset flag so SIGIO can restart */
1225 ioc
->aen_event_read_flag
= 0;
1230 * _ctl_do_reset - main handler for MPT3HARDRESET opcode
1231 * @ioc: per adapter object
1232 * @arg - user space buffer containing ioctl content
1235 _ctl_do_reset(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1237 struct mpt3_ioctl_diag_reset karg
;
1240 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1241 pr_err("failure at %s:%d/%s()!\n",
1242 __FILE__
, __LINE__
, __func__
);
1246 if (ioc
->shost_recovery
|| ioc
->pci_error_recovery
||
1247 ioc
->is_driver_loading
)
1250 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s: enter\n", ioc
->name
,
1253 retval
= mpt3sas_base_hard_reset_handler(ioc
, FORCE_BIG_HAMMER
);
1254 pr_info(MPT3SAS_FMT
"host reset: %s\n",
1255 ioc
->name
, ((!retval
) ? "SUCCESS" : "FAILED"));
1260 * _ctl_btdh_search_sas_device - searching for sas device
1261 * @ioc: per adapter object
1262 * @btdh: btdh ioctl payload
1265 _ctl_btdh_search_sas_device(struct MPT3SAS_ADAPTER
*ioc
,
1266 struct mpt3_ioctl_btdh_mapping
*btdh
)
1268 struct _sas_device
*sas_device
;
1269 unsigned long flags
;
1272 if (list_empty(&ioc
->sas_device_list
))
1275 spin_lock_irqsave(&ioc
->sas_device_lock
, flags
);
1276 list_for_each_entry(sas_device
, &ioc
->sas_device_list
, list
) {
1277 if (btdh
->bus
== 0xFFFFFFFF && btdh
->id
== 0xFFFFFFFF &&
1278 btdh
->handle
== sas_device
->handle
) {
1279 btdh
->bus
= sas_device
->channel
;
1280 btdh
->id
= sas_device
->id
;
1283 } else if (btdh
->bus
== sas_device
->channel
&& btdh
->id
==
1284 sas_device
->id
&& btdh
->handle
== 0xFFFF) {
1285 btdh
->handle
= sas_device
->handle
;
1291 spin_unlock_irqrestore(&ioc
->sas_device_lock
, flags
);
1296 * _ctl_btdh_search_raid_device - searching for raid device
1297 * @ioc: per adapter object
1298 * @btdh: btdh ioctl payload
1301 _ctl_btdh_search_raid_device(struct MPT3SAS_ADAPTER
*ioc
,
1302 struct mpt3_ioctl_btdh_mapping
*btdh
)
1304 struct _raid_device
*raid_device
;
1305 unsigned long flags
;
1308 if (list_empty(&ioc
->raid_device_list
))
1311 spin_lock_irqsave(&ioc
->raid_device_lock
, flags
);
1312 list_for_each_entry(raid_device
, &ioc
->raid_device_list
, list
) {
1313 if (btdh
->bus
== 0xFFFFFFFF && btdh
->id
== 0xFFFFFFFF &&
1314 btdh
->handle
== raid_device
->handle
) {
1315 btdh
->bus
= raid_device
->channel
;
1316 btdh
->id
= raid_device
->id
;
1319 } else if (btdh
->bus
== raid_device
->channel
&& btdh
->id
==
1320 raid_device
->id
&& btdh
->handle
== 0xFFFF) {
1321 btdh
->handle
= raid_device
->handle
;
1327 spin_unlock_irqrestore(&ioc
->raid_device_lock
, flags
);
1332 * _ctl_btdh_mapping - main handler for MPT3BTDHMAPPING opcode
1333 * @ioc: per adapter object
1334 * @arg - user space buffer containing ioctl content
1337 _ctl_btdh_mapping(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1339 struct mpt3_ioctl_btdh_mapping karg
;
1342 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1343 pr_err("failure at %s:%d/%s()!\n",
1344 __FILE__
, __LINE__
, __func__
);
1348 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s\n", ioc
->name
,
1351 rc
= _ctl_btdh_search_sas_device(ioc
, &karg
);
1353 _ctl_btdh_search_raid_device(ioc
, &karg
);
1355 if (copy_to_user(arg
, &karg
, sizeof(karg
))) {
1356 pr_err("failure at %s:%d/%s()!\n",
1357 __FILE__
, __LINE__
, __func__
);
1364 * _ctl_diag_capability - return diag buffer capability
1365 * @ioc: per adapter object
1366 * @buffer_type: specifies either TRACE, SNAPSHOT, or EXTENDED
1368 * returns 1 when diag buffer support is enabled in firmware
1371 _ctl_diag_capability(struct MPT3SAS_ADAPTER
*ioc
, u8 buffer_type
)
1375 switch (buffer_type
) {
1376 case MPI2_DIAG_BUF_TYPE_TRACE
:
1377 if (ioc
->facts
.IOCCapabilities
&
1378 MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER
)
1381 case MPI2_DIAG_BUF_TYPE_SNAPSHOT
:
1382 if (ioc
->facts
.IOCCapabilities
&
1383 MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER
)
1386 case MPI2_DIAG_BUF_TYPE_EXTENDED
:
1387 if (ioc
->facts
.IOCCapabilities
&
1388 MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER
)
1397 * _ctl_diag_register_2 - wrapper for registering diag buffer support
1398 * @ioc: per adapter object
1399 * @diag_register: the diag_register struct passed in from user space
1403 _ctl_diag_register_2(struct MPT3SAS_ADAPTER
*ioc
,
1404 struct mpt3_diag_register
*diag_register
)
1407 void *request_data
= NULL
;
1408 dma_addr_t request_data_dma
;
1409 u32 request_data_sz
= 0;
1410 Mpi2DiagBufferPostRequest_t
*mpi_request
;
1411 Mpi2DiagBufferPostReply_t
*mpi_reply
;
1418 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s\n", ioc
->name
,
1421 ioc_state
= mpt3sas_base_get_iocstate(ioc
, 1);
1422 if (ioc_state
!= MPI2_IOC_STATE_OPERATIONAL
) {
1424 "%s: failed due to ioc not operational\n",
1425 ioc
->name
, __func__
);
1430 if (ioc
->ctl_cmds
.status
!= MPT3_CMD_NOT_USED
) {
1431 pr_err(MPT3SAS_FMT
"%s: ctl_cmd in use\n",
1432 ioc
->name
, __func__
);
1437 buffer_type
= diag_register
->buffer_type
;
1438 if (!_ctl_diag_capability(ioc
, buffer_type
)) {
1440 "%s: doesn't have capability for buffer_type(0x%02x)\n",
1441 ioc
->name
, __func__
, buffer_type
);
1445 if (ioc
->diag_buffer_status
[buffer_type
] &
1446 MPT3_DIAG_BUFFER_IS_REGISTERED
) {
1448 "%s: already has a registered buffer for buffer_type(0x%02x)\n",
1449 ioc
->name
, __func__
,
1454 if (diag_register
->requested_buffer_size
% 4) {
1456 "%s: the requested_buffer_size is not 4 byte aligned\n",
1457 ioc
->name
, __func__
);
1461 smid
= mpt3sas_base_get_smid(ioc
, ioc
->ctl_cb_idx
);
1463 pr_err(MPT3SAS_FMT
"%s: failed obtaining a smid\n",
1464 ioc
->name
, __func__
);
1470 ioc
->ctl_cmds
.status
= MPT3_CMD_PENDING
;
1471 memset(ioc
->ctl_cmds
.reply
, 0, ioc
->reply_sz
);
1472 mpi_request
= mpt3sas_base_get_msg_frame(ioc
, smid
);
1473 ioc
->ctl_cmds
.smid
= smid
;
1475 request_data
= ioc
->diag_buffer
[buffer_type
];
1476 request_data_sz
= diag_register
->requested_buffer_size
;
1477 ioc
->unique_id
[buffer_type
] = diag_register
->unique_id
;
1478 ioc
->diag_buffer_status
[buffer_type
] = 0;
1479 memcpy(ioc
->product_specific
[buffer_type
],
1480 diag_register
->product_specific
, MPT3_PRODUCT_SPECIFIC_DWORDS
);
1481 ioc
->diagnostic_flags
[buffer_type
] = diag_register
->diagnostic_flags
;
1484 request_data_dma
= ioc
->diag_buffer_dma
[buffer_type
];
1485 if (request_data_sz
!= ioc
->diag_buffer_sz
[buffer_type
]) {
1486 pci_free_consistent(ioc
->pdev
,
1487 ioc
->diag_buffer_sz
[buffer_type
],
1488 request_data
, request_data_dma
);
1489 request_data
= NULL
;
1493 if (request_data
== NULL
) {
1494 ioc
->diag_buffer_sz
[buffer_type
] = 0;
1495 ioc
->diag_buffer_dma
[buffer_type
] = 0;
1496 request_data
= pci_alloc_consistent(
1497 ioc
->pdev
, request_data_sz
, &request_data_dma
);
1498 if (request_data
== NULL
) {
1499 pr_err(MPT3SAS_FMT
"%s: failed allocating memory" \
1500 " for diag buffers, requested size(%d)\n",
1501 ioc
->name
, __func__
, request_data_sz
);
1502 mpt3sas_base_free_smid(ioc
, smid
);
1505 ioc
->diag_buffer
[buffer_type
] = request_data
;
1506 ioc
->diag_buffer_sz
[buffer_type
] = request_data_sz
;
1507 ioc
->diag_buffer_dma
[buffer_type
] = request_data_dma
;
1510 mpi_request
->Function
= MPI2_FUNCTION_DIAG_BUFFER_POST
;
1511 mpi_request
->BufferType
= diag_register
->buffer_type
;
1512 mpi_request
->Flags
= cpu_to_le32(diag_register
->diagnostic_flags
);
1513 mpi_request
->BufferAddress
= cpu_to_le64(request_data_dma
);
1514 mpi_request
->BufferLength
= cpu_to_le32(request_data_sz
);
1515 mpi_request
->VF_ID
= 0; /* TODO */
1516 mpi_request
->VP_ID
= 0;
1518 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
1519 "%s: diag_buffer(0x%p), dma(0x%llx), sz(%d)\n",
1520 ioc
->name
, __func__
, request_data
,
1521 (unsigned long long)request_data_dma
,
1522 le32_to_cpu(mpi_request
->BufferLength
)));
1524 for (i
= 0; i
< MPT3_PRODUCT_SPECIFIC_DWORDS
; i
++)
1525 mpi_request
->ProductSpecific
[i
] =
1526 cpu_to_le32(ioc
->product_specific
[buffer_type
][i
]);
1528 init_completion(&ioc
->ctl_cmds
.done
);
1529 ioc
->put_smid_default(ioc
, smid
);
1530 wait_for_completion_timeout(&ioc
->ctl_cmds
.done
,
1531 MPT3_IOCTL_DEFAULT_TIMEOUT
*HZ
);
1533 if (!(ioc
->ctl_cmds
.status
& MPT3_CMD_COMPLETE
)) {
1534 pr_err(MPT3SAS_FMT
"%s: timeout\n", ioc
->name
,
1536 _debug_dump_mf(mpi_request
,
1537 sizeof(Mpi2DiagBufferPostRequest_t
)/4);
1538 if (!(ioc
->ctl_cmds
.status
& MPT3_CMD_RESET
))
1540 goto issue_host_reset
;
1543 /* process the completed Reply Message Frame */
1544 if ((ioc
->ctl_cmds
.status
& MPT3_CMD_REPLY_VALID
) == 0) {
1545 pr_err(MPT3SAS_FMT
"%s: no reply message\n",
1546 ioc
->name
, __func__
);
1551 mpi_reply
= ioc
->ctl_cmds
.reply
;
1552 ioc_status
= le16_to_cpu(mpi_reply
->IOCStatus
) & MPI2_IOCSTATUS_MASK
;
1554 if (ioc_status
== MPI2_IOCSTATUS_SUCCESS
) {
1555 ioc
->diag_buffer_status
[buffer_type
] |=
1556 MPT3_DIAG_BUFFER_IS_REGISTERED
;
1557 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s: success\n",
1558 ioc
->name
, __func__
));
1561 "%s: ioc_status(0x%04x) log_info(0x%08x)\n",
1562 ioc
->name
, __func__
,
1563 ioc_status
, le32_to_cpu(mpi_reply
->IOCLogInfo
));
1569 mpt3sas_base_hard_reset_handler(ioc
, FORCE_BIG_HAMMER
);
1573 if (rc
&& request_data
)
1574 pci_free_consistent(ioc
->pdev
, request_data_sz
,
1575 request_data
, request_data_dma
);
1577 ioc
->ctl_cmds
.status
= MPT3_CMD_NOT_USED
;
1582 * mpt3sas_enable_diag_buffer - enabling diag_buffers support driver load time
1583 * @ioc: per adapter object
1584 * @bits_to_register: bitwise field where trace is bit 0, and snapshot is bit 1
1586 * This is called when command line option diag_buffer_enable is enabled
1587 * at driver load time.
1590 mpt3sas_enable_diag_buffer(struct MPT3SAS_ADAPTER
*ioc
, u8 bits_to_register
)
1592 struct mpt3_diag_register diag_register
;
1594 memset(&diag_register
, 0, sizeof(struct mpt3_diag_register
));
1596 if (bits_to_register
& 1) {
1597 pr_info(MPT3SAS_FMT
"registering trace buffer support\n",
1599 ioc
->diag_trigger_master
.MasterData
=
1600 (MASTER_TRIGGER_FW_FAULT
+ MASTER_TRIGGER_ADAPTER_RESET
);
1601 diag_register
.buffer_type
= MPI2_DIAG_BUF_TYPE_TRACE
;
1602 /* register for 2MB buffers */
1603 diag_register
.requested_buffer_size
= 2 * (1024 * 1024);
1604 diag_register
.unique_id
= 0x7075900;
1605 _ctl_diag_register_2(ioc
, &diag_register
);
1608 if (bits_to_register
& 2) {
1609 pr_info(MPT3SAS_FMT
"registering snapshot buffer support\n",
1611 diag_register
.buffer_type
= MPI2_DIAG_BUF_TYPE_SNAPSHOT
;
1612 /* register for 2MB buffers */
1613 diag_register
.requested_buffer_size
= 2 * (1024 * 1024);
1614 diag_register
.unique_id
= 0x7075901;
1615 _ctl_diag_register_2(ioc
, &diag_register
);
1618 if (bits_to_register
& 4) {
1619 pr_info(MPT3SAS_FMT
"registering extended buffer support\n",
1621 diag_register
.buffer_type
= MPI2_DIAG_BUF_TYPE_EXTENDED
;
1622 /* register for 2MB buffers */
1623 diag_register
.requested_buffer_size
= 2 * (1024 * 1024);
1624 diag_register
.unique_id
= 0x7075901;
1625 _ctl_diag_register_2(ioc
, &diag_register
);
1630 * _ctl_diag_register - application register with driver
1631 * @ioc: per adapter object
1632 * @arg - user space buffer containing ioctl content
1634 * This will allow the driver to setup any required buffers that will be
1635 * needed by firmware to communicate with the driver.
1638 _ctl_diag_register(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1640 struct mpt3_diag_register karg
;
1643 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1644 pr_err("failure at %s:%d/%s()!\n",
1645 __FILE__
, __LINE__
, __func__
);
1649 rc
= _ctl_diag_register_2(ioc
, &karg
);
1654 * _ctl_diag_unregister - application unregister with driver
1655 * @ioc: per adapter object
1656 * @arg - user space buffer containing ioctl content
1658 * This will allow the driver to cleanup any memory allocated for diag
1659 * messages and to free up any resources.
1662 _ctl_diag_unregister(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1664 struct mpt3_diag_unregister karg
;
1666 dma_addr_t request_data_dma
;
1667 u32 request_data_sz
;
1670 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1671 pr_err("failure at %s:%d/%s()!\n",
1672 __FILE__
, __LINE__
, __func__
);
1676 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s\n", ioc
->name
,
1679 buffer_type
= karg
.unique_id
& 0x000000ff;
1680 if (!_ctl_diag_capability(ioc
, buffer_type
)) {
1682 "%s: doesn't have capability for buffer_type(0x%02x)\n",
1683 ioc
->name
, __func__
, buffer_type
);
1687 if ((ioc
->diag_buffer_status
[buffer_type
] &
1688 MPT3_DIAG_BUFFER_IS_REGISTERED
) == 0) {
1690 "%s: buffer_type(0x%02x) is not registered\n",
1691 ioc
->name
, __func__
, buffer_type
);
1694 if ((ioc
->diag_buffer_status
[buffer_type
] &
1695 MPT3_DIAG_BUFFER_IS_RELEASED
) == 0) {
1697 "%s: buffer_type(0x%02x) has not been released\n",
1698 ioc
->name
, __func__
, buffer_type
);
1702 if (karg
.unique_id
!= ioc
->unique_id
[buffer_type
]) {
1704 "%s: unique_id(0x%08x) is not registered\n",
1705 ioc
->name
, __func__
, karg
.unique_id
);
1709 request_data
= ioc
->diag_buffer
[buffer_type
];
1710 if (!request_data
) {
1712 "%s: doesn't have memory allocated for buffer_type(0x%02x)\n",
1713 ioc
->name
, __func__
, buffer_type
);
1717 request_data_sz
= ioc
->diag_buffer_sz
[buffer_type
];
1718 request_data_dma
= ioc
->diag_buffer_dma
[buffer_type
];
1719 pci_free_consistent(ioc
->pdev
, request_data_sz
,
1720 request_data
, request_data_dma
);
1721 ioc
->diag_buffer
[buffer_type
] = NULL
;
1722 ioc
->diag_buffer_status
[buffer_type
] = 0;
1727 * _ctl_diag_query - query relevant info associated with diag buffers
1728 * @ioc: per adapter object
1729 * @arg - user space buffer containing ioctl content
1731 * The application will send only buffer_type and unique_id. Driver will
1732 * inspect unique_id first, if valid, fill in all the info. If unique_id is
1733 * 0x00, the driver will return info specified by Buffer Type.
1736 _ctl_diag_query(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1738 struct mpt3_diag_query karg
;
1743 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1744 pr_err("failure at %s:%d/%s()!\n",
1745 __FILE__
, __LINE__
, __func__
);
1749 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s\n", ioc
->name
,
1752 karg
.application_flags
= 0;
1753 buffer_type
= karg
.buffer_type
;
1755 if (!_ctl_diag_capability(ioc
, buffer_type
)) {
1757 "%s: doesn't have capability for buffer_type(0x%02x)\n",
1758 ioc
->name
, __func__
, buffer_type
);
1762 if ((ioc
->diag_buffer_status
[buffer_type
] &
1763 MPT3_DIAG_BUFFER_IS_REGISTERED
) == 0) {
1765 "%s: buffer_type(0x%02x) is not registered\n",
1766 ioc
->name
, __func__
, buffer_type
);
1770 if (karg
.unique_id
& 0xffffff00) {
1771 if (karg
.unique_id
!= ioc
->unique_id
[buffer_type
]) {
1773 "%s: unique_id(0x%08x) is not registered\n",
1774 ioc
->name
, __func__
, karg
.unique_id
);
1779 request_data
= ioc
->diag_buffer
[buffer_type
];
1780 if (!request_data
) {
1782 "%s: doesn't have buffer for buffer_type(0x%02x)\n",
1783 ioc
->name
, __func__
, buffer_type
);
1787 if (ioc
->diag_buffer_status
[buffer_type
] & MPT3_DIAG_BUFFER_IS_RELEASED
)
1788 karg
.application_flags
= (MPT3_APP_FLAGS_APP_OWNED
|
1789 MPT3_APP_FLAGS_BUFFER_VALID
);
1791 karg
.application_flags
= (MPT3_APP_FLAGS_APP_OWNED
|
1792 MPT3_APP_FLAGS_BUFFER_VALID
|
1793 MPT3_APP_FLAGS_FW_BUFFER_ACCESS
);
1795 for (i
= 0; i
< MPT3_PRODUCT_SPECIFIC_DWORDS
; i
++)
1796 karg
.product_specific
[i
] =
1797 ioc
->product_specific
[buffer_type
][i
];
1799 karg
.total_buffer_size
= ioc
->diag_buffer_sz
[buffer_type
];
1800 karg
.driver_added_buffer_size
= 0;
1801 karg
.unique_id
= ioc
->unique_id
[buffer_type
];
1802 karg
.diagnostic_flags
= ioc
->diagnostic_flags
[buffer_type
];
1804 if (copy_to_user(arg
, &karg
, sizeof(struct mpt3_diag_query
))) {
1806 "%s: unable to write mpt3_diag_query data @ %p\n",
1807 ioc
->name
, __func__
, arg
);
1814 * mpt3sas_send_diag_release - Diag Release Message
1815 * @ioc: per adapter object
1816 * @buffer_type - specifies either TRACE, SNAPSHOT, or EXTENDED
1817 * @issue_reset - specifies whether host reset is required.
1821 mpt3sas_send_diag_release(struct MPT3SAS_ADAPTER
*ioc
, u8 buffer_type
,
1824 Mpi2DiagReleaseRequest_t
*mpi_request
;
1825 Mpi2DiagReleaseReply_t
*mpi_reply
;
1831 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s\n", ioc
->name
,
1837 ioc_state
= mpt3sas_base_get_iocstate(ioc
, 1);
1838 if (ioc_state
!= MPI2_IOC_STATE_OPERATIONAL
) {
1839 if (ioc
->diag_buffer_status
[buffer_type
] &
1840 MPT3_DIAG_BUFFER_IS_REGISTERED
)
1841 ioc
->diag_buffer_status
[buffer_type
] |=
1842 MPT3_DIAG_BUFFER_IS_RELEASED
;
1843 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
1844 "%s: skipping due to FAULT state\n", ioc
->name
,
1850 if (ioc
->ctl_cmds
.status
!= MPT3_CMD_NOT_USED
) {
1851 pr_err(MPT3SAS_FMT
"%s: ctl_cmd in use\n",
1852 ioc
->name
, __func__
);
1857 smid
= mpt3sas_base_get_smid(ioc
, ioc
->ctl_cb_idx
);
1859 pr_err(MPT3SAS_FMT
"%s: failed obtaining a smid\n",
1860 ioc
->name
, __func__
);
1865 ioc
->ctl_cmds
.status
= MPT3_CMD_PENDING
;
1866 memset(ioc
->ctl_cmds
.reply
, 0, ioc
->reply_sz
);
1867 mpi_request
= mpt3sas_base_get_msg_frame(ioc
, smid
);
1868 ioc
->ctl_cmds
.smid
= smid
;
1870 mpi_request
->Function
= MPI2_FUNCTION_DIAG_RELEASE
;
1871 mpi_request
->BufferType
= buffer_type
;
1872 mpi_request
->VF_ID
= 0; /* TODO */
1873 mpi_request
->VP_ID
= 0;
1875 init_completion(&ioc
->ctl_cmds
.done
);
1876 ioc
->put_smid_default(ioc
, smid
);
1877 wait_for_completion_timeout(&ioc
->ctl_cmds
.done
,
1878 MPT3_IOCTL_DEFAULT_TIMEOUT
*HZ
);
1880 if (!(ioc
->ctl_cmds
.status
& MPT3_CMD_COMPLETE
)) {
1881 pr_err(MPT3SAS_FMT
"%s: timeout\n", ioc
->name
,
1883 _debug_dump_mf(mpi_request
,
1884 sizeof(Mpi2DiagReleaseRequest_t
)/4);
1885 if (!(ioc
->ctl_cmds
.status
& MPT3_CMD_RESET
))
1891 /* process the completed Reply Message Frame */
1892 if ((ioc
->ctl_cmds
.status
& MPT3_CMD_REPLY_VALID
) == 0) {
1893 pr_err(MPT3SAS_FMT
"%s: no reply message\n",
1894 ioc
->name
, __func__
);
1899 mpi_reply
= ioc
->ctl_cmds
.reply
;
1900 ioc_status
= le16_to_cpu(mpi_reply
->IOCStatus
) & MPI2_IOCSTATUS_MASK
;
1902 if (ioc_status
== MPI2_IOCSTATUS_SUCCESS
) {
1903 ioc
->diag_buffer_status
[buffer_type
] |=
1904 MPT3_DIAG_BUFFER_IS_RELEASED
;
1905 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s: success\n",
1906 ioc
->name
, __func__
));
1909 "%s: ioc_status(0x%04x) log_info(0x%08x)\n",
1910 ioc
->name
, __func__
,
1911 ioc_status
, le32_to_cpu(mpi_reply
->IOCLogInfo
));
1916 ioc
->ctl_cmds
.status
= MPT3_CMD_NOT_USED
;
1921 * _ctl_diag_release - request to send Diag Release Message to firmware
1922 * @arg - user space buffer containing ioctl content
1924 * This allows ownership of the specified buffer to returned to the driver,
1925 * allowing an application to read the buffer without fear that firmware is
1926 * overwritting information in the buffer.
1929 _ctl_diag_release(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1931 struct mpt3_diag_release karg
;
1937 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1938 pr_err("failure at %s:%d/%s()!\n",
1939 __FILE__
, __LINE__
, __func__
);
1943 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s\n", ioc
->name
,
1946 buffer_type
= karg
.unique_id
& 0x000000ff;
1947 if (!_ctl_diag_capability(ioc
, buffer_type
)) {
1949 "%s: doesn't have capability for buffer_type(0x%02x)\n",
1950 ioc
->name
, __func__
, buffer_type
);
1954 if ((ioc
->diag_buffer_status
[buffer_type
] &
1955 MPT3_DIAG_BUFFER_IS_REGISTERED
) == 0) {
1957 "%s: buffer_type(0x%02x) is not registered\n",
1958 ioc
->name
, __func__
, buffer_type
);
1962 if (karg
.unique_id
!= ioc
->unique_id
[buffer_type
]) {
1964 "%s: unique_id(0x%08x) is not registered\n",
1965 ioc
->name
, __func__
, karg
.unique_id
);
1969 if (ioc
->diag_buffer_status
[buffer_type
] &
1970 MPT3_DIAG_BUFFER_IS_RELEASED
) {
1972 "%s: buffer_type(0x%02x) is already released\n",
1973 ioc
->name
, __func__
,
1978 request_data
= ioc
->diag_buffer
[buffer_type
];
1980 if (!request_data
) {
1982 "%s: doesn't have memory allocated for buffer_type(0x%02x)\n",
1983 ioc
->name
, __func__
, buffer_type
);
1987 /* buffers were released by due to host reset */
1988 if ((ioc
->diag_buffer_status
[buffer_type
] &
1989 MPT3_DIAG_BUFFER_IS_DIAG_RESET
)) {
1990 ioc
->diag_buffer_status
[buffer_type
] |=
1991 MPT3_DIAG_BUFFER_IS_RELEASED
;
1992 ioc
->diag_buffer_status
[buffer_type
] &=
1993 ~MPT3_DIAG_BUFFER_IS_DIAG_RESET
;
1995 "%s: buffer_type(0x%02x) was released due to host reset\n",
1996 ioc
->name
, __func__
, buffer_type
);
2000 rc
= mpt3sas_send_diag_release(ioc
, buffer_type
, &issue_reset
);
2003 mpt3sas_base_hard_reset_handler(ioc
, FORCE_BIG_HAMMER
);
2009 * _ctl_diag_read_buffer - request for copy of the diag buffer
2010 * @ioc: per adapter object
2011 * @arg - user space buffer containing ioctl content
2014 _ctl_diag_read_buffer(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
2016 struct mpt3_diag_read_buffer karg
;
2017 struct mpt3_diag_read_buffer __user
*uarg
= arg
;
2018 void *request_data
, *diag_data
;
2019 Mpi2DiagBufferPostRequest_t
*mpi_request
;
2020 Mpi2DiagBufferPostReply_t
*mpi_reply
;
2023 unsigned long request_size
, copy_size
;
2028 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
2029 pr_err("failure at %s:%d/%s()!\n",
2030 __FILE__
, __LINE__
, __func__
);
2034 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s\n", ioc
->name
,
2037 buffer_type
= karg
.unique_id
& 0x000000ff;
2038 if (!_ctl_diag_capability(ioc
, buffer_type
)) {
2040 "%s: doesn't have capability for buffer_type(0x%02x)\n",
2041 ioc
->name
, __func__
, buffer_type
);
2045 if (karg
.unique_id
!= ioc
->unique_id
[buffer_type
]) {
2047 "%s: unique_id(0x%08x) is not registered\n",
2048 ioc
->name
, __func__
, karg
.unique_id
);
2052 request_data
= ioc
->diag_buffer
[buffer_type
];
2053 if (!request_data
) {
2055 "%s: doesn't have buffer for buffer_type(0x%02x)\n",
2056 ioc
->name
, __func__
, buffer_type
);
2060 request_size
= ioc
->diag_buffer_sz
[buffer_type
];
2062 if ((karg
.starting_offset
% 4) || (karg
.bytes_to_read
% 4)) {
2063 pr_err(MPT3SAS_FMT
"%s: either the starting_offset " \
2064 "or bytes_to_read are not 4 byte aligned\n", ioc
->name
,
2069 if (karg
.starting_offset
> request_size
)
2072 diag_data
= (void *)(request_data
+ karg
.starting_offset
);
2073 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
2074 "%s: diag_buffer(%p), offset(%d), sz(%d)\n",
2075 ioc
->name
, __func__
,
2076 diag_data
, karg
.starting_offset
, karg
.bytes_to_read
));
2078 /* Truncate data on requests that are too large */
2079 if ((diag_data
+ karg
.bytes_to_read
< diag_data
) ||
2080 (diag_data
+ karg
.bytes_to_read
> request_data
+ request_size
))
2081 copy_size
= request_size
- karg
.starting_offset
;
2083 copy_size
= karg
.bytes_to_read
;
2085 if (copy_to_user((void __user
*)uarg
->diagnostic_data
,
2086 diag_data
, copy_size
)) {
2088 "%s: Unable to write mpt_diag_read_buffer_t data @ %p\n",
2089 ioc
->name
, __func__
, diag_data
);
2093 if ((karg
.flags
& MPT3_FLAGS_REREGISTER
) == 0)
2096 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
2097 "%s: Reregister buffer_type(0x%02x)\n",
2098 ioc
->name
, __func__
, buffer_type
));
2099 if ((ioc
->diag_buffer_status
[buffer_type
] &
2100 MPT3_DIAG_BUFFER_IS_RELEASED
) == 0) {
2101 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
2102 "%s: buffer_type(0x%02x) is still registered\n",
2103 ioc
->name
, __func__
, buffer_type
));
2106 /* Get a free request frame and save the message context.
2109 if (ioc
->ctl_cmds
.status
!= MPT3_CMD_NOT_USED
) {
2110 pr_err(MPT3SAS_FMT
"%s: ctl_cmd in use\n",
2111 ioc
->name
, __func__
);
2116 smid
= mpt3sas_base_get_smid(ioc
, ioc
->ctl_cb_idx
);
2118 pr_err(MPT3SAS_FMT
"%s: failed obtaining a smid\n",
2119 ioc
->name
, __func__
);
2125 ioc
->ctl_cmds
.status
= MPT3_CMD_PENDING
;
2126 memset(ioc
->ctl_cmds
.reply
, 0, ioc
->reply_sz
);
2127 mpi_request
= mpt3sas_base_get_msg_frame(ioc
, smid
);
2128 ioc
->ctl_cmds
.smid
= smid
;
2130 mpi_request
->Function
= MPI2_FUNCTION_DIAG_BUFFER_POST
;
2131 mpi_request
->BufferType
= buffer_type
;
2132 mpi_request
->BufferLength
=
2133 cpu_to_le32(ioc
->diag_buffer_sz
[buffer_type
]);
2134 mpi_request
->BufferAddress
=
2135 cpu_to_le64(ioc
->diag_buffer_dma
[buffer_type
]);
2136 for (i
= 0; i
< MPT3_PRODUCT_SPECIFIC_DWORDS
; i
++)
2137 mpi_request
->ProductSpecific
[i
] =
2138 cpu_to_le32(ioc
->product_specific
[buffer_type
][i
]);
2139 mpi_request
->VF_ID
= 0; /* TODO */
2140 mpi_request
->VP_ID
= 0;
2142 init_completion(&ioc
->ctl_cmds
.done
);
2143 ioc
->put_smid_default(ioc
, smid
);
2144 wait_for_completion_timeout(&ioc
->ctl_cmds
.done
,
2145 MPT3_IOCTL_DEFAULT_TIMEOUT
*HZ
);
2147 if (!(ioc
->ctl_cmds
.status
& MPT3_CMD_COMPLETE
)) {
2148 pr_err(MPT3SAS_FMT
"%s: timeout\n", ioc
->name
,
2150 _debug_dump_mf(mpi_request
,
2151 sizeof(Mpi2DiagBufferPostRequest_t
)/4);
2152 if (!(ioc
->ctl_cmds
.status
& MPT3_CMD_RESET
))
2154 goto issue_host_reset
;
2157 /* process the completed Reply Message Frame */
2158 if ((ioc
->ctl_cmds
.status
& MPT3_CMD_REPLY_VALID
) == 0) {
2159 pr_err(MPT3SAS_FMT
"%s: no reply message\n",
2160 ioc
->name
, __func__
);
2165 mpi_reply
= ioc
->ctl_cmds
.reply
;
2166 ioc_status
= le16_to_cpu(mpi_reply
->IOCStatus
) & MPI2_IOCSTATUS_MASK
;
2168 if (ioc_status
== MPI2_IOCSTATUS_SUCCESS
) {
2169 ioc
->diag_buffer_status
[buffer_type
] |=
2170 MPT3_DIAG_BUFFER_IS_REGISTERED
;
2171 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s: success\n",
2172 ioc
->name
, __func__
));
2175 "%s: ioc_status(0x%04x) log_info(0x%08x)\n",
2176 ioc
->name
, __func__
,
2177 ioc_status
, le32_to_cpu(mpi_reply
->IOCLogInfo
));
2183 mpt3sas_base_hard_reset_handler(ioc
, FORCE_BIG_HAMMER
);
2187 ioc
->ctl_cmds
.status
= MPT3_CMD_NOT_USED
;
2193 #ifdef CONFIG_COMPAT
2195 * _ctl_compat_mpt_command - convert 32bit pointers to 64bit.
2196 * @ioc: per adapter object
2197 * @cmd - ioctl opcode
2198 * @arg - (struct mpt3_ioctl_command32)
2200 * MPT3COMMAND32 - Handle 32bit applications running on 64bit os.
2203 _ctl_compat_mpt_command(struct MPT3SAS_ADAPTER
*ioc
, unsigned cmd
,
2206 struct mpt3_ioctl_command32 karg32
;
2207 struct mpt3_ioctl_command32 __user
*uarg
;
2208 struct mpt3_ioctl_command karg
;
2210 if (_IOC_SIZE(cmd
) != sizeof(struct mpt3_ioctl_command32
))
2213 uarg
= (struct mpt3_ioctl_command32 __user
*) arg
;
2215 if (copy_from_user(&karg32
, (char __user
*)arg
, sizeof(karg32
))) {
2216 pr_err("failure at %s:%d/%s()!\n",
2217 __FILE__
, __LINE__
, __func__
);
2221 memset(&karg
, 0, sizeof(struct mpt3_ioctl_command
));
2222 karg
.hdr
.ioc_number
= karg32
.hdr
.ioc_number
;
2223 karg
.hdr
.port_number
= karg32
.hdr
.port_number
;
2224 karg
.hdr
.max_data_size
= karg32
.hdr
.max_data_size
;
2225 karg
.timeout
= karg32
.timeout
;
2226 karg
.max_reply_bytes
= karg32
.max_reply_bytes
;
2227 karg
.data_in_size
= karg32
.data_in_size
;
2228 karg
.data_out_size
= karg32
.data_out_size
;
2229 karg
.max_sense_bytes
= karg32
.max_sense_bytes
;
2230 karg
.data_sge_offset
= karg32
.data_sge_offset
;
2231 karg
.reply_frame_buf_ptr
= compat_ptr(karg32
.reply_frame_buf_ptr
);
2232 karg
.data_in_buf_ptr
= compat_ptr(karg32
.data_in_buf_ptr
);
2233 karg
.data_out_buf_ptr
= compat_ptr(karg32
.data_out_buf_ptr
);
2234 karg
.sense_data_ptr
= compat_ptr(karg32
.sense_data_ptr
);
2235 return _ctl_do_mpt_command(ioc
, karg
, &uarg
->mf
);
2240 * _ctl_ioctl_main - main ioctl entry point
2241 * @file - (struct file)
2242 * @cmd - ioctl opcode
2243 * @arg - user space data buffer
2244 * @compat - handles 32 bit applications in 64bit os
2245 * @mpi_version: will be MPI2_VERSION for mpt2ctl ioctl device &
2246 * MPI25_VERSION | MPI26_VERSION for mpt3ctl ioctl device.
2249 _ctl_ioctl_main(struct file
*file
, unsigned int cmd
, void __user
*arg
,
2250 u8 compat
, u16 mpi_version
)
2252 struct MPT3SAS_ADAPTER
*ioc
;
2253 struct mpt3_ioctl_header ioctl_header
;
2254 enum block_state state
;
2257 /* get IOCTL header */
2258 if (copy_from_user(&ioctl_header
, (char __user
*)arg
,
2259 sizeof(struct mpt3_ioctl_header
))) {
2260 pr_err("failure at %s:%d/%s()!\n",
2261 __FILE__
, __LINE__
, __func__
);
2265 if (_ctl_verify_adapter(ioctl_header
.ioc_number
,
2266 &ioc
, mpi_version
) == -1 || !ioc
)
2269 /* pci_access_mutex lock acquired by ioctl path */
2270 mutex_lock(&ioc
->pci_access_mutex
);
2272 if (ioc
->shost_recovery
|| ioc
->pci_error_recovery
||
2273 ioc
->is_driver_loading
|| ioc
->remove_host
) {
2275 goto out_unlock_pciaccess
;
2278 state
= (file
->f_flags
& O_NONBLOCK
) ? NON_BLOCKING
: BLOCKING
;
2279 if (state
== NON_BLOCKING
) {
2280 if (!mutex_trylock(&ioc
->ctl_cmds
.mutex
)) {
2282 goto out_unlock_pciaccess
;
2284 } else if (mutex_lock_interruptible(&ioc
->ctl_cmds
.mutex
)) {
2286 goto out_unlock_pciaccess
;
2292 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_ioctl_iocinfo
))
2293 ret
= _ctl_getiocinfo(ioc
, arg
);
2295 #ifdef CONFIG_COMPAT
2300 struct mpt3_ioctl_command __user
*uarg
;
2301 struct mpt3_ioctl_command karg
;
2303 #ifdef CONFIG_COMPAT
2305 ret
= _ctl_compat_mpt_command(ioc
, cmd
, arg
);
2309 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
2310 pr_err("failure at %s:%d/%s()!\n",
2311 __FILE__
, __LINE__
, __func__
);
2316 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_ioctl_command
)) {
2318 ret
= _ctl_do_mpt_command(ioc
, karg
, &uarg
->mf
);
2322 case MPT3EVENTQUERY
:
2323 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_ioctl_eventquery
))
2324 ret
= _ctl_eventquery(ioc
, arg
);
2326 case MPT3EVENTENABLE
:
2327 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_ioctl_eventenable
))
2328 ret
= _ctl_eventenable(ioc
, arg
);
2330 case MPT3EVENTREPORT
:
2331 ret
= _ctl_eventreport(ioc
, arg
);
2334 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_ioctl_diag_reset
))
2335 ret
= _ctl_do_reset(ioc
, arg
);
2337 case MPT3BTDHMAPPING
:
2338 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_ioctl_btdh_mapping
))
2339 ret
= _ctl_btdh_mapping(ioc
, arg
);
2341 case MPT3DIAGREGISTER
:
2342 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_diag_register
))
2343 ret
= _ctl_diag_register(ioc
, arg
);
2345 case MPT3DIAGUNREGISTER
:
2346 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_diag_unregister
))
2347 ret
= _ctl_diag_unregister(ioc
, arg
);
2350 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_diag_query
))
2351 ret
= _ctl_diag_query(ioc
, arg
);
2353 case MPT3DIAGRELEASE
:
2354 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_diag_release
))
2355 ret
= _ctl_diag_release(ioc
, arg
);
2357 case MPT3DIAGREADBUFFER
:
2358 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_diag_read_buffer
))
2359 ret
= _ctl_diag_read_buffer(ioc
, arg
);
2362 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
2363 "unsupported ioctl opcode(0x%08x)\n", ioc
->name
, cmd
));
2367 mutex_unlock(&ioc
->ctl_cmds
.mutex
);
2368 out_unlock_pciaccess
:
2369 mutex_unlock(&ioc
->pci_access_mutex
);
2374 * _ctl_ioctl - mpt3ctl main ioctl entry point (unlocked)
2375 * @file - (struct file)
2376 * @cmd - ioctl opcode
2380 _ctl_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
2384 /* pass MPI25_VERSION | MPI26_VERSION value,
2385 * to indicate that this ioctl cmd
2386 * came from mpt3ctl ioctl device.
2388 ret
= _ctl_ioctl_main(file
, cmd
, (void __user
*)arg
, 0,
2389 MPI25_VERSION
| MPI26_VERSION
);
2394 * _ctl_mpt2_ioctl - mpt2ctl main ioctl entry point (unlocked)
2395 * @file - (struct file)
2396 * @cmd - ioctl opcode
2400 _ctl_mpt2_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
2404 /* pass MPI2_VERSION value, to indicate that this ioctl cmd
2405 * came from mpt2ctl ioctl device.
2407 ret
= _ctl_ioctl_main(file
, cmd
, (void __user
*)arg
, 0, MPI2_VERSION
);
2410 #ifdef CONFIG_COMPAT
2412 *_ ctl_ioctl_compat - main ioctl entry point (compat)
2417 * This routine handles 32 bit applications in 64bit os.
2420 _ctl_ioctl_compat(struct file
*file
, unsigned cmd
, unsigned long arg
)
2424 ret
= _ctl_ioctl_main(file
, cmd
, (void __user
*)arg
, 1,
2425 MPI25_VERSION
| MPI26_VERSION
);
2430 *_ ctl_mpt2_ioctl_compat - main ioctl entry point (compat)
2435 * This routine handles 32 bit applications in 64bit os.
2438 _ctl_mpt2_ioctl_compat(struct file
*file
, unsigned cmd
, unsigned long arg
)
2442 ret
= _ctl_ioctl_main(file
, cmd
, (void __user
*)arg
, 1, MPI2_VERSION
);
2447 /* scsi host attributes */
2449 * _ctl_version_fw_show - firmware version
2450 * @cdev - pointer to embedded class device
2451 * @buf - the buffer returned
2453 * A sysfs 'read-only' shost attribute.
2456 _ctl_version_fw_show(struct device
*cdev
, struct device_attribute
*attr
,
2459 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2460 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2462 return snprintf(buf
, PAGE_SIZE
, "%02d.%02d.%02d.%02d\n",
2463 (ioc
->facts
.FWVersion
.Word
& 0xFF000000) >> 24,
2464 (ioc
->facts
.FWVersion
.Word
& 0x00FF0000) >> 16,
2465 (ioc
->facts
.FWVersion
.Word
& 0x0000FF00) >> 8,
2466 ioc
->facts
.FWVersion
.Word
& 0x000000FF);
2468 static DEVICE_ATTR(version_fw
, S_IRUGO
, _ctl_version_fw_show
, NULL
);
2471 * _ctl_version_bios_show - bios version
2472 * @cdev - pointer to embedded class device
2473 * @buf - the buffer returned
2475 * A sysfs 'read-only' shost attribute.
2478 _ctl_version_bios_show(struct device
*cdev
, struct device_attribute
*attr
,
2481 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2482 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2484 u32 version
= le32_to_cpu(ioc
->bios_pg3
.BiosVersion
);
2486 return snprintf(buf
, PAGE_SIZE
, "%02d.%02d.%02d.%02d\n",
2487 (version
& 0xFF000000) >> 24,
2488 (version
& 0x00FF0000) >> 16,
2489 (version
& 0x0000FF00) >> 8,
2490 version
& 0x000000FF);
2492 static DEVICE_ATTR(version_bios
, S_IRUGO
, _ctl_version_bios_show
, NULL
);
2495 * _ctl_version_mpi_show - MPI (message passing interface) version
2496 * @cdev - pointer to embedded class device
2497 * @buf - the buffer returned
2499 * A sysfs 'read-only' shost attribute.
2502 _ctl_version_mpi_show(struct device
*cdev
, struct device_attribute
*attr
,
2505 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2506 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2508 return snprintf(buf
, PAGE_SIZE
, "%03x.%02x\n",
2509 ioc
->facts
.MsgVersion
, ioc
->facts
.HeaderVersion
>> 8);
2511 static DEVICE_ATTR(version_mpi
, S_IRUGO
, _ctl_version_mpi_show
, NULL
);
2514 * _ctl_version_product_show - product name
2515 * @cdev - pointer to embedded class device
2516 * @buf - the buffer returned
2518 * A sysfs 'read-only' shost attribute.
2521 _ctl_version_product_show(struct device
*cdev
, struct device_attribute
*attr
,
2524 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2525 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2527 return snprintf(buf
, 16, "%s\n", ioc
->manu_pg0
.ChipName
);
2529 static DEVICE_ATTR(version_product
, S_IRUGO
, _ctl_version_product_show
, NULL
);
2532 * _ctl_version_nvdata_persistent_show - ndvata persistent version
2533 * @cdev - pointer to embedded class device
2534 * @buf - the buffer returned
2536 * A sysfs 'read-only' shost attribute.
2539 _ctl_version_nvdata_persistent_show(struct device
*cdev
,
2540 struct device_attribute
*attr
, char *buf
)
2542 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2543 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2545 return snprintf(buf
, PAGE_SIZE
, "%08xh\n",
2546 le32_to_cpu(ioc
->iounit_pg0
.NvdataVersionPersistent
.Word
));
2548 static DEVICE_ATTR(version_nvdata_persistent
, S_IRUGO
,
2549 _ctl_version_nvdata_persistent_show
, NULL
);
2552 * _ctl_version_nvdata_default_show - nvdata default version
2553 * @cdev - pointer to embedded class device
2554 * @buf - the buffer returned
2556 * A sysfs 'read-only' shost attribute.
2559 _ctl_version_nvdata_default_show(struct device
*cdev
, struct device_attribute
2562 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2563 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2565 return snprintf(buf
, PAGE_SIZE
, "%08xh\n",
2566 le32_to_cpu(ioc
->iounit_pg0
.NvdataVersionDefault
.Word
));
2568 static DEVICE_ATTR(version_nvdata_default
, S_IRUGO
,
2569 _ctl_version_nvdata_default_show
, NULL
);
2572 * _ctl_board_name_show - board name
2573 * @cdev - pointer to embedded class device
2574 * @buf - the buffer returned
2576 * A sysfs 'read-only' shost attribute.
2579 _ctl_board_name_show(struct device
*cdev
, struct device_attribute
*attr
,
2582 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2583 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2585 return snprintf(buf
, 16, "%s\n", ioc
->manu_pg0
.BoardName
);
2587 static DEVICE_ATTR(board_name
, S_IRUGO
, _ctl_board_name_show
, NULL
);
2590 * _ctl_board_assembly_show - board assembly name
2591 * @cdev - pointer to embedded class device
2592 * @buf - the buffer returned
2594 * A sysfs 'read-only' shost attribute.
2597 _ctl_board_assembly_show(struct device
*cdev
, struct device_attribute
*attr
,
2600 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2601 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2603 return snprintf(buf
, 16, "%s\n", ioc
->manu_pg0
.BoardAssembly
);
2605 static DEVICE_ATTR(board_assembly
, S_IRUGO
, _ctl_board_assembly_show
, NULL
);
2608 * _ctl_board_tracer_show - board tracer number
2609 * @cdev - pointer to embedded class device
2610 * @buf - the buffer returned
2612 * A sysfs 'read-only' shost attribute.
2615 _ctl_board_tracer_show(struct device
*cdev
, struct device_attribute
*attr
,
2618 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2619 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2621 return snprintf(buf
, 16, "%s\n", ioc
->manu_pg0
.BoardTracerNumber
);
2623 static DEVICE_ATTR(board_tracer
, S_IRUGO
, _ctl_board_tracer_show
, NULL
);
2626 * _ctl_io_delay_show - io missing delay
2627 * @cdev - pointer to embedded class device
2628 * @buf - the buffer returned
2630 * This is for firmware implemention for deboucing device
2633 * A sysfs 'read-only' shost attribute.
2636 _ctl_io_delay_show(struct device
*cdev
, struct device_attribute
*attr
,
2639 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2640 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2642 return snprintf(buf
, PAGE_SIZE
, "%02d\n", ioc
->io_missing_delay
);
2644 static DEVICE_ATTR(io_delay
, S_IRUGO
, _ctl_io_delay_show
, NULL
);
2647 * _ctl_device_delay_show - device missing delay
2648 * @cdev - pointer to embedded class device
2649 * @buf - the buffer returned
2651 * This is for firmware implemention for deboucing device
2654 * A sysfs 'read-only' shost attribute.
2657 _ctl_device_delay_show(struct device
*cdev
, struct device_attribute
*attr
,
2660 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2661 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2663 return snprintf(buf
, PAGE_SIZE
, "%02d\n", ioc
->device_missing_delay
);
2665 static DEVICE_ATTR(device_delay
, S_IRUGO
, _ctl_device_delay_show
, NULL
);
2668 * _ctl_fw_queue_depth_show - global credits
2669 * @cdev - pointer to embedded class device
2670 * @buf - the buffer returned
2672 * This is firmware queue depth limit
2674 * A sysfs 'read-only' shost attribute.
2677 _ctl_fw_queue_depth_show(struct device
*cdev
, struct device_attribute
*attr
,
2680 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2681 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2683 return snprintf(buf
, PAGE_SIZE
, "%02d\n", ioc
->facts
.RequestCredit
);
2685 static DEVICE_ATTR(fw_queue_depth
, S_IRUGO
, _ctl_fw_queue_depth_show
, NULL
);
2688 * _ctl_sas_address_show - sas address
2689 * @cdev - pointer to embedded class device
2690 * @buf - the buffer returned
2692 * This is the controller sas address
2694 * A sysfs 'read-only' shost attribute.
2697 _ctl_host_sas_address_show(struct device
*cdev
, struct device_attribute
*attr
,
2701 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2702 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2704 return snprintf(buf
, PAGE_SIZE
, "0x%016llx\n",
2705 (unsigned long long)ioc
->sas_hba
.sas_address
);
2707 static DEVICE_ATTR(host_sas_address
, S_IRUGO
,
2708 _ctl_host_sas_address_show
, NULL
);
2711 * _ctl_logging_level_show - logging level
2712 * @cdev - pointer to embedded class device
2713 * @buf - the buffer returned
2715 * A sysfs 'read/write' shost attribute.
2718 _ctl_logging_level_show(struct device
*cdev
, struct device_attribute
*attr
,
2721 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2722 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2724 return snprintf(buf
, PAGE_SIZE
, "%08xh\n", ioc
->logging_level
);
2727 _ctl_logging_level_store(struct device
*cdev
, struct device_attribute
*attr
,
2728 const char *buf
, size_t count
)
2730 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2731 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2734 if (sscanf(buf
, "%x", &val
) != 1)
2737 ioc
->logging_level
= val
;
2738 pr_info(MPT3SAS_FMT
"logging_level=%08xh\n", ioc
->name
,
2739 ioc
->logging_level
);
2742 static DEVICE_ATTR(logging_level
, S_IRUGO
| S_IWUSR
, _ctl_logging_level_show
,
2743 _ctl_logging_level_store
);
2746 * _ctl_fwfault_debug_show - show/store fwfault_debug
2747 * @cdev - pointer to embedded class device
2748 * @buf - the buffer returned
2750 * mpt3sas_fwfault_debug is command line option
2751 * A sysfs 'read/write' shost attribute.
2754 _ctl_fwfault_debug_show(struct device
*cdev
, struct device_attribute
*attr
,
2757 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2758 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2760 return snprintf(buf
, PAGE_SIZE
, "%d\n", ioc
->fwfault_debug
);
2763 _ctl_fwfault_debug_store(struct device
*cdev
, struct device_attribute
*attr
,
2764 const char *buf
, size_t count
)
2766 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2767 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2770 if (sscanf(buf
, "%d", &val
) != 1)
2773 ioc
->fwfault_debug
= val
;
2774 pr_info(MPT3SAS_FMT
"fwfault_debug=%d\n", ioc
->name
,
2775 ioc
->fwfault_debug
);
2778 static DEVICE_ATTR(fwfault_debug
, S_IRUGO
| S_IWUSR
,
2779 _ctl_fwfault_debug_show
, _ctl_fwfault_debug_store
);
2782 * _ctl_ioc_reset_count_show - ioc reset count
2783 * @cdev - pointer to embedded class device
2784 * @buf - the buffer returned
2786 * This is firmware queue depth limit
2788 * A sysfs 'read-only' shost attribute.
2791 _ctl_ioc_reset_count_show(struct device
*cdev
, struct device_attribute
*attr
,
2794 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2795 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2797 return snprintf(buf
, PAGE_SIZE
, "%d\n", ioc
->ioc_reset_count
);
2799 static DEVICE_ATTR(ioc_reset_count
, S_IRUGO
, _ctl_ioc_reset_count_show
, NULL
);
2802 * _ctl_ioc_reply_queue_count_show - number of reply queues
2803 * @cdev - pointer to embedded class device
2804 * @buf - the buffer returned
2806 * This is number of reply queues
2808 * A sysfs 'read-only' shost attribute.
2811 _ctl_ioc_reply_queue_count_show(struct device
*cdev
,
2812 struct device_attribute
*attr
, char *buf
)
2814 u8 reply_queue_count
;
2815 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2816 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2818 if ((ioc
->facts
.IOCCapabilities
&
2819 MPI2_IOCFACTS_CAPABILITY_MSI_X_INDEX
) && ioc
->msix_enable
)
2820 reply_queue_count
= ioc
->reply_queue_count
;
2822 reply_queue_count
= 1;
2824 return snprintf(buf
, PAGE_SIZE
, "%d\n", reply_queue_count
);
2826 static DEVICE_ATTR(reply_queue_count
, S_IRUGO
, _ctl_ioc_reply_queue_count_show
,
2830 * _ctl_BRM_status_show - Backup Rail Monitor Status
2831 * @cdev - pointer to embedded class device
2832 * @buf - the buffer returned
2834 * This is number of reply queues
2836 * A sysfs 'read-only' shost attribute.
2839 _ctl_BRM_status_show(struct device
*cdev
, struct device_attribute
*attr
,
2842 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2843 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2844 Mpi2IOUnitPage3_t
*io_unit_pg3
= NULL
;
2845 Mpi2ConfigReply_t mpi_reply
;
2846 u16 backup_rail_monitor_status
= 0;
2851 if (!ioc
->is_warpdrive
) {
2852 pr_err(MPT3SAS_FMT
"%s: BRM attribute is only for"
2853 " warpdrive\n", ioc
->name
, __func__
);
2856 /* pci_access_mutex lock acquired by sysfs show path */
2857 mutex_lock(&ioc
->pci_access_mutex
);
2858 if (ioc
->pci_error_recovery
|| ioc
->remove_host
) {
2859 mutex_unlock(&ioc
->pci_access_mutex
);
2863 /* allocate upto GPIOVal 36 entries */
2864 sz
= offsetof(Mpi2IOUnitPage3_t
, GPIOVal
) + (sizeof(u16
) * 36);
2865 io_unit_pg3
= kzalloc(sz
, GFP_KERNEL
);
2867 pr_err(MPT3SAS_FMT
"%s: failed allocating memory "
2868 "for iounit_pg3: (%d) bytes\n", ioc
->name
, __func__
, sz
);
2872 if (mpt3sas_config_get_iounit_pg3(ioc
, &mpi_reply
, io_unit_pg3
, sz
) !=
2875 "%s: failed reading iounit_pg3\n", ioc
->name
,
2880 ioc_status
= le16_to_cpu(mpi_reply
.IOCStatus
) & MPI2_IOCSTATUS_MASK
;
2881 if (ioc_status
!= MPI2_IOCSTATUS_SUCCESS
) {
2882 pr_err(MPT3SAS_FMT
"%s: iounit_pg3 failed with "
2883 "ioc_status(0x%04x)\n", ioc
->name
, __func__
, ioc_status
);
2887 if (io_unit_pg3
->GPIOCount
< 25) {
2888 pr_err(MPT3SAS_FMT
"%s: iounit_pg3->GPIOCount less than "
2889 "25 entries, detected (%d) entries\n", ioc
->name
, __func__
,
2890 io_unit_pg3
->GPIOCount
);
2894 /* BRM status is in bit zero of GPIOVal[24] */
2895 backup_rail_monitor_status
= le16_to_cpu(io_unit_pg3
->GPIOVal
[24]);
2896 rc
= snprintf(buf
, PAGE_SIZE
, "%d\n", (backup_rail_monitor_status
& 1));
2900 mutex_unlock(&ioc
->pci_access_mutex
);
2903 static DEVICE_ATTR(BRM_status
, S_IRUGO
, _ctl_BRM_status_show
, NULL
);
2905 struct DIAG_BUFFER_START
{
2916 * _ctl_host_trace_buffer_size_show - host buffer size (trace only)
2917 * @cdev - pointer to embedded class device
2918 * @buf - the buffer returned
2920 * A sysfs 'read-only' shost attribute.
2923 _ctl_host_trace_buffer_size_show(struct device
*cdev
,
2924 struct device_attribute
*attr
, char *buf
)
2926 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2927 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2929 struct DIAG_BUFFER_START
*request_data
;
2931 if (!ioc
->diag_buffer
[MPI2_DIAG_BUF_TYPE_TRACE
]) {
2933 "%s: host_trace_buffer is not registered\n",
2934 ioc
->name
, __func__
);
2938 if ((ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] &
2939 MPT3_DIAG_BUFFER_IS_REGISTERED
) == 0) {
2941 "%s: host_trace_buffer is not registered\n",
2942 ioc
->name
, __func__
);
2946 request_data
= (struct DIAG_BUFFER_START
*)
2947 ioc
->diag_buffer
[MPI2_DIAG_BUF_TYPE_TRACE
];
2948 if ((le32_to_cpu(request_data
->DiagVersion
) == 0x00000000 ||
2949 le32_to_cpu(request_data
->DiagVersion
) == 0x01000000 ||
2950 le32_to_cpu(request_data
->DiagVersion
) == 0x01010000) &&
2951 le32_to_cpu(request_data
->Reserved3
) == 0x4742444c)
2952 size
= le32_to_cpu(request_data
->Size
);
2954 ioc
->ring_buffer_sz
= size
;
2955 return snprintf(buf
, PAGE_SIZE
, "%d\n", size
);
2957 static DEVICE_ATTR(host_trace_buffer_size
, S_IRUGO
,
2958 _ctl_host_trace_buffer_size_show
, NULL
);
2961 * _ctl_host_trace_buffer_show - firmware ring buffer (trace only)
2962 * @cdev - pointer to embedded class device
2963 * @buf - the buffer returned
2965 * A sysfs 'read/write' shost attribute.
2967 * You will only be able to read 4k bytes of ring buffer at a time.
2968 * In order to read beyond 4k bytes, you will have to write out the
2969 * offset to the same attribute, it will move the pointer.
2972 _ctl_host_trace_buffer_show(struct device
*cdev
, struct device_attribute
*attr
,
2975 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2976 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2980 if (!ioc
->diag_buffer
[MPI2_DIAG_BUF_TYPE_TRACE
]) {
2982 "%s: host_trace_buffer is not registered\n",
2983 ioc
->name
, __func__
);
2987 if ((ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] &
2988 MPT3_DIAG_BUFFER_IS_REGISTERED
) == 0) {
2990 "%s: host_trace_buffer is not registered\n",
2991 ioc
->name
, __func__
);
2995 if (ioc
->ring_buffer_offset
> ioc
->ring_buffer_sz
)
2998 size
= ioc
->ring_buffer_sz
- ioc
->ring_buffer_offset
;
2999 size
= (size
>= PAGE_SIZE
) ? (PAGE_SIZE
- 1) : size
;
3000 request_data
= ioc
->diag_buffer
[0] + ioc
->ring_buffer_offset
;
3001 memcpy(buf
, request_data
, size
);
3006 _ctl_host_trace_buffer_store(struct device
*cdev
, struct device_attribute
*attr
,
3007 const char *buf
, size_t count
)
3009 struct Scsi_Host
*shost
= class_to_shost(cdev
);
3010 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
3013 if (sscanf(buf
, "%d", &val
) != 1)
3016 ioc
->ring_buffer_offset
= val
;
3019 static DEVICE_ATTR(host_trace_buffer
, S_IRUGO
| S_IWUSR
,
3020 _ctl_host_trace_buffer_show
, _ctl_host_trace_buffer_store
);
3023 /*****************************************/
3026 * _ctl_host_trace_buffer_enable_show - firmware ring buffer (trace only)
3027 * @cdev - pointer to embedded class device
3028 * @buf - the buffer returned
3030 * A sysfs 'read/write' shost attribute.
3032 * This is a mechnism to post/release host_trace_buffers
3035 _ctl_host_trace_buffer_enable_show(struct device
*cdev
,
3036 struct device_attribute
*attr
, char *buf
)
3038 struct Scsi_Host
*shost
= class_to_shost(cdev
);
3039 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
3041 if ((!ioc
->diag_buffer
[MPI2_DIAG_BUF_TYPE_TRACE
]) ||
3042 ((ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] &
3043 MPT3_DIAG_BUFFER_IS_REGISTERED
) == 0))
3044 return snprintf(buf
, PAGE_SIZE
, "off\n");
3045 else if ((ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] &
3046 MPT3_DIAG_BUFFER_IS_RELEASED
))
3047 return snprintf(buf
, PAGE_SIZE
, "release\n");
3049 return snprintf(buf
, PAGE_SIZE
, "post\n");
3053 _ctl_host_trace_buffer_enable_store(struct device
*cdev
,
3054 struct device_attribute
*attr
, const char *buf
, size_t count
)
3056 struct Scsi_Host
*shost
= class_to_shost(cdev
);
3057 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
3059 struct mpt3_diag_register diag_register
;
3062 /* don't allow post/release occurr while recovery is active */
3063 if (ioc
->shost_recovery
|| ioc
->remove_host
||
3064 ioc
->pci_error_recovery
|| ioc
->is_driver_loading
)
3067 if (sscanf(buf
, "%9s", str
) != 1)
3070 if (!strcmp(str
, "post")) {
3071 /* exit out if host buffers are already posted */
3072 if ((ioc
->diag_buffer
[MPI2_DIAG_BUF_TYPE_TRACE
]) &&
3073 (ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] &
3074 MPT3_DIAG_BUFFER_IS_REGISTERED
) &&
3075 ((ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] &
3076 MPT3_DIAG_BUFFER_IS_RELEASED
) == 0))
3078 memset(&diag_register
, 0, sizeof(struct mpt3_diag_register
));
3079 pr_info(MPT3SAS_FMT
"posting host trace buffers\n",
3081 diag_register
.buffer_type
= MPI2_DIAG_BUF_TYPE_TRACE
;
3082 diag_register
.requested_buffer_size
= (1024 * 1024);
3083 diag_register
.unique_id
= 0x7075900;
3084 ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] = 0;
3085 _ctl_diag_register_2(ioc
, &diag_register
);
3086 } else if (!strcmp(str
, "release")) {
3087 /* exit out if host buffers are already released */
3088 if (!ioc
->diag_buffer
[MPI2_DIAG_BUF_TYPE_TRACE
])
3090 if ((ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] &
3091 MPT3_DIAG_BUFFER_IS_REGISTERED
) == 0)
3093 if ((ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] &
3094 MPT3_DIAG_BUFFER_IS_RELEASED
))
3096 pr_info(MPT3SAS_FMT
"releasing host trace buffer\n",
3098 mpt3sas_send_diag_release(ioc
, MPI2_DIAG_BUF_TYPE_TRACE
,
3105 static DEVICE_ATTR(host_trace_buffer_enable
, S_IRUGO
| S_IWUSR
,
3106 _ctl_host_trace_buffer_enable_show
,
3107 _ctl_host_trace_buffer_enable_store
);
3109 /*********** diagnostic trigger suppport *********************************/
3112 * _ctl_diag_trigger_master_show - show the diag_trigger_master attribute
3113 * @cdev - pointer to embedded class device
3114 * @buf - the buffer returned
3116 * A sysfs 'read/write' shost attribute.
3119 _ctl_diag_trigger_master_show(struct device
*cdev
,
3120 struct device_attribute
*attr
, char *buf
)
3123 struct Scsi_Host
*shost
= class_to_shost(cdev
);
3124 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
3125 unsigned long flags
;
3128 spin_lock_irqsave(&ioc
->diag_trigger_lock
, flags
);
3129 rc
= sizeof(struct SL_WH_MASTER_TRIGGER_T
);
3130 memcpy(buf
, &ioc
->diag_trigger_master
, rc
);
3131 spin_unlock_irqrestore(&ioc
->diag_trigger_lock
, flags
);
3136 * _ctl_diag_trigger_master_store - store the diag_trigger_master attribute
3137 * @cdev - pointer to embedded class device
3138 * @buf - the buffer returned
3140 * A sysfs 'read/write' shost attribute.
3143 _ctl_diag_trigger_master_store(struct device
*cdev
,
3144 struct device_attribute
*attr
, const char *buf
, size_t count
)
3147 struct Scsi_Host
*shost
= class_to_shost(cdev
);
3148 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
3149 unsigned long flags
;
3152 spin_lock_irqsave(&ioc
->diag_trigger_lock
, flags
);
3153 rc
= min(sizeof(struct SL_WH_MASTER_TRIGGER_T
), count
);
3154 memset(&ioc
->diag_trigger_master
, 0,
3155 sizeof(struct SL_WH_MASTER_TRIGGER_T
));
3156 memcpy(&ioc
->diag_trigger_master
, buf
, rc
);
3157 ioc
->diag_trigger_master
.MasterData
|=
3158 (MASTER_TRIGGER_FW_FAULT
+ MASTER_TRIGGER_ADAPTER_RESET
);
3159 spin_unlock_irqrestore(&ioc
->diag_trigger_lock
, flags
);
3162 static DEVICE_ATTR(diag_trigger_master
, S_IRUGO
| S_IWUSR
,
3163 _ctl_diag_trigger_master_show
, _ctl_diag_trigger_master_store
);
3167 * _ctl_diag_trigger_event_show - show the diag_trigger_event attribute
3168 * @cdev - pointer to embedded class device
3169 * @buf - the buffer returned
3171 * A sysfs 'read/write' shost attribute.
3174 _ctl_diag_trigger_event_show(struct device
*cdev
,
3175 struct device_attribute
*attr
, char *buf
)
3177 struct Scsi_Host
*shost
= class_to_shost(cdev
);
3178 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
3179 unsigned long flags
;
3182 spin_lock_irqsave(&ioc
->diag_trigger_lock
, flags
);
3183 rc
= sizeof(struct SL_WH_EVENT_TRIGGERS_T
);
3184 memcpy(buf
, &ioc
->diag_trigger_event
, rc
);
3185 spin_unlock_irqrestore(&ioc
->diag_trigger_lock
, flags
);
3190 * _ctl_diag_trigger_event_store - store the diag_trigger_event attribute
3191 * @cdev - pointer to embedded class device
3192 * @buf - the buffer returned
3194 * A sysfs 'read/write' shost attribute.
3197 _ctl_diag_trigger_event_store(struct device
*cdev
,
3198 struct device_attribute
*attr
, const char *buf
, size_t count
)
3201 struct Scsi_Host
*shost
= class_to_shost(cdev
);
3202 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
3203 unsigned long flags
;
3206 spin_lock_irqsave(&ioc
->diag_trigger_lock
, flags
);
3207 sz
= min(sizeof(struct SL_WH_EVENT_TRIGGERS_T
), count
);
3208 memset(&ioc
->diag_trigger_event
, 0,
3209 sizeof(struct SL_WH_EVENT_TRIGGERS_T
));
3210 memcpy(&ioc
->diag_trigger_event
, buf
, sz
);
3211 if (ioc
->diag_trigger_event
.ValidEntries
> NUM_VALID_ENTRIES
)
3212 ioc
->diag_trigger_event
.ValidEntries
= NUM_VALID_ENTRIES
;
3213 spin_unlock_irqrestore(&ioc
->diag_trigger_lock
, flags
);
3216 static DEVICE_ATTR(diag_trigger_event
, S_IRUGO
| S_IWUSR
,
3217 _ctl_diag_trigger_event_show
, _ctl_diag_trigger_event_store
);
3221 * _ctl_diag_trigger_scsi_show - show the diag_trigger_scsi attribute
3222 * @cdev - pointer to embedded class device
3223 * @buf - the buffer returned
3225 * A sysfs 'read/write' shost attribute.
3228 _ctl_diag_trigger_scsi_show(struct device
*cdev
,
3229 struct device_attribute
*attr
, char *buf
)
3231 struct Scsi_Host
*shost
= class_to_shost(cdev
);
3232 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
3233 unsigned long flags
;
3236 spin_lock_irqsave(&ioc
->diag_trigger_lock
, flags
);
3237 rc
= sizeof(struct SL_WH_SCSI_TRIGGERS_T
);
3238 memcpy(buf
, &ioc
->diag_trigger_scsi
, rc
);
3239 spin_unlock_irqrestore(&ioc
->diag_trigger_lock
, flags
);
3244 * _ctl_diag_trigger_scsi_store - store the diag_trigger_scsi attribute
3245 * @cdev - pointer to embedded class device
3246 * @buf - the buffer returned
3248 * A sysfs 'read/write' shost attribute.
3251 _ctl_diag_trigger_scsi_store(struct device
*cdev
,
3252 struct device_attribute
*attr
, const char *buf
, size_t count
)
3254 struct Scsi_Host
*shost
= class_to_shost(cdev
);
3255 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
3256 unsigned long flags
;
3259 spin_lock_irqsave(&ioc
->diag_trigger_lock
, flags
);
3260 sz
= min(sizeof(struct SL_WH_SCSI_TRIGGERS_T
), count
);
3261 memset(&ioc
->diag_trigger_scsi
, 0,
3262 sizeof(struct SL_WH_EVENT_TRIGGERS_T
));
3263 memcpy(&ioc
->diag_trigger_scsi
, buf
, sz
);
3264 if (ioc
->diag_trigger_scsi
.ValidEntries
> NUM_VALID_ENTRIES
)
3265 ioc
->diag_trigger_scsi
.ValidEntries
= NUM_VALID_ENTRIES
;
3266 spin_unlock_irqrestore(&ioc
->diag_trigger_lock
, flags
);
3269 static DEVICE_ATTR(diag_trigger_scsi
, S_IRUGO
| S_IWUSR
,
3270 _ctl_diag_trigger_scsi_show
, _ctl_diag_trigger_scsi_store
);
3274 * _ctl_diag_trigger_scsi_show - show the diag_trigger_mpi attribute
3275 * @cdev - pointer to embedded class device
3276 * @buf - the buffer returned
3278 * A sysfs 'read/write' shost attribute.
3281 _ctl_diag_trigger_mpi_show(struct device
*cdev
,
3282 struct device_attribute
*attr
, char *buf
)
3284 struct Scsi_Host
*shost
= class_to_shost(cdev
);
3285 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
3286 unsigned long flags
;
3289 spin_lock_irqsave(&ioc
->diag_trigger_lock
, flags
);
3290 rc
= sizeof(struct SL_WH_MPI_TRIGGERS_T
);
3291 memcpy(buf
, &ioc
->diag_trigger_mpi
, rc
);
3292 spin_unlock_irqrestore(&ioc
->diag_trigger_lock
, flags
);
3297 * _ctl_diag_trigger_mpi_store - store the diag_trigger_mpi attribute
3298 * @cdev - pointer to embedded class device
3299 * @buf - the buffer returned
3301 * A sysfs 'read/write' shost attribute.
3304 _ctl_diag_trigger_mpi_store(struct device
*cdev
,
3305 struct device_attribute
*attr
, const char *buf
, size_t count
)
3307 struct Scsi_Host
*shost
= class_to_shost(cdev
);
3308 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
3309 unsigned long flags
;
3312 spin_lock_irqsave(&ioc
->diag_trigger_lock
, flags
);
3313 sz
= min(sizeof(struct SL_WH_MPI_TRIGGERS_T
), count
);
3314 memset(&ioc
->diag_trigger_mpi
, 0,
3315 sizeof(ioc
->diag_trigger_mpi
));
3316 memcpy(&ioc
->diag_trigger_mpi
, buf
, sz
);
3317 if (ioc
->diag_trigger_mpi
.ValidEntries
> NUM_VALID_ENTRIES
)
3318 ioc
->diag_trigger_mpi
.ValidEntries
= NUM_VALID_ENTRIES
;
3319 spin_unlock_irqrestore(&ioc
->diag_trigger_lock
, flags
);
3323 static DEVICE_ATTR(diag_trigger_mpi
, S_IRUGO
| S_IWUSR
,
3324 _ctl_diag_trigger_mpi_show
, _ctl_diag_trigger_mpi_store
);
3326 /*********** diagnostic trigger suppport *** END ****************************/
3330 /*****************************************/
3332 struct device_attribute
*mpt3sas_host_attrs
[] = {
3333 &dev_attr_version_fw
,
3334 &dev_attr_version_bios
,
3335 &dev_attr_version_mpi
,
3336 &dev_attr_version_product
,
3337 &dev_attr_version_nvdata_persistent
,
3338 &dev_attr_version_nvdata_default
,
3339 &dev_attr_board_name
,
3340 &dev_attr_board_assembly
,
3341 &dev_attr_board_tracer
,
3343 &dev_attr_device_delay
,
3344 &dev_attr_logging_level
,
3345 &dev_attr_fwfault_debug
,
3346 &dev_attr_fw_queue_depth
,
3347 &dev_attr_host_sas_address
,
3348 &dev_attr_ioc_reset_count
,
3349 &dev_attr_host_trace_buffer_size
,
3350 &dev_attr_host_trace_buffer
,
3351 &dev_attr_host_trace_buffer_enable
,
3352 &dev_attr_reply_queue_count
,
3353 &dev_attr_diag_trigger_master
,
3354 &dev_attr_diag_trigger_event
,
3355 &dev_attr_diag_trigger_scsi
,
3356 &dev_attr_diag_trigger_mpi
,
3357 &dev_attr_BRM_status
,
3361 /* device attributes */
3364 * _ctl_device_sas_address_show - sas address
3365 * @cdev - pointer to embedded class device
3366 * @buf - the buffer returned
3368 * This is the sas address for the target
3370 * A sysfs 'read-only' shost attribute.
3373 _ctl_device_sas_address_show(struct device
*dev
, struct device_attribute
*attr
,
3376 struct scsi_device
*sdev
= to_scsi_device(dev
);
3377 struct MPT3SAS_DEVICE
*sas_device_priv_data
= sdev
->hostdata
;
3379 return snprintf(buf
, PAGE_SIZE
, "0x%016llx\n",
3380 (unsigned long long)sas_device_priv_data
->sas_target
->sas_address
);
3382 static DEVICE_ATTR(sas_address
, S_IRUGO
, _ctl_device_sas_address_show
, NULL
);
3385 * _ctl_device_handle_show - device handle
3386 * @cdev - pointer to embedded class device
3387 * @buf - the buffer returned
3389 * This is the firmware assigned device handle
3391 * A sysfs 'read-only' shost attribute.
3394 _ctl_device_handle_show(struct device
*dev
, struct device_attribute
*attr
,
3397 struct scsi_device
*sdev
= to_scsi_device(dev
);
3398 struct MPT3SAS_DEVICE
*sas_device_priv_data
= sdev
->hostdata
;
3400 return snprintf(buf
, PAGE_SIZE
, "0x%04x\n",
3401 sas_device_priv_data
->sas_target
->handle
);
3403 static DEVICE_ATTR(sas_device_handle
, S_IRUGO
, _ctl_device_handle_show
, NULL
);
3405 struct device_attribute
*mpt3sas_dev_attrs
[] = {
3406 &dev_attr_sas_address
,
3407 &dev_attr_sas_device_handle
,
3411 /* file operations table for mpt3ctl device */
3412 static const struct file_operations ctl_fops
= {
3413 .owner
= THIS_MODULE
,
3414 .unlocked_ioctl
= _ctl_ioctl
,
3416 .fasync
= _ctl_fasync
,
3417 #ifdef CONFIG_COMPAT
3418 .compat_ioctl
= _ctl_ioctl_compat
,
3422 /* file operations table for mpt2ctl device */
3423 static const struct file_operations ctl_gen2_fops
= {
3424 .owner
= THIS_MODULE
,
3425 .unlocked_ioctl
= _ctl_mpt2_ioctl
,
3427 .fasync
= _ctl_fasync
,
3428 #ifdef CONFIG_COMPAT
3429 .compat_ioctl
= _ctl_mpt2_ioctl_compat
,
3433 static struct miscdevice ctl_dev
= {
3434 .minor
= MPT3SAS_MINOR
,
3435 .name
= MPT3SAS_DEV_NAME
,
3439 static struct miscdevice gen2_ctl_dev
= {
3440 .minor
= MPT2SAS_MINOR
,
3441 .name
= MPT2SAS_DEV_NAME
,
3442 .fops
= &ctl_gen2_fops
,
3446 * mpt3sas_ctl_init - main entry point for ctl.
3450 mpt3sas_ctl_init(ushort hbas_to_enumerate
)
3454 /* Don't register mpt3ctl ioctl device if
3455 * hbas_to_enumarate is one.
3457 if (hbas_to_enumerate
!= 1)
3458 if (misc_register(&ctl_dev
) < 0)
3459 pr_err("%s can't register misc device [minor=%d]\n",
3460 MPT3SAS_DRIVER_NAME
, MPT3SAS_MINOR
);
3462 /* Don't register mpt3ctl ioctl device if
3463 * hbas_to_enumarate is two.
3465 if (hbas_to_enumerate
!= 2)
3466 if (misc_register(&gen2_ctl_dev
) < 0)
3467 pr_err("%s can't register misc device [minor=%d]\n",
3468 MPT2SAS_DRIVER_NAME
, MPT2SAS_MINOR
);
3470 init_waitqueue_head(&ctl_poll_wait
);
3474 * mpt3sas_ctl_exit - exit point for ctl
3478 mpt3sas_ctl_exit(ushort hbas_to_enumerate
)
3480 struct MPT3SAS_ADAPTER
*ioc
;
3483 list_for_each_entry(ioc
, &mpt3sas_ioc_list
, list
) {
3485 /* free memory associated to diag buffers */
3486 for (i
= 0; i
< MPI2_DIAG_BUF_TYPE_COUNT
; i
++) {
3487 if (!ioc
->diag_buffer
[i
])
3489 if (!(ioc
->diag_buffer_status
[i
] &
3490 MPT3_DIAG_BUFFER_IS_REGISTERED
))
3492 if ((ioc
->diag_buffer_status
[i
] &
3493 MPT3_DIAG_BUFFER_IS_RELEASED
))
3495 pci_free_consistent(ioc
->pdev
, ioc
->diag_buffer_sz
[i
],
3496 ioc
->diag_buffer
[i
], ioc
->diag_buffer_dma
[i
]);
3497 ioc
->diag_buffer
[i
] = NULL
;
3498 ioc
->diag_buffer_status
[i
] = 0;
3501 kfree(ioc
->event_log
);
3503 if (hbas_to_enumerate
!= 1)
3504 misc_deregister(&ctl_dev
);
3505 if (hbas_to_enumerate
!= 2)
3506 misc_deregister(&gen2_ctl_dev
);