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