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