1 /*
2  * SAS Transport Layer for MPT (Message Passing Technology) based controllers
3  *
4  * This code is based on drivers/scsi/mpt3sas/mpt3sas_transport.c
5  * Copyright (C) 2012-2014  LSI Corporation
6  * Copyright (C) 2013-2014 Avago Technologies
7  *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version 2
12  * of the License, or (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * NO WARRANTY
20  * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
21  * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
22  * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
23  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
24  * solely responsible for determining the appropriateness of using and
25  * distributing the Program and assumes all risks associated with its
26  * exercise of rights under this Agreement, including but not limited to
27  * the risks and costs of program errors, damage to or loss of data,
28  * programs or equipment, and unavailability or interruption of operations.
29 
30  * DISCLAIMER OF LIABILITY
31  * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
32  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33  * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
34  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
35  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
36  * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
37  * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
38 
39  * You should have received a copy of the GNU General Public License
40  * along with this program; if not, write to the Free Software
41  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
42  * USA.
43  */
44 
45 #include <linux/module.h>
46 #include <linux/kernel.h>
47 #include <linux/init.h>
48 #include <linux/errno.h>
49 #include <linux/sched.h>
50 #include <linux/workqueue.h>
51 #include <linux/delay.h>
52 #include <linux/pci.h>
53 
54 #include <scsi/scsi.h>
55 #include <scsi/scsi_cmnd.h>
56 #include <scsi/scsi_device.h>
57 #include <scsi/scsi_host.h>
58 #include <scsi/scsi_transport_sas.h>
59 #include <scsi/scsi_dbg.h>
60 
61 #include "mpt3sas_base.h"
62 
63 /**
64  * _transport_sas_node_find_by_sas_address - sas node search
65  * @ioc: per adapter object
66  * @sas_address: sas address of expander or sas host
67  * Context: Calling function should acquire ioc->sas_node_lock.
68  *
69  * Search for either hba phys or expander device based on handle, then returns
70  * the sas_node object.
71  */
72 static struct _sas_node *
73 _transport_sas_node_find_by_sas_address(struct MPT3SAS_ADAPTER *ioc,
74 	u64 sas_address)
75 {
76 	if (ioc->sas_hba.sas_address == sas_address)
77 		return &ioc->sas_hba;
78 	else
79 		return mpt3sas_scsih_expander_find_by_sas_address(ioc,
80 		    sas_address);
81 }
82 
83 /**
84  * _transport_convert_phy_link_rate -
85  * @link_rate: link rate returned from mpt firmware
86  *
87  * Convert link_rate from mpi fusion into sas_transport form.
88  */
89 static enum sas_linkrate
90 _transport_convert_phy_link_rate(u8 link_rate)
91 {
92 	enum sas_linkrate rc;
93 
94 	switch (link_rate) {
95 	case MPI2_SAS_NEG_LINK_RATE_1_5:
96 		rc = SAS_LINK_RATE_1_5_GBPS;
97 		break;
98 	case MPI2_SAS_NEG_LINK_RATE_3_0:
99 		rc = SAS_LINK_RATE_3_0_GBPS;
100 		break;
101 	case MPI2_SAS_NEG_LINK_RATE_6_0:
102 		rc = SAS_LINK_RATE_6_0_GBPS;
103 		break;
104 	case MPI25_SAS_NEG_LINK_RATE_12_0:
105 		rc = SAS_LINK_RATE_12_0_GBPS;
106 		break;
107 	case MPI2_SAS_NEG_LINK_RATE_PHY_DISABLED:
108 		rc = SAS_PHY_DISABLED;
109 		break;
110 	case MPI2_SAS_NEG_LINK_RATE_NEGOTIATION_FAILED:
111 		rc = SAS_LINK_RATE_FAILED;
112 		break;
113 	case MPI2_SAS_NEG_LINK_RATE_PORT_SELECTOR:
114 		rc = SAS_SATA_PORT_SELECTOR;
115 		break;
116 	case MPI2_SAS_NEG_LINK_RATE_SMP_RESET_IN_PROGRESS:
117 		rc = SAS_PHY_RESET_IN_PROGRESS;
118 		break;
119 
120 	default:
121 	case MPI2_SAS_NEG_LINK_RATE_SATA_OOB_COMPLETE:
122 	case MPI2_SAS_NEG_LINK_RATE_UNKNOWN_LINK_RATE:
123 		rc = SAS_LINK_RATE_UNKNOWN;
124 		break;
125 	}
126 	return rc;
127 }
128 
129 /**
130  * _transport_set_identify - set identify for phys and end devices
131  * @ioc: per adapter object
132  * @handle: device handle
133  * @identify: sas identify info
134  *
135  * Populates sas identify info.
136  *
137  * Returns 0 for success, non-zero for failure.
138  */
139 static int
140 _transport_set_identify(struct MPT3SAS_ADAPTER *ioc, u16 handle,
141 	struct sas_identify *identify)
142 {
143 	Mpi2SasDevicePage0_t sas_device_pg0;
144 	Mpi2ConfigReply_t mpi_reply;
145 	u32 device_info;
146 	u32 ioc_status;
147 
148 	if (ioc->shost_recovery || ioc->pci_error_recovery) {
149 		pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
150 		    __func__, ioc->name);
151 		return -EFAULT;
152 	}
153 
154 	if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
155 	    MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
156 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
157 		    ioc->name, __FILE__, __LINE__, __func__);
158 		return -ENXIO;
159 	}
160 
161 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
162 	    MPI2_IOCSTATUS_MASK;
163 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
164 		pr_err(MPT3SAS_FMT
165 			"handle(0x%04x), ioc_status(0x%04x)\nfailure at %s:%d/%s()!\n",
166 			ioc->name, handle, ioc_status,
167 		     __FILE__, __LINE__, __func__);
168 		return -EIO;
169 	}
170 
171 	memset(identify, 0, sizeof(struct sas_identify));
172 	device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
173 
174 	/* sas_address */
175 	identify->sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
176 
177 	/* phy number of the parent device this device is linked to */
178 	identify->phy_identifier = sas_device_pg0.PhyNum;
179 
180 	/* device_type */
181 	switch (device_info & MPI2_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
182 	case MPI2_SAS_DEVICE_INFO_NO_DEVICE:
183 		identify->device_type = SAS_PHY_UNUSED;
184 		break;
185 	case MPI2_SAS_DEVICE_INFO_END_DEVICE:
186 		identify->device_type = SAS_END_DEVICE;
187 		break;
188 	case MPI2_SAS_DEVICE_INFO_EDGE_EXPANDER:
189 		identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
190 		break;
191 	case MPI2_SAS_DEVICE_INFO_FANOUT_EXPANDER:
192 		identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
193 		break;
194 	}
195 
196 	/* initiator_port_protocols */
197 	if (device_info & MPI2_SAS_DEVICE_INFO_SSP_INITIATOR)
198 		identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
199 	if (device_info & MPI2_SAS_DEVICE_INFO_STP_INITIATOR)
200 		identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
201 	if (device_info & MPI2_SAS_DEVICE_INFO_SMP_INITIATOR)
202 		identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
203 	if (device_info & MPI2_SAS_DEVICE_INFO_SATA_HOST)
204 		identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
205 
206 	/* target_port_protocols */
207 	if (device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET)
208 		identify->target_port_protocols |= SAS_PROTOCOL_SSP;
209 	if (device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET)
210 		identify->target_port_protocols |= SAS_PROTOCOL_STP;
211 	if (device_info & MPI2_SAS_DEVICE_INFO_SMP_TARGET)
212 		identify->target_port_protocols |= SAS_PROTOCOL_SMP;
213 	if (device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
214 		identify->target_port_protocols |= SAS_PROTOCOL_SATA;
215 
216 	return 0;
217 }
218 
219 /**
220  * mpt3sas_transport_done -  internal transport layer callback handler.
221  * @ioc: per adapter object
222  * @smid: system request message index
223  * @msix_index: MSIX table index supplied by the OS
224  * @reply: reply message frame(lower 32bit addr)
225  *
226  * Callback handler when sending internal generated transport cmds.
227  * The callback index passed is `ioc->transport_cb_idx`
228  *
229  * Return 1 meaning mf should be freed from _base_interrupt
230  *        0 means the mf is freed from this function.
231  */
232 u8
233 mpt3sas_transport_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
234 	u32 reply)
235 {
236 	MPI2DefaultReply_t *mpi_reply;
237 
238 	mpi_reply =  mpt3sas_base_get_reply_virt_addr(ioc, reply);
239 	if (ioc->transport_cmds.status == MPT3_CMD_NOT_USED)
240 		return 1;
241 	if (ioc->transport_cmds.smid != smid)
242 		return 1;
243 	ioc->transport_cmds.status |= MPT3_CMD_COMPLETE;
244 	if (mpi_reply) {
245 		memcpy(ioc->transport_cmds.reply, mpi_reply,
246 		    mpi_reply->MsgLength*4);
247 		ioc->transport_cmds.status |= MPT3_CMD_REPLY_VALID;
248 	}
249 	ioc->transport_cmds.status &= ~MPT3_CMD_PENDING;
250 	complete(&ioc->transport_cmds.done);
251 	return 1;
252 }
253 
254 /* report manufacture request structure */
255 struct rep_manu_request {
256 	u8 smp_frame_type;
257 	u8 function;
258 	u8 reserved;
259 	u8 request_length;
260 };
261 
262 /* report manufacture reply structure */
263 struct rep_manu_reply {
264 	u8 smp_frame_type; /* 0x41 */
265 	u8 function; /* 0x01 */
266 	u8 function_result;
267 	u8 response_length;
268 	u16 expander_change_count;
269 	u8 reserved0[2];
270 	u8 sas_format;
271 	u8 reserved2[3];
272 	u8 vendor_id[SAS_EXPANDER_VENDOR_ID_LEN];
273 	u8 product_id[SAS_EXPANDER_PRODUCT_ID_LEN];
274 	u8 product_rev[SAS_EXPANDER_PRODUCT_REV_LEN];
275 	u8 component_vendor_id[SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN];
276 	u16 component_id;
277 	u8 component_revision_id;
278 	u8 reserved3;
279 	u8 vendor_specific[8];
280 };
281 
282 /**
283  * transport_expander_report_manufacture - obtain SMP report_manufacture
284  * @ioc: per adapter object
285  * @sas_address: expander sas address
286  * @edev: the sas_expander_device object
287  *
288  * Fills in the sas_expander_device object when SMP port is created.
289  *
290  * Returns 0 for success, non-zero for failure.
291  */
292 static int
293 _transport_expander_report_manufacture(struct MPT3SAS_ADAPTER *ioc,
294 	u64 sas_address, struct sas_expander_device *edev)
295 {
296 	Mpi2SmpPassthroughRequest_t *mpi_request;
297 	Mpi2SmpPassthroughReply_t *mpi_reply;
298 	struct rep_manu_reply *manufacture_reply;
299 	struct rep_manu_request *manufacture_request;
300 	int rc;
301 	u16 smid;
302 	u32 ioc_state;
303 	unsigned long timeleft;
304 	void *psge;
305 	u8 issue_reset = 0;
306 	void *data_out = NULL;
307 	dma_addr_t data_out_dma;
308 	dma_addr_t data_in_dma;
309 	size_t data_in_sz;
310 	size_t data_out_sz;
311 	u16 wait_state_count;
312 
313 	if (ioc->shost_recovery || ioc->pci_error_recovery) {
314 		pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
315 		    __func__, ioc->name);
316 		return -EFAULT;
317 	}
318 
319 	mutex_lock(&ioc->transport_cmds.mutex);
320 
321 	if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
322 		pr_err(MPT3SAS_FMT "%s: transport_cmds in use\n",
323 		    ioc->name, __func__);
324 		rc = -EAGAIN;
325 		goto out;
326 	}
327 	ioc->transport_cmds.status = MPT3_CMD_PENDING;
328 
329 	wait_state_count = 0;
330 	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
331 	while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
332 		if (wait_state_count++ == 10) {
333 			pr_err(MPT3SAS_FMT
334 			    "%s: failed due to ioc not operational\n",
335 			    ioc->name, __func__);
336 			rc = -EFAULT;
337 			goto out;
338 		}
339 		ssleep(1);
340 		ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
341 		pr_info(MPT3SAS_FMT
342 			"%s: waiting for operational state(count=%d)\n",
343 			ioc->name, __func__, wait_state_count);
344 	}
345 	if (wait_state_count)
346 		pr_info(MPT3SAS_FMT "%s: ioc is operational\n",
347 		    ioc->name, __func__);
348 
349 	smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
350 	if (!smid) {
351 		pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
352 		    ioc->name, __func__);
353 		rc = -EAGAIN;
354 		goto out;
355 	}
356 
357 	rc = 0;
358 	mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
359 	ioc->transport_cmds.smid = smid;
360 
361 	data_out_sz = sizeof(struct rep_manu_request);
362 	data_in_sz = sizeof(struct rep_manu_reply);
363 	data_out = pci_alloc_consistent(ioc->pdev, data_out_sz + data_in_sz,
364 	    &data_out_dma);
365 
366 	if (!data_out) {
367 		pr_err("failure at %s:%d/%s()!\n", __FILE__,
368 		    __LINE__, __func__);
369 		rc = -ENOMEM;
370 		mpt3sas_base_free_smid(ioc, smid);
371 		goto out;
372 	}
373 
374 	data_in_dma = data_out_dma + sizeof(struct rep_manu_request);
375 
376 	manufacture_request = data_out;
377 	manufacture_request->smp_frame_type = 0x40;
378 	manufacture_request->function = 1;
379 	manufacture_request->reserved = 0;
380 	manufacture_request->request_length = 0;
381 
382 	memset(mpi_request, 0, sizeof(Mpi2SmpPassthroughRequest_t));
383 	mpi_request->Function = MPI2_FUNCTION_SMP_PASSTHROUGH;
384 	mpi_request->PhysicalPort = 0xFF;
385 	mpi_request->SASAddress = cpu_to_le64(sas_address);
386 	mpi_request->RequestDataLength = cpu_to_le16(data_out_sz);
387 	psge = &mpi_request->SGL;
388 
389 	ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma,
390 	    data_in_sz);
391 
392 	dtransportprintk(ioc, pr_info(MPT3SAS_FMT
393 		"report_manufacture - send to sas_addr(0x%016llx)\n",
394 		ioc->name, (unsigned long long)sas_address));
395 	init_completion(&ioc->transport_cmds.done);
396 	mpt3sas_base_put_smid_default(ioc, smid);
397 	timeleft = wait_for_completion_timeout(&ioc->transport_cmds.done,
398 	    10*HZ);
399 
400 	if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
401 		pr_err(MPT3SAS_FMT "%s: timeout\n",
402 		    ioc->name, __func__);
403 		_debug_dump_mf(mpi_request,
404 		    sizeof(Mpi2SmpPassthroughRequest_t)/4);
405 		if (!(ioc->transport_cmds.status & MPT3_CMD_RESET))
406 			issue_reset = 1;
407 		goto issue_host_reset;
408 	}
409 
410 	dtransportprintk(ioc, pr_info(MPT3SAS_FMT
411 		"report_manufacture - complete\n", ioc->name));
412 
413 	if (ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID) {
414 		u8 *tmp;
415 
416 		mpi_reply = ioc->transport_cmds.reply;
417 
418 		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
419 		    "report_manufacture - reply data transfer size(%d)\n",
420 		    ioc->name, le16_to_cpu(mpi_reply->ResponseDataLength)));
421 
422 		if (le16_to_cpu(mpi_reply->ResponseDataLength) !=
423 		    sizeof(struct rep_manu_reply))
424 			goto out;
425 
426 		manufacture_reply = data_out + sizeof(struct rep_manu_request);
427 		strncpy(edev->vendor_id, manufacture_reply->vendor_id,
428 		     SAS_EXPANDER_VENDOR_ID_LEN);
429 		strncpy(edev->product_id, manufacture_reply->product_id,
430 		     SAS_EXPANDER_PRODUCT_ID_LEN);
431 		strncpy(edev->product_rev, manufacture_reply->product_rev,
432 		     SAS_EXPANDER_PRODUCT_REV_LEN);
433 		edev->level = manufacture_reply->sas_format & 1;
434 		if (edev->level) {
435 			strncpy(edev->component_vendor_id,
436 			    manufacture_reply->component_vendor_id,
437 			     SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN);
438 			tmp = (u8 *)&manufacture_reply->component_id;
439 			edev->component_id = tmp[0] << 8 | tmp[1];
440 			edev->component_revision_id =
441 			    manufacture_reply->component_revision_id;
442 		}
443 	} else
444 		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
445 		    "report_manufacture - no reply\n", ioc->name));
446 
447  issue_host_reset:
448 	if (issue_reset)
449 		mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
450 		    FORCE_BIG_HAMMER);
451  out:
452 	ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
453 	if (data_out)
454 		pci_free_consistent(ioc->pdev, data_out_sz + data_in_sz,
455 		    data_out, data_out_dma);
456 
457 	mutex_unlock(&ioc->transport_cmds.mutex);
458 	return rc;
459 }
460 
461 
462 /**
463  * _transport_delete_port - helper function to removing a port
464  * @ioc: per adapter object
465  * @mpt3sas_port: mpt3sas per port object
466  *
467  * Returns nothing.
468  */
469 static void
470 _transport_delete_port(struct MPT3SAS_ADAPTER *ioc,
471 	struct _sas_port *mpt3sas_port)
472 {
473 	u64 sas_address = mpt3sas_port->remote_identify.sas_address;
474 	enum sas_device_type device_type =
475 	    mpt3sas_port->remote_identify.device_type;
476 
477 	dev_printk(KERN_INFO, &mpt3sas_port->port->dev,
478 	    "remove: sas_addr(0x%016llx)\n",
479 	    (unsigned long long) sas_address);
480 
481 	ioc->logging_level |= MPT_DEBUG_TRANSPORT;
482 	if (device_type == SAS_END_DEVICE)
483 		mpt3sas_device_remove_by_sas_address(ioc, sas_address);
484 	else if (device_type == SAS_EDGE_EXPANDER_DEVICE ||
485 	    device_type == SAS_FANOUT_EXPANDER_DEVICE)
486 		mpt3sas_expander_remove(ioc, sas_address);
487 	ioc->logging_level &= ~MPT_DEBUG_TRANSPORT;
488 }
489 
490 /**
491  * _transport_delete_phy - helper function to removing single phy from port
492  * @ioc: per adapter object
493  * @mpt3sas_port: mpt3sas per port object
494  * @mpt3sas_phy: mpt3sas per phy object
495  *
496  * Returns nothing.
497  */
498 static void
499 _transport_delete_phy(struct MPT3SAS_ADAPTER *ioc,
500 	struct _sas_port *mpt3sas_port, struct _sas_phy *mpt3sas_phy)
501 {
502 	u64 sas_address = mpt3sas_port->remote_identify.sas_address;
503 
504 	dev_printk(KERN_INFO, &mpt3sas_phy->phy->dev,
505 	    "remove: sas_addr(0x%016llx), phy(%d)\n",
506 	    (unsigned long long) sas_address, mpt3sas_phy->phy_id);
507 
508 	list_del(&mpt3sas_phy->port_siblings);
509 	mpt3sas_port->num_phys--;
510 	sas_port_delete_phy(mpt3sas_port->port, mpt3sas_phy->phy);
511 	mpt3sas_phy->phy_belongs_to_port = 0;
512 }
513 
514 /**
515  * _transport_add_phy - helper function to adding single phy to port
516  * @ioc: per adapter object
517  * @mpt3sas_port: mpt3sas per port object
518  * @mpt3sas_phy: mpt3sas per phy object
519  *
520  * Returns nothing.
521  */
522 static void
523 _transport_add_phy(struct MPT3SAS_ADAPTER *ioc, struct _sas_port *mpt3sas_port,
524 	struct _sas_phy *mpt3sas_phy)
525 {
526 	u64 sas_address = mpt3sas_port->remote_identify.sas_address;
527 
528 	dev_printk(KERN_INFO, &mpt3sas_phy->phy->dev,
529 	    "add: sas_addr(0x%016llx), phy(%d)\n", (unsigned long long)
530 	    sas_address, mpt3sas_phy->phy_id);
531 
532 	list_add_tail(&mpt3sas_phy->port_siblings, &mpt3sas_port->phy_list);
533 	mpt3sas_port->num_phys++;
534 	sas_port_add_phy(mpt3sas_port->port, mpt3sas_phy->phy);
535 	mpt3sas_phy->phy_belongs_to_port = 1;
536 }
537 
538 /**
539  * _transport_add_phy_to_an_existing_port - adding new phy to existing port
540  * @ioc: per adapter object
541  * @sas_node: sas node object (either expander or sas host)
542  * @mpt3sas_phy: mpt3sas per phy object
543  * @sas_address: sas address of device/expander were phy needs to be added to
544  *
545  * Returns nothing.
546  */
547 static void
548 _transport_add_phy_to_an_existing_port(struct MPT3SAS_ADAPTER *ioc,
549 	struct _sas_node *sas_node, struct _sas_phy *mpt3sas_phy,
550 	u64 sas_address)
551 {
552 	struct _sas_port *mpt3sas_port;
553 	struct _sas_phy *phy_srch;
554 
555 	if (mpt3sas_phy->phy_belongs_to_port == 1)
556 		return;
557 
558 	list_for_each_entry(mpt3sas_port, &sas_node->sas_port_list,
559 	    port_list) {
560 		if (mpt3sas_port->remote_identify.sas_address !=
561 		    sas_address)
562 			continue;
563 		list_for_each_entry(phy_srch, &mpt3sas_port->phy_list,
564 		    port_siblings) {
565 			if (phy_srch == mpt3sas_phy)
566 				return;
567 		}
568 		_transport_add_phy(ioc, mpt3sas_port, mpt3sas_phy);
569 			return;
570 	}
571 
572 }
573 
574 /**
575  * _transport_del_phy_from_an_existing_port - delete phy from existing port
576  * @ioc: per adapter object
577  * @sas_node: sas node object (either expander or sas host)
578  * @mpt3sas_phy: mpt3sas per phy object
579  *
580  * Returns nothing.
581  */
582 static void
583 _transport_del_phy_from_an_existing_port(struct MPT3SAS_ADAPTER *ioc,
584 	struct _sas_node *sas_node, struct _sas_phy *mpt3sas_phy)
585 {
586 	struct _sas_port *mpt3sas_port, *next;
587 	struct _sas_phy *phy_srch;
588 
589 	if (mpt3sas_phy->phy_belongs_to_port == 0)
590 		return;
591 
592 	list_for_each_entry_safe(mpt3sas_port, next, &sas_node->sas_port_list,
593 	    port_list) {
594 		list_for_each_entry(phy_srch, &mpt3sas_port->phy_list,
595 		    port_siblings) {
596 			if (phy_srch != mpt3sas_phy)
597 				continue;
598 
599 			if (mpt3sas_port->num_phys == 1)
600 				_transport_delete_port(ioc, mpt3sas_port);
601 			else
602 				_transport_delete_phy(ioc, mpt3sas_port,
603 				    mpt3sas_phy);
604 			return;
605 		}
606 	}
607 }
608 
609 /**
610  * _transport_sanity_check - sanity check when adding a new port
611  * @ioc: per adapter object
612  * @sas_node: sas node object (either expander or sas host)
613  * @sas_address: sas address of device being added
614  *
615  * See the explanation above from _transport_delete_duplicate_port
616  */
617 static void
618 _transport_sanity_check(struct MPT3SAS_ADAPTER *ioc, struct _sas_node *sas_node,
619 	u64 sas_address)
620 {
621 	int i;
622 
623 	for (i = 0; i < sas_node->num_phys; i++) {
624 		if (sas_node->phy[i].remote_identify.sas_address != sas_address)
625 			continue;
626 		if (sas_node->phy[i].phy_belongs_to_port == 1)
627 			_transport_del_phy_from_an_existing_port(ioc, sas_node,
628 			    &sas_node->phy[i]);
629 	}
630 }
631 
632 /**
633  * mpt3sas_transport_port_add - insert port to the list
634  * @ioc: per adapter object
635  * @handle: handle of attached device
636  * @sas_address: sas address of parent expander or sas host
637  * Context: This function will acquire ioc->sas_node_lock.
638  *
639  * Adding new port object to the sas_node->sas_port_list.
640  *
641  * Returns mpt3sas_port.
642  */
643 struct _sas_port *
644 mpt3sas_transport_port_add(struct MPT3SAS_ADAPTER *ioc, u16 handle,
645 	u64 sas_address)
646 {
647 	struct _sas_phy *mpt3sas_phy, *next;
648 	struct _sas_port *mpt3sas_port;
649 	unsigned long flags;
650 	struct _sas_node *sas_node;
651 	struct sas_rphy *rphy;
652 	struct _sas_device *sas_device = NULL;
653 	int i;
654 	struct sas_port *port;
655 
656 	mpt3sas_port = kzalloc(sizeof(struct _sas_port),
657 	    GFP_KERNEL);
658 	if (!mpt3sas_port) {
659 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
660 		    ioc->name, __FILE__, __LINE__, __func__);
661 		return NULL;
662 	}
663 
664 	INIT_LIST_HEAD(&mpt3sas_port->port_list);
665 	INIT_LIST_HEAD(&mpt3sas_port->phy_list);
666 	spin_lock_irqsave(&ioc->sas_node_lock, flags);
667 	sas_node = _transport_sas_node_find_by_sas_address(ioc, sas_address);
668 	spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
669 
670 	if (!sas_node) {
671 		pr_err(MPT3SAS_FMT
672 			"%s: Could not find parent sas_address(0x%016llx)!\n",
673 			ioc->name, __func__, (unsigned long long)sas_address);
674 		goto out_fail;
675 	}
676 
677 	if ((_transport_set_identify(ioc, handle,
678 	    &mpt3sas_port->remote_identify))) {
679 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
680 		    ioc->name, __FILE__, __LINE__, __func__);
681 		goto out_fail;
682 	}
683 
684 	if (mpt3sas_port->remote_identify.device_type == SAS_PHY_UNUSED) {
685 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
686 		    ioc->name, __FILE__, __LINE__, __func__);
687 		goto out_fail;
688 	}
689 
690 	_transport_sanity_check(ioc, sas_node,
691 	    mpt3sas_port->remote_identify.sas_address);
692 
693 	for (i = 0; i < sas_node->num_phys; i++) {
694 		if (sas_node->phy[i].remote_identify.sas_address !=
695 		    mpt3sas_port->remote_identify.sas_address)
696 			continue;
697 		list_add_tail(&sas_node->phy[i].port_siblings,
698 		    &mpt3sas_port->phy_list);
699 		mpt3sas_port->num_phys++;
700 	}
701 
702 	if (!mpt3sas_port->num_phys) {
703 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
704 		    ioc->name, __FILE__, __LINE__, __func__);
705 		goto out_fail;
706 	}
707 
708 	port = sas_port_alloc_num(sas_node->parent_dev);
709 	if ((sas_port_add(port))) {
710 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
711 		    ioc->name, __FILE__, __LINE__, __func__);
712 		goto out_fail;
713 	}
714 
715 	list_for_each_entry(mpt3sas_phy, &mpt3sas_port->phy_list,
716 	    port_siblings) {
717 		if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
718 			dev_printk(KERN_INFO, &port->dev,
719 				"add: handle(0x%04x), sas_addr(0x%016llx), phy(%d)\n",
720 				handle, (unsigned long long)
721 			    mpt3sas_port->remote_identify.sas_address,
722 			    mpt3sas_phy->phy_id);
723 		sas_port_add_phy(port, mpt3sas_phy->phy);
724 		mpt3sas_phy->phy_belongs_to_port = 1;
725 	}
726 
727 	mpt3sas_port->port = port;
728 	if (mpt3sas_port->remote_identify.device_type == SAS_END_DEVICE)
729 		rphy = sas_end_device_alloc(port);
730 	else
731 		rphy = sas_expander_alloc(port,
732 		    mpt3sas_port->remote_identify.device_type);
733 
734 	rphy->identify = mpt3sas_port->remote_identify;
735 
736 	if (mpt3sas_port->remote_identify.device_type == SAS_END_DEVICE) {
737 		sas_device = mpt3sas_get_sdev_by_addr(ioc,
738 				    mpt3sas_port->remote_identify.sas_address);
739 		if (!sas_device) {
740 			dfailprintk(ioc, printk(MPT3SAS_FMT
741 				"failure at %s:%d/%s()!\n",
742 				ioc->name, __FILE__, __LINE__, __func__));
743 			goto out_fail;
744 		}
745 		sas_device->pend_sas_rphy_add = 1;
746 	}
747 
748 	if ((sas_rphy_add(rphy))) {
749 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
750 		    ioc->name, __FILE__, __LINE__, __func__);
751 	}
752 
753 	if (mpt3sas_port->remote_identify.device_type == SAS_END_DEVICE) {
754 		sas_device->pend_sas_rphy_add = 0;
755 		sas_device_put(sas_device);
756 	}
757 
758 	if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
759 		dev_printk(KERN_INFO, &rphy->dev,
760 			"add: handle(0x%04x), sas_addr(0x%016llx)\n",
761 			handle, (unsigned long long)
762 		    mpt3sas_port->remote_identify.sas_address);
763 	mpt3sas_port->rphy = rphy;
764 	spin_lock_irqsave(&ioc->sas_node_lock, flags);
765 	list_add_tail(&mpt3sas_port->port_list, &sas_node->sas_port_list);
766 	spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
767 
768 	/* fill in report manufacture */
769 	if (mpt3sas_port->remote_identify.device_type ==
770 	    MPI2_SAS_DEVICE_INFO_EDGE_EXPANDER ||
771 	    mpt3sas_port->remote_identify.device_type ==
772 	    MPI2_SAS_DEVICE_INFO_FANOUT_EXPANDER)
773 		_transport_expander_report_manufacture(ioc,
774 		    mpt3sas_port->remote_identify.sas_address,
775 		    rphy_to_expander_device(rphy));
776 	return mpt3sas_port;
777 
778  out_fail:
779 	list_for_each_entry_safe(mpt3sas_phy, next, &mpt3sas_port->phy_list,
780 	    port_siblings)
781 		list_del(&mpt3sas_phy->port_siblings);
782 	kfree(mpt3sas_port);
783 	return NULL;
784 }
785 
786 /**
787  * mpt3sas_transport_port_remove - remove port from the list
788  * @ioc: per adapter object
789  * @sas_address: sas address of attached device
790  * @sas_address_parent: sas address of parent expander or sas host
791  * Context: This function will acquire ioc->sas_node_lock.
792  *
793  * Removing object and freeing associated memory from the
794  * ioc->sas_port_list.
795  *
796  * Return nothing.
797  */
798 void
799 mpt3sas_transport_port_remove(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
800 	u64 sas_address_parent)
801 {
802 	int i;
803 	unsigned long flags;
804 	struct _sas_port *mpt3sas_port, *next;
805 	struct _sas_node *sas_node;
806 	u8 found = 0;
807 	struct _sas_phy *mpt3sas_phy, *next_phy;
808 
809 	spin_lock_irqsave(&ioc->sas_node_lock, flags);
810 	sas_node = _transport_sas_node_find_by_sas_address(ioc,
811 	    sas_address_parent);
812 	if (!sas_node) {
813 		spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
814 		return;
815 	}
816 	list_for_each_entry_safe(mpt3sas_port, next, &sas_node->sas_port_list,
817 	    port_list) {
818 		if (mpt3sas_port->remote_identify.sas_address != sas_address)
819 			continue;
820 		found = 1;
821 		list_del(&mpt3sas_port->port_list);
822 		goto out;
823 	}
824  out:
825 	if (!found) {
826 		spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
827 		return;
828 	}
829 
830 	for (i = 0; i < sas_node->num_phys; i++) {
831 		if (sas_node->phy[i].remote_identify.sas_address == sas_address)
832 			memset(&sas_node->phy[i].remote_identify, 0 ,
833 			    sizeof(struct sas_identify));
834 	}
835 
836 	spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
837 
838 	list_for_each_entry_safe(mpt3sas_phy, next_phy,
839 	    &mpt3sas_port->phy_list, port_siblings) {
840 		if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
841 			dev_printk(KERN_INFO, &mpt3sas_port->port->dev,
842 			    "remove: sas_addr(0x%016llx), phy(%d)\n",
843 			    (unsigned long long)
844 			    mpt3sas_port->remote_identify.sas_address,
845 			    mpt3sas_phy->phy_id);
846 		mpt3sas_phy->phy_belongs_to_port = 0;
847 		sas_port_delete_phy(mpt3sas_port->port, mpt3sas_phy->phy);
848 		list_del(&mpt3sas_phy->port_siblings);
849 	}
850 	sas_port_delete(mpt3sas_port->port);
851 	kfree(mpt3sas_port);
852 }
853 
854 /**
855  * mpt3sas_transport_add_host_phy - report sas_host phy to transport
856  * @ioc: per adapter object
857  * @mpt3sas_phy: mpt3sas per phy object
858  * @phy_pg0: sas phy page 0
859  * @parent_dev: parent device class object
860  *
861  * Returns 0 for success, non-zero for failure.
862  */
863 int
864 mpt3sas_transport_add_host_phy(struct MPT3SAS_ADAPTER *ioc, struct _sas_phy
865 	*mpt3sas_phy, Mpi2SasPhyPage0_t phy_pg0, struct device *parent_dev)
866 {
867 	struct sas_phy *phy;
868 	int phy_index = mpt3sas_phy->phy_id;
869 
870 
871 	INIT_LIST_HEAD(&mpt3sas_phy->port_siblings);
872 	phy = sas_phy_alloc(parent_dev, phy_index);
873 	if (!phy) {
874 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
875 		    ioc->name, __FILE__, __LINE__, __func__);
876 		return -1;
877 	}
878 	if ((_transport_set_identify(ioc, mpt3sas_phy->handle,
879 	    &mpt3sas_phy->identify))) {
880 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
881 		    ioc->name, __FILE__, __LINE__, __func__);
882 		sas_phy_free(phy);
883 		return -1;
884 	}
885 	phy->identify = mpt3sas_phy->identify;
886 	mpt3sas_phy->attached_handle = le16_to_cpu(phy_pg0.AttachedDevHandle);
887 	if (mpt3sas_phy->attached_handle)
888 		_transport_set_identify(ioc, mpt3sas_phy->attached_handle,
889 		    &mpt3sas_phy->remote_identify);
890 	phy->identify.phy_identifier = mpt3sas_phy->phy_id;
891 	phy->negotiated_linkrate = _transport_convert_phy_link_rate(
892 	    phy_pg0.NegotiatedLinkRate & MPI2_SAS_NEG_LINK_RATE_MASK_PHYSICAL);
893 	phy->minimum_linkrate_hw = _transport_convert_phy_link_rate(
894 	    phy_pg0.HwLinkRate & MPI2_SAS_HWRATE_MIN_RATE_MASK);
895 	phy->maximum_linkrate_hw = _transport_convert_phy_link_rate(
896 	    phy_pg0.HwLinkRate >> 4);
897 	phy->minimum_linkrate = _transport_convert_phy_link_rate(
898 	    phy_pg0.ProgrammedLinkRate & MPI2_SAS_PRATE_MIN_RATE_MASK);
899 	phy->maximum_linkrate = _transport_convert_phy_link_rate(
900 	    phy_pg0.ProgrammedLinkRate >> 4);
901 
902 	if ((sas_phy_add(phy))) {
903 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
904 		    ioc->name, __FILE__, __LINE__, __func__);
905 		sas_phy_free(phy);
906 		return -1;
907 	}
908 	if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
909 		dev_printk(KERN_INFO, &phy->dev,
910 		    "add: handle(0x%04x), sas_addr(0x%016llx)\n"
911 		    "\tattached_handle(0x%04x), sas_addr(0x%016llx)\n",
912 		    mpt3sas_phy->handle, (unsigned long long)
913 		    mpt3sas_phy->identify.sas_address,
914 		    mpt3sas_phy->attached_handle,
915 		    (unsigned long long)
916 		    mpt3sas_phy->remote_identify.sas_address);
917 	mpt3sas_phy->phy = phy;
918 	return 0;
919 }
920 
921 
922 /**
923  * mpt3sas_transport_add_expander_phy - report expander phy to transport
924  * @ioc: per adapter object
925  * @mpt3sas_phy: mpt3sas per phy object
926  * @expander_pg1: expander page 1
927  * @parent_dev: parent device class object
928  *
929  * Returns 0 for success, non-zero for failure.
930  */
931 int
932 mpt3sas_transport_add_expander_phy(struct MPT3SAS_ADAPTER *ioc, struct _sas_phy
933 	*mpt3sas_phy, Mpi2ExpanderPage1_t expander_pg1,
934 	struct device *parent_dev)
935 {
936 	struct sas_phy *phy;
937 	int phy_index = mpt3sas_phy->phy_id;
938 
939 	INIT_LIST_HEAD(&mpt3sas_phy->port_siblings);
940 	phy = sas_phy_alloc(parent_dev, phy_index);
941 	if (!phy) {
942 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
943 		    ioc->name, __FILE__, __LINE__, __func__);
944 		return -1;
945 	}
946 	if ((_transport_set_identify(ioc, mpt3sas_phy->handle,
947 	    &mpt3sas_phy->identify))) {
948 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
949 		    ioc->name, __FILE__, __LINE__, __func__);
950 		sas_phy_free(phy);
951 		return -1;
952 	}
953 	phy->identify = mpt3sas_phy->identify;
954 	mpt3sas_phy->attached_handle =
955 	    le16_to_cpu(expander_pg1.AttachedDevHandle);
956 	if (mpt3sas_phy->attached_handle)
957 		_transport_set_identify(ioc, mpt3sas_phy->attached_handle,
958 		    &mpt3sas_phy->remote_identify);
959 	phy->identify.phy_identifier = mpt3sas_phy->phy_id;
960 	phy->negotiated_linkrate = _transport_convert_phy_link_rate(
961 	    expander_pg1.NegotiatedLinkRate &
962 	    MPI2_SAS_NEG_LINK_RATE_MASK_PHYSICAL);
963 	phy->minimum_linkrate_hw = _transport_convert_phy_link_rate(
964 	    expander_pg1.HwLinkRate & MPI2_SAS_HWRATE_MIN_RATE_MASK);
965 	phy->maximum_linkrate_hw = _transport_convert_phy_link_rate(
966 	    expander_pg1.HwLinkRate >> 4);
967 	phy->minimum_linkrate = _transport_convert_phy_link_rate(
968 	    expander_pg1.ProgrammedLinkRate & MPI2_SAS_PRATE_MIN_RATE_MASK);
969 	phy->maximum_linkrate = _transport_convert_phy_link_rate(
970 	    expander_pg1.ProgrammedLinkRate >> 4);
971 
972 	if ((sas_phy_add(phy))) {
973 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
974 		    ioc->name, __FILE__, __LINE__, __func__);
975 		sas_phy_free(phy);
976 		return -1;
977 	}
978 	if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
979 		dev_printk(KERN_INFO, &phy->dev,
980 		    "add: handle(0x%04x), sas_addr(0x%016llx)\n"
981 		    "\tattached_handle(0x%04x), sas_addr(0x%016llx)\n",
982 		    mpt3sas_phy->handle, (unsigned long long)
983 		    mpt3sas_phy->identify.sas_address,
984 		    mpt3sas_phy->attached_handle,
985 		    (unsigned long long)
986 		    mpt3sas_phy->remote_identify.sas_address);
987 	mpt3sas_phy->phy = phy;
988 	return 0;
989 }
990 
991 /**
992  * mpt3sas_transport_update_links - refreshing phy link changes
993  * @ioc: per adapter object
994  * @sas_address: sas address of parent expander or sas host
995  * @handle: attached device handle
996  * @phy_numberv: phy number
997  * @link_rate: new link rate
998  *
999  * Returns nothing.
1000  */
1001 void
1002 mpt3sas_transport_update_links(struct MPT3SAS_ADAPTER *ioc,
1003 	u64 sas_address, u16 handle, u8 phy_number, u8 link_rate)
1004 {
1005 	unsigned long flags;
1006 	struct _sas_node *sas_node;
1007 	struct _sas_phy *mpt3sas_phy;
1008 
1009 	if (ioc->shost_recovery || ioc->pci_error_recovery)
1010 		return;
1011 
1012 	spin_lock_irqsave(&ioc->sas_node_lock, flags);
1013 	sas_node = _transport_sas_node_find_by_sas_address(ioc, sas_address);
1014 	if (!sas_node) {
1015 		spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1016 		return;
1017 	}
1018 
1019 	mpt3sas_phy = &sas_node->phy[phy_number];
1020 	mpt3sas_phy->attached_handle = handle;
1021 	spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1022 	if (handle && (link_rate >= MPI2_SAS_NEG_LINK_RATE_1_5)) {
1023 		_transport_set_identify(ioc, handle,
1024 		    &mpt3sas_phy->remote_identify);
1025 		_transport_add_phy_to_an_existing_port(ioc, sas_node,
1026 		    mpt3sas_phy, mpt3sas_phy->remote_identify.sas_address);
1027 	} else
1028 		memset(&mpt3sas_phy->remote_identify, 0 , sizeof(struct
1029 		    sas_identify));
1030 
1031 	if (mpt3sas_phy->phy)
1032 		mpt3sas_phy->phy->negotiated_linkrate =
1033 		    _transport_convert_phy_link_rate(link_rate);
1034 
1035 	if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
1036 		dev_printk(KERN_INFO, &mpt3sas_phy->phy->dev,
1037 		    "refresh: parent sas_addr(0x%016llx),\n"
1038 		    "\tlink_rate(0x%02x), phy(%d)\n"
1039 		    "\tattached_handle(0x%04x), sas_addr(0x%016llx)\n",
1040 		    (unsigned long long)sas_address,
1041 		    link_rate, phy_number, handle, (unsigned long long)
1042 		    mpt3sas_phy->remote_identify.sas_address);
1043 }
1044 
1045 static inline void *
1046 phy_to_ioc(struct sas_phy *phy)
1047 {
1048 	struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
1049 	return shost_priv(shost);
1050 }
1051 
1052 static inline void *
1053 rphy_to_ioc(struct sas_rphy *rphy)
1054 {
1055 	struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent);
1056 	return shost_priv(shost);
1057 }
1058 
1059 /* report phy error log structure */
1060 struct phy_error_log_request {
1061 	u8 smp_frame_type; /* 0x40 */
1062 	u8 function; /* 0x11 */
1063 	u8 allocated_response_length;
1064 	u8 request_length; /* 02 */
1065 	u8 reserved_1[5];
1066 	u8 phy_identifier;
1067 	u8 reserved_2[2];
1068 };
1069 
1070 /* report phy error log reply structure */
1071 struct phy_error_log_reply {
1072 	u8 smp_frame_type; /* 0x41 */
1073 	u8 function; /* 0x11 */
1074 	u8 function_result;
1075 	u8 response_length;
1076 	__be16 expander_change_count;
1077 	u8 reserved_1[3];
1078 	u8 phy_identifier;
1079 	u8 reserved_2[2];
1080 	__be32 invalid_dword;
1081 	__be32 running_disparity_error;
1082 	__be32 loss_of_dword_sync;
1083 	__be32 phy_reset_problem;
1084 };
1085 
1086 /**
1087  * _transport_get_expander_phy_error_log - return expander counters
1088  * @ioc: per adapter object
1089  * @phy: The sas phy object
1090  *
1091  * Returns 0 for success, non-zero for failure.
1092  *
1093  */
1094 static int
1095 _transport_get_expander_phy_error_log(struct MPT3SAS_ADAPTER *ioc,
1096 	struct sas_phy *phy)
1097 {
1098 	Mpi2SmpPassthroughRequest_t *mpi_request;
1099 	Mpi2SmpPassthroughReply_t *mpi_reply;
1100 	struct phy_error_log_request *phy_error_log_request;
1101 	struct phy_error_log_reply *phy_error_log_reply;
1102 	int rc;
1103 	u16 smid;
1104 	u32 ioc_state;
1105 	unsigned long timeleft;
1106 	void *psge;
1107 	u8 issue_reset = 0;
1108 	void *data_out = NULL;
1109 	dma_addr_t data_out_dma;
1110 	u32 sz;
1111 	u16 wait_state_count;
1112 
1113 	if (ioc->shost_recovery || ioc->pci_error_recovery) {
1114 		pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
1115 		    __func__, ioc->name);
1116 		return -EFAULT;
1117 	}
1118 
1119 	mutex_lock(&ioc->transport_cmds.mutex);
1120 
1121 	if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
1122 		pr_err(MPT3SAS_FMT "%s: transport_cmds in use\n",
1123 		    ioc->name, __func__);
1124 		rc = -EAGAIN;
1125 		goto out;
1126 	}
1127 	ioc->transport_cmds.status = MPT3_CMD_PENDING;
1128 
1129 	wait_state_count = 0;
1130 	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
1131 	while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
1132 		if (wait_state_count++ == 10) {
1133 			pr_err(MPT3SAS_FMT
1134 			    "%s: failed due to ioc not operational\n",
1135 			    ioc->name, __func__);
1136 			rc = -EFAULT;
1137 			goto out;
1138 		}
1139 		ssleep(1);
1140 		ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
1141 		pr_info(MPT3SAS_FMT
1142 			"%s: waiting for operational state(count=%d)\n",
1143 			ioc->name, __func__, wait_state_count);
1144 	}
1145 	if (wait_state_count)
1146 		pr_info(MPT3SAS_FMT "%s: ioc is operational\n",
1147 		    ioc->name, __func__);
1148 
1149 	smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
1150 	if (!smid) {
1151 		pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
1152 		    ioc->name, __func__);
1153 		rc = -EAGAIN;
1154 		goto out;
1155 	}
1156 
1157 	mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
1158 	ioc->transport_cmds.smid = smid;
1159 
1160 	sz = sizeof(struct phy_error_log_request) +
1161 	    sizeof(struct phy_error_log_reply);
1162 	data_out = pci_alloc_consistent(ioc->pdev, sz, &data_out_dma);
1163 	if (!data_out) {
1164 		pr_err("failure at %s:%d/%s()!\n", __FILE__,
1165 		    __LINE__, __func__);
1166 		rc = -ENOMEM;
1167 		mpt3sas_base_free_smid(ioc, smid);
1168 		goto out;
1169 	}
1170 
1171 	rc = -EINVAL;
1172 	memset(data_out, 0, sz);
1173 	phy_error_log_request = data_out;
1174 	phy_error_log_request->smp_frame_type = 0x40;
1175 	phy_error_log_request->function = 0x11;
1176 	phy_error_log_request->request_length = 2;
1177 	phy_error_log_request->allocated_response_length = 0;
1178 	phy_error_log_request->phy_identifier = phy->number;
1179 
1180 	memset(mpi_request, 0, sizeof(Mpi2SmpPassthroughRequest_t));
1181 	mpi_request->Function = MPI2_FUNCTION_SMP_PASSTHROUGH;
1182 	mpi_request->PhysicalPort = 0xFF;
1183 	mpi_request->VF_ID = 0; /* TODO */
1184 	mpi_request->VP_ID = 0;
1185 	mpi_request->SASAddress = cpu_to_le64(phy->identify.sas_address);
1186 	mpi_request->RequestDataLength =
1187 	    cpu_to_le16(sizeof(struct phy_error_log_request));
1188 	psge = &mpi_request->SGL;
1189 
1190 	ioc->build_sg(ioc, psge, data_out_dma,
1191 		sizeof(struct phy_error_log_request),
1192 	    data_out_dma + sizeof(struct phy_error_log_request),
1193 	    sizeof(struct phy_error_log_reply));
1194 
1195 	dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1196 		"phy_error_log - send to sas_addr(0x%016llx), phy(%d)\n",
1197 		ioc->name, (unsigned long long)phy->identify.sas_address,
1198 		phy->number));
1199 	init_completion(&ioc->transport_cmds.done);
1200 	mpt3sas_base_put_smid_default(ioc, smid);
1201 	timeleft = wait_for_completion_timeout(&ioc->transport_cmds.done,
1202 	    10*HZ);
1203 
1204 	if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
1205 		pr_err(MPT3SAS_FMT "%s: timeout\n",
1206 		    ioc->name, __func__);
1207 		_debug_dump_mf(mpi_request,
1208 		    sizeof(Mpi2SmpPassthroughRequest_t)/4);
1209 		if (!(ioc->transport_cmds.status & MPT3_CMD_RESET))
1210 			issue_reset = 1;
1211 		goto issue_host_reset;
1212 	}
1213 
1214 	dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1215 		"phy_error_log - complete\n", ioc->name));
1216 
1217 	if (ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID) {
1218 
1219 		mpi_reply = ioc->transport_cmds.reply;
1220 
1221 		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1222 		    "phy_error_log - reply data transfer size(%d)\n",
1223 		    ioc->name, le16_to_cpu(mpi_reply->ResponseDataLength)));
1224 
1225 		if (le16_to_cpu(mpi_reply->ResponseDataLength) !=
1226 		    sizeof(struct phy_error_log_reply))
1227 			goto out;
1228 
1229 		phy_error_log_reply = data_out +
1230 		    sizeof(struct phy_error_log_request);
1231 
1232 		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1233 		    "phy_error_log - function_result(%d)\n",
1234 		    ioc->name, phy_error_log_reply->function_result));
1235 
1236 		phy->invalid_dword_count =
1237 		    be32_to_cpu(phy_error_log_reply->invalid_dword);
1238 		phy->running_disparity_error_count =
1239 		    be32_to_cpu(phy_error_log_reply->running_disparity_error);
1240 		phy->loss_of_dword_sync_count =
1241 		    be32_to_cpu(phy_error_log_reply->loss_of_dword_sync);
1242 		phy->phy_reset_problem_count =
1243 		    be32_to_cpu(phy_error_log_reply->phy_reset_problem);
1244 		rc = 0;
1245 	} else
1246 		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1247 		    "phy_error_log - no reply\n", ioc->name));
1248 
1249  issue_host_reset:
1250 	if (issue_reset)
1251 		mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1252 		    FORCE_BIG_HAMMER);
1253  out:
1254 	ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
1255 	if (data_out)
1256 		pci_free_consistent(ioc->pdev, sz, data_out, data_out_dma);
1257 
1258 	mutex_unlock(&ioc->transport_cmds.mutex);
1259 	return rc;
1260 }
1261 
1262 /**
1263  * _transport_get_linkerrors - return phy counters for both hba and expanders
1264  * @phy: The sas phy object
1265  *
1266  * Returns 0 for success, non-zero for failure.
1267  *
1268  */
1269 static int
1270 _transport_get_linkerrors(struct sas_phy *phy)
1271 {
1272 	struct MPT3SAS_ADAPTER *ioc = phy_to_ioc(phy);
1273 	unsigned long flags;
1274 	Mpi2ConfigReply_t mpi_reply;
1275 	Mpi2SasPhyPage1_t phy_pg1;
1276 
1277 	spin_lock_irqsave(&ioc->sas_node_lock, flags);
1278 	if (_transport_sas_node_find_by_sas_address(ioc,
1279 	    phy->identify.sas_address) == NULL) {
1280 		spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1281 		return -EINVAL;
1282 	}
1283 	spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1284 
1285 	if (phy->identify.sas_address != ioc->sas_hba.sas_address)
1286 		return _transport_get_expander_phy_error_log(ioc, phy);
1287 
1288 	/* get hba phy error logs */
1289 	if ((mpt3sas_config_get_phy_pg1(ioc, &mpi_reply, &phy_pg1,
1290 		    phy->number))) {
1291 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1292 		    ioc->name, __FILE__, __LINE__, __func__);
1293 		return -ENXIO;
1294 	}
1295 
1296 	if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo)
1297 		pr_info(MPT3SAS_FMT
1298 			"phy(%d), ioc_status (0x%04x), loginfo(0x%08x)\n",
1299 			ioc->name, phy->number,
1300 			le16_to_cpu(mpi_reply.IOCStatus),
1301 		    le32_to_cpu(mpi_reply.IOCLogInfo));
1302 
1303 	phy->invalid_dword_count = le32_to_cpu(phy_pg1.InvalidDwordCount);
1304 	phy->running_disparity_error_count =
1305 	    le32_to_cpu(phy_pg1.RunningDisparityErrorCount);
1306 	phy->loss_of_dword_sync_count =
1307 	    le32_to_cpu(phy_pg1.LossDwordSynchCount);
1308 	phy->phy_reset_problem_count =
1309 	    le32_to_cpu(phy_pg1.PhyResetProblemCount);
1310 	return 0;
1311 }
1312 
1313 /**
1314  * _transport_get_enclosure_identifier -
1315  * @phy: The sas phy object
1316  *
1317  * Obtain the enclosure logical id for an expander.
1318  * Returns 0 for success, non-zero for failure.
1319  */
1320 static int
1321 _transport_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
1322 {
1323 	struct MPT3SAS_ADAPTER *ioc = rphy_to_ioc(rphy);
1324 	struct _sas_device *sas_device;
1325 	unsigned long flags;
1326 	int rc;
1327 
1328 	spin_lock_irqsave(&ioc->sas_device_lock, flags);
1329 	sas_device = __mpt3sas_get_sdev_by_addr(ioc,
1330 	    rphy->identify.sas_address);
1331 	if (sas_device) {
1332 		*identifier = sas_device->enclosure_logical_id;
1333 		rc = 0;
1334 		sas_device_put(sas_device);
1335 	} else {
1336 		*identifier = 0;
1337 		rc = -ENXIO;
1338 	}
1339 
1340 	spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1341 	return rc;
1342 }
1343 
1344 /**
1345  * _transport_get_bay_identifier -
1346  * @phy: The sas phy object
1347  *
1348  * Returns the slot id for a device that resides inside an enclosure.
1349  */
1350 static int
1351 _transport_get_bay_identifier(struct sas_rphy *rphy)
1352 {
1353 	struct MPT3SAS_ADAPTER *ioc = rphy_to_ioc(rphy);
1354 	struct _sas_device *sas_device;
1355 	unsigned long flags;
1356 	int rc;
1357 
1358 	spin_lock_irqsave(&ioc->sas_device_lock, flags);
1359 	sas_device = __mpt3sas_get_sdev_by_addr(ioc,
1360 	    rphy->identify.sas_address);
1361 	if (sas_device) {
1362 		rc = sas_device->slot;
1363 		sas_device_put(sas_device);
1364 	} else {
1365 		rc = -ENXIO;
1366 	}
1367 	spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1368 	return rc;
1369 }
1370 
1371 /* phy control request structure */
1372 struct phy_control_request {
1373 	u8 smp_frame_type; /* 0x40 */
1374 	u8 function; /* 0x91 */
1375 	u8 allocated_response_length;
1376 	u8 request_length; /* 0x09 */
1377 	u16 expander_change_count;
1378 	u8 reserved_1[3];
1379 	u8 phy_identifier;
1380 	u8 phy_operation;
1381 	u8 reserved_2[13];
1382 	u64 attached_device_name;
1383 	u8 programmed_min_physical_link_rate;
1384 	u8 programmed_max_physical_link_rate;
1385 	u8 reserved_3[6];
1386 };
1387 
1388 /* phy control reply structure */
1389 struct phy_control_reply {
1390 	u8 smp_frame_type; /* 0x41 */
1391 	u8 function; /* 0x11 */
1392 	u8 function_result;
1393 	u8 response_length;
1394 };
1395 
1396 #define SMP_PHY_CONTROL_LINK_RESET	(0x01)
1397 #define SMP_PHY_CONTROL_HARD_RESET	(0x02)
1398 #define SMP_PHY_CONTROL_DISABLE		(0x03)
1399 
1400 /**
1401  * _transport_expander_phy_control - expander phy control
1402  * @ioc: per adapter object
1403  * @phy: The sas phy object
1404  *
1405  * Returns 0 for success, non-zero for failure.
1406  *
1407  */
1408 static int
1409 _transport_expander_phy_control(struct MPT3SAS_ADAPTER *ioc,
1410 	struct sas_phy *phy, u8 phy_operation)
1411 {
1412 	Mpi2SmpPassthroughRequest_t *mpi_request;
1413 	Mpi2SmpPassthroughReply_t *mpi_reply;
1414 	struct phy_control_request *phy_control_request;
1415 	struct phy_control_reply *phy_control_reply;
1416 	int rc;
1417 	u16 smid;
1418 	u32 ioc_state;
1419 	unsigned long timeleft;
1420 	void *psge;
1421 	u32 sgl_flags;
1422 	u8 issue_reset = 0;
1423 	void *data_out = NULL;
1424 	dma_addr_t data_out_dma;
1425 	u32 sz;
1426 	u16 wait_state_count;
1427 
1428 	if (ioc->shost_recovery || ioc->pci_error_recovery) {
1429 		pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
1430 		    __func__, ioc->name);
1431 		return -EFAULT;
1432 	}
1433 
1434 	mutex_lock(&ioc->transport_cmds.mutex);
1435 
1436 	if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
1437 		pr_err(MPT3SAS_FMT "%s: transport_cmds in use\n",
1438 		    ioc->name, __func__);
1439 		rc = -EAGAIN;
1440 		goto out;
1441 	}
1442 	ioc->transport_cmds.status = MPT3_CMD_PENDING;
1443 
1444 	wait_state_count = 0;
1445 	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
1446 	while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
1447 		if (wait_state_count++ == 10) {
1448 			pr_err(MPT3SAS_FMT
1449 			    "%s: failed due to ioc not operational\n",
1450 			    ioc->name, __func__);
1451 			rc = -EFAULT;
1452 			goto out;
1453 		}
1454 		ssleep(1);
1455 		ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
1456 		pr_info(MPT3SAS_FMT
1457 			"%s: waiting for operational state(count=%d)\n",
1458 			ioc->name, __func__, wait_state_count);
1459 	}
1460 	if (wait_state_count)
1461 		pr_info(MPT3SAS_FMT "%s: ioc is operational\n",
1462 		    ioc->name, __func__);
1463 
1464 	smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
1465 	if (!smid) {
1466 		pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
1467 		    ioc->name, __func__);
1468 		rc = -EAGAIN;
1469 		goto out;
1470 	}
1471 
1472 	mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
1473 	ioc->transport_cmds.smid = smid;
1474 
1475 	sz = sizeof(struct phy_control_request) +
1476 	    sizeof(struct phy_control_reply);
1477 	data_out = pci_alloc_consistent(ioc->pdev, sz, &data_out_dma);
1478 	if (!data_out) {
1479 		pr_err("failure at %s:%d/%s()!\n", __FILE__,
1480 		    __LINE__, __func__);
1481 		rc = -ENOMEM;
1482 		mpt3sas_base_free_smid(ioc, smid);
1483 		goto out;
1484 	}
1485 
1486 	rc = -EINVAL;
1487 	memset(data_out, 0, sz);
1488 	phy_control_request = data_out;
1489 	phy_control_request->smp_frame_type = 0x40;
1490 	phy_control_request->function = 0x91;
1491 	phy_control_request->request_length = 9;
1492 	phy_control_request->allocated_response_length = 0;
1493 	phy_control_request->phy_identifier = phy->number;
1494 	phy_control_request->phy_operation = phy_operation;
1495 	phy_control_request->programmed_min_physical_link_rate =
1496 	    phy->minimum_linkrate << 4;
1497 	phy_control_request->programmed_max_physical_link_rate =
1498 	    phy->maximum_linkrate << 4;
1499 
1500 	memset(mpi_request, 0, sizeof(Mpi2SmpPassthroughRequest_t));
1501 	mpi_request->Function = MPI2_FUNCTION_SMP_PASSTHROUGH;
1502 	mpi_request->PhysicalPort = 0xFF;
1503 	mpi_request->VF_ID = 0; /* TODO */
1504 	mpi_request->VP_ID = 0;
1505 	mpi_request->SASAddress = cpu_to_le64(phy->identify.sas_address);
1506 	mpi_request->RequestDataLength =
1507 	    cpu_to_le16(sizeof(struct phy_error_log_request));
1508 	psge = &mpi_request->SGL;
1509 
1510 	/* WRITE sgel first */
1511 	sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT |
1512 	    MPI2_SGE_FLAGS_END_OF_BUFFER | MPI2_SGE_FLAGS_HOST_TO_IOC);
1513 	sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
1514 	ioc->base_add_sg_single(psge, sgl_flags |
1515 	    sizeof(struct phy_control_request), data_out_dma);
1516 
1517 	/* incr sgel */
1518 	psge += ioc->sge_size;
1519 
1520 	/* READ sgel last */
1521 	sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT |
1522 	    MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER |
1523 	    MPI2_SGE_FLAGS_END_OF_LIST);
1524 	sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
1525 	ioc->base_add_sg_single(psge, sgl_flags |
1526 	    sizeof(struct phy_control_reply), data_out_dma +
1527 	    sizeof(struct phy_control_request));
1528 
1529 	dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1530 		"phy_control - send to sas_addr(0x%016llx), phy(%d), opcode(%d)\n",
1531 		ioc->name, (unsigned long long)phy->identify.sas_address,
1532 		phy->number, phy_operation));
1533 	init_completion(&ioc->transport_cmds.done);
1534 	mpt3sas_base_put_smid_default(ioc, smid);
1535 	timeleft = wait_for_completion_timeout(&ioc->transport_cmds.done,
1536 	    10*HZ);
1537 
1538 	if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
1539 		pr_err(MPT3SAS_FMT "%s: timeout\n",
1540 		    ioc->name, __func__);
1541 		_debug_dump_mf(mpi_request,
1542 		    sizeof(Mpi2SmpPassthroughRequest_t)/4);
1543 		if (!(ioc->transport_cmds.status & MPT3_CMD_RESET))
1544 			issue_reset = 1;
1545 		goto issue_host_reset;
1546 	}
1547 
1548 	dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1549 		"phy_control - complete\n", ioc->name));
1550 
1551 	if (ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID) {
1552 
1553 		mpi_reply = ioc->transport_cmds.reply;
1554 
1555 		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1556 		    "phy_control - reply data transfer size(%d)\n",
1557 		    ioc->name, le16_to_cpu(mpi_reply->ResponseDataLength)));
1558 
1559 		if (le16_to_cpu(mpi_reply->ResponseDataLength) !=
1560 		    sizeof(struct phy_control_reply))
1561 			goto out;
1562 
1563 		phy_control_reply = data_out +
1564 		    sizeof(struct phy_control_request);
1565 
1566 		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1567 		    "phy_control - function_result(%d)\n",
1568 		    ioc->name, phy_control_reply->function_result));
1569 
1570 		rc = 0;
1571 	} else
1572 		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1573 		    "phy_control - no reply\n", ioc->name));
1574 
1575  issue_host_reset:
1576 	if (issue_reset)
1577 		mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1578 		    FORCE_BIG_HAMMER);
1579  out:
1580 	ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
1581 	if (data_out)
1582 		pci_free_consistent(ioc->pdev, sz, data_out, data_out_dma);
1583 
1584 	mutex_unlock(&ioc->transport_cmds.mutex);
1585 	return rc;
1586 }
1587 
1588 /**
1589  * _transport_phy_reset -
1590  * @phy: The sas phy object
1591  * @hard_reset:
1592  *
1593  * Returns 0 for success, non-zero for failure.
1594  */
1595 static int
1596 _transport_phy_reset(struct sas_phy *phy, int hard_reset)
1597 {
1598 	struct MPT3SAS_ADAPTER *ioc = phy_to_ioc(phy);
1599 	Mpi2SasIoUnitControlReply_t mpi_reply;
1600 	Mpi2SasIoUnitControlRequest_t mpi_request;
1601 	unsigned long flags;
1602 
1603 	spin_lock_irqsave(&ioc->sas_node_lock, flags);
1604 	if (_transport_sas_node_find_by_sas_address(ioc,
1605 	    phy->identify.sas_address) == NULL) {
1606 		spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1607 		return -EINVAL;
1608 	}
1609 	spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1610 
1611 	/* handle expander phys */
1612 	if (phy->identify.sas_address != ioc->sas_hba.sas_address)
1613 		return _transport_expander_phy_control(ioc, phy,
1614 		    (hard_reset == 1) ? SMP_PHY_CONTROL_HARD_RESET :
1615 		    SMP_PHY_CONTROL_LINK_RESET);
1616 
1617 	/* handle hba phys */
1618 	memset(&mpi_request, 0, sizeof(Mpi2SasIoUnitControlReply_t));
1619 	mpi_request.Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
1620 	mpi_request.Operation = hard_reset ?
1621 	    MPI2_SAS_OP_PHY_HARD_RESET : MPI2_SAS_OP_PHY_LINK_RESET;
1622 	mpi_request.PhyNum = phy->number;
1623 
1624 	if ((mpt3sas_base_sas_iounit_control(ioc, &mpi_reply, &mpi_request))) {
1625 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1626 		    ioc->name, __FILE__, __LINE__, __func__);
1627 		return -ENXIO;
1628 	}
1629 
1630 	if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo)
1631 		pr_info(MPT3SAS_FMT
1632 		"phy(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
1633 		ioc->name, phy->number, le16_to_cpu(mpi_reply.IOCStatus),
1634 		    le32_to_cpu(mpi_reply.IOCLogInfo));
1635 
1636 	return 0;
1637 }
1638 
1639 /**
1640  * _transport_phy_enable - enable/disable phys
1641  * @phy: The sas phy object
1642  * @enable: enable phy when true
1643  *
1644  * Only support sas_host direct attached phys.
1645  * Returns 0 for success, non-zero for failure.
1646  */
1647 static int
1648 _transport_phy_enable(struct sas_phy *phy, int enable)
1649 {
1650 	struct MPT3SAS_ADAPTER *ioc = phy_to_ioc(phy);
1651 	Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
1652 	Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
1653 	Mpi2ConfigReply_t mpi_reply;
1654 	u16 ioc_status;
1655 	u16 sz;
1656 	int rc = 0;
1657 	unsigned long flags;
1658 	int i, discovery_active;
1659 
1660 	spin_lock_irqsave(&ioc->sas_node_lock, flags);
1661 	if (_transport_sas_node_find_by_sas_address(ioc,
1662 	    phy->identify.sas_address) == NULL) {
1663 		spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1664 		return -EINVAL;
1665 	}
1666 	spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1667 
1668 	/* handle expander phys */
1669 	if (phy->identify.sas_address != ioc->sas_hba.sas_address)
1670 		return _transport_expander_phy_control(ioc, phy,
1671 		    (enable == 1) ? SMP_PHY_CONTROL_LINK_RESET :
1672 		    SMP_PHY_CONTROL_DISABLE);
1673 
1674 	/* handle hba phys */
1675 
1676 	/* read sas_iounit page 0 */
1677 	sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys *
1678 	    sizeof(Mpi2SasIOUnit0PhyData_t));
1679 	sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
1680 	if (!sas_iounit_pg0) {
1681 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1682 		    ioc->name, __FILE__, __LINE__, __func__);
1683 		rc = -ENOMEM;
1684 		goto out;
1685 	}
1686 	if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
1687 	    sas_iounit_pg0, sz))) {
1688 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1689 		    ioc->name, __FILE__, __LINE__, __func__);
1690 		rc = -ENXIO;
1691 		goto out;
1692 	}
1693 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1694 	    MPI2_IOCSTATUS_MASK;
1695 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1696 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1697 		    ioc->name, __FILE__, __LINE__, __func__);
1698 		rc = -EIO;
1699 		goto out;
1700 	}
1701 
1702 	/* unable to enable/disable phys when when discovery is active */
1703 	for (i = 0, discovery_active = 0; i < ioc->sas_hba.num_phys ; i++) {
1704 		if (sas_iounit_pg0->PhyData[i].PortFlags &
1705 		    MPI2_SASIOUNIT0_PORTFLAGS_DISCOVERY_IN_PROGRESS) {
1706 			pr_err(MPT3SAS_FMT "discovery is active on " \
1707 			    "port = %d, phy = %d: unable to enable/disable "
1708 			    "phys, try again later!\n", ioc->name,
1709 			    sas_iounit_pg0->PhyData[i].Port, i);
1710 			discovery_active = 1;
1711 		}
1712 	}
1713 
1714 	if (discovery_active) {
1715 		rc = -EAGAIN;
1716 		goto out;
1717 	}
1718 
1719 	/* read sas_iounit page 1 */
1720 	sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
1721 	    sizeof(Mpi2SasIOUnit1PhyData_t));
1722 	sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
1723 	if (!sas_iounit_pg1) {
1724 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1725 		    ioc->name, __FILE__, __LINE__, __func__);
1726 		rc = -ENOMEM;
1727 		goto out;
1728 	}
1729 	if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
1730 	    sas_iounit_pg1, sz))) {
1731 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1732 		    ioc->name, __FILE__, __LINE__, __func__);
1733 		rc = -ENXIO;
1734 		goto out;
1735 	}
1736 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1737 	    MPI2_IOCSTATUS_MASK;
1738 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1739 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1740 		    ioc->name, __FILE__, __LINE__, __func__);
1741 		rc = -EIO;
1742 		goto out;
1743 	}
1744 
1745 	/* copy Port/PortFlags/PhyFlags from page 0 */
1746 	for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
1747 		sas_iounit_pg1->PhyData[i].Port =
1748 		    sas_iounit_pg0->PhyData[i].Port;
1749 		sas_iounit_pg1->PhyData[i].PortFlags =
1750 		    (sas_iounit_pg0->PhyData[i].PortFlags &
1751 		    MPI2_SASIOUNIT0_PORTFLAGS_AUTO_PORT_CONFIG);
1752 		sas_iounit_pg1->PhyData[i].PhyFlags =
1753 		    (sas_iounit_pg0->PhyData[i].PhyFlags &
1754 		    (MPI2_SASIOUNIT0_PHYFLAGS_ZONING_ENABLED +
1755 		    MPI2_SASIOUNIT0_PHYFLAGS_PHY_DISABLED));
1756 	}
1757 
1758 	if (enable)
1759 		sas_iounit_pg1->PhyData[phy->number].PhyFlags
1760 		    &= ~MPI2_SASIOUNIT1_PHYFLAGS_PHY_DISABLE;
1761 	else
1762 		sas_iounit_pg1->PhyData[phy->number].PhyFlags
1763 		    |= MPI2_SASIOUNIT1_PHYFLAGS_PHY_DISABLE;
1764 
1765 	mpt3sas_config_set_sas_iounit_pg1(ioc, &mpi_reply, sas_iounit_pg1, sz);
1766 
1767 	/* link reset */
1768 	if (enable)
1769 		_transport_phy_reset(phy, 0);
1770 
1771  out:
1772 	kfree(sas_iounit_pg1);
1773 	kfree(sas_iounit_pg0);
1774 	return rc;
1775 }
1776 
1777 /**
1778  * _transport_phy_speed - set phy min/max link rates
1779  * @phy: The sas phy object
1780  * @rates: rates defined in sas_phy_linkrates
1781  *
1782  * Only support sas_host direct attached phys.
1783  * Returns 0 for success, non-zero for failure.
1784  */
1785 static int
1786 _transport_phy_speed(struct sas_phy *phy, struct sas_phy_linkrates *rates)
1787 {
1788 	struct MPT3SAS_ADAPTER *ioc = phy_to_ioc(phy);
1789 	Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
1790 	Mpi2SasPhyPage0_t phy_pg0;
1791 	Mpi2ConfigReply_t mpi_reply;
1792 	u16 ioc_status;
1793 	u16 sz;
1794 	int i;
1795 	int rc = 0;
1796 	unsigned long flags;
1797 
1798 	spin_lock_irqsave(&ioc->sas_node_lock, flags);
1799 	if (_transport_sas_node_find_by_sas_address(ioc,
1800 	    phy->identify.sas_address) == NULL) {
1801 		spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1802 		return -EINVAL;
1803 	}
1804 	spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1805 
1806 	if (!rates->minimum_linkrate)
1807 		rates->minimum_linkrate = phy->minimum_linkrate;
1808 	else if (rates->minimum_linkrate < phy->minimum_linkrate_hw)
1809 		rates->minimum_linkrate = phy->minimum_linkrate_hw;
1810 
1811 	if (!rates->maximum_linkrate)
1812 		rates->maximum_linkrate = phy->maximum_linkrate;
1813 	else if (rates->maximum_linkrate > phy->maximum_linkrate_hw)
1814 		rates->maximum_linkrate = phy->maximum_linkrate_hw;
1815 
1816 	/* handle expander phys */
1817 	if (phy->identify.sas_address != ioc->sas_hba.sas_address) {
1818 		phy->minimum_linkrate = rates->minimum_linkrate;
1819 		phy->maximum_linkrate = rates->maximum_linkrate;
1820 		return _transport_expander_phy_control(ioc, phy,
1821 		    SMP_PHY_CONTROL_LINK_RESET);
1822 	}
1823 
1824 	/* handle hba phys */
1825 
1826 	/* sas_iounit page 1 */
1827 	sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
1828 	    sizeof(Mpi2SasIOUnit1PhyData_t));
1829 	sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
1830 	if (!sas_iounit_pg1) {
1831 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1832 		    ioc->name, __FILE__, __LINE__, __func__);
1833 		rc = -ENOMEM;
1834 		goto out;
1835 	}
1836 	if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
1837 	    sas_iounit_pg1, sz))) {
1838 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1839 		    ioc->name, __FILE__, __LINE__, __func__);
1840 		rc = -ENXIO;
1841 		goto out;
1842 	}
1843 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1844 	    MPI2_IOCSTATUS_MASK;
1845 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1846 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1847 		    ioc->name, __FILE__, __LINE__, __func__);
1848 		rc = -EIO;
1849 		goto out;
1850 	}
1851 
1852 	for (i = 0; i < ioc->sas_hba.num_phys; i++) {
1853 		if (phy->number != i) {
1854 			sas_iounit_pg1->PhyData[i].MaxMinLinkRate =
1855 			    (ioc->sas_hba.phy[i].phy->minimum_linkrate +
1856 			    (ioc->sas_hba.phy[i].phy->maximum_linkrate << 4));
1857 		} else {
1858 			sas_iounit_pg1->PhyData[i].MaxMinLinkRate =
1859 			    (rates->minimum_linkrate +
1860 			    (rates->maximum_linkrate << 4));
1861 		}
1862 	}
1863 
1864 	if (mpt3sas_config_set_sas_iounit_pg1(ioc, &mpi_reply, sas_iounit_pg1,
1865 	    sz)) {
1866 		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1867 		    ioc->name, __FILE__, __LINE__, __func__);
1868 		rc = -ENXIO;
1869 		goto out;
1870 	}
1871 
1872 	/* link reset */
1873 	_transport_phy_reset(phy, 0);
1874 
1875 	/* read phy page 0, then update the rates in the sas transport phy */
1876 	if (!mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
1877 	    phy->number)) {
1878 		phy->minimum_linkrate = _transport_convert_phy_link_rate(
1879 		    phy_pg0.ProgrammedLinkRate & MPI2_SAS_PRATE_MIN_RATE_MASK);
1880 		phy->maximum_linkrate = _transport_convert_phy_link_rate(
1881 		    phy_pg0.ProgrammedLinkRate >> 4);
1882 		phy->negotiated_linkrate = _transport_convert_phy_link_rate(
1883 		    phy_pg0.NegotiatedLinkRate &
1884 		    MPI2_SAS_NEG_LINK_RATE_MASK_PHYSICAL);
1885 	}
1886 
1887  out:
1888 	kfree(sas_iounit_pg1);
1889 	return rc;
1890 }
1891 
1892 /**
1893  * _transport_smp_handler - transport portal for smp passthru
1894  * @shost: shost object
1895  * @rphy: sas transport rphy object
1896  * @req:
1897  *
1898  * This used primarily for smp_utils.
1899  * Example:
1900  *           smp_rep_general /sys/class/bsg/expander-5:0
1901  */
1902 static int
1903 _transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
1904 	struct request *req)
1905 {
1906 	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1907 	Mpi2SmpPassthroughRequest_t *mpi_request;
1908 	Mpi2SmpPassthroughReply_t *mpi_reply;
1909 	int rc;
1910 	u16 smid;
1911 	u32 ioc_state;
1912 	unsigned long timeleft;
1913 	void *psge;
1914 	u8 issue_reset = 0;
1915 	dma_addr_t dma_addr_in = 0;
1916 	dma_addr_t dma_addr_out = 0;
1917 	dma_addr_t pci_dma_in = 0;
1918 	dma_addr_t pci_dma_out = 0;
1919 	void *pci_addr_in = NULL;
1920 	void *pci_addr_out = NULL;
1921 	u16 wait_state_count;
1922 	struct request *rsp = req->next_rq;
1923 	struct bio_vec bvec;
1924 	struct bvec_iter iter;
1925 
1926 	if (!rsp) {
1927 		pr_err(MPT3SAS_FMT "%s: the smp response space is missing\n",
1928 			ioc->name, __func__);
1929 		return -EINVAL;
1930 	}
1931 
1932 	if (ioc->shost_recovery || ioc->pci_error_recovery) {
1933 		pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
1934 		    __func__, ioc->name);
1935 		return -EFAULT;
1936 	}
1937 
1938 	rc = mutex_lock_interruptible(&ioc->transport_cmds.mutex);
1939 	if (rc)
1940 		return rc;
1941 
1942 	if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
1943 		pr_err(MPT3SAS_FMT "%s: transport_cmds in use\n", ioc->name,
1944 		    __func__);
1945 		rc = -EAGAIN;
1946 		goto out;
1947 	}
1948 	ioc->transport_cmds.status = MPT3_CMD_PENDING;
1949 
1950 	/* Check if the request is split across multiple segments */
1951 	if (bio_multiple_segments(req->bio)) {
1952 		u32 offset = 0;
1953 
1954 		/* Allocate memory and copy the request */
1955 		pci_addr_out = pci_alloc_consistent(ioc->pdev,
1956 		    blk_rq_bytes(req), &pci_dma_out);
1957 		if (!pci_addr_out) {
1958 			pr_info(MPT3SAS_FMT "%s(): PCI Addr out = NULL\n",
1959 			    ioc->name, __func__);
1960 			rc = -ENOMEM;
1961 			goto out;
1962 		}
1963 
1964 		bio_for_each_segment(bvec, req->bio, iter) {
1965 			memcpy(pci_addr_out + offset,
1966 			    page_address(bvec.bv_page) + bvec.bv_offset,
1967 			    bvec.bv_len);
1968 			offset += bvec.bv_len;
1969 		}
1970 	} else {
1971 		dma_addr_out = pci_map_single(ioc->pdev, bio_data(req->bio),
1972 		    blk_rq_bytes(req), PCI_DMA_BIDIRECTIONAL);
1973 		if (pci_dma_mapping_error(ioc->pdev, dma_addr_out)) {
1974 			pr_info(MPT3SAS_FMT "%s(): DMA Addr out = NULL\n",
1975 			    ioc->name, __func__);
1976 			rc = -ENOMEM;
1977 			goto free_pci;
1978 		}
1979 	}
1980 
1981 	/* Check if the response needs to be populated across
1982 	 * multiple segments */
1983 	if (bio_multiple_segments(rsp->bio)) {
1984 		pci_addr_in = pci_alloc_consistent(ioc->pdev, blk_rq_bytes(rsp),
1985 		    &pci_dma_in);
1986 		if (!pci_addr_in) {
1987 			pr_info(MPT3SAS_FMT "%s(): PCI Addr in = NULL\n",
1988 			    ioc->name, __func__);
1989 			rc = -ENOMEM;
1990 			goto unmap;
1991 		}
1992 	} else {
1993 		dma_addr_in =  pci_map_single(ioc->pdev, bio_data(rsp->bio),
1994 		    blk_rq_bytes(rsp), PCI_DMA_BIDIRECTIONAL);
1995 		if (pci_dma_mapping_error(ioc->pdev, dma_addr_in)) {
1996 			pr_info(MPT3SAS_FMT "%s(): DMA Addr in = NULL\n",
1997 			    ioc->name, __func__);
1998 			rc = -ENOMEM;
1999 			goto unmap;
2000 		}
2001 	}
2002 
2003 	wait_state_count = 0;
2004 	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
2005 	while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
2006 		if (wait_state_count++ == 10) {
2007 			pr_err(MPT3SAS_FMT
2008 			    "%s: failed due to ioc not operational\n",
2009 			    ioc->name, __func__);
2010 			rc = -EFAULT;
2011 			goto unmap;
2012 		}
2013 		ssleep(1);
2014 		ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
2015 		pr_info(MPT3SAS_FMT
2016 			"%s: waiting for operational state(count=%d)\n",
2017 			ioc->name, __func__, wait_state_count);
2018 	}
2019 	if (wait_state_count)
2020 		pr_info(MPT3SAS_FMT "%s: ioc is operational\n",
2021 		    ioc->name, __func__);
2022 
2023 	smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
2024 	if (!smid) {
2025 		pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
2026 		    ioc->name, __func__);
2027 		rc = -EAGAIN;
2028 		goto unmap;
2029 	}
2030 
2031 	rc = 0;
2032 	mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
2033 	ioc->transport_cmds.smid = smid;
2034 
2035 	memset(mpi_request, 0, sizeof(Mpi2SmpPassthroughRequest_t));
2036 	mpi_request->Function = MPI2_FUNCTION_SMP_PASSTHROUGH;
2037 	mpi_request->PhysicalPort = 0xFF;
2038 	mpi_request->SASAddress = (rphy) ?
2039 	    cpu_to_le64(rphy->identify.sas_address) :
2040 	    cpu_to_le64(ioc->sas_hba.sas_address);
2041 	mpi_request->RequestDataLength = cpu_to_le16(blk_rq_bytes(req) - 4);
2042 	psge = &mpi_request->SGL;
2043 
2044 	if (bio_multiple_segments(req->bio))
2045 		ioc->build_sg(ioc, psge, pci_dma_out, (blk_rq_bytes(req) - 4),
2046 		    pci_dma_in, (blk_rq_bytes(rsp) + 4));
2047 	else
2048 		ioc->build_sg(ioc, psge, dma_addr_out, (blk_rq_bytes(req) - 4),
2049 		    dma_addr_in, (blk_rq_bytes(rsp) + 4));
2050 
2051 	dtransportprintk(ioc, pr_info(MPT3SAS_FMT
2052 		"%s - sending smp request\n", ioc->name, __func__));
2053 
2054 	init_completion(&ioc->transport_cmds.done);
2055 	mpt3sas_base_put_smid_default(ioc, smid);
2056 	timeleft = wait_for_completion_timeout(&ioc->transport_cmds.done,
2057 	    10*HZ);
2058 
2059 	if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
2060 		pr_err(MPT3SAS_FMT "%s : timeout\n",
2061 		    __func__, ioc->name);
2062 		_debug_dump_mf(mpi_request,
2063 		    sizeof(Mpi2SmpPassthroughRequest_t)/4);
2064 		if (!(ioc->transport_cmds.status & MPT3_CMD_RESET))
2065 			issue_reset = 1;
2066 		goto issue_host_reset;
2067 	}
2068 
2069 	dtransportprintk(ioc, pr_info(MPT3SAS_FMT
2070 		"%s - complete\n", ioc->name, __func__));
2071 
2072 	if (ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID) {
2073 
2074 		mpi_reply = ioc->transport_cmds.reply;
2075 
2076 		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
2077 		    "%s - reply data transfer size(%d)\n",
2078 		    ioc->name, __func__,
2079 		    le16_to_cpu(mpi_reply->ResponseDataLength)));
2080 
2081 		memcpy(req->sense, mpi_reply, sizeof(*mpi_reply));
2082 		req->sense_len = sizeof(*mpi_reply);
2083 		req->resid_len = 0;
2084 		rsp->resid_len -=
2085 		    le16_to_cpu(mpi_reply->ResponseDataLength);
2086 
2087 		/* check if the resp needs to be copied from the allocated
2088 		 * pci mem */
2089 		if (bio_multiple_segments(rsp->bio)) {
2090 			u32 offset = 0;
2091 			u32 bytes_to_copy =
2092 			    le16_to_cpu(mpi_reply->ResponseDataLength);
2093 			bio_for_each_segment(bvec, rsp->bio, iter) {
2094 				if (bytes_to_copy <= bvec.bv_len) {
2095 					memcpy(page_address(bvec.bv_page) +
2096 					    bvec.bv_offset, pci_addr_in +
2097 					    offset, bytes_to_copy);
2098 					break;
2099 				} else {
2100 					memcpy(page_address(bvec.bv_page) +
2101 					    bvec.bv_offset, pci_addr_in +
2102 					    offset, bvec.bv_len);
2103 					bytes_to_copy -= bvec.bv_len;
2104 				}
2105 				offset += bvec.bv_len;
2106 			}
2107 		}
2108 	} else {
2109 		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
2110 		    "%s - no reply\n", ioc->name, __func__));
2111 		rc = -ENXIO;
2112 	}
2113 
2114  issue_host_reset:
2115 	if (issue_reset) {
2116 		mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2117 		    FORCE_BIG_HAMMER);
2118 		rc = -ETIMEDOUT;
2119 	}
2120 
2121  unmap:
2122 	if (dma_addr_out)
2123 		pci_unmap_single(ioc->pdev, dma_addr_out, blk_rq_bytes(req),
2124 		    PCI_DMA_BIDIRECTIONAL);
2125 	if (dma_addr_in)
2126 		pci_unmap_single(ioc->pdev, dma_addr_in, blk_rq_bytes(rsp),
2127 		    PCI_DMA_BIDIRECTIONAL);
2128 
2129  free_pci:
2130 	if (pci_addr_out)
2131 		pci_free_consistent(ioc->pdev, blk_rq_bytes(req), pci_addr_out,
2132 		    pci_dma_out);
2133 
2134 	if (pci_addr_in)
2135 		pci_free_consistent(ioc->pdev, blk_rq_bytes(rsp), pci_addr_in,
2136 		    pci_dma_in);
2137 
2138  out:
2139 	ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
2140 	mutex_unlock(&ioc->transport_cmds.mutex);
2141 	return rc;
2142 }
2143 
2144 struct sas_function_template mpt3sas_transport_functions = {
2145 	.get_linkerrors		= _transport_get_linkerrors,
2146 	.get_enclosure_identifier = _transport_get_enclosure_identifier,
2147 	.get_bay_identifier	= _transport_get_bay_identifier,
2148 	.phy_reset		= _transport_phy_reset,
2149 	.phy_enable		= _transport_phy_enable,
2150 	.set_phy_speed		= _transport_phy_speed,
2151 	.smp_handler		= _transport_smp_handler,
2152 };
2153 
2154 struct scsi_transport_template *mpt3sas_transport_template;
2155