aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/mpt3sas/mpt3sas_transport.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/scsi/mpt3sas/mpt3sas_transport.c')
-rw-r--r--drivers/scsi/mpt3sas/mpt3sas_transport.c2128
1 files changed, 2128 insertions, 0 deletions
diff --git a/drivers/scsi/mpt3sas/mpt3sas_transport.c b/drivers/scsi/mpt3sas/mpt3sas_transport.c
new file mode 100644
index 000000000000..87ca2b7287c3
--- /dev/null
+++ b/drivers/scsi/mpt3sas/mpt3sas_transport.c
@@ -0,0 +1,2128 @@
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 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 */
71static 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 */
88static 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 */
138static 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 */
231u8
232mpt3sas_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 */
254struct 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 */
262struct 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 */
291static 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 */
468static 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 */
497static 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 */
521static 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 */
546static 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 */
581static 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 */
616static 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 */
642struct _sas_port *
643mpt3sas_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 */
777void
778mpt3sas_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 */
842int
843mpt3sas_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 */
910int
911mpt3sas_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 */
980void
981mpt3sas_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
1010 if (mpt3sas_phy->phy)
1011 mpt3sas_phy->phy->negotiated_linkrate =
1012 _transport_convert_phy_link_rate(link_rate);
1013
1014 if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
1015 dev_printk(KERN_INFO, &mpt3sas_phy->phy->dev,
1016 "refresh: parent sas_addr(0x%016llx),\n"
1017 "\tlink_rate(0x%02x), phy(%d)\n"
1018 "\tattached_handle(0x%04x), sas_addr(0x%016llx)\n",
1019 (unsigned long long)sas_address,
1020 link_rate, phy_number, handle, (unsigned long long)
1021 mpt3sas_phy->remote_identify.sas_address);
1022}
1023
1024static inline void *
1025phy_to_ioc(struct sas_phy *phy)
1026{
1027 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
1028 return shost_priv(shost);
1029}
1030
1031static inline void *
1032rphy_to_ioc(struct sas_rphy *rphy)
1033{
1034 struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent);
1035 return shost_priv(shost);
1036}
1037
1038/* report phy error log structure */
1039struct phy_error_log_request {
1040 u8 smp_frame_type; /* 0x40 */
1041 u8 function; /* 0x11 */
1042 u8 allocated_response_length;
1043 u8 request_length; /* 02 */
1044 u8 reserved_1[5];
1045 u8 phy_identifier;
1046 u8 reserved_2[2];
1047};
1048
1049/* report phy error log reply structure */
1050struct phy_error_log_reply {
1051 u8 smp_frame_type; /* 0x41 */
1052 u8 function; /* 0x11 */
1053 u8 function_result;
1054 u8 response_length;
1055 __be16 expander_change_count;
1056 u8 reserved_1[3];
1057 u8 phy_identifier;
1058 u8 reserved_2[2];
1059 __be32 invalid_dword;
1060 __be32 running_disparity_error;
1061 __be32 loss_of_dword_sync;
1062 __be32 phy_reset_problem;
1063};
1064
1065/**
1066 * _transport_get_expander_phy_error_log - return expander counters
1067 * @ioc: per adapter object
1068 * @phy: The sas phy object
1069 *
1070 * Returns 0 for success, non-zero for failure.
1071 *
1072 */
1073static int
1074_transport_get_expander_phy_error_log(struct MPT3SAS_ADAPTER *ioc,
1075 struct sas_phy *phy)
1076{
1077 Mpi2SmpPassthroughRequest_t *mpi_request;
1078 Mpi2SmpPassthroughReply_t *mpi_reply;
1079 struct phy_error_log_request *phy_error_log_request;
1080 struct phy_error_log_reply *phy_error_log_reply;
1081 int rc;
1082 u16 smid;
1083 u32 ioc_state;
1084 unsigned long timeleft;
1085 void *psge;
1086 u8 issue_reset = 0;
1087 void *data_out = NULL;
1088 dma_addr_t data_out_dma;
1089 u32 sz;
1090 u16 wait_state_count;
1091
1092 if (ioc->shost_recovery || ioc->pci_error_recovery) {
1093 pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
1094 __func__, ioc->name);
1095 return -EFAULT;
1096 }
1097
1098 mutex_lock(&ioc->transport_cmds.mutex);
1099
1100 if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
1101 pr_err(MPT3SAS_FMT "%s: transport_cmds in use\n",
1102 ioc->name, __func__);
1103 rc = -EAGAIN;
1104 goto out;
1105 }
1106 ioc->transport_cmds.status = MPT3_CMD_PENDING;
1107
1108 wait_state_count = 0;
1109 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
1110 while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
1111 if (wait_state_count++ == 10) {
1112 pr_err(MPT3SAS_FMT
1113 "%s: failed due to ioc not operational\n",
1114 ioc->name, __func__);
1115 rc = -EFAULT;
1116 goto out;
1117 }
1118 ssleep(1);
1119 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
1120 pr_info(MPT3SAS_FMT
1121 "%s: waiting for operational state(count=%d)\n",
1122 ioc->name, __func__, wait_state_count);
1123 }
1124 if (wait_state_count)
1125 pr_info(MPT3SAS_FMT "%s: ioc is operational\n",
1126 ioc->name, __func__);
1127
1128 smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
1129 if (!smid) {
1130 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
1131 ioc->name, __func__);
1132 rc = -EAGAIN;
1133 goto out;
1134 }
1135
1136 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
1137 ioc->transport_cmds.smid = smid;
1138
1139 sz = sizeof(struct phy_error_log_request) +
1140 sizeof(struct phy_error_log_reply);
1141 data_out = pci_alloc_consistent(ioc->pdev, sz, &data_out_dma);
1142 if (!data_out) {
1143 pr_err("failure at %s:%d/%s()!\n", __FILE__,
1144 __LINE__, __func__);
1145 rc = -ENOMEM;
1146 mpt3sas_base_free_smid(ioc, smid);
1147 goto out;
1148 }
1149
1150 rc = -EINVAL;
1151 memset(data_out, 0, sz);
1152 phy_error_log_request = data_out;
1153 phy_error_log_request->smp_frame_type = 0x40;
1154 phy_error_log_request->function = 0x11;
1155 phy_error_log_request->request_length = 2;
1156 phy_error_log_request->allocated_response_length = 0;
1157 phy_error_log_request->phy_identifier = phy->number;
1158
1159 memset(mpi_request, 0, sizeof(Mpi2SmpPassthroughRequest_t));
1160 mpi_request->Function = MPI2_FUNCTION_SMP_PASSTHROUGH;
1161 mpi_request->PhysicalPort = 0xFF;
1162 mpi_request->VF_ID = 0; /* TODO */
1163 mpi_request->VP_ID = 0;
1164 mpi_request->SASAddress = cpu_to_le64(phy->identify.sas_address);
1165 mpi_request->RequestDataLength =
1166 cpu_to_le16(sizeof(struct phy_error_log_request));
1167 psge = &mpi_request->SGL;
1168
1169 ioc->build_sg(ioc, psge, data_out_dma,
1170 sizeof(struct phy_error_log_request),
1171 data_out_dma + sizeof(struct phy_error_log_request),
1172 sizeof(struct phy_error_log_reply));
1173
1174 dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1175 "phy_error_log - send to sas_addr(0x%016llx), phy(%d)\n",
1176 ioc->name, (unsigned long long)phy->identify.sas_address,
1177 phy->number));
1178 init_completion(&ioc->transport_cmds.done);
1179 mpt3sas_base_put_smid_default(ioc, smid);
1180 timeleft = wait_for_completion_timeout(&ioc->transport_cmds.done,
1181 10*HZ);
1182
1183 if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
1184 pr_err(MPT3SAS_FMT "%s: timeout\n",
1185 ioc->name, __func__);
1186 _debug_dump_mf(mpi_request,
1187 sizeof(Mpi2SmpPassthroughRequest_t)/4);
1188 if (!(ioc->transport_cmds.status & MPT3_CMD_RESET))
1189 issue_reset = 1;
1190 goto issue_host_reset;
1191 }
1192
1193 dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1194 "phy_error_log - complete\n", ioc->name));
1195
1196 if (ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID) {
1197
1198 mpi_reply = ioc->transport_cmds.reply;
1199
1200 dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1201 "phy_error_log - reply data transfer size(%d)\n",
1202 ioc->name, le16_to_cpu(mpi_reply->ResponseDataLength)));
1203
1204 if (le16_to_cpu(mpi_reply->ResponseDataLength) !=
1205 sizeof(struct phy_error_log_reply))
1206 goto out;
1207
1208 phy_error_log_reply = data_out +
1209 sizeof(struct phy_error_log_request);
1210
1211 dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1212 "phy_error_log - function_result(%d)\n",
1213 ioc->name, phy_error_log_reply->function_result));
1214
1215 phy->invalid_dword_count =
1216 be32_to_cpu(phy_error_log_reply->invalid_dword);
1217 phy->running_disparity_error_count =
1218 be32_to_cpu(phy_error_log_reply->running_disparity_error);
1219 phy->loss_of_dword_sync_count =
1220 be32_to_cpu(phy_error_log_reply->loss_of_dword_sync);
1221 phy->phy_reset_problem_count =
1222 be32_to_cpu(phy_error_log_reply->phy_reset_problem);
1223 rc = 0;
1224 } else
1225 dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1226 "phy_error_log - no reply\n", ioc->name));
1227
1228 issue_host_reset:
1229 if (issue_reset)
1230 mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1231 FORCE_BIG_HAMMER);
1232 out:
1233 ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
1234 if (data_out)
1235 pci_free_consistent(ioc->pdev, sz, data_out, data_out_dma);
1236
1237 mutex_unlock(&ioc->transport_cmds.mutex);
1238 return rc;
1239}
1240
1241/**
1242 * _transport_get_linkerrors - return phy counters for both hba and expanders
1243 * @phy: The sas phy object
1244 *
1245 * Returns 0 for success, non-zero for failure.
1246 *
1247 */
1248static int
1249_transport_get_linkerrors(struct sas_phy *phy)
1250{
1251 struct MPT3SAS_ADAPTER *ioc = phy_to_ioc(phy);
1252 unsigned long flags;
1253 Mpi2ConfigReply_t mpi_reply;
1254 Mpi2SasPhyPage1_t phy_pg1;
1255
1256 spin_lock_irqsave(&ioc->sas_node_lock, flags);
1257 if (_transport_sas_node_find_by_sas_address(ioc,
1258 phy->identify.sas_address) == NULL) {
1259 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1260 return -EINVAL;
1261 }
1262 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1263
1264 if (phy->identify.sas_address != ioc->sas_hba.sas_address)
1265 return _transport_get_expander_phy_error_log(ioc, phy);
1266
1267 /* get hba phy error logs */
1268 if ((mpt3sas_config_get_phy_pg1(ioc, &mpi_reply, &phy_pg1,
1269 phy->number))) {
1270 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1271 ioc->name, __FILE__, __LINE__, __func__);
1272 return -ENXIO;
1273 }
1274
1275 if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo)
1276 pr_info(MPT3SAS_FMT
1277 "phy(%d), ioc_status (0x%04x), loginfo(0x%08x)\n",
1278 ioc->name, phy->number,
1279 le16_to_cpu(mpi_reply.IOCStatus),
1280 le32_to_cpu(mpi_reply.IOCLogInfo));
1281
1282 phy->invalid_dword_count = le32_to_cpu(phy_pg1.InvalidDwordCount);
1283 phy->running_disparity_error_count =
1284 le32_to_cpu(phy_pg1.RunningDisparityErrorCount);
1285 phy->loss_of_dword_sync_count =
1286 le32_to_cpu(phy_pg1.LossDwordSynchCount);
1287 phy->phy_reset_problem_count =
1288 le32_to_cpu(phy_pg1.PhyResetProblemCount);
1289 return 0;
1290}
1291
1292/**
1293 * _transport_get_enclosure_identifier -
1294 * @phy: The sas phy object
1295 *
1296 * Obtain the enclosure logical id for an expander.
1297 * Returns 0 for success, non-zero for failure.
1298 */
1299static int
1300_transport_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
1301{
1302 struct MPT3SAS_ADAPTER *ioc = rphy_to_ioc(rphy);
1303 struct _sas_device *sas_device;
1304 unsigned long flags;
1305 int rc;
1306
1307 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1308 sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
1309 rphy->identify.sas_address);
1310 if (sas_device) {
1311 *identifier = sas_device->enclosure_logical_id;
1312 rc = 0;
1313 } else {
1314 *identifier = 0;
1315 rc = -ENXIO;
1316 }
1317 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1318 return rc;
1319}
1320
1321/**
1322 * _transport_get_bay_identifier -
1323 * @phy: The sas phy object
1324 *
1325 * Returns the slot id for a device that resides inside an enclosure.
1326 */
1327static int
1328_transport_get_bay_identifier(struct sas_rphy *rphy)
1329{
1330 struct MPT3SAS_ADAPTER *ioc = rphy_to_ioc(rphy);
1331 struct _sas_device *sas_device;
1332 unsigned long flags;
1333 int rc;
1334
1335 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1336 sas_device = mpt3sas_scsih_sas_device_find_by_sas_address(ioc,
1337 rphy->identify.sas_address);
1338 if (sas_device)
1339 rc = sas_device->slot;
1340 else
1341 rc = -ENXIO;
1342 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1343 return rc;
1344}
1345
1346/* phy control request structure */
1347struct phy_control_request {
1348 u8 smp_frame_type; /* 0x40 */
1349 u8 function; /* 0x91 */
1350 u8 allocated_response_length;
1351 u8 request_length; /* 0x09 */
1352 u16 expander_change_count;
1353 u8 reserved_1[3];
1354 u8 phy_identifier;
1355 u8 phy_operation;
1356 u8 reserved_2[13];
1357 u64 attached_device_name;
1358 u8 programmed_min_physical_link_rate;
1359 u8 programmed_max_physical_link_rate;
1360 u8 reserved_3[6];
1361};
1362
1363/* phy control reply structure */
1364struct phy_control_reply {
1365 u8 smp_frame_type; /* 0x41 */
1366 u8 function; /* 0x11 */
1367 u8 function_result;
1368 u8 response_length;
1369};
1370
1371#define SMP_PHY_CONTROL_LINK_RESET (0x01)
1372#define SMP_PHY_CONTROL_HARD_RESET (0x02)
1373#define SMP_PHY_CONTROL_DISABLE (0x03)
1374
1375/**
1376 * _transport_expander_phy_control - expander phy control
1377 * @ioc: per adapter object
1378 * @phy: The sas phy object
1379 *
1380 * Returns 0 for success, non-zero for failure.
1381 *
1382 */
1383static int
1384_transport_expander_phy_control(struct MPT3SAS_ADAPTER *ioc,
1385 struct sas_phy *phy, u8 phy_operation)
1386{
1387 Mpi2SmpPassthroughRequest_t *mpi_request;
1388 Mpi2SmpPassthroughReply_t *mpi_reply;
1389 struct phy_control_request *phy_control_request;
1390 struct phy_control_reply *phy_control_reply;
1391 int rc;
1392 u16 smid;
1393 u32 ioc_state;
1394 unsigned long timeleft;
1395 void *psge;
1396 u32 sgl_flags;
1397 u8 issue_reset = 0;
1398 void *data_out = NULL;
1399 dma_addr_t data_out_dma;
1400 u32 sz;
1401 u16 wait_state_count;
1402
1403 if (ioc->shost_recovery || ioc->pci_error_recovery) {
1404 pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
1405 __func__, ioc->name);
1406 return -EFAULT;
1407 }
1408
1409 mutex_lock(&ioc->transport_cmds.mutex);
1410
1411 if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
1412 pr_err(MPT3SAS_FMT "%s: transport_cmds in use\n",
1413 ioc->name, __func__);
1414 rc = -EAGAIN;
1415 goto out;
1416 }
1417 ioc->transport_cmds.status = MPT3_CMD_PENDING;
1418
1419 wait_state_count = 0;
1420 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
1421 while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
1422 if (wait_state_count++ == 10) {
1423 pr_err(MPT3SAS_FMT
1424 "%s: failed due to ioc not operational\n",
1425 ioc->name, __func__);
1426 rc = -EFAULT;
1427 goto out;
1428 }
1429 ssleep(1);
1430 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
1431 pr_info(MPT3SAS_FMT
1432 "%s: waiting for operational state(count=%d)\n",
1433 ioc->name, __func__, wait_state_count);
1434 }
1435 if (wait_state_count)
1436 pr_info(MPT3SAS_FMT "%s: ioc is operational\n",
1437 ioc->name, __func__);
1438
1439 smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
1440 if (!smid) {
1441 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
1442 ioc->name, __func__);
1443 rc = -EAGAIN;
1444 goto out;
1445 }
1446
1447 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
1448 ioc->transport_cmds.smid = smid;
1449
1450 sz = sizeof(struct phy_control_request) +
1451 sizeof(struct phy_control_reply);
1452 data_out = pci_alloc_consistent(ioc->pdev, sz, &data_out_dma);
1453 if (!data_out) {
1454 pr_err("failure at %s:%d/%s()!\n", __FILE__,
1455 __LINE__, __func__);
1456 rc = -ENOMEM;
1457 mpt3sas_base_free_smid(ioc, smid);
1458 goto out;
1459 }
1460
1461 rc = -EINVAL;
1462 memset(data_out, 0, sz);
1463 phy_control_request = data_out;
1464 phy_control_request->smp_frame_type = 0x40;
1465 phy_control_request->function = 0x91;
1466 phy_control_request->request_length = 9;
1467 phy_control_request->allocated_response_length = 0;
1468 phy_control_request->phy_identifier = phy->number;
1469 phy_control_request->phy_operation = phy_operation;
1470 phy_control_request->programmed_min_physical_link_rate =
1471 phy->minimum_linkrate << 4;
1472 phy_control_request->programmed_max_physical_link_rate =
1473 phy->maximum_linkrate << 4;
1474
1475 memset(mpi_request, 0, sizeof(Mpi2SmpPassthroughRequest_t));
1476 mpi_request->Function = MPI2_FUNCTION_SMP_PASSTHROUGH;
1477 mpi_request->PhysicalPort = 0xFF;
1478 mpi_request->VF_ID = 0; /* TODO */
1479 mpi_request->VP_ID = 0;
1480 mpi_request->SASAddress = cpu_to_le64(phy->identify.sas_address);
1481 mpi_request->RequestDataLength =
1482 cpu_to_le16(sizeof(struct phy_error_log_request));
1483 psge = &mpi_request->SGL;
1484
1485 /* WRITE sgel first */
1486 sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT |
1487 MPI2_SGE_FLAGS_END_OF_BUFFER | MPI2_SGE_FLAGS_HOST_TO_IOC);
1488 sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
1489 ioc->base_add_sg_single(psge, sgl_flags |
1490 sizeof(struct phy_control_request), data_out_dma);
1491
1492 /* incr sgel */
1493 psge += ioc->sge_size;
1494
1495 /* READ sgel last */
1496 sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT |
1497 MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER |
1498 MPI2_SGE_FLAGS_END_OF_LIST);
1499 sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
1500 ioc->base_add_sg_single(psge, sgl_flags |
1501 sizeof(struct phy_control_reply), data_out_dma +
1502 sizeof(struct phy_control_request));
1503
1504 dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1505 "phy_control - send to sas_addr(0x%016llx), phy(%d), opcode(%d)\n",
1506 ioc->name, (unsigned long long)phy->identify.sas_address,
1507 phy->number, phy_operation));
1508 init_completion(&ioc->transport_cmds.done);
1509 mpt3sas_base_put_smid_default(ioc, smid);
1510 timeleft = wait_for_completion_timeout(&ioc->transport_cmds.done,
1511 10*HZ);
1512
1513 if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
1514 pr_err(MPT3SAS_FMT "%s: timeout\n",
1515 ioc->name, __func__);
1516 _debug_dump_mf(mpi_request,
1517 sizeof(Mpi2SmpPassthroughRequest_t)/4);
1518 if (!(ioc->transport_cmds.status & MPT3_CMD_RESET))
1519 issue_reset = 1;
1520 goto issue_host_reset;
1521 }
1522
1523 dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1524 "phy_control - complete\n", ioc->name));
1525
1526 if (ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID) {
1527
1528 mpi_reply = ioc->transport_cmds.reply;
1529
1530 dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1531 "phy_control - reply data transfer size(%d)\n",
1532 ioc->name, le16_to_cpu(mpi_reply->ResponseDataLength)));
1533
1534 if (le16_to_cpu(mpi_reply->ResponseDataLength) !=
1535 sizeof(struct phy_control_reply))
1536 goto out;
1537
1538 phy_control_reply = data_out +
1539 sizeof(struct phy_control_request);
1540
1541 dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1542 "phy_control - function_result(%d)\n",
1543 ioc->name, phy_control_reply->function_result));
1544
1545 rc = 0;
1546 } else
1547 dtransportprintk(ioc, pr_info(MPT3SAS_FMT
1548 "phy_control - no reply\n", ioc->name));
1549
1550 issue_host_reset:
1551 if (issue_reset)
1552 mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1553 FORCE_BIG_HAMMER);
1554 out:
1555 ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
1556 if (data_out)
1557 pci_free_consistent(ioc->pdev, sz, data_out, data_out_dma);
1558
1559 mutex_unlock(&ioc->transport_cmds.mutex);
1560 return rc;
1561}
1562
1563/**
1564 * _transport_phy_reset -
1565 * @phy: The sas phy object
1566 * @hard_reset:
1567 *
1568 * Returns 0 for success, non-zero for failure.
1569 */
1570static int
1571_transport_phy_reset(struct sas_phy *phy, int hard_reset)
1572{
1573 struct MPT3SAS_ADAPTER *ioc = phy_to_ioc(phy);
1574 Mpi2SasIoUnitControlReply_t mpi_reply;
1575 Mpi2SasIoUnitControlRequest_t mpi_request;
1576 unsigned long flags;
1577
1578 spin_lock_irqsave(&ioc->sas_node_lock, flags);
1579 if (_transport_sas_node_find_by_sas_address(ioc,
1580 phy->identify.sas_address) == NULL) {
1581 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1582 return -EINVAL;
1583 }
1584 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1585
1586 /* handle expander phys */
1587 if (phy->identify.sas_address != ioc->sas_hba.sas_address)
1588 return _transport_expander_phy_control(ioc, phy,
1589 (hard_reset == 1) ? SMP_PHY_CONTROL_HARD_RESET :
1590 SMP_PHY_CONTROL_LINK_RESET);
1591
1592 /* handle hba phys */
1593 memset(&mpi_request, 0, sizeof(Mpi2SasIoUnitControlReply_t));
1594 mpi_request.Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
1595 mpi_request.Operation = hard_reset ?
1596 MPI2_SAS_OP_PHY_HARD_RESET : MPI2_SAS_OP_PHY_LINK_RESET;
1597 mpi_request.PhyNum = phy->number;
1598
1599 if ((mpt3sas_base_sas_iounit_control(ioc, &mpi_reply, &mpi_request))) {
1600 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1601 ioc->name, __FILE__, __LINE__, __func__);
1602 return -ENXIO;
1603 }
1604
1605 if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo)
1606 pr_info(MPT3SAS_FMT
1607 "phy(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
1608 ioc->name, phy->number, le16_to_cpu(mpi_reply.IOCStatus),
1609 le32_to_cpu(mpi_reply.IOCLogInfo));
1610
1611 return 0;
1612}
1613
1614/**
1615 * _transport_phy_enable - enable/disable phys
1616 * @phy: The sas phy object
1617 * @enable: enable phy when true
1618 *
1619 * Only support sas_host direct attached phys.
1620 * Returns 0 for success, non-zero for failure.
1621 */
1622static int
1623_transport_phy_enable(struct sas_phy *phy, int enable)
1624{
1625 struct MPT3SAS_ADAPTER *ioc = phy_to_ioc(phy);
1626 Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
1627 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
1628 Mpi2ConfigReply_t mpi_reply;
1629 u16 ioc_status;
1630 u16 sz;
1631 int rc = 0;
1632 unsigned long flags;
1633 int i, discovery_active;
1634
1635 spin_lock_irqsave(&ioc->sas_node_lock, flags);
1636 if (_transport_sas_node_find_by_sas_address(ioc,
1637 phy->identify.sas_address) == NULL) {
1638 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1639 return -EINVAL;
1640 }
1641 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1642
1643 /* handle expander phys */
1644 if (phy->identify.sas_address != ioc->sas_hba.sas_address)
1645 return _transport_expander_phy_control(ioc, phy,
1646 (enable == 1) ? SMP_PHY_CONTROL_LINK_RESET :
1647 SMP_PHY_CONTROL_DISABLE);
1648
1649 /* handle hba phys */
1650
1651 /* read sas_iounit page 0 */
1652 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys *
1653 sizeof(Mpi2SasIOUnit0PhyData_t));
1654 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
1655 if (!sas_iounit_pg0) {
1656 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1657 ioc->name, __FILE__, __LINE__, __func__);
1658 rc = -ENOMEM;
1659 goto out;
1660 }
1661 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
1662 sas_iounit_pg0, sz))) {
1663 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1664 ioc->name, __FILE__, __LINE__, __func__);
1665 rc = -ENXIO;
1666 goto out;
1667 }
1668 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1669 MPI2_IOCSTATUS_MASK;
1670 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1671 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1672 ioc->name, __FILE__, __LINE__, __func__);
1673 rc = -EIO;
1674 goto out;
1675 }
1676
1677 /* unable to enable/disable phys when when discovery is active */
1678 for (i = 0, discovery_active = 0; i < ioc->sas_hba.num_phys ; i++) {
1679 if (sas_iounit_pg0->PhyData[i].PortFlags &
1680 MPI2_SASIOUNIT0_PORTFLAGS_DISCOVERY_IN_PROGRESS) {
1681 pr_err(MPT3SAS_FMT "discovery is active on " \
1682 "port = %d, phy = %d: unable to enable/disable "
1683 "phys, try again later!\n", ioc->name,
1684 sas_iounit_pg0->PhyData[i].Port, i);
1685 discovery_active = 1;
1686 }
1687 }
1688
1689 if (discovery_active) {
1690 rc = -EAGAIN;
1691 goto out;
1692 }
1693
1694 /* read sas_iounit page 1 */
1695 sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
1696 sizeof(Mpi2SasIOUnit1PhyData_t));
1697 sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
1698 if (!sas_iounit_pg1) {
1699 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1700 ioc->name, __FILE__, __LINE__, __func__);
1701 rc = -ENOMEM;
1702 goto out;
1703 }
1704 if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
1705 sas_iounit_pg1, sz))) {
1706 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1707 ioc->name, __FILE__, __LINE__, __func__);
1708 rc = -ENXIO;
1709 goto out;
1710 }
1711 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1712 MPI2_IOCSTATUS_MASK;
1713 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1714 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1715 ioc->name, __FILE__, __LINE__, __func__);
1716 rc = -EIO;
1717 goto out;
1718 }
1719
1720 /* copy Port/PortFlags/PhyFlags from page 0 */
1721 for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
1722 sas_iounit_pg1->PhyData[i].Port =
1723 sas_iounit_pg0->PhyData[i].Port;
1724 sas_iounit_pg1->PhyData[i].PortFlags =
1725 (sas_iounit_pg0->PhyData[i].PortFlags &
1726 MPI2_SASIOUNIT0_PORTFLAGS_AUTO_PORT_CONFIG);
1727 sas_iounit_pg1->PhyData[i].PhyFlags =
1728 (sas_iounit_pg0->PhyData[i].PhyFlags &
1729 (MPI2_SASIOUNIT0_PHYFLAGS_ZONING_ENABLED +
1730 MPI2_SASIOUNIT0_PHYFLAGS_PHY_DISABLED));
1731 }
1732
1733 if (enable)
1734 sas_iounit_pg1->PhyData[phy->number].PhyFlags
1735 &= ~MPI2_SASIOUNIT1_PHYFLAGS_PHY_DISABLE;
1736 else
1737 sas_iounit_pg1->PhyData[phy->number].PhyFlags
1738 |= MPI2_SASIOUNIT1_PHYFLAGS_PHY_DISABLE;
1739
1740 mpt3sas_config_set_sas_iounit_pg1(ioc, &mpi_reply, sas_iounit_pg1, sz);
1741
1742 /* link reset */
1743 if (enable)
1744 _transport_phy_reset(phy, 0);
1745
1746 out:
1747 kfree(sas_iounit_pg1);
1748 kfree(sas_iounit_pg0);
1749 return rc;
1750}
1751
1752/**
1753 * _transport_phy_speed - set phy min/max link rates
1754 * @phy: The sas phy object
1755 * @rates: rates defined in sas_phy_linkrates
1756 *
1757 * Only support sas_host direct attached phys.
1758 * Returns 0 for success, non-zero for failure.
1759 */
1760static int
1761_transport_phy_speed(struct sas_phy *phy, struct sas_phy_linkrates *rates)
1762{
1763 struct MPT3SAS_ADAPTER *ioc = phy_to_ioc(phy);
1764 Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
1765 Mpi2SasPhyPage0_t phy_pg0;
1766 Mpi2ConfigReply_t mpi_reply;
1767 u16 ioc_status;
1768 u16 sz;
1769 int i;
1770 int rc = 0;
1771 unsigned long flags;
1772
1773 spin_lock_irqsave(&ioc->sas_node_lock, flags);
1774 if (_transport_sas_node_find_by_sas_address(ioc,
1775 phy->identify.sas_address) == NULL) {
1776 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1777 return -EINVAL;
1778 }
1779 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1780
1781 if (!rates->minimum_linkrate)
1782 rates->minimum_linkrate = phy->minimum_linkrate;
1783 else if (rates->minimum_linkrate < phy->minimum_linkrate_hw)
1784 rates->minimum_linkrate = phy->minimum_linkrate_hw;
1785
1786 if (!rates->maximum_linkrate)
1787 rates->maximum_linkrate = phy->maximum_linkrate;
1788 else if (rates->maximum_linkrate > phy->maximum_linkrate_hw)
1789 rates->maximum_linkrate = phy->maximum_linkrate_hw;
1790
1791 /* handle expander phys */
1792 if (phy->identify.sas_address != ioc->sas_hba.sas_address) {
1793 phy->minimum_linkrate = rates->minimum_linkrate;
1794 phy->maximum_linkrate = rates->maximum_linkrate;
1795 return _transport_expander_phy_control(ioc, phy,
1796 SMP_PHY_CONTROL_LINK_RESET);
1797 }
1798
1799 /* handle hba phys */
1800
1801 /* sas_iounit page 1 */
1802 sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
1803 sizeof(Mpi2SasIOUnit1PhyData_t));
1804 sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
1805 if (!sas_iounit_pg1) {
1806 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1807 ioc->name, __FILE__, __LINE__, __func__);
1808 rc = -ENOMEM;
1809 goto out;
1810 }
1811 if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
1812 sas_iounit_pg1, sz))) {
1813 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1814 ioc->name, __FILE__, __LINE__, __func__);
1815 rc = -ENXIO;
1816 goto out;
1817 }
1818 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1819 MPI2_IOCSTATUS_MASK;
1820 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1821 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1822 ioc->name, __FILE__, __LINE__, __func__);
1823 rc = -EIO;
1824 goto out;
1825 }
1826
1827 for (i = 0; i < ioc->sas_hba.num_phys; i++) {
1828 if (phy->number != i) {
1829 sas_iounit_pg1->PhyData[i].MaxMinLinkRate =
1830 (ioc->sas_hba.phy[i].phy->minimum_linkrate +
1831 (ioc->sas_hba.phy[i].phy->maximum_linkrate << 4));
1832 } else {
1833 sas_iounit_pg1->PhyData[i].MaxMinLinkRate =
1834 (rates->minimum_linkrate +
1835 (rates->maximum_linkrate << 4));
1836 }
1837 }
1838
1839 if (mpt3sas_config_set_sas_iounit_pg1(ioc, &mpi_reply, sas_iounit_pg1,
1840 sz)) {
1841 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
1842 ioc->name, __FILE__, __LINE__, __func__);
1843 rc = -ENXIO;
1844 goto out;
1845 }
1846
1847 /* link reset */
1848 _transport_phy_reset(phy, 0);
1849
1850 /* read phy page 0, then update the rates in the sas transport phy */
1851 if (!mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
1852 phy->number)) {
1853 phy->minimum_linkrate = _transport_convert_phy_link_rate(
1854 phy_pg0.ProgrammedLinkRate & MPI2_SAS_PRATE_MIN_RATE_MASK);
1855 phy->maximum_linkrate = _transport_convert_phy_link_rate(
1856 phy_pg0.ProgrammedLinkRate >> 4);
1857 phy->negotiated_linkrate = _transport_convert_phy_link_rate(
1858 phy_pg0.NegotiatedLinkRate &
1859 MPI2_SAS_NEG_LINK_RATE_MASK_PHYSICAL);
1860 }
1861
1862 out:
1863 kfree(sas_iounit_pg1);
1864 return rc;
1865}
1866
1867/**
1868 * _transport_smp_handler - transport portal for smp passthru
1869 * @shost: shost object
1870 * @rphy: sas transport rphy object
1871 * @req:
1872 *
1873 * This used primarily for smp_utils.
1874 * Example:
1875 * smp_rep_general /sys/class/bsg/expander-5:0
1876 */
1877static int
1878_transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
1879 struct request *req)
1880{
1881 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1882 Mpi2SmpPassthroughRequest_t *mpi_request;
1883 Mpi2SmpPassthroughReply_t *mpi_reply;
1884 int rc, i;
1885 u16 smid;
1886 u32 ioc_state;
1887 unsigned long timeleft;
1888 void *psge;
1889 u8 issue_reset = 0;
1890 dma_addr_t dma_addr_in = 0;
1891 dma_addr_t dma_addr_out = 0;
1892 dma_addr_t pci_dma_in = 0;
1893 dma_addr_t pci_dma_out = 0;
1894 void *pci_addr_in = NULL;
1895 void *pci_addr_out = NULL;
1896 u16 wait_state_count;
1897 struct request *rsp = req->next_rq;
1898 struct bio_vec *bvec = NULL;
1899
1900 if (!rsp) {
1901 pr_err(MPT3SAS_FMT "%s: the smp response space is missing\n",
1902 ioc->name, __func__);
1903 return -EINVAL;
1904 }
1905
1906 if (ioc->shost_recovery || ioc->pci_error_recovery) {
1907 pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
1908 __func__, ioc->name);
1909 return -EFAULT;
1910 }
1911
1912 rc = mutex_lock_interruptible(&ioc->transport_cmds.mutex);
1913 if (rc)
1914 return rc;
1915
1916 if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
1917 pr_err(MPT3SAS_FMT "%s: transport_cmds in use\n", ioc->name,
1918 __func__);
1919 rc = -EAGAIN;
1920 goto out;
1921 }
1922 ioc->transport_cmds.status = MPT3_CMD_PENDING;
1923
1924 /* Check if the request is split across multiple segments */
1925 if (req->bio->bi_vcnt > 1) {
1926 u32 offset = 0;
1927
1928 /* Allocate memory and copy the request */
1929 pci_addr_out = pci_alloc_consistent(ioc->pdev,
1930 blk_rq_bytes(req), &pci_dma_out);
1931 if (!pci_addr_out) {
1932 pr_info(MPT3SAS_FMT "%s(): PCI Addr out = NULL\n",
1933 ioc->name, __func__);
1934 rc = -ENOMEM;
1935 goto out;
1936 }
1937
1938 bio_for_each_segment(bvec, req->bio, i) {
1939 memcpy(pci_addr_out + offset,
1940 page_address(bvec->bv_page) + bvec->bv_offset,
1941 bvec->bv_len);
1942 offset += bvec->bv_len;
1943 }
1944 } else {
1945 dma_addr_out = pci_map_single(ioc->pdev, bio_data(req->bio),
1946 blk_rq_bytes(req), PCI_DMA_BIDIRECTIONAL);
1947 if (!dma_addr_out) {
1948 pr_info(MPT3SAS_FMT "%s(): DMA Addr out = NULL\n",
1949 ioc->name, __func__);
1950 rc = -ENOMEM;
1951 goto free_pci;
1952 }
1953 }
1954
1955 /* Check if the response needs to be populated across
1956 * multiple segments */
1957 if (rsp->bio->bi_vcnt > 1) {
1958 pci_addr_in = pci_alloc_consistent(ioc->pdev, blk_rq_bytes(rsp),
1959 &pci_dma_in);
1960 if (!pci_addr_in) {
1961 pr_info(MPT3SAS_FMT "%s(): PCI Addr in = NULL\n",
1962 ioc->name, __func__);
1963 rc = -ENOMEM;
1964 goto unmap;
1965 }
1966 } else {
1967 dma_addr_in = pci_map_single(ioc->pdev, bio_data(rsp->bio),
1968 blk_rq_bytes(rsp), PCI_DMA_BIDIRECTIONAL);
1969 if (!dma_addr_in) {
1970 pr_info(MPT3SAS_FMT "%s(): DMA Addr in = NULL\n",
1971 ioc->name, __func__);
1972 rc = -ENOMEM;
1973 goto unmap;
1974 }
1975 }
1976
1977 wait_state_count = 0;
1978 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
1979 while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
1980 if (wait_state_count++ == 10) {
1981 pr_err(MPT3SAS_FMT
1982 "%s: failed due to ioc not operational\n",
1983 ioc->name, __func__);
1984 rc = -EFAULT;
1985 goto unmap;
1986 }
1987 ssleep(1);
1988 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
1989 pr_info(MPT3SAS_FMT
1990 "%s: waiting for operational state(count=%d)\n",
1991 ioc->name, __func__, wait_state_count);
1992 }
1993 if (wait_state_count)
1994 pr_info(MPT3SAS_FMT "%s: ioc is operational\n",
1995 ioc->name, __func__);
1996
1997 smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
1998 if (!smid) {
1999 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
2000 ioc->name, __func__);
2001 rc = -EAGAIN;
2002 goto unmap;
2003 }
2004
2005 rc = 0;
2006 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
2007 ioc->transport_cmds.smid = smid;
2008
2009 memset(mpi_request, 0, sizeof(Mpi2SmpPassthroughRequest_t));
2010 mpi_request->Function = MPI2_FUNCTION_SMP_PASSTHROUGH;
2011 mpi_request->PhysicalPort = 0xFF;
2012 mpi_request->SASAddress = (rphy) ?
2013 cpu_to_le64(rphy->identify.sas_address) :
2014 cpu_to_le64(ioc->sas_hba.sas_address);
2015 mpi_request->RequestDataLength = cpu_to_le16(blk_rq_bytes(req) - 4);
2016 psge = &mpi_request->SGL;
2017
2018 if (req->bio->bi_vcnt > 1)
2019 ioc->build_sg(ioc, psge, pci_dma_out, (blk_rq_bytes(req) - 4),
2020 pci_dma_in, (blk_rq_bytes(rsp) + 4));
2021 else
2022 ioc->build_sg(ioc, psge, dma_addr_out, (blk_rq_bytes(req) - 4),
2023 dma_addr_in, (blk_rq_bytes(rsp) + 4));
2024
2025 dtransportprintk(ioc, pr_info(MPT3SAS_FMT
2026 "%s - sending smp request\n", ioc->name, __func__));
2027
2028 init_completion(&ioc->transport_cmds.done);
2029 mpt3sas_base_put_smid_default(ioc, smid);
2030 timeleft = wait_for_completion_timeout(&ioc->transport_cmds.done,
2031 10*HZ);
2032
2033 if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
2034 pr_err(MPT3SAS_FMT "%s : timeout\n",
2035 __func__, ioc->name);
2036 _debug_dump_mf(mpi_request,
2037 sizeof(Mpi2SmpPassthroughRequest_t)/4);
2038 if (!(ioc->transport_cmds.status & MPT3_CMD_RESET))
2039 issue_reset = 1;
2040 goto issue_host_reset;
2041 }
2042
2043 dtransportprintk(ioc, pr_info(MPT3SAS_FMT
2044 "%s - complete\n", ioc->name, __func__));
2045
2046 if (ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID) {
2047
2048 mpi_reply = ioc->transport_cmds.reply;
2049
2050 dtransportprintk(ioc, pr_info(MPT3SAS_FMT
2051 "%s - reply data transfer size(%d)\n",
2052 ioc->name, __func__,
2053 le16_to_cpu(mpi_reply->ResponseDataLength)));
2054
2055 memcpy(req->sense, mpi_reply, sizeof(*mpi_reply));
2056 req->sense_len = sizeof(*mpi_reply);
2057 req->resid_len = 0;
2058 rsp->resid_len -=
2059 le16_to_cpu(mpi_reply->ResponseDataLength);
2060
2061 /* check if the resp needs to be copied from the allocated
2062 * pci mem */
2063 if (rsp->bio->bi_vcnt > 1) {
2064 u32 offset = 0;
2065 u32 bytes_to_copy =
2066 le16_to_cpu(mpi_reply->ResponseDataLength);
2067 bio_for_each_segment(bvec, rsp->bio, i) {
2068 if (bytes_to_copy <= bvec->bv_len) {
2069 memcpy(page_address(bvec->bv_page) +
2070 bvec->bv_offset, pci_addr_in +
2071 offset, bytes_to_copy);
2072 break;
2073 } else {
2074 memcpy(page_address(bvec->bv_page) +
2075 bvec->bv_offset, pci_addr_in +
2076 offset, bvec->bv_len);
2077 bytes_to_copy -= bvec->bv_len;
2078 }
2079 offset += bvec->bv_len;
2080 }
2081 }
2082 } else {
2083 dtransportprintk(ioc, pr_info(MPT3SAS_FMT
2084 "%s - no reply\n", ioc->name, __func__));
2085 rc = -ENXIO;
2086 }
2087
2088 issue_host_reset:
2089 if (issue_reset) {
2090 mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2091 FORCE_BIG_HAMMER);
2092 rc = -ETIMEDOUT;
2093 }
2094
2095 unmap:
2096 if (dma_addr_out)
2097 pci_unmap_single(ioc->pdev, dma_addr_out, blk_rq_bytes(req),
2098 PCI_DMA_BIDIRECTIONAL);
2099 if (dma_addr_in)
2100 pci_unmap_single(ioc->pdev, dma_addr_in, blk_rq_bytes(rsp),
2101 PCI_DMA_BIDIRECTIONAL);
2102
2103 free_pci:
2104 if (pci_addr_out)
2105 pci_free_consistent(ioc->pdev, blk_rq_bytes(req), pci_addr_out,
2106 pci_dma_out);
2107
2108 if (pci_addr_in)
2109 pci_free_consistent(ioc->pdev, blk_rq_bytes(rsp), pci_addr_in,
2110 pci_dma_in);
2111
2112 out:
2113 ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
2114 mutex_unlock(&ioc->transport_cmds.mutex);
2115 return rc;
2116}
2117
2118struct sas_function_template mpt3sas_transport_functions = {
2119 .get_linkerrors = _transport_get_linkerrors,
2120 .get_enclosure_identifier = _transport_get_enclosure_identifier,
2121 .get_bay_identifier = _transport_get_bay_identifier,
2122 .phy_reset = _transport_phy_reset,
2123 .phy_enable = _transport_phy_enable,
2124 .set_phy_speed = _transport_phy_speed,
2125 .smp_handler = _transport_smp_handler,
2126};
2127
2128struct scsi_transport_template *mpt3sas_transport_template;
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-02 12:43:26 -0500