2 * Management Module Support for MPT (Message Passing Technology) based
5 * This code is based on drivers/scsi/mpt2sas/mpt2_ctl.c
6 * Copyright (C) 2007-2008 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/version.h>
46 #include <linux/kernel.h>
47 #include <linux/module.h>
48 #include <linux/errno.h>
49 #include <linux/init.h>
50 #include <linux/slab.h>
51 #include <linux/types.h>
52 #include <linux/pci.h>
53 #include <linux/delay.h>
54 #include <linux/smp_lock.h>
55 #include <linux/compat.h>
56 #include <linux/poll.h>
59 #include <linux/uaccess.h>
61 #include "mpt2sas_base.h"
62 #include "mpt2sas_ctl.h"
64 static struct fasync_struct
*async_queue
;
65 static DECLARE_WAIT_QUEUE_HEAD(ctl_poll_wait
);
67 static int _ctl_send_release(struct MPT2SAS_ADAPTER
*ioc
, u8 buffer_type
,
71 * enum block_state - blocking state
72 * @NON_BLOCKING: non blocking
75 * These states are for ioctls that need to wait for a response
76 * from firmware, so they probably require sleep.
83 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
85 * _ctl_display_some_debug - debug routine
86 * @ioc: per adapter object
87 * @smid: system request message index
88 * @calling_function_name: string pass from calling function
89 * @mpi_reply: reply message frame
92 * Function for displaying debug info helpfull when debugging issues
96 _ctl_display_some_debug(struct MPT2SAS_ADAPTER
*ioc
, u16 smid
,
97 char *calling_function_name
, MPI2DefaultReply_t
*mpi_reply
)
99 Mpi2ConfigRequest_t
*mpi_request
;
102 if (!(ioc
->logging_level
& MPT_DEBUG_IOCTL
))
105 mpi_request
= mpt2sas_base_get_msg_frame(ioc
, smid
);
106 switch (mpi_request
->Function
) {
107 case MPI2_FUNCTION_SCSI_IO_REQUEST
:
109 Mpi2SCSIIORequest_t
*scsi_request
=
110 (Mpi2SCSIIORequest_t
*)mpi_request
;
112 snprintf(ioc
->tmp_string
, MPT_STRING_LENGTH
,
113 "scsi_io, cmd(0x%02x), cdb_len(%d)",
114 scsi_request
->CDB
.CDB32
[0],
115 le16_to_cpu(scsi_request
->IoFlags
) & 0xF);
116 desc
= ioc
->tmp_string
;
119 case MPI2_FUNCTION_SCSI_TASK_MGMT
:
122 case MPI2_FUNCTION_IOC_INIT
:
125 case MPI2_FUNCTION_IOC_FACTS
:
128 case MPI2_FUNCTION_CONFIG
:
130 Mpi2ConfigRequest_t
*config_request
=
131 (Mpi2ConfigRequest_t
*)mpi_request
;
133 snprintf(ioc
->tmp_string
, MPT_STRING_LENGTH
,
134 "config, type(0x%02x), ext_type(0x%02x), number(%d)",
135 (config_request
->Header
.PageType
&
136 MPI2_CONFIG_PAGETYPE_MASK
), config_request
->ExtPageType
,
137 config_request
->Header
.PageNumber
);
138 desc
= ioc
->tmp_string
;
141 case MPI2_FUNCTION_PORT_FACTS
:
144 case MPI2_FUNCTION_PORT_ENABLE
:
145 desc
= "port_enable";
147 case MPI2_FUNCTION_EVENT_NOTIFICATION
:
148 desc
= "event_notification";
150 case MPI2_FUNCTION_FW_DOWNLOAD
:
151 desc
= "fw_download";
153 case MPI2_FUNCTION_FW_UPLOAD
:
156 case MPI2_FUNCTION_RAID_ACTION
:
157 desc
= "raid_action";
159 case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
:
161 Mpi2SCSIIORequest_t
*scsi_request
=
162 (Mpi2SCSIIORequest_t
*)mpi_request
;
164 snprintf(ioc
->tmp_string
, MPT_STRING_LENGTH
,
165 "raid_pass, cmd(0x%02x), cdb_len(%d)",
166 scsi_request
->CDB
.CDB32
[0],
167 le16_to_cpu(scsi_request
->IoFlags
) & 0xF);
168 desc
= ioc
->tmp_string
;
171 case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL
:
172 desc
= "sas_iounit_cntl";
174 case MPI2_FUNCTION_SATA_PASSTHROUGH
:
177 case MPI2_FUNCTION_DIAG_BUFFER_POST
:
178 desc
= "diag_buffer_post";
180 case MPI2_FUNCTION_DIAG_RELEASE
:
181 desc
= "diag_release";
183 case MPI2_FUNCTION_SMP_PASSTHROUGH
:
184 desc
= "smp_passthrough";
191 printk(MPT2SAS_DEBUG_FMT
"%s: %s, smid(%d)\n",
192 ioc
->name
, calling_function_name
, desc
, smid
);
197 if (mpi_reply
->IOCStatus
|| mpi_reply
->IOCLogInfo
)
198 printk(MPT2SAS_DEBUG_FMT
199 "\tiocstatus(0x%04x), loginfo(0x%08x)\n",
200 ioc
->name
, le16_to_cpu(mpi_reply
->IOCStatus
),
201 le32_to_cpu(mpi_reply
->IOCLogInfo
));
203 if (mpi_request
->Function
== MPI2_FUNCTION_SCSI_IO_REQUEST
||
204 mpi_request
->Function
==
205 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
) {
206 Mpi2SCSIIOReply_t
*scsi_reply
=
207 (Mpi2SCSIIOReply_t
*)mpi_reply
;
208 if (scsi_reply
->SCSIState
|| scsi_reply
->SCSIStatus
)
209 printk(MPT2SAS_DEBUG_FMT
210 "\tscsi_state(0x%02x), scsi_status"
211 "(0x%02x)\n", ioc
->name
,
212 scsi_reply
->SCSIState
,
213 scsi_reply
->SCSIStatus
);
219 * mpt2sas_ctl_done - ctl module completion routine
220 * @ioc: per adapter object
221 * @smid: system request message index
222 * @VF_ID: virtual function id
223 * @reply: reply message frame(lower 32bit addr)
226 * The callback handler when using ioc->ctl_cb_idx.
231 mpt2sas_ctl_done(struct MPT2SAS_ADAPTER
*ioc
, u16 smid
, u8 VF_ID
, u32 reply
)
233 MPI2DefaultReply_t
*mpi_reply
;
235 if (ioc
->ctl_cmds
.status
== MPT2_CMD_NOT_USED
)
237 if (ioc
->ctl_cmds
.smid
!= smid
)
239 ioc
->ctl_cmds
.status
|= MPT2_CMD_COMPLETE
;
240 mpi_reply
= mpt2sas_base_get_reply_virt_addr(ioc
, reply
);
242 memcpy(ioc
->ctl_cmds
.reply
, mpi_reply
, mpi_reply
->MsgLength
*4);
243 ioc
->ctl_cmds
.status
|= MPT2_CMD_REPLY_VALID
;
245 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
246 _ctl_display_some_debug(ioc
, smid
, "ctl_done", mpi_reply
);
248 ioc
->ctl_cmds
.status
&= ~MPT2_CMD_PENDING
;
249 complete(&ioc
->ctl_cmds
.done
);
253 * _ctl_check_event_type - determines when an event needs logging
254 * @ioc: per adapter object
255 * @event: firmware event
257 * The bitmask in ioc->event_type[] indicates which events should be
258 * be saved in the driver event_log. This bitmask is set by application.
260 * Returns 1 when event should be captured, or zero means no match.
263 _ctl_check_event_type(struct MPT2SAS_ADAPTER
*ioc
, u16 event
)
268 if (event
>= 128 || !event
|| !ioc
->event_log
)
271 desired_event
= (1 << (event
% 32));
275 return desired_event
& ioc
->event_type
[i
];
279 * mpt2sas_ctl_add_to_event_log - add event
280 * @ioc: per adapter object
281 * @mpi_reply: reply message frame
286 mpt2sas_ctl_add_to_event_log(struct MPT2SAS_ADAPTER
*ioc
,
287 Mpi2EventNotificationReply_t
*mpi_reply
)
289 struct MPT2_IOCTL_EVENTS
*event_log
;
292 u32 sz
, event_data_sz
;
298 event
= le16_to_cpu(mpi_reply
->Event
);
300 if (_ctl_check_event_type(ioc
, event
)) {
302 /* insert entry into circular event_log */
303 i
= ioc
->event_context
% MPT2SAS_CTL_EVENT_LOG_SIZE
;
304 event_log
= ioc
->event_log
;
305 event_log
[i
].event
= event
;
306 event_log
[i
].context
= ioc
->event_context
++;
308 event_data_sz
= le16_to_cpu(mpi_reply
->EventDataLength
)*4;
309 sz
= min_t(u32
, event_data_sz
, MPT2_EVENT_DATA_SIZE
);
310 memset(event_log
[i
].data
, 0, MPT2_EVENT_DATA_SIZE
);
311 memcpy(event_log
[i
].data
, mpi_reply
->EventData
, sz
);
315 /* This aen_event_read_flag flag is set until the
316 * application has read the event log.
317 * For MPI2_EVENT_LOG_ENTRY_ADDED, we always notify.
319 if (event
== MPI2_EVENT_LOG_ENTRY_ADDED
||
320 (send_aen
&& !ioc
->aen_event_read_flag
)) {
321 ioc
->aen_event_read_flag
= 1;
322 wake_up_interruptible(&ctl_poll_wait
);
324 kill_fasync(&async_queue
, SIGIO
, POLL_IN
);
329 * mpt2sas_ctl_event_callback - firmware event handler (called at ISR time)
330 * @ioc: per adapter object
331 * @VF_ID: virtual function id
332 * @reply: reply message frame(lower 32bit addr)
333 * Context: interrupt.
335 * This function merely adds a new work task into ioc->firmware_event_thread.
336 * The tasks are worked from _firmware_event_work in user context.
341 mpt2sas_ctl_event_callback(struct MPT2SAS_ADAPTER
*ioc
, u8 VF_ID
, u32 reply
)
343 Mpi2EventNotificationReply_t
*mpi_reply
;
345 mpi_reply
= mpt2sas_base_get_reply_virt_addr(ioc
, reply
);
346 mpt2sas_ctl_add_to_event_log(ioc
, mpi_reply
);
350 * _ctl_verify_adapter - validates ioc_number passed from application
351 * @ioc: per adapter object
352 * @iocpp: The ioc pointer is returned in this.
354 * Return (-1) means error, else ioc_number.
357 _ctl_verify_adapter(int ioc_number
, struct MPT2SAS_ADAPTER
**iocpp
)
359 struct MPT2SAS_ADAPTER
*ioc
;
361 list_for_each_entry(ioc
, &mpt2sas_ioc_list
, list
) {
362 if (ioc
->id
!= ioc_number
)
372 * mpt2sas_ctl_reset_handler - reset callback handler (for ctl)
373 * @ioc: per adapter object
374 * @reset_phase: phase
376 * The handler for doing any required cleanup or initialization.
378 * The reset phase can be MPT2_IOC_PRE_RESET, MPT2_IOC_AFTER_RESET,
379 * MPT2_IOC_DONE_RESET
382 mpt2sas_ctl_reset_handler(struct MPT2SAS_ADAPTER
*ioc
, int reset_phase
)
387 switch (reset_phase
) {
388 case MPT2_IOC_PRE_RESET
:
389 dtmprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s: "
390 "MPT2_IOC_PRE_RESET\n", ioc
->name
, __func__
));
391 for (i
= 0; i
< MPI2_DIAG_BUF_TYPE_COUNT
; i
++) {
392 if (!(ioc
->diag_buffer_status
[i
] &
393 MPT2_DIAG_BUFFER_IS_REGISTERED
))
395 if ((ioc
->diag_buffer_status
[i
] &
396 MPT2_DIAG_BUFFER_IS_RELEASED
))
398 _ctl_send_release(ioc
, i
, &issue_reset
);
401 case MPT2_IOC_AFTER_RESET
:
402 dtmprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s: "
403 "MPT2_IOC_AFTER_RESET\n", ioc
->name
, __func__
));
404 if (ioc
->ctl_cmds
.status
& MPT2_CMD_PENDING
) {
405 ioc
->ctl_cmds
.status
|= MPT2_CMD_RESET
;
406 mpt2sas_base_free_smid(ioc
, ioc
->ctl_cmds
.smid
);
407 complete(&ioc
->ctl_cmds
.done
);
410 case MPT2_IOC_DONE_RESET
:
411 dtmprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s: "
412 "MPT2_IOC_DONE_RESET\n", ioc
->name
, __func__
));
414 for (i
= 0; i
< MPI2_DIAG_BUF_TYPE_COUNT
; i
++) {
415 if (!(ioc
->diag_buffer_status
[i
] &
416 MPT2_DIAG_BUFFER_IS_REGISTERED
))
418 if ((ioc
->diag_buffer_status
[i
] &
419 MPT2_DIAG_BUFFER_IS_RELEASED
))
421 ioc
->diag_buffer_status
[i
] |=
422 MPT2_DIAG_BUFFER_IS_DIAG_RESET
;
434 * Called when application request fasyn callback handler.
437 _ctl_fasync(int fd
, struct file
*filep
, int mode
)
439 return fasync_helper(fd
, filep
, mode
, &async_queue
);
447 * Called when application releases the fasyn callback handler.
450 _ctl_release(struct inode
*inode
, struct file
*filep
)
452 return fasync_helper(-1, filep
, 0, &async_queue
);
462 _ctl_poll(struct file
*filep
, poll_table
*wait
)
464 struct MPT2SAS_ADAPTER
*ioc
;
466 poll_wait(filep
, &ctl_poll_wait
, wait
);
468 list_for_each_entry(ioc
, &mpt2sas_ioc_list
, list
) {
469 if (ioc
->aen_event_read_flag
)
470 return POLLIN
| POLLRDNORM
;
476 * _ctl_do_task_abort - assign an active smid to the abort_task
477 * @ioc: per adapter object
478 * @karg - (struct mpt2_ioctl_command)
479 * @tm_request - pointer to mf from user space
481 * Returns 0 when an smid if found, else fail.
482 * during failure, the reply frame is filled.
485 _ctl_do_task_abort(struct MPT2SAS_ADAPTER
*ioc
, struct mpt2_ioctl_command
*karg
,
486 Mpi2SCSITaskManagementRequest_t
*tm_request
)
491 struct scsi_cmnd
*scmd
;
492 struct MPT2SAS_DEVICE
*priv_data
;
494 Mpi2SCSITaskManagementReply_t
*tm_reply
;
498 lun
= scsilun_to_int((struct scsi_lun
*)tm_request
->LUN
);
500 handle
= le16_to_cpu(tm_request
->DevHandle
);
501 spin_lock_irqsave(&ioc
->scsi_lookup_lock
, flags
);
502 for (i
= ioc
->request_depth
; i
&& !found
; i
--) {
503 scmd
= ioc
->scsi_lookup
[i
- 1].scmd
;
504 if (scmd
== NULL
|| scmd
->device
== NULL
||
505 scmd
->device
->hostdata
== NULL
)
507 if (lun
!= scmd
->device
->lun
)
509 priv_data
= scmd
->device
->hostdata
;
510 if (priv_data
->sas_target
== NULL
)
512 if (priv_data
->sas_target
->handle
!= handle
)
514 tm_request
->TaskMID
= cpu_to_le16(ioc
->scsi_lookup
[i
- 1].smid
);
517 spin_unlock_irqrestore(&ioc
->scsi_lookup_lock
, flags
);
520 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"ABORT_TASK: "
521 "DevHandle(0x%04x), lun(%d), no active mid!!\n", ioc
->name
,
522 tm_request
->DevHandle
, lun
));
523 tm_reply
= ioc
->ctl_cmds
.reply
;
524 tm_reply
->DevHandle
= tm_request
->DevHandle
;
525 tm_reply
->Function
= MPI2_FUNCTION_SCSI_TASK_MGMT
;
526 tm_reply
->TaskType
= MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK
;
527 tm_reply
->MsgLength
= sizeof(Mpi2SCSITaskManagementReply_t
)/4;
528 tm_reply
->VP_ID
= tm_request
->VP_ID
;
529 tm_reply
->VF_ID
= tm_request
->VF_ID
;
530 sz
= min_t(u32
, karg
->max_reply_bytes
, ioc
->reply_sz
);
531 if (copy_to_user(karg
->reply_frame_buf_ptr
, ioc
->ctl_cmds
.reply
,
533 printk(KERN_ERR
"failure at %s:%d/%s()!\n", __FILE__
,
538 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"ABORT_TASK: "
539 "DevHandle(0x%04x), lun(%d), smid(%d)\n", ioc
->name
,
540 tm_request
->DevHandle
, lun
, tm_request
->TaskMID
));
545 * _ctl_do_mpt_command - main handler for MPT2COMMAND opcode
546 * @ioc: per adapter object
547 * @karg - (struct mpt2_ioctl_command)
548 * @mf - pointer to mf in user space
549 * @state - NON_BLOCKING or BLOCKING
552 _ctl_do_mpt_command(struct MPT2SAS_ADAPTER
*ioc
,
553 struct mpt2_ioctl_command karg
, void __user
*mf
, enum block_state state
)
555 MPI2RequestHeader_t
*mpi_request
;
556 MPI2DefaultReply_t
*mpi_reply
;
560 unsigned long timeout
, timeleft
;
564 void *priv_sense
= NULL
;
565 void *data_out
= NULL
;
566 dma_addr_t data_out_dma
;
567 size_t data_out_sz
= 0;
568 void *data_in
= NULL
;
569 dma_addr_t data_in_dma
;
570 size_t data_in_sz
= 0;
573 u16 wait_state_count
;
577 if (state
== NON_BLOCKING
&& !mutex_trylock(&ioc
->ctl_cmds
.mutex
))
579 else if (mutex_lock_interruptible(&ioc
->ctl_cmds
.mutex
))
582 if (ioc
->ctl_cmds
.status
!= MPT2_CMD_NOT_USED
) {
583 printk(MPT2SAS_ERR_FMT
"%s: ctl_cmd in use\n",
584 ioc
->name
, __func__
);
589 wait_state_count
= 0;
590 ioc_state
= mpt2sas_base_get_iocstate(ioc
, 1);
591 while (ioc_state
!= MPI2_IOC_STATE_OPERATIONAL
) {
592 if (wait_state_count
++ == 10) {
593 printk(MPT2SAS_ERR_FMT
594 "%s: failed due to ioc not operational\n",
595 ioc
->name
, __func__
);
600 ioc_state
= mpt2sas_base_get_iocstate(ioc
, 1);
601 printk(MPT2SAS_INFO_FMT
"%s: waiting for "
602 "operational state(count=%d)\n", ioc
->name
,
603 __func__
, wait_state_count
);
605 if (wait_state_count
)
606 printk(MPT2SAS_INFO_FMT
"%s: ioc is operational\n",
607 ioc
->name
, __func__
);
609 smid
= mpt2sas_base_get_smid(ioc
, ioc
->ctl_cb_idx
);
611 printk(MPT2SAS_ERR_FMT
"%s: failed obtaining a smid\n",
612 ioc
->name
, __func__
);
618 ioc
->ctl_cmds
.status
= MPT2_CMD_PENDING
;
619 memset(ioc
->ctl_cmds
.reply
, 0, ioc
->reply_sz
);
620 mpi_request
= mpt2sas_base_get_msg_frame(ioc
, smid
);
621 ioc
->ctl_cmds
.smid
= smid
;
622 data_out_sz
= karg
.data_out_size
;
623 data_in_sz
= karg
.data_in_size
;
625 /* copy in request message frame from user */
626 if (copy_from_user(mpi_request
, mf
, karg
.data_sge_offset
*4)) {
627 printk(KERN_ERR
"failure at %s:%d/%s()!\n", __FILE__
, __LINE__
,
630 mpt2sas_base_free_smid(ioc
, smid
);
634 if (mpi_request
->Function
== MPI2_FUNCTION_SCSI_IO_REQUEST
||
635 mpi_request
->Function
== MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
) {
636 if (!mpi_request
->FunctionDependent1
||
637 mpi_request
->FunctionDependent1
>
638 cpu_to_le16(ioc
->facts
.MaxDevHandle
)) {
640 mpt2sas_base_free_smid(ioc
, smid
);
645 /* obtain dma-able memory for data transfer */
646 if (data_out_sz
) /* WRITE */ {
647 data_out
= pci_alloc_consistent(ioc
->pdev
, data_out_sz
,
650 printk(KERN_ERR
"failure at %s:%d/%s()!\n", __FILE__
,
653 mpt2sas_base_free_smid(ioc
, smid
);
656 if (copy_from_user(data_out
, karg
.data_out_buf_ptr
,
658 printk(KERN_ERR
"failure at %s:%d/%s()!\n", __FILE__
,
661 mpt2sas_base_free_smid(ioc
, smid
);
666 if (data_in_sz
) /* READ */ {
667 data_in
= pci_alloc_consistent(ioc
->pdev
, data_in_sz
,
670 printk(KERN_ERR
"failure at %s:%d/%s()!\n", __FILE__
,
673 mpt2sas_base_free_smid(ioc
, smid
);
678 /* add scatter gather elements */
679 psge
= (void *)mpi_request
+ (karg
.data_sge_offset
*4);
681 if (!data_out_sz
&& !data_in_sz
) {
682 mpt2sas_base_build_zero_len_sge(ioc
, psge
);
683 } else if (data_out_sz
&& data_in_sz
) {
684 /* WRITE sgel first */
685 sgl_flags
= (MPI2_SGE_FLAGS_SIMPLE_ELEMENT
|
686 MPI2_SGE_FLAGS_END_OF_BUFFER
| MPI2_SGE_FLAGS_HOST_TO_IOC
);
687 sgl_flags
= sgl_flags
<< MPI2_SGE_FLAGS_SHIFT
;
688 ioc
->base_add_sg_single(psge
, sgl_flags
|
689 data_out_sz
, data_out_dma
);
692 psge
+= ioc
->sge_size
;
695 sgl_flags
= (MPI2_SGE_FLAGS_SIMPLE_ELEMENT
|
696 MPI2_SGE_FLAGS_LAST_ELEMENT
| MPI2_SGE_FLAGS_END_OF_BUFFER
|
697 MPI2_SGE_FLAGS_END_OF_LIST
);
698 sgl_flags
= sgl_flags
<< MPI2_SGE_FLAGS_SHIFT
;
699 ioc
->base_add_sg_single(psge
, sgl_flags
|
700 data_in_sz
, data_in_dma
);
701 } else if (data_out_sz
) /* WRITE */ {
702 sgl_flags
= (MPI2_SGE_FLAGS_SIMPLE_ELEMENT
|
703 MPI2_SGE_FLAGS_LAST_ELEMENT
| MPI2_SGE_FLAGS_END_OF_BUFFER
|
704 MPI2_SGE_FLAGS_END_OF_LIST
| MPI2_SGE_FLAGS_HOST_TO_IOC
);
705 sgl_flags
= sgl_flags
<< MPI2_SGE_FLAGS_SHIFT
;
706 ioc
->base_add_sg_single(psge
, sgl_flags
|
707 data_out_sz
, data_out_dma
);
708 } else if (data_in_sz
) /* READ */ {
709 sgl_flags
= (MPI2_SGE_FLAGS_SIMPLE_ELEMENT
|
710 MPI2_SGE_FLAGS_LAST_ELEMENT
| MPI2_SGE_FLAGS_END_OF_BUFFER
|
711 MPI2_SGE_FLAGS_END_OF_LIST
);
712 sgl_flags
= sgl_flags
<< MPI2_SGE_FLAGS_SHIFT
;
713 ioc
->base_add_sg_single(psge
, sgl_flags
|
714 data_in_sz
, data_in_dma
);
717 /* send command to firmware */
718 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
719 _ctl_display_some_debug(ioc
, smid
, "ctl_request", NULL
);
722 switch (mpi_request
->Function
) {
723 case MPI2_FUNCTION_SCSI_IO_REQUEST
:
724 case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
:
726 Mpi2SCSIIORequest_t
*scsiio_request
=
727 (Mpi2SCSIIORequest_t
*)mpi_request
;
728 scsiio_request
->SenseBufferLowAddress
=
729 (u32
)mpt2sas_base_get_sense_buffer_dma(ioc
, smid
);
730 priv_sense
= mpt2sas_base_get_sense_buffer(ioc
, smid
);
731 memset(priv_sense
, 0, SCSI_SENSE_BUFFERSIZE
);
732 mpt2sas_base_put_smid_scsi_io(ioc
, smid
, 0,
733 le16_to_cpu(mpi_request
->FunctionDependent1
));
736 case MPI2_FUNCTION_SCSI_TASK_MGMT
:
738 Mpi2SCSITaskManagementRequest_t
*tm_request
=
739 (Mpi2SCSITaskManagementRequest_t
*)mpi_request
;
741 if (tm_request
->TaskType
==
742 MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK
) {
743 if (_ctl_do_task_abort(ioc
, &karg
, tm_request
)) {
744 mpt2sas_base_free_smid(ioc
, smid
);
749 mutex_lock(&ioc
->tm_cmds
.mutex
);
750 mpt2sas_scsih_set_tm_flag(ioc
, le16_to_cpu(
751 tm_request
->DevHandle
));
752 mpt2sas_base_put_smid_hi_priority(ioc
, smid
,
756 case MPI2_FUNCTION_SMP_PASSTHROUGH
:
758 Mpi2SmpPassthroughRequest_t
*smp_request
=
759 (Mpi2SmpPassthroughRequest_t
*)mpi_request
;
762 /* ioc determines which port to use */
763 smp_request
->PhysicalPort
= 0xFF;
764 if (smp_request
->PassthroughFlags
&
765 MPI2_SMP_PT_REQ_PT_FLAGS_IMMEDIATE
)
766 data
= (u8
*)&smp_request
->SGL
;
770 if (data
[1] == 0x91 && (data
[10] == 1 || data
[10] == 2)) {
771 ioc
->ioc_link_reset_in_progress
= 1;
772 ioc
->ignore_loginfos
= 1;
774 mpt2sas_base_put_smid_default(ioc
, smid
, mpi_request
->VF_ID
);
777 case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL
:
779 Mpi2SasIoUnitControlRequest_t
*sasiounit_request
=
780 (Mpi2SasIoUnitControlRequest_t
*)mpi_request
;
782 if (sasiounit_request
->Operation
== MPI2_SAS_OP_PHY_HARD_RESET
783 || sasiounit_request
->Operation
==
784 MPI2_SAS_OP_PHY_LINK_RESET
) {
785 ioc
->ioc_link_reset_in_progress
= 1;
786 ioc
->ignore_loginfos
= 1;
788 mpt2sas_base_put_smid_default(ioc
, smid
, mpi_request
->VF_ID
);
792 mpt2sas_base_put_smid_default(ioc
, smid
, mpi_request
->VF_ID
);
796 if (karg
.timeout
< MPT2_IOCTL_DEFAULT_TIMEOUT
)
797 timeout
= MPT2_IOCTL_DEFAULT_TIMEOUT
;
799 timeout
= karg
.timeout
;
800 timeleft
= wait_for_completion_timeout(&ioc
->ctl_cmds
.done
,
802 if (mpi_request
->Function
== MPI2_FUNCTION_SCSI_TASK_MGMT
) {
803 Mpi2SCSITaskManagementRequest_t
*tm_request
=
804 (Mpi2SCSITaskManagementRequest_t
*)mpi_request
;
805 mutex_unlock(&ioc
->tm_cmds
.mutex
);
806 mpt2sas_scsih_clear_tm_flag(ioc
, le16_to_cpu(
807 tm_request
->DevHandle
));
808 } else if ((mpi_request
->Function
== MPI2_FUNCTION_SMP_PASSTHROUGH
||
809 mpi_request
->Function
== MPI2_FUNCTION_SAS_IO_UNIT_CONTROL
) &&
810 ioc
->ioc_link_reset_in_progress
) {
811 ioc
->ioc_link_reset_in_progress
= 0;
812 ioc
->ignore_loginfos
= 0;
814 if (!(ioc
->ctl_cmds
.status
& MPT2_CMD_COMPLETE
)) {
815 printk(MPT2SAS_ERR_FMT
"%s: timeout\n", ioc
->name
,
817 _debug_dump_mf(mpi_request
, karg
.data_sge_offset
);
818 if (!(ioc
->ctl_cmds
.status
& MPT2_CMD_RESET
))
820 goto issue_host_reset
;
823 mpi_reply
= ioc
->ctl_cmds
.reply
;
824 ioc_status
= le16_to_cpu(mpi_reply
->IOCStatus
) & MPI2_IOCSTATUS_MASK
;
826 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
827 if (mpi_reply
->Function
== MPI2_FUNCTION_SCSI_TASK_MGMT
&&
828 (ioc
->logging_level
& MPT_DEBUG_TM
)) {
829 Mpi2SCSITaskManagementReply_t
*tm_reply
=
830 (Mpi2SCSITaskManagementReply_t
*)mpi_reply
;
832 printk(MPT2SAS_DEBUG_FMT
"TASK_MGMT: "
833 "IOCStatus(0x%04x), IOCLogInfo(0x%08x), "
834 "TerminationCount(0x%08x)\n", ioc
->name
,
835 tm_reply
->IOCStatus
, tm_reply
->IOCLogInfo
,
836 tm_reply
->TerminationCount
);
839 /* copy out xdata to user */
841 if (copy_to_user(karg
.data_in_buf_ptr
, data_in
,
843 printk(KERN_ERR
"failure at %s:%d/%s()!\n", __FILE__
,
850 /* copy out reply message frame to user */
851 if (karg
.max_reply_bytes
) {
852 sz
= min_t(u32
, karg
.max_reply_bytes
, ioc
->reply_sz
);
853 if (copy_to_user(karg
.reply_frame_buf_ptr
, ioc
->ctl_cmds
.reply
,
855 printk(KERN_ERR
"failure at %s:%d/%s()!\n", __FILE__
,
862 /* copy out sense to user */
863 if (karg
.max_sense_bytes
&& (mpi_request
->Function
==
864 MPI2_FUNCTION_SCSI_IO_REQUEST
|| mpi_request
->Function
==
865 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
)) {
866 sz
= min_t(u32
, karg
.max_sense_bytes
, SCSI_SENSE_BUFFERSIZE
);
867 if (copy_to_user(karg
.sense_data_ptr
, priv_sense
, sz
)) {
868 printk(KERN_ERR
"failure at %s:%d/%s()!\n", __FILE__
,
877 if ((mpi_request
->Function
== MPI2_FUNCTION_SCSI_IO_REQUEST
||
878 mpi_request
->Function
==
879 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH
)) {
880 printk(MPT2SAS_INFO_FMT
"issue target reset: handle "
881 "= (0x%04x)\n", ioc
->name
,
882 mpi_request
->FunctionDependent1
);
883 mutex_lock(&ioc
->tm_cmds
.mutex
);
884 mpt2sas_scsih_issue_tm(ioc
,
885 mpi_request
->FunctionDependent1
, 0,
886 MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET
, 0, 10);
887 ioc
->tm_cmds
.status
= MPT2_CMD_NOT_USED
;
888 mutex_unlock(&ioc
->tm_cmds
.mutex
);
890 mpt2sas_base_hard_reset_handler(ioc
, CAN_SLEEP
,
896 /* free memory associated with sg buffers */
898 pci_free_consistent(ioc
->pdev
, data_in_sz
, data_in
,
902 pci_free_consistent(ioc
->pdev
, data_out_sz
, data_out
,
905 ioc
->ctl_cmds
.status
= MPT2_CMD_NOT_USED
;
906 mutex_unlock(&ioc
->ctl_cmds
.mutex
);
911 * _ctl_getiocinfo - main handler for MPT2IOCINFO opcode
912 * @arg - user space buffer containing ioctl content
915 _ctl_getiocinfo(void __user
*arg
)
917 struct mpt2_ioctl_iocinfo karg
;
918 struct MPT2SAS_ADAPTER
*ioc
;
921 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
922 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
923 __FILE__
, __LINE__
, __func__
);
926 if (_ctl_verify_adapter(karg
.hdr
.ioc_number
, &ioc
) == -1 || !ioc
)
929 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s: enter\n", ioc
->name
,
932 memset(&karg
, 0 , sizeof(karg
));
933 karg
.adapter_type
= MPT2_IOCTL_INTERFACE_SAS2
;
935 karg
.port_number
= ioc
->pfacts
[0].PortNumber
;
936 pci_read_config_byte(ioc
->pdev
, PCI_CLASS_REVISION
, &revision
);
937 karg
.hw_rev
= revision
;
938 karg
.pci_id
= ioc
->pdev
->device
;
939 karg
.subsystem_device
= ioc
->pdev
->subsystem_device
;
940 karg
.subsystem_vendor
= ioc
->pdev
->subsystem_vendor
;
941 karg
.pci_information
.u
.bits
.bus
= ioc
->pdev
->bus
->number
;
942 karg
.pci_information
.u
.bits
.device
= PCI_SLOT(ioc
->pdev
->devfn
);
943 karg
.pci_information
.u
.bits
.function
= PCI_FUNC(ioc
->pdev
->devfn
);
944 karg
.pci_information
.segment_id
= pci_domain_nr(ioc
->pdev
->bus
);
945 karg
.firmware_version
= ioc
->facts
.FWVersion
.Word
;
946 strcpy(karg
.driver_version
, MPT2SAS_DRIVER_NAME
);
947 strcat(karg
.driver_version
, "-");
948 strcat(karg
.driver_version
, MPT2SAS_DRIVER_VERSION
);
949 karg
.bios_version
= le32_to_cpu(ioc
->bios_pg3
.BiosVersion
);
951 if (copy_to_user(arg
, &karg
, sizeof(karg
))) {
952 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
953 __FILE__
, __LINE__
, __func__
);
960 * _ctl_eventquery - main handler for MPT2EVENTQUERY opcode
961 * @arg - user space buffer containing ioctl content
964 _ctl_eventquery(void __user
*arg
)
966 struct mpt2_ioctl_eventquery karg
;
967 struct MPT2SAS_ADAPTER
*ioc
;
969 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
970 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
971 __FILE__
, __LINE__
, __func__
);
974 if (_ctl_verify_adapter(karg
.hdr
.ioc_number
, &ioc
) == -1 || !ioc
)
977 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s: enter\n", ioc
->name
,
980 karg
.event_entries
= MPT2SAS_CTL_EVENT_LOG_SIZE
;
981 memcpy(karg
.event_types
, ioc
->event_type
,
982 MPI2_EVENT_NOTIFY_EVENTMASK_WORDS
* sizeof(u32
));
984 if (copy_to_user(arg
, &karg
, sizeof(karg
))) {
985 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
986 __FILE__
, __LINE__
, __func__
);
993 * _ctl_eventenable - main handler for MPT2EVENTENABLE opcode
994 * @arg - user space buffer containing ioctl content
997 _ctl_eventenable(void __user
*arg
)
999 struct mpt2_ioctl_eventenable karg
;
1000 struct MPT2SAS_ADAPTER
*ioc
;
1002 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1003 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
1004 __FILE__
, __LINE__
, __func__
);
1007 if (_ctl_verify_adapter(karg
.hdr
.ioc_number
, &ioc
) == -1 || !ioc
)
1010 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s: enter\n", ioc
->name
,
1015 memcpy(ioc
->event_type
, karg
.event_types
,
1016 MPI2_EVENT_NOTIFY_EVENTMASK_WORDS
* sizeof(u32
));
1017 mpt2sas_base_validate_event_type(ioc
, ioc
->event_type
);
1019 /* initialize event_log */
1020 ioc
->event_context
= 0;
1021 ioc
->aen_event_read_flag
= 0;
1022 ioc
->event_log
= kcalloc(MPT2SAS_CTL_EVENT_LOG_SIZE
,
1023 sizeof(struct MPT2_IOCTL_EVENTS
), GFP_KERNEL
);
1024 if (!ioc
->event_log
) {
1025 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
1026 __FILE__
, __LINE__
, __func__
);
1033 * _ctl_eventreport - main handler for MPT2EVENTREPORT opcode
1034 * @arg - user space buffer containing ioctl content
1037 _ctl_eventreport(void __user
*arg
)
1039 struct mpt2_ioctl_eventreport karg
;
1040 struct MPT2SAS_ADAPTER
*ioc
;
1041 u32 number_bytes
, max_events
, max
;
1042 struct mpt2_ioctl_eventreport __user
*uarg
= arg
;
1044 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1045 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
1046 __FILE__
, __LINE__
, __func__
);
1049 if (_ctl_verify_adapter(karg
.hdr
.ioc_number
, &ioc
) == -1 || !ioc
)
1052 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s: enter\n", ioc
->name
,
1055 number_bytes
= karg
.hdr
.max_data_size
-
1056 sizeof(struct mpt2_ioctl_header
);
1057 max_events
= number_bytes
/sizeof(struct MPT2_IOCTL_EVENTS
);
1058 max
= min_t(u32
, MPT2SAS_CTL_EVENT_LOG_SIZE
, max_events
);
1060 /* If fewer than 1 event is requested, there must have
1061 * been some type of error.
1063 if (!max
|| !ioc
->event_log
)
1066 number_bytes
= max
* sizeof(struct MPT2_IOCTL_EVENTS
);
1067 if (copy_to_user(uarg
->event_data
, ioc
->event_log
, number_bytes
)) {
1068 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
1069 __FILE__
, __LINE__
, __func__
);
1073 /* reset flag so SIGIO can restart */
1074 ioc
->aen_event_read_flag
= 0;
1079 * _ctl_do_reset - main handler for MPT2HARDRESET opcode
1080 * @arg - user space buffer containing ioctl content
1083 _ctl_do_reset(void __user
*arg
)
1085 struct mpt2_ioctl_diag_reset karg
;
1086 struct MPT2SAS_ADAPTER
*ioc
;
1089 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1090 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
1091 __FILE__
, __LINE__
, __func__
);
1094 if (_ctl_verify_adapter(karg
.hdr
.ioc_number
, &ioc
) == -1 || !ioc
)
1097 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s: enter\n", ioc
->name
,
1100 retval
= mpt2sas_base_hard_reset_handler(ioc
, CAN_SLEEP
,
1102 printk(MPT2SAS_INFO_FMT
"host reset: %s\n",
1103 ioc
->name
, ((!retval
) ? "SUCCESS" : "FAILED"));
1108 * _ctl_btdh_search_sas_device - searching for sas device
1109 * @ioc: per adapter object
1110 * @btdh: btdh ioctl payload
1113 _ctl_btdh_search_sas_device(struct MPT2SAS_ADAPTER
*ioc
,
1114 struct mpt2_ioctl_btdh_mapping
*btdh
)
1116 struct _sas_device
*sas_device
;
1117 unsigned long flags
;
1120 if (list_empty(&ioc
->sas_device_list
))
1123 spin_lock_irqsave(&ioc
->sas_device_lock
, flags
);
1124 list_for_each_entry(sas_device
, &ioc
->sas_device_list
, list
) {
1125 if (btdh
->bus
== 0xFFFFFFFF && btdh
->id
== 0xFFFFFFFF &&
1126 btdh
->handle
== sas_device
->handle
) {
1127 btdh
->bus
= sas_device
->channel
;
1128 btdh
->id
= sas_device
->id
;
1131 } else if (btdh
->bus
== sas_device
->channel
&& btdh
->id
==
1132 sas_device
->id
&& btdh
->handle
== 0xFFFF) {
1133 btdh
->handle
= sas_device
->handle
;
1139 spin_unlock_irqrestore(&ioc
->sas_device_lock
, flags
);
1144 * _ctl_btdh_search_raid_device - searching for raid device
1145 * @ioc: per adapter object
1146 * @btdh: btdh ioctl payload
1149 _ctl_btdh_search_raid_device(struct MPT2SAS_ADAPTER
*ioc
,
1150 struct mpt2_ioctl_btdh_mapping
*btdh
)
1152 struct _raid_device
*raid_device
;
1153 unsigned long flags
;
1156 if (list_empty(&ioc
->raid_device_list
))
1159 spin_lock_irqsave(&ioc
->raid_device_lock
, flags
);
1160 list_for_each_entry(raid_device
, &ioc
->raid_device_list
, list
) {
1161 if (btdh
->bus
== 0xFFFFFFFF && btdh
->id
== 0xFFFFFFFF &&
1162 btdh
->handle
== raid_device
->handle
) {
1163 btdh
->bus
= raid_device
->channel
;
1164 btdh
->id
= raid_device
->id
;
1167 } else if (btdh
->bus
== raid_device
->channel
&& btdh
->id
==
1168 raid_device
->id
&& btdh
->handle
== 0xFFFF) {
1169 btdh
->handle
= raid_device
->handle
;
1175 spin_unlock_irqrestore(&ioc
->raid_device_lock
, flags
);
1180 * _ctl_btdh_mapping - main handler for MPT2BTDHMAPPING opcode
1181 * @arg - user space buffer containing ioctl content
1184 _ctl_btdh_mapping(void __user
*arg
)
1186 struct mpt2_ioctl_btdh_mapping karg
;
1187 struct MPT2SAS_ADAPTER
*ioc
;
1190 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1191 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
1192 __FILE__
, __LINE__
, __func__
);
1195 if (_ctl_verify_adapter(karg
.hdr
.ioc_number
, &ioc
) == -1 || !ioc
)
1198 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s\n", ioc
->name
,
1201 rc
= _ctl_btdh_search_sas_device(ioc
, &karg
);
1203 _ctl_btdh_search_raid_device(ioc
, &karg
);
1205 if (copy_to_user(arg
, &karg
, sizeof(karg
))) {
1206 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
1207 __FILE__
, __LINE__
, __func__
);
1214 * _ctl_diag_capability - return diag buffer capability
1215 * @ioc: per adapter object
1216 * @buffer_type: specifies either TRACE or SNAPSHOT
1218 * returns 1 when diag buffer support is enabled in firmware
1221 _ctl_diag_capability(struct MPT2SAS_ADAPTER
*ioc
, u8 buffer_type
)
1225 switch (buffer_type
) {
1226 case MPI2_DIAG_BUF_TYPE_TRACE
:
1227 if (ioc
->facts
.IOCCapabilities
&
1228 MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER
)
1231 case MPI2_DIAG_BUF_TYPE_SNAPSHOT
:
1232 if (ioc
->facts
.IOCCapabilities
&
1233 MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER
)
1242 * _ctl_diag_register - application register with driver
1243 * @arg - user space buffer containing ioctl content
1244 * @state - NON_BLOCKING or BLOCKING
1246 * This will allow the driver to setup any required buffers that will be
1247 * needed by firmware to communicate with the driver.
1250 _ctl_diag_register(void __user
*arg
, enum block_state state
)
1252 struct mpt2_diag_register karg
;
1253 struct MPT2SAS_ADAPTER
*ioc
;
1255 void *request_data
= NULL
;
1256 dma_addr_t request_data_dma
;
1257 u32 request_data_sz
= 0;
1258 Mpi2DiagBufferPostRequest_t
*mpi_request
;
1259 Mpi2DiagBufferPostReply_t
*mpi_reply
;
1261 unsigned long timeleft
;
1266 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1267 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
1268 __FILE__
, __LINE__
, __func__
);
1271 if (_ctl_verify_adapter(karg
.hdr
.ioc_number
, &ioc
) == -1 || !ioc
)
1274 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s\n", ioc
->name
,
1277 buffer_type
= karg
.buffer_type
;
1278 if (!_ctl_diag_capability(ioc
, buffer_type
)) {
1279 printk(MPT2SAS_ERR_FMT
"%s: doesn't have capability for "
1280 "buffer_type(0x%02x)\n", ioc
->name
, __func__
, buffer_type
);
1284 if (ioc
->diag_buffer_status
[buffer_type
] &
1285 MPT2_DIAG_BUFFER_IS_REGISTERED
) {
1286 printk(MPT2SAS_ERR_FMT
"%s: already has a registered "
1287 "buffer for buffer_type(0x%02x)\n", ioc
->name
, __func__
,
1292 if (karg
.requested_buffer_size
% 4) {
1293 printk(MPT2SAS_ERR_FMT
"%s: the requested_buffer_size "
1294 "is not 4 byte aligned\n", ioc
->name
, __func__
);
1298 if (state
== NON_BLOCKING
&& !mutex_trylock(&ioc
->ctl_cmds
.mutex
))
1300 else if (mutex_lock_interruptible(&ioc
->ctl_cmds
.mutex
))
1301 return -ERESTARTSYS
;
1303 if (ioc
->ctl_cmds
.status
!= MPT2_CMD_NOT_USED
) {
1304 printk(MPT2SAS_ERR_FMT
"%s: ctl_cmd in use\n",
1305 ioc
->name
, __func__
);
1310 smid
= mpt2sas_base_get_smid(ioc
, ioc
->ctl_cb_idx
);
1312 printk(MPT2SAS_ERR_FMT
"%s: failed obtaining a smid\n",
1313 ioc
->name
, __func__
);
1319 ioc
->ctl_cmds
.status
= MPT2_CMD_PENDING
;
1320 memset(ioc
->ctl_cmds
.reply
, 0, ioc
->reply_sz
);
1321 mpi_request
= mpt2sas_base_get_msg_frame(ioc
, smid
);
1322 ioc
->ctl_cmds
.smid
= smid
;
1324 request_data
= ioc
->diag_buffer
[buffer_type
];
1325 request_data_sz
= karg
.requested_buffer_size
;
1326 ioc
->unique_id
[buffer_type
] = karg
.unique_id
;
1327 ioc
->diag_buffer_status
[buffer_type
] = 0;
1328 memcpy(ioc
->product_specific
[buffer_type
], karg
.product_specific
,
1329 MPT2_PRODUCT_SPECIFIC_DWORDS
);
1330 ioc
->diagnostic_flags
[buffer_type
] = karg
.diagnostic_flags
;
1333 request_data_dma
= ioc
->diag_buffer_dma
[buffer_type
];
1334 if (request_data_sz
!= ioc
->diag_buffer_sz
[buffer_type
]) {
1335 pci_free_consistent(ioc
->pdev
,
1336 ioc
->diag_buffer_sz
[buffer_type
],
1337 request_data
, request_data_dma
);
1338 request_data
= NULL
;
1342 if (request_data
== NULL
) {
1343 ioc
->diag_buffer_sz
[buffer_type
] = 0;
1344 ioc
->diag_buffer_dma
[buffer_type
] = 0;
1345 request_data
= pci_alloc_consistent(
1346 ioc
->pdev
, request_data_sz
, &request_data_dma
);
1347 if (request_data
== NULL
) {
1348 printk(MPT2SAS_ERR_FMT
"%s: failed allocating memory"
1349 " for diag buffers, requested size(%d)\n",
1350 ioc
->name
, __func__
, request_data_sz
);
1351 mpt2sas_base_free_smid(ioc
, smid
);
1354 ioc
->diag_buffer
[buffer_type
] = request_data
;
1355 ioc
->diag_buffer_sz
[buffer_type
] = request_data_sz
;
1356 ioc
->diag_buffer_dma
[buffer_type
] = request_data_dma
;
1359 mpi_request
->Function
= MPI2_FUNCTION_DIAG_BUFFER_POST
;
1360 mpi_request
->BufferType
= karg
.buffer_type
;
1361 mpi_request
->Flags
= cpu_to_le32(karg
.diagnostic_flags
);
1362 mpi_request
->BufferAddress
= cpu_to_le64(request_data_dma
);
1363 mpi_request
->BufferLength
= cpu_to_le32(request_data_sz
);
1365 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s: diag_buffer(0x%p), "
1366 "dma(0x%llx), sz(%d)\n", ioc
->name
, __func__
, request_data
,
1367 (unsigned long long)request_data_dma
, mpi_request
->BufferLength
));
1369 for (i
= 0; i
< MPT2_PRODUCT_SPECIFIC_DWORDS
; i
++)
1370 mpi_request
->ProductSpecific
[i
] =
1371 cpu_to_le32(ioc
->product_specific
[buffer_type
][i
]);
1373 mpt2sas_base_put_smid_default(ioc
, smid
, mpi_request
->VF_ID
);
1374 timeleft
= wait_for_completion_timeout(&ioc
->ctl_cmds
.done
,
1375 MPT2_IOCTL_DEFAULT_TIMEOUT
*HZ
);
1377 if (!(ioc
->ctl_cmds
.status
& MPT2_CMD_COMPLETE
)) {
1378 printk(MPT2SAS_ERR_FMT
"%s: timeout\n", ioc
->name
,
1380 _debug_dump_mf(mpi_request
,
1381 sizeof(Mpi2DiagBufferPostRequest_t
)/4);
1382 if (!(ioc
->ctl_cmds
.status
& MPT2_CMD_RESET
))
1384 goto issue_host_reset
;
1387 /* process the completed Reply Message Frame */
1388 if ((ioc
->ctl_cmds
.status
& MPT2_CMD_REPLY_VALID
) == 0) {
1389 printk(MPT2SAS_ERR_FMT
"%s: no reply message\n",
1390 ioc
->name
, __func__
);
1395 mpi_reply
= ioc
->ctl_cmds
.reply
;
1396 ioc_status
= le16_to_cpu(mpi_reply
->IOCStatus
) & MPI2_IOCSTATUS_MASK
;
1398 if (ioc_status
== MPI2_IOCSTATUS_SUCCESS
) {
1399 ioc
->diag_buffer_status
[buffer_type
] |=
1400 MPT2_DIAG_BUFFER_IS_REGISTERED
;
1401 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s: success\n",
1402 ioc
->name
, __func__
));
1404 printk(MPT2SAS_DEBUG_FMT
"%s: ioc_status(0x%04x) "
1405 "log_info(0x%08x)\n", ioc
->name
, __func__
,
1406 ioc_status
, mpi_reply
->IOCLogInfo
);
1412 mpt2sas_base_hard_reset_handler(ioc
, CAN_SLEEP
,
1417 if (rc
&& request_data
)
1418 pci_free_consistent(ioc
->pdev
, request_data_sz
,
1419 request_data
, request_data_dma
);
1421 ioc
->ctl_cmds
.status
= MPT2_CMD_NOT_USED
;
1422 mutex_unlock(&ioc
->ctl_cmds
.mutex
);
1427 * _ctl_diag_unregister - application unregister with driver
1428 * @arg - user space buffer containing ioctl content
1430 * This will allow the driver to cleanup any memory allocated for diag
1431 * messages and to free up any resources.
1434 _ctl_diag_unregister(void __user
*arg
)
1436 struct mpt2_diag_unregister karg
;
1437 struct MPT2SAS_ADAPTER
*ioc
;
1439 dma_addr_t request_data_dma
;
1440 u32 request_data_sz
;
1443 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1444 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
1445 __FILE__
, __LINE__
, __func__
);
1448 if (_ctl_verify_adapter(karg
.hdr
.ioc_number
, &ioc
) == -1 || !ioc
)
1451 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s\n", ioc
->name
,
1454 buffer_type
= karg
.unique_id
& 0x000000ff;
1455 if (!_ctl_diag_capability(ioc
, buffer_type
)) {
1456 printk(MPT2SAS_ERR_FMT
"%s: doesn't have capability for "
1457 "buffer_type(0x%02x)\n", ioc
->name
, __func__
, buffer_type
);
1461 if ((ioc
->diag_buffer_status
[buffer_type
] &
1462 MPT2_DIAG_BUFFER_IS_REGISTERED
) == 0) {
1463 printk(MPT2SAS_ERR_FMT
"%s: buffer_type(0x%02x) is not "
1464 "registered\n", ioc
->name
, __func__
, buffer_type
);
1467 if ((ioc
->diag_buffer_status
[buffer_type
] &
1468 MPT2_DIAG_BUFFER_IS_RELEASED
) == 0) {
1469 printk(MPT2SAS_ERR_FMT
"%s: buffer_type(0x%02x) has not been "
1470 "released\n", ioc
->name
, __func__
, buffer_type
);
1474 if (karg
.unique_id
!= ioc
->unique_id
[buffer_type
]) {
1475 printk(MPT2SAS_ERR_FMT
"%s: unique_id(0x%08x) is not "
1476 "registered\n", ioc
->name
, __func__
, karg
.unique_id
);
1480 request_data
= ioc
->diag_buffer
[buffer_type
];
1481 if (!request_data
) {
1482 printk(MPT2SAS_ERR_FMT
"%s: doesn't have memory allocated for "
1483 "buffer_type(0x%02x)\n", ioc
->name
, __func__
, buffer_type
);
1487 request_data_sz
= ioc
->diag_buffer_sz
[buffer_type
];
1488 request_data_dma
= ioc
->diag_buffer_dma
[buffer_type
];
1489 pci_free_consistent(ioc
->pdev
, request_data_sz
,
1490 request_data
, request_data_dma
);
1491 ioc
->diag_buffer
[buffer_type
] = NULL
;
1492 ioc
->diag_buffer_status
[buffer_type
] = 0;
1497 * _ctl_diag_query - query relevant info associated with diag buffers
1498 * @arg - user space buffer containing ioctl content
1500 * The application will send only buffer_type and unique_id. Driver will
1501 * inspect unique_id first, if valid, fill in all the info. If unique_id is
1502 * 0x00, the driver will return info specified by Buffer Type.
1505 _ctl_diag_query(void __user
*arg
)
1507 struct mpt2_diag_query karg
;
1508 struct MPT2SAS_ADAPTER
*ioc
;
1513 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1514 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
1515 __FILE__
, __LINE__
, __func__
);
1518 if (_ctl_verify_adapter(karg
.hdr
.ioc_number
, &ioc
) == -1 || !ioc
)
1521 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s\n", ioc
->name
,
1524 karg
.application_flags
= 0;
1525 buffer_type
= karg
.buffer_type
;
1527 if (!_ctl_diag_capability(ioc
, buffer_type
)) {
1528 printk(MPT2SAS_ERR_FMT
"%s: doesn't have capability for "
1529 "buffer_type(0x%02x)\n", ioc
->name
, __func__
, buffer_type
);
1533 if ((ioc
->diag_buffer_status
[buffer_type
] &
1534 MPT2_DIAG_BUFFER_IS_REGISTERED
) == 0) {
1535 printk(MPT2SAS_ERR_FMT
"%s: buffer_type(0x%02x) is not "
1536 "registered\n", ioc
->name
, __func__
, buffer_type
);
1540 if (karg
.unique_id
& 0xffffff00) {
1541 if (karg
.unique_id
!= ioc
->unique_id
[buffer_type
]) {
1542 printk(MPT2SAS_ERR_FMT
"%s: unique_id(0x%08x) is not "
1543 "registered\n", ioc
->name
, __func__
,
1549 request_data
= ioc
->diag_buffer
[buffer_type
];
1550 if (!request_data
) {
1551 printk(MPT2SAS_ERR_FMT
"%s: doesn't have buffer for "
1552 "buffer_type(0x%02x)\n", ioc
->name
, __func__
, buffer_type
);
1556 if (ioc
->diag_buffer_status
[buffer_type
] & MPT2_DIAG_BUFFER_IS_RELEASED
)
1557 karg
.application_flags
= (MPT2_APP_FLAGS_APP_OWNED
|
1558 MPT2_APP_FLAGS_BUFFER_VALID
);
1560 karg
.application_flags
= (MPT2_APP_FLAGS_APP_OWNED
|
1561 MPT2_APP_FLAGS_BUFFER_VALID
|
1562 MPT2_APP_FLAGS_FW_BUFFER_ACCESS
);
1564 for (i
= 0; i
< MPT2_PRODUCT_SPECIFIC_DWORDS
; i
++)
1565 karg
.product_specific
[i
] =
1566 ioc
->product_specific
[buffer_type
][i
];
1568 karg
.total_buffer_size
= ioc
->diag_buffer_sz
[buffer_type
];
1569 karg
.driver_added_buffer_size
= 0;
1570 karg
.unique_id
= ioc
->unique_id
[buffer_type
];
1571 karg
.diagnostic_flags
= ioc
->diagnostic_flags
[buffer_type
];
1573 if (copy_to_user(arg
, &karg
, sizeof(struct mpt2_diag_query
))) {
1574 printk(MPT2SAS_ERR_FMT
"%s: unable to write mpt2_diag_query "
1575 "data @ %p\n", ioc
->name
, __func__
, arg
);
1582 * _ctl_send_release - Diag Release Message
1583 * @ioc: per adapter object
1584 * @buffer_type - specifies either TRACE or SNAPSHOT
1585 * @issue_reset - specifies whether host reset is required.
1589 _ctl_send_release(struct MPT2SAS_ADAPTER
*ioc
, u8 buffer_type
, u8
*issue_reset
)
1591 Mpi2DiagReleaseRequest_t
*mpi_request
;
1592 Mpi2DiagReleaseReply_t
*mpi_reply
;
1597 unsigned long timeleft
;
1599 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s\n", ioc
->name
,
1605 ioc_state
= mpt2sas_base_get_iocstate(ioc
, 1);
1606 if (ioc_state
!= MPI2_IOC_STATE_OPERATIONAL
) {
1607 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s: "
1608 "skipping due to FAULT state\n", ioc
->name
,
1614 if (ioc
->ctl_cmds
.status
!= MPT2_CMD_NOT_USED
) {
1615 printk(MPT2SAS_ERR_FMT
"%s: ctl_cmd in use\n",
1616 ioc
->name
, __func__
);
1621 smid
= mpt2sas_base_get_smid(ioc
, ioc
->ctl_cb_idx
);
1623 printk(MPT2SAS_ERR_FMT
"%s: failed obtaining a smid\n",
1624 ioc
->name
, __func__
);
1629 ioc
->ctl_cmds
.status
= MPT2_CMD_PENDING
;
1630 memset(ioc
->ctl_cmds
.reply
, 0, ioc
->reply_sz
);
1631 mpi_request
= mpt2sas_base_get_msg_frame(ioc
, smid
);
1632 ioc
->ctl_cmds
.smid
= smid
;
1634 mpi_request
->Function
= MPI2_FUNCTION_DIAG_RELEASE
;
1635 mpi_request
->BufferType
= buffer_type
;
1637 mpt2sas_base_put_smid_default(ioc
, smid
, mpi_request
->VF_ID
);
1638 timeleft
= wait_for_completion_timeout(&ioc
->ctl_cmds
.done
,
1639 MPT2_IOCTL_DEFAULT_TIMEOUT
*HZ
);
1641 if (!(ioc
->ctl_cmds
.status
& MPT2_CMD_COMPLETE
)) {
1642 printk(MPT2SAS_ERR_FMT
"%s: timeout\n", ioc
->name
,
1644 _debug_dump_mf(mpi_request
,
1645 sizeof(Mpi2DiagReleaseRequest_t
)/4);
1646 if (!(ioc
->ctl_cmds
.status
& MPT2_CMD_RESET
))
1652 /* process the completed Reply Message Frame */
1653 if ((ioc
->ctl_cmds
.status
& MPT2_CMD_REPLY_VALID
) == 0) {
1654 printk(MPT2SAS_ERR_FMT
"%s: no reply message\n",
1655 ioc
->name
, __func__
);
1660 mpi_reply
= ioc
->ctl_cmds
.reply
;
1661 ioc_status
= le16_to_cpu(mpi_reply
->IOCStatus
) & MPI2_IOCSTATUS_MASK
;
1663 if (ioc_status
== MPI2_IOCSTATUS_SUCCESS
) {
1664 ioc
->diag_buffer_status
[buffer_type
] |=
1665 MPT2_DIAG_BUFFER_IS_RELEASED
;
1666 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s: success\n",
1667 ioc
->name
, __func__
));
1669 printk(MPT2SAS_DEBUG_FMT
"%s: ioc_status(0x%04x) "
1670 "log_info(0x%08x)\n", ioc
->name
, __func__
,
1671 ioc_status
, mpi_reply
->IOCLogInfo
);
1676 ioc
->ctl_cmds
.status
= MPT2_CMD_NOT_USED
;
1681 * _ctl_diag_release - request to send Diag Release Message to firmware
1682 * @arg - user space buffer containing ioctl content
1683 * @state - NON_BLOCKING or BLOCKING
1685 * This allows ownership of the specified buffer to returned to the driver,
1686 * allowing an application to read the buffer without fear that firmware is
1687 * overwritting information in the buffer.
1690 _ctl_diag_release(void __user
*arg
, enum block_state state
)
1692 struct mpt2_diag_release karg
;
1693 struct MPT2SAS_ADAPTER
*ioc
;
1699 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1700 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
1701 __FILE__
, __LINE__
, __func__
);
1704 if (_ctl_verify_adapter(karg
.hdr
.ioc_number
, &ioc
) == -1 || !ioc
)
1707 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s\n", ioc
->name
,
1710 buffer_type
= karg
.unique_id
& 0x000000ff;
1711 if (!_ctl_diag_capability(ioc
, buffer_type
)) {
1712 printk(MPT2SAS_ERR_FMT
"%s: doesn't have capability for "
1713 "buffer_type(0x%02x)\n", ioc
->name
, __func__
, buffer_type
);
1717 if ((ioc
->diag_buffer_status
[buffer_type
] &
1718 MPT2_DIAG_BUFFER_IS_REGISTERED
) == 0) {
1719 printk(MPT2SAS_ERR_FMT
"%s: buffer_type(0x%02x) is not "
1720 "registered\n", ioc
->name
, __func__
, buffer_type
);
1724 if (karg
.unique_id
!= ioc
->unique_id
[buffer_type
]) {
1725 printk(MPT2SAS_ERR_FMT
"%s: unique_id(0x%08x) is not "
1726 "registered\n", ioc
->name
, __func__
, karg
.unique_id
);
1730 if (ioc
->diag_buffer_status
[buffer_type
] &
1731 MPT2_DIAG_BUFFER_IS_RELEASED
) {
1732 printk(MPT2SAS_ERR_FMT
"%s: buffer_type(0x%02x) "
1733 "is already released\n", ioc
->name
, __func__
,
1738 request_data
= ioc
->diag_buffer
[buffer_type
];
1740 if (!request_data
) {
1741 printk(MPT2SAS_ERR_FMT
"%s: doesn't have memory allocated for "
1742 "buffer_type(0x%02x)\n", ioc
->name
, __func__
, buffer_type
);
1746 /* buffers were released by due to host reset */
1747 if ((ioc
->diag_buffer_status
[buffer_type
] &
1748 MPT2_DIAG_BUFFER_IS_DIAG_RESET
)) {
1749 ioc
->diag_buffer_status
[buffer_type
] |=
1750 MPT2_DIAG_BUFFER_IS_RELEASED
;
1751 ioc
->diag_buffer_status
[buffer_type
] &=
1752 ~MPT2_DIAG_BUFFER_IS_DIAG_RESET
;
1753 printk(MPT2SAS_ERR_FMT
"%s: buffer_type(0x%02x) "
1754 "was released due to host reset\n", ioc
->name
, __func__
,
1759 if (state
== NON_BLOCKING
&& !mutex_trylock(&ioc
->ctl_cmds
.mutex
))
1761 else if (mutex_lock_interruptible(&ioc
->ctl_cmds
.mutex
))
1762 return -ERESTARTSYS
;
1764 rc
= _ctl_send_release(ioc
, buffer_type
, &issue_reset
);
1767 mpt2sas_base_hard_reset_handler(ioc
, CAN_SLEEP
,
1770 mutex_unlock(&ioc
->ctl_cmds
.mutex
);
1775 * _ctl_diag_read_buffer - request for copy of the diag buffer
1776 * @arg - user space buffer containing ioctl content
1777 * @state - NON_BLOCKING or BLOCKING
1780 _ctl_diag_read_buffer(void __user
*arg
, enum block_state state
)
1782 struct mpt2_diag_read_buffer karg
;
1783 struct mpt2_diag_read_buffer __user
*uarg
= arg
;
1784 struct MPT2SAS_ADAPTER
*ioc
;
1785 void *request_data
, *diag_data
;
1786 Mpi2DiagBufferPostRequest_t
*mpi_request
;
1787 Mpi2DiagBufferPostReply_t
*mpi_reply
;
1790 unsigned long timeleft
;
1795 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1796 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
1797 __FILE__
, __LINE__
, __func__
);
1800 if (_ctl_verify_adapter(karg
.hdr
.ioc_number
, &ioc
) == -1 || !ioc
)
1803 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s\n", ioc
->name
,
1806 buffer_type
= karg
.unique_id
& 0x000000ff;
1807 if (!_ctl_diag_capability(ioc
, buffer_type
)) {
1808 printk(MPT2SAS_ERR_FMT
"%s: doesn't have capability for "
1809 "buffer_type(0x%02x)\n", ioc
->name
, __func__
, buffer_type
);
1813 if (karg
.unique_id
!= ioc
->unique_id
[buffer_type
]) {
1814 printk(MPT2SAS_ERR_FMT
"%s: unique_id(0x%08x) is not "
1815 "registered\n", ioc
->name
, __func__
, karg
.unique_id
);
1819 request_data
= ioc
->diag_buffer
[buffer_type
];
1820 if (!request_data
) {
1821 printk(MPT2SAS_ERR_FMT
"%s: doesn't have buffer for "
1822 "buffer_type(0x%02x)\n", ioc
->name
, __func__
, buffer_type
);
1826 if ((karg
.starting_offset
% 4) || (karg
.bytes_to_read
% 4)) {
1827 printk(MPT2SAS_ERR_FMT
"%s: either the starting_offset "
1828 "or bytes_to_read are not 4 byte aligned\n", ioc
->name
,
1833 diag_data
= (void *)(request_data
+ karg
.starting_offset
);
1834 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s: diag_buffer(%p), "
1835 "offset(%d), sz(%d)\n", ioc
->name
, __func__
,
1836 diag_data
, karg
.starting_offset
, karg
.bytes_to_read
));
1838 if (copy_to_user((void __user
*)uarg
->diagnostic_data
,
1839 diag_data
, karg
.bytes_to_read
)) {
1840 printk(MPT2SAS_ERR_FMT
"%s: Unable to write "
1841 "mpt_diag_read_buffer_t data @ %p\n", ioc
->name
,
1842 __func__
, diag_data
);
1846 if ((karg
.flags
& MPT2_FLAGS_REREGISTER
) == 0)
1849 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s: Reregister "
1850 "buffer_type(0x%02x)\n", ioc
->name
, __func__
, buffer_type
));
1851 if ((ioc
->diag_buffer_status
[buffer_type
] &
1852 MPT2_DIAG_BUFFER_IS_RELEASED
) == 0) {
1853 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s: "
1854 "buffer_type(0x%02x) is still registered\n", ioc
->name
,
1855 __func__
, buffer_type
));
1858 /* Get a free request frame and save the message context.
1860 if (state
== NON_BLOCKING
&& !mutex_trylock(&ioc
->ctl_cmds
.mutex
))
1862 else if (mutex_lock_interruptible(&ioc
->ctl_cmds
.mutex
))
1863 return -ERESTARTSYS
;
1865 if (ioc
->ctl_cmds
.status
!= MPT2_CMD_NOT_USED
) {
1866 printk(MPT2SAS_ERR_FMT
"%s: ctl_cmd in use\n",
1867 ioc
->name
, __func__
);
1872 smid
= mpt2sas_base_get_smid(ioc
, ioc
->ctl_cb_idx
);
1874 printk(MPT2SAS_ERR_FMT
"%s: failed obtaining a smid\n",
1875 ioc
->name
, __func__
);
1881 ioc
->ctl_cmds
.status
= MPT2_CMD_PENDING
;
1882 memset(ioc
->ctl_cmds
.reply
, 0, ioc
->reply_sz
);
1883 mpi_request
= mpt2sas_base_get_msg_frame(ioc
, smid
);
1884 ioc
->ctl_cmds
.smid
= smid
;
1886 mpi_request
->Function
= MPI2_FUNCTION_DIAG_BUFFER_POST
;
1887 mpi_request
->BufferType
= buffer_type
;
1888 mpi_request
->BufferLength
=
1889 cpu_to_le32(ioc
->diag_buffer_sz
[buffer_type
]);
1890 mpi_request
->BufferAddress
=
1891 cpu_to_le64(ioc
->diag_buffer_dma
[buffer_type
]);
1892 for (i
= 0; i
< MPT2_PRODUCT_SPECIFIC_DWORDS
; i
++)
1893 mpi_request
->ProductSpecific
[i
] =
1894 cpu_to_le32(ioc
->product_specific
[buffer_type
][i
]);
1896 mpt2sas_base_put_smid_default(ioc
, smid
, mpi_request
->VF_ID
);
1897 timeleft
= wait_for_completion_timeout(&ioc
->ctl_cmds
.done
,
1898 MPT2_IOCTL_DEFAULT_TIMEOUT
*HZ
);
1900 if (!(ioc
->ctl_cmds
.status
& MPT2_CMD_COMPLETE
)) {
1901 printk(MPT2SAS_ERR_FMT
"%s: timeout\n", ioc
->name
,
1903 _debug_dump_mf(mpi_request
,
1904 sizeof(Mpi2DiagBufferPostRequest_t
)/4);
1905 if (!(ioc
->ctl_cmds
.status
& MPT2_CMD_RESET
))
1907 goto issue_host_reset
;
1910 /* process the completed Reply Message Frame */
1911 if ((ioc
->ctl_cmds
.status
& MPT2_CMD_REPLY_VALID
) == 0) {
1912 printk(MPT2SAS_ERR_FMT
"%s: no reply message\n",
1913 ioc
->name
, __func__
);
1918 mpi_reply
= ioc
->ctl_cmds
.reply
;
1919 ioc_status
= le16_to_cpu(mpi_reply
->IOCStatus
) & MPI2_IOCSTATUS_MASK
;
1921 if (ioc_status
== MPI2_IOCSTATUS_SUCCESS
) {
1922 ioc
->diag_buffer_status
[buffer_type
] |=
1923 MPT2_DIAG_BUFFER_IS_REGISTERED
;
1924 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s: success\n",
1925 ioc
->name
, __func__
));
1927 printk(MPT2SAS_DEBUG_FMT
"%s: ioc_status(0x%04x) "
1928 "log_info(0x%08x)\n", ioc
->name
, __func__
,
1929 ioc_status
, mpi_reply
->IOCLogInfo
);
1935 mpt2sas_base_hard_reset_handler(ioc
, CAN_SLEEP
,
1940 ioc
->ctl_cmds
.status
= MPT2_CMD_NOT_USED
;
1941 mutex_unlock(&ioc
->ctl_cmds
.mutex
);
1946 * _ctl_ioctl_main - main ioctl entry point
1947 * @file - (struct file)
1948 * @cmd - ioctl opcode
1952 _ctl_ioctl_main(struct file
*file
, unsigned int cmd
, void __user
*arg
)
1954 enum block_state state
;
1956 unsigned long flags
;
1958 state
= (file
->f_flags
& O_NONBLOCK
) ? NON_BLOCKING
:
1963 if (_IOC_SIZE(cmd
) == sizeof(struct mpt2_ioctl_iocinfo
))
1964 ret
= _ctl_getiocinfo(arg
);
1968 struct mpt2_ioctl_command karg
;
1969 struct mpt2_ioctl_command __user
*uarg
;
1970 struct MPT2SAS_ADAPTER
*ioc
;
1972 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
1973 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
1974 __FILE__
, __LINE__
, __func__
);
1978 if (_ctl_verify_adapter(karg
.hdr
.ioc_number
, &ioc
) == -1 ||
1982 spin_lock_irqsave(&ioc
->ioc_reset_in_progress_lock
, flags
);
1983 if (ioc
->shost_recovery
) {
1984 spin_unlock_irqrestore(&ioc
->ioc_reset_in_progress_lock
,
1988 spin_unlock_irqrestore(&ioc
->ioc_reset_in_progress_lock
, flags
);
1990 if (_IOC_SIZE(cmd
) == sizeof(struct mpt2_ioctl_command
)) {
1992 ret
= _ctl_do_mpt_command(ioc
, karg
, &uarg
->mf
, state
);
1996 case MPT2EVENTQUERY
:
1997 if (_IOC_SIZE(cmd
) == sizeof(struct mpt2_ioctl_eventquery
))
1998 ret
= _ctl_eventquery(arg
);
2000 case MPT2EVENTENABLE
:
2001 if (_IOC_SIZE(cmd
) == sizeof(struct mpt2_ioctl_eventenable
))
2002 ret
= _ctl_eventenable(arg
);
2004 case MPT2EVENTREPORT
:
2005 ret
= _ctl_eventreport(arg
);
2008 if (_IOC_SIZE(cmd
) == sizeof(struct mpt2_ioctl_diag_reset
))
2009 ret
= _ctl_do_reset(arg
);
2011 case MPT2BTDHMAPPING
:
2012 if (_IOC_SIZE(cmd
) == sizeof(struct mpt2_ioctl_btdh_mapping
))
2013 ret
= _ctl_btdh_mapping(arg
);
2015 case MPT2DIAGREGISTER
:
2016 if (_IOC_SIZE(cmd
) == sizeof(struct mpt2_diag_register
))
2017 ret
= _ctl_diag_register(arg
, state
);
2019 case MPT2DIAGUNREGISTER
:
2020 if (_IOC_SIZE(cmd
) == sizeof(struct mpt2_diag_unregister
))
2021 ret
= _ctl_diag_unregister(arg
);
2024 if (_IOC_SIZE(cmd
) == sizeof(struct mpt2_diag_query
))
2025 ret
= _ctl_diag_query(arg
);
2027 case MPT2DIAGRELEASE
:
2028 if (_IOC_SIZE(cmd
) == sizeof(struct mpt2_diag_release
))
2029 ret
= _ctl_diag_release(arg
, state
);
2031 case MPT2DIAGREADBUFFER
:
2032 if (_IOC_SIZE(cmd
) == sizeof(struct mpt2_diag_read_buffer
))
2033 ret
= _ctl_diag_read_buffer(arg
, state
);
2037 struct mpt2_ioctl_command karg
;
2038 struct MPT2SAS_ADAPTER
*ioc
;
2040 if (copy_from_user(&karg
, arg
, sizeof(karg
))) {
2041 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
2042 __FILE__
, __LINE__
, __func__
);
2046 if (_ctl_verify_adapter(karg
.hdr
.ioc_number
, &ioc
) == -1 ||
2050 dctlprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
2051 "unsupported ioctl opcode(0x%08x)\n", ioc
->name
, cmd
));
2059 * _ctl_ioctl - main ioctl entry point (unlocked)
2060 * @file - (struct file)
2061 * @cmd - ioctl opcode
2065 _ctl_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
2069 ret
= _ctl_ioctl_main(file
, cmd
, (void __user
*)arg
);
2074 #ifdef CONFIG_COMPAT
2076 * _ctl_compat_mpt_command - convert 32bit pointers to 64bit.
2077 * @file - (struct file)
2078 * @cmd - ioctl opcode
2079 * @arg - (struct mpt2_ioctl_command32)
2081 * MPT2COMMAND32 - Handle 32bit applications running on 64bit os.
2084 _ctl_compat_mpt_command(struct file
*file
, unsigned cmd
, unsigned long arg
)
2086 struct mpt2_ioctl_command32 karg32
;
2087 struct mpt2_ioctl_command32 __user
*uarg
;
2088 struct mpt2_ioctl_command karg
;
2089 struct MPT2SAS_ADAPTER
*ioc
;
2090 enum block_state state
;
2091 unsigned long flags
;
2093 if (_IOC_SIZE(cmd
) != sizeof(struct mpt2_ioctl_command32
))
2096 uarg
= (struct mpt2_ioctl_command32 __user
*) arg
;
2098 if (copy_from_user(&karg32
, (char __user
*)arg
, sizeof(karg32
))) {
2099 printk(KERN_ERR
"failure at %s:%d/%s()!\n",
2100 __FILE__
, __LINE__
, __func__
);
2103 if (_ctl_verify_adapter(karg32
.hdr
.ioc_number
, &ioc
) == -1 || !ioc
)
2106 spin_lock_irqsave(&ioc
->ioc_reset_in_progress_lock
, flags
);
2107 if (ioc
->shost_recovery
) {
2108 spin_unlock_irqrestore(&ioc
->ioc_reset_in_progress_lock
,
2112 spin_unlock_irqrestore(&ioc
->ioc_reset_in_progress_lock
, flags
);
2114 memset(&karg
, 0, sizeof(struct mpt2_ioctl_command
));
2115 karg
.hdr
.ioc_number
= karg32
.hdr
.ioc_number
;
2116 karg
.hdr
.port_number
= karg32
.hdr
.port_number
;
2117 karg
.hdr
.max_data_size
= karg32
.hdr
.max_data_size
;
2118 karg
.timeout
= karg32
.timeout
;
2119 karg
.max_reply_bytes
= karg32
.max_reply_bytes
;
2120 karg
.data_in_size
= karg32
.data_in_size
;
2121 karg
.data_out_size
= karg32
.data_out_size
;
2122 karg
.max_sense_bytes
= karg32
.max_sense_bytes
;
2123 karg
.data_sge_offset
= karg32
.data_sge_offset
;
2124 memcpy(&karg
.reply_frame_buf_ptr
, &karg32
.reply_frame_buf_ptr
,
2126 memcpy(&karg
.data_in_buf_ptr
, &karg32
.data_in_buf_ptr
,
2128 memcpy(&karg
.data_out_buf_ptr
, &karg32
.data_out_buf_ptr
,
2130 memcpy(&karg
.sense_data_ptr
, &karg32
.sense_data_ptr
,
2132 state
= (file
->f_flags
& O_NONBLOCK
) ? NON_BLOCKING
: BLOCKING
;
2133 return _ctl_do_mpt_command(ioc
, karg
, &uarg
->mf
, state
);
2137 * _ctl_ioctl_compat - main ioctl entry point (compat)
2142 * This routine handles 32 bit applications in 64bit os.
2145 _ctl_ioctl_compat(struct file
*file
, unsigned cmd
, unsigned long arg
)
2149 if (cmd
== MPT2COMMAND32
)
2150 ret
= _ctl_compat_mpt_command(file
, cmd
, arg
);
2152 ret
= _ctl_ioctl_main(file
, cmd
, (void __user
*)arg
);
2158 /* scsi host attributes */
2161 * _ctl_version_fw_show - firmware version
2162 * @cdev - pointer to embedded class device
2163 * @buf - the buffer returned
2165 * A sysfs 'read-only' shost attribute.
2168 _ctl_version_fw_show(struct device
*cdev
, struct device_attribute
*attr
,
2171 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2172 struct MPT2SAS_ADAPTER
*ioc
= shost_priv(shost
);
2174 return snprintf(buf
, PAGE_SIZE
, "%02d.%02d.%02d.%02d\n",
2175 (ioc
->facts
.FWVersion
.Word
& 0xFF000000) >> 24,
2176 (ioc
->facts
.FWVersion
.Word
& 0x00FF0000) >> 16,
2177 (ioc
->facts
.FWVersion
.Word
& 0x0000FF00) >> 8,
2178 ioc
->facts
.FWVersion
.Word
& 0x000000FF);
2180 static DEVICE_ATTR(version_fw
, S_IRUGO
, _ctl_version_fw_show
, NULL
);
2183 * _ctl_version_bios_show - bios version
2184 * @cdev - pointer to embedded class device
2185 * @buf - the buffer returned
2187 * A sysfs 'read-only' shost attribute.
2190 _ctl_version_bios_show(struct device
*cdev
, struct device_attribute
*attr
,
2193 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2194 struct MPT2SAS_ADAPTER
*ioc
= shost_priv(shost
);
2196 u32 version
= le32_to_cpu(ioc
->bios_pg3
.BiosVersion
);
2198 return snprintf(buf
, PAGE_SIZE
, "%02d.%02d.%02d.%02d\n",
2199 (version
& 0xFF000000) >> 24,
2200 (version
& 0x00FF0000) >> 16,
2201 (version
& 0x0000FF00) >> 8,
2202 version
& 0x000000FF);
2204 static DEVICE_ATTR(version_bios
, S_IRUGO
, _ctl_version_bios_show
, NULL
);
2207 * _ctl_version_mpi_show - MPI (message passing interface) version
2208 * @cdev - pointer to embedded class device
2209 * @buf - the buffer returned
2211 * A sysfs 'read-only' shost attribute.
2214 _ctl_version_mpi_show(struct device
*cdev
, struct device_attribute
*attr
,
2217 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2218 struct MPT2SAS_ADAPTER
*ioc
= shost_priv(shost
);
2220 return snprintf(buf
, PAGE_SIZE
, "%03x.%02x\n",
2221 ioc
->facts
.MsgVersion
, ioc
->facts
.HeaderVersion
>> 8);
2223 static DEVICE_ATTR(version_mpi
, S_IRUGO
, _ctl_version_mpi_show
, NULL
);
2226 * _ctl_version_product_show - product name
2227 * @cdev - pointer to embedded class device
2228 * @buf - the buffer returned
2230 * A sysfs 'read-only' shost attribute.
2233 _ctl_version_product_show(struct device
*cdev
, struct device_attribute
*attr
,
2236 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2237 struct MPT2SAS_ADAPTER
*ioc
= shost_priv(shost
);
2239 return snprintf(buf
, 16, "%s\n", ioc
->manu_pg0
.ChipName
);
2241 static DEVICE_ATTR(version_product
, S_IRUGO
,
2242 _ctl_version_product_show
, NULL
);
2245 * _ctl_version_nvdata_persistent_show - ndvata persistent version
2246 * @cdev - pointer to embedded class device
2247 * @buf - the buffer returned
2249 * A sysfs 'read-only' shost attribute.
2252 _ctl_version_nvdata_persistent_show(struct device
*cdev
,
2253 struct device_attribute
*attr
, char *buf
)
2255 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2256 struct MPT2SAS_ADAPTER
*ioc
= shost_priv(shost
);
2258 return snprintf(buf
, PAGE_SIZE
, "%02xh\n",
2259 le16_to_cpu(ioc
->iounit_pg0
.NvdataVersionPersistent
.Word
));
2261 static DEVICE_ATTR(version_nvdata_persistent
, S_IRUGO
,
2262 _ctl_version_nvdata_persistent_show
, NULL
);
2265 * _ctl_version_nvdata_default_show - nvdata default version
2266 * @cdev - pointer to embedded class device
2267 * @buf - the buffer returned
2269 * A sysfs 'read-only' shost attribute.
2272 _ctl_version_nvdata_default_show(struct device
*cdev
,
2273 struct device_attribute
*attr
, char *buf
)
2275 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2276 struct MPT2SAS_ADAPTER
*ioc
= shost_priv(shost
);
2278 return snprintf(buf
, PAGE_SIZE
, "%02xh\n",
2279 le16_to_cpu(ioc
->iounit_pg0
.NvdataVersionDefault
.Word
));
2281 static DEVICE_ATTR(version_nvdata_default
, S_IRUGO
,
2282 _ctl_version_nvdata_default_show
, NULL
);
2285 * _ctl_board_name_show - board name
2286 * @cdev - pointer to embedded class device
2287 * @buf - the buffer returned
2289 * A sysfs 'read-only' shost attribute.
2292 _ctl_board_name_show(struct device
*cdev
, struct device_attribute
*attr
,
2295 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2296 struct MPT2SAS_ADAPTER
*ioc
= shost_priv(shost
);
2298 return snprintf(buf
, 16, "%s\n", ioc
->manu_pg0
.BoardName
);
2300 static DEVICE_ATTR(board_name
, S_IRUGO
, _ctl_board_name_show
, NULL
);
2303 * _ctl_board_assembly_show - board assembly name
2304 * @cdev - pointer to embedded class device
2305 * @buf - the buffer returned
2307 * A sysfs 'read-only' shost attribute.
2310 _ctl_board_assembly_show(struct device
*cdev
, struct device_attribute
*attr
,
2313 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2314 struct MPT2SAS_ADAPTER
*ioc
= shost_priv(shost
);
2316 return snprintf(buf
, 16, "%s\n", ioc
->manu_pg0
.BoardAssembly
);
2318 static DEVICE_ATTR(board_assembly
, S_IRUGO
,
2319 _ctl_board_assembly_show
, NULL
);
2322 * _ctl_board_tracer_show - board tracer number
2323 * @cdev - pointer to embedded class device
2324 * @buf - the buffer returned
2326 * A sysfs 'read-only' shost attribute.
2329 _ctl_board_tracer_show(struct device
*cdev
, struct device_attribute
*attr
,
2332 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2333 struct MPT2SAS_ADAPTER
*ioc
= shost_priv(shost
);
2335 return snprintf(buf
, 16, "%s\n", ioc
->manu_pg0
.BoardTracerNumber
);
2337 static DEVICE_ATTR(board_tracer
, S_IRUGO
,
2338 _ctl_board_tracer_show
, NULL
);
2341 * _ctl_io_delay_show - io missing delay
2342 * @cdev - pointer to embedded class device
2343 * @buf - the buffer returned
2345 * This is for firmware implemention for deboucing device
2348 * A sysfs 'read-only' shost attribute.
2351 _ctl_io_delay_show(struct device
*cdev
, struct device_attribute
*attr
,
2354 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2355 struct MPT2SAS_ADAPTER
*ioc
= shost_priv(shost
);
2357 return snprintf(buf
, PAGE_SIZE
, "%02d\n", ioc
->io_missing_delay
);
2359 static DEVICE_ATTR(io_delay
, S_IRUGO
,
2360 _ctl_io_delay_show
, NULL
);
2363 * _ctl_device_delay_show - device missing delay
2364 * @cdev - pointer to embedded class device
2365 * @buf - the buffer returned
2367 * This is for firmware implemention for deboucing device
2370 * A sysfs 'read-only' shost attribute.
2373 _ctl_device_delay_show(struct device
*cdev
, struct device_attribute
*attr
,
2376 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2377 struct MPT2SAS_ADAPTER
*ioc
= shost_priv(shost
);
2379 return snprintf(buf
, PAGE_SIZE
, "%02d\n", ioc
->device_missing_delay
);
2381 static DEVICE_ATTR(device_delay
, S_IRUGO
,
2382 _ctl_device_delay_show
, NULL
);
2385 * _ctl_fw_queue_depth_show - global credits
2386 * @cdev - pointer to embedded class device
2387 * @buf - the buffer returned
2389 * This is firmware queue depth limit
2391 * A sysfs 'read-only' shost attribute.
2394 _ctl_fw_queue_depth_show(struct device
*cdev
, struct device_attribute
*attr
,
2397 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2398 struct MPT2SAS_ADAPTER
*ioc
= shost_priv(shost
);
2400 return snprintf(buf
, PAGE_SIZE
, "%02d\n", ioc
->facts
.RequestCredit
);
2402 static DEVICE_ATTR(fw_queue_depth
, S_IRUGO
,
2403 _ctl_fw_queue_depth_show
, NULL
);
2406 * _ctl_sas_address_show - sas address
2407 * @cdev - pointer to embedded class device
2408 * @buf - the buffer returned
2410 * This is the controller sas address
2412 * A sysfs 'read-only' shost attribute.
2415 _ctl_host_sas_address_show(struct device
*cdev
, struct device_attribute
*attr
,
2418 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2419 struct MPT2SAS_ADAPTER
*ioc
= shost_priv(shost
);
2421 return snprintf(buf
, PAGE_SIZE
, "0x%016llx\n",
2422 (unsigned long long)ioc
->sas_hba
.sas_address
);
2424 static DEVICE_ATTR(host_sas_address
, S_IRUGO
,
2425 _ctl_host_sas_address_show
, NULL
);
2428 * _ctl_logging_level_show - logging level
2429 * @cdev - pointer to embedded class device
2430 * @buf - the buffer returned
2432 * A sysfs 'read/write' shost attribute.
2435 _ctl_logging_level_show(struct device
*cdev
, struct device_attribute
*attr
,
2438 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2439 struct MPT2SAS_ADAPTER
*ioc
= shost_priv(shost
);
2441 return snprintf(buf
, PAGE_SIZE
, "%08xh\n", ioc
->logging_level
);
2444 _ctl_logging_level_store(struct device
*cdev
, struct device_attribute
*attr
,
2445 const char *buf
, size_t count
)
2447 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2448 struct MPT2SAS_ADAPTER
*ioc
= shost_priv(shost
);
2451 if (sscanf(buf
, "%x", &val
) != 1)
2454 ioc
->logging_level
= val
;
2455 printk(MPT2SAS_INFO_FMT
"logging_level=%08xh\n", ioc
->name
,
2456 ioc
->logging_level
);
2459 static DEVICE_ATTR(logging_level
, S_IRUGO
| S_IWUSR
,
2460 _ctl_logging_level_show
, _ctl_logging_level_store
);
2462 struct device_attribute
*mpt2sas_host_attrs
[] = {
2463 &dev_attr_version_fw
,
2464 &dev_attr_version_bios
,
2465 &dev_attr_version_mpi
,
2466 &dev_attr_version_product
,
2467 &dev_attr_version_nvdata_persistent
,
2468 &dev_attr_version_nvdata_default
,
2469 &dev_attr_board_name
,
2470 &dev_attr_board_assembly
,
2471 &dev_attr_board_tracer
,
2473 &dev_attr_device_delay
,
2474 &dev_attr_logging_level
,
2475 &dev_attr_fw_queue_depth
,
2476 &dev_attr_host_sas_address
,
2480 /* device attributes */
2483 * _ctl_device_sas_address_show - sas address
2484 * @cdev - pointer to embedded class device
2485 * @buf - the buffer returned
2487 * This is the sas address for the target
2489 * A sysfs 'read-only' shost attribute.
2492 _ctl_device_sas_address_show(struct device
*dev
, struct device_attribute
*attr
,
2495 struct scsi_device
*sdev
= to_scsi_device(dev
);
2496 struct MPT2SAS_DEVICE
*sas_device_priv_data
= sdev
->hostdata
;
2498 return snprintf(buf
, PAGE_SIZE
, "0x%016llx\n",
2499 (unsigned long long)sas_device_priv_data
->sas_target
->sas_address
);
2501 static DEVICE_ATTR(sas_address
, S_IRUGO
, _ctl_device_sas_address_show
, NULL
);
2504 * _ctl_device_handle_show - device handle
2505 * @cdev - pointer to embedded class device
2506 * @buf - the buffer returned
2508 * This is the firmware assigned device handle
2510 * A sysfs 'read-only' shost attribute.
2513 _ctl_device_handle_show(struct device
*dev
, struct device_attribute
*attr
,
2516 struct scsi_device
*sdev
= to_scsi_device(dev
);
2517 struct MPT2SAS_DEVICE
*sas_device_priv_data
= sdev
->hostdata
;
2519 return snprintf(buf
, PAGE_SIZE
, "0x%04x\n",
2520 sas_device_priv_data
->sas_target
->handle
);
2522 static DEVICE_ATTR(sas_device_handle
, S_IRUGO
, _ctl_device_handle_show
, NULL
);
2524 struct device_attribute
*mpt2sas_dev_attrs
[] = {
2525 &dev_attr_sas_address
,
2526 &dev_attr_sas_device_handle
,
2530 static const struct file_operations ctl_fops
= {
2531 .owner
= THIS_MODULE
,
2532 .unlocked_ioctl
= _ctl_ioctl
,
2533 .release
= _ctl_release
,
2535 .fasync
= _ctl_fasync
,
2536 #ifdef CONFIG_COMPAT
2537 .compat_ioctl
= _ctl_ioctl_compat
,
2541 static struct miscdevice ctl_dev
= {
2542 .minor
= MPT2SAS_MINOR
,
2543 .name
= MPT2SAS_DEV_NAME
,
2548 * mpt2sas_ctl_init - main entry point for ctl.
2552 mpt2sas_ctl_init(void)
2555 if (misc_register(&ctl_dev
) < 0)
2556 printk(KERN_ERR
"%s can't register misc device [minor=%d]\n",
2557 MPT2SAS_DRIVER_NAME
, MPT2SAS_MINOR
);
2559 init_waitqueue_head(&ctl_poll_wait
);
2563 * mpt2sas_ctl_exit - exit point for ctl
2567 mpt2sas_ctl_exit(void)
2569 struct MPT2SAS_ADAPTER
*ioc
;
2572 list_for_each_entry(ioc
, &mpt2sas_ioc_list
, list
) {
2574 /* free memory associated to diag buffers */
2575 for (i
= 0; i
< MPI2_DIAG_BUF_TYPE_COUNT
; i
++) {
2576 if (!ioc
->diag_buffer
[i
])
2578 pci_free_consistent(ioc
->pdev
, ioc
->diag_buffer_sz
[i
],
2579 ioc
->diag_buffer
[i
], ioc
->diag_buffer_dma
[i
]);
2580 ioc
->diag_buffer
[i
] = NULL
;
2581 ioc
->diag_buffer_status
[i
] = 0;
2584 kfree(ioc
->event_log
);
2586 misc_deregister(&ctl_dev
);