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-2013 LSI Corporation
7 * (mailto:DL-MPTFusionLinux@lsi.com)
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 2
12 * of the License, or (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
20 * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
21 * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
22 * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
23 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
24 * solely responsible for determining the appropriateness of using and
25 * distributing the Program and assumes all risks associated with its
26 * exercise of rights under this Agreement, including but not limited to
27 * the risks and costs of program errors, damage to or loss of data,
28 * programs or equipment, and unavailability or interruption of operations.
30 * DISCLAIMER OF LIABILITY
31 * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
32 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
34 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
35 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
36 * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
37 * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
39 * You should have received a copy of the GNU General Public License
40 * along with this program; if not, write to the Free Software
41 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
45 #include <linux/kernel.h>
46 #include <linux/module.h>
47 #include <linux/errno.h>
48 #include <linux/init.h>
49 #include <linux/slab.h>
50 #include <linux/types.h>
51 #include <linux/pci.h>
52 #include <linux/delay.h>
53 #include <linux/compat.h>
54 #include <linux/poll.h>
57 #include <linux/uaccess.h>
59 #include "mpt3sas_base.h"
60 #include "mpt3sas_ctl.h"
63 static struct fasync_struct
*async_queue
;
64 static DECLARE_WAIT_QUEUE_HEAD(ctl_poll_wait
);
68 * enum block_state - blocking state
69 * @NON_BLOCKING: non blocking
72 * These states are for ioctls that need to wait for a response
73 * from firmware, so they probably require sleep.
80 #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
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
);
259 * mpt3sas_ctl_done - ctl module completion routine
260 * @ioc: per adapter object
261 * @smid: system request message index
262 * @msix_index: MSIX table index supplied by the OS
263 * @reply: reply message frame(lower 32bit addr)
266 * The callback handler when using ioc->ctl_cb_idx.
268 * Return 1 meaning mf should be freed from _base_interrupt
269 * 0 means the mf is freed from this function.
272 mpt3sas_ctl_done(struct MPT3SAS_ADAPTER
*ioc
, u16 smid
, u8 msix_index
,
275 MPI2DefaultReply_t
*mpi_reply
;
276 Mpi2SCSIIOReply_t
*scsiio_reply
;
277 const void *sense_data
;
280 if (ioc
->ctl_cmds
.status
== MPT3_CMD_NOT_USED
)
282 if (ioc
->ctl_cmds
.smid
!= smid
)
284 ioc
->ctl_cmds
.status
|= MPT3_CMD_COMPLETE
;
285 mpi_reply
= mpt3sas_base_get_reply_virt_addr(ioc
, reply
);
287 memcpy(ioc
->ctl_cmds
.reply
, mpi_reply
, mpi_reply
->MsgLength
*4);
288 ioc
->ctl_cmds
.status
|= MPT3_CMD_REPLY_VALID
;
290 if (mpi_reply
->Function
== MPI2_FUNCTION_SCSI_IO_REQUEST
||
291 mpi_reply
->Function
==
292 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
) {
293 scsiio_reply
= (Mpi2SCSIIOReply_t
*)mpi_reply
;
294 if (scsiio_reply
->SCSIState
&
295 MPI2_SCSI_STATE_AUTOSENSE_VALID
) {
296 sz
= min_t(u32
, SCSI_SENSE_BUFFERSIZE
,
297 le32_to_cpu(scsiio_reply
->SenseCount
));
298 sense_data
= mpt3sas_base_get_sense_buffer(ioc
,
300 memcpy(ioc
->ctl_cmds
.sense
, sense_data
, sz
);
304 #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
305 _ctl_display_some_debug(ioc
, smid
, "ctl_done", mpi_reply
);
307 ioc
->ctl_cmds
.status
&= ~MPT3_CMD_PENDING
;
308 complete(&ioc
->ctl_cmds
.done
);
313 * _ctl_check_event_type - determines when an event needs logging
314 * @ioc: per adapter object
315 * @event: firmware event
317 * The bitmask in ioc->event_type[] indicates which events should be
318 * be saved in the driver event_log. This bitmask is set by application.
320 * Returns 1 when event should be captured, or zero means no match.
323 _ctl_check_event_type(struct MPT3SAS_ADAPTER
*ioc
, u16 event
)
328 if (event
>= 128 || !event
|| !ioc
->event_log
)
331 desired_event
= (1 << (event
% 32));
335 return desired_event
& ioc
->event_type
[i
];
339 * mpt3sas_ctl_add_to_event_log - add event
340 * @ioc: per adapter object
341 * @mpi_reply: reply message frame
346 mpt3sas_ctl_add_to_event_log(struct MPT3SAS_ADAPTER
*ioc
,
347 Mpi2EventNotificationReply_t
*mpi_reply
)
349 struct MPT3_IOCTL_EVENTS
*event_log
;
352 u32 sz
, event_data_sz
;
358 event
= le16_to_cpu(mpi_reply
->Event
);
360 if (_ctl_check_event_type(ioc
, event
)) {
362 /* insert entry into circular event_log */
363 i
= ioc
->event_context
% MPT3SAS_CTL_EVENT_LOG_SIZE
;
364 event_log
= ioc
->event_log
;
365 event_log
[i
].event
= event
;
366 event_log
[i
].context
= ioc
->event_context
++;
368 event_data_sz
= le16_to_cpu(mpi_reply
->EventDataLength
)*4;
369 sz
= min_t(u32
, event_data_sz
, MPT3_EVENT_DATA_SIZE
);
370 memset(event_log
[i
].data
, 0, MPT3_EVENT_DATA_SIZE
);
371 memcpy(event_log
[i
].data
, mpi_reply
->EventData
, sz
);
375 /* This aen_event_read_flag flag is set until the
376 * application has read the event log.
377 * For MPI2_EVENT_LOG_ENTRY_ADDED, we always notify.
379 if (event
== MPI2_EVENT_LOG_ENTRY_ADDED
||
380 (send_aen
&& !ioc
->aen_event_read_flag
)) {
381 ioc
->aen_event_read_flag
= 1;
382 wake_up_interruptible(&ctl_poll_wait
);
384 kill_fasync(&async_queue
, SIGIO
, POLL_IN
);
389 * mpt3sas_ctl_event_callback - firmware event handler (called at ISR time)
390 * @ioc: per adapter object
391 * @msix_index: MSIX table index supplied by the OS
392 * @reply: reply message frame(lower 32bit addr)
393 * Context: interrupt.
395 * This function merely adds a new work task into ioc->firmware_event_thread.
396 * The tasks are worked from _firmware_event_work in user context.
398 * Return 1 meaning mf should be freed from _base_interrupt
399 * 0 means the mf is freed from this function.
402 mpt3sas_ctl_event_callback(struct MPT3SAS_ADAPTER
*ioc
, u8 msix_index
,
405 Mpi2EventNotificationReply_t
*mpi_reply
;
407 mpi_reply
= mpt3sas_base_get_reply_virt_addr(ioc
, reply
);
408 mpt3sas_ctl_add_to_event_log(ioc
, mpi_reply
);
413 * _ctl_verify_adapter - validates ioc_number passed from application
414 * @ioc: per adapter object
415 * @iocpp: The ioc pointer is returned in this.
417 * Return (-1) means error, else ioc_number.
420 _ctl_verify_adapter(int ioc_number
, struct MPT3SAS_ADAPTER
**iocpp
)
422 struct MPT3SAS_ADAPTER
*ioc
;
424 list_for_each_entry(ioc
, &mpt3sas_ioc_list
, list
) {
425 if (ioc
->id
!= ioc_number
)
435 * mpt3sas_ctl_reset_handler - reset callback handler (for ctl)
436 * @ioc: per adapter object
437 * @reset_phase: phase
439 * The handler for doing any required cleanup or initialization.
441 * The reset phase can be MPT3_IOC_PRE_RESET, MPT3_IOC_AFTER_RESET,
442 * MPT3_IOC_DONE_RESET
445 mpt3sas_ctl_reset_handler(struct MPT3SAS_ADAPTER
*ioc
, int reset_phase
)
450 switch (reset_phase
) {
451 case MPT3_IOC_PRE_RESET
:
452 dtmprintk(ioc
, pr_info(MPT3SAS_FMT
453 "%s: MPT3_IOC_PRE_RESET\n", ioc
->name
, __func__
));
454 for (i
= 0; i
< MPI2_DIAG_BUF_TYPE_COUNT
; i
++) {
455 if (!(ioc
->diag_buffer_status
[i
] &
456 MPT3_DIAG_BUFFER_IS_REGISTERED
))
458 if ((ioc
->diag_buffer_status
[i
] &
459 MPT3_DIAG_BUFFER_IS_RELEASED
))
461 mpt3sas_send_diag_release(ioc
, i
, &issue_reset
);
464 case MPT3_IOC_AFTER_RESET
:
465 dtmprintk(ioc
, pr_info(MPT3SAS_FMT
466 "%s: MPT3_IOC_AFTER_RESET\n", ioc
->name
, __func__
));
467 if (ioc
->ctl_cmds
.status
& MPT3_CMD_PENDING
) {
468 ioc
->ctl_cmds
.status
|= MPT3_CMD_RESET
;
469 mpt3sas_base_free_smid(ioc
, ioc
->ctl_cmds
.smid
);
470 complete(&ioc
->ctl_cmds
.done
);
473 case MPT3_IOC_DONE_RESET
:
474 dtmprintk(ioc
, pr_info(MPT3SAS_FMT
475 "%s: MPT3_IOC_DONE_RESET\n", ioc
->name
, __func__
));
477 for (i
= 0; i
< MPI2_DIAG_BUF_TYPE_COUNT
; i
++) {
478 if (!(ioc
->diag_buffer_status
[i
] &
479 MPT3_DIAG_BUFFER_IS_REGISTERED
))
481 if ((ioc
->diag_buffer_status
[i
] &
482 MPT3_DIAG_BUFFER_IS_RELEASED
))
484 ioc
->diag_buffer_status
[i
] |=
485 MPT3_DIAG_BUFFER_IS_DIAG_RESET
;
497 * Called when application request fasyn callback handler.
500 _ctl_fasync(int fd
, struct file
*filep
, int mode
)
502 return fasync_helper(fd
, filep
, mode
, &async_queue
);
512 _ctl_poll(struct file
*filep
, poll_table
*wait
)
514 struct MPT3SAS_ADAPTER
*ioc
;
516 poll_wait(filep
, &ctl_poll_wait
, wait
);
518 list_for_each_entry(ioc
, &mpt3sas_ioc_list
, list
) {
519 if (ioc
->aen_event_read_flag
)
520 return POLLIN
| POLLRDNORM
;
526 * _ctl_set_task_mid - assign an active smid to tm request
527 * @ioc: per adapter object
528 * @karg - (struct mpt3_ioctl_command)
529 * @tm_request - pointer to mf from user space
531 * Returns 0 when an smid if found, else fail.
532 * during failure, the reply frame is filled.
535 _ctl_set_task_mid(struct MPT3SAS_ADAPTER
*ioc
, struct mpt3_ioctl_command
*karg
,
536 Mpi2SCSITaskManagementRequest_t
*tm_request
)
541 struct scsi_cmnd
*scmd
;
542 struct MPT3SAS_DEVICE
*priv_data
;
544 Mpi2SCSITaskManagementReply_t
*tm_reply
;
549 if (tm_request
->TaskType
== MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK
)
551 else if (tm_request
->TaskType
== MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK
)
556 lun
= scsilun_to_int((struct scsi_lun
*)tm_request
->LUN
);
558 handle
= le16_to_cpu(tm_request
->DevHandle
);
559 spin_lock_irqsave(&ioc
->scsi_lookup_lock
, flags
);
560 for (i
= ioc
->scsiio_depth
; i
&& !found
; i
--) {
561 scmd
= ioc
->scsi_lookup
[i
- 1].scmd
;
562 if (scmd
== NULL
|| scmd
->device
== NULL
||
563 scmd
->device
->hostdata
== NULL
)
565 if (lun
!= scmd
->device
->lun
)
567 priv_data
= scmd
->device
->hostdata
;
568 if (priv_data
->sas_target
== NULL
)
570 if (priv_data
->sas_target
->handle
!= handle
)
572 tm_request
->TaskMID
= cpu_to_le16(ioc
->scsi_lookup
[i
- 1].smid
);
575 spin_unlock_irqrestore(&ioc
->scsi_lookup_lock
, flags
);
578 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
579 "%s: handle(0x%04x), lun(%d), no active mid!!\n",
581 desc
, le16_to_cpu(tm_request
->DevHandle
), lun
));
582 tm_reply
= ioc
->ctl_cmds
.reply
;
583 tm_reply
->DevHandle
= tm_request
->DevHandle
;
584 tm_reply
->Function
= MPI2_FUNCTION_SCSI_TASK_MGMT
;
585 tm_reply
->TaskType
= tm_request
->TaskType
;
586 tm_reply
->MsgLength
= sizeof(Mpi2SCSITaskManagementReply_t
)/4;
587 tm_reply
->VP_ID
= tm_request
->VP_ID
;
588 tm_reply
->VF_ID
= tm_request
->VF_ID
;
589 sz
= min_t(u32
, karg
->max_reply_bytes
, ioc
->reply_sz
);
590 if (copy_to_user(karg
->reply_frame_buf_ptr
, ioc
->ctl_cmds
.reply
,
592 pr_err("failure at %s:%d/%s()!\n", __FILE__
,
597 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
598 "%s: handle(0x%04x), lun(%d), task_mid(%d)\n", ioc
->name
,
599 desc
, le16_to_cpu(tm_request
->DevHandle
), lun
,
600 le16_to_cpu(tm_request
->TaskMID
)));
605 * _ctl_do_mpt_command - main handler for MPT3COMMAND opcode
606 * @ioc: per adapter object
607 * @karg - (struct mpt3_ioctl_command)
608 * @mf - pointer to mf in user space
611 _ctl_do_mpt_command(struct MPT3SAS_ADAPTER
*ioc
, struct mpt3_ioctl_command karg
,
614 MPI2RequestHeader_t
*mpi_request
= NULL
, *request
;
615 MPI2DefaultReply_t
*mpi_reply
;
619 unsigned long timeout
, timeleft
;
623 void *data_out
= NULL
;
624 dma_addr_t data_out_dma
= 0;
625 size_t data_out_sz
= 0;
626 void *data_in
= NULL
;
627 dma_addr_t data_in_dma
= 0;
628 size_t data_in_sz
= 0;
630 u16 wait_state_count
;
634 if (ioc
->ctl_cmds
.status
!= MPT3_CMD_NOT_USED
) {
635 pr_err(MPT3SAS_FMT
"%s: ctl_cmd in use\n",
636 ioc
->name
, __func__
);
641 wait_state_count
= 0;
642 ioc_state
= mpt3sas_base_get_iocstate(ioc
, 1);
643 while (ioc_state
!= MPI2_IOC_STATE_OPERATIONAL
) {
644 if (wait_state_count
++ == 10) {
646 "%s: failed due to ioc not operational\n",
647 ioc
->name
, __func__
);
652 ioc_state
= mpt3sas_base_get_iocstate(ioc
, 1);
654 "%s: waiting for operational state(count=%d)\n",
656 __func__
, wait_state_count
);
658 if (wait_state_count
)
659 pr_info(MPT3SAS_FMT
"%s: ioc is operational\n",
660 ioc
->name
, __func__
);
662 mpi_request
= kzalloc(ioc
->request_sz
, GFP_KERNEL
);
665 "%s: failed obtaining a memory for mpi_request\n",
666 ioc
->name
, __func__
);
671 /* Check for overflow and wraparound */
672 if (karg
.data_sge_offset
* 4 > ioc
->request_sz
||
673 karg
.data_sge_offset
> (UINT_MAX
/ 4)) {
678 /* copy in request message frame from user */
679 if (copy_from_user(mpi_request
, mf
, karg
.data_sge_offset
*4)) {
680 pr_err("failure at %s:%d/%s()!\n", __FILE__
, __LINE__
,
686 if (mpi_request
->Function
== MPI2_FUNCTION_SCSI_TASK_MGMT
) {
687 smid
= mpt3sas_base_get_smid_hpr(ioc
, ioc
->ctl_cb_idx
);
689 pr_err(MPT3SAS_FMT
"%s: failed obtaining a smid\n",
690 ioc
->name
, __func__
);
696 smid
= mpt3sas_base_get_smid_scsiio(ioc
, ioc
->ctl_cb_idx
, NULL
);
698 pr_err(MPT3SAS_FMT
"%s: failed obtaining a smid\n",
699 ioc
->name
, __func__
);
706 ioc
->ctl_cmds
.status
= MPT3_CMD_PENDING
;
707 memset(ioc
->ctl_cmds
.reply
, 0, ioc
->reply_sz
);
708 request
= mpt3sas_base_get_msg_frame(ioc
, smid
);
709 memcpy(request
, mpi_request
, karg
.data_sge_offset
*4);
710 ioc
->ctl_cmds
.smid
= smid
;
711 data_out_sz
= karg
.data_out_size
;
712 data_in_sz
= karg
.data_in_size
;
714 if (mpi_request
->Function
== MPI2_FUNCTION_SCSI_IO_REQUEST
||
715 mpi_request
->Function
== MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
) {
716 if (!le16_to_cpu(mpi_request
->FunctionDependent1
) ||
717 le16_to_cpu(mpi_request
->FunctionDependent1
) >
718 ioc
->facts
.MaxDevHandle
) {
720 mpt3sas_base_free_smid(ioc
, smid
);
725 /* obtain dma-able memory for data transfer */
726 if (data_out_sz
) /* WRITE */ {
727 data_out
= pci_alloc_consistent(ioc
->pdev
, data_out_sz
,
730 pr_err("failure at %s:%d/%s()!\n", __FILE__
,
733 mpt3sas_base_free_smid(ioc
, smid
);
736 if (copy_from_user(data_out
, karg
.data_out_buf_ptr
,
738 pr_err("failure at %s:%d/%s()!\n", __FILE__
,
741 mpt3sas_base_free_smid(ioc
, smid
);
746 if (data_in_sz
) /* READ */ {
747 data_in
= pci_alloc_consistent(ioc
->pdev
, data_in_sz
,
750 pr_err("failure at %s:%d/%s()!\n", __FILE__
,
753 mpt3sas_base_free_smid(ioc
, smid
);
758 psge
= (void *)request
+ (karg
.data_sge_offset
*4);
760 /* send command to firmware */
761 #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
762 _ctl_display_some_debug(ioc
, smid
, "ctl_request", NULL
);
765 init_completion(&ioc
->ctl_cmds
.done
);
766 switch (mpi_request
->Function
) {
767 case MPI2_FUNCTION_SCSI_IO_REQUEST
:
768 case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
:
770 Mpi2SCSIIORequest_t
*scsiio_request
=
771 (Mpi2SCSIIORequest_t
*)request
;
772 scsiio_request
->SenseBufferLength
= SCSI_SENSE_BUFFERSIZE
;
773 scsiio_request
->SenseBufferLowAddress
=
774 mpt3sas_base_get_sense_buffer_dma(ioc
, smid
);
775 memset(ioc
->ctl_cmds
.sense
, 0, SCSI_SENSE_BUFFERSIZE
);
776 ioc
->build_sg(ioc
, psge
, data_out_dma
, data_out_sz
,
777 data_in_dma
, data_in_sz
);
779 if (mpi_request
->Function
== MPI2_FUNCTION_SCSI_IO_REQUEST
)
780 mpt3sas_base_put_smid_scsi_io(ioc
, smid
,
781 le16_to_cpu(mpi_request
->FunctionDependent1
));
783 mpt3sas_base_put_smid_default(ioc
, smid
);
786 case MPI2_FUNCTION_SCSI_TASK_MGMT
:
788 Mpi2SCSITaskManagementRequest_t
*tm_request
=
789 (Mpi2SCSITaskManagementRequest_t
*)request
;
791 dtmprintk(ioc
, pr_info(MPT3SAS_FMT
792 "TASK_MGMT: handle(0x%04x), task_type(0x%02x)\n",
794 le16_to_cpu(tm_request
->DevHandle
), tm_request
->TaskType
));
796 if (tm_request
->TaskType
==
797 MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK
||
798 tm_request
->TaskType
==
799 MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK
) {
800 if (_ctl_set_task_mid(ioc
, &karg
, tm_request
)) {
801 mpt3sas_base_free_smid(ioc
, smid
);
806 mpt3sas_scsih_set_tm_flag(ioc
, le16_to_cpu(
807 tm_request
->DevHandle
));
808 ioc
->build_sg_mpi(ioc
, psge
, data_out_dma
, data_out_sz
,
809 data_in_dma
, data_in_sz
);
810 mpt3sas_base_put_smid_hi_priority(ioc
, smid
);
813 case MPI2_FUNCTION_SMP_PASSTHROUGH
:
815 Mpi2SmpPassthroughRequest_t
*smp_request
=
816 (Mpi2SmpPassthroughRequest_t
*)mpi_request
;
819 /* ioc determines which port to use */
820 smp_request
->PhysicalPort
= 0xFF;
821 if (smp_request
->PassthroughFlags
&
822 MPI2_SMP_PT_REQ_PT_FLAGS_IMMEDIATE
)
823 data
= (u8
*)&smp_request
->SGL
;
825 if (unlikely(data_out
== NULL
)) {
826 pr_err("failure at %s:%d/%s()!\n",
827 __FILE__
, __LINE__
, __func__
);
828 mpt3sas_base_free_smid(ioc
, smid
);
835 if (data
[1] == 0x91 && (data
[10] == 1 || data
[10] == 2)) {
836 ioc
->ioc_link_reset_in_progress
= 1;
837 ioc
->ignore_loginfos
= 1;
839 ioc
->build_sg(ioc
, psge
, data_out_dma
, data_out_sz
, data_in_dma
,
841 mpt3sas_base_put_smid_default(ioc
, smid
);
844 case MPI2_FUNCTION_SATA_PASSTHROUGH
:
845 case MPI2_FUNCTION_FW_DOWNLOAD
:
846 case MPI2_FUNCTION_FW_UPLOAD
:
848 ioc
->build_sg(ioc
, psge
, data_out_dma
, data_out_sz
, data_in_dma
,
850 mpt3sas_base_put_smid_default(ioc
, smid
);
853 case MPI2_FUNCTION_TOOLBOX
:
855 Mpi2ToolboxCleanRequest_t
*toolbox_request
=
856 (Mpi2ToolboxCleanRequest_t
*)mpi_request
;
858 if (toolbox_request
->Tool
== MPI2_TOOLBOX_DIAGNOSTIC_CLI_TOOL
) {
859 ioc
->build_sg(ioc
, psge
, data_out_dma
, data_out_sz
,
860 data_in_dma
, data_in_sz
);
862 ioc
->build_sg_mpi(ioc
, psge
, data_out_dma
, data_out_sz
,
863 data_in_dma
, data_in_sz
);
865 mpt3sas_base_put_smid_default(ioc
, smid
);
868 case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL
:
870 Mpi2SasIoUnitControlRequest_t
*sasiounit_request
=
871 (Mpi2SasIoUnitControlRequest_t
*)mpi_request
;
873 if (sasiounit_request
->Operation
== MPI2_SAS_OP_PHY_HARD_RESET
874 || sasiounit_request
->Operation
==
875 MPI2_SAS_OP_PHY_LINK_RESET
) {
876 ioc
->ioc_link_reset_in_progress
= 1;
877 ioc
->ignore_loginfos
= 1;
879 /* drop to default case for posting the request */
882 ioc
->build_sg_mpi(ioc
, psge
, data_out_dma
, data_out_sz
,
883 data_in_dma
, data_in_sz
);
884 mpt3sas_base_put_smid_default(ioc
, smid
);
888 if (karg
.timeout
< MPT3_IOCTL_DEFAULT_TIMEOUT
)
889 timeout
= MPT3_IOCTL_DEFAULT_TIMEOUT
;
891 timeout
= karg
.timeout
;
892 timeleft
= wait_for_completion_timeout(&ioc
->ctl_cmds
.done
,
894 if (mpi_request
->Function
== MPI2_FUNCTION_SCSI_TASK_MGMT
) {
895 Mpi2SCSITaskManagementRequest_t
*tm_request
=
896 (Mpi2SCSITaskManagementRequest_t
*)mpi_request
;
897 mpt3sas_scsih_clear_tm_flag(ioc
, le16_to_cpu(
898 tm_request
->DevHandle
));
899 mpt3sas_trigger_master(ioc
, MASTER_TRIGGER_TASK_MANAGMENT
);
900 } else if ((mpi_request
->Function
== MPI2_FUNCTION_SMP_PASSTHROUGH
||
901 mpi_request
->Function
== MPI2_FUNCTION_SAS_IO_UNIT_CONTROL
) &&
902 ioc
->ioc_link_reset_in_progress
) {
903 ioc
->ioc_link_reset_in_progress
= 0;
904 ioc
->ignore_loginfos
= 0;
906 if (!(ioc
->ctl_cmds
.status
& MPT3_CMD_COMPLETE
)) {
907 pr_err(MPT3SAS_FMT
"%s: timeout\n", ioc
->name
,
909 _debug_dump_mf(mpi_request
, karg
.data_sge_offset
);
910 if (!(ioc
->ctl_cmds
.status
& MPT3_CMD_RESET
))
912 goto issue_host_reset
;
915 mpi_reply
= ioc
->ctl_cmds
.reply
;
916 ioc_status
= le16_to_cpu(mpi_reply
->IOCStatus
) & MPI2_IOCSTATUS_MASK
;
918 #ifdef CONFIG_SCSI_MPT3SAS_LOGGING
919 if (mpi_reply
->Function
== MPI2_FUNCTION_SCSI_TASK_MGMT
&&
920 (ioc
->logging_level
& MPT_DEBUG_TM
)) {
921 Mpi2SCSITaskManagementReply_t
*tm_reply
=
922 (Mpi2SCSITaskManagementReply_t
*)mpi_reply
;
924 pr_info(MPT3SAS_FMT
"TASK_MGMT: " \
925 "IOCStatus(0x%04x), IOCLogInfo(0x%08x), "
926 "TerminationCount(0x%08x)\n", ioc
->name
,
927 le16_to_cpu(tm_reply
->IOCStatus
),
928 le32_to_cpu(tm_reply
->IOCLogInfo
),
929 le32_to_cpu(tm_reply
->TerminationCount
));
932 /* copy out xdata to user */
934 if (copy_to_user(karg
.data_in_buf_ptr
, data_in
,
936 pr_err("failure at %s:%d/%s()!\n", __FILE__
,
943 /* copy out reply message frame to user */
944 if (karg
.max_reply_bytes
) {
945 sz
= min_t(u32
, karg
.max_reply_bytes
, ioc
->reply_sz
);
946 if (copy_to_user(karg
.reply_frame_buf_ptr
, ioc
->ctl_cmds
.reply
,
948 pr_err("failure at %s:%d/%s()!\n", __FILE__
,
955 /* copy out sense to user */
956 if (karg
.max_sense_bytes
&& (mpi_request
->Function
==
957 MPI2_FUNCTION_SCSI_IO_REQUEST
|| mpi_request
->Function
==
958 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
)) {
959 sz
= min_t(u32
, karg
.max_sense_bytes
, SCSI_SENSE_BUFFERSIZE
);
960 if (copy_to_user(karg
.sense_data_ptr
, ioc
->ctl_cmds
.sense
,
962 pr_err("failure at %s:%d/%s()!\n", __FILE__
,
972 if ((mpi_request
->Function
== MPI2_FUNCTION_SCSI_IO_REQUEST
||
973 mpi_request
->Function
==
974 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
||
975 mpi_request
->Function
== MPI2_FUNCTION_SATA_PASSTHROUGH
)) {
976 pr_info(MPT3SAS_FMT
"issue target reset: handle = (0x%04x)\n",
978 le16_to_cpu(mpi_request
->FunctionDependent1
));
979 mpt3sas_halt_firmware(ioc
);
980 mpt3sas_scsih_issue_tm(ioc
,
981 le16_to_cpu(mpi_request
->FunctionDependent1
), 0, 0,
982 0, MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET
, 0, 30,
985 mpt3sas_base_hard_reset_handler(ioc
, CAN_SLEEP
,
991 /* free memory associated with sg buffers */
993 pci_free_consistent(ioc
->pdev
, data_in_sz
, data_in
,
997 pci_free_consistent(ioc
->pdev
, data_out_sz
, data_out
,
1001 ioc
->ctl_cmds
.status
= MPT3_CMD_NOT_USED
;
1006 * _ctl_getiocinfo - main handler for MPT3IOCINFO opcode
1007 * @ioc: per adapter object
1008 * @arg - user space buffer containing ioctl content
1011 _ctl_getiocinfo(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1013 struct mpt3_ioctl_iocinfo karg
;
1015 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1016 pr_err("failure at %s:%d/%s()!\n",
1017 __FILE__
, __LINE__
, __func__
);
1021 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s: enter\n", ioc
->name
,
1024 memset(&karg
, 0 , sizeof(karg
));
1025 karg
.adapter_type
= MPT3_IOCTL_INTERFACE_SAS3
;
1027 karg
.port_number
= ioc
->pfacts
[0].PortNumber
;
1028 karg
.hw_rev
= ioc
->pdev
->revision
;
1029 karg
.pci_id
= ioc
->pdev
->device
;
1030 karg
.subsystem_device
= ioc
->pdev
->subsystem_device
;
1031 karg
.subsystem_vendor
= ioc
->pdev
->subsystem_vendor
;
1032 karg
.pci_information
.u
.bits
.bus
= ioc
->pdev
->bus
->number
;
1033 karg
.pci_information
.u
.bits
.device
= PCI_SLOT(ioc
->pdev
->devfn
);
1034 karg
.pci_information
.u
.bits
.function
= PCI_FUNC(ioc
->pdev
->devfn
);
1035 karg
.pci_information
.segment_id
= pci_domain_nr(ioc
->pdev
->bus
);
1036 karg
.firmware_version
= ioc
->facts
.FWVersion
.Word
;
1037 strcpy(karg
.driver_version
, MPT3SAS_DRIVER_NAME
);
1038 strcat(karg
.driver_version
, "-");
1039 strcat(karg
.driver_version
, MPT3SAS_DRIVER_VERSION
);
1040 karg
.bios_version
= le32_to_cpu(ioc
->bios_pg3
.BiosVersion
);
1042 if (copy_to_user(arg
, &karg
, sizeof(karg
))) {
1043 pr_err("failure at %s:%d/%s()!\n",
1044 __FILE__
, __LINE__
, __func__
);
1051 * _ctl_eventquery - main handler for MPT3EVENTQUERY opcode
1052 * @ioc: per adapter object
1053 * @arg - user space buffer containing ioctl content
1056 _ctl_eventquery(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1058 struct mpt3_ioctl_eventquery karg
;
1060 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1061 pr_err("failure at %s:%d/%s()!\n",
1062 __FILE__
, __LINE__
, __func__
);
1066 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s: enter\n", ioc
->name
,
1069 karg
.event_entries
= MPT3SAS_CTL_EVENT_LOG_SIZE
;
1070 memcpy(karg
.event_types
, ioc
->event_type
,
1071 MPI2_EVENT_NOTIFY_EVENTMASK_WORDS
* sizeof(u32
));
1073 if (copy_to_user(arg
, &karg
, sizeof(karg
))) {
1074 pr_err("failure at %s:%d/%s()!\n",
1075 __FILE__
, __LINE__
, __func__
);
1082 * _ctl_eventenable - main handler for MPT3EVENTENABLE opcode
1083 * @ioc: per adapter object
1084 * @arg - user space buffer containing ioctl content
1087 _ctl_eventenable(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1089 struct mpt3_ioctl_eventenable karg
;
1091 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1092 pr_err("failure at %s:%d/%s()!\n",
1093 __FILE__
, __LINE__
, __func__
);
1097 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s: enter\n", ioc
->name
,
1100 memcpy(ioc
->event_type
, karg
.event_types
,
1101 MPI2_EVENT_NOTIFY_EVENTMASK_WORDS
* sizeof(u32
));
1102 mpt3sas_base_validate_event_type(ioc
, ioc
->event_type
);
1106 /* initialize event_log */
1107 ioc
->event_context
= 0;
1108 ioc
->aen_event_read_flag
= 0;
1109 ioc
->event_log
= kcalloc(MPT3SAS_CTL_EVENT_LOG_SIZE
,
1110 sizeof(struct MPT3_IOCTL_EVENTS
), GFP_KERNEL
);
1111 if (!ioc
->event_log
) {
1112 pr_err("failure at %s:%d/%s()!\n",
1113 __FILE__
, __LINE__
, __func__
);
1120 * _ctl_eventreport - main handler for MPT3EVENTREPORT opcode
1121 * @ioc: per adapter object
1122 * @arg - user space buffer containing ioctl content
1125 _ctl_eventreport(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1127 struct mpt3_ioctl_eventreport karg
;
1128 u32 number_bytes
, max_events
, max
;
1129 struct mpt3_ioctl_eventreport __user
*uarg
= arg
;
1131 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1132 pr_err("failure at %s:%d/%s()!\n",
1133 __FILE__
, __LINE__
, __func__
);
1137 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s: enter\n", ioc
->name
,
1140 number_bytes
= karg
.hdr
.max_data_size
-
1141 sizeof(struct mpt3_ioctl_header
);
1142 max_events
= number_bytes
/sizeof(struct MPT3_IOCTL_EVENTS
);
1143 max
= min_t(u32
, MPT3SAS_CTL_EVENT_LOG_SIZE
, max_events
);
1145 /* If fewer than 1 event is requested, there must have
1146 * been some type of error.
1148 if (!max
|| !ioc
->event_log
)
1151 number_bytes
= max
* sizeof(struct MPT3_IOCTL_EVENTS
);
1152 if (copy_to_user(uarg
->event_data
, ioc
->event_log
, number_bytes
)) {
1153 pr_err("failure at %s:%d/%s()!\n",
1154 __FILE__
, __LINE__
, __func__
);
1158 /* reset flag so SIGIO can restart */
1159 ioc
->aen_event_read_flag
= 0;
1164 * _ctl_do_reset - main handler for MPT3HARDRESET opcode
1165 * @ioc: per adapter object
1166 * @arg - user space buffer containing ioctl content
1169 _ctl_do_reset(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1171 struct mpt3_ioctl_diag_reset karg
;
1174 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1175 pr_err("failure at %s:%d/%s()!\n",
1176 __FILE__
, __LINE__
, __func__
);
1180 if (ioc
->shost_recovery
|| ioc
->pci_error_recovery
||
1181 ioc
->is_driver_loading
)
1184 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s: enter\n", ioc
->name
,
1187 retval
= mpt3sas_base_hard_reset_handler(ioc
, CAN_SLEEP
,
1189 pr_info(MPT3SAS_FMT
"host reset: %s\n",
1190 ioc
->name
, ((!retval
) ? "SUCCESS" : "FAILED"));
1195 * _ctl_btdh_search_sas_device - searching for sas device
1196 * @ioc: per adapter object
1197 * @btdh: btdh ioctl payload
1200 _ctl_btdh_search_sas_device(struct MPT3SAS_ADAPTER
*ioc
,
1201 struct mpt3_ioctl_btdh_mapping
*btdh
)
1203 struct _sas_device
*sas_device
;
1204 unsigned long flags
;
1207 if (list_empty(&ioc
->sas_device_list
))
1210 spin_lock_irqsave(&ioc
->sas_device_lock
, flags
);
1211 list_for_each_entry(sas_device
, &ioc
->sas_device_list
, list
) {
1212 if (btdh
->bus
== 0xFFFFFFFF && btdh
->id
== 0xFFFFFFFF &&
1213 btdh
->handle
== sas_device
->handle
) {
1214 btdh
->bus
= sas_device
->channel
;
1215 btdh
->id
= sas_device
->id
;
1218 } else if (btdh
->bus
== sas_device
->channel
&& btdh
->id
==
1219 sas_device
->id
&& btdh
->handle
== 0xFFFF) {
1220 btdh
->handle
= sas_device
->handle
;
1226 spin_unlock_irqrestore(&ioc
->sas_device_lock
, flags
);
1231 * _ctl_btdh_search_raid_device - searching for raid device
1232 * @ioc: per adapter object
1233 * @btdh: btdh ioctl payload
1236 _ctl_btdh_search_raid_device(struct MPT3SAS_ADAPTER
*ioc
,
1237 struct mpt3_ioctl_btdh_mapping
*btdh
)
1239 struct _raid_device
*raid_device
;
1240 unsigned long flags
;
1243 if (list_empty(&ioc
->raid_device_list
))
1246 spin_lock_irqsave(&ioc
->raid_device_lock
, flags
);
1247 list_for_each_entry(raid_device
, &ioc
->raid_device_list
, list
) {
1248 if (btdh
->bus
== 0xFFFFFFFF && btdh
->id
== 0xFFFFFFFF &&
1249 btdh
->handle
== raid_device
->handle
) {
1250 btdh
->bus
= raid_device
->channel
;
1251 btdh
->id
= raid_device
->id
;
1254 } else if (btdh
->bus
== raid_device
->channel
&& btdh
->id
==
1255 raid_device
->id
&& btdh
->handle
== 0xFFFF) {
1256 btdh
->handle
= raid_device
->handle
;
1262 spin_unlock_irqrestore(&ioc
->raid_device_lock
, flags
);
1267 * _ctl_btdh_mapping - main handler for MPT3BTDHMAPPING opcode
1268 * @ioc: per adapter object
1269 * @arg - user space buffer containing ioctl content
1272 _ctl_btdh_mapping(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1274 struct mpt3_ioctl_btdh_mapping karg
;
1277 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1278 pr_err("failure at %s:%d/%s()!\n",
1279 __FILE__
, __LINE__
, __func__
);
1283 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s\n", ioc
->name
,
1286 rc
= _ctl_btdh_search_sas_device(ioc
, &karg
);
1288 _ctl_btdh_search_raid_device(ioc
, &karg
);
1290 if (copy_to_user(arg
, &karg
, sizeof(karg
))) {
1291 pr_err("failure at %s:%d/%s()!\n",
1292 __FILE__
, __LINE__
, __func__
);
1299 * _ctl_diag_capability - return diag buffer capability
1300 * @ioc: per adapter object
1301 * @buffer_type: specifies either TRACE, SNAPSHOT, or EXTENDED
1303 * returns 1 when diag buffer support is enabled in firmware
1306 _ctl_diag_capability(struct MPT3SAS_ADAPTER
*ioc
, u8 buffer_type
)
1310 switch (buffer_type
) {
1311 case MPI2_DIAG_BUF_TYPE_TRACE
:
1312 if (ioc
->facts
.IOCCapabilities
&
1313 MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER
)
1316 case MPI2_DIAG_BUF_TYPE_SNAPSHOT
:
1317 if (ioc
->facts
.IOCCapabilities
&
1318 MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER
)
1321 case MPI2_DIAG_BUF_TYPE_EXTENDED
:
1322 if (ioc
->facts
.IOCCapabilities
&
1323 MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER
)
1332 * _ctl_diag_register_2 - wrapper for registering diag buffer support
1333 * @ioc: per adapter object
1334 * @diag_register: the diag_register struct passed in from user space
1338 _ctl_diag_register_2(struct MPT3SAS_ADAPTER
*ioc
,
1339 struct mpt3_diag_register
*diag_register
)
1342 void *request_data
= NULL
;
1343 dma_addr_t request_data_dma
;
1344 u32 request_data_sz
= 0;
1345 Mpi2DiagBufferPostRequest_t
*mpi_request
;
1346 Mpi2DiagBufferPostReply_t
*mpi_reply
;
1348 unsigned long timeleft
;
1354 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s\n", ioc
->name
,
1357 ioc_state
= mpt3sas_base_get_iocstate(ioc
, 1);
1358 if (ioc_state
!= MPI2_IOC_STATE_OPERATIONAL
) {
1360 "%s: failed due to ioc not operational\n",
1361 ioc
->name
, __func__
);
1366 if (ioc
->ctl_cmds
.status
!= MPT3_CMD_NOT_USED
) {
1367 pr_err(MPT3SAS_FMT
"%s: ctl_cmd in use\n",
1368 ioc
->name
, __func__
);
1373 buffer_type
= diag_register
->buffer_type
;
1374 if (!_ctl_diag_capability(ioc
, buffer_type
)) {
1376 "%s: doesn't have capability for buffer_type(0x%02x)\n",
1377 ioc
->name
, __func__
, buffer_type
);
1381 if (ioc
->diag_buffer_status
[buffer_type
] &
1382 MPT3_DIAG_BUFFER_IS_REGISTERED
) {
1384 "%s: already has a registered buffer for buffer_type(0x%02x)\n",
1385 ioc
->name
, __func__
,
1390 if (diag_register
->requested_buffer_size
% 4) {
1392 "%s: the requested_buffer_size is not 4 byte aligned\n",
1393 ioc
->name
, __func__
);
1397 smid
= mpt3sas_base_get_smid(ioc
, ioc
->ctl_cb_idx
);
1399 pr_err(MPT3SAS_FMT
"%s: failed obtaining a smid\n",
1400 ioc
->name
, __func__
);
1406 ioc
->ctl_cmds
.status
= MPT3_CMD_PENDING
;
1407 memset(ioc
->ctl_cmds
.reply
, 0, ioc
->reply_sz
);
1408 mpi_request
= mpt3sas_base_get_msg_frame(ioc
, smid
);
1409 ioc
->ctl_cmds
.smid
= smid
;
1411 request_data
= ioc
->diag_buffer
[buffer_type
];
1412 request_data_sz
= diag_register
->requested_buffer_size
;
1413 ioc
->unique_id
[buffer_type
] = diag_register
->unique_id
;
1414 ioc
->diag_buffer_status
[buffer_type
] = 0;
1415 memcpy(ioc
->product_specific
[buffer_type
],
1416 diag_register
->product_specific
, MPT3_PRODUCT_SPECIFIC_DWORDS
);
1417 ioc
->diagnostic_flags
[buffer_type
] = diag_register
->diagnostic_flags
;
1420 request_data_dma
= ioc
->diag_buffer_dma
[buffer_type
];
1421 if (request_data_sz
!= ioc
->diag_buffer_sz
[buffer_type
]) {
1422 pci_free_consistent(ioc
->pdev
,
1423 ioc
->diag_buffer_sz
[buffer_type
],
1424 request_data
, request_data_dma
);
1425 request_data
= NULL
;
1429 if (request_data
== NULL
) {
1430 ioc
->diag_buffer_sz
[buffer_type
] = 0;
1431 ioc
->diag_buffer_dma
[buffer_type
] = 0;
1432 request_data
= pci_alloc_consistent(
1433 ioc
->pdev
, request_data_sz
, &request_data_dma
);
1434 if (request_data
== NULL
) {
1435 pr_err(MPT3SAS_FMT
"%s: failed allocating memory" \
1436 " for diag buffers, requested size(%d)\n",
1437 ioc
->name
, __func__
, request_data_sz
);
1438 mpt3sas_base_free_smid(ioc
, smid
);
1441 ioc
->diag_buffer
[buffer_type
] = request_data
;
1442 ioc
->diag_buffer_sz
[buffer_type
] = request_data_sz
;
1443 ioc
->diag_buffer_dma
[buffer_type
] = request_data_dma
;
1446 mpi_request
->Function
= MPI2_FUNCTION_DIAG_BUFFER_POST
;
1447 mpi_request
->BufferType
= diag_register
->buffer_type
;
1448 mpi_request
->Flags
= cpu_to_le32(diag_register
->diagnostic_flags
);
1449 mpi_request
->BufferAddress
= cpu_to_le64(request_data_dma
);
1450 mpi_request
->BufferLength
= cpu_to_le32(request_data_sz
);
1451 mpi_request
->VF_ID
= 0; /* TODO */
1452 mpi_request
->VP_ID
= 0;
1454 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
1455 "%s: diag_buffer(0x%p), dma(0x%llx), sz(%d)\n",
1456 ioc
->name
, __func__
, request_data
,
1457 (unsigned long long)request_data_dma
,
1458 le32_to_cpu(mpi_request
->BufferLength
)));
1460 for (i
= 0; i
< MPT3_PRODUCT_SPECIFIC_DWORDS
; i
++)
1461 mpi_request
->ProductSpecific
[i
] =
1462 cpu_to_le32(ioc
->product_specific
[buffer_type
][i
]);
1464 init_completion(&ioc
->ctl_cmds
.done
);
1465 mpt3sas_base_put_smid_default(ioc
, smid
);
1466 timeleft
= wait_for_completion_timeout(&ioc
->ctl_cmds
.done
,
1467 MPT3_IOCTL_DEFAULT_TIMEOUT
*HZ
);
1469 if (!(ioc
->ctl_cmds
.status
& MPT3_CMD_COMPLETE
)) {
1470 pr_err(MPT3SAS_FMT
"%s: timeout\n", ioc
->name
,
1472 _debug_dump_mf(mpi_request
,
1473 sizeof(Mpi2DiagBufferPostRequest_t
)/4);
1474 if (!(ioc
->ctl_cmds
.status
& MPT3_CMD_RESET
))
1476 goto issue_host_reset
;
1479 /* process the completed Reply Message Frame */
1480 if ((ioc
->ctl_cmds
.status
& MPT3_CMD_REPLY_VALID
) == 0) {
1481 pr_err(MPT3SAS_FMT
"%s: no reply message\n",
1482 ioc
->name
, __func__
);
1487 mpi_reply
= ioc
->ctl_cmds
.reply
;
1488 ioc_status
= le16_to_cpu(mpi_reply
->IOCStatus
) & MPI2_IOCSTATUS_MASK
;
1490 if (ioc_status
== MPI2_IOCSTATUS_SUCCESS
) {
1491 ioc
->diag_buffer_status
[buffer_type
] |=
1492 MPT3_DIAG_BUFFER_IS_REGISTERED
;
1493 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s: success\n",
1494 ioc
->name
, __func__
));
1497 "%s: ioc_status(0x%04x) log_info(0x%08x)\n",
1498 ioc
->name
, __func__
,
1499 ioc_status
, le32_to_cpu(mpi_reply
->IOCLogInfo
));
1505 mpt3sas_base_hard_reset_handler(ioc
, CAN_SLEEP
,
1510 if (rc
&& request_data
)
1511 pci_free_consistent(ioc
->pdev
, request_data_sz
,
1512 request_data
, request_data_dma
);
1514 ioc
->ctl_cmds
.status
= MPT3_CMD_NOT_USED
;
1519 * mpt3sas_enable_diag_buffer - enabling diag_buffers support driver load time
1520 * @ioc: per adapter object
1521 * @bits_to_register: bitwise field where trace is bit 0, and snapshot is bit 1
1523 * This is called when command line option diag_buffer_enable is enabled
1524 * at driver load time.
1527 mpt3sas_enable_diag_buffer(struct MPT3SAS_ADAPTER
*ioc
, u8 bits_to_register
)
1529 struct mpt3_diag_register diag_register
;
1531 memset(&diag_register
, 0, sizeof(struct mpt3_diag_register
));
1533 if (bits_to_register
& 1) {
1534 pr_info(MPT3SAS_FMT
"registering trace buffer support\n",
1536 ioc
->diag_trigger_master
.MasterData
=
1537 (MASTER_TRIGGER_FW_FAULT
+ MASTER_TRIGGER_ADAPTER_RESET
);
1538 diag_register
.buffer_type
= MPI2_DIAG_BUF_TYPE_TRACE
;
1539 /* register for 2MB buffers */
1540 diag_register
.requested_buffer_size
= 2 * (1024 * 1024);
1541 diag_register
.unique_id
= 0x7075900;
1542 _ctl_diag_register_2(ioc
, &diag_register
);
1545 if (bits_to_register
& 2) {
1546 pr_info(MPT3SAS_FMT
"registering snapshot buffer support\n",
1548 diag_register
.buffer_type
= MPI2_DIAG_BUF_TYPE_SNAPSHOT
;
1549 /* register for 2MB buffers */
1550 diag_register
.requested_buffer_size
= 2 * (1024 * 1024);
1551 diag_register
.unique_id
= 0x7075901;
1552 _ctl_diag_register_2(ioc
, &diag_register
);
1555 if (bits_to_register
& 4) {
1556 pr_info(MPT3SAS_FMT
"registering extended buffer support\n",
1558 diag_register
.buffer_type
= MPI2_DIAG_BUF_TYPE_EXTENDED
;
1559 /* register for 2MB buffers */
1560 diag_register
.requested_buffer_size
= 2 * (1024 * 1024);
1561 diag_register
.unique_id
= 0x7075901;
1562 _ctl_diag_register_2(ioc
, &diag_register
);
1567 * _ctl_diag_register - application register with driver
1568 * @ioc: per adapter object
1569 * @arg - user space buffer containing ioctl content
1571 * This will allow the driver to setup any required buffers that will be
1572 * needed by firmware to communicate with the driver.
1575 _ctl_diag_register(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1577 struct mpt3_diag_register karg
;
1580 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1581 pr_err("failure at %s:%d/%s()!\n",
1582 __FILE__
, __LINE__
, __func__
);
1586 rc
= _ctl_diag_register_2(ioc
, &karg
);
1591 * _ctl_diag_unregister - application unregister with driver
1592 * @ioc: per adapter object
1593 * @arg - user space buffer containing ioctl content
1595 * This will allow the driver to cleanup any memory allocated for diag
1596 * messages and to free up any resources.
1599 _ctl_diag_unregister(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1601 struct mpt3_diag_unregister karg
;
1603 dma_addr_t request_data_dma
;
1604 u32 request_data_sz
;
1607 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1608 pr_err("failure at %s:%d/%s()!\n",
1609 __FILE__
, __LINE__
, __func__
);
1613 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s\n", ioc
->name
,
1616 buffer_type
= karg
.unique_id
& 0x000000ff;
1617 if (!_ctl_diag_capability(ioc
, buffer_type
)) {
1619 "%s: doesn't have capability for buffer_type(0x%02x)\n",
1620 ioc
->name
, __func__
, buffer_type
);
1624 if ((ioc
->diag_buffer_status
[buffer_type
] &
1625 MPT3_DIAG_BUFFER_IS_REGISTERED
) == 0) {
1627 "%s: buffer_type(0x%02x) is not registered\n",
1628 ioc
->name
, __func__
, buffer_type
);
1631 if ((ioc
->diag_buffer_status
[buffer_type
] &
1632 MPT3_DIAG_BUFFER_IS_RELEASED
) == 0) {
1634 "%s: buffer_type(0x%02x) has not been released\n",
1635 ioc
->name
, __func__
, buffer_type
);
1639 if (karg
.unique_id
!= ioc
->unique_id
[buffer_type
]) {
1641 "%s: unique_id(0x%08x) is not registered\n",
1642 ioc
->name
, __func__
, karg
.unique_id
);
1646 request_data
= ioc
->diag_buffer
[buffer_type
];
1647 if (!request_data
) {
1649 "%s: doesn't have memory allocated for buffer_type(0x%02x)\n",
1650 ioc
->name
, __func__
, buffer_type
);
1654 request_data_sz
= ioc
->diag_buffer_sz
[buffer_type
];
1655 request_data_dma
= ioc
->diag_buffer_dma
[buffer_type
];
1656 pci_free_consistent(ioc
->pdev
, request_data_sz
,
1657 request_data
, request_data_dma
);
1658 ioc
->diag_buffer
[buffer_type
] = NULL
;
1659 ioc
->diag_buffer_status
[buffer_type
] = 0;
1664 * _ctl_diag_query - query relevant info associated with diag buffers
1665 * @ioc: per adapter object
1666 * @arg - user space buffer containing ioctl content
1668 * The application will send only buffer_type and unique_id. Driver will
1669 * inspect unique_id first, if valid, fill in all the info. If unique_id is
1670 * 0x00, the driver will return info specified by Buffer Type.
1673 _ctl_diag_query(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1675 struct mpt3_diag_query karg
;
1680 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1681 pr_err("failure at %s:%d/%s()!\n",
1682 __FILE__
, __LINE__
, __func__
);
1686 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s\n", ioc
->name
,
1689 karg
.application_flags
= 0;
1690 buffer_type
= karg
.buffer_type
;
1692 if (!_ctl_diag_capability(ioc
, buffer_type
)) {
1694 "%s: doesn't have capability for buffer_type(0x%02x)\n",
1695 ioc
->name
, __func__
, buffer_type
);
1699 if ((ioc
->diag_buffer_status
[buffer_type
] &
1700 MPT3_DIAG_BUFFER_IS_REGISTERED
) == 0) {
1702 "%s: buffer_type(0x%02x) is not registered\n",
1703 ioc
->name
, __func__
, buffer_type
);
1707 if (karg
.unique_id
& 0xffffff00) {
1708 if (karg
.unique_id
!= ioc
->unique_id
[buffer_type
]) {
1710 "%s: unique_id(0x%08x) is not registered\n",
1711 ioc
->name
, __func__
, karg
.unique_id
);
1716 request_data
= ioc
->diag_buffer
[buffer_type
];
1717 if (!request_data
) {
1719 "%s: doesn't have buffer for buffer_type(0x%02x)\n",
1720 ioc
->name
, __func__
, buffer_type
);
1724 if (ioc
->diag_buffer_status
[buffer_type
] & MPT3_DIAG_BUFFER_IS_RELEASED
)
1725 karg
.application_flags
= (MPT3_APP_FLAGS_APP_OWNED
|
1726 MPT3_APP_FLAGS_BUFFER_VALID
);
1728 karg
.application_flags
= (MPT3_APP_FLAGS_APP_OWNED
|
1729 MPT3_APP_FLAGS_BUFFER_VALID
|
1730 MPT3_APP_FLAGS_FW_BUFFER_ACCESS
);
1732 for (i
= 0; i
< MPT3_PRODUCT_SPECIFIC_DWORDS
; i
++)
1733 karg
.product_specific
[i
] =
1734 ioc
->product_specific
[buffer_type
][i
];
1736 karg
.total_buffer_size
= ioc
->diag_buffer_sz
[buffer_type
];
1737 karg
.driver_added_buffer_size
= 0;
1738 karg
.unique_id
= ioc
->unique_id
[buffer_type
];
1739 karg
.diagnostic_flags
= ioc
->diagnostic_flags
[buffer_type
];
1741 if (copy_to_user(arg
, &karg
, sizeof(struct mpt3_diag_query
))) {
1743 "%s: unable to write mpt3_diag_query data @ %p\n",
1744 ioc
->name
, __func__
, arg
);
1751 * mpt3sas_send_diag_release - Diag Release Message
1752 * @ioc: per adapter object
1753 * @buffer_type - specifies either TRACE, SNAPSHOT, or EXTENDED
1754 * @issue_reset - specifies whether host reset is required.
1758 mpt3sas_send_diag_release(struct MPT3SAS_ADAPTER
*ioc
, u8 buffer_type
,
1761 Mpi2DiagReleaseRequest_t
*mpi_request
;
1762 Mpi2DiagReleaseReply_t
*mpi_reply
;
1767 unsigned long timeleft
;
1769 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s\n", ioc
->name
,
1775 ioc_state
= mpt3sas_base_get_iocstate(ioc
, 1);
1776 if (ioc_state
!= MPI2_IOC_STATE_OPERATIONAL
) {
1777 if (ioc
->diag_buffer_status
[buffer_type
] &
1778 MPT3_DIAG_BUFFER_IS_REGISTERED
)
1779 ioc
->diag_buffer_status
[buffer_type
] |=
1780 MPT3_DIAG_BUFFER_IS_RELEASED
;
1781 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
1782 "%s: skipping due to FAULT state\n", ioc
->name
,
1788 if (ioc
->ctl_cmds
.status
!= MPT3_CMD_NOT_USED
) {
1789 pr_err(MPT3SAS_FMT
"%s: ctl_cmd in use\n",
1790 ioc
->name
, __func__
);
1795 smid
= mpt3sas_base_get_smid(ioc
, ioc
->ctl_cb_idx
);
1797 pr_err(MPT3SAS_FMT
"%s: failed obtaining a smid\n",
1798 ioc
->name
, __func__
);
1803 ioc
->ctl_cmds
.status
= MPT3_CMD_PENDING
;
1804 memset(ioc
->ctl_cmds
.reply
, 0, ioc
->reply_sz
);
1805 mpi_request
= mpt3sas_base_get_msg_frame(ioc
, smid
);
1806 ioc
->ctl_cmds
.smid
= smid
;
1808 mpi_request
->Function
= MPI2_FUNCTION_DIAG_RELEASE
;
1809 mpi_request
->BufferType
= buffer_type
;
1810 mpi_request
->VF_ID
= 0; /* TODO */
1811 mpi_request
->VP_ID
= 0;
1813 init_completion(&ioc
->ctl_cmds
.done
);
1814 mpt3sas_base_put_smid_default(ioc
, smid
);
1815 timeleft
= wait_for_completion_timeout(&ioc
->ctl_cmds
.done
,
1816 MPT3_IOCTL_DEFAULT_TIMEOUT
*HZ
);
1818 if (!(ioc
->ctl_cmds
.status
& MPT3_CMD_COMPLETE
)) {
1819 pr_err(MPT3SAS_FMT
"%s: timeout\n", ioc
->name
,
1821 _debug_dump_mf(mpi_request
,
1822 sizeof(Mpi2DiagReleaseRequest_t
)/4);
1823 if (!(ioc
->ctl_cmds
.status
& MPT3_CMD_RESET
))
1829 /* process the completed Reply Message Frame */
1830 if ((ioc
->ctl_cmds
.status
& MPT3_CMD_REPLY_VALID
) == 0) {
1831 pr_err(MPT3SAS_FMT
"%s: no reply message\n",
1832 ioc
->name
, __func__
);
1837 mpi_reply
= ioc
->ctl_cmds
.reply
;
1838 ioc_status
= le16_to_cpu(mpi_reply
->IOCStatus
) & MPI2_IOCSTATUS_MASK
;
1840 if (ioc_status
== MPI2_IOCSTATUS_SUCCESS
) {
1841 ioc
->diag_buffer_status
[buffer_type
] |=
1842 MPT3_DIAG_BUFFER_IS_RELEASED
;
1843 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s: success\n",
1844 ioc
->name
, __func__
));
1847 "%s: ioc_status(0x%04x) log_info(0x%08x)\n",
1848 ioc
->name
, __func__
,
1849 ioc_status
, le32_to_cpu(mpi_reply
->IOCLogInfo
));
1854 ioc
->ctl_cmds
.status
= MPT3_CMD_NOT_USED
;
1859 * _ctl_diag_release - request to send Diag Release Message to firmware
1860 * @arg - user space buffer containing ioctl content
1862 * This allows ownership of the specified buffer to returned to the driver,
1863 * allowing an application to read the buffer without fear that firmware is
1864 * overwritting information in the buffer.
1867 _ctl_diag_release(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1869 struct mpt3_diag_release karg
;
1875 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1876 pr_err("failure at %s:%d/%s()!\n",
1877 __FILE__
, __LINE__
, __func__
);
1881 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s\n", ioc
->name
,
1884 buffer_type
= karg
.unique_id
& 0x000000ff;
1885 if (!_ctl_diag_capability(ioc
, buffer_type
)) {
1887 "%s: doesn't have capability for buffer_type(0x%02x)\n",
1888 ioc
->name
, __func__
, buffer_type
);
1892 if ((ioc
->diag_buffer_status
[buffer_type
] &
1893 MPT3_DIAG_BUFFER_IS_REGISTERED
) == 0) {
1895 "%s: buffer_type(0x%02x) is not registered\n",
1896 ioc
->name
, __func__
, buffer_type
);
1900 if (karg
.unique_id
!= ioc
->unique_id
[buffer_type
]) {
1902 "%s: unique_id(0x%08x) is not registered\n",
1903 ioc
->name
, __func__
, karg
.unique_id
);
1907 if (ioc
->diag_buffer_status
[buffer_type
] &
1908 MPT3_DIAG_BUFFER_IS_RELEASED
) {
1910 "%s: buffer_type(0x%02x) is already released\n",
1911 ioc
->name
, __func__
,
1916 request_data
= ioc
->diag_buffer
[buffer_type
];
1918 if (!request_data
) {
1920 "%s: doesn't have memory allocated for buffer_type(0x%02x)\n",
1921 ioc
->name
, __func__
, buffer_type
);
1925 /* buffers were released by due to host reset */
1926 if ((ioc
->diag_buffer_status
[buffer_type
] &
1927 MPT3_DIAG_BUFFER_IS_DIAG_RESET
)) {
1928 ioc
->diag_buffer_status
[buffer_type
] |=
1929 MPT3_DIAG_BUFFER_IS_RELEASED
;
1930 ioc
->diag_buffer_status
[buffer_type
] &=
1931 ~MPT3_DIAG_BUFFER_IS_DIAG_RESET
;
1933 "%s: buffer_type(0x%02x) was released due to host reset\n",
1934 ioc
->name
, __func__
, buffer_type
);
1938 rc
= mpt3sas_send_diag_release(ioc
, buffer_type
, &issue_reset
);
1941 mpt3sas_base_hard_reset_handler(ioc
, CAN_SLEEP
,
1948 * _ctl_diag_read_buffer - request for copy of the diag buffer
1949 * @ioc: per adapter object
1950 * @arg - user space buffer containing ioctl content
1953 _ctl_diag_read_buffer(struct MPT3SAS_ADAPTER
*ioc
, void __user
*arg
)
1955 struct mpt3_diag_read_buffer karg
;
1956 struct mpt3_diag_read_buffer __user
*uarg
= arg
;
1957 void *request_data
, *diag_data
;
1958 Mpi2DiagBufferPostRequest_t
*mpi_request
;
1959 Mpi2DiagBufferPostReply_t
*mpi_reply
;
1962 unsigned long timeleft
, request_size
, copy_size
;
1967 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1968 pr_err("failure at %s:%d/%s()!\n",
1969 __FILE__
, __LINE__
, __func__
);
1973 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s\n", ioc
->name
,
1976 buffer_type
= karg
.unique_id
& 0x000000ff;
1977 if (!_ctl_diag_capability(ioc
, buffer_type
)) {
1979 "%s: doesn't have capability for buffer_type(0x%02x)\n",
1980 ioc
->name
, __func__
, buffer_type
);
1984 if (karg
.unique_id
!= ioc
->unique_id
[buffer_type
]) {
1986 "%s: unique_id(0x%08x) is not registered\n",
1987 ioc
->name
, __func__
, karg
.unique_id
);
1991 request_data
= ioc
->diag_buffer
[buffer_type
];
1992 if (!request_data
) {
1994 "%s: doesn't have buffer for buffer_type(0x%02x)\n",
1995 ioc
->name
, __func__
, buffer_type
);
1999 request_size
= ioc
->diag_buffer_sz
[buffer_type
];
2001 if ((karg
.starting_offset
% 4) || (karg
.bytes_to_read
% 4)) {
2002 pr_err(MPT3SAS_FMT
"%s: either the starting_offset " \
2003 "or bytes_to_read are not 4 byte aligned\n", ioc
->name
,
2008 if (karg
.starting_offset
> request_size
)
2011 diag_data
= (void *)(request_data
+ karg
.starting_offset
);
2012 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
2013 "%s: diag_buffer(%p), offset(%d), sz(%d)\n",
2014 ioc
->name
, __func__
,
2015 diag_data
, karg
.starting_offset
, karg
.bytes_to_read
));
2017 /* Truncate data on requests that are too large */
2018 if ((diag_data
+ karg
.bytes_to_read
< diag_data
) ||
2019 (diag_data
+ karg
.bytes_to_read
> request_data
+ request_size
))
2020 copy_size
= request_size
- karg
.starting_offset
;
2022 copy_size
= karg
.bytes_to_read
;
2024 if (copy_to_user((void __user
*)uarg
->diagnostic_data
,
2025 diag_data
, copy_size
)) {
2027 "%s: Unable to write mpt_diag_read_buffer_t data @ %p\n",
2028 ioc
->name
, __func__
, diag_data
);
2032 if ((karg
.flags
& MPT3_FLAGS_REREGISTER
) == 0)
2035 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
2036 "%s: Reregister buffer_type(0x%02x)\n",
2037 ioc
->name
, __func__
, buffer_type
));
2038 if ((ioc
->diag_buffer_status
[buffer_type
] &
2039 MPT3_DIAG_BUFFER_IS_RELEASED
) == 0) {
2040 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
2041 "%s: buffer_type(0x%02x) is still registered\n",
2042 ioc
->name
, __func__
, buffer_type
));
2045 /* Get a free request frame and save the message context.
2048 if (ioc
->ctl_cmds
.status
!= MPT3_CMD_NOT_USED
) {
2049 pr_err(MPT3SAS_FMT
"%s: ctl_cmd in use\n",
2050 ioc
->name
, __func__
);
2055 smid
= mpt3sas_base_get_smid(ioc
, ioc
->ctl_cb_idx
);
2057 pr_err(MPT3SAS_FMT
"%s: failed obtaining a smid\n",
2058 ioc
->name
, __func__
);
2064 ioc
->ctl_cmds
.status
= MPT3_CMD_PENDING
;
2065 memset(ioc
->ctl_cmds
.reply
, 0, ioc
->reply_sz
);
2066 mpi_request
= mpt3sas_base_get_msg_frame(ioc
, smid
);
2067 ioc
->ctl_cmds
.smid
= smid
;
2069 mpi_request
->Function
= MPI2_FUNCTION_DIAG_BUFFER_POST
;
2070 mpi_request
->BufferType
= buffer_type
;
2071 mpi_request
->BufferLength
=
2072 cpu_to_le32(ioc
->diag_buffer_sz
[buffer_type
]);
2073 mpi_request
->BufferAddress
=
2074 cpu_to_le64(ioc
->diag_buffer_dma
[buffer_type
]);
2075 for (i
= 0; i
< MPT3_PRODUCT_SPECIFIC_DWORDS
; i
++)
2076 mpi_request
->ProductSpecific
[i
] =
2077 cpu_to_le32(ioc
->product_specific
[buffer_type
][i
]);
2078 mpi_request
->VF_ID
= 0; /* TODO */
2079 mpi_request
->VP_ID
= 0;
2081 init_completion(&ioc
->ctl_cmds
.done
);
2082 mpt3sas_base_put_smid_default(ioc
, smid
);
2083 timeleft
= wait_for_completion_timeout(&ioc
->ctl_cmds
.done
,
2084 MPT3_IOCTL_DEFAULT_TIMEOUT
*HZ
);
2086 if (!(ioc
->ctl_cmds
.status
& MPT3_CMD_COMPLETE
)) {
2087 pr_err(MPT3SAS_FMT
"%s: timeout\n", ioc
->name
,
2089 _debug_dump_mf(mpi_request
,
2090 sizeof(Mpi2DiagBufferPostRequest_t
)/4);
2091 if (!(ioc
->ctl_cmds
.status
& MPT3_CMD_RESET
))
2093 goto issue_host_reset
;
2096 /* process the completed Reply Message Frame */
2097 if ((ioc
->ctl_cmds
.status
& MPT3_CMD_REPLY_VALID
) == 0) {
2098 pr_err(MPT3SAS_FMT
"%s: no reply message\n",
2099 ioc
->name
, __func__
);
2104 mpi_reply
= ioc
->ctl_cmds
.reply
;
2105 ioc_status
= le16_to_cpu(mpi_reply
->IOCStatus
) & MPI2_IOCSTATUS_MASK
;
2107 if (ioc_status
== MPI2_IOCSTATUS_SUCCESS
) {
2108 ioc
->diag_buffer_status
[buffer_type
] |=
2109 MPT3_DIAG_BUFFER_IS_REGISTERED
;
2110 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
"%s: success\n",
2111 ioc
->name
, __func__
));
2114 "%s: ioc_status(0x%04x) log_info(0x%08x)\n",
2115 ioc
->name
, __func__
,
2116 ioc_status
, le32_to_cpu(mpi_reply
->IOCLogInfo
));
2122 mpt3sas_base_hard_reset_handler(ioc
, CAN_SLEEP
,
2127 ioc
->ctl_cmds
.status
= MPT3_CMD_NOT_USED
;
2133 #ifdef CONFIG_COMPAT
2135 * _ctl_compat_mpt_command - convert 32bit pointers to 64bit.
2136 * @ioc: per adapter object
2137 * @cmd - ioctl opcode
2138 * @arg - (struct mpt3_ioctl_command32)
2140 * MPT3COMMAND32 - Handle 32bit applications running on 64bit os.
2143 _ctl_compat_mpt_command(struct MPT3SAS_ADAPTER
*ioc
, unsigned cmd
,
2146 struct mpt3_ioctl_command32 karg32
;
2147 struct mpt3_ioctl_command32 __user
*uarg
;
2148 struct mpt3_ioctl_command karg
;
2150 if (_IOC_SIZE(cmd
) != sizeof(struct mpt3_ioctl_command32
))
2153 uarg
= (struct mpt3_ioctl_command32 __user
*) arg
;
2155 if (copy_from_user(&karg32
, (char __user
*)arg
, sizeof(karg32
))) {
2156 pr_err("failure at %s:%d/%s()!\n",
2157 __FILE__
, __LINE__
, __func__
);
2161 memset(&karg
, 0, sizeof(struct mpt3_ioctl_command
));
2162 karg
.hdr
.ioc_number
= karg32
.hdr
.ioc_number
;
2163 karg
.hdr
.port_number
= karg32
.hdr
.port_number
;
2164 karg
.hdr
.max_data_size
= karg32
.hdr
.max_data_size
;
2165 karg
.timeout
= karg32
.timeout
;
2166 karg
.max_reply_bytes
= karg32
.max_reply_bytes
;
2167 karg
.data_in_size
= karg32
.data_in_size
;
2168 karg
.data_out_size
= karg32
.data_out_size
;
2169 karg
.max_sense_bytes
= karg32
.max_sense_bytes
;
2170 karg
.data_sge_offset
= karg32
.data_sge_offset
;
2171 karg
.reply_frame_buf_ptr
= compat_ptr(karg32
.reply_frame_buf_ptr
);
2172 karg
.data_in_buf_ptr
= compat_ptr(karg32
.data_in_buf_ptr
);
2173 karg
.data_out_buf_ptr
= compat_ptr(karg32
.data_out_buf_ptr
);
2174 karg
.sense_data_ptr
= compat_ptr(karg32
.sense_data_ptr
);
2175 return _ctl_do_mpt_command(ioc
, karg
, &uarg
->mf
);
2180 * _ctl_ioctl_main - main ioctl entry point
2181 * @file - (struct file)
2182 * @cmd - ioctl opcode
2184 * compat - handles 32 bit applications in 64bit os
2187 _ctl_ioctl_main(struct file
*file
, unsigned int cmd
, void __user
*arg
,
2190 struct MPT3SAS_ADAPTER
*ioc
;
2191 struct mpt3_ioctl_header ioctl_header
;
2192 enum block_state state
;
2195 /* get IOCTL header */
2196 if (copy_from_user(&ioctl_header
, (char __user
*)arg
,
2197 sizeof(struct mpt3_ioctl_header
))) {
2198 pr_err("failure at %s:%d/%s()!\n",
2199 __FILE__
, __LINE__
, __func__
);
2203 if (_ctl_verify_adapter(ioctl_header
.ioc_number
, &ioc
) == -1 || !ioc
)
2206 if (ioc
->shost_recovery
|| ioc
->pci_error_recovery
||
2207 ioc
->is_driver_loading
)
2210 state
= (file
->f_flags
& O_NONBLOCK
) ? NON_BLOCKING
: BLOCKING
;
2211 if (state
== NON_BLOCKING
) {
2212 if (!mutex_trylock(&ioc
->ctl_cmds
.mutex
))
2214 } else if (mutex_lock_interruptible(&ioc
->ctl_cmds
.mutex
))
2215 return -ERESTARTSYS
;
2220 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_ioctl_iocinfo
))
2221 ret
= _ctl_getiocinfo(ioc
, arg
);
2223 #ifdef CONFIG_COMPAT
2228 struct mpt3_ioctl_command __user
*uarg
;
2229 struct mpt3_ioctl_command karg
;
2231 #ifdef CONFIG_COMPAT
2233 ret
= _ctl_compat_mpt_command(ioc
, cmd
, arg
);
2237 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
2238 pr_err("failure at %s:%d/%s()!\n",
2239 __FILE__
, __LINE__
, __func__
);
2244 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_ioctl_command
)) {
2246 ret
= _ctl_do_mpt_command(ioc
, karg
, &uarg
->mf
);
2250 case MPT3EVENTQUERY
:
2251 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_ioctl_eventquery
))
2252 ret
= _ctl_eventquery(ioc
, arg
);
2254 case MPT3EVENTENABLE
:
2255 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_ioctl_eventenable
))
2256 ret
= _ctl_eventenable(ioc
, arg
);
2258 case MPT3EVENTREPORT
:
2259 ret
= _ctl_eventreport(ioc
, arg
);
2262 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_ioctl_diag_reset
))
2263 ret
= _ctl_do_reset(ioc
, arg
);
2265 case MPT3BTDHMAPPING
:
2266 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_ioctl_btdh_mapping
))
2267 ret
= _ctl_btdh_mapping(ioc
, arg
);
2269 case MPT3DIAGREGISTER
:
2270 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_diag_register
))
2271 ret
= _ctl_diag_register(ioc
, arg
);
2273 case MPT3DIAGUNREGISTER
:
2274 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_diag_unregister
))
2275 ret
= _ctl_diag_unregister(ioc
, arg
);
2278 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_diag_query
))
2279 ret
= _ctl_diag_query(ioc
, arg
);
2281 case MPT3DIAGRELEASE
:
2282 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_diag_release
))
2283 ret
= _ctl_diag_release(ioc
, arg
);
2285 case MPT3DIAGREADBUFFER
:
2286 if (_IOC_SIZE(cmd
) == sizeof(struct mpt3_diag_read_buffer
))
2287 ret
= _ctl_diag_read_buffer(ioc
, arg
);
2290 dctlprintk(ioc
, pr_info(MPT3SAS_FMT
2291 "unsupported ioctl opcode(0x%08x)\n", ioc
->name
, cmd
));
2295 mutex_unlock(&ioc
->ctl_cmds
.mutex
);
2300 * _ctl_ioctl - main ioctl entry point (unlocked)
2301 * @file - (struct file)
2302 * @cmd - ioctl opcode
2306 _ctl_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
2310 ret
= _ctl_ioctl_main(file
, cmd
, (void __user
*)arg
, 0);
2314 #ifdef CONFIG_COMPAT
2316 * _ctl_ioctl_compat - main ioctl entry point (compat)
2321 * This routine handles 32 bit applications in 64bit os.
2324 _ctl_ioctl_compat(struct file
*file
, unsigned cmd
, unsigned long arg
)
2328 ret
= _ctl_ioctl_main(file
, cmd
, (void __user
*)arg
, 1);
2333 /* scsi host attributes */
2335 * _ctl_version_fw_show - firmware version
2336 * @cdev - pointer to embedded class device
2337 * @buf - the buffer returned
2339 * A sysfs 'read-only' shost attribute.
2342 _ctl_version_fw_show(struct device
*cdev
, struct device_attribute
*attr
,
2345 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2346 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2348 return snprintf(buf
, PAGE_SIZE
, "%02d.%02d.%02d.%02d\n",
2349 (ioc
->facts
.FWVersion
.Word
& 0xFF000000) >> 24,
2350 (ioc
->facts
.FWVersion
.Word
& 0x00FF0000) >> 16,
2351 (ioc
->facts
.FWVersion
.Word
& 0x0000FF00) >> 8,
2352 ioc
->facts
.FWVersion
.Word
& 0x000000FF);
2354 static DEVICE_ATTR(version_fw
, S_IRUGO
, _ctl_version_fw_show
, NULL
);
2357 * _ctl_version_bios_show - bios version
2358 * @cdev - pointer to embedded class device
2359 * @buf - the buffer returned
2361 * A sysfs 'read-only' shost attribute.
2364 _ctl_version_bios_show(struct device
*cdev
, struct device_attribute
*attr
,
2367 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2368 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2370 u32 version
= le32_to_cpu(ioc
->bios_pg3
.BiosVersion
);
2372 return snprintf(buf
, PAGE_SIZE
, "%02d.%02d.%02d.%02d\n",
2373 (version
& 0xFF000000) >> 24,
2374 (version
& 0x00FF0000) >> 16,
2375 (version
& 0x0000FF00) >> 8,
2376 version
& 0x000000FF);
2378 static DEVICE_ATTR(version_bios
, S_IRUGO
, _ctl_version_bios_show
, NULL
);
2381 * _ctl_version_mpi_show - MPI (message passing interface) version
2382 * @cdev - pointer to embedded class device
2383 * @buf - the buffer returned
2385 * A sysfs 'read-only' shost attribute.
2388 _ctl_version_mpi_show(struct device
*cdev
, struct device_attribute
*attr
,
2391 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2392 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2394 return snprintf(buf
, PAGE_SIZE
, "%03x.%02x\n",
2395 ioc
->facts
.MsgVersion
, ioc
->facts
.HeaderVersion
>> 8);
2397 static DEVICE_ATTR(version_mpi
, S_IRUGO
, _ctl_version_mpi_show
, NULL
);
2400 * _ctl_version_product_show - product name
2401 * @cdev - pointer to embedded class device
2402 * @buf - the buffer returned
2404 * A sysfs 'read-only' shost attribute.
2407 _ctl_version_product_show(struct device
*cdev
, struct device_attribute
*attr
,
2410 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2411 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2413 return snprintf(buf
, 16, "%s\n", ioc
->manu_pg0
.ChipName
);
2415 static DEVICE_ATTR(version_product
, S_IRUGO
, _ctl_version_product_show
, NULL
);
2418 * _ctl_version_nvdata_persistent_show - ndvata persistent version
2419 * @cdev - pointer to embedded class device
2420 * @buf - the buffer returned
2422 * A sysfs 'read-only' shost attribute.
2425 _ctl_version_nvdata_persistent_show(struct device
*cdev
,
2426 struct device_attribute
*attr
, char *buf
)
2428 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2429 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2431 return snprintf(buf
, PAGE_SIZE
, "%08xh\n",
2432 le32_to_cpu(ioc
->iounit_pg0
.NvdataVersionPersistent
.Word
));
2434 static DEVICE_ATTR(version_nvdata_persistent
, S_IRUGO
,
2435 _ctl_version_nvdata_persistent_show
, NULL
);
2438 * _ctl_version_nvdata_default_show - nvdata default version
2439 * @cdev - pointer to embedded class device
2440 * @buf - the buffer returned
2442 * A sysfs 'read-only' shost attribute.
2445 _ctl_version_nvdata_default_show(struct device
*cdev
, struct device_attribute
2448 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2449 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2451 return snprintf(buf
, PAGE_SIZE
, "%08xh\n",
2452 le32_to_cpu(ioc
->iounit_pg0
.NvdataVersionDefault
.Word
));
2454 static DEVICE_ATTR(version_nvdata_default
, S_IRUGO
,
2455 _ctl_version_nvdata_default_show
, NULL
);
2458 * _ctl_board_name_show - board name
2459 * @cdev - pointer to embedded class device
2460 * @buf - the buffer returned
2462 * A sysfs 'read-only' shost attribute.
2465 _ctl_board_name_show(struct device
*cdev
, struct device_attribute
*attr
,
2468 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2469 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2471 return snprintf(buf
, 16, "%s\n", ioc
->manu_pg0
.BoardName
);
2473 static DEVICE_ATTR(board_name
, S_IRUGO
, _ctl_board_name_show
, NULL
);
2476 * _ctl_board_assembly_show - board assembly name
2477 * @cdev - pointer to embedded class device
2478 * @buf - the buffer returned
2480 * A sysfs 'read-only' shost attribute.
2483 _ctl_board_assembly_show(struct device
*cdev
, struct device_attribute
*attr
,
2486 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2487 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2489 return snprintf(buf
, 16, "%s\n", ioc
->manu_pg0
.BoardAssembly
);
2491 static DEVICE_ATTR(board_assembly
, S_IRUGO
, _ctl_board_assembly_show
, NULL
);
2494 * _ctl_board_tracer_show - board tracer number
2495 * @cdev - pointer to embedded class device
2496 * @buf - the buffer returned
2498 * A sysfs 'read-only' shost attribute.
2501 _ctl_board_tracer_show(struct device
*cdev
, struct device_attribute
*attr
,
2504 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2505 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2507 return snprintf(buf
, 16, "%s\n", ioc
->manu_pg0
.BoardTracerNumber
);
2509 static DEVICE_ATTR(board_tracer
, S_IRUGO
, _ctl_board_tracer_show
, NULL
);
2512 * _ctl_io_delay_show - io missing delay
2513 * @cdev - pointer to embedded class device
2514 * @buf - the buffer returned
2516 * This is for firmware implemention for deboucing device
2519 * A sysfs 'read-only' shost attribute.
2522 _ctl_io_delay_show(struct device
*cdev
, struct device_attribute
*attr
,
2525 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2526 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2528 return snprintf(buf
, PAGE_SIZE
, "%02d\n", ioc
->io_missing_delay
);
2530 static DEVICE_ATTR(io_delay
, S_IRUGO
, _ctl_io_delay_show
, NULL
);
2533 * _ctl_device_delay_show - device missing delay
2534 * @cdev - pointer to embedded class device
2535 * @buf - the buffer returned
2537 * This is for firmware implemention for deboucing device
2540 * A sysfs 'read-only' shost attribute.
2543 _ctl_device_delay_show(struct device
*cdev
, struct device_attribute
*attr
,
2546 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2547 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2549 return snprintf(buf
, PAGE_SIZE
, "%02d\n", ioc
->device_missing_delay
);
2551 static DEVICE_ATTR(device_delay
, S_IRUGO
, _ctl_device_delay_show
, NULL
);
2554 * _ctl_fw_queue_depth_show - global credits
2555 * @cdev - pointer to embedded class device
2556 * @buf - the buffer returned
2558 * This is firmware queue depth limit
2560 * A sysfs 'read-only' shost attribute.
2563 _ctl_fw_queue_depth_show(struct device
*cdev
, struct device_attribute
*attr
,
2566 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2567 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2569 return snprintf(buf
, PAGE_SIZE
, "%02d\n", ioc
->facts
.RequestCredit
);
2571 static DEVICE_ATTR(fw_queue_depth
, S_IRUGO
, _ctl_fw_queue_depth_show
, NULL
);
2574 * _ctl_sas_address_show - sas address
2575 * @cdev - pointer to embedded class device
2576 * @buf - the buffer returned
2578 * This is the controller sas address
2580 * A sysfs 'read-only' shost attribute.
2583 _ctl_host_sas_address_show(struct device
*cdev
, struct device_attribute
*attr
,
2587 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2588 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2590 return snprintf(buf
, PAGE_SIZE
, "0x%016llx\n",
2591 (unsigned long long)ioc
->sas_hba
.sas_address
);
2593 static DEVICE_ATTR(host_sas_address
, S_IRUGO
,
2594 _ctl_host_sas_address_show
, NULL
);
2597 * _ctl_logging_level_show - logging level
2598 * @cdev - pointer to embedded class device
2599 * @buf - the buffer returned
2601 * A sysfs 'read/write' shost attribute.
2604 _ctl_logging_level_show(struct device
*cdev
, struct device_attribute
*attr
,
2607 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2608 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2610 return snprintf(buf
, PAGE_SIZE
, "%08xh\n", ioc
->logging_level
);
2613 _ctl_logging_level_store(struct device
*cdev
, struct device_attribute
*attr
,
2614 const char *buf
, size_t count
)
2616 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2617 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2620 if (sscanf(buf
, "%x", &val
) != 1)
2623 ioc
->logging_level
= val
;
2624 pr_info(MPT3SAS_FMT
"logging_level=%08xh\n", ioc
->name
,
2625 ioc
->logging_level
);
2628 static DEVICE_ATTR(logging_level
, S_IRUGO
| S_IWUSR
, _ctl_logging_level_show
,
2629 _ctl_logging_level_store
);
2632 * _ctl_fwfault_debug_show - show/store fwfault_debug
2633 * @cdev - pointer to embedded class device
2634 * @buf - the buffer returned
2636 * mpt3sas_fwfault_debug is command line option
2637 * A sysfs 'read/write' shost attribute.
2640 _ctl_fwfault_debug_show(struct device
*cdev
, struct device_attribute
*attr
,
2643 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2644 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2646 return snprintf(buf
, PAGE_SIZE
, "%d\n", ioc
->fwfault_debug
);
2649 _ctl_fwfault_debug_store(struct device
*cdev
, struct device_attribute
*attr
,
2650 const char *buf
, size_t count
)
2652 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2653 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2656 if (sscanf(buf
, "%d", &val
) != 1)
2659 ioc
->fwfault_debug
= val
;
2660 pr_info(MPT3SAS_FMT
"fwfault_debug=%d\n", ioc
->name
,
2661 ioc
->fwfault_debug
);
2664 static DEVICE_ATTR(fwfault_debug
, S_IRUGO
| S_IWUSR
,
2665 _ctl_fwfault_debug_show
, _ctl_fwfault_debug_store
);
2668 * _ctl_ioc_reset_count_show - ioc reset count
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_ioc_reset_count_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
, "%d\n", ioc
->ioc_reset_count
);
2685 static DEVICE_ATTR(ioc_reset_count
, S_IRUGO
, _ctl_ioc_reset_count_show
, NULL
);
2688 * _ctl_ioc_reply_queue_count_show - number of reply queues
2689 * @cdev - pointer to embedded class device
2690 * @buf - the buffer returned
2692 * This is number of reply queues
2694 * A sysfs 'read-only' shost attribute.
2697 _ctl_ioc_reply_queue_count_show(struct device
*cdev
,
2698 struct device_attribute
*attr
, char *buf
)
2700 u8 reply_queue_count
;
2701 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2702 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2704 if ((ioc
->facts
.IOCCapabilities
&
2705 MPI2_IOCFACTS_CAPABILITY_MSI_X_INDEX
) && ioc
->msix_enable
)
2706 reply_queue_count
= ioc
->reply_queue_count
;
2708 reply_queue_count
= 1;
2710 return snprintf(buf
, PAGE_SIZE
, "%d\n", reply_queue_count
);
2712 static DEVICE_ATTR(reply_queue_count
, S_IRUGO
, _ctl_ioc_reply_queue_count_show
,
2715 struct DIAG_BUFFER_START
{
2726 * _ctl_host_trace_buffer_size_show - host buffer size (trace only)
2727 * @cdev - pointer to embedded class device
2728 * @buf - the buffer returned
2730 * A sysfs 'read-only' shost attribute.
2733 _ctl_host_trace_buffer_size_show(struct device
*cdev
,
2734 struct device_attribute
*attr
, char *buf
)
2736 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2737 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2739 struct DIAG_BUFFER_START
*request_data
;
2741 if (!ioc
->diag_buffer
[MPI2_DIAG_BUF_TYPE_TRACE
]) {
2743 "%s: host_trace_buffer is not registered\n",
2744 ioc
->name
, __func__
);
2748 if ((ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] &
2749 MPT3_DIAG_BUFFER_IS_REGISTERED
) == 0) {
2751 "%s: host_trace_buffer is not registered\n",
2752 ioc
->name
, __func__
);
2756 request_data
= (struct DIAG_BUFFER_START
*)
2757 ioc
->diag_buffer
[MPI2_DIAG_BUF_TYPE_TRACE
];
2758 if ((le32_to_cpu(request_data
->DiagVersion
) == 0x00000000 ||
2759 le32_to_cpu(request_data
->DiagVersion
) == 0x01000000 ||
2760 le32_to_cpu(request_data
->DiagVersion
) == 0x01010000) &&
2761 le32_to_cpu(request_data
->Reserved3
) == 0x4742444c)
2762 size
= le32_to_cpu(request_data
->Size
);
2764 ioc
->ring_buffer_sz
= size
;
2765 return snprintf(buf
, PAGE_SIZE
, "%d\n", size
);
2767 static DEVICE_ATTR(host_trace_buffer_size
, S_IRUGO
,
2768 _ctl_host_trace_buffer_size_show
, NULL
);
2771 * _ctl_host_trace_buffer_show - firmware ring buffer (trace only)
2772 * @cdev - pointer to embedded class device
2773 * @buf - the buffer returned
2775 * A sysfs 'read/write' shost attribute.
2777 * You will only be able to read 4k bytes of ring buffer at a time.
2778 * In order to read beyond 4k bytes, you will have to write out the
2779 * offset to the same attribute, it will move the pointer.
2782 _ctl_host_trace_buffer_show(struct device
*cdev
, struct device_attribute
*attr
,
2785 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2786 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2790 if (!ioc
->diag_buffer
[MPI2_DIAG_BUF_TYPE_TRACE
]) {
2792 "%s: host_trace_buffer is not registered\n",
2793 ioc
->name
, __func__
);
2797 if ((ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] &
2798 MPT3_DIAG_BUFFER_IS_REGISTERED
) == 0) {
2800 "%s: host_trace_buffer is not registered\n",
2801 ioc
->name
, __func__
);
2805 if (ioc
->ring_buffer_offset
> ioc
->ring_buffer_sz
)
2808 size
= ioc
->ring_buffer_sz
- ioc
->ring_buffer_offset
;
2809 size
= (size
>= PAGE_SIZE
) ? (PAGE_SIZE
- 1) : size
;
2810 request_data
= ioc
->diag_buffer
[0] + ioc
->ring_buffer_offset
;
2811 memcpy(buf
, request_data
, size
);
2816 _ctl_host_trace_buffer_store(struct device
*cdev
, struct device_attribute
*attr
,
2817 const char *buf
, size_t count
)
2819 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2820 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2823 if (sscanf(buf
, "%d", &val
) != 1)
2826 ioc
->ring_buffer_offset
= val
;
2829 static DEVICE_ATTR(host_trace_buffer
, S_IRUGO
| S_IWUSR
,
2830 _ctl_host_trace_buffer_show
, _ctl_host_trace_buffer_store
);
2833 /*****************************************/
2836 * _ctl_host_trace_buffer_enable_show - firmware ring buffer (trace only)
2837 * @cdev - pointer to embedded class device
2838 * @buf - the buffer returned
2840 * A sysfs 'read/write' shost attribute.
2842 * This is a mechnism to post/release host_trace_buffers
2845 _ctl_host_trace_buffer_enable_show(struct device
*cdev
,
2846 struct device_attribute
*attr
, char *buf
)
2848 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2849 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2851 if ((!ioc
->diag_buffer
[MPI2_DIAG_BUF_TYPE_TRACE
]) ||
2852 ((ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] &
2853 MPT3_DIAG_BUFFER_IS_REGISTERED
) == 0))
2854 return snprintf(buf
, PAGE_SIZE
, "off\n");
2855 else if ((ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] &
2856 MPT3_DIAG_BUFFER_IS_RELEASED
))
2857 return snprintf(buf
, PAGE_SIZE
, "release\n");
2859 return snprintf(buf
, PAGE_SIZE
, "post\n");
2863 _ctl_host_trace_buffer_enable_store(struct device
*cdev
,
2864 struct device_attribute
*attr
, const char *buf
, size_t count
)
2866 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2867 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2869 struct mpt3_diag_register diag_register
;
2872 /* don't allow post/release occurr while recovery is active */
2873 if (ioc
->shost_recovery
|| ioc
->remove_host
||
2874 ioc
->pci_error_recovery
|| ioc
->is_driver_loading
)
2877 if (sscanf(buf
, "%9s", str
) != 1)
2880 if (!strcmp(str
, "post")) {
2881 /* exit out if host buffers are already posted */
2882 if ((ioc
->diag_buffer
[MPI2_DIAG_BUF_TYPE_TRACE
]) &&
2883 (ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] &
2884 MPT3_DIAG_BUFFER_IS_REGISTERED
) &&
2885 ((ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] &
2886 MPT3_DIAG_BUFFER_IS_RELEASED
) == 0))
2888 memset(&diag_register
, 0, sizeof(struct mpt3_diag_register
));
2889 pr_info(MPT3SAS_FMT
"posting host trace buffers\n",
2891 diag_register
.buffer_type
= MPI2_DIAG_BUF_TYPE_TRACE
;
2892 diag_register
.requested_buffer_size
= (1024 * 1024);
2893 diag_register
.unique_id
= 0x7075900;
2894 ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] = 0;
2895 _ctl_diag_register_2(ioc
, &diag_register
);
2896 } else if (!strcmp(str
, "release")) {
2897 /* exit out if host buffers are already released */
2898 if (!ioc
->diag_buffer
[MPI2_DIAG_BUF_TYPE_TRACE
])
2900 if ((ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] &
2901 MPT3_DIAG_BUFFER_IS_REGISTERED
) == 0)
2903 if ((ioc
->diag_buffer_status
[MPI2_DIAG_BUF_TYPE_TRACE
] &
2904 MPT3_DIAG_BUFFER_IS_RELEASED
))
2906 pr_info(MPT3SAS_FMT
"releasing host trace buffer\n",
2908 mpt3sas_send_diag_release(ioc
, MPI2_DIAG_BUF_TYPE_TRACE
,
2915 static DEVICE_ATTR(host_trace_buffer_enable
, S_IRUGO
| S_IWUSR
,
2916 _ctl_host_trace_buffer_enable_show
,
2917 _ctl_host_trace_buffer_enable_store
);
2919 /*********** diagnostic trigger suppport *********************************/
2922 * _ctl_diag_trigger_master_show - show the diag_trigger_master attribute
2923 * @cdev - pointer to embedded class device
2924 * @buf - the buffer returned
2926 * A sysfs 'read/write' shost attribute.
2929 _ctl_diag_trigger_master_show(struct device
*cdev
,
2930 struct device_attribute
*attr
, char *buf
)
2933 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2934 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2935 unsigned long flags
;
2938 spin_lock_irqsave(&ioc
->diag_trigger_lock
, flags
);
2939 rc
= sizeof(struct SL_WH_MASTER_TRIGGER_T
);
2940 memcpy(buf
, &ioc
->diag_trigger_master
, rc
);
2941 spin_unlock_irqrestore(&ioc
->diag_trigger_lock
, flags
);
2946 * _ctl_diag_trigger_master_store - store the diag_trigger_master attribute
2947 * @cdev - pointer to embedded class device
2948 * @buf - the buffer returned
2950 * A sysfs 'read/write' shost attribute.
2953 _ctl_diag_trigger_master_store(struct device
*cdev
,
2954 struct device_attribute
*attr
, const char *buf
, size_t count
)
2957 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2958 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2959 unsigned long flags
;
2962 spin_lock_irqsave(&ioc
->diag_trigger_lock
, flags
);
2963 rc
= min(sizeof(struct SL_WH_MASTER_TRIGGER_T
), count
);
2964 memset(&ioc
->diag_trigger_master
, 0,
2965 sizeof(struct SL_WH_MASTER_TRIGGER_T
));
2966 memcpy(&ioc
->diag_trigger_master
, buf
, rc
);
2967 ioc
->diag_trigger_master
.MasterData
|=
2968 (MASTER_TRIGGER_FW_FAULT
+ MASTER_TRIGGER_ADAPTER_RESET
);
2969 spin_unlock_irqrestore(&ioc
->diag_trigger_lock
, flags
);
2972 static DEVICE_ATTR(diag_trigger_master
, S_IRUGO
| S_IWUSR
,
2973 _ctl_diag_trigger_master_show
, _ctl_diag_trigger_master_store
);
2977 * _ctl_diag_trigger_event_show - show the diag_trigger_event attribute
2978 * @cdev - pointer to embedded class device
2979 * @buf - the buffer returned
2981 * A sysfs 'read/write' shost attribute.
2984 _ctl_diag_trigger_event_show(struct device
*cdev
,
2985 struct device_attribute
*attr
, char *buf
)
2987 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2988 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
2989 unsigned long flags
;
2992 spin_lock_irqsave(&ioc
->diag_trigger_lock
, flags
);
2993 rc
= sizeof(struct SL_WH_EVENT_TRIGGERS_T
);
2994 memcpy(buf
, &ioc
->diag_trigger_event
, rc
);
2995 spin_unlock_irqrestore(&ioc
->diag_trigger_lock
, flags
);
3000 * _ctl_diag_trigger_event_store - store the diag_trigger_event attribute
3001 * @cdev - pointer to embedded class device
3002 * @buf - the buffer returned
3004 * A sysfs 'read/write' shost attribute.
3007 _ctl_diag_trigger_event_store(struct device
*cdev
,
3008 struct device_attribute
*attr
, const char *buf
, size_t count
)
3011 struct Scsi_Host
*shost
= class_to_shost(cdev
);
3012 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
3013 unsigned long flags
;
3016 spin_lock_irqsave(&ioc
->diag_trigger_lock
, flags
);
3017 sz
= min(sizeof(struct SL_WH_EVENT_TRIGGERS_T
), count
);
3018 memset(&ioc
->diag_trigger_event
, 0,
3019 sizeof(struct SL_WH_EVENT_TRIGGERS_T
));
3020 memcpy(&ioc
->diag_trigger_event
, buf
, sz
);
3021 if (ioc
->diag_trigger_event
.ValidEntries
> NUM_VALID_ENTRIES
)
3022 ioc
->diag_trigger_event
.ValidEntries
= NUM_VALID_ENTRIES
;
3023 spin_unlock_irqrestore(&ioc
->diag_trigger_lock
, flags
);
3026 static DEVICE_ATTR(diag_trigger_event
, S_IRUGO
| S_IWUSR
,
3027 _ctl_diag_trigger_event_show
, _ctl_diag_trigger_event_store
);
3031 * _ctl_diag_trigger_scsi_show - show the diag_trigger_scsi attribute
3032 * @cdev - pointer to embedded class device
3033 * @buf - the buffer returned
3035 * A sysfs 'read/write' shost attribute.
3038 _ctl_diag_trigger_scsi_show(struct device
*cdev
,
3039 struct device_attribute
*attr
, char *buf
)
3041 struct Scsi_Host
*shost
= class_to_shost(cdev
);
3042 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
3043 unsigned long flags
;
3046 spin_lock_irqsave(&ioc
->diag_trigger_lock
, flags
);
3047 rc
= sizeof(struct SL_WH_SCSI_TRIGGERS_T
);
3048 memcpy(buf
, &ioc
->diag_trigger_scsi
, rc
);
3049 spin_unlock_irqrestore(&ioc
->diag_trigger_lock
, flags
);
3054 * _ctl_diag_trigger_scsi_store - store the diag_trigger_scsi attribute
3055 * @cdev - pointer to embedded class device
3056 * @buf - the buffer returned
3058 * A sysfs 'read/write' shost attribute.
3061 _ctl_diag_trigger_scsi_store(struct device
*cdev
,
3062 struct device_attribute
*attr
, const char *buf
, size_t count
)
3064 struct Scsi_Host
*shost
= class_to_shost(cdev
);
3065 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
3066 unsigned long flags
;
3069 spin_lock_irqsave(&ioc
->diag_trigger_lock
, flags
);
3070 sz
= min(sizeof(struct SL_WH_SCSI_TRIGGERS_T
), count
);
3071 memset(&ioc
->diag_trigger_scsi
, 0,
3072 sizeof(struct SL_WH_EVENT_TRIGGERS_T
));
3073 memcpy(&ioc
->diag_trigger_scsi
, buf
, sz
);
3074 if (ioc
->diag_trigger_scsi
.ValidEntries
> NUM_VALID_ENTRIES
)
3075 ioc
->diag_trigger_scsi
.ValidEntries
= NUM_VALID_ENTRIES
;
3076 spin_unlock_irqrestore(&ioc
->diag_trigger_lock
, flags
);
3079 static DEVICE_ATTR(diag_trigger_scsi
, S_IRUGO
| S_IWUSR
,
3080 _ctl_diag_trigger_scsi_show
, _ctl_diag_trigger_scsi_store
);
3084 * _ctl_diag_trigger_scsi_show - show the diag_trigger_mpi attribute
3085 * @cdev - pointer to embedded class device
3086 * @buf - the buffer returned
3088 * A sysfs 'read/write' shost attribute.
3091 _ctl_diag_trigger_mpi_show(struct device
*cdev
,
3092 struct device_attribute
*attr
, char *buf
)
3094 struct Scsi_Host
*shost
= class_to_shost(cdev
);
3095 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
3096 unsigned long flags
;
3099 spin_lock_irqsave(&ioc
->diag_trigger_lock
, flags
);
3100 rc
= sizeof(struct SL_WH_MPI_TRIGGERS_T
);
3101 memcpy(buf
, &ioc
->diag_trigger_mpi
, rc
);
3102 spin_unlock_irqrestore(&ioc
->diag_trigger_lock
, flags
);
3107 * _ctl_diag_trigger_mpi_store - store the diag_trigger_mpi attribute
3108 * @cdev - pointer to embedded class device
3109 * @buf - the buffer returned
3111 * A sysfs 'read/write' shost attribute.
3114 _ctl_diag_trigger_mpi_store(struct device
*cdev
,
3115 struct device_attribute
*attr
, const char *buf
, size_t count
)
3117 struct Scsi_Host
*shost
= class_to_shost(cdev
);
3118 struct MPT3SAS_ADAPTER
*ioc
= shost_priv(shost
);
3119 unsigned long flags
;
3122 spin_lock_irqsave(&ioc
->diag_trigger_lock
, flags
);
3123 sz
= min(sizeof(struct SL_WH_MPI_TRIGGERS_T
), count
);
3124 memset(&ioc
->diag_trigger_mpi
, 0,
3125 sizeof(ioc
->diag_trigger_mpi
));
3126 memcpy(&ioc
->diag_trigger_mpi
, buf
, sz
);
3127 if (ioc
->diag_trigger_mpi
.ValidEntries
> NUM_VALID_ENTRIES
)
3128 ioc
->diag_trigger_mpi
.ValidEntries
= NUM_VALID_ENTRIES
;
3129 spin_unlock_irqrestore(&ioc
->diag_trigger_lock
, flags
);
3133 static DEVICE_ATTR(diag_trigger_mpi
, S_IRUGO
| S_IWUSR
,
3134 _ctl_diag_trigger_mpi_show
, _ctl_diag_trigger_mpi_store
);
3136 /*********** diagnostic trigger suppport *** END ****************************/
3140 /*****************************************/
3142 struct device_attribute
*mpt3sas_host_attrs
[] = {
3143 &dev_attr_version_fw
,
3144 &dev_attr_version_bios
,
3145 &dev_attr_version_mpi
,
3146 &dev_attr_version_product
,
3147 &dev_attr_version_nvdata_persistent
,
3148 &dev_attr_version_nvdata_default
,
3149 &dev_attr_board_name
,
3150 &dev_attr_board_assembly
,
3151 &dev_attr_board_tracer
,
3153 &dev_attr_device_delay
,
3154 &dev_attr_logging_level
,
3155 &dev_attr_fwfault_debug
,
3156 &dev_attr_fw_queue_depth
,
3157 &dev_attr_host_sas_address
,
3158 &dev_attr_ioc_reset_count
,
3159 &dev_attr_host_trace_buffer_size
,
3160 &dev_attr_host_trace_buffer
,
3161 &dev_attr_host_trace_buffer_enable
,
3162 &dev_attr_reply_queue_count
,
3163 &dev_attr_diag_trigger_master
,
3164 &dev_attr_diag_trigger_event
,
3165 &dev_attr_diag_trigger_scsi
,
3166 &dev_attr_diag_trigger_mpi
,
3170 /* device attributes */
3173 * _ctl_device_sas_address_show - sas address
3174 * @cdev - pointer to embedded class device
3175 * @buf - the buffer returned
3177 * This is the sas address for the target
3179 * A sysfs 'read-only' shost attribute.
3182 _ctl_device_sas_address_show(struct device
*dev
, struct device_attribute
*attr
,
3185 struct scsi_device
*sdev
= to_scsi_device(dev
);
3186 struct MPT3SAS_DEVICE
*sas_device_priv_data
= sdev
->hostdata
;
3188 return snprintf(buf
, PAGE_SIZE
, "0x%016llx\n",
3189 (unsigned long long)sas_device_priv_data
->sas_target
->sas_address
);
3191 static DEVICE_ATTR(sas_address
, S_IRUGO
, _ctl_device_sas_address_show
, NULL
);
3194 * _ctl_device_handle_show - device handle
3195 * @cdev - pointer to embedded class device
3196 * @buf - the buffer returned
3198 * This is the firmware assigned device handle
3200 * A sysfs 'read-only' shost attribute.
3203 _ctl_device_handle_show(struct device
*dev
, struct device_attribute
*attr
,
3206 struct scsi_device
*sdev
= to_scsi_device(dev
);
3207 struct MPT3SAS_DEVICE
*sas_device_priv_data
= sdev
->hostdata
;
3209 return snprintf(buf
, PAGE_SIZE
, "0x%04x\n",
3210 sas_device_priv_data
->sas_target
->handle
);
3212 static DEVICE_ATTR(sas_device_handle
, S_IRUGO
, _ctl_device_handle_show
, NULL
);
3214 struct device_attribute
*mpt3sas_dev_attrs
[] = {
3215 &dev_attr_sas_address
,
3216 &dev_attr_sas_device_handle
,
3220 static const struct file_operations ctl_fops
= {
3221 .owner
= THIS_MODULE
,
3222 .unlocked_ioctl
= _ctl_ioctl
,
3224 .fasync
= _ctl_fasync
,
3225 #ifdef CONFIG_COMPAT
3226 .compat_ioctl
= _ctl_ioctl_compat
,
3230 static struct miscdevice ctl_dev
= {
3231 .minor
= MPT3SAS_MINOR
,
3232 .name
= MPT3SAS_DEV_NAME
,
3237 * mpt3sas_ctl_init - main entry point for ctl.
3241 mpt3sas_ctl_init(void)
3244 if (misc_register(&ctl_dev
) < 0)
3245 pr_err("%s can't register misc device [minor=%d]\n",
3246 MPT3SAS_DRIVER_NAME
, MPT3SAS_MINOR
);
3248 init_waitqueue_head(&ctl_poll_wait
);
3252 * mpt3sas_ctl_exit - exit point for ctl
3256 mpt3sas_ctl_exit(void)
3258 struct MPT3SAS_ADAPTER
*ioc
;
3261 list_for_each_entry(ioc
, &mpt3sas_ioc_list
, list
) {
3263 /* free memory associated to diag buffers */
3264 for (i
= 0; i
< MPI2_DIAG_BUF_TYPE_COUNT
; i
++) {
3265 if (!ioc
->diag_buffer
[i
])
3267 if (!(ioc
->diag_buffer_status
[i
] &
3268 MPT3_DIAG_BUFFER_IS_REGISTERED
))
3270 if ((ioc
->diag_buffer_status
[i
] &
3271 MPT3_DIAG_BUFFER_IS_RELEASED
))
3273 pci_free_consistent(ioc
->pdev
, ioc
->diag_buffer_sz
[i
],
3274 ioc
->diag_buffer
[i
], ioc
->diag_buffer_dma
[i
]);
3275 ioc
->diag_buffer
[i
] = NULL
;
3276 ioc
->diag_buffer_status
[i
] = 0;
3279 kfree(ioc
->event_log
);
3281 misc_deregister(&ctl_dev
);