2 * SAS Transport Layer for MPT (Message Passing Technology) based controllers
4 * This code is based on drivers/scsi/mpt2sas/mpt2_transport.c
5 * Copyright (C) 2007-2009 LSI Corporation
6 * (mailto:DL-MPTFusionLinux@lsi.com)
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
19 * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
20 * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
21 * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
22 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
23 * solely responsible for determining the appropriateness of using and
24 * distributing the Program and assumes all risks associated with its
25 * exercise of rights under this Agreement, including but not limited to
26 * the risks and costs of program errors, damage to or loss of data,
27 * programs or equipment, and unavailability or interruption of operations.
29 * DISCLAIMER OF LIABILITY
30 * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
31 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
33 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
34 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
35 * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
36 * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
38 * You should have received a copy of the GNU General Public License
39 * along with this program; if not, write to the Free Software
40 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
44 #include <linux/module.h>
45 #include <linux/kernel.h>
46 #include <linux/init.h>
47 #include <linux/errno.h>
48 #include <linux/sched.h>
49 #include <linux/workqueue.h>
50 #include <linux/delay.h>
51 #include <linux/pci.h>
53 #include <scsi/scsi.h>
54 #include <scsi/scsi_cmnd.h>
55 #include <scsi/scsi_device.h>
56 #include <scsi/scsi_host.h>
57 #include <scsi/scsi_transport_sas.h>
58 #include <scsi/scsi_dbg.h>
60 #include "mpt2sas_base.h"
62 * _transport_sas_node_find_by_sas_address - sas node search
63 * @ioc: per adapter object
64 * @sas_address: sas address of expander or sas host
65 * Context: Calling function should acquire ioc->sas_node_lock.
67 * Search for either hba phys or expander device based on handle, then returns
68 * the sas_node object.
70 static struct _sas_node
*
71 _transport_sas_node_find_by_sas_address(struct MPT2SAS_ADAPTER
*ioc
,
74 if (ioc
->sas_hba
.sas_address
== sas_address
)
77 return mpt2sas_scsih_expander_find_by_sas_address(ioc
,
82 * _transport_convert_phy_link_rate -
83 * @link_rate: link rate returned from mpt firmware
85 * Convert link_rate from mpi fusion into sas_transport form.
87 static enum sas_linkrate
88 _transport_convert_phy_link_rate(u8 link_rate
)
93 case MPI2_SAS_NEG_LINK_RATE_1_5
:
94 rc
= SAS_LINK_RATE_1_5_GBPS
;
96 case MPI2_SAS_NEG_LINK_RATE_3_0
:
97 rc
= SAS_LINK_RATE_3_0_GBPS
;
99 case MPI2_SAS_NEG_LINK_RATE_6_0
:
100 rc
= SAS_LINK_RATE_6_0_GBPS
;
102 case MPI2_SAS_NEG_LINK_RATE_PHY_DISABLED
:
103 rc
= SAS_PHY_DISABLED
;
105 case MPI2_SAS_NEG_LINK_RATE_NEGOTIATION_FAILED
:
106 rc
= SAS_LINK_RATE_FAILED
;
108 case MPI2_SAS_NEG_LINK_RATE_PORT_SELECTOR
:
109 rc
= SAS_SATA_PORT_SELECTOR
;
111 case MPI2_SAS_NEG_LINK_RATE_SMP_RESET_IN_PROGRESS
:
112 rc
= SAS_PHY_RESET_IN_PROGRESS
;
115 case MPI2_SAS_NEG_LINK_RATE_SATA_OOB_COMPLETE
:
116 case MPI2_SAS_NEG_LINK_RATE_UNKNOWN_LINK_RATE
:
117 rc
= SAS_LINK_RATE_UNKNOWN
;
124 * _transport_set_identify - set identify for phys and end devices
125 * @ioc: per adapter object
126 * @handle: device handle
127 * @identify: sas identify info
129 * Populates sas identify info.
131 * Returns 0 for success, non-zero for failure.
134 _transport_set_identify(struct MPT2SAS_ADAPTER
*ioc
, u16 handle
,
135 struct sas_identify
*identify
)
137 Mpi2SasDevicePage0_t sas_device_pg0
;
138 Mpi2ConfigReply_t mpi_reply
;
142 if (ioc
->shost_recovery
) {
143 printk(MPT2SAS_INFO_FMT
"%s: host reset in progress!\n",
144 __func__
, ioc
->name
);
148 if ((mpt2sas_config_get_sas_device_pg0(ioc
, &mpi_reply
, &sas_device_pg0
,
149 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE
, handle
))) {
150 printk(MPT2SAS_ERR_FMT
"failure at %s:%d/%s()!\n",
152 ioc
->name
, __FILE__
, __LINE__
, __func__
);
156 ioc_status
= le16_to_cpu(mpi_reply
.IOCStatus
) &
158 if (ioc_status
!= MPI2_IOCSTATUS_SUCCESS
) {
159 printk(MPT2SAS_ERR_FMT
"handle(0x%04x), ioc_status(0x%04x)"
160 "\nfailure at %s:%d/%s()!\n", ioc
->name
, handle
, ioc_status
,
161 __FILE__
, __LINE__
, __func__
);
165 memset(identify
, 0, sizeof(identify
));
166 device_info
= le32_to_cpu(sas_device_pg0
.DeviceInfo
);
169 identify
->sas_address
= le64_to_cpu(sas_device_pg0
.SASAddress
);
172 switch (device_info
& MPI2_SAS_DEVICE_INFO_MASK_DEVICE_TYPE
) {
173 case MPI2_SAS_DEVICE_INFO_NO_DEVICE
:
174 identify
->device_type
= SAS_PHY_UNUSED
;
176 case MPI2_SAS_DEVICE_INFO_END_DEVICE
:
177 identify
->device_type
= SAS_END_DEVICE
;
179 case MPI2_SAS_DEVICE_INFO_EDGE_EXPANDER
:
180 identify
->device_type
= SAS_EDGE_EXPANDER_DEVICE
;
182 case MPI2_SAS_DEVICE_INFO_FANOUT_EXPANDER
:
183 identify
->device_type
= SAS_FANOUT_EXPANDER_DEVICE
;
187 /* initiator_port_protocols */
188 if (device_info
& MPI2_SAS_DEVICE_INFO_SSP_INITIATOR
)
189 identify
->initiator_port_protocols
|= SAS_PROTOCOL_SSP
;
190 if (device_info
& MPI2_SAS_DEVICE_INFO_STP_INITIATOR
)
191 identify
->initiator_port_protocols
|= SAS_PROTOCOL_STP
;
192 if (device_info
& MPI2_SAS_DEVICE_INFO_SMP_INITIATOR
)
193 identify
->initiator_port_protocols
|= SAS_PROTOCOL_SMP
;
194 if (device_info
& MPI2_SAS_DEVICE_INFO_SATA_HOST
)
195 identify
->initiator_port_protocols
|= SAS_PROTOCOL_SATA
;
197 /* target_port_protocols */
198 if (device_info
& MPI2_SAS_DEVICE_INFO_SSP_TARGET
)
199 identify
->target_port_protocols
|= SAS_PROTOCOL_SSP
;
200 if (device_info
& MPI2_SAS_DEVICE_INFO_STP_TARGET
)
201 identify
->target_port_protocols
|= SAS_PROTOCOL_STP
;
202 if (device_info
& MPI2_SAS_DEVICE_INFO_SMP_TARGET
)
203 identify
->target_port_protocols
|= SAS_PROTOCOL_SMP
;
204 if (device_info
& MPI2_SAS_DEVICE_INFO_SATA_DEVICE
)
205 identify
->target_port_protocols
|= SAS_PROTOCOL_SATA
;
211 * mpt2sas_transport_done - internal transport layer callback handler.
212 * @ioc: per adapter object
213 * @smid: system request message index
214 * @msix_index: MSIX table index supplied by the OS
215 * @reply: reply message frame(lower 32bit addr)
217 * Callback handler when sending internal generated transport cmds.
218 * The callback index passed is `ioc->transport_cb_idx`
220 * Return 1 meaning mf should be freed from _base_interrupt
221 * 0 means the mf is freed from this function.
224 mpt2sas_transport_done(struct MPT2SAS_ADAPTER
*ioc
, u16 smid
, u8 msix_index
,
227 MPI2DefaultReply_t
*mpi_reply
;
229 mpi_reply
= mpt2sas_base_get_reply_virt_addr(ioc
, reply
);
230 if (ioc
->transport_cmds
.status
== MPT2_CMD_NOT_USED
)
232 if (ioc
->transport_cmds
.smid
!= smid
)
234 ioc
->transport_cmds
.status
|= MPT2_CMD_COMPLETE
;
236 memcpy(ioc
->transport_cmds
.reply
, mpi_reply
,
237 mpi_reply
->MsgLength
*4);
238 ioc
->transport_cmds
.status
|= MPT2_CMD_REPLY_VALID
;
240 ioc
->transport_cmds
.status
&= ~MPT2_CMD_PENDING
;
241 complete(&ioc
->transport_cmds
.done
);
245 /* report manufacture request structure */
246 struct rep_manu_request
{
253 /* report manufacture reply structure */
254 struct rep_manu_reply
{
255 u8 smp_frame_type
; /* 0x41 */
256 u8 function
; /* 0x01 */
259 u16 expander_change_count
;
263 u8 vendor_id
[SAS_EXPANDER_VENDOR_ID_LEN
];
264 u8 product_id
[SAS_EXPANDER_PRODUCT_ID_LEN
];
265 u8 product_rev
[SAS_EXPANDER_PRODUCT_REV_LEN
];
266 u8 component_vendor_id
[SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN
];
268 u8 component_revision_id
;
270 u8 vendor_specific
[8];
274 * _transport_expander_report_manufacture - obtain SMP report_manufacture
275 * @ioc: per adapter object
276 * @sas_address: expander sas address
277 * @edev: the sas_expander_device object
279 * Fills in the sas_expander_device object when SMP port is created.
281 * Returns 0 for success, non-zero for failure.
284 _transport_expander_report_manufacture(struct MPT2SAS_ADAPTER
*ioc
,
285 u64 sas_address
, struct sas_expander_device
*edev
)
287 Mpi2SmpPassthroughRequest_t
*mpi_request
;
288 Mpi2SmpPassthroughReply_t
*mpi_reply
;
289 struct rep_manu_reply
*manufacture_reply
;
290 struct rep_manu_request
*manufacture_request
;
294 unsigned long timeleft
;
298 void *data_out
= NULL
;
299 dma_addr_t data_out_dma
;
302 u16 wait_state_count
;
304 if (ioc
->shost_recovery
) {
305 printk(MPT2SAS_INFO_FMT
"%s: host reset in progress!\n",
306 __func__
, ioc
->name
);
310 mutex_lock(&ioc
->transport_cmds
.mutex
);
312 if (ioc
->transport_cmds
.status
!= MPT2_CMD_NOT_USED
) {
313 printk(MPT2SAS_ERR_FMT
"%s: transport_cmds in use\n",
314 ioc
->name
, __func__
);
318 ioc
->transport_cmds
.status
= MPT2_CMD_PENDING
;
320 wait_state_count
= 0;
321 ioc_state
= mpt2sas_base_get_iocstate(ioc
, 1);
322 while (ioc_state
!= MPI2_IOC_STATE_OPERATIONAL
) {
323 if (wait_state_count
++ == 10) {
324 printk(MPT2SAS_ERR_FMT
325 "%s: failed due to ioc not operational\n",
326 ioc
->name
, __func__
);
331 ioc_state
= mpt2sas_base_get_iocstate(ioc
, 1);
332 printk(MPT2SAS_INFO_FMT
"%s: waiting for "
333 "operational state(count=%d)\n", ioc
->name
,
334 __func__
, wait_state_count
);
336 if (wait_state_count
)
337 printk(MPT2SAS_INFO_FMT
"%s: ioc is operational\n",
338 ioc
->name
, __func__
);
340 smid
= mpt2sas_base_get_smid(ioc
, ioc
->transport_cb_idx
);
342 printk(MPT2SAS_ERR_FMT
"%s: failed obtaining a smid\n",
343 ioc
->name
, __func__
);
349 mpi_request
= mpt2sas_base_get_msg_frame(ioc
, smid
);
350 ioc
->transport_cmds
.smid
= smid
;
352 sz
= sizeof(struct rep_manu_request
) + sizeof(struct rep_manu_reply
);
353 data_out
= pci_alloc_consistent(ioc
->pdev
, sz
, &data_out_dma
);
356 printk(KERN_ERR
"failure at %s:%d/%s()!\n", __FILE__
,
359 mpt2sas_base_free_smid(ioc
, smid
);
363 manufacture_request
= data_out
;
364 manufacture_request
->smp_frame_type
= 0x40;
365 manufacture_request
->function
= 1;
366 manufacture_request
->reserved
= 0;
367 manufacture_request
->request_length
= 0;
369 memset(mpi_request
, 0, sizeof(Mpi2SmpPassthroughRequest_t
));
370 mpi_request
->Function
= MPI2_FUNCTION_SMP_PASSTHROUGH
;
371 mpi_request
->PhysicalPort
= 0xFF;
372 mpi_request
->VF_ID
= 0; /* TODO */
373 mpi_request
->VP_ID
= 0;
374 sas_address_le
= (u64
*)&mpi_request
->SASAddress
;
375 *sas_address_le
= cpu_to_le64(sas_address
);
376 mpi_request
->RequestDataLength
=
377 cpu_to_le16(sizeof(struct rep_manu_request
));
378 psge
= &mpi_request
->SGL
;
380 /* WRITE sgel first */
381 sgl_flags
= (MPI2_SGE_FLAGS_SIMPLE_ELEMENT
|
382 MPI2_SGE_FLAGS_END_OF_BUFFER
| MPI2_SGE_FLAGS_HOST_TO_IOC
);
383 sgl_flags
= sgl_flags
<< MPI2_SGE_FLAGS_SHIFT
;
384 ioc
->base_add_sg_single(psge
, sgl_flags
|
385 sizeof(struct rep_manu_request
), data_out_dma
);
388 psge
+= ioc
->sge_size
;
391 sgl_flags
= (MPI2_SGE_FLAGS_SIMPLE_ELEMENT
|
392 MPI2_SGE_FLAGS_LAST_ELEMENT
| MPI2_SGE_FLAGS_END_OF_BUFFER
|
393 MPI2_SGE_FLAGS_END_OF_LIST
);
394 sgl_flags
= sgl_flags
<< MPI2_SGE_FLAGS_SHIFT
;
395 ioc
->base_add_sg_single(psge
, sgl_flags
|
396 sizeof(struct rep_manu_reply
), data_out_dma
+
397 sizeof(struct rep_manu_request
));
399 dtransportprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"report_manufacture - "
400 "send to sas_addr(0x%016llx)\n", ioc
->name
,
401 (unsigned long long)sas_address
));
402 mpt2sas_base_put_smid_default(ioc
, smid
);
403 init_completion(&ioc
->transport_cmds
.done
);
404 timeleft
= wait_for_completion_timeout(&ioc
->transport_cmds
.done
,
407 if (!(ioc
->transport_cmds
.status
& MPT2_CMD_COMPLETE
)) {
408 printk(MPT2SAS_ERR_FMT
"%s: timeout\n",
409 ioc
->name
, __func__
);
410 _debug_dump_mf(mpi_request
,
411 sizeof(Mpi2SmpPassthroughRequest_t
)/4);
412 if (!(ioc
->transport_cmds
.status
& MPT2_CMD_RESET
))
414 goto issue_host_reset
;
417 dtransportprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"report_manufacture - "
418 "complete\n", ioc
->name
));
420 if (ioc
->transport_cmds
.status
& MPT2_CMD_REPLY_VALID
) {
423 mpi_reply
= ioc
->transport_cmds
.reply
;
425 dtransportprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
426 "report_manufacture - reply data transfer size(%d)\n",
427 ioc
->name
, le16_to_cpu(mpi_reply
->ResponseDataLength
)));
429 if (le16_to_cpu(mpi_reply
->ResponseDataLength
) !=
430 sizeof(struct rep_manu_reply
))
433 manufacture_reply
= data_out
+ sizeof(struct rep_manu_request
);
434 strncpy(edev
->vendor_id
, manufacture_reply
->vendor_id
,
435 SAS_EXPANDER_VENDOR_ID_LEN
);
436 strncpy(edev
->product_id
, manufacture_reply
->product_id
,
437 SAS_EXPANDER_PRODUCT_ID_LEN
);
438 strncpy(edev
->product_rev
, manufacture_reply
->product_rev
,
439 SAS_EXPANDER_PRODUCT_REV_LEN
);
440 edev
->level
= manufacture_reply
->sas_format
& 1;
442 strncpy(edev
->component_vendor_id
,
443 manufacture_reply
->component_vendor_id
,
444 SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN
);
445 tmp
= (u8
*)&manufacture_reply
->component_id
;
446 edev
->component_id
= tmp
[0] << 8 | tmp
[1];
447 edev
->component_revision_id
=
448 manufacture_reply
->component_revision_id
;
451 dtransportprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
452 "report_manufacture - no reply\n", ioc
->name
));
456 mpt2sas_base_hard_reset_handler(ioc
, CAN_SLEEP
,
459 ioc
->transport_cmds
.status
= MPT2_CMD_NOT_USED
;
461 pci_free_consistent(ioc
->pdev
, sz
, data_out
, data_out_dma
);
463 mutex_unlock(&ioc
->transport_cmds
.mutex
);
468 * mpt2sas_transport_port_add - insert port to the list
469 * @ioc: per adapter object
470 * @handle: handle of attached device
471 * @sas_address: sas address of parent expander or sas host
472 * Context: This function will acquire ioc->sas_node_lock.
474 * Adding new port object to the sas_node->sas_port_list.
476 * Returns mpt2sas_port.
479 mpt2sas_transport_port_add(struct MPT2SAS_ADAPTER
*ioc
, u16 handle
,
482 struct _sas_phy
*mpt2sas_phy
, *next
;
483 struct _sas_port
*mpt2sas_port
;
485 struct _sas_node
*sas_node
;
486 struct sas_rphy
*rphy
;
488 struct sas_port
*port
;
490 mpt2sas_port
= kzalloc(sizeof(struct _sas_port
),
493 printk(MPT2SAS_ERR_FMT
"failure at %s:%d/%s()!\n",
494 ioc
->name
, __FILE__
, __LINE__
, __func__
);
498 INIT_LIST_HEAD(&mpt2sas_port
->port_list
);
499 INIT_LIST_HEAD(&mpt2sas_port
->phy_list
);
500 spin_lock_irqsave(&ioc
->sas_node_lock
, flags
);
501 sas_node
= _transport_sas_node_find_by_sas_address(ioc
, sas_address
);
502 spin_unlock_irqrestore(&ioc
->sas_node_lock
, flags
);
505 printk(MPT2SAS_ERR_FMT
"%s: Could not find "
506 "parent sas_address(0x%016llx)!\n", ioc
->name
,
507 __func__
, (unsigned long long)sas_address
);
511 if ((_transport_set_identify(ioc
, handle
,
512 &mpt2sas_port
->remote_identify
))) {
513 printk(MPT2SAS_ERR_FMT
"failure at %s:%d/%s()!\n",
514 ioc
->name
, __FILE__
, __LINE__
, __func__
);
518 if (mpt2sas_port
->remote_identify
.device_type
== SAS_PHY_UNUSED
) {
519 printk(MPT2SAS_ERR_FMT
"failure at %s:%d/%s()!\n",
520 ioc
->name
, __FILE__
, __LINE__
, __func__
);
524 for (i
= 0; i
< sas_node
->num_phys
; i
++) {
525 if (sas_node
->phy
[i
].remote_identify
.sas_address
!=
526 mpt2sas_port
->remote_identify
.sas_address
)
528 list_add_tail(&sas_node
->phy
[i
].port_siblings
,
529 &mpt2sas_port
->phy_list
);
530 mpt2sas_port
->num_phys
++;
533 if (!mpt2sas_port
->num_phys
) {
534 printk(MPT2SAS_ERR_FMT
"failure at %s:%d/%s()!\n",
535 ioc
->name
, __FILE__
, __LINE__
, __func__
);
539 port
= sas_port_alloc_num(sas_node
->parent_dev
);
540 if ((sas_port_add(port
))) {
541 printk(MPT2SAS_ERR_FMT
"failure at %s:%d/%s()!\n",
542 ioc
->name
, __FILE__
, __LINE__
, __func__
);
546 list_for_each_entry(mpt2sas_phy
, &mpt2sas_port
->phy_list
,
548 if ((ioc
->logging_level
& MPT_DEBUG_TRANSPORT
))
549 dev_printk(KERN_INFO
, &port
->dev
, "add: handle(0x%04x)"
550 ", sas_addr(0x%016llx), phy(%d)\n", handle
,
552 mpt2sas_port
->remote_identify
.sas_address
,
553 mpt2sas_phy
->phy_id
);
554 sas_port_add_phy(port
, mpt2sas_phy
->phy
);
557 mpt2sas_port
->port
= port
;
558 if (mpt2sas_port
->remote_identify
.device_type
== SAS_END_DEVICE
)
559 rphy
= sas_end_device_alloc(port
);
561 rphy
= sas_expander_alloc(port
,
562 mpt2sas_port
->remote_identify
.device_type
);
564 rphy
->identify
= mpt2sas_port
->remote_identify
;
565 if ((sas_rphy_add(rphy
))) {
566 printk(MPT2SAS_ERR_FMT
"failure at %s:%d/%s()!\n",
567 ioc
->name
, __FILE__
, __LINE__
, __func__
);
569 if ((ioc
->logging_level
& MPT_DEBUG_TRANSPORT
))
570 dev_printk(KERN_INFO
, &rphy
->dev
, "add: handle(0x%04x), "
571 "sas_addr(0x%016llx)\n", handle
,
573 mpt2sas_port
->remote_identify
.sas_address
);
574 mpt2sas_port
->rphy
= rphy
;
575 spin_lock_irqsave(&ioc
->sas_node_lock
, flags
);
576 list_add_tail(&mpt2sas_port
->port_list
, &sas_node
->sas_port_list
);
577 spin_unlock_irqrestore(&ioc
->sas_node_lock
, flags
);
579 /* fill in report manufacture */
580 if (mpt2sas_port
->remote_identify
.device_type
==
581 MPI2_SAS_DEVICE_INFO_EDGE_EXPANDER
||
582 mpt2sas_port
->remote_identify
.device_type
==
583 MPI2_SAS_DEVICE_INFO_FANOUT_EXPANDER
)
584 _transport_expander_report_manufacture(ioc
,
585 mpt2sas_port
->remote_identify
.sas_address
,
586 rphy_to_expander_device(rphy
));
591 list_for_each_entry_safe(mpt2sas_phy
, next
, &mpt2sas_port
->phy_list
,
593 list_del(&mpt2sas_phy
->port_siblings
);
599 * mpt2sas_transport_port_remove - remove port from the list
600 * @ioc: per adapter object
601 * @sas_address: sas address of attached device
602 * @sas_address_parent: sas address of parent expander or sas host
603 * Context: This function will acquire ioc->sas_node_lock.
605 * Removing object and freeing associated memory from the
606 * ioc->sas_port_list.
611 mpt2sas_transport_port_remove(struct MPT2SAS_ADAPTER
*ioc
, u64 sas_address
,
612 u64 sas_address_parent
)
616 struct _sas_port
*mpt2sas_port
, *next
;
617 struct _sas_node
*sas_node
;
619 struct _sas_phy
*mpt2sas_phy
, *next_phy
;
621 spin_lock_irqsave(&ioc
->sas_node_lock
, flags
);
622 sas_node
= _transport_sas_node_find_by_sas_address(ioc
,
624 spin_unlock_irqrestore(&ioc
->sas_node_lock
, flags
);
627 list_for_each_entry_safe(mpt2sas_port
, next
, &sas_node
->sas_port_list
,
629 if (mpt2sas_port
->remote_identify
.sas_address
!= sas_address
)
632 list_del(&mpt2sas_port
->port_list
);
639 for (i
= 0; i
< sas_node
->num_phys
; i
++) {
640 if (sas_node
->phy
[i
].remote_identify
.sas_address
== sas_address
)
641 memset(&sas_node
->phy
[i
].remote_identify
, 0 ,
642 sizeof(struct sas_identify
));
645 list_for_each_entry_safe(mpt2sas_phy
, next_phy
,
646 &mpt2sas_port
->phy_list
, port_siblings
) {
647 if ((ioc
->logging_level
& MPT_DEBUG_TRANSPORT
))
648 dev_printk(KERN_INFO
, &mpt2sas_port
->port
->dev
,
649 "remove: sas_addr(0x%016llx), phy(%d)\n",
651 mpt2sas_port
->remote_identify
.sas_address
,
652 mpt2sas_phy
->phy_id
);
653 sas_port_delete_phy(mpt2sas_port
->port
, mpt2sas_phy
->phy
);
654 list_del(&mpt2sas_phy
->port_siblings
);
656 sas_port_delete(mpt2sas_port
->port
);
661 * mpt2sas_transport_add_host_phy - report sas_host phy to transport
662 * @ioc: per adapter object
663 * @mpt2sas_phy: mpt2sas per phy object
664 * @phy_pg0: sas phy page 0
665 * @parent_dev: parent device class object
667 * Returns 0 for success, non-zero for failure.
670 mpt2sas_transport_add_host_phy(struct MPT2SAS_ADAPTER
*ioc
, struct _sas_phy
671 *mpt2sas_phy
, Mpi2SasPhyPage0_t phy_pg0
, struct device
*parent_dev
)
674 int phy_index
= mpt2sas_phy
->phy_id
;
677 INIT_LIST_HEAD(&mpt2sas_phy
->port_siblings
);
678 phy
= sas_phy_alloc(parent_dev
, phy_index
);
680 printk(MPT2SAS_ERR_FMT
"failure at %s:%d/%s()!\n",
681 ioc
->name
, __FILE__
, __LINE__
, __func__
);
684 if ((_transport_set_identify(ioc
, mpt2sas_phy
->handle
,
685 &mpt2sas_phy
->identify
))) {
686 printk(MPT2SAS_ERR_FMT
"failure at %s:%d/%s()!\n",
687 ioc
->name
, __FILE__
, __LINE__
, __func__
);
690 phy
->identify
= mpt2sas_phy
->identify
;
691 mpt2sas_phy
->attached_handle
= le16_to_cpu(phy_pg0
.AttachedDevHandle
);
692 if (mpt2sas_phy
->attached_handle
)
693 _transport_set_identify(ioc
, mpt2sas_phy
->attached_handle
,
694 &mpt2sas_phy
->remote_identify
);
695 phy
->identify
.phy_identifier
= mpt2sas_phy
->phy_id
;
696 phy
->negotiated_linkrate
= _transport_convert_phy_link_rate(
697 phy_pg0
.NegotiatedLinkRate
& MPI2_SAS_NEG_LINK_RATE_MASK_PHYSICAL
);
698 phy
->minimum_linkrate_hw
= _transport_convert_phy_link_rate(
699 phy_pg0
.HwLinkRate
& MPI2_SAS_HWRATE_MIN_RATE_MASK
);
700 phy
->maximum_linkrate_hw
= _transport_convert_phy_link_rate(
701 phy_pg0
.HwLinkRate
>> 4);
702 phy
->minimum_linkrate
= _transport_convert_phy_link_rate(
703 phy_pg0
.ProgrammedLinkRate
& MPI2_SAS_PRATE_MIN_RATE_MASK
);
704 phy
->maximum_linkrate
= _transport_convert_phy_link_rate(
705 phy_pg0
.ProgrammedLinkRate
>> 4);
707 if ((sas_phy_add(phy
))) {
708 printk(MPT2SAS_ERR_FMT
"failure at %s:%d/%s()!\n",
709 ioc
->name
, __FILE__
, __LINE__
, __func__
);
713 if ((ioc
->logging_level
& MPT_DEBUG_TRANSPORT
))
714 dev_printk(KERN_INFO
, &phy
->dev
,
715 "add: handle(0x%04x), sas_addr(0x%016llx)\n"
716 "\tattached_handle(0x%04x), sas_addr(0x%016llx)\n",
717 mpt2sas_phy
->handle
, (unsigned long long)
718 mpt2sas_phy
->identify
.sas_address
,
719 mpt2sas_phy
->attached_handle
,
721 mpt2sas_phy
->remote_identify
.sas_address
);
722 mpt2sas_phy
->phy
= phy
;
728 * mpt2sas_transport_add_expander_phy - report expander phy to transport
729 * @ioc: per adapter object
730 * @mpt2sas_phy: mpt2sas per phy object
731 * @expander_pg1: expander page 1
732 * @parent_dev: parent device class object
734 * Returns 0 for success, non-zero for failure.
737 mpt2sas_transport_add_expander_phy(struct MPT2SAS_ADAPTER
*ioc
, struct _sas_phy
738 *mpt2sas_phy
, Mpi2ExpanderPage1_t expander_pg1
, struct device
*parent_dev
)
741 int phy_index
= mpt2sas_phy
->phy_id
;
743 INIT_LIST_HEAD(&mpt2sas_phy
->port_siblings
);
744 phy
= sas_phy_alloc(parent_dev
, phy_index
);
746 printk(MPT2SAS_ERR_FMT
"failure at %s:%d/%s()!\n",
747 ioc
->name
, __FILE__
, __LINE__
, __func__
);
750 if ((_transport_set_identify(ioc
, mpt2sas_phy
->handle
,
751 &mpt2sas_phy
->identify
))) {
752 printk(MPT2SAS_ERR_FMT
"failure at %s:%d/%s()!\n",
753 ioc
->name
, __FILE__
, __LINE__
, __func__
);
756 phy
->identify
= mpt2sas_phy
->identify
;
757 mpt2sas_phy
->attached_handle
=
758 le16_to_cpu(expander_pg1
.AttachedDevHandle
);
759 if (mpt2sas_phy
->attached_handle
)
760 _transport_set_identify(ioc
, mpt2sas_phy
->attached_handle
,
761 &mpt2sas_phy
->remote_identify
);
762 phy
->identify
.phy_identifier
= mpt2sas_phy
->phy_id
;
763 phy
->negotiated_linkrate
= _transport_convert_phy_link_rate(
764 expander_pg1
.NegotiatedLinkRate
&
765 MPI2_SAS_NEG_LINK_RATE_MASK_PHYSICAL
);
766 phy
->minimum_linkrate_hw
= _transport_convert_phy_link_rate(
767 expander_pg1
.HwLinkRate
& MPI2_SAS_HWRATE_MIN_RATE_MASK
);
768 phy
->maximum_linkrate_hw
= _transport_convert_phy_link_rate(
769 expander_pg1
.HwLinkRate
>> 4);
770 phy
->minimum_linkrate
= _transport_convert_phy_link_rate(
771 expander_pg1
.ProgrammedLinkRate
& MPI2_SAS_PRATE_MIN_RATE_MASK
);
772 phy
->maximum_linkrate
= _transport_convert_phy_link_rate(
773 expander_pg1
.ProgrammedLinkRate
>> 4);
775 if ((sas_phy_add(phy
))) {
776 printk(MPT2SAS_ERR_FMT
"failure at %s:%d/%s()!\n",
777 ioc
->name
, __FILE__
, __LINE__
, __func__
);
781 if ((ioc
->logging_level
& MPT_DEBUG_TRANSPORT
))
782 dev_printk(KERN_INFO
, &phy
->dev
,
783 "add: handle(0x%04x), sas_addr(0x%016llx)\n"
784 "\tattached_handle(0x%04x), sas_addr(0x%016llx)\n",
785 mpt2sas_phy
->handle
, (unsigned long long)
786 mpt2sas_phy
->identify
.sas_address
,
787 mpt2sas_phy
->attached_handle
,
789 mpt2sas_phy
->remote_identify
.sas_address
);
790 mpt2sas_phy
->phy
= phy
;
795 * mpt2sas_transport_update_links - refreshing phy link changes
796 * @ioc: per adapter object
797 * @sas_address: sas address of parent expander or sas host
798 * @handle: attached device handle
799 * @phy_numberv: phy number
800 * @link_rate: new link rate
805 mpt2sas_transport_update_links(struct MPT2SAS_ADAPTER
*ioc
,
806 u64 sas_address
, u16 handle
, u8 phy_number
, u8 link_rate
)
809 struct _sas_node
*sas_node
;
810 struct _sas_phy
*mpt2sas_phy
;
812 if (ioc
->shost_recovery
)
815 spin_lock_irqsave(&ioc
->sas_node_lock
, flags
);
816 sas_node
= _transport_sas_node_find_by_sas_address(ioc
, sas_address
);
817 spin_unlock_irqrestore(&ioc
->sas_node_lock
, flags
);
821 mpt2sas_phy
= &sas_node
->phy
[phy_number
];
822 mpt2sas_phy
->attached_handle
= handle
;
823 if (handle
&& (link_rate
>= MPI2_SAS_NEG_LINK_RATE_1_5
))
824 _transport_set_identify(ioc
, handle
,
825 &mpt2sas_phy
->remote_identify
);
827 memset(&mpt2sas_phy
->remote_identify
, 0 , sizeof(struct
830 if (mpt2sas_phy
->phy
)
831 mpt2sas_phy
->phy
->negotiated_linkrate
=
832 _transport_convert_phy_link_rate(link_rate
);
834 if ((ioc
->logging_level
& MPT_DEBUG_TRANSPORT
))
835 dev_printk(KERN_INFO
, &mpt2sas_phy
->phy
->dev
,
836 "refresh: parent sas_addr(0x%016llx),\n"
837 "\tlink_rate(0x%02x), phy(%d)\n"
838 "\tattached_handle(0x%04x), sas_addr(0x%016llx)\n",
839 (unsigned long long)sas_address
,
840 link_rate
, phy_number
, handle
, (unsigned long long)
841 mpt2sas_phy
->remote_identify
.sas_address
);
845 phy_to_ioc(struct sas_phy
*phy
)
847 struct Scsi_Host
*shost
= dev_to_shost(phy
->dev
.parent
);
848 return shost_priv(shost
);
852 rphy_to_ioc(struct sas_rphy
*rphy
)
854 struct Scsi_Host
*shost
= dev_to_shost(rphy
->dev
.parent
->parent
);
855 return shost_priv(shost
);
859 * _transport_get_linkerrors -
860 * @phy: The sas phy object
862 * Only support sas_host direct attached phys.
863 * Returns 0 for success, non-zero for failure.
867 _transport_get_linkerrors(struct sas_phy
*phy
)
869 struct MPT2SAS_ADAPTER
*ioc
= phy_to_ioc(phy
);
870 struct _sas_phy
*mpt2sas_phy
;
871 Mpi2ConfigReply_t mpi_reply
;
872 Mpi2SasPhyPage1_t phy_pg1
;
875 for (i
= 0, mpt2sas_phy
= NULL
; i
< ioc
->sas_hba
.num_phys
&&
877 if (ioc
->sas_hba
.phy
[i
].phy
!= phy
)
879 mpt2sas_phy
= &ioc
->sas_hba
.phy
[i
];
882 if (!mpt2sas_phy
) /* this phy not on sas_host */
885 if ((mpt2sas_config_get_phy_pg1(ioc
, &mpi_reply
, &phy_pg1
,
886 mpt2sas_phy
->phy_id
))) {
887 printk(MPT2SAS_ERR_FMT
"failure at %s:%d/%s()!\n",
888 ioc
->name
, __FILE__
, __LINE__
, __func__
);
892 if (mpi_reply
.IOCStatus
|| mpi_reply
.IOCLogInfo
)
893 printk(MPT2SAS_INFO_FMT
"phy(%d), ioc_status"
894 "(0x%04x), loginfo(0x%08x)\n", ioc
->name
,
896 le16_to_cpu(mpi_reply
.IOCStatus
),
897 le32_to_cpu(mpi_reply
.IOCLogInfo
));
899 phy
->invalid_dword_count
= le32_to_cpu(phy_pg1
.InvalidDwordCount
);
900 phy
->running_disparity_error_count
=
901 le32_to_cpu(phy_pg1
.RunningDisparityErrorCount
);
902 phy
->loss_of_dword_sync_count
=
903 le32_to_cpu(phy_pg1
.LossDwordSynchCount
);
904 phy
->phy_reset_problem_count
=
905 le32_to_cpu(phy_pg1
.PhyResetProblemCount
);
910 * _transport_get_enclosure_identifier -
911 * @phy: The sas phy object
913 * Obtain the enclosure logical id for an expander.
914 * Returns 0 for success, non-zero for failure.
917 _transport_get_enclosure_identifier(struct sas_rphy
*rphy
, u64
*identifier
)
919 struct MPT2SAS_ADAPTER
*ioc
= rphy_to_ioc(rphy
);
920 struct _sas_node
*sas_expander
;
923 spin_lock_irqsave(&ioc
->sas_node_lock
, flags
);
924 sas_expander
= mpt2sas_scsih_expander_find_by_sas_address(ioc
,
925 rphy
->identify
.sas_address
);
926 spin_unlock_irqrestore(&ioc
->sas_node_lock
, flags
);
931 *identifier
= sas_expander
->enclosure_logical_id
;
936 * _transport_get_bay_identifier -
937 * @phy: The sas phy object
939 * Returns the slot id for a device that resides inside an enclosure.
942 _transport_get_bay_identifier(struct sas_rphy
*rphy
)
944 struct MPT2SAS_ADAPTER
*ioc
= rphy_to_ioc(rphy
);
945 struct _sas_device
*sas_device
;
948 spin_lock_irqsave(&ioc
->sas_device_lock
, flags
);
949 sas_device
= mpt2sas_scsih_sas_device_find_by_sas_address(ioc
,
950 rphy
->identify
.sas_address
);
951 spin_unlock_irqrestore(&ioc
->sas_device_lock
, flags
);
956 return sas_device
->slot
;
960 * _transport_phy_reset -
961 * @phy: The sas phy object
964 * Only support sas_host direct attached phys.
965 * Returns 0 for success, non-zero for failure.
968 _transport_phy_reset(struct sas_phy
*phy
, int hard_reset
)
970 struct MPT2SAS_ADAPTER
*ioc
= phy_to_ioc(phy
);
971 struct _sas_phy
*mpt2sas_phy
;
972 Mpi2SasIoUnitControlReply_t mpi_reply
;
973 Mpi2SasIoUnitControlRequest_t mpi_request
;
976 for (i
= 0, mpt2sas_phy
= NULL
; i
< ioc
->sas_hba
.num_phys
&&
978 if (ioc
->sas_hba
.phy
[i
].phy
!= phy
)
980 mpt2sas_phy
= &ioc
->sas_hba
.phy
[i
];
983 if (!mpt2sas_phy
) /* this phy not on sas_host */
986 memset(&mpi_request
, 0, sizeof(Mpi2SasIoUnitControlReply_t
));
987 mpi_request
.Function
= MPI2_FUNCTION_SAS_IO_UNIT_CONTROL
;
988 mpi_request
.Operation
= hard_reset
?
989 MPI2_SAS_OP_PHY_HARD_RESET
: MPI2_SAS_OP_PHY_LINK_RESET
;
990 mpi_request
.PhyNum
= mpt2sas_phy
->phy_id
;
992 if ((mpt2sas_base_sas_iounit_control(ioc
, &mpi_reply
, &mpi_request
))) {
993 printk(MPT2SAS_ERR_FMT
"failure at %s:%d/%s()!\n",
994 ioc
->name
, __FILE__
, __LINE__
, __func__
);
998 if (mpi_reply
.IOCStatus
|| mpi_reply
.IOCLogInfo
)
999 printk(MPT2SAS_INFO_FMT
"phy(%d), ioc_status"
1000 "(0x%04x), loginfo(0x%08x)\n", ioc
->name
,
1001 mpt2sas_phy
->phy_id
,
1002 le16_to_cpu(mpi_reply
.IOCStatus
),
1003 le32_to_cpu(mpi_reply
.IOCLogInfo
));
1009 * _transport_smp_handler - transport portal for smp passthru
1010 * @shost: shost object
1011 * @rphy: sas transport rphy object
1014 * This used primarily for smp_utils.
1016 * smp_rep_general /sys/class/bsg/expander-5:0
1019 _transport_smp_handler(struct Scsi_Host
*shost
, struct sas_rphy
*rphy
,
1020 struct request
*req
)
1022 struct MPT2SAS_ADAPTER
*ioc
= shost_priv(shost
);
1023 Mpi2SmpPassthroughRequest_t
*mpi_request
;
1024 Mpi2SmpPassthroughReply_t
*mpi_reply
;
1028 unsigned long timeleft
;
1032 dma_addr_t dma_addr_in
= 0;
1033 dma_addr_t dma_addr_out
= 0;
1034 u16 wait_state_count
;
1035 struct request
*rsp
= req
->next_rq
;
1038 printk(MPT2SAS_ERR_FMT
"%s: the smp response space is "
1039 "missing\n", ioc
->name
, __func__
);
1043 /* do we need to support multiple segments? */
1044 if (req
->bio
->bi_vcnt
> 1 || rsp
->bio
->bi_vcnt
> 1) {
1045 printk(MPT2SAS_ERR_FMT
"%s: multiple segments req %u %u, "
1046 "rsp %u %u\n", ioc
->name
, __func__
, req
->bio
->bi_vcnt
,
1047 blk_rq_bytes(req
), rsp
->bio
->bi_vcnt
, blk_rq_bytes(rsp
));
1051 if (ioc
->shost_recovery
) {
1052 printk(MPT2SAS_INFO_FMT
"%s: host reset in progress!\n",
1053 __func__
, ioc
->name
);
1057 rc
= mutex_lock_interruptible(&ioc
->transport_cmds
.mutex
);
1061 if (ioc
->transport_cmds
.status
!= MPT2_CMD_NOT_USED
) {
1062 printk(MPT2SAS_ERR_FMT
"%s: transport_cmds in use\n", ioc
->name
,
1067 ioc
->transport_cmds
.status
= MPT2_CMD_PENDING
;
1069 wait_state_count
= 0;
1070 ioc_state
= mpt2sas_base_get_iocstate(ioc
, 1);
1071 while (ioc_state
!= MPI2_IOC_STATE_OPERATIONAL
) {
1072 if (wait_state_count
++ == 10) {
1073 printk(MPT2SAS_ERR_FMT
1074 "%s: failed due to ioc not operational\n",
1075 ioc
->name
, __func__
);
1080 ioc_state
= mpt2sas_base_get_iocstate(ioc
, 1);
1081 printk(MPT2SAS_INFO_FMT
"%s: waiting for "
1082 "operational state(count=%d)\n", ioc
->name
,
1083 __func__
, wait_state_count
);
1085 if (wait_state_count
)
1086 printk(MPT2SAS_INFO_FMT
"%s: ioc is operational\n",
1087 ioc
->name
, __func__
);
1089 smid
= mpt2sas_base_get_smid(ioc
, ioc
->transport_cb_idx
);
1091 printk(MPT2SAS_ERR_FMT
"%s: failed obtaining a smid\n",
1092 ioc
->name
, __func__
);
1098 mpi_request
= mpt2sas_base_get_msg_frame(ioc
, smid
);
1099 ioc
->transport_cmds
.smid
= smid
;
1101 memset(mpi_request
, 0, sizeof(Mpi2SmpPassthroughRequest_t
));
1102 mpi_request
->Function
= MPI2_FUNCTION_SMP_PASSTHROUGH
;
1103 mpi_request
->PhysicalPort
= 0xFF;
1104 mpi_request
->VF_ID
= 0; /* TODO */
1105 mpi_request
->VP_ID
= 0;
1106 *((u64
*)&mpi_request
->SASAddress
) = (rphy
) ?
1107 cpu_to_le64(rphy
->identify
.sas_address
) :
1108 cpu_to_le64(ioc
->sas_hba
.sas_address
);
1109 mpi_request
->RequestDataLength
= cpu_to_le16(blk_rq_bytes(req
) - 4);
1110 psge
= &mpi_request
->SGL
;
1112 /* WRITE sgel first */
1113 sgl_flags
= (MPI2_SGE_FLAGS_SIMPLE_ELEMENT
|
1114 MPI2_SGE_FLAGS_END_OF_BUFFER
| MPI2_SGE_FLAGS_HOST_TO_IOC
);
1115 sgl_flags
= sgl_flags
<< MPI2_SGE_FLAGS_SHIFT
;
1116 dma_addr_out
= pci_map_single(ioc
->pdev
, bio_data(req
->bio
),
1117 blk_rq_bytes(req
), PCI_DMA_BIDIRECTIONAL
);
1118 if (!dma_addr_out
) {
1119 mpt2sas_base_free_smid(ioc
, smid
);
1123 ioc
->base_add_sg_single(psge
, sgl_flags
| (blk_rq_bytes(req
) - 4),
1127 psge
+= ioc
->sge_size
;
1129 /* READ sgel last */
1130 sgl_flags
= (MPI2_SGE_FLAGS_SIMPLE_ELEMENT
|
1131 MPI2_SGE_FLAGS_LAST_ELEMENT
| MPI2_SGE_FLAGS_END_OF_BUFFER
|
1132 MPI2_SGE_FLAGS_END_OF_LIST
);
1133 sgl_flags
= sgl_flags
<< MPI2_SGE_FLAGS_SHIFT
;
1134 dma_addr_in
= pci_map_single(ioc
->pdev
, bio_data(rsp
->bio
),
1135 blk_rq_bytes(rsp
), PCI_DMA_BIDIRECTIONAL
);
1137 mpt2sas_base_free_smid(ioc
, smid
);
1141 ioc
->base_add_sg_single(psge
, sgl_flags
| (blk_rq_bytes(rsp
) + 4),
1144 dtransportprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s - "
1145 "sending smp request\n", ioc
->name
, __func__
));
1147 mpt2sas_base_put_smid_default(ioc
, smid
);
1148 init_completion(&ioc
->transport_cmds
.done
);
1149 timeleft
= wait_for_completion_timeout(&ioc
->transport_cmds
.done
,
1152 if (!(ioc
->transport_cmds
.status
& MPT2_CMD_COMPLETE
)) {
1153 printk(MPT2SAS_ERR_FMT
"%s : timeout\n",
1154 __func__
, ioc
->name
);
1155 _debug_dump_mf(mpi_request
,
1156 sizeof(Mpi2SmpPassthroughRequest_t
)/4);
1157 if (!(ioc
->transport_cmds
.status
& MPT2_CMD_RESET
))
1159 goto issue_host_reset
;
1162 dtransportprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
"%s - "
1163 "complete\n", ioc
->name
, __func__
));
1165 if (ioc
->transport_cmds
.status
& MPT2_CMD_REPLY_VALID
) {
1167 mpi_reply
= ioc
->transport_cmds
.reply
;
1169 dtransportprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
1170 "%s - reply data transfer size(%d)\n",
1171 ioc
->name
, __func__
,
1172 le16_to_cpu(mpi_reply
->ResponseDataLength
)));
1174 memcpy(req
->sense
, mpi_reply
, sizeof(*mpi_reply
));
1175 req
->sense_len
= sizeof(*mpi_reply
);
1177 rsp
->resid_len
-= mpi_reply
->ResponseDataLength
;
1179 dtransportprintk(ioc
, printk(MPT2SAS_DEBUG_FMT
1180 "%s - no reply\n", ioc
->name
, __func__
));
1186 mpt2sas_base_hard_reset_handler(ioc
, CAN_SLEEP
,
1193 pci_unmap_single(ioc
->pdev
, dma_addr_out
, blk_rq_bytes(req
),
1194 PCI_DMA_BIDIRECTIONAL
);
1196 pci_unmap_single(ioc
->pdev
, dma_addr_in
, blk_rq_bytes(rsp
),
1197 PCI_DMA_BIDIRECTIONAL
);
1200 ioc
->transport_cmds
.status
= MPT2_CMD_NOT_USED
;
1201 mutex_unlock(&ioc
->transport_cmds
.mutex
);
1205 struct sas_function_template mpt2sas_transport_functions
= {
1206 .get_linkerrors
= _transport_get_linkerrors
,
1207 .get_enclosure_identifier
= _transport_get_enclosure_identifier
,
1208 .get_bay_identifier
= _transport_get_bay_identifier
,
1209 .phy_reset
= _transport_phy_reset
,
1210 .smp_handler
= _transport_smp_handler
,
1213 struct scsi_transport_template
*mpt2sas_transport_template
;