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