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